#include "includes.h"
#include "winbindd.h"
extern BOOL opt_nocache;
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
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;
}
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;
}
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; i<num_names; i++) {
DEBUG(10, ("Adding group member SID %s\n",
sid_string_static(&sid_mem[i])));
if (types[i] != SID_NAME_USER) {
DEBUG(1, ("Hmmm. Member %s of group %s is no user. "
"Ignoring.\n", names[i], name));
continue;
}
add_member(domain->name, 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; i<num_members; i++) {
add_expanded_sid(&members[i], gr_mem, num_gr_mem);
}
TALLOC_FREE(members);
if (*gr_mem != NULL) {
size_t len;
len = strlen(*gr_mem);
(*gr_mem)[len-1] = '\0';
*gr_mem_len = len;
}
return True;
}
static BOOL fill_grent(struct winbindd_gr *gr, const char *dom_name,
const char *gr_name, gid_t unix_gid)
{
fstring full_group_name;
fill_domain_username( full_group_name, dom_name, gr_name, True );
gr->gr_gid = unix_gid;
safe_strcpy(gr->gr_name, full_group_name, sizeof(gr->gr_name) - 1);
safe_strcpy(gr->gr_passwd, "x", sizeof(gr->gr_passwd) - 1);
return True;
}
static BOOL fill_grent_mem(struct winbindd_domain *domain,
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 *gr_mem_len)
{
DOM_SID *sid_mem = NULL;
uint32 num_names = 0;
uint32 *name_types = NULL;
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)))
return False;
DEBUG(10, ("group SID %s\n", sid_to_string(sid_string, group_sid)));
*num_gr_mem = 0;
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)) )
{
DEBUG(1, ("SID %s in domain %s isn't a domain group (%d)\n",
sid_to_string(sid_string, group_sid), domain->name,
group_name_type));
goto done;
}
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) {
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) ));
}
}
}
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])) {
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 ));
*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;
}
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 sid %s in domain %s (error: %s)\n",
sid_to_string(sid_string, group_sid), domain->name, nt_errstr(status)));
goto done;
}
DEBUG(10, ("looked up %d names\n", num_names));
if (DEBUGLEVEL >= 10) {
for (i = 0; i < num_names; i++)
DEBUG(10, ("\t%20s %s %d\n", names[i],
sid_string_static(&sid_mem[i]),
name_types[i]));
}
again:
for (i = 0; i < num_names; i++) {
char *the_name;
fstring name;
int len;
the_name = names[i];
DEBUG(10, ("processing name %s\n", the_name));
if (name_types[i] != SID_NAME_USER && name_types[i] != SID_NAME_COMPUTER) {
DEBUG(3, ("name %s isn't a domain user (%s)\n", the_name, sid_type_lookup(name_types[i])));
continue;
}
fill_domain_username(name, domain->name, the_name, True);
len = strlen(name);
if (!buf) {
buf_len += len + 1;
(*num_gr_mem)++;
DEBUG(10, ("buf_len + %d = %d\n", len + 1, buf_len));
} else {
DEBUG(10, ("appending %s at ndx %d\n", name, buf_ndx));
safe_strcpy(&buf[buf_ndx], name, len);
buf_ndx += len;
buf[buf_ndx] = ',';
buf_ndx++;
}
}
if (!buf && buf_len != 0) {
if (!(buf = (char *)SMB_MALLOC(buf_len))) {
DEBUG(1, ("out of memory\n"));
result = False;
goto done;
}
memset(buf, 0, buf_len);
goto again;
}
if (buf && buf_ndx > 0) {
buf[buf_ndx - 1] = '\0';
}
*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;
done:
talloc_destroy(mem_ctx);
DEBUG(10, ("fill_grent_mem returning %d\n", result));
return result;
}
void winbindd_getgrnam(struct winbindd_cli_state *state)
{
DOM_SID group_sid, tmp_sid;
uint32 grp_rid;
struct winbindd_domain *domain;
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;
state->request.data.groupname[sizeof(state->request.data.groupname)-1]='\0';
DEBUG(3, ("[%5lu]: getgrnam %s\n", (unsigned long)state->pid,
state->request.data.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 ( !*name_domain || strequal(name_domain, get_global_sam_name()) ) {
fstrcpy(name_domain, get_global_sam_name());
}
if ((domain = find_domain_from_name(name_domain)) == NULL) {
DEBUG(3, ("could not get domain sid for domain %s\n",
name_domain));
request_error(state);
return;
}
if ( lp_winbind_trusted_domains_only() && domain->primary) {
DEBUG(7,("winbindd_getgrnam: My domain -- rejecting "
"getgrnam() for %s\\%s.\n", name_domain, name_group));
request_error(state);
return;
}
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;
}
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)) )
{
DEBUG(1, ("name '%s' is not a local, domain or builtin "
"group: %d\n", name_group, name_type));
request_error(state);
return;
}
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);
return;
}
status = idmap_sid_to_gid(&group_sid, &gid);
if (NT_STATUS_IS_OK(status)) {
goto got_gid;
}
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;
}
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, 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;
state->response.data.gr.gr_mem_ofs = 0;
state->response.length += gr_mem_len;
state->response.extra_data.data = gr_mem;
request_ok(state);
}
static void getgrgid_got_sid(struct winbindd_cli_state *state, DOM_SID group_sid)
{
struct winbindd_domain *domain;
enum lsa_SidType name_type;
char *dom_name;
char *group_name;
size_t gr_mem_len;
size_t num_gr_mem;
char *gr_mem;
if (!winbindd_lookup_name_by_sid(state->mem_ctx, &group_sid, &dom_name,
&group_name, &name_type)) {
DEBUG(1, ("could not lookup sid\n"));
request_error(state);
TALLOC_FREE(group_name);
TALLOC_FREE(dom_name);
return;
}
domain = find_domain_from_sid_noinit(&group_sid);
if (!domain) {
DEBUG(1,("Can't find domain from sid\n"));
request_error(state);
TALLOC_FREE(group_name);
TALLOC_FREE(dom_name);
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);
TALLOC_FREE(group_name);
TALLOC_FREE(dom_name);
return;
}
if (!fill_grent(&state->response.data.gr, dom_name, group_name,
state->request.data.gid) ||
!fill_grent_mem(domain, state, &group_sid, name_type,
&num_gr_mem,
&gr_mem, &gr_mem_len)) {
request_error(state);
TALLOC_FREE(group_name);
TALLOC_FREE(dom_name);
return;
}
state->response.data.gr.num_gr_mem = (uint32)num_gr_mem;
state->response.data.gr.gr_mem_ofs = 0;
state->response.length += gr_mem_len;
state->response.extra_data.data = gr_mem;
TALLOC_FREE(group_name);
TALLOC_FREE(dom_name);
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;
}
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)) {
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);
}
void winbindd_getgrgid(struct winbindd_cli_state *state)
{
DEBUG(3, ("[%5lu]: getgrgid %lu\n", (unsigned long)state->pid,
(unsigned long)state->request.data.gid));
winbindd_gid2sid_async(state->mem_ctx, state->request.data.gid, getgrgid_recv, state);
}
static BOOL winbindd_setgrent_internal(struct winbindd_cli_state *state)
{
struct winbindd_domain *domain;
DEBUG(3, ("[%5lu]: setgrent\n", (unsigned long)state->pid));
if (!lp_winbind_enum_groups()) {
return False;
}
if (state->getgrent_state != NULL) {
free_getent_state(state->getgrent_state);
state->getgrent_state = NULL;
}
for (domain = domain_list(); domain != NULL; domain = domain->next) {
struct getent_state *domain_state;
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"));
return False;
}
ZERO_STRUCTP(domain_state);
fstrcpy(domain_state->domain_name, domain->name);
DLIST_ADD(state->getgrent_state, domain_state);
}
state->getgrent_initialized = True;
return True;
}
void winbindd_setgrent(struct winbindd_cli_state *state)
{
if (winbindd_setgrent_internal(state)) {
request_ok(state);
} else {
request_error(state);
}
}
void winbindd_endgrent(struct winbindd_cli_state *state)
{
DEBUG(3, ("[%5lu]: endgrent\n", (unsigned long)state->pid));
free_getent_state(state->getgrent_state);
state->getgrent_initialized = False;
state->getgrent_state = NULL;
request_ok(state);
}
static BOOL get_sam_group_entries(struct getent_state *ent)
{
NTSTATUS status;
uint32 num_entries;
struct acct_info *name_list = NULL;
TALLOC_CTX *mem_ctx;
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"));
return False;
}
SAFE_FREE(ent->sam_entries);
ent->num_sam_entries = 0;
ent->got_sam_entries = True;
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));
goto done;
}
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)));
result = False;
goto done;
}
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));
result = False;
goto done;
}
memcpy( name_list, sam_grp_entries, num_entries * sizeof(struct acct_info) );
}
ent->num_sam_entries = num_entries;
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(3,("get_sam_group_entries: Failed to enumerate domain local groups!\n"));
num_entries = 0;
}
else
DEBUG(4,("get_sam_group_entries: Returned %d local groups\n", num_entries));
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));
result = False;
goto done;
}
memcpy( &name_list[ent->num_sam_entries], sam_grp_entries,
num_entries * sizeof(struct acct_info) );
}
ent->num_sam_entries += num_entries;
}
ent->sam_entries = name_list;
ent->sam_entry_index = 0;
result = (ent->num_sam_entries > 0);
done:
talloc_destroy(mem_ctx);
return result;
}
#define MAX_GETGRENT_GROUPS 500
void winbindd_getgrent(struct winbindd_cli_state *state)
{
struct getent_state *ent;
struct winbindd_gr *group_list = NULL;
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));
if (!lp_winbind_enum_groups()) {
request_error(state);
return;
}
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;
}
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);
if (!(ent = state->getgrent_state)) {
request_error(state);
return;
}
for (group_list_ndx = 0; group_list_ndx < num_groups; ) {
struct acct_info *name_list = NULL;
fstring domain_group_name;
uint32 result;
gid_t group_gid;
size_t gr_mem_len;
char *gr_mem;
DOM_SID group_sid;
struct winbindd_domain *domain;
tryagain:
DEBUG(10, ("entry_index = %d, num_entries = %d\n",
ent->sam_entry_index, ent->num_sam_entries));
if (ent->num_sam_entries == ent->sam_entry_index) {
while(ent && !get_sam_group_entries(ent)) {
struct getent_state *next_ent;
DEBUG(10, ("freeing state info for domain %s\n", ent->domain_name));
SAFE_FREE(ent->sam_entries);
next_ent = ent->next;
DLIST_REMOVE(state->getgrent_state, ent);
SAFE_FREE(ent);
ent = next_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));
result = False;
goto done;
}
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))) {
union unid_t id;
enum lsa_SidType type;
DEBUG(10, ("SID %s not in idmap\n",
sid_string_static(&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));
ent->sam_entry_index++;
goto tryagain;
}
if ((type != SID_NAME_DOM_GRP) &&
(type != SID_NAME_ALIAS) &&
(type != SID_NAME_WKN_GRP)) {
DEBUG(1, ("Group %s is a %s, not a group\n",
sid_type_lookup(type),
name_list[ent->sam_entry_index].acct_name));
ent->sam_entry_index++;
goto tryagain;
}
group_gid = id.gid;
}
DEBUG(10, ("got gid %lu for group %lu\n", (unsigned long)group_gid,
(unsigned long)name_list[ent->sam_entry_index].rid));
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],
ent->domain_name,
name_list[ent->sam_entry_index].acct_name,
group_gid);
if (result) {
size_t num_gr_mem = 0;
DOM_SID member_sid;
group_list[group_list_ndx].num_gr_mem = 0;
gr_mem = NULL;
gr_mem_len = 0;
if (state->request.cmd == WINBINDD_GETGRLST) {
result = True;
} else {
sid_copy(&member_sid, &domain->sid);
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,
&gr_mem, &gr_mem_len);
group_list[group_list_ndx].num_gr_mem = (uint32)num_gr_mem;
}
}
if (result) {
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)) {
DEBUG(0, ("out of memory\n"));
gr_mem_list_len = 0;
break;
}
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);
SAFE_FREE(gr_mem);
group_list[group_list_ndx].gr_mem_ofs =
gr_mem_list_len;
gr_mem_list_len += gr_mem_len;
}
ent->sam_entry_index++;
if (result) {
DEBUG(10, ("adding group num_entries = %d\n",
state->response.data.num_entries));
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",
domain_group_name));
}
}
if (group_list_ndx == 0)
goto done;
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.data) {
DEBUG(0, ("out of memory\n"));
group_list_ndx = 0;
SAFE_FREE(gr_mem_list);
request_error(state);
return;
}
memcpy(&((char *)state->response.extra_data.data)
[group_list_ndx * sizeof(struct winbindd_gr)],
gr_mem_list, gr_mem_list_len);
state->response.length += gr_mem_list_len;
DEBUG(10, ("returning %d groups, length = %d\n",
group_list_ndx, gr_mem_list_len));
done:
SAFE_FREE(gr_mem_list);
if (group_list_ndx > 0)
request_ok(state);
else
request_error(state);
}
void winbindd_list_groups(struct winbindd_cli_state *state)
{
uint32 total_entries = 0;
struct winbindd_domain *domain;
const char *which_domain;
char *extra_data = NULL;
unsigned int extra_data_len = 0, i;
DEBUG(3, ("[%5lu]: list groups\n", (unsigned long)state->pid));
state->request.domain_name[sizeof(state->request.domain_name)-1]='\0';
which_domain = state->request.domain_name;
for (domain = domain_list(); domain; domain = domain->next) {
struct getent_state groups;
if ( *which_domain && !strequal(which_domain, domain->name) )
continue;
ZERO_STRUCT(groups);
fstrcpy(groups.domain_name, domain->name);
get_sam_group_entries(&groups);
if (groups.num_sam_entries == 0) {
continue;
}
total_entries += groups.num_sam_entries;
extra_data = (char *)SMB_REALLOC(
extra_data, sizeof(fstring) * total_entries);
if (!extra_data) {
DEBUG(0,("failed to enlarge buffer!\n"));
request_error(state);
return;
}
for (i = 0; i < groups.num_sam_entries; i++) {
char *group_name = ((struct acct_info *)
groups.sam_entries)[i].acct_name;
fstring name;
fill_domain_username(name, domain->name, group_name, True);
memcpy(&extra_data[extra_data_len], name,
strlen(name));
extra_data_len += strlen(name);
extra_data[extra_data_len++] = ',';
}
SAFE_FREE(groups.sam_entries);
}
if (extra_data) {
extra_data[extra_data_len - 1] = '\0';
state->response.extra_data.data = extra_data;
state->response.length += extra_data_len;
}
request_ok(state);
}
struct getgroups_state {
struct winbindd_cli_state *state;
struct winbindd_domain *domain;
char *domname;
char *username;
DOM_SID user_sid;
const DOM_SID *token_sids;
size_t i, num_token_sids;
gid_t *token_gids;
size_t num_token_gids;
};
static void getgroups_usersid_recv(void *private_data, BOOL success,
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);
void winbindd_getgroups(struct winbindd_cli_state *state)
{
struct getgroups_state *s;
state->request.data.username
[sizeof(state->request.data.username)-1]='\0';
DEBUG(3, ("[%5lu]: getgroups %s\n", (unsigned long)state->pid,
state->request.data.username));
s = TALLOC_P(state->mem_ctx, struct getgroups_state);
if (s == NULL) {
DEBUG(0, ("talloc failed\n"));
request_error(state);
return;
}
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)) {
DEBUG(5, ("Could not parse domain user: %s\n",
state->request.data.username));
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 );
}
s->domain = find_domain_from_name_noinit(s->domname);
if (s->domain == NULL) {
DEBUG(7, ("could not find domain entry for domain %s\n",
s->domname));
request_error(state);
return;
}
if ( s->domain->primary && lp_winbind_trusted_domains_only()) {
DEBUG(7,("winbindd_getgroups: My domain -- rejecting "
"getgroups() for %s\\%s.\n", s->domname,
s->username));
request_error(state);
return;
}
winbindd_lookupname_async(state->mem_ctx, s->domname, s->username,
getgroups_usersid_recv, s);
}
static void getgroups_usersid_recv(void *private_data, BOOL success,
const DOM_SID *sid, enum lsa_SidType type)
{
struct getgroups_state *s =
(struct getgroups_state *)private_data;
if ((!success) ||
((type != SID_NAME_USER) && (type != SID_NAME_COMPUTER))) {
request_error(s->state);
return;
}
sid_copy(&s->user_sid, sid);
winbindd_gettoken_async(s->state->mem_ctx, &s->user_sid,
getgroups_tokensids_recv, s);
}
static void getgroups_tokensids_recv(void *private_data, BOOL success,
DOM_SID *token_sids, size_t num_token_sids)
{
struct getgroups_state *s =
(struct getgroups_state *)private_data;
if ((!success) || (num_token_sids < 2)) {
request_error(s->state);
return;
}
s->token_sids = token_sids;
s->num_token_sids = num_token_sids;
s->i = 0;
s->token_gids = NULL;
s->num_token_gids = 0;
getgroups_sid2gid_recv(s, False, 0);
}
static void getgroups_sid2gid_recv(void *private_data, BOOL success, gid_t gid)
{
struct getgroups_state *s =
(struct getgroups_state *)private_data;
if (success) {
if (!add_gid_to_array_unique(s->state->mem_ctx, gid,
&s->token_gids,
&s->num_token_gids)) {
return;
}
}
if (s->i < s->num_token_sids) {
const DOM_SID *sid = &s->token_sids[s->i];
s->i += 1;
if (sid_equal(sid, &s->user_sid)) {
getgroups_sid2gid_recv(s, False, 0);
return;
}
winbindd_sid2gid_async(s->state->mem_ctx, sid,
getgroups_sid2gid_recv, s);
return;
}
s->state->response.data.num_entries = s->num_token_gids;
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);
}
static void getusersids_recv(void *private_data, BOOL success, DOM_SID *sids,
size_t num_sids);
void winbindd_getusersids(struct winbindd_cli_state *state)
{
DOM_SID *user_sid;
state->request.data.sid[sizeof(state->request.data.sid)-1]='\0';
user_sid = TALLOC_P(state->mem_ctx, DOM_SID);
if (user_sid == NULL) {
DEBUG(1, ("talloc failed\n"));
request_error(state);
return;
}
if (!string_to_sid(user_sid, state->request.data.sid)) {
DEBUG(1, ("Could not get convert sid %s from string\n",
state->request.data.sid));
request_error(state);
return;
}
winbindd_gettoken_async(state->mem_ctx, user_sid, getusersids_recv,
state);
}
static void getusersids_recv(void *private_data, BOOL success, DOM_SID *sids,
size_t num_sids)
{
struct winbindd_cli_state *state =
(struct winbindd_cli_state *)private_data;
char *ret = NULL;
unsigned ofs, ret_size = 0;
size_t i;
if (!success) {
request_error(state);
return;
}
for (i = 0; i < num_sids; i++) {
const char *s = sid_string_static(&sids[i]);
ret_size += strlen(s) + 1;
}
ret = (char *)SMB_MALLOC(ret_size);
if (!ret) {
DEBUG(0, ("malloc failed\n"));
request_error(state);
return;
}
ofs = 0;
for (i = 0; i < num_sids; i++) {
const char *s = sid_string_static(&sids[i]);
safe_strcpy(ret + ofs, s, ret_size - ofs - 1);
ofs += strlen(ret+ofs) + 1;
}
state->response.data.num_entries = num_sids;
state->response.extra_data.data = ret;
state->response.length += ret_size;
request_ok(state);
}
void winbindd_getuserdomgroups(struct winbindd_cli_state *state)
{
DOM_SID user_sid;
struct winbindd_domain *domain;
state->request.data.sid[sizeof(state->request.data.sid)-1]='\0';
if (!string_to_sid(&user_sid, state->request.data.sid)) {
DEBUG(1, ("Could not get convert sid %s from string\n",
state->request.data.sid));
request_error(state);
return;
}
if ((domain = find_domain_from_sid_noinit(&user_sid)) == NULL) {
DEBUG(0,("could not find domain entry for sid %s\n",
sid_string_static(&user_sid)));
request_error(state);
return;
}
sendto_domain(state, domain);
}
enum winbindd_result winbindd_dual_getuserdomgroups(struct winbindd_domain *domain,
struct winbindd_cli_state *state)
{
DOM_SID user_sid;
NTSTATUS status;
char *sidstring;
ssize_t len;
DOM_SID *groups;
uint32 num_groups;
state->request.data.sid[sizeof(state->request.data.sid)-1]='\0';
if (!string_to_sid(&user_sid, state->request.data.sid)) {
DEBUG(1, ("Could not get convert sid %s from string\n",
state->request.data.sid));
return WINBINDD_ERROR;
}
status = domain->methods->lookup_usergroups(domain, state->mem_ctx,
&user_sid, &num_groups,
&groups);
if (!NT_STATUS_IS_OK(status))
return WINBINDD_ERROR;
if (num_groups == 0) {
state->response.data.num_entries = 0;
state->response.extra_data.data = NULL;
return WINBINDD_OK;
}
if (!print_sidlist(state->mem_ctx, groups, num_groups, &sidstring, &len)) {
DEBUG(0, ("talloc failed\n"));
return WINBINDD_ERROR;
}
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;
return WINBINDD_OK;
}