/*
* name: give me his name
* type: and type (UUID_USER or UUID_GROUP)
* uuid: pointer to uuid_t storage that the caller must provide
* returns 0 on success !=0 on errror
*/
int getuuidfromname( const char *name, uuidtype_t type, uuidp_t uuid) {
int ret = 0;
#ifdef HAVE_LDAP
char *uuid_string = NULL;
#endif
ret = search_cachebyname( name, type, uuid);
if (ret == 0) {
/* found in cache */
LOG(log_debug, logtype_afpd, "getuuidfromname{cache}: name: %s, type: %s -> UUID: %s",
name, uuidtype[type], uuid_bin2string(uuid));
} else {
/* if not found in cache */
#ifdef HAVE_LDAP
if ((ret = ldap_getuuidfromname( name, type, &uuid_string)) == 0) {
uuid_string2bin( uuid_string, uuid);
LOG(log_debug, logtype_afpd, "getuuidfromname{local}: name: %s, type: %s -> UUID: %s",
name, uuidtype[type], uuid_bin2string(uuid));
} else {
LOG(log_debug, logtype_afpd, "getuuidfromname(\"%s\",t:%u): no result from ldap search",
name, type);
}
#endif
if (ret != 0) {
/* Build a local UUID */
if (type == UUID_USER) {
struct passwd *pwd;
if ((pwd = getpwnam(name)) == NULL) {
LOG(log_error, logtype_afpd, "getuuidfromname(\"%s\",t:%u): unknown user",
name, uuidtype[type]);
goto cleanup;
}
localuuid_from_id(uuid, UUID_USER, pwd->pw_uid);
} else {
struct group *grp;
if ((grp = getgrnam(name)) == NULL) {
LOG(log_error, logtype_afpd, "getuuidfromname(\"%s\",t:%u): unknown user",
name, uuidtype[type]);
goto cleanup;
}
localuuid_from_id(uuid, UUID_GROUP, grp->gr_gid);
}
LOG(log_debug, logtype_afpd, "getuuidfromname{local}: name: %s, type: %s -> UUID: %s",
name, uuidtype[type], uuid_bin2string(uuid));
}
ret = 0;
add_cachebyname( name, uuid, type, 0);
}
cleanup:
#ifdef HAVE_LDAP
if (uuid_string) free(uuid_string);
#endif
return ret;
}
/*
* uuidp: pointer to a uuid
* name: returns allocated buffer from ldap_getnamefromuuid
* type: returns USER, GROUP or LOCAL
* return 0 on success !=0 on errror
*
* Caller must free name appropiately.
*/
int getnamefromuuid(const uuidp_t uuidp, char **name, uuidtype_t *type) {
int ret;
ret = search_cachebyuuid( uuidp, name, type);
if (ret == 0) {
/* found in cache */
LOG(log_debug9, logtype_afpd, "getnamefromuuid{cache}: UUID: %s -> name: %s, type:%s",
uuid_bin2string(uuidp), *name, uuidtype[*type]);
} else {
/* not found in cache */
/* Check if UUID is a client local one */
if (memcmp(uuidp, local_user_uuid, 12) == 0
|| memcmp(uuidp, local_group_uuid, 12) == 0) {
LOG(log_debug, logtype_afpd, "getnamefromuuid: local UUID: %" PRIu32 "",
ntohl(*(uint32_t *)(uuidp + 12)));
*type = UUID_LOCAL;
*name = strdup("UUID_LOCAL");
return 0;
}
#ifdef HAVE_LDAP
ret = ldap_getnamefromuuid(uuid_bin2string(uuidp), name, type);
if (ret != 0) {
LOG(log_warning, logtype_afpd, "getnamefromuuid(%s): no result from ldap_getnamefromuuid",
uuid_bin2string(uuidp));
goto cleanup;
}
add_cachebyuuid( uuidp, *name, *type, 0);
LOG(log_debug, logtype_afpd, "getnamefromuuid{LDAP}: UUID: %s -> name: %s, type:%s",
uuid_bin2string(uuidp), *name, uuidtype[*type]);
#endif
}
cleanup:
return ret;
}
/*
* uuidp: pointer to a uuid
* name: returns allocated buffer from ldap_getnamefromuuid
* type: returns USER, GROUP or LOCAL
* return 0 on success !=0 on errror
*
* Caller must free name appropiately.
*/
int getnamefromuuid(const uuidp_t uuidp, char **name, uuidtype_t *type) {
int ret;
uid_t uid;
gid_t gid;
struct passwd *pwd;
struct group *grp;
if (search_cachebyuuid(uuidp, name, type) == 0) {
/* found in cache */
LOG(log_debug, logtype_afpd,
"getnamefromuuid{cache}: UUID: %s -> name: %s, type%s: %s",
uuid_bin2string(uuidp),
*name,
(*type & UUID_ENOENT) == UUID_ENOENT ? "[negative]" : "",
uuidtype[(*type) & UUIDTYPESTR_MASK]);
if ((*type & UUID_ENOENT) == UUID_ENOENT)
return -1;
return 0;
}
/* not found in cache */
/* Check if UUID is a client local one */
if (memcmp(uuidp, local_user_uuid, 12) == 0) {
*type = UUID_USER;
uid = ntohl(*(uint32_t *)(uuidp + 12));
if ((pwd = getpwuid(uid)) == NULL) {
/* not found, add negative entry to cache */
add_cachebyuuid(uuidp, "UUID_ENOENT", UUID_ENOENT, 0);
ret = -1;
} else {
*name = strdup(pwd->pw_name);
add_cachebyuuid(uuidp, *name, *type, 0);
ret = 0;
}
LOG(log_debug, logtype_afpd,
"getnamefromuuid{local}: UUID: %s -> name: %s, type:%s",
uuid_bin2string(uuidp), *name, uuidtype[(*type) & UUIDTYPESTR_MASK]);
return ret;
} else if (memcmp(uuidp, local_group_uuid, 12) == 0) {
*type = UUID_GROUP;
gid = ntohl(*(uint32_t *)(uuidp + 12));
if ((grp = getgrgid(gid)) == NULL) {
/* not found, add negative entry to cache */
add_cachebyuuid(uuidp, "UUID_ENOENT", UUID_ENOENT, 0);
ret = -1;
} else {
*name = strdup(grp->gr_name);
add_cachebyuuid(uuidp, *name, *type, 0);
ret = 0;
}
return ret;
}
#ifdef HAVE_LDAP
ret = ldap_getnamefromuuid(uuid_bin2string(uuidp), name, type);
#else
ret = -1;
#endif
if (ret != 0) {
LOG(log_debug, logtype_afpd, "getnamefromuuid(%s): not found",
uuid_bin2string(uuidp));
add_cachebyuuid(uuidp, "UUID_ENOENT", UUID_ENOENT, 0);
return -1;
}
add_cachebyuuid(uuidp, *name, *type, 0);
LOG(log_debug, logtype_afpd, "getnamefromuuid{LDAP}: UUID: %s -> name: %s, type:%s",
uuid_bin2string(uuidp), *name, uuidtype[(*type) & UUIDTYPESTR_MASK]);
return 0;
}
/*
* name: give me his name
* type: and type (UUID_USER or UUID_GROUP)
* uuid: pointer to uuid_t storage that the caller must provide
* returns 0 on success !=0 on errror
*/
int getuuidfromname( const char *name, uuidtype_t type, uuidp_t uuid) {
int ret = 0;
uuidtype_t mytype = type;
char nulluuid[16] = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
#ifdef HAVE_LDAP
char *uuid_string = NULL;
#endif
ret = search_cachebyname(name, &mytype, uuid);
if (ret == 0) {
/* found in cache */
LOG(log_debug, logtype_afpd,
"getuuidfromname{cache}: name: %s, type%s: %s -> UUID: %s",
name,
(mytype & UUID_ENOENT) == UUID_ENOENT ? "[negative]" : "",
uuidtype[type & UUIDTYPESTR_MASK],
uuid_bin2string(uuid));
if ((mytype & UUID_ENOENT) == UUID_ENOENT)
return -1;
} else {
/* if not found in cache */
#ifdef HAVE_LDAP
if ((ret = ldap_getuuidfromname( name, type, &uuid_string)) == 0) {
uuid_string2bin( uuid_string, uuid);
LOG(log_debug, logtype_afpd, "getuuidfromname{LDAP}: name: %s, type: %s -> UUID: %s",
name, uuidtype[type & UUIDTYPESTR_MASK], uuid_bin2string(uuid));
} else {
LOG(log_debug, logtype_afpd, "getuuidfromname(\"%s\",t:%u): no result from ldap search",
name, type);
}
#endif
if (ret != 0) {
/* Build a local UUID */
if (type == UUID_USER) {
struct passwd *pwd;
if ((pwd = getpwnam(name)) == NULL) {
LOG(log_error, logtype_afpd, "getuuidfromname(\"%s\",t:%u): unknown user",
name, uuidtype[type & UUIDTYPESTR_MASK]);
mytype |= UUID_ENOENT;
memcpy(uuid, nulluuid, 16);
} else {
localuuid_from_id(uuid, UUID_USER, pwd->pw_uid);
ret = 0;
LOG(log_debug, logtype_afpd, "getuuidfromname{local}: name: %s, type: %s -> UUID: %s",
name, uuidtype[type & UUIDTYPESTR_MASK], uuid_bin2string(uuid));
}
} else {
struct group *grp;
if ((grp = getgrnam(name)) == NULL) {
LOG(log_error, logtype_afpd, "getuuidfromname(\"%s\",t:%u): unknown user",
name, uuidtype[type & UUIDTYPESTR_MASK]);
mytype |= UUID_ENOENT;
memcpy(uuid, nulluuid, 16);
} else {
localuuid_from_id(uuid, UUID_GROUP, grp->gr_gid);
ret = 0;
LOG(log_debug, logtype_afpd, "getuuidfromname{local}: name: %s, type: %s -> UUID: %s",
name, uuidtype[type & UUIDTYPESTR_MASK], uuid_bin2string(uuid));
}
}
}
add_cachebyname(name, uuid, mytype, 0);
}
cleanup:
#ifdef HAVE_LDAP
if (uuid_string) free(uuid_string);
#endif
return ret;
}
