From 4be7a83a2cc249f4b15de43df30560fe078dacf8 Mon Sep 17 00:00:00 2001 From: Simo Sorce Date: Sun, 6 Jul 2008 12:55:07 -0400 Subject: Clean up winbindd_group.c too (This used to be commit 50a347f5503ebed0fcc7b9de60f8368677585bb1) --- source3/winbindd/winbindd_group.c | 465 +++++++++++++++++++++----------------- 1 file changed, 255 insertions(+), 210 deletions(-) diff --git a/source3/winbindd/winbindd_group.c b/source3/winbindd/winbindd_group.c index 20b90e3283..69e3a6a555 100644 --- a/source3/winbindd/winbindd_group.c +++ b/source3/winbindd/winbindd_group.c @@ -45,7 +45,9 @@ static void add_member(const char *domain, const char *user, 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) +static void add_expanded_sid(const DOM_SID *sid, + char **pp_members, + size_t *p_num_members) { DOM_SID dom_sid; uint32 rid; @@ -143,8 +145,8 @@ static void add_expanded_sid(const DOM_SID *sid, char **pp_members, size_t *p_nu } 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 *group_sid, size_t *num_gr_mem, + char **gr_mem, size_t *gr_mem_len) { DOM_SID *members; size_t i, num_members; @@ -177,7 +179,7 @@ static bool fill_passdb_alias_grmem(struct winbindd_domain *domain, /* Fill a grent structure from various other information */ -static bool fill_grent(struct winbindd_gr *gr, const char *dom_name, +static bool fill_grent(struct winbindd_gr *gr, const char *dom_name, const char *gr_name, gid_t unix_gid) { fstring full_group_name; @@ -185,9 +187,9 @@ static bool fill_grent(struct winbindd_gr *gr, const char *dom_name, fill_domain_username( full_group_name, dom_name, gr_name, True ); gr->gr_gid = unix_gid; - + /* Group name and password */ - + safe_strcpy(gr->gr_name, full_group_name, sizeof(gr->gr_name) - 1); safe_strcpy(gr->gr_passwd, "x", sizeof(gr->gr_passwd) - 1); @@ -208,7 +210,7 @@ static bool fill_grent_mem_domusers( TALLOC_CTX *mem_ctx, struct winbindd_cli_state *state, DOM_SID *group_sid, enum lsa_SidType group_name_type, - size_t *num_gr_mem, char **gr_mem, + size_t *num_gr_mem, char **gr_mem, size_t *gr_mem_len) { DOM_SID querying_user_sid; @@ -232,7 +234,8 @@ static bool fill_grent_mem_domusers( TALLOC_CTX *mem_ctx, 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_domain_users: querying uid %u -> %s\n", + DEBUG(10,("fill_grent_mem_domain_users: " + "querying uid %u -> %s\n", (unsigned int)ret_uid, sid_string_dbg(pquerying_user_sid))); } @@ -242,22 +245,23 @@ static bool fill_grent_mem_domusers( TALLOC_CTX *mem_ctx, /* 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_domain_users: querying user = %s\n", sid_string_dbg(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_domain_users: lookup_usergroups failed " - "for sid %s in domain %s (error: %s)\n", + DEBUG(1, ("fill_grent_mem_domain_users: " + "lookup_usergroups failed " + "for sid %s in domain %s (error: %s)\n", sid_string_dbg(pquerying_user_sid), domain->name, nt_errstr(status))); - return False; + return False; } for (i = 0; i < num_groups; i++) { @@ -269,18 +273,19 @@ static bool fill_grent_mem_domusers( TALLOC_CTX *mem_ctx, } } } - + 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_domain_users: sid %s in 'Domain Users' in domain %s\n", + + DEBUG(10,("fill_grent_mem_domain_users: " + "sid %s in 'Domain Users' in domain %s\n", sid_string_dbg(pquerying_user_sid), domain->name )); - + status = domain->methods->sid_to_name(domain, mem_ctx, pquerying_user_sid, &domainname, @@ -288,38 +293,39 @@ static bool fill_grent_mem_domusers( TALLOC_CTX *mem_ctx, &type); if (!NT_STATUS_IS_OK(status)) { DEBUG(1, ("could not lookup username for user " - "sid %s in domain %s (error: %s)\n", + "sid %s in domain %s (error: %s)\n", sid_string_dbg(pquerying_user_sid), domain->name, nt_errstr(status))); - return False; + return False; } 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")); - return False; + return False; } memcpy(buf, name, buf_len); - + DEBUG(10,("fill_grent_mem_domain_users: 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, ("fill_grent_mem_domain_users: num_mem = %u, len = %u, mem = %s\n", - (unsigned int)*num_gr_mem, - (unsigned int)buf_len, *num_gr_mem ? buf : "NULL")); + + DEBUG(10, ("fill_grent_mem_domain_users: " + "num_mem = %u, len = %u, mem = %s\n", + (unsigned int)*num_gr_mem, + (unsigned int)buf_len, *num_gr_mem ? buf : "NULL")); return True; -} +} /*********************************************************************** Add names to a list. Assumes a canonical version of the string @@ -328,28 +334,29 @@ static bool fill_grent_mem_domusers( TALLOC_CTX *mem_ctx, static int namecmp( const void *a, const void *b ) { - return StrCaseCmp( * (char * const *) a, * (char * const *) b); + return StrCaseCmp( * (char * const *) a, * (char * const *) b); } -static NTSTATUS add_names_to_list( TALLOC_CTX *ctx, - char ***list, uint32 *n_list, +static NTSTATUS add_names_to_list( TALLOC_CTX *ctx, + char ***list, uint32 *n_list, char **names, uint32 n_names ) { - char **new_list = NULL; - uint32 n_new_list = 0; - int i, j; + char **new_list = NULL; + uint32 n_new_list = 0; + int i, j; if ( !names || (n_names == 0) ) return NT_STATUS_OK; - + /* Alloc the maximum size we'll need */ if ( *list == NULL ) { - if ( (new_list = TALLOC_ARRAY( ctx, char *, n_names )) == NULL ) + if ((new_list = TALLOC_ARRAY(ctx, char *, n_names)) == NULL) { return NT_STATUS_NO_MEMORY; - n_new_list = n_names; + } + n_new_list = n_names; } else { - new_list = TALLOC_REALLOC_ARRAY( ctx, *list, char *, + new_list = TALLOC_REALLOC_ARRAY( ctx, *list, char *, (*n_list) + n_names ); if ( !new_list ) return NT_STATUS_NO_MEMORY; @@ -364,33 +371,33 @@ static NTSTATUS add_names_to_list( TALLOC_CTX *ctx, /* search for duplicates for sorting and looking for matching neighbors */ - + qsort( new_list, n_new_list, sizeof(char*), QSORT_CAST namecmp ); - + for ( i=1; imethods->lookup_groupmem(d, tmp_ctx, + status = d->methods->lookup_groupmem(d, tmp_ctx, &glist[i], &num_names, - &sid_mem, &names, + &sid_mem, &names, &name_types); - if ( !NT_STATUS_IS_OK(status) ) + if ( !NT_STATUS_IS_OK(status) ) goto out; - + /* Separate users and groups into two lists */ for ( j=0; jname))) return False; @@ -508,7 +516,7 @@ static bool fill_grent_mem(struct winbindd_domain *domain, if ( !((group_name_type==SID_NAME_DOM_GRP) || ((group_name_type==SID_NAME_ALIAS) && domain->primary)) ) { - DEBUG(1, ("SID %s in domain %s isn't a domain group (%d)\n", + DEBUG(1, ("SID %s in domain %s isn't a domain group (%d)\n", sid_string_dbg(group_sid), domain->name, group_name_type)); goto done; @@ -519,15 +527,15 @@ static bool fill_grent_mem(struct winbindd_domain *domain, sid_peek_rid( group_sid, &group_rid ); if (!lp_winbind_enum_users() && group_rid == DOMAIN_GROUP_RID_USERS) { - result = fill_grent_mem_domusers( mem_ctx, domain, state, + result = fill_grent_mem_domusers( mem_ctx, domain, state, group_sid, group_name_type, num_gr_mem, gr_mem, gr_mem_len ); - goto done; + goto done; } /* Real work goes here. Create a list of group names to - expand startign with the initial one. Pass that to + expand startign with the initial one. Pass that to expand_groups() which returns a list of more group names to expand. Do this up to the max search depth. */ @@ -536,33 +544,33 @@ static bool fill_grent_mem(struct winbindd_domain *domain, DEBUG(0,("fill_grent_mem: talloc failure!\n")); goto done; } - sid_copy( &glist[0], group_sid ); - n_glist = 1; + sid_copy( &glist[0], group_sid ); + n_glist = 1; for ( i=0; irequest.data.groupname[sizeof(state->request.data.groupname)-1]='\0'; @@ -676,14 +686,14 @@ void winbindd_getgrnam(struct winbindd_cli_state *state) state->request.data.groupname)); /* Parse domain and groupname */ - + 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); /* if no domain or our local domain and no local tdb group, default to @@ -702,7 +712,7 @@ void winbindd_getgrnam(struct winbindd_cli_state *state) return; } /* should we deal with users for our domain? */ - + if ( lp_winbind_trusted_domains_only() && domain->primary) { DEBUG(7,("winbindd_getgrnam: My domain -- rejecting " "getgrnam() for %s\\%s.\n", name_domain, name_group)); @@ -713,7 +723,7 @@ void winbindd_getgrnam(struct winbindd_cli_state *state) /* Get rid and name type from name */ ws_name_replace( name_group, WB_REPLACE_CHAR ); - + winbindd_lookupname_async( state->mem_ctx, domain->name, name_group, getgrnam_recv, WINBINDD_GETGRNAM, state ); } @@ -722,7 +732,7 @@ struct getgrsid_state { struct winbindd_cli_state *state; struct winbindd_domain *domain; char *group_name; - enum lsa_SidType group_type; + enum lsa_SidType group_type; uid_t gid; DOM_SID group_sid; }; @@ -735,7 +745,7 @@ static void getgrsid_sid2gid_recv(void *private_data, bool success, gid_t gid) size_t gr_mem_len; size_t num_gr_mem; char *gr_mem; - fstring dom_name, group_name; + fstring dom_name, group_name; if (!success) { DEBUG(5,("getgrsid_sid2gid_recv: sid2gid failed!\n")); @@ -751,7 +761,7 @@ static void getgrsid_sid2gid_recv(void *private_data, bool success, gid_t gid) return; } - + /* Fill in group structure */ if ( (domain = find_domain_from_name_noinit(dom_name)) == NULL ) { @@ -762,7 +772,7 @@ static void getgrsid_sid2gid_recv(void *private_data, bool success, gid_t gid) 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)) + &num_gr_mem, &gr_mem, &gr_mem_len)) { request_error(s->state); return; @@ -777,7 +787,7 @@ static void getgrsid_sid2gid_recv(void *private_data, bool success, gid_t gid) s->state->response.length += gr_mem_len; s->state->response.extra_data.data = gr_mem; - request_ok(s->state); + request_ok(s->state); } static void getgrsid_lookupsid_recv( void *private_data, bool success, @@ -796,16 +806,16 @@ static void getgrsid_lookupsid_recv( void *private_data, bool success, local group in an internal domain */ if ( !( (name_type==SID_NAME_DOM_GRP) || - ((name_type==SID_NAME_ALIAS) && + ((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", + DEBUG(1, ("name '%s\\%s' is not a local or domain group: %d\n", dom_name, name, name_type)); request_error(s->state); return; } - if ( (s->group_name = talloc_asprintf( s->state->mem_ctx, + if ( (s->group_name = talloc_asprintf( s->state->mem_ctx, "%s%c%s", dom_name, *lp_winbind_separator(), @@ -843,7 +853,7 @@ static void winbindd_getgrsid( struct winbindd_cli_state *state, const DOM_SID g sid_copy(&s->group_sid, &group_sid); - winbindd_lookupsid_async( s->state->mem_ctx, &group_sid, + winbindd_lookupsid_async( s->state->mem_ctx, &group_sid, getgrsid_lookupsid_recv, s ); } @@ -874,7 +884,7 @@ static void getgrgid_recv(void *private_data, bool success, const char *sid) return; } - DEBUG(1, ("could not convert gid %lu to sid\n", + DEBUG(1, ("could not convert gid %lu to sid\n", (unsigned long)state->request.data.gid)); request_error(state); } @@ -882,11 +892,14 @@ static void getgrgid_recv(void *private_data, bool success, const char *sid) /* 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)); + gid_t gid = state->request.data.gid; + + DEBUG(3, ("[%5lu]: getgrgid %lu\n", + (unsigned long)state->pid, + (unsigned long)gid)); /* always use the async interface */ - winbindd_gid2sid_async(state->mem_ctx, state->request.data.gid, getgrgid_recv, state); + winbindd_gid2sid_async(state->mem_ctx, gid, getgrgid_recv, state); } /* @@ -905,45 +918,46 @@ static bool winbindd_setgrent_internal(struct winbindd_cli_state *state) if (!lp_winbind_enum_groups()) { return False; - } + } /* Free old static data if it exists */ - + if (state->getgrent_state != NULL) { free_getent_state(state->getgrent_state); state->getgrent_state = NULL; } - + /* Create sam pipes for each domain we know about */ - + for (domain = domain_list(); domain != NULL; domain = domain->next) { struct getent_state *domain_state; - + /* Create a state record for this domain */ - /* don't add our domaina if we are a PDC or if we + /* don't add our domaina if we are a PDC or if we are a member of a Samba domain */ - + if ( lp_winbind_trusted_domains_only() && domain->primary ) { continue; } - - - if ((domain_state = SMB_MALLOC_P(struct getent_state)) == NULL) { - DEBUG(1, ("winbindd_setgrent: malloc failed for domain_state!\n")); + + domain_state = SMB_MALLOC_P(struct getent_state); + if (!domain_state) { + DEBUG(1, ("winbindd_setgrent: " + "malloc failed for domain_state!\n")); return False; } - + ZERO_STRUCTP(domain_state); - + fstrcpy(domain_state->domain_name, domain->name); /* Add to list of open domains */ - + DLIST_ADD(state->getgrent_state, domain_state); } - + state->getgrent_initialized = True; return True; } @@ -970,7 +984,7 @@ void winbindd_endgrent(struct winbindd_cli_state *state) } /* Get the list of domain groups and domain aliases for a domain. We fill in - the sam_entries and num_sam_entries fields with domain group information. + the sam_entries and num_sam_entries fields with domain group information. Return True if some groups were returned, False otherwise. */ bool get_sam_group_entries(struct getent_state *ent) @@ -982,16 +996,17 @@ bool get_sam_group_entries(struct getent_state *ent) bool result = False; struct acct_info *sam_grp_entries = NULL; struct winbindd_domain *domain; - + if (ent->got_sam_entries) return False; if (!(mem_ctx = talloc_init("get_sam_group_entries(%s)", ent->domain_name))) { - DEBUG(1, ("get_sam_group_entries: could not create talloc context!\n")); + DEBUG(1, ("get_sam_group_entries: " + "could not create talloc context!\n")); return False; } - + /* Free any existing group info */ SAFE_FREE(ent->sam_entries); @@ -1003,16 +1018,20 @@ bool get_sam_group_entries(struct getent_state *ent) num_entries = 0; if (!(domain = find_domain_from_name(ent->domain_name))) { - DEBUG(3, ("no such domain %s in get_sam_group_entries\n", ent->domain_name)); + DEBUG(3, ("no such domain %s in get_sam_group_entries\n", + ent->domain_name)); goto done; } /* always get the domain global groups */ - status = domain->methods->enum_dom_groups(domain, mem_ctx, &num_entries, &sam_grp_entries); - + status = domain->methods->enum_dom_groups(domain, mem_ctx, &num_entries, + &sam_grp_entries); + if (!NT_STATUS_IS_OK(status)) { - DEBUG(3, ("get_sam_group_entries: could not enumerate domain groups! Error: %s\n", nt_errstr(status))); + DEBUG(3, ("get_sam_group_entries: " + "could not enumerate domain groups! Error: %s\n", + nt_errstr(status))); result = False; goto done; } @@ -1020,29 +1039,36 @@ bool get_sam_group_entries(struct getent_state *ent) /* Copy entries into return buffer */ if (num_entries) { - if ( !(name_list = SMB_MALLOC_ARRAY(struct acct_info, num_entries)) ) { - DEBUG(0,("get_sam_group_entries: Failed to malloc memory for %d domain groups!\n", - num_entries)); + name_list = SMB_MALLOC_ARRAY(struct acct_info, num_entries); + if (!name_list) { + DEBUG(0,("get_sam_group_entries: Failed to malloc " + "memory for %d domain groups!\n", + num_entries)); result = False; goto done; } - memcpy( name_list, sam_grp_entries, num_entries * sizeof(struct acct_info) ); + memcpy(name_list, sam_grp_entries, + num_entries * sizeof(struct acct_info)); } - + ent->num_sam_entries = num_entries; - - /* get the domain local groups if we are a member of a native win2k domain - and are not using LDAP to get the groups */ - - if ( ( lp_security() != SEC_ADS && domain->native_mode + + /* get the domain local groups if we are a member of a native win2k + * domain and are not using LDAP to get the groups */ + + if ( ( lp_security() != SEC_ADS && domain->native_mode && domain->primary) || domain->internal ) { - DEBUG(4,("get_sam_group_entries: %s domain; enumerating local groups as well\n", - domain->native_mode ? "Native Mode 2k":"BUILTIN or local")); - - status = domain->methods->enum_local_groups(domain, mem_ctx, &num_entries, &sam_grp_entries); - - if ( !NT_STATUS_IS_OK(status) ) { + DEBUG(4,("get_sam_group_entries: %s domain; " + "enumerating local groups as well\n", + domain->native_mode ? "Native Mode 2k": + "BUILTIN or local")); + + status = domain->methods->enum_local_groups(domain, mem_ctx, + &num_entries, + &sam_grp_entries); + + if ( !NT_STATUS_IS_OK(status) ) { DEBUG(3,("get_sam_group_entries: " "Failed to enumerate " "domain local groups with error %s!\n", @@ -1050,27 +1076,35 @@ bool get_sam_group_entries(struct getent_state *ent) num_entries = 0; } else - DEBUG(4,("get_sam_group_entries: Returned %d local groups\n", num_entries)); - + DEBUG(4,("get_sam_group_entries: " + "Returned %d local groups\n", + num_entries)); + /* Copy entries into return buffer */ if ( num_entries ) { - if ( !(name_list = SMB_REALLOC_ARRAY( name_list, struct acct_info, ent->num_sam_entries+num_entries)) ) - { - DEBUG(0,("get_sam_group_entries: Failed to realloc more memory for %d local groups!\n", - num_entries)); + name_list = SMB_REALLOC_ARRAY(name_list, + struct acct_info, + ent->num_sam_entries+ + num_entries); + if (!name_list) { + DEBUG(0,("get_sam_group_entries: " + "Failed to realloc more memory " + "for %d local groups!\n", + num_entries)); result = False; goto done; } - - memcpy( &name_list[ent->num_sam_entries], sam_grp_entries, - num_entries * sizeof(struct acct_info) ); + + memcpy(&name_list[ent->num_sam_entries], + sam_grp_entries, + num_entries * sizeof(struct acct_info)); } - + ent->num_sam_entries += num_entries; } - - + + /* Fill in remaining fields */ ent->sam_entries = name_list; @@ -1111,18 +1145,19 @@ void winbindd_getgrent(struct winbindd_cli_state *state) return; } - if ((state->response.extra_data.data = SMB_MALLOC_ARRAY(struct winbindd_gr, num_groups)) == NULL) { + group_list = SMB_MALLOC_ARRAY(struct winbindd_gr, num_groups); + if (!group_list) { request_error(state); return; } + /* will be freed by process_request() */ + state->response.extra_data.data = group_list; memset(state->response.extra_data.data, '\0', num_groups * sizeof(struct winbindd_gr) ); state->response.data.num_entries = 0; - group_list = (struct winbindd_gr *)state->response.extra_data.data; - if (!state->getgrent_initialized) winbindd_setgrent_internal(state); @@ -1142,7 +1177,7 @@ void winbindd_getgrent(struct winbindd_cli_state *state) char *gr_mem; DOM_SID group_sid; struct winbindd_domain *domain; - + /* Do we need to fetch another chunk of groups? */ tryagain: @@ -1155,7 +1190,8 @@ void winbindd_getgrent(struct winbindd_cli_state *state) while(ent && !get_sam_group_entries(ent)) { struct getent_state *next_ent; - DEBUG(10, ("freeing state info for domain %s\n", ent->domain_name)); + DEBUG(10, ("freeing state info for domain %s\n", + ent->domain_name)); /* Free state information for this domain */ @@ -1163,28 +1199,28 @@ void winbindd_getgrent(struct winbindd_cli_state *state) next_ent = ent->next; DLIST_REMOVE(state->getgrent_state, ent); - + SAFE_FREE(ent); ent = next_ent; } /* No more domains */ - if (!ent) + if (!ent) break; } - + name_list = (struct acct_info *)ent->sam_entries; - - if (!(domain = - find_domain_from_name(ent->domain_name))) { - DEBUG(3, ("No such domain %s in winbindd_getgrent\n", ent->domain_name)); + + if (!(domain = find_domain_from_name(ent->domain_name))) { + DEBUG(3, ("No such domain %s in winbindd_getgrent\n", + ent->domain_name)); result = False; goto done; } /* Lookup group info */ - + sid_copy(&group_sid, &domain->sid); sid_append_rid(&group_sid, name_list[ent->sam_entry_index].rid); @@ -1196,9 +1232,8 @@ void winbindd_getgrent(struct winbindd_cli_state *state) sid_string_dbg(&group_sid))); if (!pdb_sid_to_id(&group_sid, &id, &type)) { - DEBUG(1, ("could not look up gid for group " - "%s\n", - name_list[ent->sam_entry_index].acct_name)); + DEBUG(1,("could not look up gid for group %s\n", + name_list[ent->sam_entry_index].acct_name)); ent->sam_entry_index++; goto tryagain; } @@ -1215,15 +1250,16 @@ void winbindd_getgrent(struct winbindd_cli_state *state) group_gid = id.gid; } - DEBUG(10, ("got gid %lu for group %lu\n", (unsigned long)group_gid, + DEBUG(10, ("got gid %lu for group %lu\n", + (unsigned long)group_gid, (unsigned long)name_list[ent->sam_entry_index].rid)); - + /* Fill in group entry */ - fill_domain_username(domain_group_name, ent->domain_name, + fill_domain_username(domain_group_name, ent->domain_name, name_list[ent->sam_entry_index].acct_name, True); - result = fill_grent(&group_list[group_list_ndx], + result = fill_grent(&group_list[group_list_ndx], ent->domain_name, name_list[ent->sam_entry_index].acct_name, group_gid); @@ -1236,8 +1272,8 @@ void winbindd_getgrent(struct winbindd_cli_state *state) group_list[group_list_ndx].num_gr_mem = 0; gr_mem = NULL; gr_mem_len = 0; - - /* Get group membership */ + + /* Get group membership */ if (state->request.cmd == WINBINDD_GETGRLST) { result = True; } else { @@ -1260,7 +1296,8 @@ void winbindd_getgrent(struct winbindd_cli_state *state) gr_mem_list = (char *)SMB_REALLOC( gr_mem_list, gr_mem_list_len + gr_mem_len); - if (!gr_mem_list && (group_list[group_list_ndx].num_gr_mem != 0)) { + 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; @@ -1274,16 +1311,16 @@ void winbindd_getgrent(struct winbindd_cli_state *state) SAFE_FREE(gr_mem); - group_list[group_list_ndx].gr_mem_ofs = + group_list[group_list_ndx].gr_mem_ofs = gr_mem_list_len; gr_mem_list_len += gr_mem_len; } ent->sam_entry_index++; - + /* Add group to return list */ - + if (result) { DEBUG(10, ("adding group num_entries = %d\n", @@ -1291,12 +1328,12 @@ void winbindd_getgrent(struct winbindd_cli_state *state) group_list_ndx++; state->response.data.num_entries++; - + state->response.length += sizeof(struct winbindd_gr); - + } else { - DEBUG(0, ("could not lookup domain group %s\n", + DEBUG(0, ("could not lookup domain group %s\n", domain_group_name)); } } @@ -1319,7 +1356,7 @@ void winbindd_getgrent(struct winbindd_cli_state *state) } memcpy(&((char *)state->response.extra_data.data) - [group_list_ndx * sizeof(struct winbindd_gr)], + [group_list_ndx * sizeof(struct winbindd_gr)], gr_mem_list, gr_mem_list_len); state->response.length += gr_mem_list_len; @@ -1408,25 +1445,27 @@ void winbindd_getgroups(struct winbindd_cli_state *state) return; } - s->domname = talloc_strdup( state->mem_ctx, get_global_sam_name() ); - s->username = talloc_strdup( state->mem_ctx, state->request.data.username ); + s->domname = talloc_strdup(state->mem_ctx, + get_global_sam_name()); + s->username = talloc_strdup(state->mem_ctx, + state->request.data.username); } - - /* Get info for the domain (either by short domain name or + + /* Get info for the domain (either by short domain name or DNS name in the case of a UPN) */ s->domain = find_domain_from_name_noinit(s->domname); if (!s->domain) { char *p = strchr(s->username, '@'); - + if (p) { - s->domain = find_domain_from_name_noinit(p+1); + s->domain = find_domain_from_name_noinit(p+1); } - + } if (s->domain == NULL) { - DEBUG(7, ("could not find domain entry for domain %s\n", + DEBUG(7, ("could not find domain entry for domain %s\n", s->domname)); request_error(state); return; @@ -1438,12 +1477,14 @@ void winbindd_getgroups(struct winbindd_cli_state *state) s->username)); request_error(state); return; - } + } /* 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, WINBINDD_GETGROUPS, s); + winbindd_lookupname_async(state->mem_ctx, + s->domname, s->username, + getgroups_usersid_recv, + WINBINDD_GETGROUPS, s); } static void getgroups_usersid_recv(void *private_data, bool success, @@ -1518,7 +1559,9 @@ static void getgroups_sid2gid_recv(void *private_data, bool success, gid_t gid) s->state->response.data.num_entries = s->num_token_gids; if (s->num_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.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); @@ -1529,7 +1572,7 @@ static void getgroups_sid2gid_recv(void *private_data, bool success, gid_t gid) rather than a NAME->SID->SIDS->GIDS mapping, which means we avoid idmap. This call is designed to be used with applications that need to do ACL evaluation themselves. Note that the cached info3 data is - not used + not used this function assumes that the SID that comes in is a user SID. If you pass in another type of SID then you may get unpredictable @@ -1622,9 +1665,9 @@ void winbindd_getuserdomgroups(struct winbindd_cli_state *state) return; } - /* Get info for the domain */ + /* Get info for the domain */ if ((domain = find_domain_from_sid_noinit(&user_sid)) == NULL) { - DEBUG(0,("could not find domain entry for sid %s\n", + DEBUG(0,("could not find domain entry for sid %s\n", sid_string_dbg(&user_sid))); request_error(state); return; @@ -1665,7 +1708,9 @@ enum winbindd_result winbindd_dual_getuserdomgroups(struct winbindd_domain *doma return WINBINDD_OK; } - if (!print_sidlist(state->mem_ctx, groups, num_groups, &sidstring, &len)) { + if (!print_sidlist(state->mem_ctx, + groups, num_groups, + &sidstring, &len)) { DEBUG(0, ("talloc failed\n")); return WINBINDD_ERROR; } -- cgit