diff options
Diffstat (limited to 'source3/nsswitch/winbindd_sid.c')
| -rw-r--r-- | source3/nsswitch/winbindd_sid.c | 697 |
1 files changed, 387 insertions, 310 deletions
diff --git a/source3/nsswitch/winbindd_sid.c b/source3/nsswitch/winbindd_sid.c index 060e66fbc2..f8fb5e93c2 100644 --- a/source3/nsswitch/winbindd_sid.c +++ b/source3/nsswitch/winbindd_sid.c @@ -28,12 +28,13 @@ /* Convert a string */ +static void lookupsid_recv(void *private, BOOL success, + const char *dom_name, const char *name, + enum SID_NAME_USE type); + enum winbindd_result winbindd_lookupsid(struct winbindd_cli_state *state) { - enum SID_NAME_USE type; DOM_SID sid; - fstring name; - fstring dom_name; /* Ensure null termination */ state->request.data.sid[sizeof(state->request.data.sid)-1]='\0'; @@ -41,38 +42,46 @@ enum winbindd_result winbindd_lookupsid(struct winbindd_cli_state *state) DEBUG(3, ("[%5lu]: lookupsid %s\n", (unsigned long)state->pid, state->request.data.sid)); - /* Lookup sid from PDC using lsa_lookup_sids() */ - if (!string_to_sid(&sid, state->request.data.sid)) { DEBUG(5, ("%s not a SID\n", state->request.data.sid)); return WINBINDD_ERROR; } - /* Lookup the sid */ + winbindd_lookupsid_async(state->mem_ctx, &sid, lookupsid_recv, state); + return WINBINDD_PENDING; +} - if (!winbindd_lookup_name_by_sid(&sid, dom_name, name, &type)) { - return WINBINDD_ERROR; +static void lookupsid_recv(void *private, BOOL success, + const char *dom_name, const char *name, + enum SID_NAME_USE type) +{ + struct winbindd_cli_state *state = + talloc_get_type_abort(private, struct winbindd_cli_state); + + if (!success) { + DEBUG(5, ("lookupsid returned an error\n")); + state->response.result = WINBINDD_ERROR; + request_finished(state); + return; } fstrcpy(state->response.data.name.dom_name, dom_name); fstrcpy(state->response.data.name.name, name); - state->response.data.name.type = type; - - return WINBINDD_OK; + state->response.result = WINBINDD_OK; + request_finished(state); } - /** * Look up the SID for a qualified name. **/ + +static void lookupname_recv(void *private, BOOL success, + const DOM_SID *sid, enum SID_NAME_USE type); + enum winbindd_result winbindd_lookupname(struct winbindd_cli_state *state) { - enum SID_NAME_USE type; - fstring sid_str; char *name_domain, *name_user; - DOM_SID sid; - struct winbindd_domain *domain; char *p; /* Ensure null termination */ @@ -95,27 +104,48 @@ enum winbindd_result winbindd_lookupname(struct winbindd_cli_state *state) DEBUG(3, ("[%5lu]: lookupname %s%s%s\n", (unsigned long)state->pid, name_domain, lp_winbind_separator(), name_user)); - if ((domain = find_lookup_domain_from_name(name_domain)) == NULL) { - DEBUG(0, ("could not find domain entry for domain %s\n", - name_domain)); - return WINBINDD_ERROR; - } + winbindd_lookupname_async(state->mem_ctx, name_domain, name_user, + lookupname_recv, state); + return WINBINDD_PENDING; +} - /* Lookup name from PDC using lsa_lookup_names() */ - if (!winbindd_lookup_sid_by_name(domain, name_domain, name_user, &sid, &type)) { - return WINBINDD_ERROR; +static void lookupname_recv(void *private, BOOL success, + const DOM_SID *sid, enum SID_NAME_USE type) +{ + struct winbindd_cli_state *state = + talloc_get_type_abort(private, struct winbindd_cli_state); + + if (!success) { + DEBUG(5, ("lookupname returned an error\n")); + state->response.result = WINBINDD_ERROR; + request_finished(state); + return; } - sid_to_string(sid_str, &sid); - fstrcpy(state->response.data.sid.sid, sid_str); + sid_to_string(state->response.data.sid.sid, sid); state->response.data.sid.type = type; + state->response.result = WINBINDD_OK; + request_finished(state); + return; +} - return WINBINDD_OK; +static struct winbindd_child static_idmap_child; + +void init_idmap_child(void) +{ + setup_domain_child(NULL, &static_idmap_child, "idmap"); +} + +struct winbindd_child *idmap_child(void) +{ + return &static_idmap_child; } /* Convert a sid to a uid. We assume we only have one rid attached to the sid. */ +static void sid2uid_recv(void *private, BOOL success, uid_t uid); + enum winbindd_result winbindd_sid_to_uid(struct winbindd_cli_state *state) { DOM_SID sid; @@ -127,105 +157,53 @@ enum winbindd_result winbindd_sid_to_uid(struct winbindd_cli_state *state) DEBUG(3, ("[%5lu]: sid to uid %s\n", (unsigned long)state->pid, state->request.data.sid)); - if (!string_to_sid(&sid, state->request.data.sid)) { - DEBUG(1, ("Could not get convert sid %s from string\n", state->request.data.sid)); + if (idmap_proxyonly()) { + DEBUG(8, ("IDMAP proxy only\n")); return WINBINDD_ERROR; } - - /* This gets a little tricky. If we assume that usernames are syncd between - /etc/passwd and the windows domain (such as a member of a Samba domain), - the we need to get the uid from the OS and not alocate one ourselves */ - - if ( lp_winbind_trusted_domains_only() ) { - struct winbindd_domain *domain = NULL; - DOM_SID sid2; - uint32 rid; - - domain = find_our_domain(); - if ( !domain ) { - DEBUG(0,("winbindd_sid_to_uid: can't find my own domain!\n")); - return WINBINDD_ERROR; - } - - sid_copy( &sid2, &sid ); - sid_split_rid( &sid2, &rid ); - - if ( sid_equal( &sid2, &domain->sid ) ) { - - fstring domain_name; - fstring user; - enum SID_NAME_USE type; - struct passwd *pw = NULL; - unid_t id; - - /* ok...here's we know that we are dealing with our - own domain (the one to which we are joined). And - we know that there must be a UNIX account for this user. - So we lookup the sid and the call getpwnam().*/ - - - /* But first check and see if we don't already have a mapping */ - - if ( NT_STATUS_IS_OK(idmap_sid_to_uid(&sid, &(state->response.data.uid), ID_QUERY_ONLY)) ) - return WINBINDD_OK; - - /* now fall back to the hard way */ - - if ( !winbindd_lookup_name_by_sid(&sid, domain_name, user, &type) ) - return WINBINDD_ERROR; - - if ( !(pw = getpwnam(user)) ) { - DEBUG(0,("winbindd_sid_to_uid: 'winbind trusted domains only' is " - "set but this user [%s] doesn't exist!\n", user)); - return WINBINDD_ERROR; - } - - state->response.data.uid = pw->pw_uid; - - id.uid = pw->pw_uid; - idmap_set_mapping( &sid, id, ID_USERID ); - - return WINBINDD_OK; - } + if (!string_to_sid(&sid, state->request.data.sid)) { + DEBUG(1, ("Could not get convert sid %s from string\n", + state->request.data.sid)); + return WINBINDD_ERROR; } - - /* Find uid for this sid and return it */ + + /* Query only the local tdb, everything else might possibly block */ result = idmap_sid_to_uid(&sid, &(state->response.data.uid), - ID_QUERY_ONLY); + ID_QUERY_ONLY|ID_CACHE_ONLY); - if (NT_STATUS_IS_OK(result)) + if (NT_STATUS_IS_OK(result)) { return WINBINDD_OK; + } - if (state->request.flags & WBFLAG_QUERY_ONLY) - return WINBINDD_ERROR; - - /* The query-only did not work, allocate a new uid *if* it's a user */ - - { - fstring dom_name, name; - enum SID_NAME_USE type; - - if (!winbindd_lookup_name_by_sid(&sid, dom_name, name, &type)) - return WINBINDD_ERROR; + winbindd_sid2uid_async(state->mem_ctx, &sid, sid2uid_recv, state); + return WINBINDD_PENDING; +} - if ((type != SID_NAME_USER) && (type != SID_NAME_COMPUTER)) - return WINBINDD_ERROR; +static void sid2uid_recv(void *private, BOOL success, uid_t uid) +{ + struct winbindd_cli_state *state = + talloc_get_type_abort(private, struct winbindd_cli_state); + + if (!success) { + DEBUG(5, ("Could not convert sid %s\n", + state->request.data.sid)); + state->response.result = WINBINDD_ERROR; + request_finished(state); + return; } - - result = idmap_sid_to_uid(&sid, &(state->response.data.uid), 0); - if (NT_STATUS_IS_OK(result)) - return WINBINDD_OK; - - DEBUG(4, ("Could not get uid for sid %s\n", state->request.data.sid)); - return WINBINDD_ERROR; + state->response.result = WINBINDD_OK; + state->response.data.uid = uid; + request_finished(state); } /* Convert a sid to a gid. We assume we only have one rid attached to the sid.*/ +static void sid2gid_recv(void *private, BOOL success, gid_t gid); + enum winbindd_result winbindd_sid_to_gid(struct winbindd_cli_state *state) { DOM_SID sid; @@ -234,253 +212,301 @@ enum winbindd_result winbindd_sid_to_gid(struct winbindd_cli_state *state) /* Ensure null termination */ state->request.data.sid[sizeof(state->request.data.sid)-1]='\0'; - DEBUG(3, ("[%5lu]: sid to gid %s\n", (unsigned long)state->pid, + DEBUG(3, ("[%5lu]: sid to gid %s\n", (unsigned long)state->pid, state->request.data.sid)); - if (!string_to_sid(&sid, state->request.data.sid)) { - DEBUG(1, ("Could not cvt string to sid %s\n", state->request.data.sid)); + if (idmap_proxyonly()) { + DEBUG(8, ("IDMAP proxy only\n")); return WINBINDD_ERROR; } - /* This gets a little tricky. If we assume that usernames are syncd between - /etc/passwd and the windows domain (such as a member of a Samba domain), - the we need to get the uid from the OS and not alocate one ourselves */ - - if ( lp_winbind_trusted_domains_only() ) { - struct winbindd_domain *domain = NULL; - DOM_SID sid2; - uint32 rid; - unid_t id; - - domain = find_our_domain(); - if ( !domain ) { - DEBUG(0,("winbindd_sid_to_uid: can't find my own domain!\n")); - return WINBINDD_ERROR; - } - - sid_copy( &sid2, &sid ); - sid_split_rid( &sid2, &rid ); - - if ( sid_equal( &sid2, &domain->sid ) ) { - - fstring domain_name; - fstring group; - enum SID_NAME_USE type; - struct group *grp = NULL; - - /* ok...here's we know that we are dealing with our - own domain (the one to which we are joined). And - we know that there must be a UNIX account for this group. - So we lookup the sid and the call getpwnam().*/ - - /* But first check and see if we don't already have a mapping */ - - if ( NT_STATUS_IS_OK(idmap_sid_to_gid(&sid, &(state->response.data.gid), ID_QUERY_ONLY)) ) - return WINBINDD_OK; - - /* now fall back to the hard way */ - - if ( !winbindd_lookup_name_by_sid(&sid, domain_name, group, &type) ) - return WINBINDD_ERROR; - - if ( !(grp = getgrnam(group)) ) { - DEBUG(0,("winbindd_sid_to_uid: 'winbind trusted domains only' is " - "set but this group [%s] doesn't exist!\n", group)); - return WINBINDD_ERROR; - } - - state->response.data.gid = grp->gr_gid; - - id.gid = grp->gr_gid; - idmap_set_mapping( &sid, id, ID_GROUPID ); - - return WINBINDD_OK; - } - + if (!string_to_sid(&sid, state->request.data.sid)) { + DEBUG(1, ("Could not get convert sid %s from string\n", + state->request.data.sid)); + return WINBINDD_ERROR; } - - /* Find gid for this sid and return it */ + + /* Query only the local tdb, everything else might possibly block */ result = idmap_sid_to_gid(&sid, &(state->response.data.gid), - ID_QUERY_ONLY); + ID_QUERY_ONLY|ID_CACHE_ONLY); - if (NT_STATUS_IS_OK(result)) + if (NT_STATUS_IS_OK(result)) { return WINBINDD_OK; + } - if (state->request.flags & WBFLAG_QUERY_ONLY) - return WINBINDD_ERROR; + winbindd_sid2gid_async(state->mem_ctx, &sid, sid2gid_recv, state); + return WINBINDD_PENDING; +} - /* The query-only did not work, allocate a new gid *if* it's a group */ - - { - fstring dom_name, name; - enum SID_NAME_USE type; - - if (sid_check_is_in_our_domain(&sid)) { - /* This is for half-created aliases... */ - type = SID_NAME_ALIAS; - } else { - /* Foreign domains need to be looked up by the DC if - * it's the right type */ - if (!winbindd_lookup_name_by_sid(&sid, dom_name, name, - &type)) - return WINBINDD_ERROR; - } - - if ((type != SID_NAME_DOM_GRP) && (type != SID_NAME_ALIAS) && - (type != SID_NAME_WKN_GRP)) - return WINBINDD_ERROR; +static void sid2gid_recv(void *private, BOOL success, gid_t gid) +{ + struct winbindd_cli_state *state = + talloc_get_type_abort(private, struct winbindd_cli_state); + + if (!success) { + DEBUG(5, ("Could not convert sid %s\n", + state->request.data.sid)); + state->response.result = WINBINDD_ERROR; + request_finished(state); + return; } - - result = idmap_sid_to_gid(&sid, &(state->response.data.gid), 0); - - if (NT_STATUS_IS_OK(result)) - return WINBINDD_OK; - DEBUG(4, ("Could not get gid for sid %s\n", state->request.data.sid)); - return WINBINDD_ERROR; + state->response.result = WINBINDD_OK; + state->response.data.gid = gid; + request_finished(state); } /* Convert a uid to a sid */ +struct uid2sid_state { + struct winbindd_cli_state *cli_state; + uid_t uid; + fstring name; + DOM_SID sid; + enum SID_NAME_USE type; +}; + +static void uid2sid_uid2name_recv(void *private, BOOL success, + const char *username); +static void uid2sid_lookupname_recv(void *private, BOOL success, + const DOM_SID *sid, + enum SID_NAME_USE type); +static void uid2sid_idmap_set_mapping_recv(void *private, BOOL success); + enum winbindd_result winbindd_uid_to_sid(struct winbindd_cli_state *state) { DOM_SID sid; + NTSTATUS status; + struct uid2sid_state *uid2sid_state; DEBUG(3, ("[%5lu]: uid to sid %lu\n", (unsigned long)state->pid, (unsigned long)state->request.data.uid)); - if ( (state->request.data.uid < server_state.uid_low ) - || (state->request.data.uid > server_state.uid_high) ) - { - struct passwd *pw = NULL; - enum SID_NAME_USE type; - unid_t id; - struct winbindd_domain *domain; - - /* SPECIAL CASE FOR MEMBERS OF SAMBA DOMAINS */ - - /* if we don't trust /etc/password then when can't know - anything about this uid */ - - if ( !lp_winbind_trusted_domains_only() ) - return WINBINDD_ERROR; - - - /* look for an idmap entry first */ - - if ( NT_STATUS_IS_OK(idmap_uid_to_sid(&sid, state->request.data.uid)) ) - goto done; - - /* if users exist in /etc/passwd, we should try to - use that uid. Get the username and the lookup the SID */ - - if ( !(pw = getpwuid(state->request.data.uid)) ) - return WINBINDD_ERROR; - - if ( !(domain = find_our_domain()) ) { - DEBUG(0,("winbindd_uid_to_sid: can't find my own domain!\n")); - return WINBINDD_ERROR; - } - - if ( !winbindd_lookup_sid_by_name(domain, domain->name, pw->pw_name, &sid, &type) ) - return WINBINDD_ERROR; - - if ( type != SID_NAME_USER ) - return WINBINDD_ERROR; - - /* don't fail if we can't store it */ - - id.uid = pw->pw_uid; - idmap_set_mapping( &sid, id, ID_USERID ); - - goto done; + if (idmap_proxyonly()) { + DEBUG(8, ("IDMAP proxy only\n")); + return WINBINDD_ERROR; } - /* Lookup rid for this uid */ - - if (!NT_STATUS_IS_OK(idmap_uid_to_sid(&sid, state->request.data.uid))) { - DEBUG(1, ("Could not convert uid %lu to rid\n", - (unsigned long)state->request.data.uid)); + status = idmap_uid_to_sid(&sid, state->request.data.uid, + ID_QUERY_ONLY | ID_CACHE_ONLY); + + if (NT_STATUS_IS_OK(status)) { + sid_to_string(state->response.data.sid.sid, &sid); + state->response.data.sid.type = SID_NAME_USER; + return WINBINDD_OK; + } + + if (is_in_uid_range(state->request.data.uid)) { + /* This is winbind's, so we should better have succeeded + * above. */ return WINBINDD_ERROR; } -done: - sid_to_string(state->response.data.sid.sid, &sid); - state->response.data.sid.type = SID_NAME_USER; + /* The only chance that this is correct is that winbind trusted + * domains only = yes, and the user exists in nss and the domain. */ - return WINBINDD_OK; + if (!lp_winbind_trusted_domains_only()) { + return WINBINDD_ERROR; + } + + /* The only chance that this is correct is that winbind trusted + * domains only = yes, and the user exists in nss and the domain. */ + + uid2sid_state = TALLOC_ZERO_P(state->mem_ctx, struct uid2sid_state); + if (uid2sid_state == NULL) { + DEBUG(0, ("talloc failed\n")); + return WINBINDD_ERROR; + } + + uid2sid_state->cli_state = state; + uid2sid_state->uid = state->request.data.uid; + + winbindd_uid2name_async(state->mem_ctx, state->request.data.uid, + uid2sid_uid2name_recv, uid2sid_state); + return WINBINDD_PENDING; +} + +static void uid2sid_uid2name_recv(void *private, BOOL success, + const char *username) +{ + struct uid2sid_state *state = + talloc_get_type_abort(private, struct uid2sid_state); + + DEBUG(10, ("uid2sid: uid %lu has name %s\n", + (unsigned long)state->uid, username)); + + fstrcpy(state->name, username); + + if (!success) { + state->cli_state->response.result = WINBINDD_ERROR; + request_finished(state->cli_state); + return; + } + + winbindd_lookupname_async(state->cli_state->mem_ctx, + find_our_domain()->name, username, + uid2sid_lookupname_recv, state); +} + +static void uid2sid_lookupname_recv(void *private, BOOL success, + const DOM_SID *sid, enum SID_NAME_USE type) +{ + struct uid2sid_state *state = + talloc_get_type_abort(private, struct uid2sid_state); + unid_t id; + + if ((!success) || (type != SID_NAME_USER)) { + state->cli_state->response.result = WINBINDD_ERROR; + request_finished(state->cli_state); + return; + } + + state->sid = *sid; + state->type = type; + + id.uid = state->uid; + idmap_set_mapping_async(state->cli_state->mem_ctx, sid, id, ID_USERID, + uid2sid_idmap_set_mapping_recv, state ); +} + +static void uid2sid_idmap_set_mapping_recv(void *private, BOOL success) +{ + struct uid2sid_state *state = + talloc_get_type_abort(private, struct uid2sid_state); + + /* don't fail if we can't store it */ + + sid_to_string(state->cli_state->response.data.sid.sid, &state->sid); + state->cli_state->response.data.sid.type = state->type; + state->cli_state->response.result = WINBINDD_OK; + request_finished(state->cli_state); } /* Convert a gid to a sid */ +struct gid2sid_state { + struct winbindd_cli_state *cli_state; + gid_t gid; + fstring name; + DOM_SID sid; + enum SID_NAME_USE type; +}; + +static void gid2sid_gid2name_recv(void *private, BOOL success, + const char *groupname); +static void gid2sid_lookupname_recv(void *private, BOOL success, + const DOM_SID *sid, + enum SID_NAME_USE type); +static void gid2sid_idmap_set_mapping_recv(void *private, BOOL success); + enum winbindd_result winbindd_gid_to_sid(struct winbindd_cli_state *state) { DOM_SID sid; + NTSTATUS status; + struct gid2sid_state *gid2sid_state; - DEBUG(3, ("[%5lu]: gid to sid %lu\n", (unsigned long)state->pid, + DEBUG(3, ("[%5lu]: gid to sid %lu\n", (unsigned long)state->pid, (unsigned long)state->request.data.gid)); - - if ( (state->request.data.gid < server_state.gid_low) - || (state->request.data.gid > server_state.gid_high) ) - { - struct group *grp = NULL; - enum SID_NAME_USE type; - unid_t id; - struct winbindd_domain *domain; - - /* SPECIAL CASE FOR MEMBERS OF SAMBA DOMAINS */ - - /* if we don't trust /etc/group then when can't know - anything about this gid */ - - if ( !lp_winbind_trusted_domains_only() ) - return WINBINDD_ERROR; - - /* look for an idmap entry first */ - - if ( NT_STATUS_IS_OK(idmap_gid_to_sid(&sid, state->request.data.gid)) ) - goto done; - - /* if users exist in /etc/group, we should try to - use that gid. Get the username and the lookup the SID */ - - if ( !(grp = getgrgid(state->request.data.gid)) ) - return WINBINDD_ERROR; - - if ( !(domain = find_our_domain()) ) { - DEBUG(0,("winbindd_uid_to_sid: can't find my own domain!\n")); - return WINBINDD_ERROR; - } - - if ( !winbindd_lookup_sid_by_name(domain, domain->name, grp->gr_name, &sid, &type) ) - return WINBINDD_ERROR; - - if ( type!=SID_NAME_DOM_GRP && type!=SID_NAME_ALIAS ) - return WINBINDD_ERROR; - - /* don't fail if we can't store it */ - - id.gid = grp->gr_gid; - idmap_set_mapping( &sid, id, ID_GROUPID ); - - goto done; + + if (idmap_proxyonly()) { + DEBUG(8, ("IDMAP proxy only\n")); + return WINBINDD_ERROR; } - /* Lookup sid for this uid */ - - if (!NT_STATUS_IS_OK(idmap_gid_to_sid(&sid, state->request.data.gid))) { - DEBUG(1, ("Could not convert gid %lu to sid\n", - (unsigned long)state->request.data.gid)); + status = idmap_gid_to_sid(&sid, state->request.data.gid, + ID_QUERY_ONLY | ID_CACHE_ONLY); + + if (NT_STATUS_IS_OK(status)) { + sid_to_string(state->response.data.sid.sid, &sid); + state->response.data.sid.type = SID_NAME_USER; + return WINBINDD_OK; + } + + if (is_in_gid_range(state->request.data.gid)) { + /* This is winbind's, so we should better have succeeded + * above. */ return WINBINDD_ERROR; } -done: - /* Construct sid and return it */ - sid_to_string(state->response.data.sid.sid, &sid); - state->response.data.sid.type = SID_NAME_DOM_GRP; + /* The only chance that this is correct is that winbind trusted + * domains only = yes, and the user exists in nss and the domain. */ - return WINBINDD_OK; + if (!lp_winbind_trusted_domains_only()) { + return WINBINDD_ERROR; + } + + /* The only chance that this is correct is that winbind trusted + * domains only = yes, and the user exists in nss and the domain. */ + + gid2sid_state = TALLOC_ZERO_P(state->mem_ctx, struct gid2sid_state); + if (gid2sid_state == NULL) { + DEBUG(0, ("talloc failed\n")); + return WINBINDD_ERROR; + } + + gid2sid_state->cli_state = state; + gid2sid_state->gid = state->request.data.gid; + + winbindd_gid2name_async(state->mem_ctx, state->request.data.gid, + gid2sid_gid2name_recv, gid2sid_state); + return WINBINDD_PENDING; +} + +static void gid2sid_gid2name_recv(void *private, BOOL success, + const char *username) +{ + struct gid2sid_state *state = + talloc_get_type_abort(private, struct gid2sid_state); + + DEBUG(10, ("gid2sid: gid %lu has name %s\n", + (unsigned long)state->gid, username)); + + fstrcpy(state->name, username); + + if (!success) { + state->cli_state->response.result = WINBINDD_ERROR; + request_finished(state->cli_state); + return; + } + + winbindd_lookupname_async(state->cli_state->mem_ctx, + find_our_domain()->name, username, + gid2sid_lookupname_recv, state); +} + +static void gid2sid_lookupname_recv(void *private, BOOL success, + const DOM_SID *sid, enum SID_NAME_USE type) +{ + struct gid2sid_state *state = + talloc_get_type_abort(private, struct gid2sid_state); + unid_t id; + + if ((!success) || + ((type != SID_NAME_DOM_GRP) && (type!=SID_NAME_ALIAS))) { + state->cli_state->response.result = WINBINDD_ERROR; + request_finished(state->cli_state); + return; + } + + state->sid = *sid; + state->type = type; + + id.gid = state->gid; + idmap_set_mapping_async(state->cli_state->mem_ctx, sid, id, ID_GROUPID, + gid2sid_idmap_set_mapping_recv, state ); +} + +static void gid2sid_idmap_set_mapping_recv(void *private, BOOL success) +{ + struct gid2sid_state *state = private; + + /* don't fail if we can't store it */ + + sid_to_string(state->cli_state->response.data.sid.sid, &state->sid); + state->cli_state->response.data.sid.type = state->type; + state->cli_state->response.result = WINBINDD_OK; + request_finished(state->cli_state); } enum winbindd_result winbindd_allocate_rid(struct winbindd_cli_state *state) @@ -491,6 +517,15 @@ enum winbindd_result winbindd_allocate_rid(struct winbindd_cli_state *state) return WINBINDD_ERROR; } + async_request(state->mem_ctx, idmap_child(), + &state->request, &state->response, + request_finished_cont, state); + return WINBINDD_PENDING; +} + +enum winbindd_result winbindd_dual_allocate_rid(struct winbindd_domain *domain, + struct winbindd_cli_state *state) +{ /* We tell idmap to always allocate a user RID. There might be a good * reason to keep RID allocation for users to even and groups to * odd. This needs discussion I think. For now only allocate user @@ -502,3 +537,45 @@ enum winbindd_result winbindd_allocate_rid(struct winbindd_cli_state *state) return WINBINDD_OK; } + +enum winbindd_result winbindd_allocate_rid_and_gid(struct winbindd_cli_state *state) +{ + if ( !state->privileged ) { + DEBUG(2, ("winbindd_allocate_rid: non-privileged access " + "denied!\n")); + return WINBINDD_ERROR; + } + + async_request(state->mem_ctx, idmap_child(), + &state->request, &state->response, + request_finished_cont, state); + return WINBINDD_PENDING; +} + +enum winbindd_result winbindd_dual_allocate_rid_and_gid(struct winbindd_domain *domain, + struct winbindd_cli_state *state) +{ + NTSTATUS result; + DOM_SID sid; + + /* We tell idmap to always allocate a user RID. This is really + * historic and needs to be fixed. I *think* this has to do with the + * way winbind determines its free RID space. */ + + result = idmap_allocate_rid(&state->response.data.rid_and_gid.rid, + USER_RID_TYPE); + + if (!NT_STATUS_IS_OK(result)) + return WINBINDD_ERROR; + + sid_copy(&sid, get_global_sam_sid()); + sid_append_rid(&sid, state->response.data.rid_and_gid.rid); + + result = idmap_sid_to_gid(&sid, &state->response.data.rid_and_gid.gid, + 0); + + if (!NT_STATUS_IS_OK(result)) + return WINBINDD_ERROR; + + return WINBINDD_OK; +} |