/*
group.c - NSS lookup functions for group database
Copyright (C) 2006 West Consulting
Copyright (C) 2006-2015 Arthur de Jong
Copyright (C) 2010 Symas Corporation
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA
*/
#include "config.h"
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include "prototypes.h"
#include "common.h"
#include "compat/attrs.h"
/* read a single group entry from the stream */
static nss_status_t read_group(TFILE *fp, struct group *result,
char *buffer, size_t buflen, int *errnop)
{
int32_t tmpint32, tmp2int32, tmp3int32;
size_t bufptr = 0;
memset(result, 0, sizeof(struct group));
READ_BUF_STRING(fp, result->gr_name);
READ_BUF_STRING(fp, result->gr_passwd);
READ_INT32(fp, result->gr_gid);
READ_BUF_STRINGLIST(fp, result->gr_mem);
return NSS_STATUS_SUCCESS;
}
/* read all group entries from the stream and add
gids of these groups to the list */
static nss_status_t read_gids(TFILE *fp, gid_t skipgroup, long int *start,
long int *size, gid_t **groupsp,
long int limit, int *errnop)
{
int32_t res = (int32_t)NSLCD_RESULT_BEGIN;
int32_t tmpint32, tmp2int32, tmp3int32;
gid_t gid;
#ifdef NSS_FLAVOUR_GLIBC
gid_t *newgroups;
long int newsize;
#endif /* NSS_FLAVOUR_GLIBC */
/* loop over results */
while (res == (int32_t)NSLCD_RESULT_BEGIN)
{
/* skip group name */
SKIP_STRING(fp);
/* skip passwd entry */
SKIP_STRING(fp);
/* read gid */
READ_INT32(fp, gid);
/* skip members */
SKIP_STRINGLIST(fp);
/* only add the group to the list if it is not the specified group */
if (gid != skipgroup)
{
#ifdef NSS_FLAVOUR_GLIBC
/* check if we reached the limit */
if ((limit > 0) && (*start >= limit))
return NSS_STATUS_TRYAGAIN;
/* check if our buffer is large enough */
if ((*start) >= (*size))
{
/* for some reason Glibc expects us to grow the array (completely
different from all other NSS functions) */
/* calculate new size */
newsize = 2 * (*size);
if ((limit > 0) && (*start >= limit))
newsize = limit;
/* allocate new memory */
newgroups = realloc(*groupsp, newsize * sizeof(gid_t));
if (newgroups == NULL)
return NSS_STATUS_TRYAGAIN;
*groupsp = newgroups;
*size = newsize;
}
#endif /* NSS_FLAVOUR_GLIBC */
#ifdef NSS_FLAVOUR_SOLARIS
/* check if we reached the limit */
if ((limit > 0) && (*start >= limit))
{
*errnop = 1; /* this is args->erange */
return NSS_STATUS_NOTFOUND;
}
#endif /* NSS_FLAVOUR_SOLARIS */
/* add gid to list */
(*groupsp)[(*start)++] = gid;
}
/* read next response code (don't bail out on not success since we
just want to build up a list) */
READ_INT32(fp, res);
}
/* return the proper status code */
return NSS_STATUS_SUCCESS;
}
#ifdef NSS_FLAVOUR_GLIBC
/* get a group entry by name */
nss_status_t NSS_NAME(getgrnam_r)(const char *name, struct group *result,
char *buffer, size_t buflen, int *errnop)
{
NSS_GETONE(NSLCD_ACTION_GROUP_BYNAME,
WRITE_STRING(fp, name),
read_group(fp, result, buffer, buflen, errnop));
}
/* get a group entry by numeric gid */
nss_status_t NSS_NAME(getgrgid_r)(gid_t gid, struct group *result,
char *buffer, size_t buflen, int *errnop)
{
NSS_GETONE(NSLCD_ACTION_GROUP_BYGID,
WRITE_INT32(fp, gid),
read_group(fp, result, buffer, buflen, errnop));
}
/* thread-local file pointer to an ongoing request */
static TLS TFILE *grentfp;
/* start a request to read all groups */
nss_status_t NSS_NAME(setgrent)(int UNUSED(stayopen))
{
NSS_SETENT(grentfp);
}
/* read a single group from the stream */
nss_status_t NSS_NAME(getgrent_r)(struct group *result,
char *buffer, size_t buflen, int *errnop)
{
NSS_GETENT(grentfp, NSLCD_ACTION_GROUP_ALL,
read_group(grentfp, result, buffer, buflen, errnop));
}
/* close the stream opened with setgrent() above */
nss_status_t NSS_NAME(endgrent)(void)
{
NSS_ENDENT(grentfp);
}
/* this function returns a list of groups, documentation for the
interface is scarce (any pointers are welcome) but this is
what is assumed the parameters mean:
user IN - the user name to find groups for
skipgroup IN - a group to not include in the list
*start IN/OUT - where to write in the array, is incremented
*size IN/OUT - the size of the supplied array (gid_t entries, not bytes)
**groupsp IN/OUT - pointer to the array of returned groupids
limit IN - the maxium size of the array
*errnop OUT - for returning errno
*/
nss_status_t NSS_NAME(initgroups_dyn)(const char *user, gid_t skipgroup,
long int *start, long int *size,
gid_t **groupsp, long int limit,
int *errnop)
{
/* temporarily map the buffer and buflen names so the check in NSS_GETONE
for validity of the buffer works (renaming the parameters may cause
confusion) */
#define buffer groupsp
#define buflen *size
NSS_GETONE(NSLCD_ACTION_GROUP_BYMEMBER,
WRITE_STRING(fp, user),
read_gids(fp, skipgroup, start, size, groupsp, limit, errnop));
#undef buffer
#undef buflen
}
#endif /* NSS_FLAVOUR_GLIBC */
#ifdef NSS_FLAVOUR_SOLARIS
#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN
static char *group2str(struct group *result, char *buffer, size_t buflen)
{
int res, i;
res = snprintf(buffer, buflen, "%s:%s:%d:", result->gr_name,
result->gr_passwd, (int)result->gr_gid);
if ((res < 0) || (res >= (int)buflen))
return NULL;
if (result->gr_mem)
for (i = 0; result->gr_mem[i]; i++)
{
if (i)
strlcat(buffer, ",", buflen);
strlcat(buffer, result->gr_mem[i], buflen);
}
/* check if buffer overflowed */
if (strlen(buffer) >= buflen - 1)
return NULL;
return buffer;
}
#endif /* HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN */
static nss_status_t read_result(TFILE *fp, nss_XbyY_args_t *args)
{
READ_RESULT(group, &args->erange);
}
static nss_status_t group_getgrnam(nss_backend_t UNUSED(*be), void *args)
{
NSS_GETONE(NSLCD_ACTION_GROUP_BYNAME,
WRITE_STRING(fp, NSS_ARGS(args)->key.name),
read_result(fp, args));
}
static nss_status_t group_getgrgid(nss_backend_t UNUSED(*be), void *args)
{
NSS_GETONE(NSLCD_ACTION_GROUP_BYGID,
WRITE_INT32(fp, NSS_ARGS(args)->key.gid),
read_result(fp, args));
}
static nss_status_t group_setgrent(nss_backend_t *be, void UNUSED(*args))
{
NSS_SETENT(LDAP_BE(be)->fp);
}
static nss_status_t group_getgrent(nss_backend_t *be, void *args)
{
NSS_GETENT(LDAP_BE(be)->fp, NSLCD_ACTION_GROUP_ALL,
read_result(LDAP_BE(be)->fp, args));
}
static nss_status_t group_endgrent(nss_backend_t *be, void UNUSED(*args))
{
NSS_ENDENT(LDAP_BE(be)->fp);
}
static nss_status_t group_getgroupsbymember(nss_backend_t UNUSED(*be), void *args)
{
struct nss_groupsbymem *argp = (struct nss_groupsbymem *)args;
long int start = (long int)argp->numgids;
gid_t skipgroup = (start > 0) ? argp->gid_array[0] : (gid_t)-1;
NSS_GETONE(NSLCD_ACTION_GROUP_BYMEMBER,
WRITE_STRING(fp, argp->username),
read_gids(fp, skipgroup, &start, NULL, (gid_t **)&argp->gid_array,
argp->maxgids, &NSS_ARGS(args)->erange);
argp->numgids = (int)start);
}
static nss_backend_op_t group_ops[] = {
nss_ldap_destructor,
group_endgrent,
group_setgrent,
group_getgrent,
group_getgrnam,
group_getgrgid,
group_getgroupsbymember
};
nss_backend_t *NSS_NAME(group_constr)(const char UNUSED(*db_name),
const char UNUSED(*src_name),
const char UNUSED(*cfg_args))
{
return nss_ldap_constructor(group_ops, sizeof(group_ops));
}
#endif /* NSS_FLAVOUR_SOLARIS */