/*
* Find the name@domain string from either a user or group id
*/
int name_lookup(char *id, key_serial_t key, int type)
{
char name[IDMAP_NAMESZ];
char domain[NFS4_MAX_DOMAIN_LEN];
uid_t uid;
gid_t gid;
int rc;
rc = nfs4_get_default_domain(NULL, domain, NFS4_MAX_DOMAIN_LEN);
if (rc != 0) {
xlog_errno(rc,
"name_lookup: nfs4_get_default_domain failed: %m");
rc = -1;
goto out;
}
if (type == USER) {
uid = atoi(id);
rc = nfs4_uid_to_name(uid, domain, name, IDMAP_NAMESZ);
} else {
gid = atoi(id);
rc = nfs4_gid_to_name(gid, domain, name, IDMAP_NAMESZ);
}
if (rc < 0)
xlog_errno(rc, "name_lookup: %s: failed: %m",
(type == USER ? "nfs4_uid_to_name" : "nfs4_gid_to_name"));
if (rc == 0) {
rc = keyctl_instantiate(key, &name, strlen(name), 0);
if (rc < 0)
xlog_err("name_lookup: keyctl_instantiate failed: %m");
}
out:
return rc;
}
/**
*
* uid2name: convert a uid to a name.
*
* convert a uid to a name.
*
* @param name [OUT] the name of the user
* @param uid [IN] the input uid
*
* return 1 if successful, 0 otherwise
*
*/
int uid2name(char *name, uid_t * puid)
{
char fqname[NFS4_MAX_DOMAIN_LEN];
#ifdef _USE_NFSIDMAP
int rc;
if(!nfsidmap_set_conf())
{
LogCrit(COMPONENT_IDMAPPER,
"uid2name: nfsidmap_set_conf failed");
return 0;
}
if(unamemap_get(*puid, name) == ID_MAPPER_SUCCESS)
{
LogFullDebug(COMPONENT_IDMAPPER,
"uid2name: unamemap_get uid %d returned %s",
*puid, name);
return 1;
}
else
{
rc = nfs4_uid_to_name(*puid, idmap_domain, name, NFS4_MAX_DOMAIN_LEN);
if(rc != 0)
{
LogDebug(COMPONENT_IDMAPPER,
"uid2name: nfs4_uid_to_name %d returned %d (%s)",
*puid, -rc, strerror(-rc));
return 0;
}
strncpy(fqname, name, NFS4_MAX_DOMAIN_LEN);
if(strchr(name, '@') == NULL)
{
LogFullDebug(COMPONENT_IDMAPPER,
"uid2name: adding domain %s",
idmap_domain);
sprintf(fqname, "%s@%s", name, idmap_domain);
strncpy(name, fqname, NFS4_MAX_DOMAIN_LEN);
}
LogFullDebug(COMPONENT_IDMAPPER,
"uid2name: nfs4_uid_to_name uid %d returned %s",
*puid, name);
if(uidmap_add(fqname, *puid) != ID_MAPPER_SUCCESS)
{
LogCrit(COMPONENT_IDMAPPER,
"uid2name: uidmap_add %s %d failed",
fqname, *puid);
return 0;
}
}
return 1;
#else
struct passwd p;
struct passwd *pp;
char buff[NFS4_MAX_DOMAIN_LEN];
if(unamemap_get(*puid, name) == ID_MAPPER_SUCCESS)
{
LogFullDebug(COMPONENT_IDMAPPER,
"uid2name: unamemap_get uid %d returned %s",
*puid, name);
return 1;
}
else
{
#ifdef _SOLARIS
if(getpwuid_r(*puid, &p, buff, MAXPATHLEN) != 0)
#else
if((getpwuid_r(*puid, &p, buff, MAXPATHLEN, &pp) != 0) ||
(pp == NULL))
#endif /* _SOLARIS */
{
LogFullDebug(COMPONENT_IDMAPPER,
"uid2name: getpwuid_r %d failed",
*puid);
return 0;
}
strncpy(name, p.pw_name, NFS4_MAX_DOMAIN_LEN);
LogFullDebug(COMPONENT_IDMAPPER,
"uid2name: getpwuid_r uid %d returned %s",
*puid, name);
if(uidmap_add(name, *puid) != ID_MAPPER_SUCCESS)
{
LogCrit(COMPONENT_IDMAPPER,
"uid2name: uidmap_add %s %d failed",
name, *puid);
return 0;
}
}
return 1;
#endif /* _USE_NFSIDMAP */
} /* uid2name */
static bool xdr_encode_nfs4_princ(XDR *xdrs, uint32_t id, bool group)
{
const struct gsh_buffdesc *found;
uint32_t not_a_size_t;
bool success = false;
PTHREAD_RWLOCK_rdlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
if (group)
success = idmapper_lookup_by_gid(id, &found);
else
success = idmapper_lookup_by_uid(id, &found, NULL);
if (likely(success)) {
not_a_size_t = found->len;
/* Fully qualified owners are always stored in the
hash table, no matter what our lookup method. */
success =
inline_xdr_bytes(xdrs, (char **)&found->addr, ¬_a_size_t,
UINT32_MAX);
PTHREAD_RWLOCK_unlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
return success;
} else {
PTHREAD_RWLOCK_unlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
int rc;
int size;
bool looked_up = false;
char *namebuff = NULL;
struct gsh_buffdesc new_name;
if (nfs_param.nfsv4_param.use_getpwnam) {
if (group)
size = sysconf(_SC_GETGR_R_SIZE_MAX);
else
size = sysconf(_SC_GETPW_R_SIZE_MAX);
if (size == -1)
size = PWENT_BEST_GUESS_LEN;
new_name.len = size;
size += owner_domain.len + 2;
} else {
size = NFS4_MAX_DOMAIN_LEN + 2;
}
namebuff = alloca(size);
new_name.addr = namebuff;
if (nfs_param.nfsv4_param.use_getpwnam) {
char *cursor;
bool nulled;
if (group) {
struct group g;
struct group *gres;
rc = getgrgid_r(id, &g, namebuff, new_name.len,
&gres);
nulled = (gres == NULL);
} else {
struct passwd p;
struct passwd *pres;
rc = getpwuid_r(id, &p, namebuff, new_name.len,
&pres);
nulled = (pres == NULL);
}
if ((rc == 0) && !nulled) {
new_name.len = strlen(namebuff);
cursor = namebuff + new_name.len;
*(cursor++) = '@';
++new_name.len;
memcpy(cursor, owner_domain.addr,
owner_domain.len);
new_name.len += owner_domain.len;
looked_up = true;
} else {
LogInfo(COMPONENT_IDMAPPER,
"%s failed with code %d.",
(group ? "getgrgid_r" : "getpwuid_r"),
rc);
}
} else {
#ifdef USE_NFSIDMAP
if (group) {
rc = nfs4_gid_to_name(id, owner_domain.addr,
namebuff,
NFS4_MAX_DOMAIN_LEN + 1);
} else {
rc = nfs4_uid_to_name(id, owner_domain.addr,
namebuff,
NFS4_MAX_DOMAIN_LEN + 1);
}
if (rc == 0) {
new_name.len = strlen(namebuff);
looked_up = true;
} else {
LogInfo(COMPONENT_IDMAPPER,
"%s failed with code %d.",
(group ? "nfs4_gid_to_name" :
"nfs4_uid_to_name"), rc);
}
#else /* USE_NFSIDMAP */
looked_up = false;
#endif /* !USE_NFSIDMAP */
}
if (!looked_up) {
if (nfs_param.nfsv4_param.allow_numeric_owners) {
LogInfo(COMPONENT_IDMAPPER,
"Lookup for %d failed, using numeric %s",
id, (group ? "group" : "owner"));
/* 2**32 is 10 digits long in decimal */
sprintf(namebuff, "%u", id);
new_name.len = strlen(namebuff);
} else {
LogInfo(COMPONENT_IDMAPPER,
"Lookup for %d failed, using nobody.",
id);
memcpy(new_name.addr, "nobody", 6);
new_name.len = 6;
}
}
/* Add to the cache and encode the result. */
PTHREAD_RWLOCK_wrlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
if (group)
success = idmapper_add_group(&new_name, id);
else
success = idmapper_add_user(&new_name, id, NULL, false);
PTHREAD_RWLOCK_unlock(group ? &idmapper_group_lock :
&idmapper_user_lock);
if (unlikely(!success)) {
LogMajor(COMPONENT_IDMAPPER, "%s failed.",
group ? "idmapper_add_group" :
"idmaper_add_user");
}
not_a_size_t = new_name.len;
return inline_xdr_bytes(xdrs, (char **)&new_name.addr,
¬_a_size_t, UINT32_MAX);
}
}
