NSS_STATUS
_nss_lsass_endgrent(
void
)
{
NSS_STATUS status;
NSS_LOCK();
status = LsaNssCommonGroupEndgrent(&lsaConnection, &gEnumGroupsState);
NSS_UNLOCK();
return status;
}
NSS_STATUS
_nss_lsass_setpwent(
void
)
{
NSS_STATUS status;
NSS_LOCK();
status = LsaNssCommonPasswdSetpwent(&lsaConnection,
&gEnumUsersState);
NSS_UNLOCK();
return status;
}
NSS_STATUS
LsaNssSolarisGroupGetgroupsbymember(
nss_backend_t* pBackend,
void* pArgs
)
{
struct nss_groupsbymem* pGroupsByMem = (struct nss_groupsbymem*) pArgs;
PCSTR pszUserName = pGroupsByMem->username;
int* pResultsSize = &pGroupsByMem->numgids;
int* pResultsCapacity = &pGroupsByMem->maxgids;
gid_t* pGidResults = pGroupsByMem->gid_array;
int err = 0;
int* pErrorNumber = &err;
int ret = NSS_STATUS_SUCCESS;
PLSA_NSS_GROUP_BACKEND pLsaBackend = (PLSA_NSS_GROUP_BACKEND) pBackend;
size_t myResultsSize = *pResultsSize;
size_t myResultsCapacity = *pResultsCapacity;
NSS_LOCK();
ret = LsaNssCommonGroupGetGroupsByUserName(
&pLsaBackend->lsaConnection,
pszUserName,
myResultsSize,
myResultsCapacity,
&myResultsSize,
pGidResults,
pErrorNumber);
NSS_UNLOCK();
if (ret == NSS_STATUS_SUCCESS)
{
if (myResultsSize > myResultsCapacity)
myResultsSize = myResultsCapacity;
*pResultsSize = (int) myResultsSize;
}
return ret;
}
static
NSS_STATUS
LsaNssSolarisGroupSetgrent(
nss_backend_t* pBackend,
void* pArgs
)
{
NSS_STATUS status;
PLSA_NSS_GROUP_BACKEND pLsaBackend = (PLSA_NSS_GROUP_BACKEND) pBackend;
PLSA_ENUMGROUPS_STATE pEnumGroupsState = &pLsaBackend->enumGroupsState;
NSS_LOCK();
status = LsaNssCommonGroupSetgrent(
&pLsaBackend->lsaConnection,
pEnumGroupsState);
NSS_UNLOCK();
return status;
}
NSS_STATUS
_nss_lsass_getgrent_r(
struct group* pResultGroup,
char * pszBuf,
size_t bufLen,
int* pErrorNumber
)
{
NSS_STATUS status;
NSS_LOCK();
status = LsaNssCommonGroupGetgrent(
&lsaConnection,
&gEnumGroupsState,
pResultGroup,
pszBuf,
bufLen,
pErrorNumber);
NSS_UNLOCK();
return status;
}
NSS_STATUS
_nss_lsass_getgrnam_r(
const char * pszGroupName,
struct group * pResultGroup,
char * pszBuf,
size_t bufLen,
int* pErrorNumber
)
{
NSS_STATUS status;
NSS_LOCK();
status = LsaNssCommonGroupGetgrnam(&lsaConnection,
pszGroupName,
pResultGroup,
pszBuf,
bufLen,
pErrorNumber);
NSS_UNLOCK();
return status;
}
NSS_STATUS
_nss_lsass_getpwent_r(
struct passwd * pResultUser,
char * pszBuf,
size_t bufLen,
int * pErrorNumber
)
{
NSS_STATUS status;
NSS_LOCK();
status = LsaNssCommonPasswdGetpwent(
&lsaConnection,
&gEnumUsersState,
pResultUser,
pszBuf,
bufLen,
pErrorNumber);
NSS_UNLOCK();
return status;
}
NSS_STATUS
_nss_lsass_getpwuid_r(
uid_t uid,
struct passwd * pResultUser,
char * pszBuf,
size_t bufLen,
int * pErrorNumber
)
{
NSS_STATUS status;
NSS_LOCK();
status = LsaNssCommonPasswdGetpwuid(&lsaConnection,
uid,
pResultUser,
pszBuf,
bufLen,
pErrorNumber);
NSS_UNLOCK();
return status;
}
NSS_STATUS
_nss_lsass_initgroups_dyn(
PCSTR pszUserName,
gid_t groupGid,
long int* pResultsSize,
long int* pResultsCapacity,
gid_t** ppGidResults,
long int maxGroups,
int* pErrorNumber
)
{
int ret = NSS_STATUS_SUCCESS;
size_t resultsCapacity = (size_t) *pResultsCapacity;
size_t resultsExistingSize = (size_t) *pResultsSize;
size_t resultsSize = 0;
gid_t* pGidResults = *ppGidResults;
gid_t* pGidResultsNew = NULL;
NSS_LOCK();
ret = LsaNssCommonGroupGetGroupsByUserName(
&lsaConnection,
pszUserName,
resultsExistingSize,
resultsCapacity,
&resultsSize,
pGidResults,
pErrorNumber);
if (ret != NSS_STATUS_SUCCESS)
goto error;
if (resultsSize > resultsCapacity)
{
/* More results were found than were stored, so
reallocate array and try again. */
pGidResultsNew = realloc(pGidResults, sizeof(*pGidResults) * resultsSize);
if (!pGidResultsNew)
{
*pErrorNumber = ENOMEM;
ret = NSS_STATUS_UNAVAIL;
goto error;
}
else
{
pGidResults = pGidResultsNew;
*ppGidResults = pGidResults;
}
/* The number of filled elements is whatever our old capacity was */
resultsExistingSize = resultsCapacity;
/* The new capacity is the number of available results */
resultsCapacity = resultsSize;
/* Try again */
ret = LsaNssCommonGroupGetGroupsByUserName(
&lsaConnection,
pszUserName,
resultsExistingSize,
resultsCapacity,
&resultsSize,
pGidResults,
pErrorNumber);
}
if (ret == NSS_STATUS_SUCCESS)
{
*pResultsSize = (long int) resultsSize;
*pResultsCapacity = (long int) resultsCapacity;
}
error:
NSS_UNLOCK();
return ret;
}
NSS_STATUS
LsaNssSolarisGroupGetgrnam(
nss_backend_t* pBackend,
void* pArgs
)
{
nss_XbyY_args_t* pXbyYArgs = (nss_XbyY_args_t*) pArgs;
const char * pszGroupName = pXbyYArgs->key.name;
struct group * pResultGroup = (struct group*) pXbyYArgs->buf.result;
char * pszBuf = pXbyYArgs->buf.buffer;
size_t bufLen = pXbyYArgs->buf.buflen;
int err = 0;
int* pErrorNumber = &err;
int ret = NSS_STATUS_SUCCESS;
PLSA_NSS_GROUP_BACKEND pLsaBackend = (PLSA_NSS_GROUP_BACKEND) pBackend;
NSS_LOCK();
ret = LsaNssCommonGroupGetgrnam(
&pLsaBackend->lsaConnection,
pszGroupName,
pResultGroup,
pszBuf,
bufLen,
pErrorNumber);
NSS_UNLOCK();
if (ret == NSS_STATUS_SUCCESS)
{
if (pResultGroup)
{
pXbyYArgs->returnval = pXbyYArgs->buf.result;
}
else
{
pXbyYArgs->returnval = pszBuf;
#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN
pXbyYArgs->returnlen = strlen(pszBuf);
#else
/* The pXbyYArgs->buf.result was NULL indicating this is NSS2/NSCD
* Cast the nss_XbyY_args_t to a NSS2 compatible version.
* NOTE: This is only required if we build on Solaris 8
*/
((nss_XbyY_nss2_args_t *)pXbyYArgs)->returnlen = strlen(pszBuf);
#endif
}
}
else if (ret == NSS_STATUS_TRYAGAIN && err == ERANGE)
{
pXbyYArgs->erange = 1;
/* Solaris 8 will call again with the same buffer size if tryagain
* is returned.
*/
ret = NSS_STATUS_UNAVAIL;
}
else if (ret == NSS_STATUS_UNAVAIL && err == ECONNREFUSED)
{
/* Librestart on Solaris does not like it when getpwnam_r returns
* ECONNREFUSED. So instead, we'll treat this case like the user
* was not found (0 for errno but NULL for result).
*/
errno = 0;
}
else
{
errno = err;
}
return ret;
}
static
NSS_STATUS
LsaNssSolarisGroupGetgrent(
nss_backend_t* pBackend,
void* pArgs
)
{
PLSA_NSS_GROUP_BACKEND pLsaBackend = (PLSA_NSS_GROUP_BACKEND) pBackend;
PLSA_ENUMGROUPS_STATE pEnumGroupsState = &pLsaBackend->enumGroupsState;
nss_XbyY_args_t* pXbyYArgs = (nss_XbyY_args_t*) pArgs;
struct group* pResultGroup = pXbyYArgs->buf.result;
char * pszBuf = pXbyYArgs->buf.buffer;
size_t bufLen = pXbyYArgs->buf.buflen;
int err = 0;
int* pErrorNumber = &err;
int ret = NSS_STATUS_NOTFOUND;
NSS_LOCK();
ret = LsaNssCommonGroupGetgrent(
&pLsaBackend->lsaConnection,
pEnumGroupsState,
pResultGroup,
pszBuf,
bufLen,
pErrorNumber);
NSS_UNLOCK();
if (ret == NSS_STATUS_SUCCESS)
{
if (pResultGroup)
{
pXbyYArgs->returnval = pXbyYArgs->buf.result;
}
else
{
pXbyYArgs->returnval = pszBuf;
#ifdef HAVE_STRUCT_NSS_XBYY_ARGS_RETURNLEN
pXbyYArgs->returnlen = strlen(pszBuf);
#else
/* The pXbyYArgs->buf.result was NULL indicating this is NSS2/NSCD
* Cast the nss_XbyY_args_t to a NSS2 compatible version.
* NOTE: This is only required if we build on Solaris 8
*/
((nss_XbyY_nss2_args_t *)pXbyYArgs)->returnlen = strlen(pszBuf);
#endif
}
}
else if (ret == NSS_STATUS_TRYAGAIN && err == ERANGE)
{
pXbyYArgs->erange = 1;
/* Solaris 8 will call again with the same buffer size if tryagain
* is returned.
*/
ret = NSS_STATUS_UNAVAIL;
}
else
{
errno = err;
}
return ret;
}
