Put back the changes that Simo reverted and fix a speling mistak.
[tprouty/samba.git] / source / nsswitch / winbindd_rpc.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Winbind rpc backend functions
5
6    Copyright (C) Tim Potter 2000-2001,2003
7    Copyright (C) Andrew Tridgell 2001
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "winbindd.h"
25
26 #undef DBGC_CLASS
27 #define DBGC_CLASS DBGC_WINBIND
28
29
30 /* Query display info for a domain.  This returns enough information plus a
31    bit extra to give an overview of domain users for the User Manager
32    application. */
33 static NTSTATUS query_user_list(struct winbindd_domain *domain,
34                                TALLOC_CTX *mem_ctx,
35                                uint32 *num_entries, 
36                                WINBIND_USERINFO **info)
37 {
38         CLI_POLICY_HND *hnd;
39         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
40         POLICY_HND dom_pol;
41         BOOL got_dom_pol = False;
42         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
43         unsigned int i, start_idx, retry;
44
45         DEBUG(3,("rpc: query_user_list\n"));
46
47         *num_entries = 0;
48         *info = NULL;
49
50         retry = 0;
51         do {
52                 /* Get sam handle */
53
54                 if ( !NT_STATUS_IS_OK(result = cm_get_sam_handle(domain->name, &hnd)) )
55                         return result;
56
57                 /* Get domain handle */
58
59                 result = cli_samr_open_domain(hnd->cli, mem_ctx, &hnd->pol,
60                                                 des_access, &domain->sid, &dom_pol);
61
62         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) && hnd && hnd->cli && hnd->cli->fd == -1);
63
64         if (!NT_STATUS_IS_OK(result))
65                 goto done;
66
67         got_dom_pol = True;
68
69         i = start_idx = 0;
70         do {
71                 TALLOC_CTX *ctx2;
72                 char **dom_users;
73                 uint32 num_dom_users, *dom_rids, j, size = 0xffff;
74                 uint16 acb_mask = ACB_NORMAL;
75
76                 if (!(ctx2 = talloc_init("winbindd enum_users"))) {
77                         result = NT_STATUS_NO_MEMORY;
78                         goto done;
79                 }               
80
81                 result = cli_samr_enum_dom_users(
82                         hnd->cli, ctx2, &dom_pol, &start_idx, acb_mask,
83                         size, &dom_users, &dom_rids, &num_dom_users);
84
85                 *num_entries += num_dom_users;
86
87                 *info = talloc_realloc(
88                         mem_ctx, *info, 
89                         (*num_entries) * sizeof(WINBIND_USERINFO));
90
91                 if (!(*info)) {
92                         result = NT_STATUS_NO_MEMORY;
93                         talloc_destroy(ctx2);
94                         goto done;
95                 }
96
97                 for (j = 0; j < num_dom_users; i++, j++) {
98                         (*info)[i].acct_name = 
99                                 talloc_strdup(mem_ctx, dom_users[j]);
100                         (*info)[i].full_name = talloc_strdup(mem_ctx, "");
101                         (*info)[i].user_sid = rid_to_talloced_sid(domain, mem_ctx, dom_rids[j]);
102                         /* For the moment we set the primary group for
103                            every user to be the Domain Users group.
104                            There are serious problems with determining
105                            the actual primary group for large domains.
106                            This should really be made into a 'winbind
107                            force group' smb.conf parameter or
108                            something like that. */
109                         (*info)[i].group_sid 
110                                 = rid_to_talloced_sid(domain, 
111                                                       mem_ctx, 
112                                                       DOMAIN_GROUP_RID_USERS);
113                 }
114
115                 talloc_destroy(ctx2);
116
117         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
118
119  done:
120
121         if (got_dom_pol)
122                 cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
123
124         return result;
125 }
126
127 /* list all domain groups */
128 static NTSTATUS enum_dom_groups(struct winbindd_domain *domain,
129                                 TALLOC_CTX *mem_ctx,
130                                 uint32 *num_entries, 
131                                 struct acct_info **info)
132 {
133         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
134         CLI_POLICY_HND *hnd;
135         POLICY_HND dom_pol;
136         NTSTATUS status;
137         uint32 start = 0;
138         int retry;
139         NTSTATUS result;
140
141         *num_entries = 0;
142         *info = NULL;
143
144         DEBUG(3,("rpc: enum_dom_groups\n"));
145
146         retry = 0;
147         do {
148                 if (!NT_STATUS_IS_OK(result = cm_get_sam_handle(domain->name, &hnd)))
149                         return result;
150
151                 status = cli_samr_open_domain(hnd->cli, mem_ctx,
152                                               &hnd->pol, des_access, &domain->sid, &dom_pol);
153         } while (!NT_STATUS_IS_OK(status) && (retry++ < 1) && hnd && hnd->cli && hnd->cli->fd == -1);
154
155         if (!NT_STATUS_IS_OK(status))
156                 return status;
157
158         do {
159                 struct acct_info *info2 = NULL;
160                 uint32 count = 0;
161                 TALLOC_CTX *mem_ctx2;
162
163                 mem_ctx2 = talloc_init("enum_dom_groups[rpc]");
164
165                 /* start is updated by this call. */
166                 status = cli_samr_enum_dom_groups(hnd->cli, mem_ctx2, &dom_pol,
167                                                   &start,
168                                                   0xFFFF, /* buffer size? */
169                                                   &info2, &count);
170
171                 if (!NT_STATUS_IS_OK(status) && 
172                     !NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
173                         talloc_destroy(mem_ctx2);
174                         break;
175                 }
176
177                 (*info) = talloc_realloc(mem_ctx, *info, 
178                                          sizeof(**info) * ((*num_entries) + count));
179                 if (! *info) {
180                         talloc_destroy(mem_ctx2);
181                         cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
182                         return NT_STATUS_NO_MEMORY;
183                 }
184
185                 memcpy(&(*info)[*num_entries], info2, count*sizeof(*info2));
186                 (*num_entries) += count;
187                 talloc_destroy(mem_ctx2);
188         } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
189
190         cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
191
192         return status;
193 }
194
195 /* List all domain groups */
196
197 static NTSTATUS enum_local_groups(struct winbindd_domain *domain,
198                                 TALLOC_CTX *mem_ctx,
199                                 uint32 *num_entries, 
200                                 struct acct_info **info)
201 {
202         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
203         CLI_POLICY_HND *hnd;
204         POLICY_HND dom_pol;
205         NTSTATUS result;
206         int retry;
207
208         *num_entries = 0;
209         *info = NULL;
210
211         retry = 0;
212         do {
213                 if ( !NT_STATUS_IS_OK(result = cm_get_sam_handle(domain->name, &hnd)) )
214                         return result;
215
216                 result = cli_samr_open_domain( hnd->cli, mem_ctx, &hnd->pol, 
217                                                 des_access, &domain->sid, &dom_pol);
218         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) && hnd && hnd->cli && hnd->cli->fd == -1);
219
220         if ( !NT_STATUS_IS_OK(result))
221                 return result;
222
223         do {
224                 struct acct_info *info2 = NULL;
225                 uint32 count = 0, start = *num_entries;
226                 TALLOC_CTX *mem_ctx2;
227
228                 mem_ctx2 = talloc_init("enum_dom_local_groups[rpc]");
229
230                 result = cli_samr_enum_als_groups( hnd->cli, mem_ctx2, &dom_pol,
231                                           &start, 0xFFFF, &info2, &count);
232                                           
233                 if ( !NT_STATUS_IS_OK(result) 
234                         && !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES) ) 
235                 {
236                         talloc_destroy(mem_ctx2);
237                         break;
238                 }
239
240                 (*info) = talloc_realloc(mem_ctx, *info, 
241                                          sizeof(**info) * ((*num_entries) + count));
242                 if (! *info) {
243                         talloc_destroy(mem_ctx2);
244                         cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
245                         return NT_STATUS_NO_MEMORY;
246                 }
247
248                 memcpy(&(*info)[*num_entries], info2, count*sizeof(*info2));
249                 (*num_entries) += count;
250                 talloc_destroy(mem_ctx2);
251         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
252
253         cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
254
255         return result;
256 }
257
258 /* convert a single name to a sid in a domain */
259 static NTSTATUS name_to_sid(struct winbindd_domain *domain,
260                             TALLOC_CTX *mem_ctx,
261                             const char *name,
262                             DOM_SID *sid,
263                             enum SID_NAME_USE *type)
264 {
265         CLI_POLICY_HND *hnd;
266         NTSTATUS result;
267         DOM_SID *sids = NULL;
268         uint32 *types = NULL;
269         const char *full_name;
270         int retry;
271
272         DEBUG(3,("rpc: name_to_sid name=%s\n", name));
273
274         full_name = talloc_asprintf(mem_ctx, "%s\\%s", domain->name, name);
275         
276         if (!full_name) {
277                 DEBUG(0, ("talloc_asprintf failed!\n"));
278                 return NT_STATUS_NO_MEMORY;
279         }
280
281         DEBUG(3,("name_to_sid [rpc] %s for domain %s\n", name, domain->name ));
282
283         retry = 0;
284         do {
285                 if (!NT_STATUS_IS_OK(result = cm_get_lsa_handle(domain->name, &hnd))) {
286                         return result;
287                 }
288         
289                 result = cli_lsa_lookup_names(hnd->cli, mem_ctx, &hnd->pol, 1, 
290                                               &full_name, &sids, &types);
291         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) &&
292                         hnd && hnd->cli && hnd->cli->fd == -1);
293         
294         /* Return rid and type if lookup successful */
295
296         if (NT_STATUS_IS_OK(result)) {
297                 sid_copy(sid, &sids[0]);
298                 *type = (enum SID_NAME_USE)types[0];
299         }
300
301         return result;
302 }
303
304 /*
305   convert a domain SID to a user or group name
306 */
307 static NTSTATUS sid_to_name(struct winbindd_domain *domain,
308                             TALLOC_CTX *mem_ctx,
309                             DOM_SID *sid,
310                             char **name,
311                             enum SID_NAME_USE *type)
312 {
313         CLI_POLICY_HND *hnd;
314         char **domains;
315         char **names;
316         uint32 *types;
317         NTSTATUS result;
318         int retry;
319
320         DEBUG(3,("sid_to_name [rpc] %s for domain %s\n", sid_string_static(sid),
321                         domain->name ));
322
323         retry = 0;
324         do {
325                 if (!NT_STATUS_IS_OK(result = cm_get_lsa_handle(domain->name, &hnd)))
326                         return result;
327         
328                 result = cli_lsa_lookup_sids(hnd->cli, mem_ctx, &hnd->pol,
329                                              1, sid, &domains, &names, &types);
330         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) &&
331                         hnd && hnd->cli && hnd->cli->fd == -1);
332
333         if (NT_STATUS_IS_OK(result)) {
334                 *type = (enum SID_NAME_USE)types[0];
335                 *name = names[0];
336                 DEBUG(5,("Mapped sid to [%s]\\[%s]\n", domains[0], *name));
337
338                 /* Paranoia */
339                 if (strcasecmp(domain->name, domains[0]) != 0) {
340                         DEBUG(1, ("domain name from domain param and PDC lookup return differ! (%s vs %s)\n", domain->name, domains[0]));
341                         return NT_STATUS_UNSUCCESSFUL;
342                 }
343         }
344
345         return result;
346 }
347
348 /* Lookup user information from a rid or username. */
349 static NTSTATUS query_user(struct winbindd_domain *domain, 
350                            TALLOC_CTX *mem_ctx, 
351                            DOM_SID *user_sid, 
352                            WINBIND_USERINFO *user_info)
353 {
354         CLI_POLICY_HND *hnd = NULL;
355         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
356         POLICY_HND dom_pol, user_pol;
357         BOOL got_dom_pol = False, got_user_pol = False;
358         SAM_USERINFO_CTR *ctr;
359         int retry;
360         fstring sid_string;
361         uint32 user_rid;
362         NET_USER_INFO_3 *user;
363
364         DEBUG(3,("rpc: query_user rid=%s\n", sid_to_string(sid_string, user_sid)));
365         if (!sid_peek_check_rid(&domain->sid, user_sid, &user_rid)) {
366                 goto done;
367         }
368         
369         /* try netsamlogon cache first */
370                         
371         if ( (user = netsamlogon_cache_get( mem_ctx, user_sid )) != NULL ) 
372         {
373                                 
374                 DEBUG(5,("query_user: Cache lookup succeeded for %s\n", 
375                         sid_string_static(user_sid)));
376                         
377                 user_info->user_sid  = rid_to_talloced_sid( domain, mem_ctx, user_rid );
378                 user_info->group_sid = rid_to_talloced_sid( domain, mem_ctx, user->group_rid );
379                                 
380                 user_info->acct_name = unistr2_tdup(mem_ctx, &user->uni_user_name);
381                 user_info->full_name = unistr2_tdup(mem_ctx, &user->uni_full_name);
382                                                                 
383                 SAFE_FREE(user);
384                                 
385                 return NT_STATUS_OK;
386         }
387         
388         /* no cache; hit the wire */
389                 
390         retry = 0;
391         do {
392                 /* Get sam handle; if we fail here there is no hope */
393                 
394                 if (!NT_STATUS_IS_OK(result = cm_get_sam_handle(domain->name, &hnd))) 
395                         goto done;
396                         
397                 /* Get domain handle */
398
399                 result = cli_samr_open_domain(hnd->cli, mem_ctx, &hnd->pol,
400                                               SEC_RIGHTS_MAXIMUM_ALLOWED, 
401                                               &domain->sid, &dom_pol);
402         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) &&
403                         hnd && hnd->cli && hnd->cli->fd == -1);
404
405         if (!NT_STATUS_IS_OK(result))
406                 goto done;
407
408         got_dom_pol = True;
409
410         /* Get user handle */
411         result = cli_samr_open_user(hnd->cli, mem_ctx, &dom_pol,
412                                     SEC_RIGHTS_MAXIMUM_ALLOWED, user_rid, &user_pol);
413
414         if (!NT_STATUS_IS_OK(result))
415                 goto done;
416
417         got_user_pol = True;
418
419         /* Get user info */
420         result = cli_samr_query_userinfo(hnd->cli, mem_ctx, &user_pol, 
421                                          0x15, &ctr);
422
423         if (!NT_STATUS_IS_OK(result))
424                 goto done;
425
426         cli_samr_close(hnd->cli, mem_ctx, &user_pol);
427         got_user_pol = False;
428
429         user_info->user_sid = rid_to_talloced_sid(domain, mem_ctx, user_rid);
430         user_info->group_sid = rid_to_talloced_sid(domain, mem_ctx, ctr->info.id21->group_rid);
431         user_info->acct_name = unistr2_tdup(mem_ctx, 
432                                             &ctr->info.id21->uni_user_name);
433         user_info->full_name = unistr2_tdup(mem_ctx, 
434                                             &ctr->info.id21->uni_full_name);
435
436  done:
437         /* Clean up policy handles */
438         if (got_user_pol)
439                 cli_samr_close(hnd->cli, mem_ctx, &user_pol);
440
441         if (got_dom_pol)
442                 cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
443
444         return result;
445 }                                   
446
447 /* Lookup groups a user is a member of.  I wish Unix had a call like this! */
448 static NTSTATUS lookup_usergroups(struct winbindd_domain *domain,
449                                   TALLOC_CTX *mem_ctx,
450                                   DOM_SID *user_sid,
451                                   uint32 *num_groups, DOM_SID ***user_grpsids)
452 {
453         CLI_POLICY_HND *hnd;
454         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
455         POLICY_HND dom_pol, user_pol;
456         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
457         BOOL got_dom_pol = False, got_user_pol = False;
458         DOM_GID *user_groups;
459         unsigned int i;
460         unsigned int retry;
461         fstring sid_string;
462         uint32 user_rid;
463         NET_USER_INFO_3 *user;
464
465         DEBUG(3,("rpc: lookup_usergroups sid=%s\n", sid_to_string(sid_string, user_sid)));
466
467         *num_groups = 0;
468         *user_grpsids = NULL;
469
470         /* so lets see if we have a cached user_info_3 */
471         
472         if ( (user = netsamlogon_cache_get( mem_ctx, user_sid )) != NULL )
473         {
474                 DEBUG(5,("query_user: Cache lookup succeeded for %s\n", 
475                         sid_string_static(user_sid)));
476                         
477                 *num_groups = user->num_groups;
478                                 
479                 (*user_grpsids) = talloc(mem_ctx, sizeof(DOM_SID*) * (*num_groups));
480                 for (i=0;i<(*num_groups);i++) {
481                         (*user_grpsids)[i] = rid_to_talloced_sid(domain, mem_ctx, user->gids[i].g_rid);
482                 }
483                                 
484                 SAFE_FREE(user);
485                                 
486                 return NT_STATUS_OK;
487         }
488
489         /* no cache; hit the wire */
490         
491         retry = 0;
492         do {
493                 /* Get sam handle; if we fail here there is no hope */
494                 
495                 if (!NT_STATUS_IS_OK(result = cm_get_sam_handle(domain->name, &hnd)))           
496                         goto done;
497
498                 /* Get domain handle */
499                 
500                 result = cli_samr_open_domain(hnd->cli, mem_ctx, &hnd->pol,
501                                               des_access, &domain->sid, &dom_pol);
502         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) && 
503                         hnd && hnd->cli && hnd->cli->fd == -1);
504
505         if (!NT_STATUS_IS_OK(result))
506                 goto done;
507
508         got_dom_pol = True;
509
510
511         if (!sid_peek_check_rid(&domain->sid, user_sid, &user_rid)) {
512                 goto done;
513         }
514
515         /* Get user handle */
516         result = cli_samr_open_user(hnd->cli, mem_ctx, &dom_pol,
517                                         des_access, user_rid, &user_pol);
518
519         if (!NT_STATUS_IS_OK(result))
520                 goto done;
521
522         got_user_pol = True;
523
524         /* Query user rids */
525         result = cli_samr_query_usergroups(hnd->cli, mem_ctx, &user_pol, 
526                                            num_groups, &user_groups);
527
528         if (!NT_STATUS_IS_OK(result) || (*num_groups) == 0)
529                 goto done;
530
531         (*user_grpsids) = talloc(mem_ctx, sizeof(DOM_SID*) * (*num_groups));
532         if (!(*user_grpsids)) {
533                 result = NT_STATUS_NO_MEMORY;
534                 goto done;
535         }
536
537         for (i=0;i<(*num_groups);i++) {
538                 (*user_grpsids)[i] = rid_to_talloced_sid(domain, mem_ctx, user_groups[i].g_rid);
539         }
540         
541  done:
542         /* Clean up policy handles */
543         if (got_user_pol)
544                 cli_samr_close(hnd->cli, mem_ctx, &user_pol);
545
546         if (got_dom_pol)
547                 cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
548
549         return result;
550 }
551
552
553 /* Lookup group membership given a rid.   */
554 static NTSTATUS lookup_groupmem(struct winbindd_domain *domain,
555                                 TALLOC_CTX *mem_ctx,
556                                 DOM_SID *group_sid, uint32 *num_names, 
557                                 DOM_SID ***sid_mem, char ***names, 
558                                 uint32 **name_types)
559 {
560         CLI_POLICY_HND *hnd = NULL;
561         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
562         uint32 i, total_names = 0;
563         POLICY_HND dom_pol, group_pol;
564         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
565         BOOL got_dom_pol = False, got_group_pol = False;
566         uint32 *rid_mem = NULL;
567         uint32 group_rid;
568         int retry;
569         unsigned int j;
570         fstring sid_string;
571
572         DEBUG(10,("rpc: lookup_groupmem %s sid=%s\n", domain->name, sid_to_string(sid_string, group_sid)));
573
574         if (!sid_peek_check_rid(&domain->sid, group_sid, &group_rid)) {
575                 goto done;
576         }
577
578         *num_names = 0;
579
580         retry = 0;
581         do {
582                 /* Get sam handle */
583                 if (!NT_STATUS_IS_OK(result = cm_get_sam_handle(domain->name, &hnd)))
584                         goto done;
585
586                 /* Get domain handle */
587
588                 result = cli_samr_open_domain(hnd->cli, mem_ctx, &hnd->pol,
589                                 des_access, &domain->sid, &dom_pol);
590         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) && hnd && hnd->cli && hnd->cli->fd == -1);
591
592         if (!NT_STATUS_IS_OK(result))
593                 goto done;
594
595         got_dom_pol = True;
596
597         /* Get group handle */
598
599         result = cli_samr_open_group(hnd->cli, mem_ctx, &dom_pol,
600                                      des_access, group_rid, &group_pol);
601
602         if (!NT_STATUS_IS_OK(result))
603                 goto done;
604
605         got_group_pol = True;
606
607         /* Step #1: Get a list of user rids that are the members of the
608            group. */
609
610         result = cli_samr_query_groupmem(hnd->cli, mem_ctx,
611                                          &group_pol, num_names, &rid_mem,
612                                          name_types);
613
614         if (!NT_STATUS_IS_OK(result))
615                 goto done;
616
617         /* Step #2: Convert list of rids into list of usernames.  Do this
618            in bunches of ~1000 to avoid crashing NT4.  It looks like there
619            is a buffer overflow or something like that lurking around
620            somewhere. */
621
622 #define MAX_LOOKUP_RIDS 900
623
624         *names = talloc_zero(mem_ctx, *num_names * sizeof(char *));
625         *name_types = talloc_zero(mem_ctx, *num_names * sizeof(uint32));
626         *sid_mem = talloc_zero(mem_ctx, *num_names * sizeof(DOM_SID *));
627
628         for (j=0;j<(*num_names);j++) {
629                 (*sid_mem)[j] = rid_to_talloced_sid(domain, mem_ctx, (rid_mem)[j]);
630         }
631         
632         if (*num_names>0 && (!*names || !*name_types)) {
633                 result = NT_STATUS_NO_MEMORY;
634                 goto done;
635         }
636
637         for (i = 0; i < *num_names; i += MAX_LOOKUP_RIDS) {
638                 int num_lookup_rids = MIN(*num_names - i, MAX_LOOKUP_RIDS);
639                 uint32 tmp_num_names = 0;
640                 char **tmp_names = NULL;
641                 uint32 *tmp_types = NULL;
642
643                 /* Lookup a chunk of rids */
644
645                 result = cli_samr_lookup_rids(hnd->cli, mem_ctx,
646                                               &dom_pol, 1000, /* flags */
647                                               num_lookup_rids,
648                                               &rid_mem[i],
649                                               &tmp_num_names,
650                                               &tmp_names, &tmp_types);
651
652                 /* see if we have a real error (and yes the STATUS_SOME_UNMAPPED is
653                    the one returned from 2k) */
654                 
655                 if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) != NT_STATUS_V(STATUS_SOME_UNMAPPED))
656                         goto done;
657                         
658                 /* Copy result into array.  The talloc system will take
659                    care of freeing the temporary arrays later on. */
660
661                 memcpy(&(*names)[i], tmp_names, sizeof(char *) * 
662                        tmp_num_names);
663
664                 memcpy(&(*name_types)[i], tmp_types, sizeof(uint32) *
665                        tmp_num_names);
666                 
667                 total_names += tmp_num_names;
668         }
669
670         *num_names = total_names;
671
672         result = NT_STATUS_OK;
673         
674 done:
675         if (got_group_pol)
676                 cli_samr_close(hnd->cli, mem_ctx, &group_pol);
677
678         if (got_dom_pol)
679                 cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
680
681         return result;
682 }
683
684 #ifdef HAVE_LDAP
685
686 #include <ldap.h>
687
688 static SIG_ATOMIC_T gotalarm;
689
690 /***************************************************************
691  Signal function to tell us we timed out.
692 ****************************************************************/
693
694 static void gotalarm_sig(void)
695 {
696         gotalarm = 1;
697 }
698
699 static LDAP *ldap_open_with_timeout(const char *server, int port, unsigned int to)
700 {
701         LDAP *ldp = NULL;
702
703         /* Setup timeout */
704         gotalarm = 0;
705         CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
706         alarm(to);
707         /* End setup timeout. */
708
709         ldp = ldap_open(server, port);
710
711         /* Teardown timeout. */
712         CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
713         alarm(0);
714
715         return ldp;
716 }
717
718 static int get_ldap_seq(const char *server, int port, uint32 *seq)
719 {
720         int ret = -1;
721         struct timeval to;
722         char *attrs[] = {"highestCommittedUSN", NULL};
723         LDAPMessage *res = NULL;
724         char **values = NULL;
725         LDAP *ldp = NULL;
726
727         *seq = DOM_SEQUENCE_NONE;
728
729         /*
730          * 10 second timeout on open. This is needed as the search timeout
731          * doesn't seem to apply to doing an open as well. JRA.
732          */
733
734         if ((ldp = ldap_open_with_timeout(server, port, 10)) == NULL)
735                 return -1;
736
737         /* Timeout if no response within 20 seconds. */
738         to.tv_sec = 10;
739         to.tv_usec = 0;
740
741         if (ldap_search_st(ldp, "", LDAP_SCOPE_BASE, "(objectclass=*)", &attrs[0], 0, &to, &res))
742                 goto done;
743
744         if (ldap_count_entries(ldp, res) != 1)
745                 goto done;
746
747         values = ldap_get_values(ldp, res, "highestCommittedUSN");
748         if (!values || !values[0])
749                 goto done;
750
751         *seq = atoi(values[0]);
752         ret = 0;
753
754   done:
755
756         if (values)
757                 ldap_value_free(values);
758         if (res)
759                 ldap_msgfree(res);
760         if (ldp)
761                 ldap_unbind(ldp);
762         return ret;
763 }
764
765 /**********************************************************************
766  Get the sequence number for a Windows AD native mode domain using
767  LDAP queries
768 **********************************************************************/
769
770 int get_ldap_sequence_number( const char* domain, uint32 *seq)
771 {
772         int ret = -1;
773         int i, port = LDAP_PORT;
774         struct ip_service *ip_list = NULL;
775         int count;
776         
777         if ( !get_sorted_dc_list(domain, &ip_list, &count, False) ) {
778                 DEBUG(3, ("Could not look up dc's for domain %s\n", domain));
779                 return False;
780         }
781
782         /* Finally return first DC that we can contact */
783
784         for (i = 0; i < count; i++) {
785                 fstring ipstr;
786
787                 /* since the is an LDAP lookup, default to the LDAP_PORT is not set */
788                 port = (ip_list[i].port!= PORT_NONE) ? ip_list[i].port : LDAP_PORT;
789
790                 fstrcpy( ipstr, inet_ntoa(ip_list[i].ip) );
791                 
792                 if (is_zero_ip(ip_list[i].ip))
793                         continue;
794
795                 if ( (ret = get_ldap_seq( ipstr, port,  seq)) == 0 )
796                         goto done;
797
798                 /* add to failed connection cache */
799                 add_failed_connection_entry( domain, ipstr, NT_STATUS_UNSUCCESSFUL );
800         }
801
802 done:
803         if ( ret == 0 ) {
804                 DEBUG(3, ("get_ldap_sequence_number: Retrieved sequence number for Domain (%s) from DC (%s:%d)\n", 
805                         domain, inet_ntoa(ip_list[i].ip), port));
806         }
807
808         SAFE_FREE(ip_list);
809
810         return ret;
811 }
812
813 #endif /* HAVE_LDAP */
814
815 /* find the sequence number for a domain */
816 static NTSTATUS sequence_number(struct winbindd_domain *domain, uint32 *seq)
817 {
818         TALLOC_CTX *mem_ctx;
819         CLI_POLICY_HND *hnd;
820         SAM_UNK_CTR ctr;
821         uint16 switch_value = 2;
822         NTSTATUS result;
823         POLICY_HND dom_pol;
824         BOOL got_dom_pol = False;
825         uint32 des_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
826         int retry;
827
828         DEBUG(10,("rpc: fetch sequence_number for %s\n", domain->name));
829
830         *seq = DOM_SEQUENCE_NONE;
831
832         if (!(mem_ctx = talloc_init("sequence_number[rpc]")))
833                 return NT_STATUS_NO_MEMORY;
834
835         retry = 0;
836         do {
837 #ifdef HAVE_LDAP
838                 if ( domain->native_mode ) 
839                 {
840                         DEBUG(8,("using get_ldap_seq() to retrieve the sequence number\n"));
841
842                         if ( get_ldap_sequence_number( domain->name, seq ) == 0 ) {                     
843                                 result = NT_STATUS_OK;
844                                 DEBUG(10,("domain_sequence_number: LDAP for domain %s is %u\n",
845                                         domain->name, *seq));
846                                 goto done;
847                         }
848
849                         DEBUG(10,("domain_sequence_number: failed to get LDAP sequence number for domain %s\n",
850                         domain->name ));
851                 }
852 #endif /* HAVE_LDAP */
853                 /* Get sam handle */
854                 if (!NT_STATUS_IS_OK(result = cm_get_sam_handle(domain->name, &hnd)))
855                         goto done;
856
857                 /* Get domain handle */
858                 result = cli_samr_open_domain(hnd->cli, mem_ctx, &hnd->pol, 
859                                       des_access, &domain->sid, &dom_pol);
860         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) && hnd && hnd->cli && hnd->cli->fd == -1);
861
862         if (!NT_STATUS_IS_OK(result))
863                 goto done;
864
865         got_dom_pol = True;
866
867         /* Query domain info */
868
869         result = cli_samr_query_dom_info(hnd->cli, mem_ctx, &dom_pol,
870                                          switch_value, &ctr);
871
872         if (NT_STATUS_IS_OK(result)) {
873                 *seq = ctr.info.inf2.seq_num;
874                 DEBUG(10,("domain_sequence_number: for domain %s is %u\n", domain->name, (unsigned)*seq));
875         } else {
876                 DEBUG(10,("domain_sequence_number: failed to get sequence number (%u) for domain %s\n",
877                         (unsigned)*seq, domain->name ));
878         }
879
880   done:
881
882         if (got_dom_pol)
883                 cli_samr_close(hnd->cli, mem_ctx, &dom_pol);
884
885         talloc_destroy(mem_ctx);
886
887         return result;
888 }
889
890 /* get a list of trusted domains */
891 static NTSTATUS trusted_domains(struct winbindd_domain *domain,
892                                 TALLOC_CTX *mem_ctx,
893                                 uint32 *num_domains,
894                                 char ***names,
895                                 char ***alt_names,
896                                 DOM_SID **dom_sids)
897 {
898         CLI_POLICY_HND *hnd;
899         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
900         uint32 enum_ctx = 0;
901         int retry;
902
903         DEBUG(3,("rpc: trusted_domains\n"));
904
905         *num_domains = 0;
906         *alt_names = NULL;
907
908         retry = 0;
909         do {
910                 if (!NT_STATUS_IS_OK(result = cm_get_lsa_handle(lp_workgroup(), &hnd)))
911                         goto done;
912
913                 result = cli_lsa_enum_trust_dom(hnd->cli, mem_ctx,
914                                                 &hnd->pol, &enum_ctx,
915                                                 num_domains, names, dom_sids);
916         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) &&  hnd && hnd->cli && hnd->cli->fd == -1);
917
918 done:
919         return result;
920 }
921
922 /* find the domain sid for a domain */
923 static NTSTATUS domain_sid(struct winbindd_domain *domain, DOM_SID *sid)
924 {
925         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
926         TALLOC_CTX *mem_ctx;
927         CLI_POLICY_HND *hnd;
928         fstring level5_dom;
929         int retry;
930
931         DEBUG(3,("rpc: domain_sid\n"));
932
933         if (!(mem_ctx = talloc_init("domain_sid[rpc]")))
934                 return NT_STATUS_NO_MEMORY;
935
936         retry = 0;
937         do {
938                 /* Get lsa handle */
939                 if (!NT_STATUS_IS_OK(result = cm_get_lsa_handle(domain->name, &hnd)))
940                         goto done;
941
942                 result = cli_lsa_query_info_policy(hnd->cli, mem_ctx,
943                                            &hnd->pol, 0x05, level5_dom, sid);
944         } while (!NT_STATUS_IS_OK(result) && (retry++ < 1) &&  hnd && hnd->cli && hnd->cli->fd == -1);
945
946 done:
947         talloc_destroy(mem_ctx);
948         return result;
949 }
950
951 /* find alternate names list for the domain - none for rpc */
952 static NTSTATUS alternate_name(struct winbindd_domain *domain)
953 {
954         return NT_STATUS_OK;
955 }
956
957
958 /* the rpc backend methods are exposed via this structure */
959 struct winbindd_methods msrpc_methods = {
960         False,
961         query_user_list,
962         enum_dom_groups,
963         enum_local_groups,
964         name_to_sid,
965         sid_to_name,
966         query_user,
967         lookup_usergroups,
968         lookup_groupmem,
969         sequence_number,
970         trusted_domains,
971         domain_sid,
972         alternate_name
973 };