nsss-0.0.2.1/0002755000000000000000000000000013553343654007541 5ustar nsss-0.0.2.1/examples/0002755000000000000000000000000013175124771011354 5ustar nsss-0.0.2.1/examples/openrc/0002755000000000000000000000000013312032576012634 5ustar nsss-0.0.2.1/examples/openrc/nsssd0000755000000000000000000000035413330704222013706 0ustar #!/sbin/openrc-run name="nsssd" command="s6-envuidgid" command_args="nsss s6-ipcserver -U -- /run/service/nsssd/s nsssd-unix" command_background=yes pidfile="/run/service/nsssd/nsssd.pid" start_stop_daemon_args="-d /run/service/nsssd" nsss-0.0.2.1/examples/s6/0002755000000000000000000000000013312032754011674 5ustar nsss-0.0.2.1/examples/s6/nsssd/0002755000000000000000000000000013204564673013040 5ustar nsss-0.0.2.1/examples/s6/nsssd/run0000755000000000000000000000014313312033100013536 0ustar #!/bin/execlineb -P fdmove -c 2 1 s6-envuidgid nsss fdmove 1 3 s6-ipcserver -1 -U -- s nsssd-unix nsss-0.0.2.1/examples/s6/nsssd/log/0002755000000000000000000000000013204564673013621 5ustar nsss-0.0.2.1/examples/s6/nsssd/log/run0000755000000000000000000000011213312032773014332 0ustar #!/bin/execlineb -P s6-setuidgid nssslog exec -c s6-log t /var/log/nsssd nsss-0.0.2.1/examples/s6/nsssd/notification-fd0000644000000000000000000000000213204564673016026 0ustar 3 nsss-0.0.2.1/examples/s6-rc/0002755000000000000000000000000013312033240012265 5ustar nsss-0.0.2.1/examples/s6-rc/nsssd-log/0002755000000000000000000000000013204564673014221 5ustar nsss-0.0.2.1/examples/s6-rc/nsssd-log/run0000644000000000000000000000011213312033164014722 0ustar #!/bin/execlineb -P s6-setuidgid nssslog exec -c s6-log t /var/log/nsssd nsss-0.0.2.1/examples/s6-rc/nsssd-log/dependencies0000644000000000000000000000000113204564673016557 0ustar nsss-0.0.2.1/examples/s6-rc/nsssd-log/consumer-for0000644000000000000000000000000613312033146016537 0ustar nsssd nsss-0.0.2.1/examples/s6-rc/nsssd-log/type0000644000000000000000000000001013204564673015112 0ustar longrun nsss-0.0.2.1/examples/s6-rc/nsssd/0002755000000000000000000000000013204564673013442 5ustar nsss-0.0.2.1/examples/s6-rc/nsssd/pipeline-name0000644000000000000000000000001713312033271016065 0ustar nsssd-pipeline nsss-0.0.2.1/examples/s6-rc/nsssd/run0000644000000000000000000000014313334756510014162 0ustar #!/bin/execlineb -P fdmove -c 2 1 s6-envuidgid nsss fdmove 1 3 s6-ipcserver -1 -U -- s nsssd-unix nsss-0.0.2.1/examples/s6-rc/nsssd/dependencies0000644000000000000000000000000113312033257015765 0ustar nsss-0.0.2.1/examples/s6-rc/nsssd/type0000644000000000000000000000001013204564673014333 0ustar longrun nsss-0.0.2.1/examples/s6-rc/nsssd/producer-for0000644000000000000000000000001213312033277015752 0ustar nsssd-log nsss-0.0.2.1/examples/s6-rc/nsssd/notification-fd0000644000000000000000000000000213204564673016430 0ustar 3 nsss-0.0.2.1/README.solaris0000644000000000000000000000065313204564673012075 0ustar This package assumes the existence of a POSIX shell in /bin/sh. On Solaris, /bin/sh is not POSIX. Most versions of Solaris provide a POSIX shell in /usr/xpg4/bin/sh. To compile this package on Solaris, you will need to run ./patch-for-solaris before you run ./configure. This script will change the #! invocation of the configure script and various tools so that a POSIX shell is used for the compilation process. nsss-0.0.2.1/AUTHORS0000644000000000000000000000031013354210163010564 0ustar Main author: Laurent Bercot Contributors: John Regan Thanks to: A. Wilcox Elizabeth Meyers nsss-0.0.2.1/INSTALL0000644000000000000000000001506613553353570010576 0ustar Build Instructions ------------------ * Requirements ------------ - A POSIX-compliant C development environment - GNU make version 3.81 or later - skalibs version 2.9.1.0 or later: https://skarnet.org/software/skalibs/ - To run the test suite and the nsssd-* programs: s6 version 2.9.0.0 or later: https://skarnet.org/software/s6/ This software will run on any operating system that implements POSIX.1-2008, available at: http://pubs.opengroup.org/onlinepubs/9699919799/ * Standard usage -------------- ./configure && make && sudo make install will work for most users. It will install the binaries in /bin and the static libraries in /usr/lib/nsss. Please note that static libraries in /usr/lib/nsss *will not* be found by a default linker invocation: you need -L/usr/lib/nsss. Other skarnet.org software automatically handles that case if the default configuration is used, but if you change the configuration, remember to use the appropriate --with-lib configure option. You can strip the binaries and libraries of their extra symbols via "make strip" before the "make install" phase. It will shave a few bytes off them. * Customization ------------- You can customize paths via flags given to configure. See ./configure --help for a list of all available configure options. * Environment variables --------------------- Controlling a build process via environment variables is a big and dangerous hammer. You should try and pass flags to configure instead; nevertheless, a few standard environment variables are recognized. If the CC environment variable is set, its value will override compiler detection by configure. The --host=HOST option will still add a HOST- prefix to the value of CC. The values of CFLAGS, CPPFLAGS and LDFLAGS will be appended to flags auto-detected by configure. To entirely override the flags set by configure instead, use make variables. * Make variables -------------- You can invoke make with a few variables for more configuration. CC, CFLAGS, CPPFLAGS, LDFLAGS, LDLIBS, AR, RANLIB, STRIP, INSTALL and CROSS_COMPILE can all be overridden on the make command line. This is an even bigger hammer than running ./configure with environment variables, so it is advised to only do this when it is the only way of obtaining the behaviour you want. DESTDIR can be given on the "make install" command line in order to install to a staging directory. * Shared libraries ---------------- Software from skarnet.org is small enough that shared libraries are generally not worth using. Static linking is simpler and incurs less runtime overhead and less points of failure: so by default, shared libraries are not built and binaries are linked against the static versions of the skarnet.org libraries. Nevertheless, you can: * build shared libraries: --enable-shared * link binaries against shared libraries: --disable-allstatic * Static binaries --------------- By default, binaries are linked against static versions of all the libraries they depend on, except for the libc. You can enforce linking against the static libc with --enable-static-libc. (If you are using a GNU/Linux system, be aware that the GNU libc behaves badly with static linking and produces huge executables, which is why it is not the default. Other libcs are better suited to static linking, for instance musl: http://musl-libc.org/. If you're using nsss, chances are you're running musl, or a similar libc, anyway.) * Cross-compilation ----------------- skarnet.org packages centralize all the difficulty of cross-compilation in one place: skalibs. Once you have cross-compiled skalibs, the rest is easy. * Use the --host=HOST option to configure, HOST being the triplet for your target. * Make sure your cross-toolchain binaries (i.e. prefixed with HOST-) are accessible via your PATH environment variable. * Make sure to use the correct version of skalibs for your target, and the correct sysdeps directory, making use of the --with-include, --with-lib, --with-dynlib and --with-sysdeps options as necessary. * The slashpackage convention --------------------------- The slashpackage convention (http://cr.yp.to/slashpackage.html) is a package installation scheme that provides a few guarantees over other conventions such as the FHS, for instance fixed absolute pathnames. skarnet.org packages support it: use the --enable-slashpackage option to configure, or --enable-slashpackage=DIR for a prefixed DIR/package tree. This option will activate slashpackage support during the build and set slashpackage-compatible installation directories. If $package_home is the home of the package, defined as DIR/package/$category/$package-$version with the variables read from the package/info file, then: --dynlibdir is set to $package_home/library.so --bindir is set to $package_home/command --sbindir is also set to $package_home/command (slashpackage differentiates root-only binaries by their Unix rights, not their location in the filesystem) --libexecdir is also set to $package_home/command (slashpackage does not need a specific directory for internal binaries) --libdir is set to $package_home/library --includedir is set to $package_home/include --prefix is pretty much ignored when you use --enable-slashpackage. You should probably not use both --enable-slashpackage and --prefix. When using slashpackage, two additional Makefile targets are available after "make install": - "make update" changes the default version of the software to the freshly installed one. (This is useful when you have several installed versions of the same software, which slashpackage supports.) - "make -L global-links" adds links from /command and /library.so to the default version of the binaries and shared libraries. The "-L" option to make is necessary because targets are symbolic links, and the default make behaviour is to check the pointed file's timestamp and not the symlink's timestamp. * Absolute pathnames ------------------ You may want to use fixed absolute pathnames even if you're not following the slashpackage convention: for instance, the Nix packaging system prefers calling binaries with immutable paths rather than rely on PATH resolution. If you are in that case, use the --enable-absolute-paths option to configure. This will ensure that programs calling binaries from this package will call them with their full installation path (in bindir) without relying on a PATH search. * Out-of-tree builds ------------------ skarnet.org packages do not support out-of-tree builds. They are small, so it does not cost much to duplicate the entire source tree if parallel builds are needed. nsss-0.0.2.1/patch-for-solaris0000755000000000000000000000075113204564673013024 0ustar #!/usr/xpg4/bin/sh patchit () { echo '#!/usr/xpg4/bin/sh' > $1.tmp tail -n +2 $1 >> $1.tmp mv -f $1.tmp $1 chmod 755 $1 } # Solaris doesn't understand POSIX.1-2008 either. sed -e 's/XOPEN_SOURCE=700/XOPEN_SOURCE=600/' < configure > configure.tmp mv -f configure.tmp configure patchit ./configure patchit ./tools/install.sh patchit ./tools/gen-deps.sh echo 'SHELL := /usr/xpg4/bin/sh' > Makefile.tmp echo >> Makefile.tmp cat Makefile >> Makefile.tmp mv -f Makefile.tmp Makefile nsss-0.0.2.1/README0000644000000000000000000000155413553367227010426 0ustar nsssd - a secure NSS-like implementation for small libcs -------------------------------------------------------- nsss is a library implementing a subset of pwd.h, group.h and shadow.h family of functions - the subset that can use a different backend than the standard /etc/passwd (et al.) files. It is intended to be used with certain libcs, such as musl, that do not implement the NSS protocol and so do not allow user/group credentials to be stored in other databases. Unlike NSS, nsss does not load dynamic modules and is fully compatible with static linking. The backend is chosen at boot time by running the appropriate daemon that will communicate with clients. See https://skarnet.org/software/nsss/ for details. * Installation ------------ See the INSTALL file. * Contact information ------------------- Laurent Bercot nsss-0.0.2.1/src/0000755000000000000000000000000013315546562010325 5ustar nsss-0.0.2.1/src/libnsss/0000755000000000000000000000000013541512070011766 5ustar nsss-0.0.2.1/src/libnsss/nsss_all_getpwent.c0000644000000000000000000000126513314271747015704 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" #include "nsss-all-internal.h" struct passwd *nsss_all_getpwent (void) { int e = errno ; if (nsss_all_errno) goto fallback ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) goto efallback ; nsss_pwd_sa_here.len = 0 ; if (!nsss_switch_pwd_get(&nsss_switch_here, &nsss_pwd_here, &nsss_pwd_sa_here, 0, 0)) return 0 ; return &nsss_pwd_here ; efallback: nsss_all_errno = errno ; errno = e ; fallback: return nsss_unix_getpwent() ; } nsss-0.0.2.1/src/libnsss/nsss_all_setgrent.c0000644000000000000000000000077313314263774015706 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-switch-internal.h" #include "nsss-all-internal.h" void nsss_all_setgrent (void) { int e = errno ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; nsss_switch_grp_rewind(&nsss_switch_here, 0, 0) ; return ; fallback: nsss_all_errno = errno ; errno = e ; nsss_unix_setgrent() ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getgrent_r.c0000644000000000000000000000166013502707421016411 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" #include "nsss-unix-internal.h" int nsss_unix_getgrent_r (struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; int e ; if (!nsss_unix_grp_maybe_start(&nsss_unix_grp_here)) return errno ; e = errno ; errno = 0 ; if (!nsss_unix_grp_get(&nsss_unix_grp_here, &gr2, &sa, &ga)) { *grp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getgrnam.c0000644000000000000000000000104113314276760016056 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" struct group *nsss_unix_getgrnam (char const *name) { nsss_unix_t a = NSSS_UNIX_ZERO ; if (!nsss_unix_grp_start(&a)) return 0 ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_unix_grp_getbyname(&a, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here, name)) { nsss_unix_grp_end(&a) ; return 0 ; } nsss_unix_grp_end(&a) ; return &nsss_grp_here ; } nsss-0.0.2.1/src/libnsss/nsss_unix_grp_getbyname.c0000644000000000000000000000104313314275570017075 0ustar /* ISC license. */ #include #include #include #include int nsss_unix_grp_getbyname (nsss_unix_t *a, struct group *gr, stralloc *sa, genalloc *ga, char const *name) { struct group gr2 ; for (;;) { size_t sabase = sa->len ; size_t gabase = genalloc_len(char *, ga) ; if (!nsss_unix_grp_get(a, &gr2, sa, ga)) return 0 ; if (!strcmp(name, gr2.gr_name)) break ; sa->len = sabase ; genalloc_setlen(char *, ga, gabase) ; } *gr = gr2 ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_op.c0000644000000000000000000000070713314244614015207 0ustar /* ISC license. */ #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_op (nsss_switch_t *a, char op, tain_t const *deadline, tain_t *stamp) { char c ; if (!ipc_timed_send(buffer_fd(&a->b), &op, 1, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &c, 1, deadline, stamp)) return 0 ; if (c) return (errno = c, 0) ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_unix_grp_here.c0000644000000000000000000000014713313745010016037 0ustar /* ISC license. */ #include "nsss-unix-internal.h" nsss_unix_t nsss_unix_grp_here = NSSS_UNIX_ZERO ; nsss-0.0.2.1/src/libnsss/nsss_switch_endspent.c0000644000000000000000000000035313314253422016403 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" void nsss_switch_endspent (void) { nsss_switch_shadow_end(&nsss_switch_here, 0, 0) ; nsss_switch_end(&nsss_switch_here, NSSS_SWITCH_SHADOW) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getpwent.c0000644000000000000000000000071713314254065016430 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" struct passwd *nsss_switch_getpwent (void) { if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) return 0 ; nsss_pwd_sa_here.len = 0 ; if (!nsss_switch_pwd_get(&nsss_switch_here, &nsss_pwd_here, &nsss_pwd_sa_here, 0, 0)) return 0 ; return &nsss_pwd_here ; } nsss-0.0.2.1/src/libnsss/nsss_switch_grp_rewind.c0000644000000000000000000000036413314251622016725 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" int nsss_switch_grp_rewind (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp) { return nsss_switch_op(a, NSSS_SWITCH_GRP_REWIND, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_rewind.c0000644000000000000000000000044713313714266015550 0ustar /* ISC license. */ #include #include #include int nsss_unix_rewind (nsss_unix_t *a) { int fd = buffer_fd(&a->b) ; if (lseek(fd, 0, SEEK_SET) < 0) return 0 ; buffer_init(&a->b, &buffer_read, fd, a->buf, NSSS_UNIX_BUFSIZE) ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_all_endpwent.c0000644000000000000000000000046013314264515015662 0ustar /* ISC license. */ #include #include #include #include "nsss-all-internal.h" void nsss_all_endpwent (void) { if (nsss_all_errno) goto fallback ; nsss_switch_endpwent() ; return ; fallback: nsss_unix_endpwent() ; nsss_all_errno = 0 ; } nsss-0.0.2.1/src/libnsss/nsss_all_getspnam_r.c0000644000000000000000000000200713314276476016205 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" int nsss_all_getspnam_r (char const *name, struct spwd *sp, char *buf, size_t buflen, struct spwd **spp) { struct spwd sp2 ; stralloc sa = STRALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; errno = 0 ; if (!nsss_switch_shadow_getbyname(&a, &sp2, &sa, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_SHADOW) ; *spp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_SHADOW) ; if (!nsss_shadow_copy(sp, buf, buflen, &sp2, sa.s, sa.len)) { stralloc_free(&sa) ; *spp = 0 ; return errno ; } stralloc_free(&sa) ; *spp = sp ; return (errno = e, 0) ; fallback: errno = e ; return nsss_unix_getspnam_r(name, sp, buf, buflen, spp) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_grp_read.c0000644000000000000000000000352613433016616016357 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include "nsss-switch-internal.h" /* Expects: 4 bytes gr_gid 4 bytes total length of strings (including \0's) 4 bytes number of strings in gr_mem (n) \0-terminated gr_name \0-terminated gr_passwd sequence of n \0-terminated elements in gr_mem */ int nsss_switch_grp_read (buffer *b, struct group *gr, stralloc *sa, genalloc *ga, tain_t const *deadline, tain_t *stamp) { struct group grtmp ; uint32_t total, len, n, x ; char **q ; char *p ; char buf[12] ; if (!buffer_timed_get(b, buf, 12, deadline, stamp)) return 0 ; uint32_unpack_big(buf, &x) ; grtmp.gr_gid = x ; uint32_unpack_big(buf + 4, &total) ; uint32_unpack_big(buf + 8, &n) ; if (total < 2 || n >= 0x30000000u) return (errno = EPROTO, 0) ; if (!stralloc_readyplus(sa, total)) return 0 ; if (!genalloc_readyplus(char *, ga, n+1)) return 0 ; if (!buffer_timed_get(b, sa->s + sa->len, total, deadline, stamp)) return 0 ; if (sa->s[sa->len + total - 1]) return (errno = EPROTO, 0) ; p = sa->s + sa->len ; len = total ; q = genalloc_s(char *, ga) + genalloc_len(char *, ga) ; grtmp.gr_mem = q ; grtmp.gr_name = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; if (!len) return (errno = EPROTO, 0) ; grtmp.gr_passwd = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; for (uint32_t i = 0 ; i < n ; i++) { if (!len) return (errno = EPROTO, 0) ; q[i] = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; } if (len) return (errno = EPROTO, 0) ; q[n] = 0 ; sa->len += total ; genalloc_setlen(char *, ga, genalloc_len(char *, ga) + n + 1) ; *gr = grtmp ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_pwd_copy.c0000644000000000000000000000107513314015575015035 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" int nsss_pwd_copy (struct passwd *pw, char *buf, size_t buflen, struct passwd const *pw2, char const *s, size_t len) { if (len > buflen) return (errno = ERANGE, 0) ; memcpy(buf, s, len) ; pw->pw_name = buf + (pw2->pw_name - s) ; pw->pw_passwd = buf + (pw2->pw_passwd - s) ; pw->pw_uid = pw2->pw_uid ; pw->pw_gid = pw2->pw_gid ; pw->pw_gecos = buf + (pw2->pw_gecos - s) ; pw->pw_dir = buf + (pw2->pw_dir - s) ; pw->pw_shell = buf + (pw2->pw_shell - s) ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_end.c0000644000000000000000000000054613314274344015343 0ustar /* ISC license. */ #include #include #include static inline void nsss_switch_disconnect (nsss_switch_t *a) { fd_close(buffer_fd(&a->b)) ; a->b.fd = -1 ; } void nsss_switch_end (nsss_switch_t *a, unsigned int what) { a->held &= ~(1U << what) ; if (!a->held) nsss_switch_disconnect(a) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getspent.c0000644000000000000000000000064313314275106016103 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" #include "nsss-unix-internal.h" struct spwd *nsss_unix_getspent (void) { if (!nsss_unix_shadow_maybe_start(&nsss_unix_shadow_here)) return 0 ; nsss_shadow_sa_here.len = 0 ; if (!nsss_unix_shadow_get(&nsss_unix_shadow_here, &nsss_shadow_here, &nsss_shadow_sa_here)) return 0 ; return &nsss_shadow_here ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getspent.c0000644000000000000000000000074213314254165016423 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" struct spwd *nsss_switch_getspent (void) { if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) return 0 ; nsss_shadow_sa_here.len = 0 ; if (!nsss_switch_shadow_get(&nsss_switch_here, &nsss_shadow_here, &nsss_shadow_sa_here, 0, 0)) return 0 ; return &nsss_shadow_here ; } nsss-0.0.2.1/src/libnsss/nsss_switch_grp_getbygid.c0000644000000000000000000000133013314252155017227 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_grp_getbygid (nsss_switch_t *a, struct group *gr, stralloc *sa, genalloc *ga, gid_t gid, tain_t const *deadline, tain_t *stamp) { char buf[5] = { NSSS_SWITCH_GRP_GETBYGID } ; uint32_pack_big(buf + 1, gid) ; if (!ipc_timed_send(buffer_fd(&a->b), buf, 5, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &buf[0], 1, deadline, stamp)) return 0 ; if ((unsigned char)buf[0] == 255) return 0 ; if (buf[0]) return (errno = buf[0], 0) ; return nsss_switch_grp_read(&a->b, gr, sa, ga, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_endspent.c0000644000000000000000000000024713313706424016073 0ustar /* ISC license. */ #include #include "nsss-unix-internal.h" void nsss_unix_endspent (void) { nsss_unix_shadow_end(&nsss_unix_shadow_here) ; } nsss-0.0.2.1/src/libnsss/nsss_all_setspent.c0000644000000000000000000000100713314264117015677 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-switch-internal.h" #include "nsss-all-internal.h" void nsss_all_setspent (void) { int e = errno ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; nsss_switch_shadow_rewind(&nsss_switch_here, 0, 0) ; return ; fallback: nsss_all_errno = errno ; errno = e ; nsss_unix_setspent() ; } nsss-0.0.2.1/src/libnsss/nsss_unix_endgrent.c0000644000000000000000000000023613313706763016065 0ustar /* ISC license. */ #include #include "nsss-unix-internal.h" void nsss_unix_endgrent (void) { nsss_unix_grp_end(&nsss_unix_grp_here) ; } nsss-0.0.2.1/src/libnsss/nsss-switch-internal.h0000644000000000000000000000135213314276041016242 0ustar /* ISC license. */ #ifndef NSSS_SWITCH_INTERNAL_H #define NSSS_SWITCH_INTERNAL_H #include #include #include #include #include #include #include #include extern nsss_switch_t nsss_switch_here ; extern int nsss_switch_op (nsss_switch_t *, char, tain_t const *, tain_t *) ; extern int nsss_switch_pwd_read (buffer *, struct passwd *, stralloc *, tain_t const *, tain_t *) ; extern int nsss_switch_grp_read (buffer *, struct group *, stralloc *, genalloc *, tain_t const *, tain_t *) ; extern int nsss_switch_shadow_read (buffer *, struct spwd *, stralloc *, tain_t const *, tain_t *) ; #endif nsss-0.0.2.1/src/libnsss/nsss_switch_endpwent.c0000644000000000000000000000034213314253307016407 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" void nsss_switch_endpwent (void) { nsss_switch_pwd_end(&nsss_switch_here, 0, 0) ; nsss_switch_end(&nsss_switch_here, NSSS_SWITCH_PWD) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getspent_r.c0000644000000000000000000000150713314254515016743 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" int nsss_switch_getspent_r (struct spwd *sp, char *buf, size_t buflen, struct spwd **spp) { struct spwd sp2 ; stralloc sa = STRALLOC_ZERO ; int e ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) return errno ; e = errno ; errno = 0 ; if (!nsss_switch_shadow_get(&nsss_switch_here, &sp2, &sa, 0, 0)) { *spp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_shadow_copy(sp, buf, buflen, &sp2, sa.s, sa.len)) { stralloc_free(&sa) ; *spp = 0 ; return errno ; } stralloc_free(&sa) ; *spp = sp ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getgrouplist.c0000644000000000000000000000073013541510532016774 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" int nsss_unix_getgrouplist (char const *user, gid_t gid, gid_t *gids, int *ngids) { int e = errno ; size_t r = 0 ; size_t n ; if (*ngids < 0) return (errno = EINVAL, -1) ; n = *ngids ; if (!nsss_unix_getgrouplist_preadjust(user, gids, n, &r)) return -1 ; return nsss_grouplist_adjust(n, r, gid, gids, ngids, e) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_grp_get.c0000644000000000000000000000324213314275510015676 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "nsss-unix-internal.h" static inline char **grp_parsemem (char *s, genalloc *ga) { char **grmem ; char **p ; size_t n = 0 ; for (char *t = s ; *t ; t++) if (*t == ',') { n++ ; *t = 0 ; } ; if (*s) n++ ; if (!genalloc_readyplus(char *, ga, n+1)) return 0 ; p = genalloc_s(char *, ga) + genalloc_len(char *, ga) ; grmem = p ; for (size_t i = 0 ; i < n ; i++) { *p++ = s ; s += strlen(s) + 1 ; } *p++ = 0 ; genalloc_setlen(char *, ga, genalloc_len(char *, ga) + n+1) ; return grmem ; } static inline int grp_parseline (struct group *gr, char *s, size_t max, genalloc *ga) { struct group gr2 ; char *p ; s[max-1] = 0 ; if (!nsss_unix_field(&gr2.gr_name, &s)) return 0 ; if (!nsss_unix_field(&gr2.gr_passwd, &s)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!gid0_scan(p, &gr2.gr_gid)) return 0 ; gr2.gr_mem = grp_parsemem(s, ga) ; if (!gr2.gr_mem) return 0 ; *gr = gr2 ; return 1 ; } int nsss_unix_grp_get (nsss_unix_t *a, struct group *gr, stralloc *sa, genalloc *ga) { int cs ; pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs) ; for (;;) { size_t sabase = sa->len ; size_t gabase = genalloc_len(char *, ga) ; if (skagetln_loose(&a->b, sa, '\n') <= 0) goto err ; if (grp_parseline(gr, sa->s + sabase, sa->len - sabase, ga)) break ; sa->len = sabase ; genalloc_setlen(char *, ga, gabase) ; } pthread_setcancelstate(cs, 0) ; return 1 ; err: pthread_setcancelstate(cs, 0) ; return 0 ; } nsss-0.0.2.1/src/libnsss/nsss_all_getspent_r.c0000644000000000000000000000202713314271640016206 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" #include "nsss-all-internal.h" int nsss_all_getspent_r (struct spwd *sp, char *buf, size_t buflen, struct spwd **spp) { struct spwd sp2 ; stralloc sa = STRALLOC_ZERO ; int e = errno ; if (nsss_all_errno) goto fallback ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) goto efallback ; errno = 0 ; if (!nsss_switch_shadow_get(&nsss_switch_here, &sp2, &sa, 0, 0)) { *spp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_shadow_copy(sp, buf, buflen, &sp2, sa.s, sa.len)) { stralloc_free(&sa) ; *spp = 0 ; return errno ; } stralloc_free(&sa) ; *spp = sp ; return (errno = e, 0) ; efallback: nsss_all_errno = errno ; errno = e ; fallback: return nsss_unix_getspent_r(sp, buf, buflen, spp) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_shadow_end.c0000644000000000000000000000036413314250301016671 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" int nsss_switch_shadow_end (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp) { return nsss_switch_op(a, NSSS_SWITCH_SHADOW_END, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_all_getpwnam.c0000644000000000000000000000125313314276247015666 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" struct passwd *nsss_all_getpwnam (char const *name) { nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; nsss_pwd_sa_here.len = 0 ; if (!nsss_switch_pwd_getbyname(&a, &nsss_pwd_here, &nsss_pwd_sa_here, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_PWD) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_PWD) ; return &nsss_pwd_here ; fallback: errno = e ; return nsss_unix_getpwnam(name) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getpwent_r.c0000644000000000000000000000137413314274731016435 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" #include "nsss-unix-internal.h" int nsss_unix_getpwent_r (struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; int e ; if (!nsss_unix_pwd_maybe_start(&nsss_unix_pwd_here)) return errno ; e = errno ; errno = 0 ; if (!nsss_unix_pwd_get(&nsss_unix_pwd_here, &pw2, &sa)) { *pwp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_setgrent.c0000644000000000000000000000037513314031760016103 0ustar /* ISC license. */ #include #include #include "nsss-unix-internal.h" void nsss_unix_setgrent (void) { if (!nsss_unix_grp_maybe_start(&nsss_unix_grp_here)) return ; nsss_unix_grp_rewind(&nsss_unix_grp_here) ; } nsss-0.0.2.1/src/libnsss/nsss_grp_copy.c0000644000000000000000000000150113314020305015010 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" int nsss_grp_copy (struct group *gr, char *buf, size_t buflen, struct group const *gr2, char const *s, size_t len, char *const *p, size_t n) { char **q ; size_t offset = (uintptr_t)buf % 16 ; offset = offset ? 16 - offset : 0 ; if (buflen < offset) return (errno = ERANGE, 0) ; buf += offset ; buflen -= offset ; offset = (n+1) * sizeof(char *) ; if (buflen < offset || buflen - offset < len) return (errno = ERANGE, 0) ; q = (char **)buf ; gr->gr_mem = q ; buf += offset ; memcpy(buf, s, len) ; for (size_t i = 0 ; i < n ; i++) q[i] = buf + (p[i] - s) ; q[n] = 0 ; gr->gr_name = buf + (gr2->gr_name - s) ; gr->gr_passwd = buf + (gr2->gr_passwd - s) ; gr->gr_gid = gr2->gr_gid ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_pwd_getbyname.c0000644000000000000000000000172013314247113017407 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_pwd_getbyname (nsss_switch_t *a, struct passwd *pw, stralloc *sa, char const *name, tain_t const *deadline, tain_t *stamp) { char buf[5] = { NSSS_SWITCH_PWD_GETBYNAME } ; size_t len = strlen(name) ; struct iovec v[2] = { { .iov_base = buf, .iov_len = 5 }, { .iov_base = (char *)name, .iov_len = len + 1 } } ; if (len > NSSS_SWITCH_NAME_MAXLEN - 1) return (errno = EINVAL, 0) ; uint32_pack_big(buf + 1, len + 1) ; if (!ipc_timed_sendv(buffer_fd(&a->b), v, 2, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &buf[0], 1, deadline, stamp)) return 0 ; if ((unsigned char)buf[0] == 255) return 0 ; if (buf[0]) return (errno = buf[0], 0) ; return nsss_switch_pwd_read(&a->b, pw, sa, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss-all-internal.h0000644000000000000000000000016113314262633015510 0ustar /* ISC license. */ #ifndef NSSS_ALL_INTERNAL_H #define NSSS_ALL_INTERNAL_H extern int nsss_all_errno ; #endif nsss-0.0.2.1/src/libnsss/nsss_switch_getgrnam.c0000644000000000000000000000122013314276546016375 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" struct group *nsss_switch_getgrnam (char const *name) { nsss_switch_t a = NSSS_SWITCH_ZERO ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) return 0 ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_switch_grp_getbyname(&a, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return &nsss_grp_here ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getpwnam.c0000644000000000000000000000067713314276702016106 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" struct passwd *nsss_unix_getpwnam (char const *name) { nsss_unix_t a = NSSS_UNIX_ZERO ; if (!nsss_unix_pwd_start(&a)) return 0 ; nsss_pwd_sa_here.len = 0 ; if (!nsss_unix_pwd_getbyname(&a, &nsss_pwd_here, &nsss_pwd_sa_here, name)) { nsss_unix_pwd_end(&a) ; return 0 ; } nsss_unix_pwd_end(&a) ; return &nsss_pwd_here ; } nsss-0.0.2.1/src/libnsss/nsss_all_getpwuid_r.c0000644000000000000000000000175613314276341016220 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" int nsss_all_getpwuid_r (uid_t uid, struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; errno = 0 ; if (!nsss_switch_pwd_getbyuid(&a, &pw2, &sa, uid, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_PWD) ; *pwp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_PWD) ; if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; fallback: errno = e ; return nsss_unix_getpwuid_r(uid, pw, buf, buflen, pwp) ; } nsss-0.0.2.1/src/libnsss/nsss_all_getgrnam_r.c0000644000000000000000000000225413502707421016163 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "nsss-internal.h" int nsss_all_getgrnam_r (char const *name, struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; errno = 0 ; if (!nsss_switch_grp_getbyname(&a, &gr2, &sa, &ga, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; *grp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; fallback: errno = e ; return nsss_unix_getgrnam_r(name, gr, buf, buflen, grp) ; } nsss-0.0.2.1/src/libnsss/nsss_all_getspent.c0000644000000000000000000000131313314274202015657 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" #include "nsss-all-internal.h" struct spwd *nsss_all_getspent (void) { int e = errno ; if (nsss_all_errno) goto fallback ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) goto efallback ; nsss_shadow_sa_here.len = 0 ; if (!nsss_switch_shadow_get(&nsss_switch_here, &nsss_shadow_here, &nsss_shadow_sa_here, 0, 0)) return 0 ; return &nsss_shadow_here ; efallback: nsss_all_errno = errno ; errno = e ; fallback: return nsss_unix_getspent() ; } nsss-0.0.2.1/src/libnsss/nsss_switch_endgrent.c0000644000000000000000000000034213314253353016372 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" void nsss_switch_endgrent (void) { nsss_switch_grp_end(&nsss_switch_here, 0, 0) ; nsss_switch_end(&nsss_switch_here, NSSS_SWITCH_GRP) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_pwd_get.c0000644000000000000000000000224113314275333015701 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-unix-internal.h" static inline int pwd_parseline (struct passwd *pw, char *s, size_t max) { struct passwd pw2 ; char *p ; s[max-1] = 0 ; if (!nsss_unix_field(&pw2.pw_name, &s)) return 0 ; if (!nsss_unix_field(&pw2.pw_passwd, &s)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!uid0_scan(p, &pw2.pw_uid)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!gid0_scan(p, &pw2.pw_gid)) return 0 ; if (!nsss_unix_field(&pw2.pw_gecos, &s)) return 0 ; if (!nsss_unix_field(&pw2.pw_dir, &s)) return 0 ; pw2.pw_shell = s ; *pw = pw2 ; return 1 ; } int nsss_unix_pwd_get (nsss_unix_t *a, struct passwd *pw, stralloc *sa) { int cs ; pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs) ; for (;;) { size_t base = sa->len ; if (skagetln_loose(&a->b, sa, '\n') <= 0) goto err ; if (pwd_parseline(pw, sa->s + base, sa->len - base)) break ; sa->len = base ; } pthread_setcancelstate(cs, 0) ; return 1 ; err: pthread_setcancelstate(cs, 0) ; return 0 ; } nsss-0.0.2.1/src/libnsss/deps-exe/0000755000000000000000000000000013312043245013477 5ustar nsss-0.0.2.1/src/libnsss/nsss_unix_getgrent.c0000644000000000000000000000075413314001437016066 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" #include "nsss-unix-internal.h" struct group *nsss_unix_getgrent (void) { if (!nsss_unix_grp_maybe_start(&nsss_unix_grp_here)) return 0 ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_unix_grp_get(&nsss_unix_grp_here, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here)) return 0 ; return &nsss_grp_here ; } nsss-0.0.2.1/src/libnsss/nsss_switch_shadow_get.c0000644000000000000000000000113513314251204016702 0ustar /* ISC license. */ #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_shadow_get (nsss_switch_t *a, struct spwd *sp, stralloc *sa, tain_t const *deadline, tain_t *stamp) { char c = NSSS_SWITCH_SHADOW_GET ; if (!ipc_timed_send(buffer_fd(&a->b), &c, 1, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &c, 1, deadline, stamp)) return 0 ; if ((unsigned char)c == 255) return 0 ; if (c) return (errno = c, 0) ; return nsss_switch_shadow_read(&a->b, sp, sa, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_setpwent.c0000644000000000000000000000050213314254300016424 0ustar /* ISC license. */ #include #include #include #include "nsss-switch-internal.h" void nsss_switch_setpwent (void) { if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) return ; nsss_switch_pwd_rewind(&nsss_switch_here, 0, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_grp_getbyname.c0000644000000000000000000000174113314252300017402 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_grp_getbyname (nsss_switch_t *a, struct group *gr, stralloc *sa, genalloc *ga, char const *name, tain_t const *deadline, tain_t *stamp) { char buf[5] = { NSSS_SWITCH_GRP_GETBYNAME } ; size_t len = strlen(name) ; struct iovec v[2] = { { .iov_base = buf, .iov_len = 5 }, { .iov_base = (char *)name, .iov_len = len + 1 } } ; if (len > NSSS_SWITCH_NAME_MAXLEN - 1) return (errno = EINVAL, 0) ; uint32_pack_big(buf + 1, len + 1) ; if (!ipc_timed_sendv(buffer_fd(&a->b), v, 2, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &buf[0], 1, deadline, stamp)) return 0 ; if ((unsigned char)buf[0] == 255) return 0 ; if (buf[0]) return (errno = buf[0], 0) ; return nsss_switch_grp_read(&a->b, gr, sa, ga, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getgrnam_r.c0000644000000000000000000000210013502707421016702 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" int nsss_switch_getgrnam_r (char const *name, struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) return errno ; errno = 0 ; if (!nsss_switch_grp_getbyname(&a, &gr2, &sa, &ga, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; *grp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_shadow_get.c0000644000000000000000000000312413354207505016375 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-unix-internal.h" static int lscan (char const *s, long *l) { if (*s) return !!ulong0_scan(s, (unsigned long *)l) ; *l = -1 ; return 1 ; } static inline int shadow_parseline (struct spwd *sp, char *s, size_t max) { struct spwd sp2 ; char *p ; s[max-1] = 0 ; if (!nsss_unix_field(&sp2.sp_namp, &s)) return 0 ; if (!nsss_unix_field(&sp2.sp_pwdp, &s)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!lscan(p, &sp2.sp_lstchg)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!lscan(p, &sp2.sp_min)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!lscan(p, &sp2.sp_max)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!lscan(p, &sp2.sp_warn)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!lscan(p, &sp2.sp_inact)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!lscan(p, &sp2.sp_expire)) return 0 ; if (!nsss_unix_field(&p, &s)) return 0 ; if (!lscan(p, (long *)&sp2.sp_flag)) return 0 ; *sp = sp2 ; return 1 ; } int nsss_unix_shadow_get (nsss_unix_t *a, struct spwd *sp, stralloc *sa) { int cs ; pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs) ; for (;;) { size_t base = sa->len ; if (skagetln_loose(&a->b, sa, '\n') <= 0) goto err ; if (shadow_parseline(sp, sa->s + base, sa->len - base)) break ; sa->len = base ; } pthread_setcancelstate(cs, 0) ; return 1 ; err: pthread_setcancelstate(cs, 0) ; return 0 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_pwd_getbyuid.c0000644000000000000000000000130713314250064017250 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_pwd_getbyuid (nsss_switch_t *a, struct passwd *pw, stralloc *sa, uid_t uid, tain_t const *deadline, tain_t *stamp) { char buf[5] = { NSSS_SWITCH_PWD_GETBYUID } ; uint32_pack_big(buf + 1, uid) ; if (!ipc_timed_send(buffer_fd(&a->b), buf, 5, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &buf[0], 1, deadline, stamp)) return 0 ; if ((unsigned char)buf[0] == 255) return 0 ; if (buf[0]) return (errno = buf[0], 0) ; return nsss_switch_pwd_read(&a->b, pw, sa, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_pwd_here.c0000644000000000000000000000026213314274300014774 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" struct passwd nsss_pwd_here ; stralloc nsss_pwd_sa_here = STRALLOC_ZERO ; nsss-0.0.2.1/src/libnsss/nsss_switch_getgrgid_r.c0000644000000000000000000000206713502707421016706 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" int nsss_switch_getgrgid_r (gid_t gid, struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) return errno ; errno = 0 ; if (!nsss_switch_grp_getbygid(&a, &gr2, &sa, &ga, gid, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; *grp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getgrnam_r.c0000644000000000000000000000172113502707421016374 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" int nsss_unix_getgrnam_r (char const *name, struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; nsss_unix_t a = NSSS_UNIX_ZERO ; int e = errno ; if (!nsss_unix_grp_start(&a)) return errno ; errno = 0 ; if (!nsss_unix_grp_getbyname(&a, &gr2, &sa, &ga, name)) { nsss_unix_grp_end(&a) ; *grp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_unix_grp_end(&a) ; if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_all_errno.c0000644000000000000000000000011513314262671015161 0ustar /* ISC license. */ #include "nsss-all-internal.h" int nsss_all_errno = 0 ; nsss-0.0.2.1/src/libnsss/nsss_switch_here.c0000644000000000000000000000021113314245305015500 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" nsss_switch_t nsss_switch_here = NSSS_SWITCH_ZERO ; nsss-0.0.2.1/src/libnsss/nsss-internal.h0000644000000000000000000000170413541505676014757 0ustar /* ISC license. */ #ifndef NSSS_INTERNAL_H #define NSSS_INTERNAL_H #include #include #include #include #include #include /* Password */ extern struct passwd nsss_pwd_here ; extern stralloc nsss_pwd_sa_here ; extern int nsss_pwd_copy (struct passwd *, char *, size_t, struct passwd const *, char const *, size_t) ; /* Group */ extern struct group nsss_grp_here ; extern stralloc nsss_grp_sa_here ; extern genalloc nsss_grp_ga_here ; extern int nsss_grp_copy (struct group *, char *, size_t, struct group const *, char const *, size_t, char *const *, size_t) ; extern int nsss_grouplist_adjust (size_t, size_t, gid_t, gid_t *, int *, int) ; /* Shadow */ extern struct spwd nsss_shadow_here ; extern stralloc nsss_shadow_sa_here ; extern int nsss_shadow_copy (struct spwd *, char *, size_t, struct spwd const *, char const *, size_t) ; #endif nsss-0.0.2.1/src/libnsss/nsss_switch_start.c0000644000000000000000000000133113314274372015724 0ustar /* ISC license. */ #include #include #include #include static inline int nsss_switch_connect (nsss_switch_t *a, char const *path, tain_t const *deadline, tain_t *stamp) { int fd = ipc_stream_nbcoe() ; if (fd < 0) return 0 ; if (!ipc_timed_connect(fd, path, deadline, stamp)) { fd_close(fd) ; return 0 ; } buffer_init(&a->b, &buffer_read, fd, a->buf, NSSS_SWITCH_BUFSIZE) ; return 1 ; } int nsss_switch_start (nsss_switch_t *a, unsigned int what, char const *path, tain_t const *deadline, tain_t *stamp) { if (!a->held && !nsss_switch_connect(a, path, deadline, stamp)) return 0 ; a->held |= (1U << what) ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_all_setpwent.c0000644000000000000000000000077313314263730015714 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-switch-internal.h" #include "nsss-all-internal.h" void nsss_all_setpwent (void) { int e = errno ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; nsss_switch_pwd_rewind(&nsss_switch_here, 0, 0) ; return ; fallback: nsss_all_errno = errno ; errno = e ; nsss_unix_setpwent() ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getpwnam_r.c0000644000000000000000000000143513314276712016421 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" int nsss_unix_getpwnam_r (char const *name, struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; nsss_unix_t a = NSSS_UNIX_ZERO ; int e = errno ; if (!nsss_unix_pwd_start(&a)) return errno ; errno = 0 ; if (!nsss_unix_pwd_getbyname(&a, &pw2, &sa, name)) { nsss_unix_pwd_end(&a) ; *pwp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_unix_pwd_end(&a) ; if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getgrouplist_preadjust.c0000644000000000000000000000103313541511353021054 0ustar /* ISC license. */ #include #include #include #include int nsss_unix_getgrouplist_preadjust (char const *user, gid_t *gids, size_t n, size_t *r) { stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; /* char * */ nsss_unix_t a = NSSS_UNIX_ZERO ; if (!nsss_unix_grp_start(&a)) return 0 ; if (!nsss_unix_grp_getlist(&a, user, gids, n, r, &sa, &ga)) { nsss_unix_grp_end(&a) ; return 0 ; } nsss_unix_grp_end(&a) ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getpwuid.c0000644000000000000000000000104513314276512016417 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" struct passwd *nsss_switch_getpwuid (uid_t uid) { nsss_switch_t a = NSSS_SWITCH_ZERO ; if (!nsss_switch_start(&a, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) return 0 ; nsss_pwd_sa_here.len = 0 ; if (!nsss_switch_pwd_getbyuid(&a, &nsss_pwd_here, &nsss_pwd_sa_here, uid, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_PWD) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_PWD) ; return &nsss_pwd_here ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getpwent_r.c0000644000000000000000000000150113314254102016731 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" int nsss_switch_getpwent_r (struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; int e ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) return errno ; e = errno ; errno = 0 ; if (!nsss_switch_pwd_get(&nsss_switch_here, &pw2, &sa, 0, 0)) { *pwp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_setspent.c0000644000000000000000000000051313314264137016433 0ustar /* ISC license. */ #include #include #include #include "nsss-switch-internal.h" void nsss_switch_setspent (void) { if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) return ; nsss_switch_shadow_rewind(&nsss_switch_here, 0, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_grp_getlist.c0000644000000000000000000000226013541511143016566 0ustar /* ISC license. */ #include #include #include #include #include #include int nsss_unix_grp_getlist (nsss_unix_t *a, char const *user, gid_t *gids, size_t n, size_t *r, stralloc *sa, genalloc *ga) { int sawasnull = !sa->s ; int gawasnull = !genalloc_s(char *, ga) ; size_t sabase = sa->len ; size_t gabase = genalloc_len(char *, ga) ; size_t m = 0 ; for (;;) { struct group gr ; sa->len = sabase ; genalloc_setlen(char *, ga, gabase) ; errno = 0 ; if (!nsss_unix_grp_get(a, &gr, sa, ga)) { if (errno) goto err ; else break ; } for (char **p = gr.gr_mem ; *p ; p++) if (!strcmp(user, *p)) { if (m < n) gids[m] = gr.gr_gid ; m++ ; break ; } } if (gawasnull) genalloc_free(char *, ga) ; else genalloc_setlen(char *, ga, gabase) ; if (sawasnull) stralloc_free(sa) ; else sa->len = sabase ; *r = m ; return 1 ; err: if (gawasnull) genalloc_free(char *, ga) ; else genalloc_setlen(char *, ga, gabase) ; if (sawasnull) stralloc_free(sa) ; else sa->len = sabase ; return 0 ; } nsss-0.0.2.1/src/libnsss/nsss_all_getgrouplist.c0000644000000000000000000000160213541510302016553 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "nsss-internal.h" int nsss_all_getgrouplist (char const *user, gid_t gid, gid_t *gids, int *ngids) { stralloc sa = STRALLOC_ZERO ; int e = errno ; size_t r = 0 ; size_t n ; nsss_switch_t a = NSSS_SWITCH_ZERO ; if (*ngids < 0) return (errno = EINVAL, -1) ; n = *ngids ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; if (!nsss_switch_grp_getlist(&a, user, gids, n, &r, &sa, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return -1 ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return nsss_grouplist_adjust(n, r, gid, gids, ngids, e) ; fallback: errno = e ; return nsss_unix_getgrouplist(user, gid, gids, ngids) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_pwd_get.c0000644000000000000000000000112613314244374016221 0ustar /* ISC license. */ #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_pwd_get (nsss_switch_t *a, struct passwd *pw, stralloc *sa, tain_t const *deadline, tain_t *stamp) { char c = NSSS_SWITCH_PWD_GET ; if (!ipc_timed_send(buffer_fd(&a->b), &c, 1, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &c, 1, deadline, stamp)) return 0 ; if ((unsigned char)c == 255) return 0 ; if (c) return (errno = c, 0) ; return nsss_switch_pwd_read(&a->b, pw, sa, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_all_endgrent.c0000644000000000000000000000046013314264422015641 0ustar /* ISC license. */ #include #include #include #include "nsss-all-internal.h" void nsss_all_endgrent (void) { if (nsss_all_errno) goto fallback ; nsss_switch_endgrent() ; return ; fallback: nsss_unix_endgrent() ; nsss_all_errno = 0 ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getpwent.c0000644000000000000000000000061213313756654016116 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" #include "nsss-unix-internal.h" struct passwd *nsss_unix_getpwent (void) { if (!nsss_unix_pwd_maybe_start(&nsss_unix_pwd_here)) return 0 ; nsss_pwd_sa_here.len = 0 ; if (!nsss_unix_pwd_get(&nsss_unix_pwd_here, &nsss_pwd_here, &nsss_pwd_sa_here)) return 0 ; return &nsss_pwd_here ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getpwuid.c0000644000000000000000000000066613314276720016112 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" struct passwd *nsss_unix_getpwuid (uid_t uid) { nsss_unix_t a = NSSS_UNIX_ZERO ; if (!nsss_unix_pwd_start(&a)) return 0 ; nsss_pwd_sa_here.len = 0 ; if (!nsss_unix_pwd_getbyuid(&a, &nsss_pwd_here, &nsss_pwd_sa_here, uid)) { nsss_unix_pwd_end(&a) ; return 0 ; } nsss_unix_pwd_end(&a) ; return &nsss_pwd_here ; } nsss-0.0.2.1/src/libnsss/nsss_unix_shadow_getbyname.c0000644000000000000000000000063513313740610017567 0ustar /* ISC license. */ #include #include #include int nsss_unix_shadow_getbyname (nsss_unix_t *a, struct spwd *sp, stralloc *sa, char const *name) { struct spwd sp2 ; for (;;) { size_t base = sa->len ; if (!nsss_unix_shadow_get(a, &sp2, sa)) return 0 ; if (!strcmp(name, sp2.sp_namp)) break ; sa->len = base ; } *sp = sp2 ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_unix_pwd_getbyuid.c0000644000000000000000000000061213313733260016733 0ustar /* ISC license. */ #include #include #include int nsss_unix_pwd_getbyuid (nsss_unix_t *a, struct passwd *pw, stralloc *sa, uid_t uid) { struct passwd pw2 ; for (;;) { size_t base = sa->len ; if (!nsss_unix_pwd_get(a, &pw2, sa)) return 0 ; if (uid == pw2.pw_uid) break ; sa->len = base ; } *pw = pw2 ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_grp_end.c0000644000000000000000000000035613315527111016204 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" int nsss_switch_grp_end (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp) { return nsss_switch_op(a, NSSS_SWITCH_GRP_END, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getspent_r.c0000644000000000000000000000141013314274720016416 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" #include "nsss-unix-internal.h" int nsss_unix_getspent_r (struct spwd *sp, char *buf, size_t buflen, struct spwd **spp) { struct spwd sp2 ; stralloc sa = STRALLOC_ZERO ; int e ; if (!nsss_unix_shadow_maybe_start(&nsss_unix_shadow_here)) return errno ; e = errno ; errno = 0 ; if (!nsss_unix_shadow_get(&nsss_unix_shadow_here, &sp2, &sa)) { *spp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_shadow_copy(sp, buf, buflen, &sp2, sa.s, sa.len)) { stralloc_free(&sa) ; *spp = 0 ; return errno ; } stralloc_free(&sa) ; *spp = sp ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getspnam.c0000644000000000000000000000110713314276612016405 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" struct spwd *nsss_switch_getspnam (char const *name) { nsss_switch_t a = NSSS_SWITCH_ZERO ; if (!nsss_switch_start(&a, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) return 0 ; nsss_shadow_sa_here.len = 0 ; if (!nsss_switch_shadow_getbyname(&a, &nsss_shadow_here, &nsss_shadow_sa_here, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_SHADOW) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_SHADOW) ; return &nsss_shadow_here ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getpwnam_r.c0000644000000000000000000000161413314276532016736 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" int nsss_switch_getpwnam_r (char const *name, struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) return errno ; errno = 0 ; if (!nsss_switch_pwd_getbyname(&a, &pw2, &sa, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_PWD) ; *pwp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_PWD) ; if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_all_getgrgid.c0000644000000000000000000000140313314276447015637 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" struct group *nsss_all_getgrgid (gid_t gid) { nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_switch_grp_getbygid(&a, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here, gid, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return &nsss_grp_here ; fallback: errno = e ; return nsss_unix_getgrgid(gid) ; } nsss-0.0.2.1/src/libnsss/nsss_grouplist_adjust.c0000644000000000000000000000121313541505704016605 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" int nsss_grouplist_adjust (size_t n, size_t r, gid_t gid, gid_t *gids, int *ngids, int e) { if (r > INT_MAX) return (errno = EMSGSIZE, -1) ; if (r > n) return (*ngids = (int)r, errno = ENOBUFS, -1) ; for (size_t i = 0 ; i < r ; i++) if (gid == gids[i]) goto ok ; r++ ; if (r > INT_MAX) return (errno = EMSGSIZE, -1) ; if (r > n) return (*ngids = (int)r, errno = ENOBUFS, -1) ; memmove(gids + 1, gids, (r-1) * sizeof(gid_t)) ; gids[0] = gid ; ok: *ngids = (int)r ; errno = e ; return (int)n ; } nsss-0.0.2.1/src/libnsss/nsss_all_getspnam.c0000644000000000000000000000130713314276471015661 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" struct spwd *nsss_all_getspnam (char const *name) { nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; nsss_shadow_sa_here.len = 0 ; if (!nsss_switch_shadow_getbyname(&a, &nsss_shadow_here, &nsss_shadow_sa_here, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_SHADOW) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_SHADOW) ; return &nsss_shadow_here ; fallback: errno = e ; return nsss_unix_getspnam(name) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_setpwent.c0000644000000000000000000000037513314032013016111 0ustar /* ISC license. */ #include #include #include "nsss-unix-internal.h" void nsss_unix_setpwent (void) { if (!nsss_unix_pwd_maybe_start(&nsss_unix_pwd_here)) return ; nsss_unix_pwd_rewind(&nsss_unix_pwd_here) ; } nsss-0.0.2.1/src/libnsss/nsss_all_endspent.c0000644000000000000000000000047113314264551015660 0ustar /* ISC license. */ #include #include #include #include "nsss-all-internal.h" void nsss_all_endspent (void) { if (nsss_all_errno) goto fallback ; nsss_switch_endspent() ; return ; fallback: nsss_unix_endspent() ; nsss_all_errno = 0 ; } nsss-0.0.2.1/src/libnsss/nsss_all_getgrent.c0000644000000000000000000000142713314271772015664 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" #include "nsss-all-internal.h" struct group *nsss_all_getgrent (void) { int e = errno ; if (nsss_all_errno) goto fallback ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) goto efallback ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_switch_grp_get(&nsss_switch_here, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here, 0, 0)) return 0 ; return &nsss_grp_here ; efallback: nsss_all_errno = errno ; errno = e ; fallback: return nsss_unix_getgrent() ; } nsss-0.0.2.1/src/libnsss/nsss_all_getpwnam_r.c0000644000000000000000000000177013314276353016211 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" int nsss_all_getpwnam_r (char const *name, struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; errno = 0 ; if (!nsss_switch_pwd_getbyname(&a, &pw2, &sa, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_PWD) ; *pwp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_PWD) ; if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; fallback: errno = e ; return nsss_unix_getpwnam_r(name, pw, buf, buflen, pwp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_end.c0000644000000000000000000000030213314135032015001 0ustar /* ISC license. */ #include #include #include void nsss_unix_end (nsss_unix_t *a) { fd_close(buffer_fd(&a->b)) ; a->b.fd = -1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_setgrent.c0000644000000000000000000000050213314254254016416 0ustar /* ISC license. */ #include #include #include #include "nsss-switch-internal.h" void nsss_switch_setgrent (void) { if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) return ; nsss_switch_grp_rewind(&nsss_switch_here, 0, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_all_getgrent_r.c0000644000000000000000000000230213502707421016170 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" #include "nsss-all-internal.h" int nsss_all_getgrent_r (struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; int e = errno ; if (nsss_all_errno) goto fallback ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) goto efallback ; errno = 0 ; if (!nsss_switch_grp_get(&nsss_switch_here, &gr2, &sa, &ga, 0, 0)) { *grp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; efallback: nsss_all_errno = errno ; errno = e ; fallback: return nsss_unix_getgrent_r(gr, buf, buflen, grp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getspnam_r.c0000644000000000000000000000145113314276750016415 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" int nsss_unix_getspnam_r (char const *name, struct spwd *sp, char *buf, size_t buflen, struct spwd **spp) { struct spwd sp2 ; stralloc sa = STRALLOC_ZERO ; nsss_unix_t a = NSSS_UNIX_ZERO ; int e = errno ; if (!nsss_unix_shadow_start(&a)) return errno ; errno = 0 ; if (!nsss_unix_shadow_getbyname(&a, &sp2, &sa, name)) { nsss_unix_shadow_end(&a) ; *spp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_unix_shadow_end(&a) ; if (!nsss_shadow_copy(sp, buf, buflen, &sp2, sa.s, sa.len)) { stralloc_free(&sa) ; *spp = 0 ; return errno ; } stralloc_free(&sa) ; *spp = sp ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getgrent_r.c0000644000000000000000000000176513502707421016735 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" int nsss_switch_getgrent_r (struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; int e ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) return errno ; e = errno ; errno = 0 ; if (!nsss_switch_grp_get(&nsss_switch_here, &gr2, &sa, &ga, 0, 0)) { *grp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_pwd_rewind.c0000644000000000000000000000036413314247405016733 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" int nsss_switch_pwd_rewind (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp) { return nsss_switch_op(a, NSSS_SWITCH_PWD_REWIND, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_grp_here.c0000644000000000000000000000037313314274265015007 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" struct group nsss_grp_here ; stralloc nsss_grp_sa_here = STRALLOC_ZERO ; genalloc nsss_grp_ga_here = GENALLOC_ZERO ; nsss-0.0.2.1/src/libnsss/nsss_shadow_here.c0000644000000000000000000000027113314274311015471 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" struct spwd nsss_shadow_here ; stralloc nsss_shadow_sa_here = STRALLOC_ZERO ; nsss-0.0.2.1/src/libnsss/nsss_unix_getpwuid_r.c0000644000000000000000000000142413314276727016433 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" int nsss_unix_getpwuid_r (uid_t uid, struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; nsss_unix_t a = NSSS_UNIX_ZERO ; int e = errno ; if (!nsss_unix_pwd_start(&a)) return errno ; errno = 0 ; if (!nsss_unix_pwd_getbyuid(&a, &pw2, &sa, uid)) { nsss_unix_pwd_end(&a) ; *pwp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_unix_pwd_end(&a) ; if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getgrent.c0000644000000000000000000000106113314254140016375 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" struct group *nsss_switch_getgrent (void) { if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) return 0 ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_switch_grp_get(&nsss_switch_here, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here, 0, 0)) return 0 ; return &nsss_grp_here ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getgrgid.c0000644000000000000000000000120713314276566016374 0ustar /* ISC license. */ #include #include #include #include #include "nsss-internal.h" struct group *nsss_switch_getgrgid (gid_t gid) { nsss_switch_t a = NSSS_SWITCH_ZERO ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) return 0 ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_switch_grp_getbygid(&a, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here, gid, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return &nsss_grp_here ; } nsss-0.0.2.1/src/libnsss/nsss_unix_maybe_start.c0000644000000000000000000000031313313743113016553 0ustar /* ISC license. */ #include #include int nsss_unix_maybe_start (nsss_unix_t *a, char const *path) { return buffer_fd(&a->b) >= 0 || nsss_unix_start(a, path) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_grp_getbygid.c0000644000000000000000000000102513314275541016716 0ustar /* ISC license. */ #include #include #include #include int nsss_unix_grp_getbygid (nsss_unix_t *a, struct group *gr, stralloc *sa, genalloc *ga, gid_t gid) { struct group gr2 ; for (;;) { size_t sabase = sa->len ; size_t gabase = genalloc_len(char *, ga) ; if (!nsss_unix_grp_get(a, &gr2, sa, ga)) return 0 ; if (gid == gr2.gr_gid) break ; sa->len = sabase ; genalloc_setlen(char *, ga, gabase) ; } *gr = gr2 ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_all_getgrnam.c0000644000000000000000000000141513314276432015644 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" struct group *nsss_all_getgrnam (char const *name) { nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_switch_grp_getbyname(&a, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return &nsss_grp_here ; fallback: errno = e ; return nsss_unix_getgrnam(name) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_shadow_getbyname.c0000644000000000000000000000172713314252364020115 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_shadow_getbyname (nsss_switch_t *a, struct spwd *sp, stralloc *sa, char const *name, tain_t const *deadline, tain_t *stamp) { char buf[5] = { NSSS_SWITCH_SHADOW_GETBYNAME } ; size_t len = strlen(name) ; struct iovec v[2] = { { .iov_base = buf, .iov_len = 5 }, { .iov_base = (char *)name, .iov_len = len + 1 } } ; if (len > NSSS_SWITCH_NAME_MAXLEN - 1) return (errno = EINVAL, 0) ; uint32_pack_big(buf + 1, len + 1) ; if (!ipc_timed_sendv(buffer_fd(&a->b), v, 2, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &buf[0], 1, deadline, stamp)) return 0 ; if ((unsigned char)buf[0] == 255) return 0 ; if (buf[0]) return (errno = buf[0], 0) ; return nsss_switch_shadow_read(&a->b, sp, sa, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_endpwent.c0000644000000000000000000000023613313706750016077 0ustar /* ISC license. */ #include #include "nsss-unix-internal.h" void nsss_unix_endpwent (void) { nsss_unix_pwd_end(&nsss_unix_pwd_here) ; } nsss-0.0.2.1/src/libnsss/nsss-unix-internal.h0000644000000000000000000000043713314275244015733 0ustar /* ISC license. */ #ifndef NSSS_UNIX_INTERNAL_H #define NSSS_UNIX_INTERNAL_H #include extern int nsss_unix_field (char **, char **) ; extern nsss_unix_t nsss_unix_pwd_here ; extern nsss_unix_t nsss_unix_grp_here ; extern nsss_unix_t nsss_unix_shadow_here ; #endif nsss-0.0.2.1/src/libnsss/nsss_all_getgrgid_r.c0000644000000000000000000000224213502707421016150 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include "nsss-internal.h" int nsss_all_getgrgid_r (gid_t gid, struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; errno = 0 ; if (!nsss_switch_grp_getbygid(&a, &gr2, &sa, &ga, gid, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; *grp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; fallback: errno = e ; return nsss_unix_getgrgid_r(gid, gr, buf, buflen, grp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_setspent.c0000644000000000000000000000041413314031731016105 0ustar /* ISC license. */ #include #include #include "nsss-unix-internal.h" void nsss_unix_setspent (void) { if (!nsss_unix_shadow_maybe_start(&nsss_unix_shadow_here)) return ; nsss_unix_shadow_rewind(&nsss_unix_shadow_here) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_shadow_rewind.c0000644000000000000000000000037213314250430017415 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" int nsss_switch_shadow_rewind (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp) { return nsss_switch_op(a, NSSS_SWITCH_SHADOW_REWIND, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_start.c0000644000000000000000000000045513313715032015404 0ustar /* ISC license. */ #include #include #include int nsss_unix_start (nsss_unix_t *a, char const *path) { int fd = open_readb(path) ; if (fd < 0) return 0 ; buffer_init(&a->b, &buffer_read, fd, a->buf, NSSS_UNIX_BUFSIZE) ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getspnam_r.c0000644000000000000000000000163013314276617016734 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" int nsss_switch_getspnam_r (char const *name, struct spwd *sp, char *buf, size_t buflen, struct spwd **spp) { struct spwd sp2 ; stralloc sa = STRALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_SHADOW, NSSS_NSSSD_PATH, 0, 0)) return errno ; errno = 0 ; if (!nsss_switch_shadow_getbyname(&a, &sp2, &sa, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_SHADOW) ; *spp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_SHADOW) ; if (!nsss_shadow_copy(sp, buf, buflen, &sp2, sa.s, sa.len)) { stralloc_free(&sa) ; *spp = 0 ; return errno ; } stralloc_free(&sa) ; *spp = sp ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_shadow_read.c0000644000000000000000000000334713433016557017061 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include "nsss-switch-internal.h" /* Expects: 8 bytes sp_lstchg 8 bytes sp_min 8 bytes sp_max 8 bytes sp_warn 8 bytes sp_inact 8 bytes sp_expire 8 bytes sp_flag 4 bytes total length of strings (including \0's) \0-terminated sp_namp \0-terminated sp_pwdp */ int nsss_switch_shadow_read (buffer *b, struct spwd *sp, stralloc *sa, tain_t const *deadline, tain_t *stamp) { struct spwd sptmp ; uint64_t x ; uint32_t total, len ; char *p ; char buf[60] ; if (!buffer_timed_get(b, buf, 60, deadline, stamp)) return 0 ; uint64_unpack_big(buf, &x) ; sptmp.sp_lstchg = x ; uint64_unpack_big(buf + 8, &x) ; sptmp.sp_min = x ; uint64_unpack_big(buf + 16, &x) ; sptmp.sp_max = x ; uint64_unpack_big(buf + 24, &x) ; sptmp.sp_warn = x ; uint64_unpack_big(buf + 32, &x) ; sptmp.sp_inact = x ; uint64_unpack_big(buf + 40, &x) ; sptmp.sp_expire = x ; uint64_unpack_big(buf + 48, &x) ; sptmp.sp_flag = x ; uint32_unpack_big(buf + 56, &total) ; if (!stralloc_readyplus(sa, total)) return 0 ; if (!buffer_timed_get(b, sa->s + sa->len, total, deadline, stamp)) return 0 ; if (sa->s[sa->len + total - 1]) return (errno = EPROTO, 0) ; p = sa->s + sa->len ; len = total ; sptmp.sp_namp = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; if (!len) return (errno = EPROTO, 0) ; sptmp.sp_pwdp = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; if (len) return (errno = EPROTO, 0) ; sa->len += total ; *sp = sptmp ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_unix_shadow_here.c0000644000000000000000000000015213313745003016532 0ustar /* ISC license. */ #include "nsss-unix-internal.h" nsss_unix_t nsss_unix_shadow_here = NSSS_UNIX_ZERO ; nsss-0.0.2.1/src/libnsss/nsss_unix_pwd_here.c0000644000000000000000000000014713313745014016045 0ustar /* ISC license. */ #include "nsss-unix-internal.h" nsss_unix_t nsss_unix_pwd_here = NSSS_UNIX_ZERO ; nsss-0.0.2.1/src/libnsss/nsss_unix_pwd_getbyname.c0000644000000000000000000000063013313733242017072 0ustar /* ISC license. */ #include #include #include int nsss_unix_pwd_getbyname (nsss_unix_t *a, struct passwd *pw, stralloc *sa, char const *name) { struct passwd pw2 ; for (;;) { size_t base = sa->len ; if (!nsss_unix_pwd_get(a, &pw2, sa)) return 0 ; if (!strcmp(name, pw2.pw_name)) break ; sa->len = base ; } *pw = pw2 ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_all_getpwent_r.c0000644000000000000000000000201613314271706016213 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" #include "nsss-switch-internal.h" #include "nsss-all-internal.h" int nsss_all_getpwent_r (struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; int e = errno ; if (nsss_all_errno) goto fallback ; if (!nsss_switch_start(&nsss_switch_here, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) goto efallback ; errno = 0 ; if (!nsss_switch_pwd_get(&nsss_switch_here, &pw2, &sa, 0, 0)) { *pwp = 0 ; if (!errno) errno = ENOENT ; return errno ; } if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; efallback: nsss_all_errno = errno ; errno = e ; fallback: return nsss_unix_getpwent_r(pw, buf, buflen, pwp) ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getgrgid_r.c0000644000000000000000000000171013502707421016362 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" int nsss_unix_getgrgid_r (gid_t gid, struct group *gr, char *buf, size_t buflen, struct group **grp) { struct group gr2 ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; nsss_unix_t a = NSSS_UNIX_ZERO ; int e = errno ; if (!nsss_unix_grp_start(&a)) return errno ; errno = 0 ; if (!nsss_unix_grp_getbygid(&a, &gr2, &sa, &ga, gid)) { nsss_unix_grp_end(&a) ; *grp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_unix_grp_end(&a) ; if (!nsss_grp_copy(gr, buf, buflen, &gr2, sa.s, sa.len, genalloc_s(char *, &ga), genalloc_len(char *, &ga))) { genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = 0 ; return errno ; } genalloc_free(char *, &ga) ; stralloc_free(&sa) ; *grp = gr ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_pwd_end.c0000644000000000000000000000035613314247371016214 0ustar /* ISC license. */ #include #include "nsss-switch-internal.h" int nsss_switch_pwd_end (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp) { return nsss_switch_op(a, NSSS_SWITCH_PWD_END, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getpwnam.c0000644000000000000000000000105613314276524016416 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" struct passwd *nsss_switch_getpwnam (char const *name) { nsss_switch_t a = NSSS_SWITCH_ZERO ; if (!nsss_switch_start(&a, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) return 0 ; nsss_pwd_sa_here.len = 0 ; if (!nsss_switch_pwd_getbyname(&a, &nsss_pwd_here, &nsss_pwd_sa_here, name, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_PWD) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_PWD) ; return &nsss_pwd_here ; } nsss-0.0.2.1/src/libnsss/nsss_shadow_copy.c0000644000000000000000000000113213314015541015513 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" int nsss_shadow_copy (struct spwd *sp, char *buf, size_t buflen, struct spwd const *sp2, char const *s, size_t len) { if (len > buflen) return (errno = ERANGE, 0) ; memcpy(buf, s, len) ; sp->sp_namp = buf + (sp2->sp_namp - s) ; sp->sp_pwdp = buf + (sp2->sp_pwdp - s) ; sp->sp_lstchg = sp2->sp_lstchg ; sp->sp_min = sp2->sp_min ; sp->sp_max = sp2->sp_max ; sp->sp_warn = sp2->sp_warn ; sp->sp_inact = sp2->sp_inact ; sp->sp_expire = sp2->sp_expire ; sp->sp_flag = sp2->sp_flag ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getgrouplist.c0000644000000000000000000000142513541510430017311 0ustar /* ISC license. */ #include #include #include #include #include #include #include "nsss-internal.h" int nsss_switch_getgrouplist (char const *user, gid_t gid, gid_t *gids, int *ngids) { stralloc sa = STRALLOC_ZERO ; int e = errno ; size_t r = 0 ; size_t n ; nsss_switch_t a = NSSS_SWITCH_ZERO ; if (*ngids < 0) return (errno = EINVAL, -1) ; n = *ngids ; if (!nsss_switch_start(&a, NSSS_SWITCH_GRP, NSSS_NSSSD_PATH, 0, 0)) return -1 ; if (!nsss_switch_grp_getlist(&a, user, gids, n, &r, &sa, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return -1 ; } nsss_switch_end(&a, NSSS_SWITCH_GRP) ; return nsss_grouplist_adjust(n, r, gid, gids, ngids, e) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_grp_get.c0000644000000000000000000000116113316414662016217 0ustar /* ISC license. */ #include #include #include #include #include "nsss-switch-internal.h" int nsss_switch_grp_get (nsss_switch_t *a, struct group *gr, stralloc *sa, genalloc *ga, tain_t const *deadline, tain_t *stamp) { unsigned char c = NSSS_SWITCH_GRP_GET ; if (!ipc_timed_send(buffer_fd(&a->b), (char *)&c, 1, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, (char *)&c, 1, deadline, stamp)) return 0 ; if (c == 255) return 0 ; if (c) return (errno = c, 0) ; return nsss_switch_grp_read(&a->b, gr, sa, ga, deadline, stamp) ; } nsss-0.0.2.1/src/libnsss/deps-lib/0000755000000000000000000000000013312043105013457 5ustar nsss-0.0.2.1/src/libnsss/deps-lib/nsss0000644000000000000000000000511613541506332014405 0ustar nsss_all_endgrent.o nsss_all_endpwent.o nsss_all_endspent.o nsss_all_errno.o nsss_all_getgrent.o nsss_all_getgrent_r.o nsss_all_getgrgid.o nsss_all_getgrgid_r.o nsss_all_getgrnam.o nsss_all_getgrnam_r.o nsss_all_getgrouplist.o nsss_all_getpwent.o nsss_all_getpwent_r.o nsss_all_getpwnam.o nsss_all_getpwnam_r.o nsss_all_getpwuid.o nsss_all_getpwuid_r.o nsss_all_getspent.o nsss_all_getspent_r.o nsss_all_getspnam.o nsss_all_getspnam_r.o nsss_all_setgrent.o nsss_all_setpwent.o nsss_all_setspent.o nsss_grp_copy.o nsss_grp_here.o nsss_grouplist_adjust.o nsss_pwd_copy.o nsss_pwd_here.o nsss_shadow_copy.o nsss_shadow_here.o nsss_switch_end.o nsss_switch_endgrent.o nsss_switch_endpwent.o nsss_switch_endspent.o nsss_switch_getgrent.o nsss_switch_getgrent_r.o nsss_switch_getgrgid.o nsss_switch_getgrgid_r.o nsss_switch_getgrnam.o nsss_switch_getgrnam_r.o nsss_switch_getgrouplist.o nsss_switch_getpwent.o nsss_switch_getpwent_r.o nsss_switch_getpwnam.o nsss_switch_getpwnam_r.o nsss_switch_getpwuid.o nsss_switch_getpwuid_r.o nsss_switch_getspent.o nsss_switch_getspent_r.o nsss_switch_getspnam.o nsss_switch_getspnam_r.o nsss_switch_grp_end.o nsss_switch_grp_get.o nsss_switch_grp_getbygid.o nsss_switch_grp_getbyname.o nsss_switch_grp_getlist.o nsss_switch_grp_read.o nsss_switch_grp_rewind.o nsss_switch_here.o nsss_switch_op.o nsss_switch_pwd_end.o nsss_switch_pwd_get.o nsss_switch_pwd_getbyname.o nsss_switch_pwd_getbyuid.o nsss_switch_pwd_read.o nsss_switch_pwd_rewind.o nsss_switch_setgrent.o nsss_switch_setpwent.o nsss_switch_setspent.o nsss_switch_shadow_end.o nsss_switch_shadow_get.o nsss_switch_shadow_getbyname.o nsss_switch_shadow_read.o nsss_switch_shadow_rewind.o nsss_switch_start.o nsss_unix_end.o nsss_unix_endgrent.o nsss_unix_endpwent.o nsss_unix_endspent.o nsss_unix_field.o nsss_unix_getgrent.o nsss_unix_getgrent_r.o nsss_unix_getgrgid.o nsss_unix_getgrgid_r.o nsss_unix_getgrnam.o nsss_unix_getgrnam_r.o nsss_unix_getgrouplist.o nsss_unix_getgrouplist_preadjust.o nsss_unix_getpwent.o nsss_unix_getpwent_r.o nsss_unix_getpwnam.o nsss_unix_getpwnam_r.o nsss_unix_getpwuid.o nsss_unix_getpwuid_r.o nsss_unix_getspent.o nsss_unix_getspent_r.o nsss_unix_getspnam.o nsss_unix_getspnam_r.o nsss_unix_grp_get.o nsss_unix_grp_getbygid.o nsss_unix_grp_getbyname.o nsss_unix_grp_getlist.o nsss_unix_grp_here.o nsss_unix_maybe_start.o nsss_unix_pwd_get.o nsss_unix_pwd_getbyname.o nsss_unix_pwd_getbyuid.o nsss_unix_pwd_here.o nsss_unix_rewind.o nsss_unix_setgrent.o nsss_unix_setpwent.o nsss_unix_setspent.o nsss_unix_shadow_get.o nsss_unix_shadow_getbyname.o nsss_unix_shadow_here.o nsss_unix_start.o -lskarnet -lpthread nsss-0.0.2.1/src/libnsss/nsss_unix_getgrgid.c0000644000000000000000000000103013314276772016047 0ustar /* ISC license. */ #include #include #include #include "nsss-internal.h" struct group *nsss_unix_getgrgid (gid_t gid) { nsss_unix_t a = NSSS_UNIX_ZERO ; if (!nsss_unix_grp_start(&a)) return 0 ; nsss_grp_sa_here.len = 0 ; genalloc_setlen(char *, &nsss_grp_ga_here, 0) ; if (!nsss_unix_grp_getbygid(&a, &nsss_grp_here, &nsss_grp_sa_here, &nsss_grp_ga_here, gid)) { nsss_unix_grp_end(&a) ; return 0 ; } nsss_unix_grp_end(&a) ; return &nsss_grp_here ; } nsss-0.0.2.1/src/libnsss/nsss_unix_field.c0000644000000000000000000000034213314275233015332 0ustar /* ISC license. */ #include #include "nsss-unix-internal.h" int nsss_unix_field (char **field, char **s) { char *p = strchr(*s, ':') ; if (!p) return 0 ; *p++ = 0 ; *field = *s ; *s = p ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_switch_pwd_read.c0000644000000000000000000000331713433016521016352 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include "nsss-switch-internal.h" /* Expects: 4 bytes pw_uid 4 bytes pw_gid 4 bytes total length of strings (including \0's) \0-terminated pw_name \0-terminated pw_passwd \0-terminated pw_gecos \0-terminated pw_dir \0-terminated pw_shell */ int nsss_switch_pwd_read (buffer *b, struct passwd *pw, stralloc *sa, tain_t const *deadline, tain_t *stamp) { struct passwd pwtmp ; uint32_t total, len, x ; char *p ; char buf[12] ; if (!buffer_timed_get(b, buf, 12, deadline, stamp)) return 0 ; uint32_unpack_big(buf, &x) ; pwtmp.pw_uid = x ; uint32_unpack_big(buf + 4, &x) ; pwtmp.pw_gid = x ; uint32_unpack_big(buf + 8, &total) ; if (!stralloc_readyplus(sa, total)) return 0 ; if (!buffer_timed_get(b, sa->s + sa->len, total, deadline, stamp)) return 0 ; if (sa->s[sa->len + total - 1]) return (errno = EPROTO, 0) ; p = sa->s + sa->len ; len = total ; pwtmp.pw_name = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; if (!len) return (errno = EPROTO, 0) ; pwtmp.pw_passwd = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; if (!len) return (errno = EPROTO, 0) ; pwtmp.pw_gecos = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; if (!len) return (errno = EPROTO, 0) ; pwtmp.pw_dir = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; if (!len) return (errno = EPROTO, 0) ; pwtmp.pw_shell = p ; x = strnlen(p, len) + 1 ; p += x ; len -= x ; if (len) return (errno = EPROTO, 0) ; sa->len += total ; *pw = pwtmp ; return 1 ; } nsss-0.0.2.1/src/libnsss/nsss_unix_getspnam.c0000644000000000000000000000073013314276743016075 0ustar /* ISC license. */ #include #include #include "nsss-internal.h" struct spwd *nsss_unix_getspnam (char const *name) { nsss_unix_t a = NSSS_UNIX_ZERO ; if (!nsss_unix_shadow_start(&a)) return 0 ; nsss_shadow_sa_here.len = 0 ; if (!nsss_unix_shadow_getbyname(&a, &nsss_shadow_here, &nsss_shadow_sa_here, name)) { nsss_unix_shadow_end(&a) ; return 0 ; } nsss_unix_shadow_end(&a) ; return &nsss_shadow_here ; } nsss-0.0.2.1/src/libnsss/nsss_all_getpwuid.c0000644000000000000000000000124113314276265015671 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" struct passwd *nsss_all_getpwuid (uid_t uid) { nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) goto fallback ; nsss_pwd_sa_here.len = 0 ; if (!nsss_switch_pwd_getbyuid(&a, &nsss_pwd_here, &nsss_pwd_sa_here, uid, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_PWD) ; return 0 ; } nsss_switch_end(&a, NSSS_SWITCH_PWD) ; return &nsss_pwd_here ; fallback: errno = e ; return nsss_unix_getpwuid(uid) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_getpwuid_r.c0000644000000000000000000000160313314276517016745 0ustar /* ISC license. */ #include #include #include #include #include #include "nsss-internal.h" int nsss_switch_getpwuid_r (uid_t uid, struct passwd *pw, char *buf, size_t buflen, struct passwd **pwp) { struct passwd pw2 ; stralloc sa = STRALLOC_ZERO ; nsss_switch_t a = NSSS_SWITCH_ZERO ; int e = errno ; if (!nsss_switch_start(&a, NSSS_SWITCH_PWD, NSSS_NSSSD_PATH, 0, 0)) return errno ; errno = 0 ; if (!nsss_switch_pwd_getbyuid(&a, &pw2, &sa, uid, 0, 0)) { nsss_switch_end(&a, NSSS_SWITCH_PWD) ; *pwp = 0 ; return errno ? errno : (errno = e, 0) ; } nsss_switch_end(&a, NSSS_SWITCH_PWD) ; if (!nsss_pwd_copy(pw, buf, buflen, &pw2, sa.s, sa.len)) { stralloc_free(&sa) ; *pwp = 0 ; return errno ; } stralloc_free(&sa) ; *pwp = pw ; return (errno = e, 0) ; } nsss-0.0.2.1/src/libnsss/nsss_switch_grp_getlist.c0000644000000000000000000000417413541510501017107 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include /* Expects: 8 bytes: n 8 bytes: r min(n, r) * sizeof(gid_t) bytes: the list of gids */ static int nsss_switch_grouplist_read (buffer *b, size_t n, size_t *r, gid_t *gids, stralloc *sa, tain_t const *deadline, tain_t *stamp) { size_t rr ; uint64_t res ; char buf[8] ; if (!buffer_timed_get(b, buf, 8, deadline, stamp)) return 0 ; uint64_unpack_big(buf, &res) ; if (res != n) return (errno = EPROTO, 0) ; if (!buffer_timed_get(b, buf, 8, deadline, stamp)) return 0 ; uint64_unpack_big(buf, &res) ; rr = res ; if (res > n) res = n ; if (res) { int sawasnull = !sa->s ; size_t sabase = sa->len ; if (!stralloc_readyplus(sa, res * sizeof(gid_t))) return 0 ; if (!buffer_timed_get(b, sa->s + sabase, res * sizeof(gid_t), deadline, stamp)) { if (sawasnull) stralloc_free(sa) ; else sa->len = sabase ; return 0 ; } for (size_t i = 0 ; i < res ; i++) gid_unpack_big(sa->s + sabase + i * sizeof(gid_t), gids + i) ; if (sawasnull) stralloc_free(sa) ; else sa->len = sabase ; } *r = rr ; return 1 ; } int nsss_switch_grp_getlist (nsss_switch_t *a, char const *user, gid_t *gids, size_t n, size_t *r, stralloc *sa, tain_t const *deadline, tain_t *stamp) { char buf[13] = { NSSS_SWITCH_GRP_GETLIST } ; size_t len = strlen(user) ; struct iovec v[2] = { { .iov_base = buf, .iov_len = 13 }, { .iov_base = (char *)user, .iov_len = len + 1 } } ; if (len > NSSS_SWITCH_NAME_MAXLEN - 1) return (errno = EINVAL, 0) ; uint64_pack_big(buf + 1, n) ; uint32_pack_big(buf + 9, len + 1) ; if (!ipc_timed_sendv(buffer_fd(&a->b), v, 2, deadline, stamp)) return 0 ; if (!buffer_timed_get(&a->b, &buf[0], 1, deadline, stamp)) return 0 ; if (buf[0]) return (errno = buf[0], 0) ; return nsss_switch_grouplist_read(&a->b, n, r, gids, sa, deadline, stamp) ; } nsss-0.0.2.1/src/nsssd/0000755000000000000000000000000013541512070011443 5ustar nsss-0.0.2.1/src/nsssd/nsssd-nslcd.h0000644000000000000000000000120613312312257014047 0ustar /* ISC license. */ #ifndef NSSSD_NSLCD_H #define NSSSD_NSLCD_H /* Taken from nslcd.h */ #define NSLCD_VERSION 0x00000002 #define NSLCD_ACTION_PASSWD_BYNAME 0x00080001 #define NSLCD_ACTION_PASSWD_BYUID 0x00080002 #define NSLCD_ACTION_PASSWD_ALL 0x00080008 #define NSLCD_ACTION_GROUP_BYNAME 0x00040001 #define NSLCD_ACTION_GROUP_BYGID 0x00040002 #define NSLCD_ACTION_GROUP_BYMEMBER 0x00040006 #define NSLCD_ACTION_GROUP_ALL 0x00040008 #define NSLCD_ACTION_SHADOW_BYNAME 0x000c0001 #define NSLCD_ACTION_SHADOW_ALL 0x000c0008 #define NSLCD_RESULT_BEGIN 1 #define NSLCD_RESULT_END 2 #endif nsss-0.0.2.1/src/nsssd/nsssd_main.c0000644000000000000000000002551413541511267013763 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static unsigned int initted = 0 ; static void get0 (char *s, size_t n) { tain_t deadline ; tain_ulong(&deadline, 30) ; tain_add_g(&deadline, &deadline) ; if (buffer_timed_get_g(buffer_0small, s, n, &deadline) < n) strerr_diefu1sys(111, "read from stdin") ; } static void put1 (char const *s, size_t n) { size_t w = 0 ; tain_t deadline ; tain_ulong(&deadline, 30) ; tain_add_g(&deadline, &deadline) ; while (!buffer_putall(buffer_1, s, n, &w)) { if (!buffer_timed_flush_g(buffer_1, &deadline)) strerr_diefu1sys(111, "write to stdout") ; } } static void flush1 (void) { tain_t deadline ; tain_ulong(&deadline, 2) ; tain_add_g(&deadline, &deadline) ; if (!buffer_timed_flush_g(buffer_1, &deadline)) strerr_diefu1sys(111, "write to stdout") ; } static void answer (int e) { unsigned char c = e ; buffer_putnoflush(buffer_1, (char *)&c, 1) ; flush1() ; } static inline void print_pw (struct passwd const *pw) { size_t len, namelen, passwdlen, gecoslen, dirlen, shelllen ; char pack[12] ; namelen = strlen(pw->pw_name) + 1 ; passwdlen = strlen(pw->pw_passwd) + 1 ; gecoslen = strlen(pw->pw_gecos) + 1 ; dirlen = strlen(pw->pw_dir) + 1 ; shelllen = strlen(pw->pw_shell) + 1 ; len = namelen + passwdlen + gecoslen + dirlen + shelllen ; if (len > 0xffffffff) { answer(ENAMETOOLONG) ; return ; } put1("", 1) ; uint32_pack_big(pack, pw->pw_uid) ; uint32_pack_big(pack + 4, pw->pw_gid) ; uint32_pack_big(pack + 8, len) ; put1(pack, 12) ; put1(pw->pw_name, namelen) ; put1(pw->pw_passwd, passwdlen) ; put1(pw->pw_gecos, gecoslen) ; put1(pw->pw_dir, dirlen) ; put1(pw->pw_shell, shelllen) ; flush1() ; } static inline void print_gr (struct group const *gr) { size_t len, namelen, passwdlen ; size_t n = 0 ; char pack[12] ; namelen = strlen(gr->gr_name) + 1 ; passwdlen = strlen(gr->gr_passwd) + 1 ; len = namelen + passwdlen ; for (char **p = gr->gr_mem ; *p ; n++, p++) len += strlen(*p) + 1 ; if (len > 0xffffffffu || n > 0x30000000u) { answer(ENAMETOOLONG) ; return ; } put1("", 1) ; uint32_pack_big(pack, gr->gr_gid) ; uint32_pack_big(pack + 4, len) ; uint32_pack_big(pack + 8, n) ; put1(pack, 12) ; put1(gr->gr_name, namelen) ; put1(gr->gr_passwd, passwdlen) ; for (size_t i = 0 ; i < n ; i++) put1(gr->gr_mem[i], strlen(gr->gr_mem[i]) + 1) ; flush1() ; } static inline void print_sp (struct spwd const *sp) { size_t len, namplen, pwdplen ; char pack[60] ; namplen = strlen(sp->sp_namp) + 1 ; pwdplen = strlen(sp->sp_pwdp) + 1 ; len = namplen + pwdplen ; if (len > 0xffffffff) { answer(ENAMETOOLONG) ; return ; } put1("", 1) ; uint64_pack_big(pack, sp->sp_lstchg) ; uint64_pack_big(pack + 8, sp->sp_min) ; uint64_pack_big(pack + 16, sp->sp_max) ; uint64_pack_big(pack + 24, sp->sp_warn) ; uint64_pack_big(pack + 32, sp->sp_inact) ; uint64_pack_big(pack + 40, sp->sp_expire) ; uint64_pack_big(pack + 48, sp->sp_flag) ; uint32_pack_big(pack + 56, len) ; put1(pack, 60) ; put1(sp->sp_namp, namplen) ; put1(sp->sp_pwdp, pwdplen) ; flush1() ; } static inline void do_pwend (void *a) { nsssd_pwd_end(a) ; answer(0) ; } static inline void do_pwrewind (void *a) { if (!(initted & 1)) { if (!nsssd_pwd_start(a)) { answer(errno) ; return ; } initted |= 1 ; } if (!nsssd_pwd_rewind(a)) { answer(errno) ; return ; } answer(0) ; } static inline void do_pwget (void *a) { struct passwd pw ; if (!(initted & 1)) { if (!nsssd_pwd_start(a)) { answer(errno ? errno : NSSSD_EOF) ; return ; } initted |= 1 ; } if (!nsssd_pwd_get(a, &pw)) { answer(errno ? errno : NSSSD_EOF) ; return ; } print_pw(&pw) ; } static inline void do_pwnam (void *a) { struct passwd pw ; uint32_t len ; char buf[4] ; get0(buf, 4) ; uint32_unpack_big(buf, &len) ; if (!len || len > NSSS_SWITCH_NAME_MAXLEN - 1) { answer(EPROTO) ; return ; } { char name[len] ; get0(name, len) ; if (name[len-1]) { answer(EPROTO) ; return ; } if (!nsssd_pwd_getbyname(a, &pw, name)) { answer(errno ? errno : NSSSD_EOF) ; return ; } } print_pw(&pw) ; } static inline void do_pwuid (void *a) { struct passwd pw ; uint32_t uid ; char buf[4] ; get0(buf, 4) ; uint32_unpack_big(buf, &uid) ; if (!nsssd_pwd_getbyuid(a, &pw, uid)) { answer(errno ? errno : NSSSD_EOF) ; return ; } print_pw(&pw) ; } static inline void do_grend (void *a) { nsssd_grp_end(a) ; answer(0) ; } static inline void do_grrewind (void *a) { if (!(initted & 2)) { if (!nsssd_grp_start(a)) { answer(errno) ; return ; } initted |= 2 ; } if (!nsssd_grp_rewind(a)) { answer(errno) ; return ; } answer(0) ; } static inline void do_grget (void *a) { struct group gr ; if (!(initted & 2)) { if (!nsssd_grp_start(a)) { answer(errno) ; return ; } initted |= 2 ; } if (!nsssd_grp_get(a, &gr)) { answer(errno ? errno : NSSSD_EOF) ; return ; } print_gr(&gr) ; } static inline void do_grnam (void *a) { struct group gr ; uint32_t len ; char buf[4] ; get0(buf, 4) ; uint32_unpack_big(buf, &len) ; if (!len || len > NSSS_SWITCH_NAME_MAXLEN - 1) { answer(EPROTO) ; return ; } { char name[len] ; get0(name, len) ; if (name[len-1]) { answer(EPROTO) ; return ; } if (!nsssd_grp_getbyname(a, &gr, name)) { answer(errno ? errno : NSSSD_EOF) ; return ; } } print_gr(&gr) ; } static inline void do_grgid (void *a) { struct group gr ; uint32_t gid ; char buf[4] ; get0(buf, 4) ; uint32_unpack_big(buf, &gid) ; if (!nsssd_grp_getbygid(a, &gr, gid)) { answer(errno ? errno : NSSSD_EOF) ; return ; } print_gr(&gr) ; } static inline void do_grlist (void *a) { uint64_t n ; uint32_t len ; char buf[12] ; get0(buf, 12) ; uint64_unpack_big(buf, &n) ; uint32_unpack_big(buf + 8, &len) ; if (!len || len > NSSS_SWITCH_NAME_MAXLEN - 1) { answer(EPROTO) ; return ; } { genalloc ga = GENALLOC_ZERO ; size_t r ; char user[len] ; get0(user, len) ; if (user[len-1]) { answer(EPROTO) ; return ; } if (!genalloc_ready(gid_t, &ga, n)) { answer(errno) ; return ; } if (!nsssd_grp_getlist(a, user, genalloc_s(gid_t, &ga), n, &r)) { genalloc_free(gid_t, &ga) ; answer(errno) ; return ; } put1("", 1) ; uint64_pack_big(buf, n) ; put1(buf, 8) ; uint64_pack_big(buf, r) ; put1(buf, 8) ; if (r > n) r = n ; for (size_t i = 0 ; i < r ; i++) { gid_pack_big(buf, genalloc_s(gid_t, &ga)[i]) ; put1(buf, sizeof(gid_t)) ; } genalloc_free(gid_t, &ga) ; } flush1() ; } static inline void do_spend (void *a) { nsssd_shadow_end(a) ; answer(0) ; } static inline void do_sprewind (void *a) { if (!(initted & 4)) { if (!nsssd_shadow_start(a)) { answer(errno) ; return ; } initted |= 4 ; } if (!nsssd_shadow_rewind(a)) { answer(errno) ; return ; } answer(0) ; } static inline void do_spget (void *a) { struct spwd sp ; if (!(initted & 4)) { if (!nsssd_shadow_start(a)) { answer(errno) ; return ; } initted |= 4 ; } if (!nsssd_shadow_get(a, &sp)) { answer(errno ? errno : NSSSD_EOF) ; return ; } print_sp(&sp) ; } static inline void do_spnam (void *a) { struct spwd sp ; uint32_t len ; char buf[4] ; get0(buf, 4) ; uint32_unpack_big(buf, &len) ; if (!len || len > NSSS_SWITCH_NAME_MAXLEN - 1) { answer(EPROTO) ; return ; } { char name[len] ; get0(name, len) ; if (name[len-1]) { answer(EPROTO) ; return ; } if (!nsssd_shadow_getbyname(a, &sp, name)) { answer(errno ? errno : NSSSD_EOF) ; return ; } } print_sp(&sp) ; } int nsssd_main (char const *const *argv, char const *const *envp) { void *a ; /* If root, drop privileges to the client's, because shadow */ if (!geteuid()) { uid_t uid ; gid_t gid ; char const *x = getenv("IPCREMOTEEGID") ; if (!x) strerr_dienotset(100, "IPCREMOTEEGID") ; if (!gid0_scan(x, &gid)) strerr_dieinvalid(100, "IPCREMOTEEGID") ; if (setgid(gid) == -1) strerr_diefu2sys(111, "setgid to ", x) ; x = getenv("IPCREMOTEEUID") ; if (!x) strerr_dienotset(100, "IPCREMOTEEUID") ; if (!uid0_scan(x, &uid)) strerr_dieinvalid(100, "IPCREMOTEEUID") ; if (setuid(uid) == -1) strerr_diefu2sys(111, "setuid to ", x) ; } tain_now_set_stopwatch_g() ; a = nsssd_handle_init() ; if (ndelay_on(0) < 0) strerr_diefu1sys(111, "set stdin non-blocking") ; tain_now_g() ; if (!nsssd_handle_start(a, argv, envp)) strerr_diefu1sys(111, "nsssd_handle_start") ; for (;;) { tain_t deadline ; char c ; tain_add_g(&deadline, &tain_infinite_relative) ; if (!buffer_timed_get_g(buffer_0small, &c, 1, &deadline)) break ; errno = 0 ; switch (c) { case NSSS_SWITCH_PWD_END : do_pwend(a) ; break ; case NSSS_SWITCH_PWD_REWIND : do_pwrewind(a) ; break ; case NSSS_SWITCH_PWD_GET : do_pwget(a) ; break ; case NSSS_SWITCH_PWD_GETBYNAME : do_pwnam(a) ; break ; case NSSS_SWITCH_PWD_GETBYUID : do_pwuid(a) ; break ; case NSSS_SWITCH_GRP_END : do_grend(a) ; break ; case NSSS_SWITCH_GRP_REWIND : do_grrewind(a) ; break ; case NSSS_SWITCH_GRP_GET : do_grget(a) ; break ; case NSSS_SWITCH_GRP_GETBYNAME : do_grnam(a) ; break ; case NSSS_SWITCH_GRP_GETBYGID : do_grgid(a) ; break ; case NSSS_SWITCH_GRP_GETLIST : do_grlist(a) ; break ; case NSSS_SWITCH_SHADOW_END : do_spend(a) ; break ; case NSSS_SWITCH_SHADOW_REWIND : do_sprewind(a) ; break ; case NSSS_SWITCH_SHADOW_GET : do_spget(a) ; break ; case NSSS_SWITCH_SHADOW_GETBYNAME : do_spnam(a) ; break ; default : errno = EPROTO ; strerr_diefu1sys(1, "interpret stdin") ; } } nsssd_handle_end(a) ; return 0 ; } nsss-0.0.2.1/src/nsssd/nsssd-unix.c0000644000000000000000000000602113541506750013731 0ustar /* ISC license. */ #include #include #include #include #include void *nsssd_handle_init (void) { return 0 ; } int nsssd_handle_start (void *handle, char const *const *argv, char const *const *envp) { (void)handle ; (void)argv ; (void)envp ; return 1 ; } void nsssd_handle_end (void *handle) { (void)handle ; } int nsssd_pwd_start (void *handle) { (void)handle ; return 1 ; } int nsssd_pwd_rewind (void *handle) { nsss_unix_setpwent() ; (void)handle ; return 1 ; } int nsssd_pwd_get (void *handle, struct passwd *pw) { struct passwd *pw2 = nsss_unix_getpwent() ; if (!pw2) return 0 ; *pw = *pw2 ; (void)handle ; return 1 ; } int nsssd_pwd_getbyuid (void *handle, struct passwd *pw, uid_t uid) { struct passwd *pw2 = nsss_unix_getpwuid(uid) ; if (!pw2) return 0 ; *pw = *pw2 ; (void)handle ; return 1 ; } int nsssd_pwd_getbyname (void *handle, struct passwd *pw, char const *name) { struct passwd *pw2 = nsss_unix_getpwnam(name) ; if (!pw2) return 0 ; *pw = *pw2 ; (void)handle ; return 1 ; } void nsssd_pwd_end (void *handle) { nsss_unix_endpwent() ; (void)handle ; } void nsssd_grp_handle_init (void *handle) { (void)handle ; } int nsssd_grp_start (void *handle) { (void)handle ; return 1 ; } int nsssd_grp_rewind (void *handle) { nsss_unix_setgrent() ; (void)handle ; return 1 ; } int nsssd_grp_get (void *handle, struct group *gr) { struct group *gr2 = nsss_unix_getgrent() ; if (!gr2) return 0 ; *gr = *gr2 ; (void)handle ; return 1 ; } int nsssd_grp_getbygid (void *handle, struct group *gr, gid_t gid) { struct group *gr2 = nsss_unix_getgrgid(gid) ; if (!gr2) return 0 ; *gr = *gr2 ; (void)handle ; return 1 ; } int nsssd_grp_getbyname (void *handle, struct group *gr, char const *name) { struct group *gr2 = nsss_unix_getgrnam(name) ; if (!gr2) return 0 ; *gr = *gr2 ; (void)handle ; return 1 ; } int nsssd_grp_getlist (void *handle, char const *user, gid_t *gids, size_t n, size_t *r) { (void)handle ; return nsss_unix_getgrouplist_preadjust(user, gids, n, r) ; } void nsssd_grp_end (void *handle) { nsss_unix_endgrent() ; (void)handle ; } void nsssd_shadow_handle_init (void *handle) { (void)handle ; } int nsssd_shadow_start (void *handle) { (void)handle ; return 1 ; } int nsssd_shadow_rewind (void *handle) { nsss_unix_setspent() ; (void)handle ; return 1 ; } int nsssd_shadow_get (void *handle, struct spwd *sp) { struct spwd *sp2 = nsss_unix_getspent() ; if (!sp2) return 0 ; *sp = *sp2 ; (void)handle ; return 1 ; } int nsssd_shadow_getbyname (void *handle, struct spwd *sp, char const *name) { struct spwd *sp2 = nsss_unix_getspnam(name) ; if (!sp2) return 0 ; *sp = *sp2 ; (void)handle ; return 1 ; } void nsssd_shadow_end (void *handle) { nsss_unix_endspent() ; (void)handle ; } int main (int argc, char const *const *argv, char const *const *envp) { PROG = "nsssd-unix" ; return nsssd_main(argv+1, envp) ; } nsss-0.0.2.1/src/nsssd/deps-exe/0000755000000000000000000000000013313300404013146 5ustar nsss-0.0.2.1/src/nsssd/deps-exe/nsssd-nslcd0000644000000000000000000000002613313300413015322 0ustar ${LIBNSSSD} -lskarnet nsss-0.0.2.1/src/nsssd/deps-exe/nsssd-unix0000644000000000000000000000004113314300107015200 0ustar ${LIBNSSS} ${LIBNSSSD} -lskarnet nsss-0.0.2.1/src/nsssd/nsssd-nslcd.c0000644000000000000000000004124213541507643014057 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "nsssd-nslcd.h" #define USAGE "nsssd-nslcd [ -t timeout ] path-to-nslcd-socket" #define dieusage() strerr_dieusage(100, USAGE) typedef struct nslcd_handle_s nslcd_handle_t, *nslcd_handle_t_ref ; struct nslcd_handle_s { char const *socketpath ; genalloc entries[3] ; /* nsss_passwd_t, nsss_group_t, nsss_spwd_t */ stralloc data[3] ; size_t head[3] ; genalloc grmemc ; /* size_t */ genalloc grmem ; /* char * */ size_t grhead ; unsigned int needdata ; } ; #define NSLCD_HANDLE_ZERO \ { \ .socketpath = 0, \ .entries = { GENALLOC_ZERO, GENALLOC_ZERO, GENALLOC_ZERO }, \ .data = { STRALLOC_ZERO, STRALLOC_ZERO, STRALLOC_ZERO }, \ .head = { 0, 0, 0 }, \ .grmemc = GENALLOC_ZERO, \ .grmem = GENALLOC_ZERO, \ .grhead = 0, \ .needdata = 0 \ } static tain_t tto = TAIN_INFINITE_RELATIVE ; void *nsssd_handle_init (void) { static nslcd_handle_t a = NSLCD_HANDLE_ZERO ; return &a ; } int nsssd_handle_start (void *handle, char const *const *argv, char const *const *envp) { nslcd_handle_t *a = handle ; if (!argv[0]) strerr_dieusage(100, USAGE) ; a->socketpath = argv[0] ; return 1 ; } void nsssd_handle_end (void *handle) { static const nslcd_handle_t nslcd_handle_zero = NSLCD_HANDLE_ZERO ; nslcd_handle_t *a = handle ; genalloc_free(nsssd_passwd_t, &a->entries[0]) ; genalloc_free(nsssd_group_t, &a->entries[1]) ; genalloc_free(nsssd_spwd_t, &a->entries[2]) ; stralloc_free(&a->data[0]) ; stralloc_free(&a->data[1]) ; stralloc_free(&a->data[2]) ; genalloc_free(size_t, &a->grmemc) ; genalloc_free(char *, &a->grmem) ; *a = nslcd_handle_zero ; } static int read_uint32 (buffer *b, uint32_t *x, tain_t const *deadline) { char pack[4] ; if (buffer_timed_get_g(b, pack, 4, deadline) < 4) return 0 ; uint32_unpack_big(pack, x) ; return 1 ; } static int read_string (buffer *b, size_t *value, stralloc *sa, tain_t const *deadline) { uint32_t len ; if (!read_uint32(b, &len, deadline)) return 0 ; if (!stralloc_readyplus(sa, len+1)) return 0 ; if (buffer_timed_get_g(b, sa->s + sa->len, len, deadline) < len) return 0 ; *value = sa->len ; sa->len += len ; sa->s[sa->len++] = 0 ; return 1 ; } static inline int read_stringlist (buffer *b, size_t *head, size_t *n, stralloc *sa, genalloc *ga, tain_t const *deadline) { uint32_t i ; size_t *p ; if (!read_uint32(b, &i, deadline)) return 0 ; if (!genalloc_readyplus(size_t, ga, i)) return 0 ; *head = genalloc_len(size_t, ga) ; p = genalloc_s(size_t, ga) + *head ; *n = i ; while (i--) if (!read_string(b, p++, sa, deadline)) return 0 ; return 1 ; } static inline int read_header (buffer *b, uint32_t action, tain_t const *deadline) { uint32_t x ; char pack[8] ; if (buffer_timed_get_g(b, pack, 8, deadline) < 8) return 0 ; uint32_unpack_big(pack, &x) ; if (x != NSLCD_VERSION) return (errno = EPROTO, 0) ; uint32_unpack_big(pack+4, &x) ; if (x != action) return (errno = EPROTO, 0) ; return 1 ; } static int read_beginend (buffer *b, tain_t const *deadline) { uint32_t x ; if (!read_uint32(b, &x, deadline)) return -1 ; switch (x) { case NSLCD_RESULT_BEGIN : return 1 ; case NSLCD_RESULT_END : return 0 ; default : return (errno = EPROTO, -1) ; } } static int read_eof (buffer *b, tain_t const *deadline) { char c ; ssize_t r = buffer_timed_get_g(b, &c, 1, deadline) ; if (r < 0) return 0 ; if (r) return (errno = EPROTO, 0) ; return 1 ; } static int read_endeof(buffer *b, tain_t const *deadline) { int r = read_beginend(b, deadline) ; if (r < 0) return 0 ; if (r) return (errno = EPROTO, 0) ; return read_eof(b, deadline) ; } static int read_pw (buffer *b, nsssd_passwd_t *pw, stralloc *sa, tain_t const *deadline) { uint32_t x ; if (!read_string(b, &pw->pw_name, sa, deadline)) return 0 ; if (!read_string(b, &pw->pw_passwd, sa, deadline)) return 0 ; if (!read_uint32(b, &x, deadline)) return 0 ; pw->pw_uid = x ; if (!read_uint32(b, &x, deadline)) return 0 ; pw->pw_gid = x ; if (!read_string(b, &pw->pw_gecos, sa, deadline)) return 0 ; if (!read_string(b, &pw->pw_dir, sa, deadline)) return 0 ; if (!read_string(b, &pw->pw_shell, sa, deadline)) return 0 ; return 1 ; } static int read_gr (buffer *b, nsssd_group_t *gr, stralloc *sa, genalloc *ga, tain_t const *deadline) { uint32_t x ; if (!read_string(b, &gr->gr_name, sa, deadline)) return 0 ; if (!read_string(b, &gr->gr_passwd, sa, deadline)) return 0 ; if (!read_uint32(b, &x, deadline)) return 0 ; gr->gr_gid = x ; if (!read_stringlist(b, &gr->gr_mem, &gr->gr_mem_n, sa, ga, deadline)) return 0 ; return 1 ; } static int read_sp (buffer *b, nsssd_spwd_t *sp, stralloc *sa, tain_t const *deadline) { uint32_t x ; if (!read_string(b, &sp->sp_namp, sa, deadline)) return 0 ; if (!read_string(b, &sp->sp_pwdp, sa, deadline)) return 0 ; if (!read_uint32(b, &x, deadline)) return 0 ; sp->sp_lstchg = x ; if (!read_uint32(b, &x, deadline)) return 0 ; sp->sp_min = x ; if (!read_uint32(b, &x, deadline)) return 0 ; sp->sp_max = x ; if (!read_uint32(b, &x, deadline)) return 0 ; sp->sp_warn = x ; if (!read_uint32(b, &x, deadline)) return 0 ; sp->sp_inact = x ; if (!read_uint32(b, &x, deadline)) return 0 ; sp->sp_expire = x ; if (!read_uint32(b, &x, deadline)) return 0 ; sp->sp_flag = x ; return 1 ; } static int nslcd_connect (nslcd_handle_t *a, uint32_t action, struct iovec const *v, unsigned int n, tain_t const *deadline) { char pack[8] ; int fd = ipc_stream_nbcoe() ; struct iovec vv[n+1] ; if (fd < 0) return 0 ; vv[0].iov_base = pack ; vv[0].iov_len = 8 ; for (unsigned int i = 0 ; i < n ; i++) vv[i+1] = v[i] ; if (!ipc_timed_connect_g(fd, a->socketpath, deadline)) goto err ; uint32_pack_big(pack, NSLCD_VERSION) ; uint32_pack_big(pack + 4, action) ; if (!ipc_timed_sendv_g(fd, vv, n+1, deadline)) goto err ; if (shutdown(fd, SHUT_WR) < 0) goto err ; return fd ; err: fd_close(fd) ; return -1 ; } int nsssd_pwd_start (void *handle) { nslcd_handle_t *a = handle ; a->head[0] = 0 ; a->needdata |= 1 ; return 1 ; } int nsssd_pwd_rewind (void *handle) { nslcd_handle_t *a = handle ; a->head[0] = 0 ; a->needdata |= 1 ; return 1 ; } static inline int pwd_getall (nslcd_handle_t *a) { tain_t deadline ; int fd ; buffer b ; char buf[8192] ; tain_add_g(&deadline, &tto) ; fd = nslcd_connect(a, NSLCD_ACTION_PASSWD_ALL, 0, 0, &deadline) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 8192) ; if (!read_header(&b, NSLCD_ACTION_PASSWD_ALL, &deadline)) goto err ; genalloc_setlen(nsssd_passwd_t, &a->entries[0], 0) ; a->data[0].len = 0 ; for (;;) { int r = read_beginend(&b, &deadline) ; if (r < 0) goto err ; if (!r) break ; if (!genalloc_readyplus(nsssd_passwd_t, &a->entries[0], 1)) goto err ; if (!read_pw(&b, genalloc_s(nsssd_passwd_t, &a->entries[0]) + genalloc_len(nsssd_passwd_t, &a->entries[0]), &a->data[0], &deadline)) goto err ; genalloc_setlen(nsssd_passwd_t, &a->entries[0], genalloc_len(nsssd_passwd_t, &a->entries[0]) + 1) ; } if (!read_eof(&b, &deadline)) goto err ; fd_close(fd) ; return 1 ; err: fd_close(fd) ; return 0 ; } int nsssd_pwd_get (void *handle, struct passwd *pw) { nslcd_handle_t *a = handle ; if (a->needdata & 1) { if (!pwd_getall(a)) return 0 ; a->needdata &= ~1 ; } if (a->head[0] >= genalloc_len(nsssd_passwd_t, &a->entries[0])) return 0 ; nsssd_passwd_convert(pw, genalloc_s(nsssd_passwd_t, &a->entries[0]) + a->head[0]++, a->data[0].s) ; return 1 ; } int nsssd_pwd_getbyuid (void *handle, struct passwd *pw, uid_t uid) { nslcd_handle_t *a = handle ; nsssd_passwd_t pwc ; tain_t deadline ; int fd ; buffer b ; char buf[4096] ; struct iovec v = { .iov_base = buf, .iov_len = 4 } ; tain_add_g(&deadline, &tto) ; uint32_pack_big(buf, uid) ; fd = nslcd_connect(a, NSLCD_ACTION_PASSWD_BYUID, &v, 1, &deadline) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 4096) ; if (!read_header(&b, NSLCD_ACTION_PASSWD_BYUID, &deadline)) goto err ; if (read_beginend(&b, &deadline) <= 0) goto err ; a->data[0].len = 0 ; if (!read_pw(&b, &pwc, &a->data[0], &deadline)) goto err ; if (!read_endeof(&b, &deadline)) goto err ; fd_close(fd) ; nsssd_passwd_convert(pw, &pwc, a->data[0].s) ; return 1 ; err: fd_close(fd) ; return 0 ; } int nsssd_pwd_getbyname (void *handle, struct passwd *pw, char const *name) { nslcd_handle_t *a = handle ; nsssd_passwd_t pwc ; tain_t deadline ; int fd ; buffer b ; char buf[4096] ; struct iovec v[2] = { { .iov_base = buf, .iov_len = 4 }, { .iov_base = (char *)name, .iov_len = strlen(name) } } ; tain_add_g(&deadline, &tto) ; fd = nslcd_connect(a, NSLCD_ACTION_PASSWD_BYNAME, v, 2, &deadline) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 4096) ; if (!read_header(&b, NSLCD_ACTION_PASSWD_BYNAME, &deadline)) goto err ; if (read_beginend(&b, &deadline) <= 0) goto err ; a->data[0].len = 0 ; if (!read_pw(&b, &pwc, &a->data[0], &deadline)) goto err ; if (!read_endeof(&b, &deadline)) goto err ; fd_close(fd) ; nsssd_passwd_convert(pw, &pwc, a->data[0].s) ; return 1 ; err: fd_close(fd) ; return 0 ; } void nsssd_pwd_end (void *handle) { } int nsssd_grp_start (void *handle) { nslcd_handle_t *a = handle ; a->head[1] = 0 ; a->grhead = 0 ; a->needdata |= 2 ; return 1 ; } int nsssd_grp_rewind (void *handle) { nslcd_handle_t *a = handle ; a->head[1] = 0 ; a->grhead = 0 ; a->needdata |= 2 ; return 1 ; } static inline int grp_getall (nslcd_handle_t *a) { tain_t deadline ; int fd ; buffer b ; char buf[8192] ; tain_add_g(&deadline, &tto) ; fd = nslcd_connect(a, NSLCD_ACTION_GROUP_ALL, 0, 0, &deadline) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 8192) ; if (!read_header(&b, NSLCD_ACTION_GROUP_ALL, &deadline)) goto err ; genalloc_setlen(nsssd_group_t, &a->entries[1], 0) ; a->data[1].len = 0 ; genalloc_setlen(size_t, &a->grmemc, 0) ; for (;;) { int r = read_beginend(&b, &deadline) ; if (r < 0) goto err ; if (!r) break ; if (!genalloc_readyplus(nsssd_group_t, &a->entries[1], 1)) goto err ; if (!read_gr(&b, genalloc_s(nsssd_group_t, &a->entries[1]) + genalloc_len(nsssd_group_t, &a->entries[1]), &a->data[1], &a->grmemc, &deadline)) goto err ; genalloc_setlen(nsssd_group_t, &a->entries[1], genalloc_len(nsssd_group_t, &a->entries[1]) + 1) ; } if (!read_eof(&b, &deadline)) goto err ; fd_close(fd) ; return 1 ; err: fd_close(fd) ; return 0 ; } int nsssd_grp_get (void *handle, struct group *gr) { nslcd_handle_t *a = handle ; nsssd_group_t *grc ; if (a->needdata & 2) { if (!grp_getall(a)) return 0 ; a->needdata &= ~2 ; } if (a->head[1] >= genalloc_len(nsssd_group_t, &a->entries[1])) return 0 ; grc = genalloc_s(nsssd_group_t, &a->entries[1]) + a->head[1]++ ; if (!genalloc_ready(char *, &a->grmem, grc->gr_mem_n + 1)) return 0 ; nsssd_group_convert(gr, genalloc_s(char *, &a->grmem), grc, a->data[1].s, genalloc_s(size_t, &a->grmemc) + a->grhead) ; a->grhead += grc->gr_mem_n ; return 1 ; } int nsssd_grp_getbygid (void *handle, struct group *gr, gid_t gid) { nslcd_handle_t *a = handle ; nsssd_group_t grc ; tain_t deadline ; int fd ; buffer b ; char buf[4096] ; struct iovec v = { .iov_base = buf, .iov_len = 4 } ; tain_add_g(&deadline, &tto) ; uint32_pack_big(buf, gid) ; fd = nslcd_connect(a, NSLCD_ACTION_GROUP_BYGID, &v, 1, &deadline) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 4096) ; if (!read_header(&b, NSLCD_ACTION_GROUP_BYGID, &deadline)) goto err ; if (read_beginend(&b, &deadline) <= 0) goto err ; a->data[1].len = 0 ; genalloc_setlen(size_t, &a->grmemc, 0) ; if (!read_gr(&b, &grc, &a->data[1], &a->grmemc, &deadline)) goto err ; if (!read_endeof(&b, &deadline)) goto err ; fd_close(fd) ; if (!genalloc_ready(char *, &a->grmem, grc.gr_mem_n + 1)) return 0 ; nsssd_group_convert(gr, genalloc_s(char *, &a->grmem), &grc, a->data[1].s, genalloc_s(size_t, &a->grmemc)) ; return 1 ; err: fd_close(fd) ; return 0 ; } int nsssd_grp_getbyname (void *handle, struct group *gr, char const *name) { nslcd_handle_t *a = handle ; nsssd_group_t grc ; tain_t deadline ; int fd ; buffer b ; char buf[4096] ; struct iovec v[2] = { { .iov_base = buf, .iov_len = 4 }, { .iov_base = (char *)name, .iov_len = strlen(name) } } ; tain_add_g(&deadline, &tto) ; fd = nslcd_connect(a, NSLCD_ACTION_GROUP_BYNAME, v, 2, &deadline) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 4096) ; if (!read_header(&b, NSLCD_ACTION_GROUP_BYNAME, &deadline)) goto err ; if (read_beginend(&b, &deadline) <= 0) goto err ; a->data[1].len = 0 ; genalloc_setlen(size_t, &a->grmemc, 0) ; if (!read_gr(&b, &grc, &a->data[1], &a->grmemc, &deadline)) goto err ; if (!read_endeof(&b, &deadline)) goto err ; fd_close(fd) ; if (!genalloc_ready(char *, &a->grmem, grc.gr_mem_n + 1)) return 0 ; nsssd_group_convert(gr, genalloc_s(char *, &a->grmem), &grc, a->data[1].s, genalloc_s(size_t, &a->grmem)) ; return 1 ; err: fd_close(fd) ; return 0 ; } int nsssd_grp_getlist (void *handle, char const *user, gid_t *gids, size_t n, size_t *r) { /* TODO: find a sane way of implementing getgrouplist() over nslcd */ (void)handle ; (void)user ; (void)gids ; (void)n ; (void)r ; return (errno = ENOSYS, 0) ; } void nsssd_grp_end (void *handle) { } int nsssd_shadow_start (void *handle) { nslcd_handle_t *a = handle ; a->head[2] = 0 ; a->needdata |= 4 ; return 1 ; } int nsssd_shadow_rewind (void *handle) { nslcd_handle_t *a = handle ; a->head[2] = 0 ; a->needdata |= 4 ; return 1 ; } static inline int shadow_getall (nslcd_handle_t *a) { tain_t deadline ; int fd ; buffer b ; char buf[8192] ; tain_add_g(&deadline, &tto) ; fd = nslcd_connect(a, NSLCD_ACTION_SHADOW_ALL, 0, 0, &deadline) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 8192) ; if (!read_header(&b, NSLCD_ACTION_SHADOW_ALL, &deadline)) goto err ; genalloc_setlen(nsssd_spwd_t, &a->entries[2], 0) ; a->data[2].len = 0 ; for (;;) { int r = read_beginend(&b, &deadline) ; if (r < 0) goto err ; if (!r) break ; if (!genalloc_readyplus(nsssd_spwd_t, &a->entries[2], 1)) goto err ; if (!read_sp(&b, genalloc_s(nsssd_spwd_t, &a->entries[2]) + genalloc_len(nsssd_spwd_t, &a->entries[2]), &a->data[2], &deadline)) goto err ; genalloc_setlen(nsssd_spwd_t, &a->entries[2], genalloc_len(nsssd_spwd_t, &a->entries[2]) + 1) ; } if (!read_eof(&b, &deadline)) goto err ; fd_close(fd) ; return 1 ; err: fd_close(fd) ; return 0 ; } int nsssd_shadow_get (void *handle, struct spwd *sp) { nslcd_handle_t *a = handle ; if (a->needdata & 4) { if (!shadow_getall(a)) return 0 ; a->needdata &= ~4 ; } if (a->head[2] >= genalloc_len(nsssd_spwd_t, &a->entries[2])) return 0 ; nsssd_spwd_convert(sp, genalloc_s(nsssd_spwd_t, &a->entries[2]) + a->head[2]++, a->data[2].s) ; return 1 ; } int nsssd_shadow_getbyname (void *handle, struct spwd *sp, char const *name) { nslcd_handle_t *a = handle ; nsssd_spwd_t spc ; tain_t deadline ; int fd ; buffer b ; char buf[4096] ; struct iovec v[2] = { { .iov_base = buf, .iov_len = 4 }, { .iov_base = (char *)name, .iov_len = strlen(name) } } ; tain_add_g(&deadline, &tto) ; fd = nslcd_connect(a, NSLCD_ACTION_SHADOW_BYNAME, v, 2, &deadline) ; if (fd < 0) return 0 ; buffer_init(&b, &buffer_read, fd, buf, 4096) ; if (!read_header(&b, NSLCD_ACTION_SHADOW_BYNAME, &deadline)) goto err ; if (read_beginend(&b, &deadline) <= 0) goto err ; a->data[2].len = 0 ; if (!read_sp(&b, &spc, &a->data[2], &deadline)) goto err ; if (!read_endeof(&b, &deadline)) goto err ; fd_close(fd) ; nsssd_spwd_convert(sp, &spc, a->data[2].s) ; return 1 ; err: fd_close(fd) ; return 0 ; } void nsssd_shadow_end (void *handle) { } int main (int argc, char const *const *argv, char const *const *envp) { PROG = "nsssd-nslcd" ; { subgetopt_t l = SUBGETOPT_ZERO ; uint32_t t = 0 ; for (;;) { int opt = subgetopt_r(argc, argv, "t:", &l) ; if (opt == -1) break ; switch (opt) { case 't' : if (!uint320_scan(l.arg, &t)) dieusage() ; break ; default : dieusage() ; } } argc -= l.ind ; argv += l.ind ; if (t) tain_from_millisecs(&tto, t) ; } return nsssd_main(argv, envp) ; } nsss-0.0.2.1/src/nsssd/nsssd_convert.c0000644000000000000000000000232113314273063014503 0ustar /* ISC license. */ #include #include #include #include #include void nsssd_passwd_convert (struct passwd *pw, nsssd_passwd_t const *p, char const *s) { pw->pw_name = (char *)s + p->pw_name ; pw->pw_passwd = (char *)s + p->pw_passwd ; pw->pw_uid = p->pw_uid ; pw->pw_gid = p->pw_gid ; pw->pw_gecos = (char *)s + p->pw_gecos ; pw->pw_dir = (char *)s + p->pw_dir ; pw->pw_shell = (char *)s + p->pw_shell ; } void nsssd_group_convert (struct group *gr, char **q, nsssd_group_t const *p, char const *s, size_t const *membase) { gr->gr_name = (char *)s + p->gr_name ; gr->gr_passwd = (char *)s + p->gr_passwd ; gr->gr_gid = p->gr_gid ; gr->gr_mem = q ; for (size_t i = 0 ; i < p->gr_mem_n ; i++) *q++ = (char *)s + membase[p->gr_mem + i] ; *q++ = 0 ; } void nsssd_spwd_convert (struct spwd *sp, nsssd_spwd_t const *p, char const *s) { sp->sp_namp = (char *)s + p->sp_namp ; sp->sp_pwdp = (char *)s + p->sp_pwdp ; sp->sp_lstchg = p->sp_lstchg ; sp->sp_min = p->sp_min ; sp->sp_max = p->sp_max ; sp->sp_warn = p->sp_warn ; sp->sp_inact = p->sp_inact ; sp->sp_expire = p->sp_expire ; sp->sp_flag = p->sp_flag ; } nsss-0.0.2.1/src/nsssd/deps-lib/0000755000000000000000000000000013312145321013137 5ustar nsss-0.0.2.1/src/nsssd/deps-lib/nsssd0000644000000000000000000000004713312556324014226 0ustar nsssd_main.o nsssd_convert.o -lskarnet nsss-0.0.2.1/src/nsssd/nsssd-switch.c0000644000000000000000000001270313516350357014255 0ustar /* ISC license. */ #include #include #include #include #include #include #include #define MAX_BACKENDS 16 static unsigned int el_getstrict (void) { static unsigned int strict = 0 ; static int first = 1 ; if (first) { char const *x = getenv("EXECLINE_STRICT") ; first = 0 ; if (x) uint0_scan(x, &strict) ; } return strict ; } static int el_semicolon (char const **argv) { static unsigned int nblock = 0 ; int argc1 = 0 ; nblock++ ; for (;; argc1++, argv++) { char const *arg = *argv ; if (!arg) return argc1 + 1 ; if (!arg[0]) return argc1 ; else if (arg[0] == ' ') ++*argv ; else { unsigned int strict = el_getstrict() ; if (strict) { char fmt1[UINT_FMT] ; char fmt2[UINT_FMT] ; fmt1[uint_fmt(fmt1, nblock)] = 0 ; fmt2[uint_fmt(fmt2, (unsigned int)argc1)] = 0 ; if (strict >= 2) strerr_dief6x(100, "unquoted argument ", arg, " at block ", fmt1, " position ", fmt2) ; else strerr_warnw6x("unquoted argument ", arg, " at block ", fmt1, " position ", fmt2) ; } } } } typedef struct backend_s backend_t, *backend_t_ref ; struct backend_s { char const *const *argv ; nsss_switch_t handle ; } ; typedef struct handle_s handle_t, *handle_t_ref ; struct handle_s { backend_t tab[MAX_BACKENDS] ; unsigned int n ; } ; static inline pid_t nsss_switch_spawn (nsss_switch_t *a, char const *const *argv, tain_t const *deadline, tain_t *stamp) { int fd ; pid_t pid = child_spawn1_socket(argv[0], argv, (char const *const *)environ, &fd) ; if (!pid) return 0 ; buffer_init(&a->b, &buffer_read, fd, a->buf, NSSS_SWITCH_BUFSIZE) ; return pid ; } static int nsss_switch_startf (nsss_switch_t *a, unsigned int what, char const *const *argv, tain_t const *deadline, tain_t *stamp) { if (!a->held && !nsss_switch_spawn(a, argv, deadline, stamp)) return 0 ; a->held |= (1U << what) ; return 1 ; } void *nsssd_handle_init (void) { static handle_t a = { .n = 0 } ; return &a ; } int nsssd_handle_start (void *handle, char const *const *argv, char const *const *envp) { static nsss_switch_t const nsss_switch_zero = NSSS_SWITCH_ZERO ; handle_t *a = handle ; char const **args = (char const **)argv ; unsigned int argc = 0 ; unsigned int i = 0 ; for (;; i++) { backend_t *be ; int argc1 ; if (!args[argc]) break ; argc1 = el_semicolon(args + argc) ; if (!argc1) strerr_dief1x(100, "empty block") ; if (!args[argc + argc1]) strerr_dief1x(100, "unterminated block") ; args[argc + argc1] = 0 ; if (i >= MAX_BACKENDS) strerr_dief1x(100, "too many defined backends") ; be = &a->tab[i++] ; be->argv = args + argc ; be->handle = nsss_switch_zero ; argc += argc1 ; } if (!i) strerr_dief1x(100, "no defined backends") ; a->n = i ; (void)envp ; return 1 ; } void nsssd_handle_end (void *handle) { (void)handle ; } int nsssd_pwd_start (void *handle) { (void)handle ; return 1 ; } int nsssd_pwd_rewind (void *handle) { nsss_unix_setpwent() ; (void)handle ; return 1 ; } int nsssd_pwd_get (void *handle, struct passwd *pw) { struct passwd *pw2 = nsss_unix_getpwent() ; if (!pw2) return 0 ; *pw = *pw2 ; (void)handle ; return 1 ; } int nsssd_pwd_getbyuid (void *handle, struct passwd *pw, uid_t uid) { struct passwd *pw2 = nsss_unix_getpwuid(uid) ; if (!pw2) return 0 ; *pw = *pw2 ; (void)handle ; return 1 ; } int nsssd_pwd_getbyname (void *handle, struct passwd *pw, char const *name) { struct passwd *pw2 = nsss_unix_getpwnam(name) ; if (!pw2) return 0 ; *pw = *pw2 ; (void)handle ; return 1 ; } void nsssd_pwd_end (void *handle) { nsss_unix_endpwent() ; (void)handle ; } void nsssd_grp_handle_init (void *handle) { (void)handle ; } int nsssd_grp_start (void *handle) { (void)handle ; return 1 ; } int nsssd_grp_rewind (void *handle) { nsss_unix_setgrent() ; (void)handle ; return 1 ; } int nsssd_grp_get (void *handle, struct group *gr) { struct group *gr2 = nsss_unix_getgrent() ; if (!gr2) return 0 ; *gr = *gr2 ; (void)handle ; return 1 ; } int nsssd_grp_getbygid (void *handle, struct group *gr, gid_t gid) { struct group *gr2 = nsss_unix_getgrgid(gid) ; if (!gr2) return 0 ; *gr = *gr2 ; (void)handle ; return 1 ; } int nsssd_grp_getbyname (void *handle, struct group *gr, char const *name) { struct group *gr2 = nsss_unix_getgrnam(name) ; if (!gr2) return 0 ; *gr = *gr2 ; (void)handle ; return 1 ; } void nsssd_grp_end (void *handle) { nsss_unix_endgrent() ; (void)handle ; } void nsssd_shadow_handle_init (void *handle) { (void)handle ; } int nsssd_shadow_start (void *handle) { (void)handle ; return 1 ; } int nsssd_shadow_rewind (void *handle) { nsss_unix_setspent() ; (void)handle ; return 1 ; } int nsssd_shadow_get (void *handle, struct spwd *sp) { struct spwd *sp2 = nsss_unix_getspent() ; if (!sp2) return 0 ; *sp = *sp2 ; (void)handle ; return 1 ; } int nsssd_shadow_getbyname (void *handle, struct spwd *sp, char const *name) { struct spwd *sp2 = nsss_unix_getspnam(name) ; if (!sp2) return 0 ; *sp = *sp2 ; (void)handle ; return 1 ; } void nsssd_shadow_end (void *handle) { nsss_unix_endspent() ; (void)handle ; } int main (int argc, char const *const *argv, char const *const *envp) { PROG = "nsssd-switch" ; return nsssd_main(argv+1, envp) ; } nsss-0.0.2.1/src/include-local/0000755000000000000000000000000012412615566013036 5ustar nsss-0.0.2.1/src/include/0000755000000000000000000000000013311441135011732 5ustar nsss-0.0.2.1/src/include/pwd.h0000644000000000000000000000061413311767012012703 0ustar /* ISC license. */ /* This file is part of the nsss package. See https://skarnet.org/software/nsss/ */ #ifndef PWD_H #define PWD_H #include #ifdef _GNU_SOURCE #include extern struct passwd *fgetpwent (FILE *) ; extern int fgetpwent_r (FILE *, struct passwd *, char *, size_t, struct passwd **) ; extern int putpwent (struct passwd const *, FILE *) ; #endif #endif nsss-0.0.2.1/src/include/grp.h0000644000000000000000000000106513522752312012703 0ustar /* ISC license. */ /* This file is part of the nsss package. See https://skarnet.org/software/nsss/ */ #ifndef GRP_H #define GRP_H #include #if defined(_GNU_SOURCE) || defined(_BSD_SOURCE) #include extern int setgroups (size_t, gid_t const *) ; extern int initgroups (char const *, gid_t) ; #endif #ifdef _GNU_SOURCE #include extern struct group *fgetgrent (FILE *) ; extern int fgetgrent_r (FILE *, struct group *, char *, size_t, struct group **) ; extern int putgrent (struct group const *, FILE *) ; #endif #endif nsss-0.0.2.1/src/include/nsss/0000755000000000000000000000000013541512070012722 5ustar nsss-0.0.2.1/src/include/nsss/shadow-switch.h0000644000000000000000000000104113313661233015656 0ustar /* ISC license. */ #ifndef NSSS_SHADOW_SWITCH_H #define NSSS_SHADOW_SWITCH_H #include /* Shadow functions contacting the nsssd daemon */ extern void nsss_switch_setspent (void) ; extern struct spwd *nsss_switch_getspent (void) ; extern int nsss_switch_getspent_r (struct spwd *, char *, size_t, struct spwd **) ; extern void nsss_switch_endspent (void) ; extern struct spwd *nsss_switch_getspnam (char const *) ; extern int nsss_switch_getspnam_r (char const *, struct spwd *, char *, size_t, struct spwd **) ; #endif nsss-0.0.2.1/src/include/nsss/grp-switch.h0000644000000000000000000000137213522752577015206 0ustar /* ISC license. */ #ifndef NSSS_GRP_SWITCH_H #define NSSS_GRP_SWITCH_H #include /* Group functions contacting the nsssd daemon */ extern void nsss_switch_setgrent (void) ; extern struct group *nsss_switch_getgrent (void) ; extern int nsss_switch_getgrent_r (struct group *, char *, size_t, struct group **) ; extern void nsss_switch_endgrent (void) ; extern struct group *nsss_switch_getgrgid (gid_t) ; extern struct group *nsss_switch_getgrnam (char const *) ; extern int nsss_switch_getgrgid_r (gid_t, struct group *, char *, size_t, struct group **) ; extern int nsss_switch_getgrnam_r (char const *, struct group *, char *, size_t, struct group **) ; extern int nsss_switch_getgrouplist (char const *, gid_t, gid_t *, int *) ; #endif nsss-0.0.2.1/src/include/nsss/nsss.h0000644000000000000000000000022013313673433014063 0ustar /* ISC license. */ #ifndef NSSS_H #define NSSS_H #include #include #include #endif nsss-0.0.2.1/src/include/nsss/pwd-unix.h0000644000000000000000000000121313313660736014655 0ustar /* ISC license. */ #ifndef NSSS_PWD_UNIX_H #define NSSS_PWD_UNIX_H #include /* /etc/passwd backend */ extern void nsss_unix_setpwent (void) ; extern struct passwd *nsss_unix_getpwent (void) ; extern int nsss_unix_getpwent_r (struct passwd *, char *, size_t, struct passwd **) ; extern void nsss_unix_endpwent (void) ; extern struct passwd *nsss_unix_getpwuid (uid_t) ; extern int nsss_unix_getpwuid_r (uid_t, struct passwd *, char *, size_t, struct passwd **) ; extern struct passwd *nsss_unix_getpwnam (char const *) ; extern int nsss_unix_getpwnam_r (char const *, struct passwd *, char *, size_t, struct passwd **) ; #endif nsss-0.0.2.1/src/include/nsss/shadow-def.h0000644000000000000000000000044213313733146015122 0ustar /* ISC license. */ #ifndef NSSS_SHADOW_DEF_H #define NSSS_SHADOW_DEF_H #include struct spwd { char *sp_namp ; char *sp_pwdp ; long sp_lstchg ; long sp_min ; long sp_max ; long sp_warn ; long sp_inact ; long sp_expire ; unsigned long sp_flag ; } ; #endif nsss-0.0.2.1/src/include/nsss/pwd.h0000644000000000000000000000227613313671152013700 0ustar /* ISC license. */ #ifndef NSSS_PWD_H #define NSSS_PWD_H #ifdef __cplusplus extern "C" { #endif #ifdef NSSS_DISABLE_SWITCH #include #define setpwent nsss_unix_setpwent #define getpwent nsss_unix_getpwent #define getpwent_r nsss_unix_getpwent_r #define endpwent nsss_unix_endpwent #define getpwuid nsss_unix_getpwuid #define getpwuid_r nsss_unix_getpwuid_r #define getpwnam nsss_unix_getpwnam #define getpwnam_r nsss_unix_getpwnam_r #else #ifdef NSSS_DISABLE_UNIX #include #define setpwent nsss_switch_setpwent #define getpwent nsss_switch_getpwent #define getpwent_r nsss_switch_getpwent_r #define endpwent nsss_switch_endpwent #define getpwuid nsss_switch_getpwuid #define getpwuid_r nsss_switch_getpwuid_r #define getpwnam nsss_switch_getpwnam #define getpwnam_r nsss_switch_getpwnam_r #else #include #define setpwent nsss_all_setpwent #define getpwent nsss_all_getpwent #define getpwent_r nsss_all_getpwent_r #define endpwent nsss_all_endpwent #define getpwuid nsss_all_getpwuid #define getpwuid_r nsss_all_getpwuid_r #define getpwnam nsss_all_getpwnam #define getpwnam_r nsss_all_getpwnam_r #endif #endif #ifdef __cplusplus } #endif #endif nsss-0.0.2.1/src/include/nsss/nsssd.h0000644000000000000000000000456413541504277014250 0ustar /* ISC license. */ #ifndef NSSSD_H #define NSSSD_H #include #include #include #include #define NSSSD_EOF 255 typedef struct nsssd_passwd_s nsssd_passwd_t, *nsssd_passwd_t_ref ; struct nsssd_passwd_s { size_t pw_name ; size_t pw_passwd ; uid_t pw_uid ; uid_t pw_gid ; size_t pw_gecos ; size_t pw_dir ; size_t pw_shell ; } ; typedef struct nsssd_group_s nsssd_group_t, *nsssd_group_t_ref ; struct nsssd_group_s { size_t gr_name ; size_t gr_passwd ; gid_t gr_gid ; size_t gr_mem ; size_t gr_mem_n ; } ; typedef struct nsssd_spwd_s nsssd_spwd_t, *nsssd_spwd_t_ref ; struct nsssd_spwd_s { size_t sp_namp ; size_t sp_pwdp ; long sp_lstchg ; long sp_min ; long sp_max ; long sp_warn ; long sp_inact ; long sp_expire ; unsigned long sp_flag ; } ; /* Functions provided by libnsssd */ extern int nsssd_main (char const *const *, char const *const *) ; extern void nsssd_passwd_convert (struct passwd *, nsssd_passwd_t const *, char const *) ; extern void nsssd_group_convert (struct group *, char **, nsssd_group_t const *, char const *, size_t const *) ; extern void nsssd_spwd_convert (struct spwd *, nsssd_spwd_t const *, char const *) ; /* Functions that must be provided by the backend */ extern void *nsssd_handle_init (void) ; extern int nsssd_handle_start (void *, char const *const *, char const *const *) ; extern void nsssd_handle_end (void *) ; extern int nsssd_pwd_start (void *) ; extern int nsssd_pwd_rewind (void *) ; extern int nsssd_pwd_get (void *, struct passwd *) ; extern int nsssd_pwd_getbyuid (void *, struct passwd *, uid_t) ; extern int nsssd_pwd_getbyname (void *, struct passwd *, char const *) ; extern void nsssd_pwd_end (void *) ; extern int nsssd_grp_start (void *) ; extern int nsssd_grp_rewind (void *) ; extern int nsssd_grp_get (void *, struct group *) ; extern int nsssd_grp_getbygid (void *, struct group *, gid_t) ; extern int nsssd_grp_getbyname (void *, struct group *, char const *) ; extern int nsssd_grp_getlist (void *, char const *, gid_t *, size_t, size_t *) ; extern void nsssd_grp_end (void *) ; extern int nsssd_shadow_start (void *) ; extern int nsssd_shadow_rewind (void *) ; extern int nsssd_shadow_get (void *, struct spwd *) ; extern int nsssd_shadow_getbyname (void *, struct spwd *, char const *) ; extern void nsssd_shadow_end (void *) ; #endif nsss-0.0.2.1/src/include/nsss/grp-unix.h0000644000000000000000000000144313541506406014654 0ustar /* ISC license. */ #ifndef NSSS_GRP_UNIX_H #define NSSS_GRP_UNIX_H #include /* /etc/group backend */ extern void nsss_unix_setgrent (void) ; extern struct group *nsss_unix_getgrent (void) ; extern int nsss_unix_getgrent_r (struct group *, char *, size_t, struct group **) ; extern void nsss_unix_endgrent (void) ; extern struct group *nsss_unix_getgrgid (gid_t) ; extern struct group *nsss_unix_getgrnam (char const *) ; extern int nsss_unix_getgrgid_r (gid_t, struct group *, char *, size_t, struct group **) ; extern int nsss_unix_getgrnam_r (char const *, struct group *, char *, size_t, struct group **) ; extern int nsss_unix_getgrouplist (char const *, gid_t, gid_t *, int *) ; extern int nsss_unix_getgrouplist_preadjust (char const *, gid_t *, size_t, size_t *) ; #endif nsss-0.0.2.1/src/include/nsss/grp.h0000644000000000000000000000276113522752422013677 0ustar /* ISC license. */ #ifndef NSSS_GRP_H #define NSSS_GRP_H #ifdef __cplusplus extern "C" { #endif #ifdef NSSS_DISABLE_SWITCH #include #define setgrent nsss_unix_setgrent #define getgrent nsss_unix_getgrent #define getgrent_r nsss_unix_getgrent_r #define endgrent nsss_unix_endgrent #define getgrgid nsss_unix_getgrgid #define getgrgid_r nsss_unix_getgrgid_r #define getgrnam nsss_unix_getgrnam #define getgrnam_r nsss_unix_getgrnam_r #if defined(_GNU_SOURCE) || defined(_BSD_SOURCE) # define getgrouplist nsss_unix_getgrouplist #endif #else #ifdef NSSS_DISABLE_UNIX #include #define setgrent nsss_switch_setgrent #define getgrent nsss_switch_getgrent #define getgrent_r nsss_switch_getgrent_r #define endgrent nsss_switch_endgrent #define getgrgid nsss_switch_getgrgid #define getgrgid_r nsss_switch_getgrgid_r #define getgrnam nsss_switch_getgrnam #define getgrnam_r nsss_switch_getgrnam_r #if defined(_GNU_SOURCE) || defined(_BSD_SOURCE) # define getgrouplist nsss_switch_getgrouplist #endif #else #include #define setgrent nsss_all_setgrent #define getgrent nsss_all_getgrent #define getgrent_r nsss_all_getgrent_r #define endgrent nsss_all_endgrent #define getgrgid nsss_all_getgrgid #define getgrgid_r nsss_all_getgrgid_r #define getgrnam nsss_all_getgrnam #define getgrnam_r nsss_all_getgrnam_r #if defined(_GNU_SOURCE) || defined(_BSD_SOURCE) # define getgrouplist nsss_all_getgrouplist #endif #endif #endif #ifdef __cplusplus } #endif #endif nsss-0.0.2.1/src/include/nsss/pwd-switch.h0000644000000000000000000000127213313673533015177 0ustar /* ISC license. */ #ifndef NSSS_PWD_SWITCH_H #define NSSS_PWD_SWITCH_H #include /* Password functions contacting the nsssd daemon */ extern void nsss_switch_setpwent (void) ; extern struct passwd *nsss_switch_getpwent (void) ; extern int nsss_switch_getpwent_r (struct passwd *, char *, size_t, struct passwd **) ; extern void nsss_switch_endpwent (void) ; extern struct passwd *nsss_switch_getpwuid (uid_t) ; extern int nsss_switch_getpwuid_r (uid_t, struct passwd *, char *, size_t, struct passwd **) ; extern struct passwd *nsss_switch_getpwnam (char const *) ; extern int nsss_switch_getpwnam_r (char const *, struct passwd *, char *, size_t, struct passwd **) ; #endif nsss-0.0.2.1/src/include/nsss/nsss-all.h0000644000000000000000000000022413313671627014640 0ustar /* ISC license. */ #ifndef NSSS_ALL_H #define NSSS_ALL_H #include #include #include #endif nsss-0.0.2.1/src/include/nsss/nsss-unix.h0000644000000000000000000000440713541500116015045 0ustar /* ISC license. */ #ifndef NSSS_UNIX_H #define NSSS_UNIX_H #include #include #include #include #include #include #include #define NSSS_UNIX_BUFSIZE 4096 typedef struct nsss_unix_s nsss_unix_t, *nsss_unix_t_ref ; struct nsss_unix_s { buffer b ; char buf[NSSS_UNIX_BUFSIZE] ; } ; #define NSSS_UNIX_ZERO { .b = BUFFER_ZERO } extern int nsss_unix_start (nsss_unix_t *, char const *) ; extern int nsss_unix_maybe_start (nsss_unix_t *, char const *) ; extern void nsss_unix_end (nsss_unix_t *) ; extern int nsss_unix_rewind (nsss_unix_t *) ; /* Password */ #define nsss_unix_pwd_start(a) nsss_unix_start(a, "/etc/passwd") #define nsss_unix_pwd_maybe_start(a) nsss_unix_maybe_start(a, "/etc/passwd") #define nsss_unix_pwd_end(a) nsss_unix_end(a) #define nsss_unix_pwd_rewind(a) nsss_unix_rewind(a) extern int nsss_unix_pwd_get (nsss_unix_t *, struct passwd *, stralloc *) ; extern int nsss_unix_pwd_getbyname (nsss_unix_t *, struct passwd *, stralloc *, char const *) ; extern int nsss_unix_pwd_getbyuid (nsss_unix_t *, struct passwd *, stralloc *, uid_t) ; /* Group */ #define nsss_unix_grp_start(a) nsss_unix_start(a, "/etc/group") #define nsss_unix_grp_maybe_start(a) nsss_unix_maybe_start(a, "/etc/group") #define nsss_unix_grp_end(a) nsss_unix_end(a) #define nsss_unix_grp_rewind(a) nsss_unix_rewind(a) extern int nsss_unix_grp_get (nsss_unix_t *, struct group *, stralloc *, genalloc *) ; extern int nsss_unix_grp_getbyname (nsss_unix_t *, struct group *, stralloc *, genalloc *, char const *) ; extern int nsss_unix_grp_getbygid (nsss_unix_t *, struct group *, stralloc *, genalloc *, gid_t) ; extern int nsss_unix_grp_getlist (nsss_unix_t *, char const *, gid_t *, size_t, size_t *, stralloc *, genalloc *) ; /* Shadow */ #define nsss_unix_shadow_start(a) nsss_unix_start(a, "/etc/shadow") #define nsss_unix_shadow_maybe_start(a) nsss_unix_maybe_start(a, "/etc/shadow") #define nsss_unix_shadow_end(a) nsss_unix_end(a) #define nsss_unix_shadow_rewind(a) nsss_unix_rewind(a) extern int nsss_unix_shadow_get (nsss_unix_t *, struct spwd *, stralloc *) ; extern int nsss_unix_shadow_getbyname (nsss_unix_t *, struct spwd *, stralloc *, char const *) ; #endif nsss-0.0.2.1/src/include/nsss/shadow.h0000644000000000000000000000174713313671543014401 0ustar /* ISC license. */ #ifndef NSSS_SHADOW_H #define NSSS_SHADOW_H #ifdef __cplusplus extern "C" { #endif #ifdef NSSS_DISABLE_SWITCH #include #define setspent nsss_unix_setspent #define getspent nsss_unix_getspent #define getspent_r nsss_unix_getspent_r #define endspent nsss_unix_endspent #define getspnam nsss_unix_getspnam #define getspnam_r nsss_unix_getspnam_r #else #ifdef NSSS_DISABLE_UNIX #include #define setspent nsss_switch_setspent #define getspent nsss_switch_getspent #define getspent_r nsss_switch_getspent_r #define endspent nsss_switch_endspent #define getspnam nsss_switch_getspnam #define getspnam_r nsss_switch_getspnam_r #else #include #define setspent nsss_all_setspent #define getspent nsss_all_getspent #define getspent_r nsss_all_getspent_r #define endspent nsss_all_endspent #define getspnam nsss_all_getspnam #define getspnam_r nsss_all_getspnam_r #endif #endif #ifdef __cplusplus } #endif #endif nsss-0.0.2.1/src/include/nsss/pwd-all.h0000644000000000000000000000121213313667117014441 0ustar /* ISC license. */ #ifndef NSSS_PWD_ALL_H #define NSSS_PWD_ALL_H #include /* switch then fallback on unix */ extern void nsss_all_setpwent (void) ; extern struct passwd *nsss_all_getpwent (void) ; extern int nsss_all_getpwent_r (struct passwd *, char *, size_t, struct passwd **) ; extern void nsss_all_endpwent (void) ; extern struct passwd *nsss_all_getpwuid (uid_t) ; extern int nsss_all_getpwuid_r (uid_t, struct passwd *, char *, size_t, struct passwd **) ; extern struct passwd *nsss_all_getpwnam (char const *) ; extern int nsss_all_getpwnam_r (char const *, struct passwd *, char *, size_t, struct passwd **) ; #endif nsss-0.0.2.1/src/include/nsss/shadow-unix.h0000644000000000000000000000077213313661101015344 0ustar /* ISC license. */ #ifndef NSSS_SHADOW_UNIX_H #define NSSS_SHADOW_UNIX_H #include /* /etc/shadow functions */ extern void nsss_unix_setspent (void) ; extern struct spwd *nsss_unix_getspent (void) ; extern int nsss_unix_getspent_r (struct spwd *, char *, size_t, struct spwd **) ; extern void nsss_unix_endspent (void) ; extern struct spwd *nsss_unix_getspnam (char const *) ; extern int nsss_unix_getspnam_r (char const *, struct spwd *, char *, size_t, struct spwd **) ; #endif nsss-0.0.2.1/src/include/nsss/grp-def.h0000644000000000000000000000027713313733126014431 0ustar /* ISC license. */ #ifndef NSSS_GRP_DEF_H #define NSSS_GRP_DEF_H #include struct group { char *gr_name ; char *gr_passwd ; gid_t gr_gid ; char **gr_mem ; } ; #endif nsss-0.0.2.1/src/include/nsss/shadow-all.h0000644000000000000000000000077013313667240015141 0ustar /* ISC license. */ #ifndef NSSS_SHADOW_ALL_H #define NSSS_SHADOW_ALL_H #include /* switch then fallback on unix */ extern void nsss_all_setspent (void) ; extern struct spwd *nsss_all_getspent (void) ; extern int nsss_all_getspent_r (struct spwd *, char *, size_t, struct spwd **) ; extern void nsss_all_endspent (void) ; extern struct spwd *nsss_all_getspnam (char const *) ; extern int nsss_all_getspnam_r (char const *, struct spwd *, char *, size_t, struct spwd **) ; #endif nsss-0.0.2.1/src/include/nsss/pwd-def.h0000644000000000000000000000036613313667735014446 0ustar /* ISC license. */ #ifndef NSSS_PWD_DEF_H #define NSSS_PWD_DEF_H #include struct passwd { char *pw_name ; char *pw_passwd ; uid_t pw_uid ; gid_t pw_gid ; char *pw_gecos ; char *pw_dir ; char *pw_shell ; } ; #endif nsss-0.0.2.1/src/include/nsss/grp-all.h0000644000000000000000000000131113522752614014436 0ustar /* ISC license. */ #ifndef NSSS_GRP_ALL_H #define NSSS_GRP_ALL_H #include /* switch then fallback on unix */ extern void nsss_all_setgrent (void) ; extern struct group *nsss_all_getgrent (void) ; extern int nsss_all_getgrent_r (struct group *, char *, size_t, struct group **) ; extern void nsss_all_endgrent (void) ; extern struct group *nsss_all_getgrgid (gid_t) ; extern struct group *nsss_all_getgrnam (char const *) ; extern int nsss_all_getgrgid_r (gid_t, struct group *, char *, size_t, struct group **) ; extern int nsss_all_getgrnam_r (char const *, struct group *, char *, size_t, struct group **) ; extern int nsss_all_getgrouplist (char const *, gid_t, gid_t *, int *) ; #endif nsss-0.0.2.1/src/include/nsss/nsss-switch.h0000644000000000000000000001145313541500636015371 0ustar /* ISC license. */ #ifndef NSSS_SWITCH_H #define NSSS_SWITCH_H #include #include #include #include #include #include #include #include #include #include #define NSSS_SWITCH_BUFSIZE 4096 #ifdef LOGIN_NAME_MAX #define NSSS_SWITCH_NAME_MAXLEN LOGIN_NAME_MAX #else #define NSSS_SWITCH_NAME_MAXLEN _SC_LOGIN_NAME_MAX #endif typedef struct nsss_switch_s nsss_switch_t, *nsss_switch_t_ref ; struct nsss_switch_s { unsigned int held ; buffer b ; char buf[NSSS_SWITCH_BUFSIZE] ; } ; #define NSSS_SWITCH_ZERO { .held = 0, .b = BUFFER_ZERO } #define NSSS_SWITCH_PWD 0 #define NSSS_SWITCH_GRP 1 #define NSSS_SWITCH_SHADOW 2 extern int nsss_switch_start (nsss_switch_t *, unsigned int, char const *, tain_t const *, tain_t *) ; #define nsss_switch_start_g(a, what, s, deadline) nsss_switch_start(a, what, s, (deadline), &STAMP) extern void nsss_switch_end (nsss_switch_t *, unsigned int) ; /* Password */ #define NSSS_SWITCH_PWD_END '\0' #define NSSS_SWITCH_PWD_REWIND '\001' #define NSSS_SWITCH_PWD_GET '\002' #define NSSS_SWITCH_PWD_GETBYNAME '\003' #define NSSS_SWITCH_PWD_GETBYUID '\004' extern int nsss_switch_pwd_end (nsss_switch_t *, tain_t const *, tain_t *) ; #define nsss_switch_pwd_end_g(a, deadline) nsss_switch_pwd_end(a, (deadline), &STAMP) extern int nsss_switch_pwd_rewind (nsss_switch_t *, tain_t const *, tain_t *) ; #define nsss_switch_pwd_rewind_g(a, deadline) nsss_switch_pwd_rewind(a, (deadline), &STAMP) extern int nsss_switch_pwd_get (nsss_switch_t *, struct passwd *, stralloc *, tain_t const *, tain_t *) ; #define nsss_switch_pwd_get_g(a, b, sa, deadline) nsss_switch_pwd_get(a, b, sa, (deadline), &STAMP) extern int nsss_switch_pwd_getbyname (nsss_switch_t *, struct passwd *, stralloc *, char const *, tain_t const *, tain_t *) ; #define nsss_switch_pwd_getbyname_g(a, b, sa, name, deadline) nsss_switch_pwd_getbyname(a, b, sa, name, (deadline), &STAMP) extern int nsss_switch_pwd_getbyuid (nsss_switch_t *, struct passwd *, stralloc *, uid_t, tain_t const *, tain_t *) ; #define nsss_switch_pwd_getbyuid_g(a, b, sa, u, deadline) nsss_switch_pwd_getbyuid(a, b, sa, u, (deadline), &STAMP) /* Group */ #define NSSS_SWITCH_GRP_END '\020' #define NSSS_SWITCH_GRP_REWIND '\021' #define NSSS_SWITCH_GRP_GET '\022' #define NSSS_SWITCH_GRP_GETBYNAME '\023' #define NSSS_SWITCH_GRP_GETBYGID '\024' #define NSSS_SWITCH_GRP_GETLIST '\025' extern int nsss_switch_grp_end (nsss_switch_t *, tain_t const *, tain_t *) ; #define nsss_switch_grp_end_g(a, deadline) nsss_switch_grp_end(a, (deadline), &STAMP) extern int nsss_switch_grp_rewind (nsss_switch_t *, tain_t const *, tain_t *) ; #define nsss_switch_grp_rewind_g(a, deadline) nsss_switch_grp_rewind(a, (deadline), &STAMP) extern int nsss_switch_grp_get (nsss_switch_t *, struct group *, stralloc *, genalloc *, tain_t const *, tain_t *) ; #define nsss_switch_grp_get_g(a, b, sa, ga, deadline) nsss_switch_grp_get(a, b, sa, ga, (deadline), &STAMP) extern int nsss_switch_grp_getbyname (nsss_switch_t *, struct group *, stralloc *, genalloc *, char const *, tain_t const *, tain_t *) ; #define nsss_switch_grp_getbyname_g(a, b, sa, ga, name, deadline) nsss_switch_grp_getbyname(a, b, sa, ga, name, (deadline), &STAMP) extern int nsss_switch_grp_getbygid (nsss_switch_t *, struct group *, stralloc *, genalloc *, gid_t, tain_t const *, tain_t *) ; #define nsss_switch_grp_getbygid_g(a, b, sa, ga, g, deadline) nsss_switch_grp_getbygid(a, b, sa, ga, g, (deadline), &STAMP) extern int nsss_switch_grp_getlist (nsss_switch_t *, char const *, gid_t *, size_t, size_t *, stralloc *, tain_t const *, tain_t *) ; #define nsss_switch_grp_getlist_g(a, user, gids, n, r, sa, deadline) nsss_switch_grp_getlist(a, user, gids, n, r, sa, (deadline), &STAMP) /* Shadow */ #define NSSS_SWITCH_SHADOW_END '\040' #define NSSS_SWITCH_SHADOW_REWIND '\041' #define NSSS_SWITCH_SHADOW_GET '\042' #define NSSS_SWITCH_SHADOW_GETBYNAME '\043' extern int nsss_switch_shadow_end (nsss_switch_t *, tain_t const *, tain_t *) ; #define nsss_switch_shadow_end_g(a, deadline) nsss_switch_shadow_end(a, (deadline), &STAMP) extern int nsss_switch_shadow_rewind (nsss_switch_t *, tain_t const *, tain_t *) ; #define nsss_switch_shadow_rewind_g(a, deadline) nsss_switch_shadow_rewind(a, (deadline), &STAMP) extern int nsss_switch_shadow_get (nsss_switch_t *, struct spwd *, stralloc *, tain_t const *, tain_t *) ; #define nsss_switch_shadow_get_g(a, b, sa, deadline) nsss_switch_shadow_get(a, b, sa, (deadline), &STAMP) extern int nsss_switch_shadow_getbyname (nsss_switch_t *, struct spwd *, stralloc *, char const *, tain_t const *, tain_t *) ; #define nsss_switch_shadow_getbyname_g(a, b, sa, name, deadline) nsss_switch_shadow_getbyname(a, b, sa, name, (deadline), &STAMP) #endif nsss-0.0.2.1/src/include/shadow.h0000644000000000000000000000112113311767477013407 0ustar /* ISC license. */ /* This file is part of the nsss package. See https://skarnet.org/software/nsss/ */ #ifndef SHADOW_H #define SHADOW_H #include #include extern struct spwd *fgetspent (FILE *) ; extern struct spwd *sgetspent (char const *) ; extern int putspent (struct spwd const *, FILE *) ; extern int lckpwdf (void) ; extern int ulckpwdf (void) ; #ifdef _DEFAULT_SOURCE extern int fgetspent_r(FILE *, struct spwd *, char *, size_t, struct spwd **) ; extern int sgetspent_r (char const *, struct spwd *, char *, size_t, struct spwd **) ; #endif #endif nsss-0.0.2.1/src/tests/0002755000000000000000000000000013534425157011470 5ustar nsss-0.0.2.1/src/tests/test-switch.baseline0000755000000000000000000000010213316255215015436 0ustar #!/bin/sh -e cat /etc/passwd echo id -u root echo cat /etc/group nsss-0.0.2.1/src/tests/deps-exe/0002755000000000000000000000000013540723124013172 5ustar nsss-0.0.2.1/src/tests/deps-exe/test-unix0000644000000000000000000000002513315547257015063 0ustar ${LIBNSSS} -lskarnet nsss-0.0.2.1/src/tests/deps-exe/test-switch0000644000000000000000000000006313540723124015370 0ustar ${LIBNSSS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} nsss-0.0.2.1/src/tests/deps-exe/test-all-fallback0000644000000000000000000000006313540723124016374 0ustar ${LIBNSSS} -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} nsss-0.0.2.1/src/tests/test-switch.c0000644000000000000000000000435713534424572014121 0ustar /* ISC license. */ #include #include #include #include #include #include #include #include #include #include #define S "./.test-switch-socket" int main (void) { nsss_switch_t a = NSSS_SWITCH_ZERO ; stralloc sa = STRALLOC_ZERO ; genalloc ga = GENALLOC_ZERO ; tain_t deadline ; PROG = "test-switch" ; tain_now_set_stopwatch_g() ; tain_from_millisecs(&deadline, 10000) ; tain_add_g(&deadline, &deadline) ; if (!nsss_switch_start_g(&a, NSSS_SWITCH_PWD, S, &deadline)) strerr_diefu1sys(111, "nsss_switch_start") ; for (;;) { struct passwd pw ; errno = 0 ; if (!nsss_switch_pwd_get_g(&a, &pw, &sa, &deadline)) break ; lolprintf("%s:%s:%d:%d:%s:%s:%s\n", pw.pw_name, pw.pw_passwd, (int)pw.pw_uid, (int)pw.pw_gid, pw.pw_gecos, pw.pw_dir, pw.pw_shell) ; sa.len = 0 ; } if (errno) strerr_diefu1sys(111, "nsss_switch_pwd_get") ; if (!nsss_switch_pwd_end_g(&a, &deadline)) strerr_diefu1sys(111, "nsss_switch_pwd_end") ; lolprintf("\n") ; { struct passwd pw ; if (!nsss_switch_pwd_getbyname_g(&a, &pw, &sa, "root", &deadline)) strerr_diefu1sys(111, "nsss_switch_pwd_getbyname") ; lolprintf("%u\n\n", (unsigned int)pw.pw_uid) ; sa.len = 0 ; } if (!nsss_switch_start_g(&a, NSSS_SWITCH_GRP, S, &deadline)) strerr_diefu1sys(111, "nsss_switch_start") ; nsss_switch_end(&a, NSSS_SWITCH_PWD) ; buffer_flush(buffer_1) ; for (;;) { struct group gr ; char **p ; errno = 0 ; if (!nsss_switch_grp_get_g(&a, &gr, &sa, &ga, &deadline)) break ; p = gr.gr_mem ; lolprintf("%s:%s:%d:", gr.gr_name, gr.gr_passwd, (int)gr.gr_gid) ; buffer_flush(buffer_1) ; if (*p) { while (*p) lolprintf("%s,", *p++) ; buffer_unput(buffer_1, 1) ; } buffer_put(buffer_1, "\n", 1) ; sa.len = 0 ; genalloc_setlen(char *, &ga, 0) ; } if (errno) strerr_diefu1sys(111, "nsss_switch_grp_get") ; if (!nsss_switch_grp_end_g(&a, &deadline)) strerr_diefu1sys(111, "nsss_switch_grp_end") ; nsss_switch_end(&a, NSSS_SWITCH_GRP) ; buffer_flush(buffer_1) ; return 0 ; } nsss-0.0.2.1/src/tests/test-all-fallback.baseline0000755000000000000000000000010213316415050016435 0ustar #!/bin/sh -e cat /etc/passwd echo id -u root echo cat /etc/group nsss-0.0.2.1/src/tests/test-all-fallback.c0000644000000000000000000000230013316415242015077 0ustar /* ISC license. */ #include #include #include #include #include #include #include int main (void) { PROG = "test-all-fallback" ; for (;;) { struct passwd *pw ; errno = 0 ; pw = nsss_all_getpwent() ; if (!pw) break ; lolprintf("%s:%s:%d:%d:%s:%s:%s\n", pw->pw_name, pw->pw_passwd, (int)pw->pw_uid, (int)pw->pw_gid, pw->pw_gecos, pw->pw_dir, pw->pw_shell) ; } if (errno) strerr_diefu1sys(111, "nsss_all_getpwent") ; nsss_all_endpwent() ; lolprintf("\n") ; { struct passwd *pw = nsss_all_getpwnam("root") ; lolprintf("%u\n\n", (unsigned int)pw->pw_uid) ; } for (;;) { struct group *gr ; char **p ; errno = 0 ; gr = nsss_all_getgrent() ; if (!gr) break ; p = gr->gr_mem ; lolprintf("%s:%s:%d:", gr->gr_name, gr->gr_passwd, (int)gr->gr_gid) ; if (*p) { while (*p) lolprintf("%s,", *p++) ; buffer_unput(buffer_1, 1) ; } buffer_put(buffer_1, "\n", 1) ; } if (errno) strerr_diefu1sys(111, "nsss_all_getgrent") ; nsss_all_endgrent() ; buffer_flush(buffer_1) ; return 0 ; } nsss-0.0.2.1/src/tests/test-switch.wrapper0000755000000000000000000000040513316414432015340 0ustar #!/bin/sh -e S=./.test-switch-socket F=./.test-switch-fifo pid=0 cleanup () { kill $pid rm -f $S } mkfifo $F head -n 1 < $F >/dev/null & pid=$! s6-ipcserver -1 -- $S ./nsssd-unix > $F & wait $pid pid=$! rm -f $F trap cleanup TERM INT EXIT ./test-switch nsss-0.0.2.1/src/tests/test-unix.c0000644000000000000000000000230013316415340013554 0ustar /* ISC license. */ #include #include #include #include #include #include #include int main (void) { PROG = "test-unix" ; for (;;) { struct passwd *pw ; errno = 0 ; pw = nsss_unix_getpwent() ; if (!pw) break ; lolprintf("%s:%s:%d:%d:%s:%s:%s\n", pw->pw_name, pw->pw_passwd, (int)pw->pw_uid, (int)pw->pw_gid, pw->pw_gecos, pw->pw_dir, pw->pw_shell) ; } if (errno) strerr_diefu1sys(111, "nsss_unix_getpwent") ; nsss_unix_endpwent() ; lolprintf("\n") ; { struct passwd *pw = nsss_unix_getpwnam("root") ; lolprintf("%u\n\n", (unsigned int)pw->pw_uid) ; } for (;;) { struct group *gr ; char **p ; errno = 0 ; gr = nsss_unix_getgrent() ; if (!gr) break ; p = gr->gr_mem ; lolprintf("%s:%s:%d:", gr->gr_name, gr->gr_passwd, (int)gr->gr_gid) ; if (*p) { while (*p) lolprintf("%s,", *p++) ; buffer_unput(buffer_1, 1) ; } buffer_put(buffer_1, "\n", 1) ; } if (errno) strerr_diefu1sys(111, "nsss_unix_getgrent") ; nsss_unix_endgrent() ; buffer_flush(buffer_1) ; return 0 ; } nsss-0.0.2.1/src/tests/test-unix.baseline0000755000000000000000000000010213316253475015126 0ustar #!/bin/sh -e cat /etc/passwd echo id -u root echo cat /etc/group nsss-0.0.2.1/src/tests/deps-lib/0002755000000000000000000000000013315546630013164 5ustar nsss-0.0.2.1/package/0002755000000000000000000000000013204564673011133 5ustar nsss-0.0.2.1/package/deps.mak0000644000000000000000000011610313553364317012560 0ustar # # This file has been generated by tools/gen-deps.sh # src/include/nsss/grp-all.h: src/include/nsss/grp-def.h src/include/nsss/grp-switch.h: src/include/nsss/grp-def.h src/include/nsss/grp-unix.h: src/include/nsss/grp-def.h src/include/nsss/grp.h: src/include/nsss/grp-all.h src/include/nsss/grp-switch.h src/include/nsss/grp-unix.h src/include/nsss/nsss-all.h: src/include/nsss/grp-all.h src/include/nsss/pwd-all.h src/include/nsss/shadow-all.h src/include/nsss/nsss-switch.h: src/include/nsss/grp-switch.h src/include/nsss/pwd-switch.h src/include/nsss/shadow-switch.h src/include/nsss/nsss-unix.h: src/include/nsss/grp-unix.h src/include/nsss/pwd-unix.h src/include/nsss/shadow-unix.h src/include/nsss/nsss.h: src/include/nsss/nsss-all.h src/include/nsss/nsss-switch.h src/include/nsss/nsss-unix.h src/include/nsss/nsssd.h: src/include/nsss/grp-def.h src/include/nsss/pwd-def.h src/include/nsss/shadow-def.h src/include/nsss/pwd-all.h: src/include/nsss/pwd-def.h src/include/nsss/pwd-switch.h: src/include/nsss/pwd-def.h src/include/nsss/pwd-unix.h: src/include/nsss/pwd-def.h src/include/nsss/pwd.h: src/include/nsss/pwd-all.h src/include/nsss/pwd-switch.h src/include/nsss/pwd-unix.h src/include/nsss/shadow-all.h: src/include/nsss/shadow-def.h src/include/nsss/shadow-switch.h: src/include/nsss/shadow-def.h src/include/nsss/shadow-unix.h: src/include/nsss/shadow-def.h src/include/nsss/shadow.h: src/include/nsss/shadow-all.h src/include/nsss/shadow-switch.h src/include/nsss/shadow-unix.h src/include/grp.h: src/include/nsss/grp.h src/include/pwd.h: src/include/nsss/pwd.h src/include/shadow.h: src/include/nsss/shadow.h src/libnsss/nsss-internal.h: src/include/nsss/grp-def.h src/include/nsss/pwd-def.h src/include/nsss/shadow-def.h src/libnsss/nsss-switch-internal.h: src/include/nsss/grp-def.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-def.h src/include/nsss/shadow-def.h src/libnsss/nsss-unix-internal.h: src/include/nsss/nsss-unix.h src/libnsss/nsss_all_endgrent.o src/libnsss/nsss_all_endgrent.lo: src/libnsss/nsss_all_endgrent.c src/libnsss/nsss-all-internal.h src/include/nsss/grp-all.h src/include/nsss/grp-switch.h src/include/nsss/grp-unix.h src/libnsss/nsss_all_endpwent.o src/libnsss/nsss_all_endpwent.lo: src/libnsss/nsss_all_endpwent.c src/libnsss/nsss-all-internal.h src/include/nsss/pwd-all.h src/include/nsss/pwd-switch.h src/include/nsss/pwd-unix.h src/libnsss/nsss_all_endspent.o src/libnsss/nsss_all_endspent.lo: src/libnsss/nsss_all_endspent.c src/libnsss/nsss-all-internal.h src/include/nsss/shadow-all.h src/include/nsss/shadow-switch.h src/include/nsss/shadow-unix.h src/libnsss/nsss_all_errno.o src/libnsss/nsss_all_errno.lo: src/libnsss/nsss_all_errno.c src/libnsss/nsss-all-internal.h src/libnsss/nsss_all_getgrent.o src/libnsss/nsss_all_getgrent.lo: src/libnsss/nsss_all_getgrent.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/grp-all.h src/include/nsss/grp-unix.h src/include/nsss/nsss-switch.h src/libnsss/nsss_all_getgrent_r.o src/libnsss/nsss_all_getgrent_r.lo: src/libnsss/nsss_all_getgrent_r.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/grp-all.h src/include/nsss/grp-unix.h src/include/nsss/nsss-switch.h src/libnsss/nsss_all_getgrgid.o src/libnsss/nsss_all_getgrgid.lo: src/libnsss/nsss_all_getgrgid.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-all.h src/include/nsss/grp-unix.h src/include/nsss/nsss-switch.h src/libnsss/nsss_all_getgrgid_r.o src/libnsss/nsss_all_getgrgid_r.lo: src/libnsss/nsss_all_getgrgid_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-all.h src/include/nsss/grp-unix.h src/include/nsss/nsss-switch.h src/libnsss/nsss_all_getgrnam.o src/libnsss/nsss_all_getgrnam.lo: src/libnsss/nsss_all_getgrnam.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-all.h src/include/nsss/grp-unix.h src/include/nsss/nsss-switch.h src/libnsss/nsss_all_getgrnam_r.o src/libnsss/nsss_all_getgrnam_r.lo: src/libnsss/nsss_all_getgrnam_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-all.h src/include/nsss/grp-unix.h src/include/nsss/nsss-switch.h src/libnsss/nsss_all_getgrouplist.o src/libnsss/nsss_all_getgrouplist.lo: src/libnsss/nsss_all_getgrouplist.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-all.h src/include/nsss/grp-unix.h src/include/nsss/nsss-switch.h src/libnsss/nsss_all_getpwent.o src/libnsss/nsss_all_getpwent.lo: src/libnsss/nsss_all_getpwent.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-all.h src/include/nsss/pwd-unix.h src/libnsss/nsss_all_getpwent_r.o src/libnsss/nsss_all_getpwent_r.lo: src/libnsss/nsss_all_getpwent_r.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-all.h src/include/nsss/pwd-unix.h src/libnsss/nsss_all_getpwnam.o src/libnsss/nsss_all_getpwnam.lo: src/libnsss/nsss_all_getpwnam.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-all.h src/include/nsss/pwd-unix.h src/libnsss/nsss_all_getpwnam_r.o src/libnsss/nsss_all_getpwnam_r.lo: src/libnsss/nsss_all_getpwnam_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-all.h src/include/nsss/pwd-unix.h src/libnsss/nsss_all_getpwuid.o src/libnsss/nsss_all_getpwuid.lo: src/libnsss/nsss_all_getpwuid.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-all.h src/include/nsss/pwd-unix.h src/libnsss/nsss_all_getpwuid_r.o src/libnsss/nsss_all_getpwuid_r.lo: src/libnsss/nsss_all_getpwuid_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-all.h src/include/nsss/pwd-unix.h src/libnsss/nsss_all_getspent.o src/libnsss/nsss_all_getspent.lo: src/libnsss/nsss_all_getspent.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-all.h src/include/nsss/shadow-unix.h src/libnsss/nsss_all_getspent_r.o src/libnsss/nsss_all_getspent_r.lo: src/libnsss/nsss_all_getspent_r.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-all.h src/include/nsss/shadow-unix.h src/libnsss/nsss_all_getspnam.o src/libnsss/nsss_all_getspnam.lo: src/libnsss/nsss_all_getspnam.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-all.h src/include/nsss/shadow-unix.h src/libnsss/nsss_all_getspnam_r.o src/libnsss/nsss_all_getspnam_r.lo: src/libnsss/nsss_all_getspnam_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-all.h src/include/nsss/shadow-unix.h src/libnsss/nsss_all_setgrent.o src/libnsss/nsss_all_setgrent.lo: src/libnsss/nsss_all_setgrent.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/grp-all.h src/include/nsss/grp-unix.h src/include/nsss/nsss-switch.h src/libnsss/nsss_all_setpwent.o src/libnsss/nsss_all_setpwent.lo: src/libnsss/nsss_all_setpwent.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-all.h src/include/nsss/pwd-unix.h src/libnsss/nsss_all_setspent.o src/libnsss/nsss_all_setspent.lo: src/libnsss/nsss_all_setspent.c src/libnsss/nsss-all-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-all.h src/include/nsss/shadow-unix.h src/libnsss/nsss_grouplist_adjust.o src/libnsss/nsss_grouplist_adjust.lo: src/libnsss/nsss_grouplist_adjust.c src/libnsss/nsss-internal.h src/include/nsss/grp-def.h src/libnsss/nsss_grp_copy.o src/libnsss/nsss_grp_copy.lo: src/libnsss/nsss_grp_copy.c src/libnsss/nsss-internal.h src/libnsss/nsss_grp_here.o src/libnsss/nsss_grp_here.lo: src/libnsss/nsss_grp_here.c src/libnsss/nsss-internal.h src/include/nsss/grp-def.h src/libnsss/nsss_pwd_copy.o src/libnsss/nsss_pwd_copy.lo: src/libnsss/nsss_pwd_copy.c src/libnsss/nsss-internal.h src/libnsss/nsss_pwd_here.o src/libnsss/nsss_pwd_here.lo: src/libnsss/nsss_pwd_here.c src/libnsss/nsss-internal.h src/include/nsss/pwd-def.h src/libnsss/nsss_shadow_copy.o src/libnsss/nsss_shadow_copy.lo: src/libnsss/nsss_shadow_copy.c src/libnsss/nsss-internal.h src/libnsss/nsss_shadow_here.o src/libnsss/nsss_shadow_here.lo: src/libnsss/nsss_shadow_here.c src/libnsss/nsss-internal.h src/include/nsss/shadow-def.h src/libnsss/nsss_switch_end.o src/libnsss/nsss_switch_end.lo: src/libnsss/nsss_switch_end.c src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_endgrent.o src/libnsss/nsss_switch_endgrent.lo: src/libnsss/nsss_switch_endgrent.c src/libnsss/nsss-switch-internal.h src/include/nsss/grp-switch.h src/libnsss/nsss_switch_endpwent.o src/libnsss/nsss_switch_endpwent.lo: src/libnsss/nsss_switch_endpwent.c src/libnsss/nsss-switch-internal.h src/include/nsss/pwd-switch.h src/libnsss/nsss_switch_endspent.o src/libnsss/nsss_switch_endspent.lo: src/libnsss/nsss_switch_endspent.c src/libnsss/nsss-switch-internal.h src/include/nsss/shadow-switch.h src/libnsss/nsss_switch_getgrent.o src/libnsss/nsss_switch_getgrent.lo: src/libnsss/nsss_switch_getgrent.c src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/grp-switch.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_getgrent_r.o src/libnsss/nsss_switch_getgrent_r.lo: src/libnsss/nsss_switch_getgrent_r.c src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/grp-switch.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_getgrgid.o src/libnsss/nsss_switch_getgrgid.lo: src/libnsss/nsss_switch_getgrgid.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-switch.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_getgrgid_r.o src/libnsss/nsss_switch_getgrgid_r.lo: src/libnsss/nsss_switch_getgrgid_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-switch.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_getgrnam.o src/libnsss/nsss_switch_getgrnam.lo: src/libnsss/nsss_switch_getgrnam.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-switch.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_getgrnam_r.o src/libnsss/nsss_switch_getgrnam_r.lo: src/libnsss/nsss_switch_getgrnam_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-switch.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_getgrouplist.o src/libnsss/nsss_switch_getgrouplist.lo: src/libnsss/nsss_switch_getgrouplist.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/grp-switch.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_getpwent.o src/libnsss/nsss_switch_getpwent.lo: src/libnsss/nsss_switch_getpwent.c src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-switch.h src/libnsss/nsss_switch_getpwent_r.o src/libnsss/nsss_switch_getpwent_r.lo: src/libnsss/nsss_switch_getpwent_r.c src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-switch.h src/libnsss/nsss_switch_getpwnam.o src/libnsss/nsss_switch_getpwnam.lo: src/libnsss/nsss_switch_getpwnam.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-switch.h src/libnsss/nsss_switch_getpwnam_r.o src/libnsss/nsss_switch_getpwnam_r.lo: src/libnsss/nsss_switch_getpwnam_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-switch.h src/libnsss/nsss_switch_getpwuid.o src/libnsss/nsss_switch_getpwuid.lo: src/libnsss/nsss_switch_getpwuid.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-switch.h src/libnsss/nsss_switch_getpwuid_r.o src/libnsss/nsss_switch_getpwuid_r.lo: src/libnsss/nsss_switch_getpwuid_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-switch.h src/libnsss/nsss_switch_getspent.o src/libnsss/nsss_switch_getspent.lo: src/libnsss/nsss_switch_getspent.c src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-switch.h src/libnsss/nsss_switch_getspent_r.o src/libnsss/nsss_switch_getspent_r.lo: src/libnsss/nsss_switch_getspent_r.c src/libnsss/nsss-internal.h src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-switch.h src/libnsss/nsss_switch_getspnam.o src/libnsss/nsss_switch_getspnam.lo: src/libnsss/nsss_switch_getspnam.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-switch.h src/libnsss/nsss_switch_getspnam_r.o src/libnsss/nsss_switch_getspnam_r.lo: src/libnsss/nsss_switch_getspnam_r.c src/libnsss/nsss-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-switch.h src/libnsss/nsss_switch_grp_end.o src/libnsss/nsss_switch_grp_end.lo: src/libnsss/nsss_switch_grp_end.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_grp_get.o src/libnsss/nsss_switch_grp_get.lo: src/libnsss/nsss_switch_grp_get.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_grp_getbygid.o src/libnsss/nsss_switch_grp_getbygid.lo: src/libnsss/nsss_switch_grp_getbygid.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_grp_getbyname.o src/libnsss/nsss_switch_grp_getbyname.lo: src/libnsss/nsss_switch_grp_getbyname.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_grp_getlist.o src/libnsss/nsss_switch_grp_getlist.lo: src/libnsss/nsss_switch_grp_getlist.c src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_grp_read.o src/libnsss/nsss_switch_grp_read.lo: src/libnsss/nsss_switch_grp_read.c src/libnsss/nsss-switch-internal.h src/include/nsss/grp-def.h src/libnsss/nsss_switch_grp_rewind.o src/libnsss/nsss_switch_grp_rewind.lo: src/libnsss/nsss_switch_grp_rewind.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_here.o src/libnsss/nsss_switch_here.lo: src/libnsss/nsss_switch_here.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_op.o src/libnsss/nsss_switch_op.lo: src/libnsss/nsss_switch_op.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_pwd_end.o src/libnsss/nsss_switch_pwd_end.lo: src/libnsss/nsss_switch_pwd_end.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_pwd_get.o src/libnsss/nsss_switch_pwd_get.lo: src/libnsss/nsss_switch_pwd_get.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_pwd_getbyname.o src/libnsss/nsss_switch_pwd_getbyname.lo: src/libnsss/nsss_switch_pwd_getbyname.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_pwd_getbyuid.o src/libnsss/nsss_switch_pwd_getbyuid.lo: src/libnsss/nsss_switch_pwd_getbyuid.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_pwd_read.o src/libnsss/nsss_switch_pwd_read.lo: src/libnsss/nsss_switch_pwd_read.c src/libnsss/nsss-switch-internal.h src/include/nsss/pwd-def.h src/libnsss/nsss_switch_pwd_rewind.o src/libnsss/nsss_switch_pwd_rewind.lo: src/libnsss/nsss_switch_pwd_rewind.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_setgrent.o src/libnsss/nsss_switch_setgrent.lo: src/libnsss/nsss_switch_setgrent.c src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/grp-switch.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_setpwent.o src/libnsss/nsss_switch_setpwent.lo: src/libnsss/nsss_switch_setpwent.c src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-switch.h src/libnsss/nsss_switch_setspent.o src/libnsss/nsss_switch_setspent.lo: src/libnsss/nsss_switch_setspent.c src/libnsss/nsss-switch-internal.h src/include/nsss/config.h src/include/nsss/nsss-switch.h src/include/nsss/shadow-switch.h src/libnsss/nsss_switch_shadow_end.o src/libnsss/nsss_switch_shadow_end.lo: src/libnsss/nsss_switch_shadow_end.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_shadow_get.o src/libnsss/nsss_switch_shadow_get.lo: src/libnsss/nsss_switch_shadow_get.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_shadow_getbyname.o src/libnsss/nsss_switch_shadow_getbyname.lo: src/libnsss/nsss_switch_shadow_getbyname.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_shadow_read.o src/libnsss/nsss_switch_shadow_read.lo: src/libnsss/nsss_switch_shadow_read.c src/libnsss/nsss-switch-internal.h src/include/nsss/shadow-def.h src/libnsss/nsss_switch_shadow_rewind.o src/libnsss/nsss_switch_shadow_rewind.lo: src/libnsss/nsss_switch_shadow_rewind.c src/libnsss/nsss-switch-internal.h src/include/nsss/nsss-switch.h src/libnsss/nsss_switch_start.o src/libnsss/nsss_switch_start.lo: src/libnsss/nsss_switch_start.c src/include/nsss/nsss-switch.h src/libnsss/nsss_unix_end.o src/libnsss/nsss_unix_end.lo: src/libnsss/nsss_unix_end.c src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_endgrent.o src/libnsss/nsss_unix_endgrent.lo: src/libnsss/nsss_unix_endgrent.c src/libnsss/nsss-unix-internal.h src/include/nsss/grp-unix.h src/libnsss/nsss_unix_endpwent.o src/libnsss/nsss_unix_endpwent.lo: src/libnsss/nsss_unix_endpwent.c src/libnsss/nsss-unix-internal.h src/include/nsss/pwd-unix.h src/libnsss/nsss_unix_endspent.o src/libnsss/nsss_unix_endspent.lo: src/libnsss/nsss_unix_endspent.c src/libnsss/nsss-unix-internal.h src/include/nsss/shadow-unix.h src/libnsss/nsss_unix_field.o src/libnsss/nsss_unix_field.lo: src/libnsss/nsss_unix_field.c src/libnsss/nsss-unix-internal.h src/libnsss/nsss_unix_getgrent.o src/libnsss/nsss_unix_getgrent.lo: src/libnsss/nsss_unix_getgrent.c src/libnsss/nsss-internal.h src/libnsss/nsss-unix-internal.h src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_getgrent_r.o src/libnsss/nsss_unix_getgrent_r.lo: src/libnsss/nsss_unix_getgrent_r.c src/libnsss/nsss-internal.h src/libnsss/nsss-unix-internal.h src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_getgrgid.o src/libnsss/nsss_unix_getgrgid.lo: src/libnsss/nsss_unix_getgrgid.c src/libnsss/nsss-internal.h src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_getgrgid_r.o src/libnsss/nsss_unix_getgrgid_r.lo: src/libnsss/nsss_unix_getgrgid_r.c src/libnsss/nsss-internal.h src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_getgrnam.o src/libnsss/nsss_unix_getgrnam.lo: src/libnsss/nsss_unix_getgrnam.c src/libnsss/nsss-internal.h src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_getgrnam_r.o src/libnsss/nsss_unix_getgrnam_r.lo: src/libnsss/nsss_unix_getgrnam_r.c src/libnsss/nsss-internal.h src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_getgrouplist.o src/libnsss/nsss_unix_getgrouplist.lo: src/libnsss/nsss_unix_getgrouplist.c src/libnsss/nsss-internal.h src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_getgrouplist_preadjust.o src/libnsss/nsss_unix_getgrouplist_preadjust.lo: src/libnsss/nsss_unix_getgrouplist_preadjust.c src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_getpwent.o src/libnsss/nsss_unix_getpwent.lo: src/libnsss/nsss_unix_getpwent.c src/libnsss/nsss-internal.h src/libnsss/nsss-unix-internal.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-unix.h src/libnsss/nsss_unix_getpwent_r.o src/libnsss/nsss_unix_getpwent_r.lo: src/libnsss/nsss_unix_getpwent_r.c src/libnsss/nsss-internal.h src/libnsss/nsss-unix-internal.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-unix.h src/libnsss/nsss_unix_getpwnam.o src/libnsss/nsss_unix_getpwnam.lo: src/libnsss/nsss_unix_getpwnam.c src/libnsss/nsss-internal.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-unix.h src/libnsss/nsss_unix_getpwnam_r.o src/libnsss/nsss_unix_getpwnam_r.lo: src/libnsss/nsss_unix_getpwnam_r.c src/libnsss/nsss-internal.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-unix.h src/libnsss/nsss_unix_getpwuid.o src/libnsss/nsss_unix_getpwuid.lo: src/libnsss/nsss_unix_getpwuid.c src/libnsss/nsss-internal.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-unix.h src/libnsss/nsss_unix_getpwuid_r.o src/libnsss/nsss_unix_getpwuid_r.lo: src/libnsss/nsss_unix_getpwuid_r.c src/libnsss/nsss-internal.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-unix.h src/libnsss/nsss_unix_getspent.o src/libnsss/nsss_unix_getspent.lo: src/libnsss/nsss_unix_getspent.c src/libnsss/nsss-internal.h src/libnsss/nsss-unix-internal.h src/include/nsss/nsss-unix.h src/include/nsss/shadow-unix.h src/libnsss/nsss_unix_getspent_r.o src/libnsss/nsss_unix_getspent_r.lo: src/libnsss/nsss_unix_getspent_r.c src/libnsss/nsss-internal.h src/libnsss/nsss-unix-internal.h src/include/nsss/nsss-unix.h src/include/nsss/shadow-unix.h src/libnsss/nsss_unix_getspnam.o src/libnsss/nsss_unix_getspnam.lo: src/libnsss/nsss_unix_getspnam.c src/libnsss/nsss-internal.h src/include/nsss/nsss-unix.h src/include/nsss/shadow-unix.h src/libnsss/nsss_unix_getspnam_r.o src/libnsss/nsss_unix_getspnam_r.lo: src/libnsss/nsss_unix_getspnam_r.c src/libnsss/nsss-internal.h src/include/nsss/nsss-unix.h src/include/nsss/shadow-unix.h src/libnsss/nsss_unix_grp_get.o src/libnsss/nsss_unix_grp_get.lo: src/libnsss/nsss_unix_grp_get.c src/libnsss/nsss-unix-internal.h src/include/nsss/grp-def.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_grp_getbygid.o src/libnsss/nsss_unix_grp_getbygid.lo: src/libnsss/nsss_unix_grp_getbygid.c src/include/nsss/grp-def.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_grp_getbyname.o src/libnsss/nsss_unix_grp_getbyname.lo: src/libnsss/nsss_unix_grp_getbyname.c src/include/nsss/grp-def.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_grp_getlist.o src/libnsss/nsss_unix_grp_getlist.lo: src/libnsss/nsss_unix_grp_getlist.c src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_grp_here.o src/libnsss/nsss_unix_grp_here.lo: src/libnsss/nsss_unix_grp_here.c src/libnsss/nsss-unix-internal.h src/libnsss/nsss_unix_maybe_start.o src/libnsss/nsss_unix_maybe_start.lo: src/libnsss/nsss_unix_maybe_start.c src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_pwd_get.o src/libnsss/nsss_unix_pwd_get.lo: src/libnsss/nsss_unix_pwd_get.c src/libnsss/nsss-unix-internal.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-def.h src/libnsss/nsss_unix_pwd_getbyname.o src/libnsss/nsss_unix_pwd_getbyname.lo: src/libnsss/nsss_unix_pwd_getbyname.c src/include/nsss/nsss-unix.h src/include/nsss/pwd-def.h src/libnsss/nsss_unix_pwd_getbyuid.o src/libnsss/nsss_unix_pwd_getbyuid.lo: src/libnsss/nsss_unix_pwd_getbyuid.c src/include/nsss/nsss-unix.h src/include/nsss/pwd-def.h src/libnsss/nsss_unix_pwd_here.o src/libnsss/nsss_unix_pwd_here.lo: src/libnsss/nsss_unix_pwd_here.c src/libnsss/nsss-unix-internal.h src/libnsss/nsss_unix_rewind.o src/libnsss/nsss_unix_rewind.lo: src/libnsss/nsss_unix_rewind.c src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_setgrent.o src/libnsss/nsss_unix_setgrent.lo: src/libnsss/nsss_unix_setgrent.c src/libnsss/nsss-unix-internal.h src/include/nsss/grp-unix.h src/include/nsss/nsss-unix.h src/libnsss/nsss_unix_setpwent.o src/libnsss/nsss_unix_setpwent.lo: src/libnsss/nsss_unix_setpwent.c src/libnsss/nsss-unix-internal.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-unix.h src/libnsss/nsss_unix_setspent.o src/libnsss/nsss_unix_setspent.lo: src/libnsss/nsss_unix_setspent.c src/libnsss/nsss-unix-internal.h src/include/nsss/nsss-unix.h src/include/nsss/shadow-unix.h src/libnsss/nsss_unix_shadow_get.o src/libnsss/nsss_unix_shadow_get.lo: src/libnsss/nsss_unix_shadow_get.c src/libnsss/nsss-unix-internal.h src/include/nsss/nsss-unix.h src/include/nsss/shadow-def.h src/libnsss/nsss_unix_shadow_getbyname.o src/libnsss/nsss_unix_shadow_getbyname.lo: src/libnsss/nsss_unix_shadow_getbyname.c src/include/nsss/nsss-unix.h src/include/nsss/shadow-def.h src/libnsss/nsss_unix_shadow_here.o src/libnsss/nsss_unix_shadow_here.lo: src/libnsss/nsss_unix_shadow_here.c src/libnsss/nsss-unix-internal.h src/libnsss/nsss_unix_start.o src/libnsss/nsss_unix_start.lo: src/libnsss/nsss_unix_start.c src/include/nsss/nsss-unix.h src/nsssd/nsssd-nslcd.o src/nsssd/nsssd-nslcd.lo: src/nsssd/nsssd-nslcd.c src/include/nsss/nsssd.h src/nsssd/nsssd-nslcd.h src/nsssd/nsssd-switch.o src/nsssd/nsssd-switch.lo: src/nsssd/nsssd-switch.c src/include/nsss/nsss-switch.h src/include/nsss/nsssd.h src/nsssd/nsssd-unix.o src/nsssd/nsssd-unix.lo: src/nsssd/nsssd-unix.c src/include/nsss/grp-unix.h src/include/nsss/nsssd.h src/include/nsss/pwd-unix.h src/include/nsss/shadow-unix.h src/nsssd/nsssd_convert.o src/nsssd/nsssd_convert.lo: src/nsssd/nsssd_convert.c src/include/nsss/grp-def.h src/include/nsss/nsssd.h src/include/nsss/pwd-def.h src/include/nsss/shadow-def.h src/nsssd/nsssd_main.o src/nsssd/nsssd_main.lo: src/nsssd/nsssd_main.c src/include/nsss/grp-def.h src/include/nsss/nsss-switch.h src/include/nsss/nsssd.h src/include/nsss/pwd-def.h src/include/nsss/shadow-def.h src/tests/test-all-fallback.o src/tests/test-all-fallback.lo: src/tests/test-all-fallback.c src/include/nsss/grp-def.h src/include/nsss/nsss-all.h src/include/nsss/pwd-def.h src/tests/test-switch.o src/tests/test-switch.lo: src/tests/test-switch.c src/include/nsss/grp-def.h src/include/nsss/nsss-switch.h src/include/nsss/pwd-def.h src/tests/test-unix.o src/tests/test-unix.lo: src/tests/test-unix.c src/include/nsss/grp-def.h src/include/nsss/nsss-unix.h src/include/nsss/pwd-def.h ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) libnsss.a.xyzzy: src/libnsss/nsss_all_endgrent.o src/libnsss/nsss_all_endpwent.o src/libnsss/nsss_all_endspent.o src/libnsss/nsss_all_errno.o src/libnsss/nsss_all_getgrent.o src/libnsss/nsss_all_getgrent_r.o src/libnsss/nsss_all_getgrgid.o src/libnsss/nsss_all_getgrgid_r.o src/libnsss/nsss_all_getgrnam.o src/libnsss/nsss_all_getgrnam_r.o src/libnsss/nsss_all_getgrouplist.o src/libnsss/nsss_all_getpwent.o src/libnsss/nsss_all_getpwent_r.o src/libnsss/nsss_all_getpwnam.o src/libnsss/nsss_all_getpwnam_r.o src/libnsss/nsss_all_getpwuid.o src/libnsss/nsss_all_getpwuid_r.o src/libnsss/nsss_all_getspent.o src/libnsss/nsss_all_getspent_r.o src/libnsss/nsss_all_getspnam.o src/libnsss/nsss_all_getspnam_r.o src/libnsss/nsss_all_setgrent.o src/libnsss/nsss_all_setpwent.o src/libnsss/nsss_all_setspent.o src/libnsss/nsss_grp_copy.o src/libnsss/nsss_grp_here.o src/libnsss/nsss_grouplist_adjust.o src/libnsss/nsss_pwd_copy.o src/libnsss/nsss_pwd_here.o src/libnsss/nsss_shadow_copy.o src/libnsss/nsss_shadow_here.o src/libnsss/nsss_switch_end.o src/libnsss/nsss_switch_endgrent.o src/libnsss/nsss_switch_endpwent.o src/libnsss/nsss_switch_endspent.o src/libnsss/nsss_switch_getgrent.o src/libnsss/nsss_switch_getgrent_r.o src/libnsss/nsss_switch_getgrgid.o src/libnsss/nsss_switch_getgrgid_r.o src/libnsss/nsss_switch_getgrnam.o src/libnsss/nsss_switch_getgrnam_r.o src/libnsss/nsss_switch_getgrouplist.o src/libnsss/nsss_switch_getpwent.o src/libnsss/nsss_switch_getpwent_r.o src/libnsss/nsss_switch_getpwnam.o src/libnsss/nsss_switch_getpwnam_r.o src/libnsss/nsss_switch_getpwuid.o src/libnsss/nsss_switch_getpwuid_r.o src/libnsss/nsss_switch_getspent.o src/libnsss/nsss_switch_getspent_r.o src/libnsss/nsss_switch_getspnam.o src/libnsss/nsss_switch_getspnam_r.o src/libnsss/nsss_switch_grp_end.o src/libnsss/nsss_switch_grp_get.o src/libnsss/nsss_switch_grp_getbygid.o src/libnsss/nsss_switch_grp_getbyname.o src/libnsss/nsss_switch_grp_getlist.o src/libnsss/nsss_switch_grp_read.o src/libnsss/nsss_switch_grp_rewind.o src/libnsss/nsss_switch_here.o src/libnsss/nsss_switch_op.o src/libnsss/nsss_switch_pwd_end.o src/libnsss/nsss_switch_pwd_get.o src/libnsss/nsss_switch_pwd_getbyname.o src/libnsss/nsss_switch_pwd_getbyuid.o src/libnsss/nsss_switch_pwd_read.o src/libnsss/nsss_switch_pwd_rewind.o src/libnsss/nsss_switch_setgrent.o src/libnsss/nsss_switch_setpwent.o src/libnsss/nsss_switch_setspent.o src/libnsss/nsss_switch_shadow_end.o src/libnsss/nsss_switch_shadow_get.o src/libnsss/nsss_switch_shadow_getbyname.o src/libnsss/nsss_switch_shadow_read.o src/libnsss/nsss_switch_shadow_rewind.o src/libnsss/nsss_switch_start.o src/libnsss/nsss_unix_end.o src/libnsss/nsss_unix_endgrent.o src/libnsss/nsss_unix_endpwent.o src/libnsss/nsss_unix_endspent.o src/libnsss/nsss_unix_field.o src/libnsss/nsss_unix_getgrent.o src/libnsss/nsss_unix_getgrent_r.o src/libnsss/nsss_unix_getgrgid.o src/libnsss/nsss_unix_getgrgid_r.o src/libnsss/nsss_unix_getgrnam.o src/libnsss/nsss_unix_getgrnam_r.o src/libnsss/nsss_unix_getgrouplist.o src/libnsss/nsss_unix_getgrouplist_preadjust.o src/libnsss/nsss_unix_getpwent.o src/libnsss/nsss_unix_getpwent_r.o src/libnsss/nsss_unix_getpwnam.o src/libnsss/nsss_unix_getpwnam_r.o src/libnsss/nsss_unix_getpwuid.o src/libnsss/nsss_unix_getpwuid_r.o src/libnsss/nsss_unix_getspent.o src/libnsss/nsss_unix_getspent_r.o src/libnsss/nsss_unix_getspnam.o src/libnsss/nsss_unix_getspnam_r.o src/libnsss/nsss_unix_grp_get.o src/libnsss/nsss_unix_grp_getbygid.o src/libnsss/nsss_unix_grp_getbyname.o src/libnsss/nsss_unix_grp_getlist.o src/libnsss/nsss_unix_grp_here.o src/libnsss/nsss_unix_maybe_start.o src/libnsss/nsss_unix_pwd_get.o src/libnsss/nsss_unix_pwd_getbyname.o src/libnsss/nsss_unix_pwd_getbyuid.o src/libnsss/nsss_unix_pwd_here.o src/libnsss/nsss_unix_rewind.o src/libnsss/nsss_unix_setgrent.o src/libnsss/nsss_unix_setpwent.o src/libnsss/nsss_unix_setspent.o src/libnsss/nsss_unix_shadow_get.o src/libnsss/nsss_unix_shadow_getbyname.o src/libnsss/nsss_unix_shadow_here.o src/libnsss/nsss_unix_start.o else libnsss.a.xyzzy: src/libnsss/nsss_all_endgrent.lo src/libnsss/nsss_all_endpwent.lo src/libnsss/nsss_all_endspent.lo src/libnsss/nsss_all_errno.lo src/libnsss/nsss_all_getgrent.lo src/libnsss/nsss_all_getgrent_r.lo src/libnsss/nsss_all_getgrgid.lo src/libnsss/nsss_all_getgrgid_r.lo src/libnsss/nsss_all_getgrnam.lo src/libnsss/nsss_all_getgrnam_r.lo src/libnsss/nsss_all_getgrouplist.lo src/libnsss/nsss_all_getpwent.lo src/libnsss/nsss_all_getpwent_r.lo src/libnsss/nsss_all_getpwnam.lo src/libnsss/nsss_all_getpwnam_r.lo src/libnsss/nsss_all_getpwuid.lo src/libnsss/nsss_all_getpwuid_r.lo src/libnsss/nsss_all_getspent.lo src/libnsss/nsss_all_getspent_r.lo src/libnsss/nsss_all_getspnam.lo src/libnsss/nsss_all_getspnam_r.lo src/libnsss/nsss_all_setgrent.lo src/libnsss/nsss_all_setpwent.lo src/libnsss/nsss_all_setspent.lo src/libnsss/nsss_grp_copy.lo src/libnsss/nsss_grp_here.lo src/libnsss/nsss_grouplist_adjust.lo src/libnsss/nsss_pwd_copy.lo src/libnsss/nsss_pwd_here.lo src/libnsss/nsss_shadow_copy.lo src/libnsss/nsss_shadow_here.lo src/libnsss/nsss_switch_end.lo src/libnsss/nsss_switch_endgrent.lo src/libnsss/nsss_switch_endpwent.lo src/libnsss/nsss_switch_endspent.lo src/libnsss/nsss_switch_getgrent.lo src/libnsss/nsss_switch_getgrent_r.lo src/libnsss/nsss_switch_getgrgid.lo src/libnsss/nsss_switch_getgrgid_r.lo src/libnsss/nsss_switch_getgrnam.lo src/libnsss/nsss_switch_getgrnam_r.lo src/libnsss/nsss_switch_getgrouplist.lo src/libnsss/nsss_switch_getpwent.lo src/libnsss/nsss_switch_getpwent_r.lo src/libnsss/nsss_switch_getpwnam.lo src/libnsss/nsss_switch_getpwnam_r.lo src/libnsss/nsss_switch_getpwuid.lo src/libnsss/nsss_switch_getpwuid_r.lo src/libnsss/nsss_switch_getspent.lo src/libnsss/nsss_switch_getspent_r.lo src/libnsss/nsss_switch_getspnam.lo src/libnsss/nsss_switch_getspnam_r.lo src/libnsss/nsss_switch_grp_end.lo src/libnsss/nsss_switch_grp_get.lo src/libnsss/nsss_switch_grp_getbygid.lo src/libnsss/nsss_switch_grp_getbyname.lo src/libnsss/nsss_switch_grp_getlist.lo src/libnsss/nsss_switch_grp_read.lo src/libnsss/nsss_switch_grp_rewind.lo src/libnsss/nsss_switch_here.lo src/libnsss/nsss_switch_op.lo src/libnsss/nsss_switch_pwd_end.lo src/libnsss/nsss_switch_pwd_get.lo src/libnsss/nsss_switch_pwd_getbyname.lo src/libnsss/nsss_switch_pwd_getbyuid.lo src/libnsss/nsss_switch_pwd_read.lo src/libnsss/nsss_switch_pwd_rewind.lo src/libnsss/nsss_switch_setgrent.lo src/libnsss/nsss_switch_setpwent.lo src/libnsss/nsss_switch_setspent.lo src/libnsss/nsss_switch_shadow_end.lo src/libnsss/nsss_switch_shadow_get.lo src/libnsss/nsss_switch_shadow_getbyname.lo src/libnsss/nsss_switch_shadow_read.lo src/libnsss/nsss_switch_shadow_rewind.lo src/libnsss/nsss_switch_start.lo src/libnsss/nsss_unix_end.lo src/libnsss/nsss_unix_endgrent.lo src/libnsss/nsss_unix_endpwent.lo src/libnsss/nsss_unix_endspent.lo src/libnsss/nsss_unix_field.lo src/libnsss/nsss_unix_getgrent.lo src/libnsss/nsss_unix_getgrent_r.lo src/libnsss/nsss_unix_getgrgid.lo src/libnsss/nsss_unix_getgrgid_r.lo src/libnsss/nsss_unix_getgrnam.lo src/libnsss/nsss_unix_getgrnam_r.lo src/libnsss/nsss_unix_getgrouplist.lo src/libnsss/nsss_unix_getgrouplist_preadjust.lo src/libnsss/nsss_unix_getpwent.lo src/libnsss/nsss_unix_getpwent_r.lo src/libnsss/nsss_unix_getpwnam.lo src/libnsss/nsss_unix_getpwnam_r.lo src/libnsss/nsss_unix_getpwuid.lo src/libnsss/nsss_unix_getpwuid_r.lo src/libnsss/nsss_unix_getspent.lo src/libnsss/nsss_unix_getspent_r.lo src/libnsss/nsss_unix_getspnam.lo src/libnsss/nsss_unix_getspnam_r.lo src/libnsss/nsss_unix_grp_get.lo src/libnsss/nsss_unix_grp_getbygid.lo src/libnsss/nsss_unix_grp_getbyname.lo src/libnsss/nsss_unix_grp_getlist.lo src/libnsss/nsss_unix_grp_here.lo src/libnsss/nsss_unix_maybe_start.lo src/libnsss/nsss_unix_pwd_get.lo src/libnsss/nsss_unix_pwd_getbyname.lo src/libnsss/nsss_unix_pwd_getbyuid.lo src/libnsss/nsss_unix_pwd_here.lo src/libnsss/nsss_unix_rewind.lo src/libnsss/nsss_unix_setgrent.lo src/libnsss/nsss_unix_setpwent.lo src/libnsss/nsss_unix_setspent.lo src/libnsss/nsss_unix_shadow_get.lo src/libnsss/nsss_unix_shadow_getbyname.lo src/libnsss/nsss_unix_shadow_here.lo src/libnsss/nsss_unix_start.lo endif libnsss.so.xyzzy: EXTRA_LIBS := -lskarnet -lpthread libnsss.so.xyzzy: src/libnsss/nsss_all_endgrent.lo src/libnsss/nsss_all_endpwent.lo src/libnsss/nsss_all_endspent.lo src/libnsss/nsss_all_errno.lo src/libnsss/nsss_all_getgrent.lo src/libnsss/nsss_all_getgrent_r.lo src/libnsss/nsss_all_getgrgid.lo src/libnsss/nsss_all_getgrgid_r.lo src/libnsss/nsss_all_getgrnam.lo src/libnsss/nsss_all_getgrnam_r.lo src/libnsss/nsss_all_getgrouplist.lo src/libnsss/nsss_all_getpwent.lo src/libnsss/nsss_all_getpwent_r.lo src/libnsss/nsss_all_getpwnam.lo src/libnsss/nsss_all_getpwnam_r.lo src/libnsss/nsss_all_getpwuid.lo src/libnsss/nsss_all_getpwuid_r.lo src/libnsss/nsss_all_getspent.lo src/libnsss/nsss_all_getspent_r.lo src/libnsss/nsss_all_getspnam.lo src/libnsss/nsss_all_getspnam_r.lo src/libnsss/nsss_all_setgrent.lo src/libnsss/nsss_all_setpwent.lo src/libnsss/nsss_all_setspent.lo src/libnsss/nsss_grp_copy.lo src/libnsss/nsss_grp_here.lo src/libnsss/nsss_grouplist_adjust.lo src/libnsss/nsss_pwd_copy.lo src/libnsss/nsss_pwd_here.lo src/libnsss/nsss_shadow_copy.lo src/libnsss/nsss_shadow_here.lo src/libnsss/nsss_switch_end.lo src/libnsss/nsss_switch_endgrent.lo src/libnsss/nsss_switch_endpwent.lo src/libnsss/nsss_switch_endspent.lo src/libnsss/nsss_switch_getgrent.lo src/libnsss/nsss_switch_getgrent_r.lo src/libnsss/nsss_switch_getgrgid.lo src/libnsss/nsss_switch_getgrgid_r.lo src/libnsss/nsss_switch_getgrnam.lo src/libnsss/nsss_switch_getgrnam_r.lo src/libnsss/nsss_switch_getgrouplist.lo src/libnsss/nsss_switch_getpwent.lo src/libnsss/nsss_switch_getpwent_r.lo src/libnsss/nsss_switch_getpwnam.lo src/libnsss/nsss_switch_getpwnam_r.lo src/libnsss/nsss_switch_getpwuid.lo src/libnsss/nsss_switch_getpwuid_r.lo src/libnsss/nsss_switch_getspent.lo src/libnsss/nsss_switch_getspent_r.lo src/libnsss/nsss_switch_getspnam.lo src/libnsss/nsss_switch_getspnam_r.lo src/libnsss/nsss_switch_grp_end.lo src/libnsss/nsss_switch_grp_get.lo src/libnsss/nsss_switch_grp_getbygid.lo src/libnsss/nsss_switch_grp_getbyname.lo src/libnsss/nsss_switch_grp_getlist.lo src/libnsss/nsss_switch_grp_read.lo src/libnsss/nsss_switch_grp_rewind.lo src/libnsss/nsss_switch_here.lo src/libnsss/nsss_switch_op.lo src/libnsss/nsss_switch_pwd_end.lo src/libnsss/nsss_switch_pwd_get.lo src/libnsss/nsss_switch_pwd_getbyname.lo src/libnsss/nsss_switch_pwd_getbyuid.lo src/libnsss/nsss_switch_pwd_read.lo src/libnsss/nsss_switch_pwd_rewind.lo src/libnsss/nsss_switch_setgrent.lo src/libnsss/nsss_switch_setpwent.lo src/libnsss/nsss_switch_setspent.lo src/libnsss/nsss_switch_shadow_end.lo src/libnsss/nsss_switch_shadow_get.lo src/libnsss/nsss_switch_shadow_getbyname.lo src/libnsss/nsss_switch_shadow_read.lo src/libnsss/nsss_switch_shadow_rewind.lo src/libnsss/nsss_switch_start.lo src/libnsss/nsss_unix_end.lo src/libnsss/nsss_unix_endgrent.lo src/libnsss/nsss_unix_endpwent.lo src/libnsss/nsss_unix_endspent.lo src/libnsss/nsss_unix_field.lo src/libnsss/nsss_unix_getgrent.lo src/libnsss/nsss_unix_getgrent_r.lo src/libnsss/nsss_unix_getgrgid.lo src/libnsss/nsss_unix_getgrgid_r.lo src/libnsss/nsss_unix_getgrnam.lo src/libnsss/nsss_unix_getgrnam_r.lo src/libnsss/nsss_unix_getgrouplist.lo src/libnsss/nsss_unix_getgrouplist_preadjust.lo src/libnsss/nsss_unix_getpwent.lo src/libnsss/nsss_unix_getpwent_r.lo src/libnsss/nsss_unix_getpwnam.lo src/libnsss/nsss_unix_getpwnam_r.lo src/libnsss/nsss_unix_getpwuid.lo src/libnsss/nsss_unix_getpwuid_r.lo src/libnsss/nsss_unix_getspent.lo src/libnsss/nsss_unix_getspent_r.lo src/libnsss/nsss_unix_getspnam.lo src/libnsss/nsss_unix_getspnam_r.lo src/libnsss/nsss_unix_grp_get.lo src/libnsss/nsss_unix_grp_getbygid.lo src/libnsss/nsss_unix_grp_getbyname.lo src/libnsss/nsss_unix_grp_getlist.lo src/libnsss/nsss_unix_grp_here.lo src/libnsss/nsss_unix_maybe_start.lo src/libnsss/nsss_unix_pwd_get.lo src/libnsss/nsss_unix_pwd_getbyname.lo src/libnsss/nsss_unix_pwd_getbyuid.lo src/libnsss/nsss_unix_pwd_here.lo src/libnsss/nsss_unix_rewind.lo src/libnsss/nsss_unix_setgrent.lo src/libnsss/nsss_unix_setpwent.lo src/libnsss/nsss_unix_setspent.lo src/libnsss/nsss_unix_shadow_get.lo src/libnsss/nsss_unix_shadow_getbyname.lo src/libnsss/nsss_unix_shadow_here.lo src/libnsss/nsss_unix_start.lo ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) libnsssd.a.xyzzy: src/nsssd/nsssd_main.o src/nsssd/nsssd_convert.o else libnsssd.a.xyzzy: src/nsssd/nsssd_main.lo src/nsssd/nsssd_convert.lo endif libnsssd.so.xyzzy: EXTRA_LIBS := -lskarnet libnsssd.so.xyzzy: src/nsssd/nsssd_main.lo src/nsssd/nsssd_convert.lo nsssd-nslcd: EXTRA_LIBS := -lskarnet nsssd-nslcd: src/nsssd/nsssd-nslcd.o ${LIBNSSSD} nsssd-unix: EXTRA_LIBS := -lskarnet nsssd-unix: src/nsssd/nsssd-unix.o ${LIBNSSS} ${LIBNSSSD} test-all-fallback: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} test-all-fallback: src/tests/test-all-fallback.o ${LIBNSSS} test-switch: EXTRA_LIBS := -lskarnet ${SOCKET_LIB} ${SYSCLOCK_LIB} test-switch: src/tests/test-switch.o ${LIBNSSS} test-unix: EXTRA_LIBS := -lskarnet test-unix: src/tests/test-unix.o ${LIBNSSS} nsss-0.0.2.1/package/deps-build0000644000000000000000000000002613204564673013102 0ustar /package/prog/skalibs nsss-0.0.2.1/package/targets.mak0000644000000000000000000000023513316416014013261 0ustar BIN_TARGETS := \ nsssd-unix \ nsssd-nslcd LIBEXEC_TARGETS := TEST_BINS := \ test-switch \ test-unix \ test-all-fallback LIB_DEFS := NSSS=nsss NSSSD=nsssd nsss-0.0.2.1/package/modes0000644000000000000000000000004113313300336012137 0ustar nsssd-unix 0755 nsssd-nslcd 0755 nsss-0.0.2.1/package/info0000644000000000000000000000010413553353537012004 0ustar package=nsss version=0.0.2.1 category=admin package_macro_name=NSSS nsss-0.0.2.1/COPYING0000644000000000000000000000137013415640601010560 0ustar Copyright (c) 2018-2019 Laurent Bercot Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. nsss-0.0.2.1/configure0000755000000000000000000003262213553343654011453 0ustar #!/bin/sh cd `dirname "$0"` . package/info usage () { cat </dev/null 2>&1 && { echo "$1" ; return 0 ; } $1 EOF echo "$1" | sed -e "s/'/'\\\\''/g" -e "1s/^/'/" -e "\$s/\$/'/" -e "s#^'\([-[:alnum:]_,./:]*\)=\(.*\)\$#\1='\2#" -e "s|\*/|* /|g" } fail () { echo "$*" exit 1 } fnmatch () { eval "case \"\$2\" in $1) return 0 ;; *) return 1 ;; esac" } cmdexists () { type "$1" >/dev/null 2>&1 } trycc () { test -z "$CC_AUTO" && cmdexists "$1" && CC_AUTO="$*" } stripdir () { while eval "fnmatch '*/' \"\${$1}\"" ; do eval "$1=\${$1%/}" done } tryflag () { echo "Checking whether compiler accepts $2 ..." echo "typedef int x;" > "$tmpc" if $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST "$2" -c -o /dev/null "$tmpc" >/dev/null 2>&1 ; then echo " ... yes" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" return 0 else echo " ... no" return 1 fi } tryldflag () { echo "Checking whether linker accepts $2 ..." echo "typedef int x;" > "$tmpc" if $CC_AUTO $CFLAGS_AUTO $CFLAGS $CFLAGS_POST $LDFLAGS_AUTO $LDFLAGS $LDFLAGS_POST -nostdlib "$2" -o /dev/null "$tmpc" >/dev/null 2>&1 ; then echo " ... yes" eval "$1=\"\${$1} \$2\"" eval "$1=\${$1# }" return 0 else echo " ... no" return 1 fi } # Actual script CC_AUTO= CPPFLAGS_AUTO="-D_POSIX_C_SOURCE=200809L -D_XOPEN_SOURCE=700 -iquote src/include-local -Isrc/include" CPPFLAGS_POST="$CPPFLAGS" CPPFLAGS= CFLAGS_AUTO="-pipe -Wall" CFLAGS_POST="$CFLAGS" CFLAGS=-O2 LDFLAGS_AUTO= LDFLAGS_POST="$LDFLAGS" LDFLAGS= LDFLAGS_NOSHARED= LDFLAGS_SHARED=-shared prefix= exec_prefix='$prefix' dynlibdir='$prefix/lib' libexecdir='$exec_prefix/libexec' bindir='$exec_prefix/bin' libdir='$prefix/lib/$package' includedir='$prefix/include' sysdeps='$prefix/lib/skalibs/sysdeps' manualsysdeps=false shared=false static=true allpic=true slashpackage=false abspath=false sproot= home= exthome= allstatic=true evenmorestatic=false addincpath='' addlibspath='' addlibdpath='' vpaths='' vpathd='' build= nsssdpath=/run/service/nsssd/s for arg ; do case "$arg" in --help) usage ;; --prefix=*) prefix=${arg#*=} ;; --exec-prefix=*) exec_prefix=${arg#*=} ;; --dynlibdir=*) dynlibdir=${arg#*=} ;; --libexecdir=*) libexecdir=${arg#*=} ;; --bindir=*) bindir=${arg#*=} ;; --libdir=*) libdir=${arg#*=} ;; --includedir=*) includedir=${arg#*=} ;; --with-sysdeps=*) sysdeps=${arg#*=} manualsysdeps=true ;; --with-include=*) var=${arg#*=} ; stripdir var ; addincpath="$addincpath -I$var" ;; --with-lib=*) var=${arg#*=} ; stripdir var ; addlibspath="$addlibspath -L$var" ; vpaths="$vpaths $var" ;; --with-dynlib=*) var=${arg#*=} ; stripdir var ; addlibdpath="$addlibdpath -L$var" ; vpathd="$vpathd $var" ;; --enable-shared|--enable-shared=yes) shared=true ;; --disable-shared|--enable-shared=no) shared=false ;; --enable-static|--enable-static=yes) static=true ;; --disable-static|--enable-static=no) static=false ;; --enable-allstatic|--enable-allstatic=yes) allstatic=true ;; --disable-allstatic|--enable-allstatic=no) allstatic=false ; evenmorestatic=false ;; --enable-static-libc|--enable-static-libc=yes) allstatic=true ; evenmorestatic=true ;; --disable-static-libc|--enable-static-libc=no) evenmorestatic=false ;; --enable-all-pic|--enable-all-pic=yes) allpic=true ;; --disable-all-pic|--enable-all-pic=no) allpic=false ;; --enable-slashpackage=*) sproot=${arg#*=} ; slashpackage=true ; ;; --enable-slashpackage) sproot= ; slashpackage=true ;; --disable-slashpackage) sproot= ; slashpackage=false ;; --enable-absolute-paths|--enable-absolute-paths=yes) abspath=true ;; --disable-absolute-paths|--enable-absolute-paths=no) abspath=false ;; --enable-*|--disable-*|--with-*|--without-*|--*dir=*) ;; --host=*|--target=*) target=${arg#*=} ;; --build=*) build=${arg#*=} ;; --with-nsssd-socket=*) nsssdpath=${arg#*=} ;; -* ) echo "$0: unknown option $arg" ;; *=*) ;; *) target=$arg ;; esac done # Add /usr in the default default case if test -z "$prefix" ; then if test "$libdir" = '$prefix/lib/$package' ; then libdir=/usr/lib/$package fi if test "$includedir" = '$prefix/include' ; then includedir=/usr/include fi if test "$sysdeps" = '$prefix/lib/skalibs/sysdeps' ; then sysdeps=/usr/lib/skalibs/sysdeps fi fi # Expand installation directories stripdir prefix for i in exec_prefix dynlibdir libexecdir bindir libdir includedir sysdeps sproot ; do eval tmp=\${$i} eval $i=$tmp stripdir $i done # Get usable temp filenames i=0 set -C while : ; do i=$(($i+1)) tmpc="./tmp-configure-$$-$PPID-$i.c" tmpe="./tmp-configure-$$-$PPID-$i.tmp" 2>|/dev/null > "$tmpc" && break 2>|/dev/null > "$tmpe" && break test "$i" -gt 50 && fail "$0: cannot create temporary files" done set +C trap 'rm -f "$tmpc" "$tmpe"' EXIT ABRT INT QUIT TERM HUP # Set slashpackage values if $slashpackage ; then home=${sproot}/package/${category}/${package}-${version} exthome=${sproot}/package/${category}/${package} if $manualsysdeps ; then : else sysdeps=${sproot}/package/prog/skalibs/sysdeps fi extbinprefix=${exthome}/command dynlibdir=${home}/library.so bindir=${home}/command libdir=${home}/library libexecdir=$bindir includedir=${home}/include while read dep ; do addincpath="$addincpath -I${sproot}${dep}/include" vpaths="$vpaths ${sproot}${dep}/library" addlibspath="$addlibspath -L${sproot}${dep}/library" vpathd="$vpathd ${sproot}${dep}/library.so" addlibdpath="$addlibdpath -L${sproot}${dep}/library.so" done < package/deps-build fi # Find a C compiler to use if test -n "$target" && test x${build} != x${target} ; then cross=${target}- else cross= fi echo "Checking for C compiler..." trycc ${CC} if test -n "$CC_AUTO" ; then b=`basename "$CC"` adjust_cross=false if test "$b" != "$CC" ; then adjust_cross=true echo "$0: warning: compiler $CC is declared with its own path. If it's not accessible via PATH, you will need to pass AR, RANLIB and STRIP make variables to the make invocation." 1>&2 fi if test -n "$cross" ; then if test "$b" = "${b##$cross}" ; then echo "$0: warning: compiler $CC is declared as a cross-compiler for target $target but does not start with prefix ${cross}" 1>&2 elif $adjust_cross ; then cross=`dirname "$CC"`/"$cross" fi fi fi trycc ${cross}gcc trycc ${cross}clang trycc ${cross}cc test -n "$CC_AUTO" || { echo "$0: cannot find a C compiler" ; exit 1 ; } echo " ... $CC_AUTO" echo "Checking whether C compiler works... " echo "typedef int x;" > "$tmpc" if $CC_AUTO $CPPFLAGS_AUTO $CPPFLAGS $CPPFLAGS_POST $CFLAGS_AUTO $CFLAGS $CFLAGS_POST -c -o /dev/null "$tmpc" 2>"$tmpe" ; then echo " ... yes" else echo " ... no. Compiler output follows:" cat < "$tmpe" exit 1 fi echo "Checking target system type..." if test -z "$target" ; then if test -n "$build" ; then target=$build ; else target=$($CC_AUTO -dumpmachine 2>/dev/null) || target=unknown fi fi echo " ... $target" if test ! -d $sysdeps || test ! -f $sysdeps/target ; then echo "$0: error: $sysdeps is not a valid sysdeps directory" exit 1 fi if [ "x$target" != "x$(cat $sysdeps/target)" ] ; then echo "$0: error: target $target does not match the contents of $sysdeps/target" exit 1 fi if $allpic ; then tryflag CPPFLAGS_AUTO -fPIC fi spawn_lib=$(cat $sysdeps/spawn.lib) socket_lib=$(cat $sysdeps/socket.lib) sysclock_lib=$(cat $sysdeps/sysclock.lib) timer_lib=$(cat $sysdeps/timer.lib) util_lib=$(cat $sysdeps/util.lib) tryflag CFLAGS_AUTO -std=c99 tryflag CFLAGS -fomit-frame-pointer tryflag CFLAGS_AUTO -fno-exceptions tryflag CFLAGS_AUTO -fno-unwind-tables tryflag CFLAGS_AUTO -fno-asynchronous-unwind-tables tryflag CFLAGS_AUTO -Wa,--noexecstack tryflag CFLAGS -fno-stack-protector tryflag CPPFLAGS_AUTO -Werror=implicit-function-declaration tryflag CPPFLAGS_AUTO -Werror=implicit-int tryflag CPPFLAGS_AUTO -Werror=pointer-sign tryflag CPPFLAGS_AUTO -Werror=pointer-arith tryflag CFLAGS_AUTO -ffunction-sections tryflag CFLAGS_AUTO -fdata-sections tryldflag LDFLAGS_AUTO -Wl,--sort-section=alignment tryldflag LDFLAGS_AUTO -Wl,--sort-common CPPFLAGS_AUTO="${CPPFLAGS_AUTO}${addincpath}" if $evenmorestatic ; then LDFLAGS_NOSHARED=-static fi if $shared ; then tryldflag LDFLAGS -Wl,--hash-style=both fi LDFLAGS_SHARED="${LDFLAGS_SHARED}${addlibdpath}" if $allstatic ; then LDFLAGS_NOSHARED="${LDFLAGS_NOSHARED}${addlibspath}" tryldflag LDFLAGS_NOSHARED -Wl,--gc-sections else LDFLAGS_NOSHARED="${LDFLAGS_NOSHARED}${addlibdpath}" fi if test -z "$vpaths" ; then while read dep ; do base=$(basename $dep) ; vpaths="$vpaths /usr/lib/$base" addlibspath="$addlibspath -L/usr/lib/$base" done < package/deps-build fi echo "Creating config.mak..." cmdline=$(quote "$0") for i ; do cmdline="$cmdline $(quote "$i")" ; done exec 3>&1 1>config.mak cat << EOF # This file was generated by: # $cmdline # Any changes made here will be lost if configure is re-run. target := $target package := $package prefix := $prefix exec_prefix := $exec_prefix dynlibdir := $dynlibdir libexecdir := $libexecdir bindir := $bindir libdir := $libdir includedir := $includedir sysdeps := $sysdeps slashpackage := $slashpackage sproot := $sproot version := $version home := $home exthome := $exthome SPAWN_LIB := ${spawn_lib} SOCKET_LIB := ${socket_lib} SYSCLOCK_LIB := ${sysclock_lib} TIMER_LIB := ${timer_lib} UTIL_LIB := ${util_lib} CC := $CC_AUTO CPPFLAGS_AUTO := $CPPFLAGS_AUTO CPPFLAGS := $CPPFLAGS $CPPFLAGS_POST CFLAGS_AUTO := $CFLAGS_AUTO CFLAGS := $CFLAGS $CFLAGS_POST LDFLAGS_AUTO := $LDFLAGS_AUTO LDFLAGS := $LDFLAGS $LDFLAGS_POST LDFLAGS_SHARED := $LDFLAGS_SHARED LDFLAGS_NOSHARED := $LDFLAGS_NOSHARED CROSS_COMPILE := $cross vpath lib%.a$vpaths vpath lib%.so$vpathd EOF if $allstatic ; then echo ".LIBPATTERNS := lib%.a" echo "DO_ALLSTATIC := 1" else echo ".LIBPATTERNS := lib%.so" fi if $static ; then echo "DO_STATIC := 1" else echo "DO_STATIC :=" fi if $shared ; then echo "DO_SHARED := 1" else echo "DO_SHARED :=" fi if $allpic ; then echo "STATIC_LIBS_ARE_PIC := 1" else echo "STATIC_LIBS_ARE_PIC :=" fi exec 1>&3 3>&- echo " ... done." echo "Creating src/include/${package}/config.h..." mkdir -p -m 0755 src/include/${package} exec 3>&1 1> src/include/${package}/config.h cat <&3 3>&- echo " ... done." nsss-0.0.2.1/tools/0002755000000000000000000000000013553363665010705 5ustar nsss-0.0.2.1/tools/install.sh0000755000000000000000000000167513204564673012714 0ustar #!/bin/sh usage() { echo "usage: $0 [-D] [-l] [-m mode] src dst" 1>&2 exit 1 } mkdirp=false symlink=false mode=0755 while getopts Dlm: name ; do case "$name" in D) mkdirp=true ;; l) symlink=true ;; m) mode=$OPTARG ;; ?) usage ;; esac done shift $(($OPTIND - 1)) test "$#" -eq 2 || usage src=$1 dst=$2 tmp="$dst.tmp.$$" case "$dst" in */) echo "$0: $dst ends in /" 1>&2 ; exit 1 ;; esac set -C set -e if $mkdirp ; then umask 022 case "$2" in */*) mkdir -p "${dst%/*}" ;; esac fi trap 'rm -f "$tmp"' EXIT INT QUIT TERM HUP umask 077 if $symlink ; then ln -s "$src" "$tmp" else cat < "$1" > "$tmp" chmod "$mode" "$tmp" fi mv -f "$tmp" "$dst" if test -d "$dst" ; then rm -f "$dst/$(basename $tmp)" if $symlink ; then mkdir "$tmp" ln -s "$src" "$tmp/$(basename $dst)" mv -f "$tmp/$(basename $dst)" "${dst%/*}" rmdir "$tmp" else echo "$0: $dst is a directory" 1>&2 exit 1 fi fi nsss-0.0.2.1/tools/gen-deps.sh0000755000000000000000000000474313553363665012754 0ustar #!/bin/sh -e . package/info echo '#' echo '# This file has been generated by tools/gen-deps.sh' echo '#' echo for dir in src/include/${package} src/* ; do for file in $(ls -1 $dir | grep -- \\.h$) ; do { grep -F -- "#include <${package}/" < ${dir}/$file | cut -d'<' -f2 | cut -d'>' -f1 ; grep -- '#include ".*\.h"' < ${dir}/$file | cut -d'"' -f2 } | sort -u | { deps= while read dep ; do if echo $dep | grep -q "^${package}/" ; then deps="$deps src/include/$dep" elif test -f "${dir}/$dep" ; then deps="$deps ${dir}/$dep" else deps="$deps src/include-local/$dep" fi done if test -n "$deps" ; then echo "${dir}/${file}:${deps}" fi } done done for dir in src/* ; do for file in $(ls -1 $dir | grep -- \\.c$) ; do { grep -F -- "#include <${package}/" < ${dir}/$file | cut -d'<' -f2 | cut -d'>' -f1 ; grep -- '#include ".*\.h"' < ${dir}/$file | cut -d'"' -f2 } | sort -u | { deps=" ${dir}/$file" while read dep ; do if echo $dep | grep -q "^${package}/" ; then deps="$deps src/include/$dep" elif test -f "${dir}/$dep" ; then deps="$deps ${dir}/$dep" else deps="$deps src/include-local/$dep" fi done o=$(echo $file | sed s/\\.c$/.o/) lo=$(echo $file | sed s/\\.c$/.lo/) echo "${dir}/${o} ${dir}/${lo}:${deps}" } done done echo for dir in $(ls -1 src | grep -v ^include) ; do for file in $(ls -1 src/$dir/deps-lib) ; do deps= libs= while read dep ; do if echo $dep | grep -q -e ^-l -e '^\${.*_LIB}' ; then libs="$libs $dep" else deps="$deps src/$dir/$dep" fi done < src/$dir/deps-lib/$file echo 'ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),)' echo "lib${file}.a.xyzzy:$deps" echo else echo "lib${file}.a.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" echo endif echo "lib${file}.so.xyzzy: EXTRA_LIBS :=$libs" echo "lib${file}.so.xyzzy:$(echo "$deps" | sed 's/\.o/.lo/g')" done for file in $(ls -1 src/$dir/deps-exe) ; do deps= libs= while read dep ; do if echo $dep | grep -q -- \\.o$ ; then dep="src/$dir/$dep" fi if echo $dep | grep -q -e ^-l -e '^\${.*_LIB}' ; then libs="$libs $dep" else deps="$deps $dep" fi done < src/$dir/deps-exe/$file echo "$file: EXTRA_LIBS :=$libs" echo "$file: src/$dir/$file.o$deps" done done nsss-0.0.2.1/tools/run-test.sh0000755000000000000000000000103713316263404013007 0ustar #!/bin/sh -e prog="$1" if test -x "./src/tests/${prog}.wrapper" ; then cmd="./src/tests/${prog}.wrapper $prog" else cmd="./$prog" fi if test -r "./src/tests/${prog}.expected" ; then cp -f "./src/tests/${prog}.expected" "./${prog}.expected" elif test -x "./src/tests/${prog}.baseline" ; then "./src/tests/${prog}.baseline" > "./${prog}.expected" else echo "run-test.sh: fatal: missing baseline for $prog" 1>&2 ; exit 100 fi $cmd | diff "./${prog}.expected" - rm -f "./${prog}.expected" echo "run-test.sh: info: $prog: pass" 1>&2 nsss-0.0.2.1/README.macosx0000644000000000000000000000025513204564673011711 0ustar This package will compile and run on Darwin (MacOS X), but the building of shared libraries is not supported. Make sure you use the --disable-shared option to configure. nsss-0.0.2.1/NEWS0000644000000000000000000000046013553353557010241 0ustar Changelog for nsss. In 0.0.2 1 ---------- - Bugfixes. In 0.0.2.0 ---------- - Adaptation to skalibs-2.9.0.0. - getgrouplist() support. In 0.0.1.2 ---------- - Bugfixes. In 0.0.1.1 ---------- - Bugfixes. - Everything builds as PIC by default. In 0.0.1.0 ---------- - Initial release. nsss-0.0.2.1/Makefile0000644000000000000000000001232213515356672011201 0ustar # # This Makefile requires GNU make. # # Do not make changes here. # Use the included .mak files. # it: all make_need := 3.81 ifeq "" "$(strip $(filter $(make_need), $(firstword $(sort $(make_need) $(MAKE_VERSION)))))" fail := $(error Your make ($(MAKE_VERSION)) is too old. You need $(make_need) or newer) endif CC = $(error Please use ./configure first) STATIC_LIBS := SHARED_LIBS := INTERNAL_LIBS := EXTRA_TARGETS := LIB_DEFS := define library_definition LIB$(firstword $(subst =, ,$(1))) := lib$(lastword $(subst =, ,$(1))).$(if $(DO_ALLSTATIC),a,so).xyzzy ifdef DO_SHARED SHARED_LIBS += lib$(lastword $(subst =, ,$(1))).so.xyzzy endif ifdef DO_STATIC STATIC_LIBS += lib$(lastword $(subst =, ,$(1))).a.xyzzy endif endef -include config.mak include package/targets.mak $(foreach var,$(LIB_DEFS),$(eval $(call library_definition,$(var)))) include package/deps.mak version_m := $(basename $(version)) version_M := $(basename $(version_m)) version_l := $(basename $(version_M)) CPPFLAGS_ALL := $(CPPFLAGS_AUTO) $(CPPFLAGS) CFLAGS_ALL := $(CFLAGS_AUTO) $(CFLAGS) ifeq ($(strip $(STATIC_LIBS_ARE_PIC)),) CFLAGS_SHARED := -fPIC else CFLAGS_SHARED := endif LDFLAGS_ALL := $(LDFLAGS_AUTO) $(LDFLAGS) AR := $(CROSS_COMPILE)ar RANLIB := $(CROSS_COMPILE)ranlib STRIP := $(CROSS_COMPILE)strip INSTALL := ./tools/install.sh ALL_BINS := $(LIBEXEC_TARGETS) $(BIN_TARGETS) ALL_LIBS := $(SHARED_LIBS) $(STATIC_LIBS) $(INTERNAL_LIBS) ALL_INCLUDES := $(wildcard src/include/$(package)/*.h) all: $(ALL_LIBS) $(ALL_BINS) $(ALL_INCLUDES) src/include/pwd.h src/include/grp.h src/include/shadow.h clean: @exec rm -f $(ALL_LIBS) $(ALL_BINS) $(wildcard src/*/*.o src/*/*.lo) $(TEST_BINS) $(EXTRA_TARGETS) distclean: clean @exec rm -f config.mak src/include/$(package)/config.h tgz: distclean @. package/info && \ rm -rf /tmp/$$package-$$version && \ cp -a . /tmp/$$package-$$version && \ cd /tmp && \ tar -zpcv --owner=0 --group=0 --numeric-owner --exclude=.git* -f /tmp/$$package-$$version.tar.gz $$package-$$version && \ exec rm -rf /tmp/$$package-$$version strip: $(ALL_LIBS) $(ALL_BINS) ifneq ($(strip $(STATIC_LIBS)),) exec $(STRIP) -x -R .note -R .comment -R .note.GNU-stack $(STATIC_LIBS) endif ifneq ($(strip $(ALL_BINS)$(SHARED_LIBS)),) exec $(STRIP) -R .note -R .comment -R .note.GNU-stack $(ALL_BINS) $(SHARED_LIBS) endif install: install-dynlib install-libexec install-bin install-lib install-include install-dynlib: $(SHARED_LIBS:lib%.so.xyzzy=$(DESTDIR)$(dynlibdir)/lib%.so) install-libexec: $(LIBEXEC_TARGETS:%=$(DESTDIR)$(libexecdir)/%) install-bin: $(BIN_TARGETS:%=$(DESTDIR)$(bindir)/%) install-lib: $(STATIC_LIBS:lib%.a.xyzzy=$(DESTDIR)$(libdir)/lib%.a) install-include: $(ALL_INCLUDES:src/include/$(package)/%.h=$(DESTDIR)$(includedir)/$(package)/%.h) $(DESTDIR)$(includedir)/pwd.h $(DESTDIR)$(includedir)/grp.h $(DESTDIR)$(includedir)/shadow.h install-data: $(ALL_DATA:src/etc/%=$(DESTDIR)$(datadir)/%) tests: $(TEST_BINS) check: tests @for i in $(TEST_BINS) ; do ./tools/run-test.sh $$i || exit 1 ; done ifneq ($(exthome),) $(DESTDIR)$(exthome): $(DESTDIR)$(home) exec $(INSTALL) -l $(notdir $(home)) $(DESTDIR)$(exthome) update: $(DESTDIR)$(exthome) global-links: $(DESTDIR)$(exthome) $(SHARED_LIBS:lib%.so.xyzzy=$(DESTDIR)$(sproot)/library.so/lib%.so.$(version_M)) $(BIN_TARGETS:%=$(DESTDIR)$(sproot)/command/%) $(DESTDIR)$(sproot)/command/%: $(DESTDIR)$(home)/command/% exec $(INSTALL) -D -l ..$(subst $(sproot),,$(exthome))/command/$( nsss - a secure NSS-like implementation for small libcs

Software
skarnet.org

nsss

What is it ?

nsss is an implementation of a subset of the pwd.h, group.h and shadow.h family of functions, performing user database access on Unix systems.

Usually, user database access via getpwnam() and similar function is provided by the system's libc. However, not all libcs implement a configurable backend for the user/group database. For instance the musl libc, on Linux, only supports the standard /etc/passwd mechanism; it also supports the nscd protocol but this is not quite enough:

  • musl only connects to nscd when it cannot find an answer in its files backend
  • The nscd protocol does not support enumeration, so primitives such as getpwent() cannot be implemented over nscd.

The mechanism used by glibc, called Name Service Switch (abbreviated to nsswitch or NSS), has its own set of issues that makes it unsuitable in certain situations.

nsss is a secure implementation of a "name service switch": configurable user/group/shadow database access, providing getpwnam() et al. functionality by communicating over a Unix domain socket with a daemon; the daemon can perform lookups in any database it chooses.

nsss does not perform dynamic module loading, only adds a small footprint to the application's binary, and does not add any complex decision engine into the client's address space. Applications can be statically linked against the nsss library, and still benefit from configurable user database access functions.

Installation

Requirements

  • A POSIX-compliant system with a standard C development environment
  • GNU make, version 3.81 or later
  • skalibs version 2.9.1.0 or later. It's a build-time requirement. It's also a run-time requirement if you link against the shared version of the skalibs library.
  • s6 version 2.9.0.1 or later. It's a run-time requirement only, to run the nsssd service (and can be done without if you have a suitable replacement for s6-ipcserver).

Licensing

nsss is free software. It is available under the ISC license.

Download

  • The current released version of nsss is 0.0.2.1.
  • Alternatively, you can checkout a copy of the nsss git repository: 
     git clone git://git.skarnet.org/nsss
  • There's also a GitHub mirror of the nsss git repository.

Compilation

  • See the enclosed INSTALL file for installation details.

Upgrade notes

  • This page lists the differences to be aware of between the previous versions of nsss and the current one.

Reference

Commands

The following commands are not meant to be directly invoked on the command-line. They are meant to be used behind a Unix domain socket super-server such as s6-ipcserver in order to provide a local service. Depending on the chosen command, the service will provide a different backend to the name service.

Future versions of nsss will come with more backends.

Libraries

  • The nsss library interface, which applications use. A client application using one of the following primitives will automatically perform libnsss calls:
    • endpwent()
    • setpwent()
    • getpwent()
    • getpwent_r()
    • getpwuid()
    • getpwuid_r()
    • getpwnam()
    • getpwnam_r()
    • endgrent()
    • setgrent()
    • getgrent()
    • getgrent_r()
    • getgrgid()
    • getgrgid_r()
    • getgrnam()
    • getgrnam_r()
    • getgrouplist()
    • endspent()
    • setspent()
    • getspent()
    • getspent_r()
    • getspnam()
    • getspnam_r()
  • The nsssd library interface, which can be used to write additional backends.

Related resources

nsss discussion

  • nsss is discussed on the skaware mailing-list.
nsss-0.0.2.1/doc/libnsss/0000755000000000000000000000000013316762566011765 5ustar nsss-0.0.2.1/doc/libnsss/nsss-unix.html0000644000000000000000000002275313330636616014623 0ustar nsss: the nsss-unix library interface

libnsss
nsss
Software
skarnet.org

The nsss-unix library interface

General information

The nsss/nsss-unix.h functions in libnsss provide a clean interface to get user/group data from the regular /etc/passwd, /etc/group and /etc/shadow text files.

All the following functions take as their first argument a pointer to a handle that has the nsss_unix_t type. This handle must be declared and initialized to NSSS_UNIX_ZERO prior to any call. It can be declared in the stack.

Programming

int nsss_unix_pwd_start (nsss_unix_t *a)

Opens a session with /etc/passwd. *a must be NSSS_UNIX_ZERO prior to the call. On error, returns 0, and sets errno. On success, returns 1, and *a is a handle to an /etc/passwd session. This function must be called even for a non-enumeration lookup.

int nsss_unix_pwd_maybe_start (nsss_unix_t *a)

Opens a session with /etc/passwd if it hasn't been opened yet. On error, returns 0, and sets errno. On success, returns 1, and *a is a handle to an /etc/passwd session. Calling this function when *a is already opened to an /etc/passwd session simply returns 1.

int nsss_unix_pwd_rewind (nsss_unix_t *a)

Performs a setpwent() operation on the current session. Returns 1 on success, and 0 (and sets errno) on error.

void nsss_unix_pwd_end (nsss_unix_t *a)

Closes the current /etc/passwd session. After this function returns, *a can be reused with another nsss_unix_*_start() function.

int nsss_unix_pwd_getbyname (nsss_unix_t *a, struct passwd *pw, stralloc *sa, char const *name)

Performs a getpwnam(name) on the current, open, /etc/passwd session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *pw, using the *sa stralloc to store strings. If name is not found, the function returns 0 without changing errno.

int nsss_unix_pwd_getbyuid (nsss_unix_t *a, struct passwd *pw, stralloc *sa, uid_t uid)

Performs a getpwuid(uid) on the current, open, /etc/passwd session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *pw, using the *sa stralloc to store strings. If uid is not found, the function returns 0 without changing errno.

int nsss_unix_pwd_get (nsss_unix_t *a, struct passwd *pw, stralloc *sa)

Performs a getpwent() on the current, open, /etc/passwd session (i.e. get the next entry in the file, as part of an enumeration). On error, returns 0 and sets errno. On success, returns 1, and stores the result into *pw, using the *sa stralloc to store strings. On EOF, the function returns 0 without changing errno.

int nsss_unix_grp_start (nsss_unix_t *a)

Opens a session with /etc/group. *a must be NSSS_UNIX_ZERO prior to the call. On error, returns 0, and sets errno. On success, returns 1, and *a is a handle to an /etc/group session. This function must be called even for a non-enumeration lookup.

int nsss_unix_grp_maybe_start (nsss_unix_t *a)

Opens a session with /etc/group if it hasn't been opened yet. On error, returns 0, and sets errno. On success, returns 1, and *a is a handle to an /etc/group session. Calling this function when *a is already opened to an /etc/group session simply returns 1.

int nsss_unix_grp_rewind (nsss_unix_t *a)

Performs a setgrent() operation on the current session. Returns 1 on success, and 0 (and sets errno) on error.

void nsss_unix_grp_end (nsss_unix_t *a)

Closes the current /etc/group session. After this function returns, *a can be reused with another nsss_unix_*_start() function.

int nsss_unix_grp_getbyname (nsss_unix_t *a, struct group *gr, stralloc *sa, genalloc *ga, char const *name)

Performs a getgrnam(name) on the current, open, /etc/group session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *gr, using the *sa stralloc to store strings, and the *ga genalloc, which must be able to hold objects of type char *, to store pointers for the gr->gr_mem field. If name is not found, the function returns 0 without changing errno.

int nsss_unix_grp_getbygid (nsss_unix_t *a, struct group *gr, stralloc *sa, genalloc *ga, gid_t gid)

Performs a getgrgid(gid) on the current, open, /etc/group session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *gr, using the *sa stralloc to store strings, and the *ga genalloc, which must be able to hold objects of type char *, to store pointers for the gr->gr_mem field. If gid is not found, the function returns 0 without changing errno.

int nsss_unix_grp_get (nsss_unix_t *a, struct group *gr, stralloc *sa, genalloc *ga)

Performs a getgrent() on the current, open, /etc/group session (i.e. get the next entry in the file, as part of an enumeration). On error, returns 0 and sets errno. On success, returns 1, and stores the result into *gr, using the *sa stralloc to store strings, and the *ga genalloc, which must be able to hold objects of type char *, to store pointers for the gr->gr_mem field. On EOF, the function returns 0 without changing errno.

int nsss_unix_shadow_start (nsss_unix_t *a)

Opens a session with /etc/shadow. *a must be NSSS_UNIX_ZERO prior to the call. On error, returns 0, and sets errno. On success, returns 1, and *a is a handle to an /etc/shadow session. This function must be called even for a non-enumeration lookup.

int nsss_unix_shadow_maybe_start (nsss_unix_t *a)

Opens a session with /etc/shadow if it hasn't been opened yet. On error, returns 0, and sets errno. On success, returns 1, and *a is a handle to an /etc/shadow session. Calling this function when *a is already opened to an /etc/shadow session simply returns 1.

int nsss_unix_shadow_rewind (nsss_unix_t *a)

Performs a setspent() operation on the current session. Returns 1 on success, and 0 (and sets errno) on error.

void nsss_unix_shadow_end (nsss_unix_t *a)

Closes the current /etc/shadow session. After this function returns, *a can be reused with another nsss_unix_*_start() function.

int nsss_unix_shadow_getbyname (nsss_unix_t *a, struct spwd *sp, stralloc *sa, char const *name)

Performs a getspnam(name) on the current, open, /etc/shadow session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *sp, using the *sa stralloc to store strings. If name is not found, the function returns 0 without changing errno.

int nsss_unix_shadow_get (nsss_unix_t *a, struct spwd *sp, stralloc *sa)

Performs a getspent() on the current, open, /etc/shadow session (i.e. get the next entry in the file, as part of an enumeration). On error, returns 0 and sets errno. On success, returns 1, and stores the result into *sp, using the *sa stralloc to store strings. On EOF, the function returns 0 without changing errno.

nsss-0.0.2.1/doc/libnsss/index.html0000644000000000000000000001320313541336065013750 0ustar nsss: the nsss library interface

nsss
Software
skarnet.org

The nsss library interface

General information

libnsss is the generic name for the nsss client library. This library is made of several parts:

  • nsss-unix: this is a set of functions to access the /etc/passwd, /etc/group and /etc/shadow files.
  • nsss-switch: this is a set of functions to connect to a nsssd-service and interact with various server-side daemons such as nsssd-unix or nsssd-nslcd.
  • nsss-all: this is a set of functions that try connecting to a nsssd service first, and fall back to the nsss-unix implementation if the connection fails (no nsssd service is running).

Both nsss-unix and nsss-switch are made of two parts:

  • An internal, clean API, that applications can use directly if they include the nsss/nsss.h header, or the relevant nsss/nsss-unix.h or nsss/nsss-switch.h header.
  • As a series of thin wrappers around the internal API, an implementation of the standard following functions:
    • endpwent()
    • setpwent()
    • getpwent()
    • getpwent_r()
    • getpwuid()
    • getpwuid_r()
    • getpwnam()
    • getpwnam_r()
    • endgrent()
    • setgrent()
    • getgrent()
    • getgrent_r()
    • getgrgid()
    • getgrgid_r()
    • getgrnam()
    • getgrnam_r()
    • endspent()
    • setspent()
    • getspent()
    • getspent_r()
    • getspnam()
    • getspnam_r()
    • The functions are prefixed with nsss_unix_ or nsss_switch_. For instance, nsss_unix_getpwnam() is the implementation of getpwnam() that uses the /etc/passwd backend.

nsss-all does not have an internal API. It only contains the implementation of the above standard functions, as nsss_all_getpwnam() and similar.

Compiling

Application programs can use the internal API directly, or the prefixed nsss_ functions directly. Most programs, however, will simply use the standard pwd.h, grp.h or shadow.h interfaces. nsss provides a version of these standard headers: if an application is built with these headers, then getpwnam() will automatically be aliased to nsss_all_getpwnam(), and the other functions will be aliased similarly.

If the NSSS_DISABLE_SWITCH macro is defined before inclusion of the nsss headers, then getpwnam() will be aliased to nsss_unix_getpwnam() instead, and the other functions will follow the same pattern. If, instead, the NSSS_DISABLE_UNIX macro is defined before inclusion of the nsss headers, then getpwnam() will be aliased to nsss_switch_getpwnam(), and the other functions will follow the same pattern.

So, the proper steps to compile an application with libnsss are:

  • Make sure the nsss headers, as well as the skalibs headers, are visible in your header search path.
  • Use #include <nsss/nsss.h>
  • To use the standard pwd.h interface, you can just #include <pwd.h>, which will work as long as the nsss/pwd.h header is accessible in your header search path.
  • Same thing for grp.h and shadow.h.
  • If don't want to use the nsss-all implementation of "try nsss-switch and fall back to nsss-unix if it fails", then compile with -DNSSS_DISABLE_SWITCH or -DNSSS_DISABLE_UNIX as desired.

Linking

  • Make sure the nsss library, as well as the skalibs library, are visible in your library search path.
  • Link against -lnsss, -lskarnet, -lpthread, `cat $SYSDEPS/socket.lib` and `cat $SYSDEPS/sysclock.lib`, $SYSDEPS being your skalibs sysdeps directory.

Programming

nsss-0.0.2.1/doc/libnsss/nsss-switch.html0000644000000000000000000002323513330701330015117 0ustar nsss: the nsss-switch library interface

libnsss
nsss
Software
skarnet.org

The nsss-switch library interface

General information

The nsss/nsss-switch.h functions in libnsss provide a clean interface to get user/group data from a nsss daemon, for instance one implemented via nsssd-unix or nsssd-nslcd. They are the C client library to such a daemon.

Most of the following functions take, in addition to their obvious arguments, a tain_t const * argument conventionally named deadline and a tain_t * argument conventionally named stamp. These two arguments are there to ensure that the function, which connects to another process in an otherwise synchronous manner, does not block forever. How to use these arguments is explained, for instance, here. A function foobar also has a version named foobar_g that only takes the deadline argument, assuming the current timestamp is held in the STAMP global variable.

All the functions take as their first argument a pointer to a handle that has the nsss_switch_t type. This handle must be declared and initialized to NSSS_SWITCH_ZERO prior to any call. It can be declared in the stack.

Programming

int nsss_switch_start (nsss_switch_t *a, unsigned int what, char const *path, tain_t const *deadline, tain_t *stamp)

Opens a session with a nsss daemon listening to a Unix domain socket located at path. *a must be NSSS_SWITCH_ZERO prior to the call. The nature of the session depends on the what argument, which should be one of NSSS_SWITCH_PWD, NSSS_SWITCH_GRP or NSSS_SWITCH_SHADOW depending on whether subsequent requests will query the user, group or shadow database. On error, the function returns 0, and sets errno. On success, it returns 1, and *a is a handle to a session with the nsssd daemon. This function must be called for every batch of communication with a nsssd service, not only for enumerations.

void nsss_switch_end (nsss_switch_t *a, unsigned int what)

Closes the current session. The what argument must be the same one that has been given to nsss_switch_start. After this function returns, *a can be reused.

int nsss_switch_pwd_rewind (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a setpwent() operation on the current session. Returns 1 on success, and 0 (and sets errno) on error.

int nsss_switch_pwd_end (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a endpwent() operation on the current session, i.e. ends an enumeration. Returns 1 on success, and 0 (and sets errno) on error.

int nsss_switch_pwd_getbyname (nsss_switch_t *a, struct passwd *pw, stralloc *sa, char const *name, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a getpwnam(name) on the current session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *pw, using the *sa stralloc to store strings. If name is not found, the function returns 0 without changing errno.

int nsss_switch_pwd_getbyuid (nsss_switch_t *a, struct passwd *pw, stralloc *sa, uid_t uid, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a getpwuid(uid) on the current session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *pw, using the *sa stralloc to store strings. If uid is not found, the function returns 0 without changing errno.

int nsss_switch_pwd_get (nsss_switch_t *a, struct passwd *pw, stralloc *sa, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a a getpwent() on the current session, i.e. get the next entry as part of an enumeration. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *pw, using the *sa stralloc to store strings. On EOF, the function returns 0 without changing errno.

int nsss_switch_grp_rewind (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a setgrent() operation on the current session. Returns 1 on success, and 0 (and sets errno) on error.

void nsss_switch_grp_end (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a endgrent() operation on the current session, i.e. ends an enumeration. Returns 1 on success, and 0 (and sets errno) on error.

int nsss_switch_grp_getbyname (nsss_switch_t *a, struct group *gr, stralloc *sa, genalloc *ga, char const *name, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a a getgrnam(name) on the current session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *gr, using the *sa stralloc to store strings, and the *ga genalloc, which must be able to hold objects of type char *, to store pointers for the gr->gr_mem field. If name is not found, the function returns 0 without changing errno.

int nsss_switch_grp_getbygid (nsss_switch_t *a, struct group *gr, stralloc *sa, genalloc *ga, gid_t gid, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a getgrgid(gid) on the current session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *gr, using the *sa stralloc to store strings, and the *ga genalloc, which must be able to hold objects of type char *, to store pointers for the gr->gr_mem field. If gid is not found, the function returns 0 without changing errno.

int nsss_switch_grp_get (nsss_switch_t *a, struct group *gr, stralloc *sa, genalloc *ga, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a getgrent() on the current session, i.e. get the next entry as part of an enumeration. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *gr, using the *sa stralloc to store strings, and the *ga genalloc, which must be able to hold objects of type char *, to store pointers for the gr->gr_mem field. On EOF, the function returns 0 without changing errno.

int nsss_switch_shadow_rewind (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a setspent() operation on the current session. Returns 1 on success, and 0 (and sets errno) on error.

int nsss_switch_shadow_end (nsss_switch_t *a, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a endspent() operation on the current session, i.e. ends an enumeration. Returns 1 on success, and 0 (and sets errno) on error.

int nsss_switch_shadow_getbyname (nsss_switch_t *a, struct spwd *sp, stralloc *sa, char const *name, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a getspnam(name) on the current session. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *sp, using the *sa stralloc to store strings. If name is not found, the function returns 0 without changing errno.

int nsss_switch_shadow_get (nsss_switch_t *a, struct spwd *sp, stralloc *sa, tain_t const *deadline, tain_t *stamp)

Performs the equivalent of a getspent() on the current session, i.e. get the next entry as part of an enumeration. On error, returns 0 and sets errno. On success, returns 1, and stores the result into *sp, using the *sa stralloc to store strings. On EOF, the function returns 0 without changing errno.

nsss-0.0.2.1/doc/nsswitch.html0000644000000000000000000001414413332146403013024 0ustar nsss: the problem with nsswitch

nsss
Software
skarnet.org

The problem with nsswitch

nsswitch, or Name Service Switch, is a common Unix mechanism to describe how user/group/shadow databases should be accessed. Nowadays it's prevalent on Linux because it's the mechanism used by the glibc.

Unfortunately, nsswitch has a certain number of flaws that make it difficult to use in a small and secure environment. In other words, it's crap. Here's why.

nsswitch uses dynamically linked modules.

nsswitch works by reading a configuration file, /etc/nsswitch.conf, and depending on what it reads in this file, loading one or more shared libraries, via dlopen(), into the application. These shared libraries, for instance /lib/libnss_files-2.19.so, are provided by the NSS implementation (glibc on Linux). This mechanism has drawbacks.

It makes it difficult to link programs statically.

Programs using dlopen() are notoriously difficult to use in a static linking environment: by nature, dlopen() is dynamic, and it's practically impossible to make it work reliably and correctly in statically linked programs.

So, small programs that just need a getpwnam() call cannot, for all intents and purposes, be linked statically when the implementation of getpwnam() goes through nsswitch.

By contrast, the nsss implementation of getpwnam() works with static linking without trouble, and without pulling the whole libc - only the nsss client library is pulled, and it is quite small.

It dynamically adds third-party code to the process' address space.

This is a common security issue with dynamically loaded modules.

Normally, when you link your executable against a third-party library - in this case, the libc - the library has a public API that you're using, and that API has documented behaviour. Some sanity checks are performed at link time, and if something is terribly wrong, linking fails.

This is not the case with dynamically loaded modules used internally by a library. These modules do not have a contract with you, the application developer, but only with the library that uses them. Some checks are performed at library build time, but not at application build time. When dlopen() is run, it performs some minimal checks at run-time (which is the worst time for checks, because failure causes application downtime!), then loads code and data into your application's address space without ever having verified that the interaction is okay.

It would be extremely easy for a malicious third-party to inject subtly bad code making your application behave in unintended ways using dynamically loaded modules. And even from benevolent library authors, it makes bugs more subtle and harder to catch.

By contrast, nsss doesn't load its backends into the client's address space - only the fallback nsss-unix implementation using /etc/passwd is linked client-side, and there's even an option to disable that. All the complex backend code lives server-side in the appropriate nsssd daemon, sharing no address space with the application.

nsswitch adds a configuration parser and a decision automaton to the application.

nsswitch's configuration is done via the /etc/nsswitch.conf file, a text, human-friendly file. The first time a user database function is called, the file is read and parsed, and then for all subsequent user database function calls, a decision automaton (that results from this parsing) is run so the engine knows which sequence of backends to call in which situation.

All this, obviously, happens at run-time, in the application's address space. Maybe it's time for a quick reminder that

  • parsing is bad - most people can't write parsers, and bugs love them (both the parsers and these people)
  • run-time is the worst time for syntax errors, and any other errors that could and should be caught earlier
  • library code should be kept as simple as possible and a dynamic decision automaton doesn't qualify as "simple"
  • every line of code linked into a critical application (such as login) is attack surface

The nsswitch configuration model goes against all these basic programming principles.

By contrast, nsss:

  • performs no parsing at all - and if a generic backend ever needs parsing, it will be done in its own process address space, not in the application's.
  • has the simplest possible decision engine: "if contacting the backend fails, fall back on the Unix mechanism". And even that can be overridden at application build time. If a more complex decision engine is needed, it can be implemented, say it with me, in a backend that has its own address space.
  • frontloads as many decisions as possible before application run time. The backend used by applications is determined when the nsssd service starts, and can be changed by modifying and restarting this service; the burden of determining which backend to run is not carried by applications.
nsss-0.0.2.1/doc/libnsssd/0000755000000000000000000000000013330701410012102 5ustar nsss-0.0.2.1/doc/libnsssd/index.html0000644000000000000000000001202513541504367014117 0ustar nsss: the nsssd library interface

nsss
Software
skarnet.org

The nsssd library interface

General information

libnsssd is a library that can be used by external applications to implement extra nsss backends, in the style of nsssd-unix and nsssd-nslcd, without learning the details of the nsss protocol or having to perform IO themselves.

Compiling

  • Make sure the nsss headers, as well as the skalibs headers, are visible in your header search path.
  • Use #include <skalibs/strerr2.h> and #include <nsss/nsssd.h>

Linking

  • Make sure the nsssd library, as well as the skalibs library, are visible in your library search path.
  • Link against -lnsssd, -lskarnet,
    • `cat $SYSDEPS/socket.lib` and `cat $SYSDEPS/sysclock.lib`, $SYSDEPS being your skalibs sysdeps directory.

Programming

  • In your main() function, start with assigning the name of your program to the PROG variable. Example: PROG = "nsssd-foobar";
  • Your main() function can parse options and take command line arguments as it sees fit. But once it's done parsing options, give control to the nsssd_main() function, using your argv and envp as arguments: return nsssd_main(argv, envp);

The rest of your program should implement the functions needed by nsssd_main(). Here is what those functions are:

void *nsssd_handle_init (void)

This function must return a pointer to an uninitialized handle. The handle can be whatever you need to implement your backend; the pointer to your handle will be passed to every subsequent function. The function must not return NULL.

int nsssd_handle_start (void *handle, char const *const *argv, char const *const *envp)

This function must initialize the handle. The arguments it receives are the argv and envp that have been passed to nsssd_main(). This allows you to write daemons that can be somewhat configured via the command line: it is how nsssd-nslcd takes an argument telling it where the nslcd socket is, and uses that argument in its own nsssd_handle_start to actually connect to the nslcd daemon.
The function must return nonzero if it succeeds, and 0 if it fails, setting errno appropriately.

void nsssd_handle_end (void *handle)

This function must deinitialize the handle and free all related resources: close connections to external processes, etc.

int nsssd_pwd_start (void *handle)

This function will be called at the start of a passwd enumeration. It must return nonzero on success and 0 on error.

int nsssd_pwd_rewind (void *handle)

This function will be called on a setpwent() call. It must rewind the current enumeration to the start of the database. It must return nonzero on success and 0 on error.

int nsssd_pwd_get (void *handle, struct passwd *pw)

This function will be called on every getpwent() call, i.e. on every iteration of an enumeration. On error, it must return 0; on success, it must return nonzero and store the obtained passwd structure into *pw.

void nsssd_pwd_end (void *handle)

This function will be called at the end of a passwd enumeration.

int nsssd_pwd_getbyuid (void *handle, struct passwd *pw, uid_t uid)

This function must implement a getpwuid(uid) call. On error, it must return 0; on success, it must return nonzero and store the result into *pw.

int nsssd_pwd_getbyname (void *handle, struct passwd *pw, char const *name)

This function must implement a getpwnam(name) call. On error, it must return 0; on success, it must return nonzero and store the result into *pw.

Similar functions for the group and shadow databases must also be implemented. The full list can be found in the nsss/nsssd.h header.

nsss-0.0.2.1/doc/upgrade.html0000644000000000000000000000341713553353674012631 0ustar How to upgrade nsss

nsss
Software
skarnet.org

What has changed in nsss

in 0.0.2.1

  • skalibs dependency bumped to 2.9.1.0.
  • s6 optional dependency bumped to 2.9.0.1.

in 0.0.2.0

  • skalibs dependency bumped to 2.9.0.0.
  • s6 optional dependency bumped to 2.9.0.0.
  • Support for getgrouplist() has been added.

in 0.0.1.2

  • No functional changes.

in 0.0.1.1

  • skalibs dependency bumped to 2.8.0.0.
  • s6 optional dependency bumped to 2.8.0.0.
  • Everything now builds as PIC by default no matter the toolchain's settings. Use the --disable-all-pic configure option to build executables and static libraries as non-PIC.

in 0.0.1.0

Initial release.

nsss-0.0.2.1/doc/nsssd-nslcd.html0000644000000000000000000000614113316756643013432 0ustar nsss: the nsssd-nslcd program

nsss
Software
skarnet.org

The nsssd-nslcd program

nsssd-nslcd is a daemon providing a backend for clients using the nsss library - more precisely, clients using the nsss-all or the nsss-switch functions.

The nsssd-nslcd backend is meant to be used when the user/group/shadow information is held in a LDAP server, and the nslcd daemon is running on the system as an interface to the LDAP architecture. nsssd-nslcd acts a server for its libnsss-using client, and as a client to nslcd. It forwards the application's requests to nslcd, and forwards the answers back.

nsssd-nslcd is not meant to be called directly; instead, it is expected to be run from a script as a part of a "nsssd" local service.

The examples/ subdirectory of the nsss package provides examples on how to run such a service. The simplest way to do so, for testing purposes, is a command line such as: 

s6-ipcserver -l0 /run/service/nsss/s nsssd-nslcd /var/run/nslcd/socket

/run/service/nsss/s is the default place where nsss's implementation of the pwd.h, grp.h and shadow.h functions expects the nsssd service to be. It can be changed at nsss build time by giving the --with-nsssd-socket=PATH option to configure. nsssd-nslcd takes one argument: the path to connect to the nslcd daemon. By default, this is /var/run/nslcd/socket. The default can be changed at nslcd build time.

nsssd-nslcd does not listen to the socket itself: it reads from its standard input and writes to its standard output. It relies on a superserver such as s6-ipcserver to manage connections to the socket. An instance of nsssd-nslcd is run for every client connection.

If fine-grained authorizations are required (only allowing certain users and groups to connect to the service), the superserver can be configured to enforce them.

nsssd-nslcd does not need to run as root, provided it can connect to the nslcd daemon. It is recommended to create a nsss user and group, dedicated to the nsssd service, and run the superserver as this user and group.

nsss-0.0.2.1/doc/nsssd-unix.html0000644000000000000000000000601213316753642013303 0ustar nsss: the nsssd-unix program

nsss
Software
skarnet.org

The nsssd-unix program

nsssd-unix is a daemon providing a backend for clients using the nsss library - more precisely, clients using the nsss-all or the nsss-switch functions.

The nsssd-unix backend is a simple one. It simply fetches user/group/shadow information from the /etc/passwd, /etc/group and /etc/shadow files. The same information can be directly obtained by a client if it uses the nsss-unix functions, without the overhead of going through an independent process. However, setting up a nsssd-unix service can still be useful:

  • For testing purposes
  • As a placeholder service that will be replaced later with a more complex backend
  • ...

nsssd-unix is not meant to be called directly; instead, it is expected to be run from a script as a part of a "nsssd" local service.

The examples/ subdirectory of the nsss package provides examples on how to run such a service. The simplest way to do so, for testing purposes, is a command line such as: 

s6-ipcserver -l0 /run/service/nsss/s nsssd-unix

/run/service/nsss/s is the default place where nsss's implementation of the pwd.h, grp.h and shadow.h functions expects the nsssd service to be. It can be changed at nsss build time by giving the --with-nsssd-socket=PATH option to configure.

nsssd-unix does not listen to the socket itself: it reads from its standard input and writes to its standard output. It relies on a superserver such as s6-ipcserver to manage connections to the socket. An instance of nsssd-unix is run for every client connection.

If fine-grained authorizations are required (only allowing certain users and groups to connect to the service), the superserver can be configured to enforce them.

nsssd-unix does not need to run as root, provided it can read the files database. It is recommended to create a nsss user and group, dedicated to the nsssd service, and run the superserver as this user and group.

nsss-0.0.2.1/doc/overview.html0000644000000000000000000001204713523262622013034 0ustar nsss: an overview

nsss
Software
skarnet.org

An overview of nsss

nsss is a secure implementation of a subset of the pwd.h, grp.h and shadow.h functionality, i.e. user authentication on Unix systems. It includes full POSIX functionality, a few GNU extensions, and an underlying C client library with better error reporting than the POSIX interface specifies.

nsss has two parts: the client library and the nsssd service.

The nsss client library

The client library provides:

  • nsss-unix: a set of functions providing access to the standard /etc/passwd, /etc/group and /etc/shadow files.
  • nsss-switch: a set of functions implementing the same functionality as nsss-unix, but instead of looking for information in the standard files, they connect to a nsssd service (see below) that performs the requests for them.
  • three implementations of the the standard getpwnam() et al. functions: one using the nsss-unix functions, one using the nsss-switch functions, and the default one, called nsss-all, which attempts to connect to the nsssd service and retrieve information from it, but falls back to the nsss-unix implementation if it fails (for instance, if no nsssd service is listening).

Applications wishing to use nsss should be built against this client library. The getpwnam() et al. definitions will override those of the libc, and use the nsss-all, nsss-switch or nsss-unix depending on compilation options.

Unlike glibc's nsswitch, the nsss client library does not use dynamically loadable modules. nsss can be statically linked, and used in static programs. It's also quite light.

The nsssd service

For applications that need to use the nsss-all or nsss-switch implementations of getpwnam() et al. (and that is the point, otherwise the libc's implementation could generally be used over nsss-unix instead!) there needs to be a daemon running on the system, and serving requests from nsss-switch clients.

That daemon should be set up by the system administrator. It should listen to the /run/service/nsssd/s Unix domain socket; that default location can be changed at nsss build time via the --with-nsssd-socket option to the configure script.

As of 0.0.2.0, three suitable implementations of a nsssd daemon are provided by the nsss package:

  • The nsssd-unix program, which is sort of a dummy implementation since it simply accesses the standard files (it simply uses the nsss-unix library). It is still useful for testing purposes, and to have a placeholder service that can easily be replaced later.
  • The nsssd-nslcd program, which performs requests to a nslcd daemon running on the same system and returns the answers fetched by nslcd. This allows nsss to get its users/groups information from a LDAP database.
  • The nsssd-switch program, which tries several other backends in sequence and uses the first one that succeeds.

More implementations, with a wider variety of backends, will come in future versions of nsss.

The provided programs are not meant to be run directly; instead, they use the UCSPI protocol and must be spawned by a Unix domain super-server (the equivalent of inetd, for Unix domain sockets). The s6-ipcserver program, from the s6 package, is such a super-server. What this means is that for instance, running the following command-line as root will set up a correct nsss service: 

 s6-ipcserver -- /run/service/nsssd/s nsssd-unix

Refinements can be added to this command-line, such as options to drop root privileges after binding to the socket, etc. Examples of how to add a nsssd service to your init scripts are provided in the examples/ subdirectory of the nsss package, for OpenRC, s6 or s6-rc based systems.