X-Git-Url: http://git.samba.org/samba.git/?a=blobdiff_plain;f=source%2Fnsswitch%2Fwinbindd_group.c;h=05aeef2612f872cda960005b38d3927f33dfb8f3;hb=07b71a02aef15b75d281cabeb7140db1bc0bb283;hp=7219292724bc1b8c98e29015274e35fc3e1f8f9f;hpb=634e0dc3c73968da8f1f50186ca15f8873f380ce;p=sfrench%2Fsamba-autobuild%2F.git diff --git a/source/nsswitch/winbindd_group.c b/source/nsswitch/winbindd_group.c index 7219292724b..05aeef2612f 100644 --- a/source/nsswitch/winbindd_group.c +++ b/source/nsswitch/winbindd_group.c @@ -31,9 +31,150 @@ extern BOOL opt_nocache; #undef DBGC_CLASS #define DBGC_CLASS DBGC_WINBIND -/*************************************************************** - Empty static struct for negative caching. -****************************************************************/ +static void add_member(const char *domain, const char *user, + char **pp_members, size_t *p_num_members) +{ + fstring name; + + fill_domain_username(name, domain, user, True); + safe_strcat(name, ",", sizeof(name)-1); + string_append(pp_members, name); + *p_num_members += 1; +} + +/********************************************************************** + Add member users resulting from sid. Expand if it is a domain group. +**********************************************************************/ + +static void add_expanded_sid(const DOM_SID *sid, char **pp_members, size_t *p_num_members) +{ + DOM_SID dom_sid; + uint32 rid; + struct winbindd_domain *domain; + size_t i; + + char *domain_name = NULL; + char *name = NULL; + enum lsa_SidType type; + + uint32 num_names; + DOM_SID *sid_mem; + char **names; + uint32 *types; + + NTSTATUS result; + + TALLOC_CTX *mem_ctx = talloc_init("add_expanded_sid"); + + if (mem_ctx == NULL) { + DEBUG(1, ("talloc_init failed\n")); + return; + } + + sid_copy(&dom_sid, sid); + sid_split_rid(&dom_sid, &rid); + + domain = find_lookup_domain_from_sid(sid); + + if (domain == NULL) { + DEBUG(3, ("Could not find domain for sid %s\n", + sid_string_static(sid))); + goto done; + } + + result = domain->methods->sid_to_name(domain, mem_ctx, sid, + &domain_name, &name, &type); + + if (!NT_STATUS_IS_OK(result)) { + DEBUG(3, ("sid_to_name failed for sid %s\n", + sid_string_static(sid))); + goto done; + } + + DEBUG(10, ("Found name %s, type %d\n", name, type)); + + if (type == SID_NAME_USER) { + add_member(domain_name, name, pp_members, p_num_members); + goto done; + } + + if (type != SID_NAME_DOM_GRP) { + DEBUG(10, ("Alias member %s neither user nor group, ignore\n", + name)); + goto done; + } + + /* Expand the domain group, this must be done via the target domain */ + + domain = find_domain_from_sid(sid); + + if (domain == NULL) { + DEBUG(3, ("Could not find domain from SID %s\n", + sid_string_static(sid))); + goto done; + } + + result = domain->methods->lookup_groupmem(domain, mem_ctx, + sid, &num_names, + &sid_mem, &names, + &types); + + if (!NT_STATUS_IS_OK(result)) { + DEBUG(10, ("Could not lookup group members for %s: %s\n", + name, nt_errstr(result))); + goto done; + } + + for (i=0; iname, names[i], pp_members, p_num_members); + } + + done: + talloc_destroy(mem_ctx); + return; +} + +static BOOL fill_passdb_alias_grmem(struct winbindd_domain *domain, + DOM_SID *group_sid, + size_t *num_gr_mem, char **gr_mem, size_t *gr_mem_len) +{ + DOM_SID *members; + size_t i, num_members; + + *num_gr_mem = 0; + *gr_mem = NULL; + *gr_mem_len = 0; + + if (!NT_STATUS_IS_OK(pdb_enum_aliasmem(group_sid, &members, + &num_members))) + return True; + + for (i=0; igr_gid = unix_gid; @@ -57,18 +198,20 @@ static BOOL fill_grent(struct winbindd_gr *gr, const char *dom_name, /* Fill in the group membership field of a NT group given by group_sid */ static BOOL fill_grent_mem(struct winbindd_domain *domain, + struct winbindd_cli_state *state, DOM_SID *group_sid, - enum SID_NAME_USE group_name_type, + enum lsa_SidType group_name_type, size_t *num_gr_mem, char **gr_mem, size_t *gr_mem_len) { DOM_SID *sid_mem = NULL; uint32 num_names = 0; uint32 *name_types = NULL; - unsigned int buf_len, buf_ndx, i; - char **names = NULL, *buf; + unsigned int buf_len = 0, buf_ndx = 0, i; + char **names = NULL, *buf = NULL; BOOL result = False; TALLOC_CTX *mem_ctx; NTSTATUS status; + uint32 group_rid; fstring sid_string; if (!(mem_ctx = talloc_init("fill_grent_mem(%s)", domain->name))) @@ -78,16 +221,19 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain, DEBUG(10, ("group SID %s\n", sid_to_string(sid_string, group_sid))); + /* Initialize with no members */ *num_gr_mem = 0; /* HACK ALERT!! This whole routine does not cope with group members * from more than one domain, ie aliases. Thus we have to work it out * ourselves in a special routine. */ - if (domain->internal) - return fill_passdb_alias_grmem(domain, group_sid, + if (domain->internal) { + result = fill_passdb_alias_grmem(domain, group_sid, num_gr_mem, gr_mem, gr_mem_len); + goto done; + } if ( !((group_name_type==SID_NAME_DOM_GRP) || ((group_name_type==SID_NAME_ALIAS) && domain->primary)) ) @@ -98,13 +244,125 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain, goto done; } + /* OPTIMIZATION / HACK. */ + /* If "enum users" is set to false, and the group being looked + up is the Domain Users SID: S-1-5-domain-513, then for the + list of members check if the querying user is in that group, + and if so only return that user as the gr_mem array. + We can change this to a different parameter than "enum users" + if neccessaey, or parameterize the group list we do this for. */ + + sid_peek_rid( group_sid, &group_rid ); + if (!lp_winbind_enum_users() && group_rid == DOMAIN_GROUP_RID_USERS) { + DOM_SID querying_user_sid; + DOM_SID *pquerying_user_sid = NULL; + uint32 num_groups = 0; + DOM_SID *user_sids = NULL; + BOOL u_in_group = False; + + DEBUG(10,("fill_grent_mem: optimized lookup for sid %s domain %s\n", + sid_to_string(sid_string, group_sid), domain->name )); + + if (state) { + uid_t ret_uid = (uid_t)-1; + if (sys_getpeereid(state->sock, &ret_uid)==0) { + /* We know who's asking - look up their SID if + it's one we've mapped before. */ + status = idmap_uid_to_sid(&querying_user_sid, ret_uid); + if (NT_STATUS_IS_OK(status)) { + pquerying_user_sid = &querying_user_sid; + DEBUG(10,("fill_grent_mem: querying uid %u -> %s\n", + (unsigned int)ret_uid, + sid_to_string(sid_string, pquerying_user_sid) )); + } + } + } + + /* Only look up if it was a winbindd user in this domain. */ + if (pquerying_user_sid && + (sid_compare_domain(pquerying_user_sid, &domain->sid) == 0)) { + + DEBUG(10,("fill_grent_mem: querying user = %s\n", + sid_to_string(sid_string, pquerying_user_sid) )); + + status = domain->methods->lookup_usergroups(domain, + mem_ctx, + pquerying_user_sid, + &num_groups, + &user_sids); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(1, ("fill_grent_mem: lookup_usergroups failed " + "for sid %s in domain %s (error: %s)\n", + sid_to_string(sid_string, pquerying_user_sid), + domain->name, + nt_errstr(status))); + goto done; + } + + for (i = 0; i < num_groups; i++) { + if (sid_equal(group_sid, &user_sids[i])) { + /* User is in Domain Users, add their name + as the only group member. */ + u_in_group = True; + break; + } + } + } + + if (u_in_group) { + size_t len = 0; + char *domainname = NULL; + char *username = NULL; + fstring name; + enum lsa_SidType type; + + DEBUG(10,("fill_grent_mem: sid %s in 'Domain Users' in domain %s\n", + sid_to_string(sid_string, pquerying_user_sid), domain->name )); + + status = domain->methods->sid_to_name(domain, mem_ctx, + pquerying_user_sid, + &domainname, + &username, + &type); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(1, ("could not lookup username for user " + "sid %s in domain %s (error: %s)\n", + sid_to_string(sid_string, pquerying_user_sid), + domain->name, + nt_errstr(status))); + goto done; + } + fill_domain_username(name, domain->name, username, True); + len = strlen(name); + buf_len = len + 1; + if (!(buf = (char *)SMB_MALLOC(buf_len))) { + DEBUG(1, ("out of memory\n")); + goto done; + } + memcpy(buf, name, buf_len); + + DEBUG(10,("fill_grent_mem: user %s in 'Domain Users' in domain %s\n", + name, domain->name )); + + /* user is the only member */ + *num_gr_mem = 1; + } + + *gr_mem = buf; + *gr_mem_len = buf_len; + + DEBUG(10, ("num_mem = %u, len = %u, mem = %s\n", (unsigned int)*num_gr_mem, + (unsigned int)buf_len, *num_gr_mem ? buf : "NULL")); + result = True; + goto done; + } + /* Lookup group members */ status = domain->methods->lookup_groupmem(domain, mem_ctx, group_sid, &num_names, &sid_mem, &names, &name_types); if (!NT_STATUS_IS_OK(status)) { - DEBUG(1, ("could not lookup membership for group rid %s in domain %s (error: %s)\n", + DEBUG(1, ("could not lookup membership for group sid %s in domain %s (error: %s)\n", sid_to_string(sid_string, group_sid), domain->name, nt_errstr(status))); - goto done; } @@ -119,9 +377,6 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain, /* Add members to list */ - buf = NULL; - buf_len = buf_ndx = 0; - again: for (i = 0; i < num_names; i++) { @@ -146,7 +401,7 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain, /* Append domain name */ - fill_domain_username(name, domain->name, the_name, False); + fill_domain_username(name, domain->name, the_name, True); len = strlen(name); @@ -157,7 +412,7 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain, (*num_gr_mem)++; DEBUG(10, ("buf_len + %d = %d\n", len + 1, buf_len)); } else { - DEBUG(10, ("appending %s at ndx %d\n", name, len)); + DEBUG(10, ("appending %s at ndx %d\n", name, buf_ndx)); safe_strcpy(&buf[buf_ndx], name, len); buf_ndx += len; buf[buf_ndx] = ','; @@ -168,7 +423,7 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain, /* Allocate buffer */ if (!buf && buf_len != 0) { - if (!(buf = SMB_MALLOC(buf_len))) { + if (!(buf = (char *)SMB_MALLOC(buf_len))) { DEBUG(1, ("out of memory\n")); result = False; goto done; @@ -184,8 +439,8 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain, *gr_mem = buf; *gr_mem_len = buf_len; - DEBUG(10, ("num_mem = %d, len = %d, mem = %s\n", *num_gr_mem, - buf_len, *num_gr_mem ? buf : "NULL")); + DEBUG(10, ("num_mem = %u, len = %u, mem = %s\n", (unsigned int)*num_gr_mem, + (unsigned int)buf_len, *num_gr_mem ? buf : "NULL")); result = True; done: @@ -197,21 +452,36 @@ done: return result; } +static void winbindd_getgrsid( struct winbindd_cli_state *state, DOM_SID group_sid ); + +static void getgrnam_recv( void *private_data, BOOL success, const DOM_SID *sid, + enum lsa_SidType type ) +{ + struct winbindd_cli_state *state = (struct winbindd_cli_state*)private_data; + + if (!success) { + DEBUG(5,("getgrnam_recv: lookupname failed!\n")); + request_error(state); + return; + } + + if ( !(type == SID_NAME_DOM_GRP) || (type == SID_NAME_ALIAS) ) { + DEBUG(5,("getgrnam_recv: not a group!\n")); + request_error(state); + return; + } + + winbindd_getgrsid( state, *sid ); +} + + /* Return a group structure from a group name */ void winbindd_getgrnam(struct winbindd_cli_state *state) { - DOM_SID group_sid, tmp_sid; - uint32 grp_rid; struct winbindd_domain *domain; - enum SID_NAME_USE name_type; fstring name_domain, name_group; - char *tmp, *gr_mem; - size_t gr_mem_len; - size_t num_gr_mem; - gid_t gid; - union unid_t id; - NTSTATUS status; + char *tmp; /* Ensure null termination */ state->request.data.groupname[sizeof(state->request.data.groupname)-1]='\0'; @@ -224,6 +494,9 @@ void winbindd_getgrnam(struct winbindd_cli_state *state) memset(name_group, 0, sizeof(fstring)); tmp = state->request.data.groupname; + + name_domain[0] = '\0'; + name_group[0] = '\0'; parse_domain_user(tmp, name_domain, name_group); @@ -252,178 +525,180 @@ void winbindd_getgrnam(struct winbindd_cli_state *state) } /* Get rid and name type from name */ + + ws_name_replace( name_group, WB_REPLACE_CHAR ); - if (!winbindd_lookup_sid_by_name(state->mem_ctx, domain, domain->name, - name_group, &group_sid, &name_type)) { - DEBUG(1, ("group %s in domain %s does not exist\n", - name_group, name_domain)); - request_error(state); - return; + winbindd_lookupname_async( state->mem_ctx, domain->name, name_group, + getgrnam_recv, WINBINDD_GETGRNAM, state ); } - if ( !((name_type==SID_NAME_DOM_GRP) || - ((name_type==SID_NAME_ALIAS) && domain->primary) || - ((name_type==SID_NAME_ALIAS) && domain->internal) || - ((name_type==SID_NAME_WKN_GRP) && domain->internal)) ) +struct getgrsid_state { + struct winbindd_cli_state *state; + struct winbindd_domain *domain; + char *group_name; + enum lsa_SidType group_type; + uid_t gid; + DOM_SID group_sid; +}; + +static void getgrsid_sid2gid_recv(void *private_data, BOOL success, gid_t gid) { - DEBUG(1, ("name '%s' is not a local, domain or builtin " - "group: %d\n", name_group, name_type)); - request_error(state); + struct getgrsid_state *s = + (struct getgrsid_state *)private_data; + struct winbindd_domain *domain; + size_t gr_mem_len; + size_t num_gr_mem; + char *gr_mem; + fstring dom_name, group_name; + + if (!success) { + DEBUG(5,("getgrsid_sid2gid_recv: sid2gid failed!\n")); + request_error(s->state); return; } - /* Make sure that the group SID is within the domain of the - original domain */ + s->gid = gid; - sid_copy( &tmp_sid, &group_sid ); - sid_split_rid( &tmp_sid, &grp_rid ); - if ( !sid_equal( &tmp_sid, &domain->sid ) ) { - DEBUG(3,("winbindd_getgrnam: group %s resolves to a SID in the wrong domain [%s]\n", - state->request.data.groupname, sid_string_static(&group_sid))); - request_error(state); + if ( !parse_domain_user( s->group_name, dom_name, group_name ) ) { + DEBUG(5,("getgrsid_sid2gid_recv: parse_domain_user() failed!\n")); + request_error(s->state); return; } + /* Fill in group structure */ - /* Try to get the GID */ - - status = idmap_sid_to_gid(&group_sid, &gid, 0); - - if (NT_STATUS_IS_OK(status)) { - goto got_gid; - } - - /* Maybe it's one of our aliases in passdb */ - - if (pdb_sid_to_id(&group_sid, &id, &name_type) && - ((name_type == SID_NAME_ALIAS) || - (name_type == SID_NAME_WKN_GRP))) { - gid = id.gid; - goto got_gid; + if ( (domain = find_domain_from_name_noinit(dom_name)) == NULL ) { + DEBUG(1,("Can't find domain from name (%s)\n", dom_name)); + request_error(s->state); + return; } - DEBUG(1, ("error converting unix gid to sid\n")); - request_error(state); - return; - - got_gid: - - if (!fill_grent(&state->response.data.gr, name_domain, - name_group, gid) || - !fill_grent_mem(domain, &group_sid, name_type, - &num_gr_mem, - &gr_mem, &gr_mem_len)) { - request_error(state); + if (!fill_grent(&s->state->response.data.gr, dom_name, group_name, gid) || + !fill_grent_mem(domain, s->state, &s->group_sid, s->group_type, + &num_gr_mem, &gr_mem, &gr_mem_len)) + { + request_error(s->state); return; } - state->response.data.gr.num_gr_mem = (uint32)num_gr_mem; + s->state->response.data.gr.num_gr_mem = (uint32)num_gr_mem; /* Group membership lives at start of extra data */ - state->response.data.gr.gr_mem_ofs = 0; + s->state->response.data.gr.gr_mem_ofs = 0; - state->response.length += gr_mem_len; - state->response.extra_data.data = gr_mem; - request_ok(state); -} + s->state->response.length += gr_mem_len; + s->state->response.extra_data.data = gr_mem; -/* Return a group structure from a gid number */ + request_ok(s->state); + } -void winbindd_getgrgid(struct winbindd_cli_state *state) +static void getgrsid_lookupsid_recv( void *private_data, BOOL success, + const char *dom_name, const char *name, + enum lsa_SidType name_type ) { - struct winbindd_domain *domain; - DOM_SID group_sid; - enum SID_NAME_USE name_type; - fstring dom_name; - fstring group_name; - size_t gr_mem_len; - size_t num_gr_mem; - char *gr_mem; - NTSTATUS status; - - DEBUG(3, ("[%5lu]: getgrgid %lu\n", (unsigned long)state->pid, - (unsigned long)state->request.data.gid)); - - /* Bug out if the gid isn't in the winbind range */ + struct getgrsid_state *s = (struct getgrsid_state *)private_data; - if ((state->request.data.gid < server_state.gid_low) || - (state->request.data.gid > server_state.gid_high)) { - request_error(state); + if (!success) { + DEBUG(5,("getgrsid_lookupsid_recv: lookupsid failed!\n")); + request_error(s->state); return; } - /* Get sid from gid */ + /* eitehr it's a domain group, a domain local group, or a + local group in an internal domain */ + + if ( !( (name_type==SID_NAME_DOM_GRP) || + ((name_type==SID_NAME_ALIAS) && + (s->domain->primary || s->domain->internal)) ) ) + { + DEBUG(1, ("name '%s\\%s' is not a local or domain group: %d\n", + dom_name, name, name_type)); + request_error(s->state); + return; +} - status = idmap_gid_to_sid(&group_sid, state->request.data.gid, 0); - if (NT_STATUS_IS_OK(status)) { - /* This is a remote one */ - goto got_sid; + if ( (s->group_name = talloc_asprintf( s->state->mem_ctx, + "%s\\%s", + dom_name, name )) == NULL ) +{ + DEBUG(1, ("getgrsid_lookupsid_recv: talloc_asprintf() Failed!\n")); + request_error(s->state); + return; } - /* Ok, this might be "ours", i.e. an alias */ + s->group_type = name_type; - if (pdb_gid_to_sid(state->request.data.gid, &group_sid) && - lookup_sid(state->mem_ctx, &group_sid, NULL, NULL, &name_type) && - (name_type == SID_NAME_ALIAS)) { - /* Hey, got an alias */ - goto got_sid; + winbindd_sid2gid_async(s->state->mem_ctx, &s->group_sid, + getgrsid_sid2gid_recv, s); } - DEBUG(1, ("could not convert gid %lu to sid\n", - (unsigned long)state->request.data.gid)); - request_error(state); - return; - - got_sid: - /* Get name from sid */ +static void winbindd_getgrsid( struct winbindd_cli_state *state, const DOM_SID group_sid ) + { + struct getgrsid_state *s; - if (!winbindd_lookup_name_by_sid(state->mem_ctx, &group_sid, dom_name, - group_name, &name_type)) { - DEBUG(1, ("could not lookup sid\n")); + if ( (s = TALLOC_ZERO_P(state->mem_ctx, struct getgrsid_state)) == NULL ) { + DEBUG(0, ("talloc failed\n")); request_error(state); return; } - /* Fill in group structure */ - - domain = find_domain_from_sid_noinit(&group_sid); + s->state = state; - if (!domain) { - DEBUG(1,("Can't find domain from sid\n")); + if ( (s->domain = find_domain_from_sid_noinit(&group_sid)) == NULL ) { + DEBUG(3, ("Could not find domain for sid %s\n", + sid_string_static(&group_sid))); request_error(state); return; } - if ( !((name_type==SID_NAME_DOM_GRP) || - ((name_type==SID_NAME_ALIAS) && domain->primary) || - ((name_type==SID_NAME_ALIAS) && domain->internal)) ) - { - DEBUG(1, ("name '%s' is not a local or domain group: %d\n", - group_name, name_type)); - request_error(state); + sid_copy(&s->group_sid, &group_sid); + + winbindd_lookupsid_async( s->state->mem_ctx, &group_sid, + getgrsid_lookupsid_recv, s ); +} + + +static void getgrgid_recv(void *private_data, BOOL success, const char *sid) +{ + struct winbindd_cli_state *state = talloc_get_type_abort(private_data, struct winbindd_cli_state); + enum lsa_SidType name_type; + DOM_SID group_sid; + + if (success) { + DEBUG(10,("getgrgid_recv: gid %lu has sid %s\n", + (unsigned long)(state->request.data.gid), sid)); + + string_to_sid(&group_sid, sid); + winbindd_getgrsid(state, group_sid); return; } - if (!fill_grent(&state->response.data.gr, dom_name, group_name, - state->request.data.gid) || - !fill_grent_mem(domain, &group_sid, name_type, - &num_gr_mem, - &gr_mem, &gr_mem_len)) { - request_error(state); + /* Ok, this might be "ours", i.e. an alias */ + if (pdb_gid_to_sid(state->request.data.gid, &group_sid) && + lookup_sid(state->mem_ctx, &group_sid, NULL, NULL, &name_type) && + (name_type == SID_NAME_ALIAS)) { + /* Hey, got an alias */ + DEBUG(10,("getgrgid_recv: we have an alias with gid %lu and sid %s\n", + (unsigned long)(state->request.data.gid), sid)); + winbindd_getgrsid(state, group_sid); return; } - state->response.data.gr.num_gr_mem = (uint32)num_gr_mem; - - /* Group membership lives at start of extra data */ + DEBUG(1, ("could not convert gid %lu to sid\n", + (unsigned long)state->request.data.gid)); + request_error(state); +} - state->response.data.gr.gr_mem_ofs = 0; +/* Return a group structure from a gid number */ +void winbindd_getgrgid(struct winbindd_cli_state *state) +{ + DEBUG(3, ("[%5lu]: getgrgid %lu\n", (unsigned long)state->pid, + (unsigned long)state->request.data.gid)); - state->response.length += gr_mem_len; - state->response.extra_data.data = gr_mem; - request_ok(state); + /* always use the async interface */ + winbindd_gid2sid_async(state->mem_ctx, state->request.data.gid, getgrgid_recv, state); } /* @@ -627,7 +902,7 @@ void winbindd_getgrent(struct winbindd_cli_state *state) { struct getent_state *ent; struct winbindd_gr *group_list = NULL; - int num_groups, group_list_ndx = 0, i, gr_mem_list_len = 0; + int num_groups, group_list_ndx, gr_mem_list_len = 0; char *gr_mem_list = NULL; DEBUG(3, ("[%5lu]: getgrent\n", (unsigned long)state->pid)); @@ -641,6 +916,11 @@ void winbindd_getgrent(struct winbindd_cli_state *state) num_groups = MIN(MAX_GETGRENT_GROUPS, state->request.data.num_entries); + if (num_groups == 0) { + request_error(state); + return; + } + if ((state->response.extra_data.data = SMB_MALLOC_ARRAY(struct winbindd_gr, num_groups)) == NULL) { request_error(state); return; @@ -663,7 +943,7 @@ void winbindd_getgrent(struct winbindd_cli_state *state) /* Start sending back groups */ - for (i = 0; i < num_groups; i++) { + for (group_list_ndx = 0; group_list_ndx < num_groups; ) { struct acct_info *name_list = NULL; fstring domain_group_name; uint32 result; @@ -704,7 +984,7 @@ void winbindd_getgrent(struct winbindd_cli_state *state) break; } - name_list = ent->sam_entries; + name_list = (struct acct_info *)ent->sam_entries; if (!(domain = find_domain_from_name(ent->domain_name))) { @@ -718,10 +998,9 @@ void winbindd_getgrent(struct winbindd_cli_state *state) sid_copy(&group_sid, &domain->sid); sid_append_rid(&group_sid, name_list[ent->sam_entry_index].rid); - if (!NT_STATUS_IS_OK(idmap_sid_to_gid(&group_sid, - &group_gid, 0))) { + if (!NT_STATUS_IS_OK(idmap_sid_to_gid(&group_sid, &group_gid))) { union unid_t id; - enum SID_NAME_USE type; + enum lsa_SidType type; DEBUG(10, ("SID %s not in idmap\n", sid_string_static(&group_sid))); @@ -752,7 +1031,7 @@ void winbindd_getgrent(struct winbindd_cli_state *state) /* Fill in group entry */ fill_domain_username(domain_group_name, ent->domain_name, - name_list[ent->sam_entry_index].acct_name, False); + name_list[ent->sam_entry_index].acct_name, True); result = fill_grent(&group_list[group_list_ndx], ent->domain_name, @@ -776,6 +1055,7 @@ void winbindd_getgrent(struct winbindd_cli_state *state) sid_append_rid(&member_sid, name_list[ent->sam_entry_index].rid); result = fill_grent_mem( domain, + NULL, &member_sid, SID_NAME_DOM_GRP, &num_gr_mem, @@ -787,16 +1067,17 @@ void winbindd_getgrent(struct winbindd_cli_state *state) if (result) { /* Append to group membership list */ - gr_mem_list = SMB_REALLOC( gr_mem_list, gr_mem_list_len + gr_mem_len); + gr_mem_list = (char *)SMB_REALLOC( + gr_mem_list, gr_mem_list_len + gr_mem_len); - if (!gr_mem_list) { + if (!gr_mem_list && (group_list[group_list_ndx].num_gr_mem != 0)) { DEBUG(0, ("out of memory\n")); gr_mem_list_len = 0; break; } - DEBUG(10, ("list_len = %d, mem_len = %d\n", - gr_mem_list_len, gr_mem_len)); + DEBUG(10, ("list_len = %d, mem_len = %u\n", + gr_mem_list_len, (unsigned int)gr_mem_len)); memcpy(&gr_mem_list[gr_mem_list_len], gr_mem, gr_mem_len); @@ -915,7 +1196,8 @@ void winbindd_list_groups(struct winbindd_cli_state *state) /* Allocate some memory for extra data. Note that we limit account names to sizeof(fstring) = 128 characters. */ - extra_data = SMB_REALLOC(extra_data, sizeof(fstring) * total_entries); + extra_data = (char *)SMB_REALLOC( + extra_data, sizeof(fstring) * total_entries); if (!extra_data) { DEBUG(0,("failed to enlarge buffer!\n")); @@ -929,7 +1211,7 @@ void winbindd_list_groups(struct winbindd_cli_state *state) groups.sam_entries)[i].acct_name; fstring name; - fill_domain_username(name, domain->name, group_name, False); + fill_domain_username(name, domain->name, group_name, True); /* Append to extra data */ memcpy(&extra_data[extra_data_len], name, strlen(name)); @@ -974,7 +1256,7 @@ struct getgroups_state { }; static void getgroups_usersid_recv(void *private_data, BOOL success, - const DOM_SID *sid, enum SID_NAME_USE type); + const DOM_SID *sid, enum lsa_SidType type); static void getgroups_tokensids_recv(void *private_data, BOOL success, DOM_SID *token_sids, size_t num_token_sids); static void getgroups_sid2gid_recv(void *private_data, BOOL success, gid_t gid); @@ -1001,6 +1283,8 @@ void winbindd_getgroups(struct winbindd_cli_state *state) s->state = state; + ws_name_return( state->request.data.username, WB_REPLACE_CHAR ); + if (!parse_domain_user_talloc(state->mem_ctx, state->request.data.username, &s->domname, &s->username)) { @@ -1030,7 +1314,7 @@ void winbindd_getgroups(struct winbindd_cli_state *state) } if ( s->domain->primary && lp_winbind_trusted_domains_only()) { - DEBUG(7,("winbindd_getpwnam: My domain -- rejecting " + DEBUG(7,("winbindd_getgroups: My domain -- rejecting " "getgroups() for %s\\%s.\n", s->domname, s->username)); request_error(state); @@ -1040,13 +1324,14 @@ void winbindd_getgroups(struct winbindd_cli_state *state) /* Get rid and name type from name. The following costs 1 packet */ winbindd_lookupname_async(state->mem_ctx, s->domname, s->username, - getgroups_usersid_recv, s); + getgroups_usersid_recv, WINBINDD_GETGROUPS, s); } static void getgroups_usersid_recv(void *private_data, BOOL success, - const DOM_SID *sid, enum SID_NAME_USE type) + const DOM_SID *sid, enum lsa_SidType type) { - struct getgroups_state *s = private_data; + struct getgroups_state *s = + (struct getgroups_state *)private_data; if ((!success) || ((type != SID_NAME_USER) && (type != SID_NAME_COMPUTER))) { @@ -1063,7 +1348,8 @@ static void getgroups_usersid_recv(void *private_data, BOOL success, static void getgroups_tokensids_recv(void *private_data, BOOL success, DOM_SID *token_sids, size_t num_token_sids) { - struct getgroups_state *s = private_data; + struct getgroups_state *s = + (struct getgroups_state *)private_data; /* We need at least the user sid and the primary group in the token, * otherwise it's an error */ @@ -1085,12 +1371,16 @@ static void getgroups_tokensids_recv(void *private_data, BOOL success, static void getgroups_sid2gid_recv(void *private_data, BOOL success, gid_t gid) { - struct getgroups_state *s = private_data; + struct getgroups_state *s = + (struct getgroups_state *)private_data; - if (success) - add_gid_to_array_unique(NULL, gid, + if (success) { + if (!add_gid_to_array_unique(s->state->mem_ctx, gid, &s->token_gids, - &s->num_token_gids); + &s->num_token_gids)) { + return; + } + } if (s->i < s->num_token_sids) { const DOM_SID *sid = &s->token_sids[s->i]; @@ -1107,7 +1397,8 @@ static void getgroups_sid2gid_recv(void *private_data, BOOL success, gid_t gid) } s->state->response.data.num_entries = s->num_token_gids; - s->state->response.extra_data.data = s->token_gids; + /* s->token_gids are talloced */ + s->state->response.extra_data.data = smb_xmemdup(s->token_gids, s->num_token_gids * sizeof(gid_t)); s->state->response.length += s->num_token_gids * sizeof(gid_t); request_ok(s->state); } @@ -1155,7 +1446,8 @@ void winbindd_getusersids(struct winbindd_cli_state *state) static void getusersids_recv(void *private_data, BOOL success, DOM_SID *sids, size_t num_sids) { - struct winbindd_cli_state *state = private_data; + struct winbindd_cli_state *state = + (struct winbindd_cli_state *)private_data; char *ret = NULL; unsigned ofs, ret_size = 0; size_t i; @@ -1172,7 +1464,7 @@ static void getusersids_recv(void *private_data, BOOL success, DOM_SID *sids, } /* build the reply */ - ret = SMB_MALLOC(ret_size); + ret = (char *)SMB_MALLOC(ret_size); if (!ret) { DEBUG(0, ("malloc failed\n")); request_error(state); @@ -1250,12 +1542,15 @@ enum winbindd_result winbindd_dual_getuserdomgroups(struct winbindd_domain *doma return WINBINDD_OK; } - if (!print_sidlist(NULL, groups, num_groups, &sidstring, &len)) { - DEBUG(0, ("malloc failed\n")); + if (!print_sidlist(state->mem_ctx, groups, num_groups, &sidstring, &len)) { + DEBUG(0, ("talloc failed\n")); return WINBINDD_ERROR; } - state->response.extra_data.data = sidstring; + state->response.extra_data.data = SMB_STRDUP(sidstring); + if (!state->response.extra_data.data) { + return WINBINDD_ERROR; + } state->response.length += len+1; state->response.data.num_entries = num_groups;