r4088: Get medieval on our ass about malloc.... :-). Take control of all our allocation
[tprouty/samba.git] / source / nsswitch / winbindd_group.c
index 41f594fe611b8dd1936c97a4c4ce4a15106d800c..4b49c1873e2425974512436faf3b1438e4010360 100644 (file)
@@ -5,6 +5,7 @@
 
    Copyright (C) Tim Potter 2000
    Copyright (C) Jeremy Allison 2001.
+   Copyright (C) Gerald (Jerry) Carter 2003.
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
+#include "includes.h"
 #include "winbindd.h"
 
+extern BOOL opt_nocache;
+
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_WINBIND
 
+/*********************************************************************
+*********************************************************************/
+
+static int gr_mem_buffer( char **buffer, char **members, int num_members )
+{
+       int i;
+       int len = 0;
+       int idx = 0;
+
+       if ( num_members == 0 ) {
+               *buffer = NULL;
+               return 0;
+       }
+       
+       for ( i=0; i<num_members; i++ )
+               len += strlen(members[i])+1;
+
+       *buffer = SMB_XMALLOC_ARRAY(char, len);
+       for ( i=0; i<num_members; i++ ) {
+               snprintf( &(*buffer)[idx], len-idx, "%s,", members[i]);
+               idx += strlen(members[i])+1;
+       }
+       /* terminate with NULL */
+       (*buffer)[len-1] = '\0';
+       
+       return len;     
+}
+
 /***************************************************************
  Empty static struct for negative caching.
 ****************************************************************/
@@ -74,8 +106,19 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain,
        DEBUG(10, ("group SID %s\n", sid_to_string(sid_string, group_sid)));
 
        *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,
+                                              num_gr_mem,
+                                              gr_mem, gr_mem_len);
        
-       if ((group_name_type!=SID_NAME_DOM_GRP) && (group_name_type!=SID_NAME_ALIAS)) {
+       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));
@@ -120,15 +163,10 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain,
                    occur in Universal groups on a Windows 2000 native mode
                    server. */
 
-               if (name_types[i] != SID_NAME_USER) {
-                       DEBUG(3, ("name %s isn't a domain user\n", the_name));
-                       continue;
-               }
+               /* make sure to allow machine accounts */
 
-               /* Don't bother with machine accounts */
-               
-               if (the_name[strlen(the_name) - 1] == '$') {
-                       DEBUG(10, ("%s is machine account\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\n", the_name));
                        continue;
                }
 
@@ -156,7 +194,7 @@ static BOOL fill_grent_mem(struct winbindd_domain *domain,
        /* Allocate buffer */
 
        if (!buf && buf_len != 0) {
-               if (!(buf = malloc(buf_len))) {
+               if (!(buf = SMB_MALLOC(buf_len))) {
                        DEBUG(1, ("out of memory\n"));
                        result = False;
                        goto done;
@@ -190,6 +228,7 @@ done:
 enum winbindd_result winbindd_getgrnam(struct winbindd_cli_state *state)
 {
        DOM_SID group_sid;
+       WINBINDD_GR *grp;
        struct winbindd_domain *domain;
        enum SID_NAME_USE name_type;
        fstring name_domain, name_group;
@@ -200,7 +239,7 @@ enum winbindd_result winbindd_getgrnam(struct winbindd_cli_state *state)
        /* Ensure null termination */
        state->request.data.groupname[sizeof(state->request.data.groupname)-1]='\0';
 
-       DEBUG(3, ("[%5d]: getgrnam %s\n", state->pid,
+       DEBUG(3, ("[%5lu]: getgrnam %s\n", (unsigned long)state->pid,
                  state->request.data.groupname));
 
        /* Parse domain and groupname */
@@ -208,33 +247,68 @@ enum winbindd_result winbindd_getgrnam(struct winbindd_cli_state *state)
        memset(name_group, 0, sizeof(fstring));
 
        tmp = state->request.data.groupname;
-       if (!parse_domain_user(tmp, name_domain, name_group))
-               return WINBINDD_ERROR;
+       
+       parse_domain_user(tmp, name_domain, name_group);
+
+       /* if no domain or our local domain, then do a local tdb search */
+       
+       if ( (!*name_domain || strequal(name_domain, get_global_sam_name())) &&
+            ((grp = wb_getgrnam(name_group)) != NULL) ) {
+
+               char *buffer = NULL;
+               
+               memcpy( &state->response.data.gr, grp, sizeof(WINBINDD_GR) );
+
+               gr_mem_len = gr_mem_buffer( &buffer, grp->gr_mem, grp->num_gr_mem );
+               
+               state->response.data.gr.gr_mem_ofs = 0;
+               state->response.length += gr_mem_len;
+               state->response.extra_data = buffer;    /* give the memory away */
+               
+               return WINBINDD_OK;
+       }
+
+       /* if no domain or our local domain and no local tdb group, default to
+        * our local domain for aliases */
+
+       if ( !*name_domain || strequal(name_domain, get_global_sam_name()) ) {
+               fstrcpy(name_domain, get_global_sam_name());
+       }
 
        /* Get info for the domain */
 
        if ((domain = find_domain_from_name(name_domain)) == NULL) {
-               DEBUG(0, ("could not get domain sid for domain %s\n",
+               DEBUG(3, ("could not get domain sid for domain %s\n",
                          name_domain));
                return WINBINDD_ERROR;
        }
+       /* 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));
+               return WINBINDD_ERROR;
+       }
 
        /* Get rid and name type from name */
         
-       if (!winbindd_lookup_sid_by_name(domain, name_group, &group_sid, 
+       if (!winbindd_lookup_sid_by_name(domain, domain->name, name_group, &group_sid, 
                                         &name_type)) {
                DEBUG(1, ("group %s in domain %s does not exist\n", 
                          name_group, name_domain));
                return WINBINDD_ERROR;
        }
 
-       if ((name_type != SID_NAME_ALIAS) && (name_type != SID_NAME_DOM_GRP)) {
+       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", 
                          name_group, name_type));
                return WINBINDD_ERROR;
        }
 
-       if (!NT_STATUS_IS_OK(sid_to_gid(&group_sid, &gid))) {
+       if (!NT_STATUS_IS_OK(idmap_sid_to_gid(&group_sid, &gid, 0))) {
                DEBUG(1, ("error converting unix gid to sid\n"));
                return WINBINDD_ERROR;
        }
@@ -262,6 +336,7 @@ enum winbindd_result winbindd_getgrnam(struct winbindd_cli_state *state)
 enum winbindd_result winbindd_getgrgid(struct winbindd_cli_state *state)
 {
        struct winbindd_domain *domain;
+       WINBINDD_GR *grp;
        DOM_SID group_sid;
        enum SID_NAME_USE name_type;
        fstring dom_name;
@@ -269,8 +344,8 @@ enum winbindd_result winbindd_getgrgid(struct winbindd_cli_state *state)
        int gr_mem_len;
        char *gr_mem;
 
-       DEBUG(3, ("[%5d]: getgrgid %d\n", state->pid, 
-                 state->request.data.gid));
+       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 */
 
@@ -278,10 +353,25 @@ enum winbindd_result winbindd_getgrgid(struct winbindd_cli_state *state)
            (state->request.data.gid > server_state.gid_high))
                return WINBINDD_ERROR;
 
+       /* alway try local tdb lookup first */
+       if ( ( grp=wb_getgrgid(state->request.data.gid)) != NULL ) {
+               char *buffer = NULL;
+               
+               memcpy( &state->response.data.gr, grp, sizeof(WINBINDD_GR) );
+               
+               gr_mem_len = gr_mem_buffer( &buffer, grp->gr_mem, grp->num_gr_mem );
+               
+               state->response.data.gr.gr_mem_ofs = 0;
+               state->response.length += gr_mem_len;
+               state->response.extra_data = buffer;    /* give away the memory */
+               
+               return WINBINDD_OK;
+       }
+
        /* Get rid from gid */
-       if (!NT_STATUS_IS_OK(gid_to_sid(&group_sid, state->request.data.gid))) {
-               DEBUG(1, ("could not convert gid %d to rid\n", 
-                         state->request.data.gid));
+       if (!NT_STATUS_IS_OK(idmap_gid_to_sid(&group_sid, state->request.data.gid))) {
+               DEBUG(1, ("could not convert gid %lu to rid\n", 
+                         (unsigned long)state->request.data.gid));
                return WINBINDD_ERROR;
        }
 
@@ -292,13 +382,6 @@ enum winbindd_result winbindd_getgrgid(struct winbindd_cli_state *state)
                return WINBINDD_ERROR;
        }
 
-       if (!((name_type == SID_NAME_ALIAS) || 
-             (name_type == SID_NAME_DOM_GRP))) {
-               DEBUG(1, ("name '%s' is not a local or domain group: %d\n", 
-                         group_name, name_type));
-               return WINBINDD_ERROR;
-       }
-
        /* Fill in group structure */
 
        domain = find_domain_from_sid(&group_sid);
@@ -308,6 +391,15 @@ enum winbindd_result winbindd_getgrgid(struct winbindd_cli_state *state)
                return WINBINDD_ERROR;
        }
 
+       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));
+               return WINBINDD_ERROR;
+       }
+
        if (!fill_grent(&state->response.data.gr, dom_name, group_name, 
                        state->request.data.gid) ||
            !fill_grent_mem(domain, &group_sid, name_type,
@@ -335,7 +427,7 @@ enum winbindd_result winbindd_setgrent(struct winbindd_cli_state *state)
 {
        struct winbindd_domain *domain;
 
-       DEBUG(3, ("[%5d]: setgrent\n", state->pid));
+       DEBUG(3, ("[%5lu]: setgrent\n", (unsigned long)state->pid));
 
        /* Check user has enabled this */
 
@@ -355,9 +447,17 @@ enum winbindd_result winbindd_setgrent(struct winbindd_cli_state *state)
                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 
+                  are a member of a Samba domain */
+               
+               if ( lp_winbind_trusted_domains_only() && domain->primary )
+               {
+                       continue;
+               }
+                                               
                
-               if ((domain_state = (struct getent_state *)
-                    malloc(sizeof(struct getent_state))) == NULL) {
+               if ((domain_state = SMB_MALLOC_P(struct getent_state)) == NULL) {
                        DEBUG(1, ("winbindd_setgrent: malloc failed for domain_state!\n"));
                        return WINBINDD_ERROR;
                }
@@ -371,6 +471,8 @@ enum winbindd_result winbindd_setgrent(struct winbindd_cli_state *state)
                DLIST_ADD(state->getgrent_state, domain_state);
        }
        
+       state->getgrent_initialized = True;
+
        return WINBINDD_OK;
 }
 
@@ -378,9 +480,10 @@ enum winbindd_result winbindd_setgrent(struct winbindd_cli_state *state)
 
 enum winbindd_result winbindd_endgrent(struct winbindd_cli_state *state)
 {
-       DEBUG(3, ("[%5d]: endgrent\n", state->pid));
+       DEBUG(3, ("[%5lu]: endgrent\n", (unsigned long)state->pid));
 
        free_getent_state(state->getgrent_state);
+       state->getgrent_initialized = False;
        state->getgrent_state = NULL;
        
        return WINBINDD_OK;
@@ -391,8 +494,6 @@ enum winbindd_result winbindd_endgrent(struct winbindd_cli_state *state)
    The dispinfo_ndx field is incremented to the index of the next group to 
    fetch. Return True if some groups were returned, False otherwise. */
 
-#define MAX_FETCH_SAM_ENTRIES 100
-
 static BOOL get_sam_group_entries(struct getent_state *ent)
 {
        NTSTATUS status;
@@ -440,7 +541,7 @@ static BOOL get_sam_group_entries(struct getent_state *ent)
        /* Copy entries into return buffer */
 
        if (num_entries) {
-               if ( !(name_list = malloc(sizeof(struct acct_info) * 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;
@@ -451,11 +552,11 @@ static BOOL get_sam_group_entries(struct getent_state *ent)
        
        ent->num_sam_entries = num_entries;
        
-       /* get the domain local groups if we are a member of a native win2k domain */
+       /* 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 ( domain->native_mode 
-               && domain->methods->enum_local_groups 
-               && strequal(lp_workgroup(), domain->name) )
+       if ( ( lp_security() != SEC_ADS && domain->native_mode 
+               && domain->primary) || domain->internal )
        {
                DEBUG(4,("get_sam_group_entries: Native Mode 2k domain; enumerating local groups as well\n"));
                
@@ -471,7 +572,7 @@ static BOOL get_sam_group_entries(struct getent_state *ent)
                /* Copy entries into return buffer */
 
                if ( num_entries ) {
-                       if ( !(tmp_name_list = Realloc( name_list, sizeof(struct acct_info) * (ent->num_sam_entries+num_entries))) )
+                       if ( !(tmp_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));
@@ -514,7 +615,7 @@ enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
        int num_groups, group_list_ndx = 0, i, gr_mem_list_len = 0;
        char *new_extra_data, *gr_mem_list = NULL;
 
-       DEBUG(3, ("[%5d]: getgrent\n", state->pid));
+       DEBUG(3, ("[%5lu]: getgrent\n", (unsigned long)state->pid));
 
        /* Check user has enabled this */
 
@@ -523,14 +624,19 @@ enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
 
        num_groups = MIN(MAX_GETGRENT_GROUPS, state->request.data.num_entries);
 
-       if ((state->response.extra_data = 
-            malloc(num_groups * sizeof(struct winbindd_gr))) == NULL)
+       if ((state->response.extra_data = SMB_MALLOC_ARRAY(struct winbindd_gr, num_groups)) == NULL)
                return WINBINDD_ERROR;
 
+       memset(state->response.extra_data, '\0',
+               num_groups * sizeof(struct winbindd_gr) );
+
        state->response.data.num_entries = 0;
 
        group_list = (struct winbindd_gr *)state->response.extra_data;
 
+       if (!state->getgrent_initialized)
+               winbindd_setgrent(state);
+
        if (!(ent = state->getgrent_state))
                return WINBINDD_ERROR;
 
@@ -591,7 +697,7 @@ enum winbindd_result 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(sid_to_gid(&group_sid, &group_gid))) {
+               if (!NT_STATUS_IS_OK(idmap_sid_to_gid(&group_sid, &group_gid, 0))) {
                        
                        DEBUG(1, ("could not look up gid for group %s\n", 
                                  name_list[ent->sam_entry_index].acct_name));
@@ -600,8 +706,8 @@ enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
                        goto tryagain;
                }
 
-               DEBUG(10, ("got gid %d for group %x\n", group_gid,
-                          name_list[ent->sam_entry_index].rid));
+               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 */
 
@@ -638,9 +744,7 @@ enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
 
                if (result) {
                        /* Append to group membership list */
-                       new_gr_mem_list = Realloc(
-                               gr_mem_list,
-                               gr_mem_list_len + gr_mem_len);
+                       new_gr_mem_list = SMB_REALLOC( gr_mem_list, gr_mem_list_len + gr_mem_len);
 
                        if (!new_gr_mem_list && (group_list[group_list_ndx].num_gr_mem != 0)) {
                                DEBUG(0, ("out of memory\n"));
@@ -691,7 +795,7 @@ enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
        if (group_list_ndx == 0)
                goto done;
 
-       new_extra_data = Realloc(
+       new_extra_data = SMB_REALLOC(
                state->response.extra_data,
                group_list_ndx * sizeof(struct winbindd_gr) + gr_mem_list_len);
 
@@ -730,17 +834,29 @@ enum winbindd_result winbindd_list_groups(struct winbindd_cli_state *state)
 {
        uint32 total_entries = 0;
        struct winbindd_domain *domain;
+       const char *which_domain;
        char *extra_data = NULL;
        char *ted = NULL;
        unsigned int extra_data_len = 0, i;
 
-       DEBUG(3, ("[%5d]: list groups\n", state->pid));
+       DEBUG(3, ("[%5lu]: list groups\n", (unsigned long)state->pid));
 
+       /* Ensure null termination */
+       state->request.domain_name[sizeof(state->request.domain_name)-1]='\0';  
+       which_domain = state->request.domain_name;
+       
        /* Enumerate over trusted domains */
 
        for (domain = domain_list(); domain; domain = domain->next) {
                struct getent_state groups;
 
+               /* if we have a domain name restricting the request and this
+                  one in the list doesn't match, then just bypass the remainder
+                  of the loop */
+                  
+               if ( *which_domain && !strequal(which_domain, domain->name) )
+                       continue;
+                       
                ZERO_STRUCT(groups);
 
                /* Get list of sam groups */
@@ -760,7 +876,7 @@ enum winbindd_result 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.  */               
-                ted = Realloc(extra_data, sizeof(fstring) * total_entries);
+                ted = SMB_REALLOC(extra_data, sizeof(fstring) * total_entries);
  
                if (!ted) {
                        DEBUG(0,("failed to enlarge buffer!\n"));
@@ -783,7 +899,7 @@ enum winbindd_result winbindd_list_groups(struct winbindd_cli_state *state)
                        extra_data[extra_data_len++] = ',';
                }
 
-               free(groups.sam_entries);
+               SAFE_FREE(groups.sam_entries);
        }
 
        /* Assign extra_data fields in response structure */
@@ -799,6 +915,65 @@ enum winbindd_result winbindd_list_groups(struct winbindd_cli_state *state)
        return WINBINDD_OK;
 }
 
+static void add_local_gids_from_sid(DOM_SID *sid, gid_t **gids, int *num)
+{
+       gid_t gid;
+       DOM_SID *aliases;
+       int j, num_aliases;
+
+       DEBUG(10, ("Adding local gids from SID: %s\n",
+                  sid_string_static(sid)));
+
+       /* Don't expand aliases if not explicitly activated -- for now
+          -- jerry */
+
+       if (!lp_winbind_nested_groups())
+               return;
+
+       /* Add nested group memberships */
+
+       if (!pdb_enum_alias_memberships(sid, 1, &aliases, &num_aliases))
+               return;
+
+       for (j=0; j<num_aliases; j++) {
+               enum SID_NAME_USE type;
+
+               if (!local_sid_to_gid(&gid, &aliases[j], &type)) {
+                       DEBUG(1, ("Got an alias membership with no alias\n"));
+                       continue;
+               }
+
+               if ((type != SID_NAME_ALIAS) && (type != SID_NAME_WKN_GRP)) {
+                       DEBUG(1, ("Got an alias membership in a non-alias\n"));
+                       continue;
+               }
+
+               add_gid_to_array_unique(gid, gids, num);
+       }
+       SAFE_FREE(aliases);
+}
+
+static void add_gids_from_user_sid(DOM_SID *sid, gid_t **gids, int *num)
+{
+       DEBUG(10, ("Adding gids from user SID: %s\n",
+                  sid_string_static(sid)));
+
+       add_local_gids_from_sid(sid, gids, num);
+}
+
+static void add_gids_from_group_sid(DOM_SID *sid, gid_t **gids, int *num)
+{
+       gid_t gid;
+
+       DEBUG(10, ("Adding gids from group SID: %s\n",
+                  sid_string_static(sid)));
+
+       if (NT_STATUS_IS_OK(idmap_sid_to_gid(sid, &gid, 0)))
+               add_gid_to_array_unique(gid, gids, num);
+
+       add_local_gids_from_sid(sid, gids, num);
+}
+
 /* Get user supplementary groups.  This is much quicker than trying to
    invert the groups database.  We merge the groups from the gids and
    other_sids info3 fields as trusted domain, universal group
@@ -816,7 +991,7 @@ enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
        DOM_SID **user_grpsids;
        struct winbindd_domain *domain;
        enum winbindd_result result = WINBINDD_ERROR;
-       gid_t *gid_list;
+       gid_t *gid_list = NULL;
        unsigned int i;
        TALLOC_CTX *mem_ctx;
        NET_USER_INFO_3 *info3 = NULL;
@@ -824,7 +999,7 @@ enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
        /* Ensure null termination */
        state->request.data.username[sizeof(state->request.data.username)-1]='\0';
 
-       DEBUG(3, ("[%5d]: getgroups %s\n", state->pid,
+       DEBUG(3, ("[%5lu]: getgroups %s\n", (unsigned long)state->pid,
                  state->request.data.username));
 
        if (!(mem_ctx = talloc_init("winbindd_getgroups(%s)",
@@ -833,42 +1008,48 @@ enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
 
        /* Parse domain and username */
 
-       if (!parse_domain_user(state->request.data.username, name_domain, 
-                         name_user))
-               goto done;
-
+       parse_domain_user(state->request.data.username, 
+                         name_domain, name_user);
+       
        /* Get info for the domain */
        
        if ((domain = find_domain_from_name(name_domain)) == NULL) {
-               DEBUG(0, ("could not find domain entry for domain %s\n", 
+               DEBUG(7, ("could not find domain entry for domain %s\n", 
                          name_domain));
                goto done;
        }
 
+       if ( domain->primary && lp_winbind_trusted_domains_only()) {
+               DEBUG(7,("winbindd_getpwnam: My domain -- rejecting getgroups() for %s\\%s.\n", 
+                       name_domain, name_user));
+               return WINBINDD_ERROR;
+       }       
+       
        /* Get rid and name type from name.  The following costs 1 packet */
 
-       if (!winbindd_lookup_sid_by_name(domain, name_user, &user_sid, 
+       if (!winbindd_lookup_sid_by_name(domain, domain->name, name_user, &user_sid, 
                                         &name_type)) {
                DEBUG(1, ("user '%s' does not exist\n", name_user));
                goto done;
        }
 
-       if (name_type != SID_NAME_USER) {
+       if (name_type != SID_NAME_USER && name_type != SID_NAME_COMPUTER) {
                DEBUG(1, ("name '%s' is not a user name: %d\n", 
                          name_user, name_type));
                goto done;
        }
 
+       add_gids_from_user_sid(&user_sid, &gid_list, &num_gids);
+
        /* Treat the info3 cache as authoritative as the
           lookup_usergroups() function may return cached data. */
 
-       if ((info3 = netsamlogon_cache_get(mem_ctx, &user_sid))) {
+       if ( !opt_nocache && (info3 = netsamlogon_cache_get(mem_ctx, &user_sid))) {
 
                DEBUG(10, ("winbindd_getgroups: info3 has %d groups, %d other sids\n",
                           info3->num_groups2, info3->num_other_sids));
 
                num_groups = info3->num_other_sids + info3->num_groups2;
-               gid_list = calloc(sizeof(gid_t), num_groups);
 
                /* Go through each other sid and convert it to a gid */
 
@@ -891,8 +1072,9 @@ enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
                        /* Check it is a domain group or an alias (domain local group) 
                           in a win2k native mode domain. */
                        
-                       if ( !(sid_type == SID_NAME_DOM_GRP || sid_type == SID_NAME_ALIAS) ) {
-
+                       if ( !((sid_type==SID_NAME_DOM_GRP) ||
+                               ((sid_type==SID_NAME_ALIAS) && domain->primary)) )
+                       {
                                DEBUG(10, ("winbindd_getgroups: sid type %d "
                                           "for %s is not a domain group\n",
                                           sid_type,
@@ -901,24 +1083,8 @@ enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
                                continue;
                        }
 
-                       /* Map to a gid */
-
-                       if (!NT_STATUS_IS_OK(sid_to_gid(&info3->other_sids[i].sid, 
-                               &gid_list[num_gids])) )
-                       {
-                               DEBUG(10, ("winbindd_getgroups: could not map sid %s to gid\n",
-                                          sid_string_static(&info3->other_sids[i].sid)));
-                               continue;
-                       }
-
-                       /* We've jumped through a lot of hoops to get here */
-
-                       DEBUG(10, ("winbindd_getgroups: mapped other sid %s to "
-                                  "gid %d\n", sid_string_static(
-                                          &info3->other_sids[i].sid),
-                                  gid_list[num_gids]));
-
-                       num_gids++;
+                       add_gids_from_group_sid(&info3->other_sids[i].sid,
+                                               &gid_list, &num_gids);
                }
 
                for (i = 0; i < info3->num_groups2; i++) {
@@ -928,12 +1094,8 @@ enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
                        sid_copy( &group_sid, &domain->sid );
                        sid_append_rid( &group_sid, info3->gids[i].g_rid );
 
-                       if (!NT_STATUS_IS_OK(sid_to_gid(&group_sid, &gid_list[num_gids])) ) {
-                               DEBUG(10, ("winbindd_getgroups: could not map sid %s to gid\n",
-                                          sid_string_static(&group_sid)));
-                       }
-
-                       num_gids++;
+                       add_gids_from_group_sid(&group_sid, &gid_list,
+                                               &num_gids);
                }
 
                SAFE_FREE(info3);
@@ -945,21 +1107,21 @@ enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
                if (!NT_STATUS_IS_OK(status)) 
                        goto done;
 
-               gid_list = malloc(sizeof(gid_t) * num_groups);
-
                if (state->response.extra_data)
                        goto done;
 
                for (i = 0; i < num_groups; i++) {
-                       if (!NT_STATUS_IS_OK(sid_to_gid(user_grpsids[i], &gid_list[num_gids]))) {
-                               DEBUG(1, ("unable to convert group sid %s to gid\n", 
-                                         sid_string_static(user_grpsids[i])));
-                               continue;
-                       }
-                       num_gids++;
+                       add_gids_from_group_sid(user_grpsids[i],
+                                               &gid_list, &num_gids);
                }
        }
 
+       /* We want at least one group... */
+       if (gid_list == NULL)
+               goto done;
+
+       remove_duplicate_gids( &num_gids, gid_list );
+
        /* Send data back to client */
 
        state->response.data.num_entries = num_gids;
@@ -974,3 +1136,144 @@ enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
 
        return result;
 }
+
+static void add_sid_to_parray_unique(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
+                                   DOM_SID ***sids, int *num_sids)
+{
+       int i;
+
+       for (i=0; i<(*num_sids); i++) {
+               if (sid_compare(sid, (*sids)[i]) == 0)
+                       return;
+       }
+
+       *sids = TALLOC_REALLOC_ARRAY(mem_ctx, *sids, DOM_SID *, *num_sids+1);
+
+       if (*sids == NULL)
+               return;
+
+       (*sids)[*num_sids] = TALLOC_P(mem_ctx, DOM_SID);
+       sid_copy((*sids)[*num_sids], sid);
+       *num_sids += 1;
+       return;
+}
+
+static void add_local_sids_from_sid(TALLOC_CTX *mem_ctx, const DOM_SID *sid,
+                                   DOM_SID ***user_grpsids,
+                                   int *num_groups)
+{
+       DOM_SID *aliases = NULL;
+       int i, num_aliases = 0;
+
+       if (!pdb_enum_alias_memberships(sid, 1, &aliases, &num_aliases))
+               return;
+
+       if (num_aliases == 0)
+               return;
+
+       for (i=0; i<num_aliases; i++)
+               add_sid_to_parray_unique(mem_ctx, &aliases[i], user_grpsids,
+                                        num_groups);
+
+       SAFE_FREE(aliases);
+
+       return;
+}
+
+/* Get user supplementary sids. This is equivalent to the
+   winbindd_getgroups() function but it involves a SID->SIDs mapping
+   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 
+
+   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
+   results.
+*/
+enum winbindd_result winbindd_getusersids(struct winbindd_cli_state *state)
+{
+       DOM_SID user_sid;
+       NTSTATUS status;
+       DOM_SID **user_grpsids;
+       struct winbindd_domain *domain;
+       enum winbindd_result result = WINBINDD_ERROR;
+       unsigned int i;
+       TALLOC_CTX *mem_ctx;
+       char *ret = NULL;
+       uint32 num_groups;
+       unsigned ofs, ret_size = 0;
+
+       /* Ensure null termination */
+       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;
+       }
+
+       if (!(mem_ctx = talloc_init("winbindd_getusersids(%s)",
+                                   state->request.data.username))) {
+               return WINBINDD_ERROR;
+       }
+
+       /* Get info for the domain */   
+       if ((domain = find_domain_from_sid(&user_sid)) == NULL) {
+               DEBUG(0,("could not find domain entry for sid %s\n", 
+                         sid_string_static(&user_sid)));
+               goto done;
+       }
+       
+       status = domain->methods->lookup_usergroups(domain, mem_ctx, 
+                                                   &user_sid, &num_groups, 
+                                                   &user_grpsids);
+       if (!NT_STATUS_IS_OK(status)) 
+               goto done;
+
+       if (num_groups == 0) {
+               goto no_groups;
+       }
+
+       if (lp_winbind_nested_groups()) {
+               int k;
+               /* num_groups is changed during the loop, that's why we have
+                  to count down here.*/
+
+               for (k=num_groups-1; k>=0; k--) {
+                       add_local_sids_from_sid(mem_ctx, user_grpsids[k],
+                                               &user_grpsids, &num_groups);
+               }
+
+               add_local_sids_from_sid(mem_ctx, &user_sid, &user_grpsids,
+                                       &num_groups);
+       }
+
+       /* work out the response size */
+       for (i = 0; i < num_groups; i++) {
+               const char *s = sid_string_static(user_grpsids[i]);
+               ret_size += strlen(s) + 1;
+       }
+
+       /* build the reply */
+       ret = SMB_MALLOC(ret_size);
+       if (!ret) goto done;
+       ofs = 0;
+       for (i = 0; i < num_groups; i++) {
+               const char *s = sid_string_static(user_grpsids[i]);
+               safe_strcpy(ret + ofs, s, ret_size - ofs - 1);
+               ofs += strlen(ret+ofs) + 1;
+       }
+
+no_groups:
+       /* Send data back to client */
+       state->response.data.num_entries = num_groups;
+       state->response.extra_data = ret;
+       state->response.length += ret_size;
+       result = WINBINDD_OK;
+
+ done:
+       talloc_destroy(mem_ctx);
+
+       return result;
+}
+