{
fstring full_group_name;
- fill_domain_username( full_group_name, dom_name, gr_name, False);
+ fill_domain_username( full_group_name, dom_name, gr_name, True );
gr->gr_gid = unix_gid;
/* 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)))
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,
+ IDMAP_FLAG_QUERY_ONLY|IDMAP_FLAG_CACHE_ONLY);
+ 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 ));
+ }
+
+ *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;
}
/* Add members to list */
- buf = NULL;
- buf_len = buf_ndx = 0;
-
again:
for (i = 0; i < num_names; i++) {
/* Append domain name */
- fill_domain_username(name, domain->name, the_name, False);
+ fill_domain_username(name, domain->name, the_name, True);
len = strlen(name);
(*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] = ',';
/* 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;
*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:
DOM_SID group_sid, tmp_sid;
uint32 grp_rid;
struct winbindd_domain *domain;
- enum SID_NAME_USE name_type;
+ enum lsa_SidType 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;
if (!fill_grent(&state->response.data.gr, name_domain,
name_group, gid) ||
- !fill_grent_mem(domain, &group_sid, name_type,
- &state->response.data.gr.num_gr_mem,
+ !fill_grent_mem(domain, state, &group_sid, name_type,
+ &num_gr_mem,
&gr_mem, &gr_mem_len)) {
request_error(state);
return;
}
+ 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;
state->response.length += gr_mem_len;
- state->response.extra_data = gr_mem;
+ state->response.extra_data.data = gr_mem;
request_ok(state);
}
-/* Return a group structure from a gid number */
-
-void winbindd_getgrgid(struct winbindd_cli_state *state)
+static void getgrgid_got_sid(struct winbindd_cli_state *state, DOM_SID group_sid)
{
struct winbindd_domain *domain;
- DOM_SID group_sid;
- enum SID_NAME_USE name_type;
+ enum lsa_SidType 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 */
-
- if ((state->request.data.gid < server_state.gid_low) ||
- (state->request.data.gid > server_state.gid_high)) {
- request_error(state);
- return;
- }
-
- /* Get sid from gid */
-
- 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;
- }
-
- /* 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 */
- goto got_sid;
- }
-
- 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 */
if (!winbindd_lookup_name_by_sid(state->mem_ctx, &group_sid, dom_name,
if (!fill_grent(&state->response.data.gr, dom_name, group_name,
state->request.data.gid) ||
- !fill_grent_mem(domain, &group_sid, name_type,
- &state->response.data.gr.num_gr_mem,
+ !fill_grent_mem(domain, state, &group_sid, name_type,
+ &num_gr_mem,
&gr_mem, &gr_mem_len)) {
request_error(state);
return;
}
+ 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;
state->response.length += gr_mem_len;
- state->response.extra_data = gr_mem;
+ state->response.extra_data.data = gr_mem;
+
request_ok(state);
}
+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);
+ getgrgid_got_sid(state, group_sid);
+ return;
+ }
+
+ /* 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));
+ getgrgid_got_sid(state, group_sid);
+ return;
+ }
+
+ DEBUG(1, ("could not convert gid %lu to sid\n",
+ (unsigned long)state->request.data.gid));
+ request_error(state);
+}
+
+/* Return a group structure from a gid number */
+void winbindd_getgrgid(struct winbindd_cli_state *state)
+{
+ DOM_SID group_sid;
+ 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 */
+
+ if ((state->request.data.gid < server_state.gid_low) ||
+ (state->request.data.gid > server_state.gid_high)) {
+ request_error(state);
+ return;
+ }
+
+ /* Get sid from gid */
+
+ status = idmap_gid_to_sid(&group_sid, state->request.data.gid, IDMAP_FLAG_NONE);
+ if (NT_STATUS_IS_OK(status)) {
+ /* This is a remote one */
+ getgrgid_got_sid(state, group_sid);
+ return;
+ }
+
+ DEBUG(10,("winbindd_getgrgid: gid %lu not found in cache, try with the async interface\n",
+ (unsigned long)state->request.data.gid));
+
+ winbindd_gid2sid_async(state->mem_ctx, state->request.data.gid, getgrgid_recv, state);
+}
+
/*
* set/get/endgrent functions
*/
num_groups = MIN(MAX_GETGRENT_GROUPS, state->request.data.num_entries);
- if ((state->response.extra_data = SMB_MALLOC_ARRAY(struct winbindd_gr, num_groups)) == NULL) {
+ if ((state->response.extra_data.data = SMB_MALLOC_ARRAY(struct winbindd_gr, num_groups)) == NULL) {
request_error(state);
return;
}
- memset(state->response.extra_data, '\0',
+ 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;
+ group_list = (struct winbindd_gr *)state->response.extra_data.data;
if (!state->getgrent_initialized)
winbindd_setgrent_internal(state);
break;
}
- name_list = ent->sam_entries;
+ name_list = (struct acct_info *)ent->sam_entries;
if (!(domain =
find_domain_from_name(ent->domain_name))) {
if (!NT_STATUS_IS_OK(idmap_sid_to_gid(&group_sid,
&group_gid, 0))) {
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)));
/* 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,
/* Fill in group membership entry */
if (result) {
+ size_t num_gr_mem = 0;
DOM_SID member_sid;
group_list[group_list_ndx].num_gr_mem = 0;
gr_mem = NULL;
sid_append_rid(&member_sid, name_list[ent->sam_entry_index].rid);
result = fill_grent_mem(
domain,
+ NULL,
&member_sid,
SID_NAME_DOM_GRP,
- &group_list[group_list_ndx].num_gr_mem,
+ &num_gr_mem,
&gr_mem, &gr_mem_len);
+
+ group_list[group_list_ndx].num_gr_mem = (uint32)num_gr_mem;
}
}
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);
if (group_list_ndx == 0)
goto done;
- state->response.extra_data = SMB_REALLOC(
- state->response.extra_data,
+ state->response.extra_data.data = SMB_REALLOC(
+ state->response.extra_data.data,
group_list_ndx * sizeof(struct winbindd_gr) + gr_mem_list_len);
- if (!state->response.extra_data) {
+ if (!state->response.extra_data.data) {
DEBUG(0, ("out of memory\n"));
group_list_ndx = 0;
SAFE_FREE(gr_mem_list);
return;
}
- memcpy(&((char *)state->response.extra_data)
+ memcpy(&((char *)state->response.extra_data.data)
[group_list_ndx * sizeof(struct winbindd_gr)],
gr_mem_list, gr_mem_list_len);
/* 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"));
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));
/* Assign extra_data fields in response structure */
if (extra_data) {
extra_data[extra_data_len - 1] = '\0';
- state->response.extra_data = extra_data;
+ state->response.extra_data.data = extra_data;
state->response.length += extra_data_len;
}
};
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);
DEBUG(3, ("[%5lu]: getgroups %s\n", (unsigned long)state->pid,
state->request.data.username));
+ /* when using "winbind use default domain" we need to avoid that
+ * initgroups() requests from NSS hit our DC too badly for accounts
+ * that will never be on the remote DC */
+
+ if (lp_winbind_use_default_domain()) {
+
+ const char **list = lp_winbind_initgroups_blacklist();
+ int i;
+
+ if (!list || !list[0]) {
+ goto parse;
+ }
+
+ for (i=0; list[i] != NULL; i++) {
+
+ if (strequal(state->request.data.username, list[i])) {
+ DEBUG(3,("ignoring blacklisted user [%s] for getgroups\n",
+ state->request.data.username));
+ request_ok(state);
+ return;
+ }
+ }
+ }
+ parse:
/* Parse domain and username */
s = TALLOC_P(state->mem_ctx, struct getgroups_state);
&s->domname, &s->username)) {
DEBUG(5, ("Could not parse domain user: %s\n",
state->request.data.username));
- request_error(state);
- return;
+
+ /* error out if we do not have nested group support */
+
+ if ( !lp_winbind_nested_groups() ) {
+ request_error(state);
+ return;
+ }
+
+ 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 */
}
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))) {
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 */
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,
}
s->state->response.data.num_entries = s->num_token_gids;
- s->state->response.extra_data = s->token_gids;
+ s->state->response.extra_data.data = s->token_gids;
s->state->response.length += s->num_token_gids * sizeof(gid_t);
request_ok(s->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;
}
/* build the reply */
- ret = SMB_MALLOC(ret_size);
+ ret = (char *)SMB_MALLOC(ret_size);
if (!ret) {
DEBUG(0, ("malloc failed\n"));
request_error(state);
/* Send data back to client */
state->response.data.num_entries = num_sids;
- state->response.extra_data = ret;
+ state->response.extra_data.data = ret;
state->response.length += ret_size;
request_ok(state);
}
if (num_groups == 0) {
state->response.data.num_entries = 0;
- state->response.extra_data = NULL;
+ state->response.extra_data.data = NULL;
return WINBINDD_OK;
}
return WINBINDD_ERROR;
}
- state->response.extra_data = sidstring;
+ state->response.extra_data.data = sidstring;
state->response.length += len+1;
state->response.data.num_entries = num_groups;
git.samba.org / tprouty / samba.git / blobdiff