static NTSTATUS sid_to_name(struct rpc_pipe_client *pipe_hnd,
TALLOC_CTX *mem_ctx,
DOM_SID *sid,
fstring name)
{
struct policy_handle pol;
enum lsa_SidType *sid_types = NULL;
NTSTATUS result;
char **domains = NULL, **names = NULL;
result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
SEC_FLAG_MAXIMUM_ALLOWED, &pol);
if ( !NT_STATUS_IS_OK(result) )
return result;
result = rpccli_lsa_lookup_sids(pipe_hnd, mem_ctx, &pol, 1, sid, &domains, &names, &sid_types);
if ( NT_STATUS_IS_OK(result) ) {
if ( *domains[0] )
fstr_sprintf( name, "%s\\%s", domains[0], names[0] );
else
fstrcpy( name, names[0] );
}
rpccli_lsa_Close(pipe_hnd, mem_ctx, &pol);
return result;
}
/* convert a SID to a string, either numeric or username/group */
static void SidToString(fstring str, struct dom_sid *sid, bool _numeric)
{
char **domains = NULL;
char **names = NULL;
enum lsa_SidType *types = NULL;
sid_to_fstring(str, sid);
if (_numeric) return;
/* Ask LSA to convert the sid to a name */
if (!cli_open_policy_hnd() ||
!NT_STATUS_IS_OK(rpccli_lsa_lookup_sids(global_pipe_hnd, talloc_tos(),
&pol, 1, sid, &domains,
&names, &types)) ||
!domains || !domains[0] || !names || !names[0]) {
return;
}
/* Converted OK */
slprintf(str, sizeof(fstring) - 1, "%s%s%s",
domains[0], lp_winbind_separator(),
names[0]);
}
static NTSTATUS sid_to_name(struct rpc_pipe_client *pipe_hnd,
TALLOC_CTX *mem_ctx,
struct dom_sid *sid,
fstring name)
{
struct policy_handle pol;
enum lsa_SidType *sid_types = NULL;
NTSTATUS status, result;
char **domains = NULL, **names = NULL;
struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, true,
SEC_FLAG_MAXIMUM_ALLOWED, &pol);
if ( !NT_STATUS_IS_OK(status) )
return status;
status = rpccli_lsa_lookup_sids(pipe_hnd, mem_ctx, &pol, 1, sid, &domains, &names, &sid_types);
if ( NT_STATUS_IS_OK(status) ) {
if ( *domains[0] )
fstr_sprintf( name, "%s\\%s", domains[0], names[0] );
else
fstrcpy( name, names[0] );
}
dcerpc_lsa_Close(b, mem_ctx, &pol, &result);
return status;
}
/* Convert a domain SID to a user or group name */
NTSTATUS rpc_sid_to_name(TALLOC_CTX *mem_ctx,
struct rpc_pipe_client *lsa_pipe,
struct policy_handle *lsa_policy,
struct winbindd_domain *domain,
const struct dom_sid *sid,
char **pdomain_name,
char **pname,
enum lsa_SidType *ptype)
{
char *mapped_name = NULL;
char **domains = NULL;
char **names = NULL;
enum lsa_SidType *types = NULL;
NTSTATUS map_status;
NTSTATUS status;
status = rpccli_lsa_lookup_sids(lsa_pipe,
mem_ctx,
lsa_policy,
1, /* num_sids */
sid,
&domains,
&names,
&types);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(2,("sid_to_name: failed to lookup sids: %s\n",
nt_errstr(status)));
return status;
}
*ptype = (enum lsa_SidType) types[0];
map_status = normalize_name_map(mem_ctx,
domain,
names[0],
&mapped_name);
if (NT_STATUS_IS_OK(map_status) ||
NT_STATUS_EQUAL(map_status, NT_STATUS_FILE_RENAMED)) {
*pname = talloc_strdup(mem_ctx, mapped_name);
DEBUG(5,("returning mapped name -- %s\n", *pname));
} else {
*pname = talloc_strdup(mem_ctx, names[0]);
}
if ((names[0] != NULL) && (*pname == NULL)) {
return NT_STATUS_NO_MEMORY;
}
*pdomain_name = talloc_strdup(mem_ctx, domains[0]);
if (*pdomain_name == NULL) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_OK;
}
NTSTATUS net_lookup_name_from_sid(struct net_context *c,
TALLOC_CTX *ctx,
struct dom_sid *psid,
const char **ppdomain,
const char **ppname)
{
NTSTATUS nt_status;
struct con_struct *csp = NULL;
char **domains;
char **names;
enum lsa_SidType *types;
*ppdomain = NULL;
*ppname = NULL;
csp = create_cs(c, ctx, &nt_status);
if (csp == NULL) {
return nt_status;
}
nt_status = rpccli_lsa_lookup_sids(csp->lsapipe, ctx,
&csp->pol,
1, psid,
&domains,
&names,
&types);
if (!NT_STATUS_IS_OK(nt_status)) {
return nt_status;
}
*ppdomain = domains[0];
*ppname = names[0];
/* Don't care about type here. */
/* Converted OK */
return NT_STATUS_OK;
}
static NTSTATUS cmd_lsa_lookup_sids(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
int argc, const char **argv)
{
struct policy_handle pol;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
DOM_SID *sids;
char **domains;
char **names;
enum lsa_SidType *types;
int i;
if (argc == 1) {
printf("Usage: %s [sid1 [sid2 [...]]]\n", argv[0]);
return NT_STATUS_OK;
}
result = rpccli_lsa_open_policy(cli, mem_ctx, True,
SEC_FLAG_MAXIMUM_ALLOWED,
&pol);
if (!NT_STATUS_IS_OK(result))
goto done;
/* Convert arguments to sids */
sids = TALLOC_ARRAY(mem_ctx, DOM_SID, argc - 1);
if (!sids) {
printf("could not allocate memory for %d sids\n", argc - 1);
goto done;
}
for (i = 0; i < argc - 1; i++)
if (!string_to_sid(&sids[i], argv[i + 1])) {
result = NT_STATUS_INVALID_SID;
goto done;
}
/* Lookup the SIDs */
result = rpccli_lsa_lookup_sids(cli, mem_ctx, &pol, argc - 1, sids,
&domains, &names, &types);
if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
NT_STATUS_V(STATUS_SOME_UNMAPPED))
goto done;
result = NT_STATUS_OK;
/* Print results */
for (i = 0; i < (argc - 1); i++) {
fstring sid_str;
sid_to_fstring(sid_str, &sids[i]);
printf("%s %s\\%s (%d)\n", sid_str,
domains[i] ? domains[i] : "*unknown*",
names[i] ? names[i] : "*unknown*", types[i]);
}
rpccli_lsa_Close(cli, mem_ctx, &pol);
done:
return result;
}
