r395: BUG 1232: patch from landonf@opendarwin.org (Landon Fuller) to fix
[tprouty/samba.git] / source / nsswitch / winbindd_group.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Winbind daemon for ntdom nss module
5
6    Copyright (C) Tim Potter 2000
7    Copyright (C) Jeremy Allison 2001.
8    Copyright (C) Gerald (Jerry) Carter 2003.
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include "includes.h"
26 #include "winbindd.h"
27
28 extern BOOL opt_nocache;
29
30 #undef DBGC_CLASS
31 #define DBGC_CLASS DBGC_WINBIND
32
33 /*********************************************************************
34 *********************************************************************/
35
36 static int gr_mem_buffer( char **buffer, char **members, int num_members )
37 {
38         int i;
39         int len = 0;
40         int idx = 0;
41
42         if ( num_members == 0 ) {
43                 *buffer = NULL;
44                 return 0;
45         }
46         
47         for ( i=0; i<num_members; i++ )
48                 len += strlen(members[i])+1;
49
50         *buffer = (char*)smb_xmalloc(len);
51         for ( i=0; i<num_members; i++ ) {
52                 snprintf( &(*buffer)[idx], len-idx, "%s,", members[i]);
53                 idx += strlen(members[i])+1;
54         }
55         /* terminate with NULL */
56         (*buffer)[len-1] = '\0';
57         
58         return len;     
59 }
60
61 /***************************************************************
62  Empty static struct for negative caching.
63 ****************************************************************/
64
65 /* Fill a grent structure from various other information */
66
67 static BOOL fill_grent(struct winbindd_gr *gr, const char *dom_name, 
68                        const char *gr_name, gid_t unix_gid)
69 {
70         fstring full_group_name;
71         /* Fill in uid/gid */
72         fill_domain_username(full_group_name, dom_name, gr_name);
73
74         gr->gr_gid = unix_gid;
75     
76         /* Group name and password */
77     
78         safe_strcpy(gr->gr_name, full_group_name, sizeof(gr->gr_name) - 1);
79         safe_strcpy(gr->gr_passwd, "x", sizeof(gr->gr_passwd) - 1);
80
81         return True;
82 }
83
84 /* Fill in the group membership field of a NT group given by group_sid */
85
86 static BOOL fill_grent_mem(struct winbindd_domain *domain,
87                            DOM_SID *group_sid, 
88                            enum SID_NAME_USE group_name_type, 
89                            int *num_gr_mem, char **gr_mem, int *gr_mem_len)
90 {
91         DOM_SID **sid_mem = NULL;
92         uint32 num_names = 0;
93         uint32 *name_types = NULL;
94         unsigned int buf_len, buf_ndx, i;
95         char **names = NULL, *buf;
96         BOOL result = False;
97         TALLOC_CTX *mem_ctx;
98         NTSTATUS status;
99         fstring sid_string;
100
101         if (!(mem_ctx = talloc_init("fill_grent_mem(%s)", domain->name)))
102                 return False;
103
104         /* Initialise group membership information */
105         
106         DEBUG(10, ("group SID %s\n", sid_to_string(sid_string, group_sid)));
107
108         *num_gr_mem = 0;
109
110         /* HACK ALERT!! This whole routine does not cope with group members
111          * from more than one domain, ie aliases. Thus we have to work it out
112          * ourselves in a special routine. */
113
114         if (domain->internal)
115                 return fill_passdb_alias_grmem(domain, group_sid,
116                                                num_gr_mem,
117                                                gr_mem, gr_mem_len);
118         
119         if ( !((group_name_type==SID_NAME_DOM_GRP) ||
120                 ((group_name_type==SID_NAME_ALIAS) && domain->primary)) )
121         {
122                 DEBUG(1, ("SID %s in domain %s isn't a domain group (%d)\n", 
123                           sid_to_string(sid_string, group_sid), domain->name, 
124                           group_name_type));
125                 goto done;
126         }
127
128         /* Lookup group members */
129         status = domain->methods->lookup_groupmem(domain, mem_ctx, group_sid, &num_names, 
130                                                   &sid_mem, &names, &name_types);
131         if (!NT_STATUS_IS_OK(status)) {
132                 DEBUG(1, ("could not lookup membership for group rid %s in domain %s (error: %s)\n", 
133                           sid_to_string(sid_string, group_sid), domain->name, nt_errstr(status)));
134
135                 goto done;
136         }
137
138         DEBUG(10, ("looked up %d names\n", num_names));
139
140         if (DEBUGLEVEL >= 10) {
141                 for (i = 0; i < num_names; i++)
142                         DEBUG(10, ("\t%20s %s %d\n", names[i], sid_to_string(sid_string, sid_mem[i]),
143                                    name_types[i]));
144         }
145
146         /* Add members to list */
147
148         buf = NULL;
149         buf_len = buf_ndx = 0;
150
151  again:
152
153         for (i = 0; i < num_names; i++) {
154                 char *the_name;
155                 fstring name;
156                 int len;
157                         
158                 the_name = names[i];
159
160                 DEBUG(10, ("processing name %s\n", the_name));
161
162                 /* FIXME: need to cope with groups within groups.  These
163                    occur in Universal groups on a Windows 2000 native mode
164                    server. */
165
166                 /* make sure to allow machine accounts */
167
168                 if (name_types[i] != SID_NAME_USER && name_types[i] != SID_NAME_COMPUTER) {
169                         DEBUG(3, ("name %s isn't a domain user\n", the_name));
170                         continue;
171                 }
172
173                 /* Append domain name */
174
175                 fill_domain_username(name, domain->name, the_name);
176
177                 len = strlen(name);
178                 
179                 /* Add to list or calculate buffer length */
180
181                 if (!buf) {
182                         buf_len += len + 1; /* List is comma separated */
183                         (*num_gr_mem)++;
184                         DEBUG(10, ("buf_len + %d = %d\n", len + 1, buf_len));
185                 } else {
186                         DEBUG(10, ("appending %s at ndx %d\n", name, len));
187                         safe_strcpy(&buf[buf_ndx], name, len);
188                         buf_ndx += len;
189                         buf[buf_ndx] = ',';
190                         buf_ndx++;
191                 }
192         }
193
194         /* Allocate buffer */
195
196         if (!buf && buf_len != 0) {
197                 if (!(buf = malloc(buf_len))) {
198                         DEBUG(1, ("out of memory\n"));
199                         result = False;
200                         goto done;
201                 }
202                 memset(buf, 0, buf_len);
203                 goto again;
204         }
205
206         if (buf && buf_ndx > 0) {
207                 buf[buf_ndx - 1] = '\0';
208         }
209
210         *gr_mem = buf;
211         *gr_mem_len = buf_len;
212
213         DEBUG(10, ("num_mem = %d, len = %d, mem = %s\n", *num_gr_mem, 
214                    buf_len, *num_gr_mem ? buf : "NULL")); 
215         result = True;
216
217 done:
218
219         talloc_destroy(mem_ctx);
220         
221         DEBUG(10, ("fill_grent_mem returning %d\n", result));
222
223         return result;
224 }
225
226 /* Return a group structure from a group name */
227
228 enum winbindd_result winbindd_getgrnam(struct winbindd_cli_state *state)
229 {
230         DOM_SID group_sid;
231         WINBINDD_GR *grp;
232         struct winbindd_domain *domain;
233         enum SID_NAME_USE name_type;
234         fstring name_domain, name_group;
235         char *tmp, *gr_mem;
236         int gr_mem_len;
237         gid_t gid;
238         
239         /* Ensure null termination */
240         state->request.data.groupname[sizeof(state->request.data.groupname)-1]='\0';
241
242         DEBUG(3, ("[%5lu]: getgrnam %s\n", (unsigned long)state->pid,
243                   state->request.data.groupname));
244
245         /* Parse domain and groupname */
246         
247         memset(name_group, 0, sizeof(fstring));
248
249         tmp = state->request.data.groupname;
250         
251         parse_domain_user(tmp, name_domain, name_group);
252
253         /* if no domain or our local domain, then do a local tdb search */
254         
255         if ( (!*name_domain || strequal(name_domain, get_global_sam_name())) &&
256              ((grp = wb_getgrnam(name_group)) != NULL) ) {
257
258                 char *buffer = NULL;
259                 
260                 memcpy( &state->response.data.gr, grp, sizeof(WINBINDD_GR) );
261
262                 gr_mem_len = gr_mem_buffer( &buffer, grp->gr_mem, grp->num_gr_mem );
263                 
264                 state->response.data.gr.gr_mem_ofs = 0;
265                 state->response.length += gr_mem_len;
266                 state->response.extra_data = buffer;    /* give the memory away */
267                 
268                 return WINBINDD_OK;
269         }
270
271         /* if no domain or our local domain and no local tdb group, default to
272          * our local domain for aliases */
273
274         if ( !*name_domain || strequal(name_domain, get_global_sam_name()) ) {
275                 fstrcpy(name_domain, get_global_sam_name());
276         }
277
278         /* Get info for the domain */
279
280         if ((domain = find_domain_from_name(name_domain)) == NULL) {
281                 DEBUG(3, ("could not get domain sid for domain %s\n",
282                           name_domain));
283                 return WINBINDD_ERROR;
284         }
285         /* should we deal with users for our domain? */
286         
287         if ( lp_winbind_trusted_domains_only() && domain->primary) {
288                 DEBUG(7,("winbindd_getgrnam: My domain -- rejecting getgrnam() for %s\\%s.\n", 
289                         name_domain, name_group));
290                 return WINBINDD_ERROR;
291         }
292
293         /* Get rid and name type from name */
294         
295         if (!winbindd_lookup_sid_by_name(domain, domain->name, name_group, &group_sid, 
296                                          &name_type)) {
297                 DEBUG(1, ("group %s in domain %s does not exist\n", 
298                           name_group, name_domain));
299                 return WINBINDD_ERROR;
300         }
301
302         if ( !((name_type==SID_NAME_DOM_GRP) ||
303                ((name_type==SID_NAME_ALIAS) && domain->primary) ||
304                ((name_type==SID_NAME_ALIAS) && domain->internal)) )
305         {
306                 DEBUG(1, ("name '%s' is not a local or domain group: %d\n", 
307                           name_group, name_type));
308                 return WINBINDD_ERROR;
309         }
310
311         if (!NT_STATUS_IS_OK(idmap_sid_to_gid(&group_sid, &gid, 0))) {
312                 DEBUG(1, ("error converting unix gid to sid\n"));
313                 return WINBINDD_ERROR;
314         }
315
316         if (!fill_grent(&state->response.data.gr, name_domain,
317                         name_group, gid) ||
318             !fill_grent_mem(domain, &group_sid, name_type,
319                             &state->response.data.gr.num_gr_mem,
320                             &gr_mem, &gr_mem_len)) {
321                 return WINBINDD_ERROR;
322         }
323
324         /* Group membership lives at start of extra data */
325
326         state->response.data.gr.gr_mem_ofs = 0;
327
328         state->response.length += gr_mem_len;
329         state->response.extra_data = gr_mem;
330
331         return WINBINDD_OK;
332 }
333
334 /* Return a group structure from a gid number */
335
336 enum winbindd_result winbindd_getgrgid(struct winbindd_cli_state *state)
337 {
338         struct winbindd_domain *domain;
339         WINBINDD_GR *grp;
340         DOM_SID group_sid;
341         enum SID_NAME_USE name_type;
342         fstring dom_name;
343         fstring group_name;
344         int gr_mem_len;
345         char *gr_mem;
346
347         DEBUG(3, ("[%5lu]: getgrgid %lu\n", (unsigned long)state->pid, 
348                   (unsigned long)state->request.data.gid));
349
350         /* Bug out if the gid isn't in the winbind range */
351
352         if ((state->request.data.gid < server_state.gid_low) ||
353             (state->request.data.gid > server_state.gid_high))
354                 return WINBINDD_ERROR;
355
356         /* alway try local tdb lookup first */
357         if ( ( grp=wb_getgrgid(state->request.data.gid)) != NULL ) {
358                 char *buffer = NULL;
359                 
360                 memcpy( &state->response.data.gr, grp, sizeof(WINBINDD_GR) );
361                 
362                 gr_mem_len = gr_mem_buffer( &buffer, grp->gr_mem, grp->num_gr_mem );
363                 
364                 state->response.data.gr.gr_mem_ofs = 0;
365                 state->response.length += gr_mem_len;
366                 state->response.extra_data = buffer;    /* give away the memory */
367                 
368                 return WINBINDD_OK;
369         }
370
371         /* Get rid from gid */
372         if (!NT_STATUS_IS_OK(idmap_gid_to_sid(&group_sid, state->request.data.gid))) {
373                 DEBUG(1, ("could not convert gid %lu to rid\n", 
374                           (unsigned long)state->request.data.gid));
375                 return WINBINDD_ERROR;
376         }
377
378         /* Get name from sid */
379
380         if (!winbindd_lookup_name_by_sid(&group_sid, dom_name, group_name, &name_type)) {
381                 DEBUG(1, ("could not lookup sid\n"));
382                 return WINBINDD_ERROR;
383         }
384
385         /* Fill in group structure */
386
387         domain = find_domain_from_sid(&group_sid);
388
389         if (!domain) {
390                 DEBUG(1,("Can't find domain from sid\n"));
391                 return WINBINDD_ERROR;
392         }
393
394         if ( !((name_type==SID_NAME_DOM_GRP) ||
395                ((name_type==SID_NAME_ALIAS) && domain->primary) ||
396                ((name_type==SID_NAME_ALIAS) && domain->internal)) )
397         {
398                 DEBUG(1, ("name '%s' is not a local or domain group: %d\n", 
399                           group_name, name_type));
400                 return WINBINDD_ERROR;
401         }
402
403         if (!fill_grent(&state->response.data.gr, dom_name, group_name, 
404                         state->request.data.gid) ||
405             !fill_grent_mem(domain, &group_sid, name_type,
406                             &state->response.data.gr.num_gr_mem,
407                             &gr_mem, &gr_mem_len))
408                 return WINBINDD_ERROR;
409
410         /* Group membership lives at start of extra data */
411
412         state->response.data.gr.gr_mem_ofs = 0;
413
414         state->response.length += gr_mem_len;
415         state->response.extra_data = gr_mem;
416
417         return WINBINDD_OK;
418 }
419
420 /*
421  * set/get/endgrent functions
422  */
423
424 /* "Rewind" file pointer for group database enumeration */
425
426 enum winbindd_result winbindd_setgrent(struct winbindd_cli_state *state)
427 {
428         struct winbindd_domain *domain;
429
430         DEBUG(3, ("[%5lu]: setgrent\n", (unsigned long)state->pid));
431
432         /* Check user has enabled this */
433
434         if (!lp_winbind_enum_groups())
435                 return WINBINDD_ERROR;
436
437         /* Free old static data if it exists */
438         
439         if (state->getgrent_state != NULL) {
440                 free_getent_state(state->getgrent_state);
441                 state->getgrent_state = NULL;
442         }
443         
444         /* Create sam pipes for each domain we know about */
445         
446         for (domain = domain_list(); domain != NULL; domain = domain->next) {
447                 struct getent_state *domain_state;
448                 
449                 /* Create a state record for this domain */
450
451                 /* don't add our domaina if we are a PDC or if we 
452                    are a member of a Samba domain */
453                 
454                 if ( lp_winbind_trusted_domains_only() && domain->primary )
455                 {
456                         continue;
457                 }
458                                                 
459                 
460                 if ((domain_state = (struct getent_state *)
461                      malloc(sizeof(struct getent_state))) == NULL) {
462                         DEBUG(1, ("winbindd_setgrent: malloc failed for domain_state!\n"));
463                         return WINBINDD_ERROR;
464                 }
465                 
466                 ZERO_STRUCTP(domain_state);
467                 
468                 fstrcpy(domain_state->domain_name, domain->name);
469
470                 /* Add to list of open domains */
471                 
472                 DLIST_ADD(state->getgrent_state, domain_state);
473         }
474         
475         state->getgrent_initialized = True;
476
477         return WINBINDD_OK;
478 }
479
480 /* Close file pointer to ntdom group database */
481
482 enum winbindd_result winbindd_endgrent(struct winbindd_cli_state *state)
483 {
484         DEBUG(3, ("[%5lu]: endgrent\n", (unsigned long)state->pid));
485
486         free_getent_state(state->getgrent_state);
487         state->getgrent_initialized = False;
488         state->getgrent_state = NULL;
489         
490         return WINBINDD_OK;
491 }
492
493 /* Get the list of domain groups and domain aliases for a domain.  We fill in
494    the sam_entries and num_sam_entries fields with domain group information.  
495    The dispinfo_ndx field is incremented to the index of the next group to 
496    fetch. Return True if some groups were returned, False otherwise. */
497
498 #define MAX_FETCH_SAM_ENTRIES 100
499
500 static BOOL get_sam_group_entries(struct getent_state *ent)
501 {
502         NTSTATUS status;
503         uint32 num_entries;
504         struct acct_info *name_list = NULL, *tmp_name_list = NULL;
505         TALLOC_CTX *mem_ctx;
506         BOOL result = False;
507         struct acct_info *sam_grp_entries = NULL;
508         struct winbindd_domain *domain;
509         
510         if (ent->got_sam_entries)
511                 return False;
512
513         if (!(mem_ctx = talloc_init("get_sam_group_entries(%s)",
514                                           ent->domain_name))) {
515                 DEBUG(1, ("get_sam_group_entries: could not create talloc context!\n")); 
516                 return False;
517         }
518                 
519         /* Free any existing group info */
520
521         SAFE_FREE(ent->sam_entries);
522         ent->num_sam_entries = 0;
523         ent->got_sam_entries = True;
524
525         /* Enumerate domain groups */
526
527         num_entries = 0;
528
529         if (!(domain = find_domain_from_name(ent->domain_name))) {
530                 DEBUG(3, ("no such domain %s in get_sam_group_entries\n", ent->domain_name));
531                 goto done;
532         }
533
534         /* always get the domain global groups */
535
536         status = domain->methods->enum_dom_groups(domain, mem_ctx, &num_entries, &sam_grp_entries);
537         
538         if (!NT_STATUS_IS_OK(status)) {
539                 DEBUG(3, ("get_sam_group_entries: could not enumerate domain groups! Error: %s\n", nt_errstr(status)));
540                 result = False;
541                 goto done;
542         }
543
544         /* Copy entries into return buffer */
545
546         if (num_entries) {
547                 if ( !(name_list = malloc(sizeof(struct acct_info) * num_entries)) ) {
548                         DEBUG(0,("get_sam_group_entries: Failed to malloc memory for %d domain groups!\n", 
549                                 num_entries));
550                         result = False;
551                         goto done;
552                 }
553                 memcpy( name_list, sam_grp_entries, num_entries * sizeof(struct acct_info) );
554         }
555         
556         ent->num_sam_entries = num_entries;
557         
558         /* get the domain local groups if we are a member of a native win2k domain
559            and are not using LDAP to get the groups */
560            
561         if ( ( lp_security() != SEC_ADS && domain->native_mode 
562                 && domain->primary) || domain->internal )
563         {
564                 DEBUG(4,("get_sam_group_entries: Native Mode 2k domain; enumerating local groups as well\n"));
565                 
566                 status = domain->methods->enum_local_groups(domain, mem_ctx, &num_entries, &sam_grp_entries);
567                 
568                 if ( !NT_STATUS_IS_OK(status) ) { 
569                         DEBUG(3,("get_sam_group_entries: Failed to enumerate domain local groups!\n"));
570                         num_entries = 0;
571                 }
572                 else
573                         DEBUG(4,("get_sam_group_entries: Returned %d local groups\n", num_entries));
574                 
575                 /* Copy entries into return buffer */
576
577                 if ( num_entries ) {
578                         if ( !(tmp_name_list = Realloc( name_list, sizeof(struct acct_info) * (ent->num_sam_entries+num_entries))) )
579                         {
580                                 DEBUG(0,("get_sam_group_entries: Failed to realloc more memory for %d local groups!\n", 
581                                         num_entries));
582                                 result = False;
583                                 SAFE_FREE( name_list );
584                                 goto done;
585                         }
586                         
587                         name_list = tmp_name_list;
588                                 
589                         memcpy( &name_list[ent->num_sam_entries], sam_grp_entries, 
590                                 num_entries * sizeof(struct acct_info) );
591                 }
592         
593                 ent->num_sam_entries += num_entries;
594         }
595         
596                 
597         /* Fill in remaining fields */
598
599         ent->sam_entries = name_list;
600         ent->sam_entry_index = 0;
601
602         result = (ent->num_sam_entries > 0);
603
604  done:
605         talloc_destroy(mem_ctx);
606
607         return result;
608 }
609
610 /* Fetch next group entry from ntdom database */
611
612 #define MAX_GETGRENT_GROUPS 500
613
614 enum winbindd_result winbindd_getgrent(struct winbindd_cli_state *state)
615 {
616         struct getent_state *ent;
617         struct winbindd_gr *group_list = NULL;
618         int num_groups, group_list_ndx = 0, i, gr_mem_list_len = 0;
619         char *new_extra_data, *gr_mem_list = NULL;
620
621         DEBUG(3, ("[%5lu]: getgrent\n", (unsigned long)state->pid));
622
623         /* Check user has enabled this */
624
625         if (!lp_winbind_enum_groups())
626                 return WINBINDD_ERROR;
627
628         num_groups = MIN(MAX_GETGRENT_GROUPS, state->request.data.num_entries);
629
630         if ((state->response.extra_data = 
631              malloc(num_groups * sizeof(struct winbindd_gr))) == NULL)
632                 return WINBINDD_ERROR;
633
634         state->response.data.num_entries = 0;
635
636         group_list = (struct winbindd_gr *)state->response.extra_data;
637
638         if (!state->getgrent_initialized)
639                 winbindd_setgrent(state);
640
641         if (!(ent = state->getgrent_state))
642                 return WINBINDD_ERROR;
643
644         /* Start sending back groups */
645
646         for (i = 0; i < num_groups; i++) {
647                 struct acct_info *name_list = NULL;
648                 fstring domain_group_name;
649                 uint32 result;
650                 gid_t group_gid;
651                 int gr_mem_len;
652                 char *gr_mem, *new_gr_mem_list;
653                 DOM_SID group_sid;
654                 struct winbindd_domain *domain;
655                                 
656                 /* Do we need to fetch another chunk of groups? */
657
658         tryagain:
659
660                 DEBUG(10, ("entry_index = %d, num_entries = %d\n",
661                            ent->sam_entry_index, ent->num_sam_entries));
662
663                 if (ent->num_sam_entries == ent->sam_entry_index) {
664
665                         while(ent && !get_sam_group_entries(ent)) {
666                                 struct getent_state *next_ent;
667
668                                 DEBUG(10, ("freeing state info for domain %s\n", ent->domain_name)); 
669
670                                 /* Free state information for this domain */
671
672                                 SAFE_FREE(ent->sam_entries);
673
674                                 next_ent = ent->next;
675                                 DLIST_REMOVE(state->getgrent_state, ent);
676                                 
677                                 SAFE_FREE(ent);
678                                 ent = next_ent;
679                         }
680
681                         /* No more domains */
682
683                         if (!ent) 
684                                 break;
685                 }
686                 
687                 name_list = ent->sam_entries;
688                 
689                 if (!(domain = 
690                       find_domain_from_name(ent->domain_name))) {
691                         DEBUG(3, ("No such domain %s in winbindd_getgrent\n", ent->domain_name));
692                         result = False;
693                         goto done;
694                 }
695
696                 /* Lookup group info */
697                 
698                 sid_copy(&group_sid, &domain->sid);
699                 sid_append_rid(&group_sid, name_list[ent->sam_entry_index].rid);
700
701                 if (!NT_STATUS_IS_OK(idmap_sid_to_gid(&group_sid, &group_gid, 0))) {
702                         
703                         DEBUG(1, ("could not look up gid for group %s\n", 
704                                   name_list[ent->sam_entry_index].acct_name));
705                         
706                         ent->sam_entry_index++;
707                         goto tryagain;
708                 }
709
710                 DEBUG(10, ("got gid %lu for group %lu\n", (unsigned long)group_gid,
711                            (unsigned long)name_list[ent->sam_entry_index].rid));
712                 
713                 /* Fill in group entry */
714
715                 fill_domain_username(domain_group_name, ent->domain_name, 
716                          name_list[ent->sam_entry_index].acct_name);
717
718                 result = fill_grent(&group_list[group_list_ndx], 
719                                     ent->domain_name,
720                                     name_list[ent->sam_entry_index].acct_name,
721                                     group_gid);
722
723                 /* Fill in group membership entry */
724
725                 if (result) {
726                         DOM_SID member_sid;
727                         group_list[group_list_ndx].num_gr_mem = 0;
728                         gr_mem = NULL;
729                         gr_mem_len = 0;
730                         
731                         /* Get group membership */                      
732                         if (state->request.cmd == WINBINDD_GETGRLST) {
733                                 result = True;
734                         } else {
735                                 sid_copy(&member_sid, &domain->sid);
736                                 sid_append_rid(&member_sid, name_list[ent->sam_entry_index].rid);
737                                 result = fill_grent_mem(
738                                         domain,
739                                         &member_sid,
740                                         SID_NAME_DOM_GRP,
741                                         &group_list[group_list_ndx].num_gr_mem, 
742                                         &gr_mem, &gr_mem_len);
743                         }
744                 }
745
746                 if (result) {
747                         /* Append to group membership list */
748                         new_gr_mem_list = Realloc(
749                                 gr_mem_list,
750                                 gr_mem_list_len + gr_mem_len);
751
752                         if (!new_gr_mem_list && (group_list[group_list_ndx].num_gr_mem != 0)) {
753                                 DEBUG(0, ("out of memory\n"));
754                                 SAFE_FREE(gr_mem_list);
755                                 gr_mem_list_len = 0;
756                                 break;
757                         }
758
759                         DEBUG(10, ("list_len = %d, mem_len = %d\n",
760                                    gr_mem_list_len, gr_mem_len));
761
762                         gr_mem_list = new_gr_mem_list;
763
764                         memcpy(&gr_mem_list[gr_mem_list_len], gr_mem,
765                                gr_mem_len);
766
767                         SAFE_FREE(gr_mem);
768
769                         group_list[group_list_ndx].gr_mem_ofs = 
770                                 gr_mem_list_len;
771
772                         gr_mem_list_len += gr_mem_len;
773                 }
774
775                 ent->sam_entry_index++;
776                 
777                 /* Add group to return list */
778                 
779                 if (result) {
780
781                         DEBUG(10, ("adding group num_entries = %d\n",
782                                    state->response.data.num_entries));
783
784                         group_list_ndx++;
785                         state->response.data.num_entries++;
786                         
787                         state->response.length +=
788                                 sizeof(struct winbindd_gr);
789                         
790                 } else {
791                         DEBUG(0, ("could not lookup domain group %s\n", 
792                                   domain_group_name));
793                 }
794         }
795
796         /* Copy the list of group memberships to the end of the extra data */
797
798         if (group_list_ndx == 0)
799                 goto done;
800
801         new_extra_data = Realloc(
802                 state->response.extra_data,
803                 group_list_ndx * sizeof(struct winbindd_gr) + gr_mem_list_len);
804
805         if (!new_extra_data) {
806                 DEBUG(0, ("out of memory\n"));
807                 group_list_ndx = 0;
808                 SAFE_FREE(state->response.extra_data);
809                 SAFE_FREE(gr_mem_list);
810
811                 return WINBINDD_ERROR;
812         }
813
814         state->response.extra_data = new_extra_data;
815
816         memcpy(&((char *)state->response.extra_data)
817                [group_list_ndx * sizeof(struct winbindd_gr)], 
818                gr_mem_list, gr_mem_list_len);
819
820         SAFE_FREE(gr_mem_list);
821
822         state->response.length += gr_mem_list_len;
823
824         DEBUG(10, ("returning %d groups, length = %d\n",
825                    group_list_ndx, gr_mem_list_len));
826
827         /* Out of domains */
828
829  done:
830
831         return (group_list_ndx > 0) ? WINBINDD_OK : WINBINDD_ERROR;
832 }
833
834 /* List domain groups without mapping to unix ids */
835
836 enum winbindd_result winbindd_list_groups(struct winbindd_cli_state *state)
837 {
838         uint32 total_entries = 0;
839         struct winbindd_domain *domain;
840         const char *which_domain;
841         char *extra_data = NULL;
842         char *ted = NULL;
843         unsigned int extra_data_len = 0, i;
844
845         DEBUG(3, ("[%5lu]: list groups\n", (unsigned long)state->pid));
846
847         /* Ensure null termination */
848         state->request.domain_name[sizeof(state->request.domain_name)-1]='\0';  
849         which_domain = state->request.domain_name;
850         
851         /* Enumerate over trusted domains */
852
853         for (domain = domain_list(); domain; domain = domain->next) {
854                 struct getent_state groups;
855
856                 /* if we have a domain name restricting the request and this
857                    one in the list doesn't match, then just bypass the remainder
858                    of the loop */
859                    
860                 if ( *which_domain && !strequal(which_domain, domain->name) )
861                         continue;
862                         
863                 ZERO_STRUCT(groups);
864
865                 /* Get list of sam groups */
866                 
867                 fstrcpy(groups.domain_name, domain->name);
868
869                 get_sam_group_entries(&groups);
870                         
871                 if (groups.num_sam_entries == 0) {
872                         /* this domain is empty or in an error state */
873                         continue;
874                 }
875
876                 /* keep track the of the total number of groups seen so 
877                    far over all domains */
878                 total_entries += groups.num_sam_entries;
879                 
880                 /* Allocate some memory for extra data.  Note that we limit
881                    account names to sizeof(fstring) = 128 characters.  */               
882                 ted = Realloc(extra_data, sizeof(fstring) * total_entries);
883  
884                 if (!ted) {
885                         DEBUG(0,("failed to enlarge buffer!\n"));
886                         SAFE_FREE(extra_data);
887                         return WINBINDD_ERROR;
888                 } else
889                         extra_data = ted;
890
891                 /* Pack group list into extra data fields */
892                 for (i = 0; i < groups.num_sam_entries; i++) {
893                         char *group_name = ((struct acct_info *)
894                                             groups.sam_entries)[i].acct_name; 
895                         fstring name;
896
897                         fill_domain_username(name, domain->name, group_name);
898                         /* Append to extra data */                      
899                         memcpy(&extra_data[extra_data_len], name, 
900                                strlen(name));
901                         extra_data_len += strlen(name);
902                         extra_data[extra_data_len++] = ',';
903                 }
904
905                 SAFE_FREE(groups.sam_entries);
906         }
907
908         /* Assign extra_data fields in response structure */
909         if (extra_data) {
910                 extra_data[extra_data_len - 1] = '\0';
911                 state->response.extra_data = extra_data;
912                 state->response.length += extra_data_len;
913         }
914
915         /* No domains may have responded but that's still OK so don't
916            return an error. */
917
918         return WINBINDD_OK;
919 }
920
921 static void add_gid_to_array_unique(gid_t gid, gid_t **gids, int *num)
922 {
923         int i;
924
925         if ((*num) >= groups_max())
926                 return;
927
928         for (i=0; i<*num; i++) {
929                 if ((*gids)[i] == gid)
930                         return;
931         }
932         
933         *gids = Realloc(*gids, (*num+1) * sizeof(gid_t));
934
935         if (*gids == NULL)
936                 return;
937
938         (*gids)[*num] = gid;
939         *num += 1;
940 }
941
942 static void add_gids_from_sid(DOM_SID *sid, gid_t **gids, int *num)
943 {
944         gid_t gid;
945         DOM_SID *aliases;
946         int j, num_aliases;
947
948         DEBUG(10, ("Adding gids from SID: %s\n", sid_string_static(sid)));
949
950         if (NT_STATUS_IS_OK(idmap_sid_to_gid(sid, &gid, 0)))
951                 add_gid_to_array_unique(gid, gids, num);
952
953         /* Don't expand aliases if not explicitly activated -- for now
954            -- jerry */
955
956         if (!lp_winbind_nested_groups())
957                 return;
958
959         /* Add nested group memberships */
960
961         if (!pdb_enum_alias_memberships(sid, &aliases, &num_aliases))
962                 return;
963
964         for (j=0; j<num_aliases; j++) {
965
966                 if (!NT_STATUS_IS_OK(sid_to_gid(&aliases[j], &gid)))
967                         continue;
968
969                 add_gid_to_array_unique(gid, gids, num);
970         }
971         SAFE_FREE(aliases);
972 }
973
974 /* Get user supplementary groups.  This is much quicker than trying to
975    invert the groups database.  We merge the groups from the gids and
976    other_sids info3 fields as trusted domain, universal group
977    memberships, and nested groups (win2k native mode only) are not
978    returned by the getgroups RPC call but are present in the info3. */
979
980 enum winbindd_result winbindd_getgroups(struct winbindd_cli_state *state)
981 {
982         fstring name_domain, name_user;
983         DOM_SID user_sid, group_sid;
984         enum SID_NAME_USE name_type;
985         uint32 num_groups = 0;
986         uint32 num_gids = 0;
987         NTSTATUS status;
988         DOM_SID **user_grpsids;
989         struct winbindd_domain *domain;
990         enum winbindd_result result = WINBINDD_ERROR;
991         gid_t *gid_list = NULL;
992         unsigned int i;
993         TALLOC_CTX *mem_ctx;
994         NET_USER_INFO_3 *info3 = NULL;
995         
996         /* Ensure null termination */
997         state->request.data.username[sizeof(state->request.data.username)-1]='\0';
998
999         DEBUG(3, ("[%5lu]: getgroups %s\n", (unsigned long)state->pid,
1000                   state->request.data.username));
1001
1002         if (!(mem_ctx = talloc_init("winbindd_getgroups(%s)",
1003                                           state->request.data.username)))
1004                 return WINBINDD_ERROR;
1005
1006         /* Parse domain and username */
1007
1008         parse_domain_user(state->request.data.username, 
1009                           name_domain, name_user);
1010         
1011         /* Get info for the domain */
1012         
1013         if ((domain = find_domain_from_name(name_domain)) == NULL) {
1014                 DEBUG(7, ("could not find domain entry for domain %s\n", 
1015                           name_domain));
1016                 goto done;
1017         }
1018
1019         if ( domain->primary && lp_winbind_trusted_domains_only()) {
1020                 DEBUG(7,("winbindd_getpwnam: My domain -- rejecting getgroups() for %s\\%s.\n", 
1021                         name_domain, name_user));
1022                 return WINBINDD_ERROR;
1023         }       
1024         
1025         /* Get rid and name type from name.  The following costs 1 packet */
1026
1027         if (!winbindd_lookup_sid_by_name(domain, domain->name, name_user, &user_sid, 
1028                                          &name_type)) {
1029                 DEBUG(1, ("user '%s' does not exist\n", name_user));
1030                 goto done;
1031         }
1032
1033         if (name_type != SID_NAME_USER && name_type != SID_NAME_COMPUTER) {
1034                 DEBUG(1, ("name '%s' is not a user name: %d\n", 
1035                           name_user, name_type));
1036                 goto done;
1037         }
1038
1039         add_gids_from_sid(&user_sid, &gid_list, &num_gids);
1040
1041         /* Treat the info3 cache as authoritative as the
1042            lookup_usergroups() function may return cached data. */
1043
1044         if ( !opt_nocache && (info3 = netsamlogon_cache_get(mem_ctx, &user_sid))) {
1045
1046                 DEBUG(10, ("winbindd_getgroups: info3 has %d groups, %d other sids\n",
1047                            info3->num_groups2, info3->num_other_sids));
1048
1049                 num_groups = info3->num_other_sids + info3->num_groups2;
1050
1051                 /* Go through each other sid and convert it to a gid */
1052
1053                 for (i = 0; i < info3->num_other_sids; i++) {
1054                         fstring name;
1055                         fstring dom_name;
1056                         enum SID_NAME_USE sid_type;
1057
1058                         /* Is this sid known to us?  It can either be
1059                            a trusted domain sid or a foreign sid. */
1060
1061                         if (!winbindd_lookup_name_by_sid( &info3->other_sids[i].sid, 
1062                                 dom_name, name, &sid_type))
1063                         {
1064                                 DEBUG(10, ("winbindd_getgroups: could not lookup name for %s\n", 
1065                                            sid_string_static(&info3->other_sids[i].sid)));
1066                                 continue;
1067                         }
1068
1069                         /* Check it is a domain group or an alias (domain local group) 
1070                            in a win2k native mode domain. */
1071                         
1072                         if ( !((sid_type==SID_NAME_DOM_GRP) ||
1073                                 ((sid_type==SID_NAME_ALIAS) && domain->primary)) )
1074                         {
1075                                 DEBUG(10, ("winbindd_getgroups: sid type %d "
1076                                            "for %s is not a domain group\n",
1077                                            sid_type,
1078                                            sid_string_static(
1079                                                    &info3->other_sids[i].sid)));
1080                                 continue;
1081                         }
1082
1083                         add_gids_from_sid(&info3->other_sids[i].sid,
1084                                           &gid_list, &num_gids);
1085
1086                         if (gid_list == NULL)
1087                                 goto done;
1088                 }
1089
1090                 for (i = 0; i < info3->num_groups2; i++) {
1091                 
1092                         /* create the group SID */
1093                         
1094                         sid_copy( &group_sid, &domain->sid );
1095                         sid_append_rid( &group_sid, info3->gids[i].g_rid );
1096
1097                         add_gids_from_sid(&group_sid, &gid_list, &num_gids);
1098
1099                         if (gid_list == NULL)
1100                                 goto done;
1101                 }
1102
1103                 SAFE_FREE(info3);
1104
1105         } else {
1106                 status = domain->methods->lookup_usergroups(domain, mem_ctx, 
1107                                                     &user_sid, &num_groups, 
1108                                                     &user_grpsids);
1109                 if (!NT_STATUS_IS_OK(status)) 
1110                         goto done;
1111
1112                 if (state->response.extra_data)
1113                         goto done;
1114
1115                 for (i = 0; i < num_groups; i++) {
1116                         add_gids_from_sid(user_grpsids[i],
1117                                           &gid_list, &num_gids);
1118
1119                         if (gid_list == NULL)
1120                                 goto done;
1121                 }
1122         }
1123
1124         remove_duplicate_gids( &num_gids, gid_list );
1125
1126         /* Send data back to client */
1127
1128         state->response.data.num_entries = num_gids;
1129         state->response.extra_data = gid_list;
1130         state->response.length += num_gids * sizeof(gid_t);
1131
1132         result = WINBINDD_OK;
1133
1134  done:
1135
1136         talloc_destroy(mem_ctx);
1137
1138         return result;
1139 }
1140
1141
1142 /* Get user supplementary sids. This is equivalent to the
1143    winbindd_getgroups() function but it involves a SID->SIDs mapping
1144    rather than a NAME->SID->SIDS->GIDS mapping, which means we avoid
1145    idmap. This call is designed to be used with applications that need
1146    to do ACL evaluation themselves. Note that the cached info3 data is
1147    not used 
1148
1149    this function assumes that the SID that comes in is a user SID. If
1150    you pass in another type of SID then you may get unpredictable
1151    results.
1152 */
1153 enum winbindd_result winbindd_getusersids(struct winbindd_cli_state *state)
1154 {
1155         DOM_SID user_sid;
1156         NTSTATUS status;
1157         DOM_SID **user_grpsids;
1158         struct winbindd_domain *domain;
1159         enum winbindd_result result = WINBINDD_ERROR;
1160         unsigned int i;
1161         TALLOC_CTX *mem_ctx;
1162         char *ret = NULL;
1163         uint32 num_groups;
1164         unsigned ofs, ret_size = 0;
1165
1166         /* Ensure null termination */
1167         state->request.data.sid[sizeof(state->request.data.sid)-1]='\0';
1168
1169         if (!string_to_sid(&user_sid, state->request.data.sid)) {
1170                 DEBUG(1, ("Could not get convert sid %s from string\n", state->request.data.sid));
1171                 return WINBINDD_ERROR;
1172         }
1173
1174         if (!(mem_ctx = talloc_init("winbindd_getusersids(%s)",
1175                                     state->request.data.username))) {
1176                 return WINBINDD_ERROR;
1177         }
1178
1179         /* Get info for the domain */   
1180         if ((domain = find_domain_from_sid(&user_sid)) == NULL) {
1181                 DEBUG(0,("could not find domain entry for sid %s\n", 
1182                           sid_string_static(&user_sid)));
1183                 goto done;
1184         }
1185         
1186         status = domain->methods->lookup_usergroups(domain, mem_ctx, 
1187                                                     &user_sid, &num_groups, 
1188                                                     &user_grpsids);
1189         if (!NT_STATUS_IS_OK(status)) 
1190                 goto done;
1191
1192         if (num_groups == 0) {
1193                 goto no_groups;
1194         }
1195
1196         /* work out the response size */
1197         for (i = 0; i < num_groups; i++) {
1198                 const char *s = sid_string_static(user_grpsids[i]);
1199                 ret_size += strlen(s) + 1;
1200         }
1201
1202         /* build the reply */
1203         ret = malloc(ret_size);
1204         if (!ret) goto done;
1205         ofs = 0;
1206         for (i = 0; i < num_groups; i++) {
1207                 const char *s = sid_string_static(user_grpsids[i]);
1208                 safe_strcpy(ret + ofs, s, ret_size - ofs - 1);
1209                 ofs += strlen(ret+ofs) + 1;
1210         }
1211
1212 no_groups:
1213         /* Send data back to client */
1214         state->response.data.num_entries = num_groups;
1215         state->response.extra_data = ret;
1216         state->response.length += ret_size;
1217         result = WINBINDD_OK;
1218
1219  done:
1220         talloc_destroy(mem_ctx);
1221
1222         return result;
1223 }
1224