sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
Code

r22702: Convert both lookup name and lookup sid to follow the

Browse Source 
same heuristic.  First try our DC and then try a DC in the
root of our forest.  Use a temporary state since
winbindd_lookupXXX_async() is called from various winbindd
API entry points.

Note this will break the compile.  That will be fixed in the
next commit.
(This used to be commit b442644bac)
This commit is contained in:
Gerald Carter 2007-05-06 19:01:54 +00:00 committed by Gerald (Jerry) Carter
parent 8ff276fcb0
commit 6ef504d71f
2 changed files with 105 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
source3/nsswitch/winbindd_async.c
View File

@ -687,6 +687,40 @@ static void name2gid_recv(TALLOC_CTX *mem_ctx, BOOL success,
}
#endif /* not used */
struct lookupsid_state {
DOM_SID sid;
void *caller_private_data;
};
static void lookupsid_recv2(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
void *c, void *private_data)
{
void (*cont)(void *priv, BOOL succ, const char *dom_name,
const char *name, enum lsa_SidType type) =
(void (*)(void *, BOOL, const char *, const char *,
enum lsa_SidType))c;
struct lookupsid_state *s = talloc_get_type_abort(private_data,
struct lookupsid_state);
if (!success) {
DEBUG(5, ("Could not trigger lookupsid\n"));
cont(s->caller_private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("lookupsid (forest root) returned an error\n"));
cont(s->caller_private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
return;
}
cont(s->caller_private_data, True, response->data.name.dom_name,
response->data.name.name,
(enum lsa_SidType)response->data.name.type);
}
static void lookupsid_recv(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
void *c, void *private_data)
@ -695,20 +729,37 @@ static void lookupsid_recv(TALLOC_CTX *mem_ctx, BOOL success,
const char *name, enum lsa_SidType type) =
(void (*)(void *, BOOL, const char *, const char *,
enum lsa_SidType))c;
struct lookupsid_state *s = talloc_get_type_abort(private_data,
struct lookupsid_state);
if (!success) {
DEBUG(5, ("Could not trigger lookupsid\n"));
cont(private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
cont(s->caller_private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("lookupsid returned an error\n"));
cont(private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
/* Try again using the forest root */
struct winbindd_domain *root_domain = find_root_domain();
struct winbindd_request request;
if ( !root_domain ) {
DEBUG(5,("lookupsid_recv: unable to determine forest root\n"));
cont(s->caller_private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
return;
}
ZERO_STRUCT(request);
request.cmd = WINBINDD_LOOKUPSID;
fstrcpy(request.data.sid, sid_string_static(&s->sid));
do_async_domain(mem_ctx, root_domain, &request, lookupsid_recv2,
(void *)cont, s);
return;
}
cont(private_data, True, response->data.name.dom_name,
cont(s->caller_private_data, True, response->data.name.dom_name,
response->data.name.name,
(enum lsa_SidType)response->data.name.type);
}
@ -722,6 +773,7 @@ void winbindd_lookupsid_async(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
{
struct winbindd_domain *domain;
struct winbindd_request request;
struct lookupsid_state *s;
domain = find_lookup_domain_from_sid(sid);
if (domain == NULL) {
@ -735,6 +787,15 @@ void winbindd_lookupsid_async(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
request.cmd = WINBINDD_LOOKUPSID;
fstrcpy(request.data.sid, sid_string_static(sid));
if ( (s = TALLOC_ZERO_P(mem_ctx, struct lookupsid_state)) == NULL ) {
DEBUG(0, ("winbindd_lookupsid_async: talloc failed\n"));
cont(private_data, False, NULL, NULL, SID_NAME_UNKNOWN);
return;
}
sid_copy( &s->sid, sid );
s->caller_private_data = private_data;
do_async_domain(mem_ctx, domain, &request, lookupsid_recv,
(void *)cont, private_data);
}
@ -762,8 +823,9 @@ enum winbindd_result winbindd_dual_lookupsid(struct winbindd_domain *domain,
/* Lookup the sid */
if (!winbindd_lookup_name_by_sid(state->mem_ctx, &sid, &dom_name, &name,
&type)) {
if (!winbindd_lookup_name_by_sid(state->mem_ctx, domain, &sid,
&dom_name, &name, &type))
{
TALLOC_FREE(dom_name);
TALLOC_FREE(name);
return WINBINDD_ERROR;
@ -782,6 +844,13 @@ enum winbindd_result winbindd_dual_lookupsid(struct winbindd_domain *domain,
This is the second callback after contacting the forest root
********************************************************************/
struct lookupname_state {
char *dom_name;
char *name;
void *caller_private_data;
};
static void lookupname_recv2(TALLOC_CTX *mem_ctx, BOOL success,
struct winbindd_response *response,
void *c, void *private_data)
@ -790,27 +859,30 @@ static void lookupname_recv2(TALLOC_CTX *mem_ctx, BOOL success,
enum lsa_SidType type) =
(void (*)(void *, BOOL, const DOM_SID *, enum lsa_SidType))c;
DOM_SID sid;
struct lookupname_state *s = talloc_get_type_abort( private_data,
struct lookupname_state );
if (!success) {
DEBUG(5, ("Could not trigger lookup_name\n"));
cont(private_data, False, NULL, SID_NAME_UNKNOWN);
cont(s->caller_private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
if (response->result != WINBINDD_OK) {
DEBUG(5, ("lookup_name returned an error\n"));
cont(private_data, False, NULL, SID_NAME_UNKNOWN);
cont(s->caller_private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
if (!string_to_sid(&sid, response->data.sid.sid)) {
DEBUG(0, ("Could not convert string %s to sid\n",
response->data.sid.sid));
cont(private_data, False, NULL, SID_NAME_UNKNOWN);
cont(s->caller_private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
cont(private_data, True, &sid,
cont(s->caller_private_data, True, &sid,
(enum lsa_SidType)response->data.sid.type);
}
@ -826,36 +898,34 @@ static void lookupname_recv(TALLOC_CTX *mem_ctx, BOOL success,
enum lsa_SidType type) =
(void (*)(void *, BOOL, const DOM_SID *, enum lsa_SidType))c;
DOM_SID sid;
struct lookupname_state *s = talloc_get_type_abort( private_data,
struct lookupname_state );
if (!success) {
DEBUG(5, ("lookupname_recv: lookup_name() failed!\n"));
cont(private_data, False, NULL, SID_NAME_UNKNOWN);
cont(s->caller_private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
if (response->result != WINBINDD_OK) {
/* Try again using the forest root */
struct winbindd_domain *root_domain = find_root_domain();
struct winbindd_cli_state *state = (struct winbindd_cli_state*)private_data;
struct winbindd_request request;
char *name_domain, *name_account;
if ( !root_domain ) {
DEBUG(5,("lookupname_recv: unable to determine forest root\n"));
cont(private_data, False, NULL, SID_NAME_UNKNOWN);
cont(s->caller_private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
name_domain = state->request.data.name.dom_name;
name_account = state->request.data.name.name;
ZERO_STRUCT(request);
request.cmd = WINBINDD_LOOKUPNAME;
fstrcpy(request.data.name.dom_name, name_domain);
fstrcpy(request.data.name.name, name_account);
fstrcpy( request.data.name.dom_name, s->dom_name );
fstrcpy( request.data.name.name, s->name );
do_async_domain(mem_ctx, root_domain, &request, lookupname_recv2,
(void *)cont, private_data);
(void *)cont, s);
return;
}
@ -863,11 +933,11 @@ static void lookupname_recv(TALLOC_CTX *mem_ctx, BOOL success,
if (!string_to_sid(&sid, response->data.sid.sid)) {
DEBUG(0, ("Could not convert string %s to sid\n",
response->data.sid.sid));
cont(private_data, False, NULL, SID_NAME_UNKNOWN);
cont(s->caller_private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
cont(private_data, True, &sid,
cont(s->caller_private_data, True, &sid,
(enum lsa_SidType)response->data.sid.type);
}
@ -886,6 +956,7 @@ void winbindd_lookupname_async(TALLOC_CTX *mem_ctx,
{
struct winbindd_request request;
struct winbindd_domain *domain;
struct lookupname_state *s;
if ( (domain = find_lookup_domain_from_name(dom_name)) == NULL ) {
DEBUG(5, ("Could not find domain for name %s\n", dom_name));
@ -898,8 +969,18 @@ void winbindd_lookupname_async(TALLOC_CTX *mem_ctx,
fstrcpy(request.data.name.dom_name, dom_name);
fstrcpy(request.data.name.name, name);
if ( (s = TALLOC_ZERO_P(mem_ctx, struct lookupname_state)) == NULL ) {
DEBUG(0, ("winbindd_lookupname_async: talloc failed\n"));
cont(private_data, False, NULL, SID_NAME_UNKNOWN);
return;
}
s->dom_name = talloc_strdup( s, dom_name );
s->name = talloc_strdup( s, name );
s->caller_private_data = private_data;
do_async_domain(mem_ctx, domain, &request, lookupname_recv,
(void *)cont, private_data);
(void *)cont, s);
}
enum winbindd_result winbindd_dual_lookupname(struct winbindd_domain *domain,

9
source3/nsswitch/winbindd_util.c
View File

@ -725,24 +725,17 @@ BOOL winbindd_lookup_sid_by_name(TALLOC_CTX *mem_ctx,
* are set, otherwise False.
**/
BOOL winbindd_lookup_name_by_sid(TALLOC_CTX *mem_ctx,
struct winbindd_domain *domain,
DOM_SID *sid,
char **dom_name,
char **name,
enum lsa_SidType *type)
{
NTSTATUS result;
struct winbindd_domain *domain;
*dom_name = NULL;
*name = NULL;
domain = find_lookup_domain_from_sid(sid);
if (!domain) {
DEBUG(1,("Can't find domain from sid\n"));
return False;
}
/* Lookup name */
result = domain->methods->sid_to_name(domain, mem_ctx, sid, dom_name, name, type);