s3-talloc Change TALLOC_ZERO_P() to talloc_zero()
[nivanova/samba-autobuild/.git] / source3 / winbindd / idmap_adex / gc_util.c
1 /*
2  * idmap_adex: Global Catalog search interface
3  *
4  * Copyright (C) Gerald (Jerry) Carter 2007-2008
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 #include "includes.h"
22 #include "ads.h"
23 #include "idmap.h"
24 #include "idmap_adex.h"
25 #include "libads/cldap.h"
26 #include "../libcli/ldap/ldap_ndr.h"
27
28 #undef DBGC_CLASS
29 #define DBGC_CLASS DBGC_IDMAP
30
31 static struct gc_info *_gc_server_list = NULL;
32
33
34 /**********************************************************************
35  *********************************************************************/
36
37 static struct gc_info *gc_list_head(void)
38 {
39         return _gc_server_list;
40 }
41
42 /**********************************************************************
43  Checks if either of the domains is a subdomain of the other
44  *********************************************************************/
45
46 static bool is_subdomain(const char* a, const char *b)
47 {
48         char *s;
49         TALLOC_CTX *frame = talloc_stackframe();
50         char *x, *y;
51         bool ret = false;
52
53         /* Trivial cases */
54
55         if (!a && !b)
56                 return true;
57
58         if (!a || !b)
59                 return false;
60
61         /* Normalize the case */
62
63         x = talloc_strdup(frame, a);
64         y = talloc_strdup(frame, b);
65         if (!x || !y) {
66                 ret = false;
67                 goto done;
68         }
69
70         strupper_m(x);
71         strupper_m(y);
72
73         /* Exact match */
74
75         if (strcmp(x, y) == 0) {
76                 ret = true;
77                 goto done;
78         }
79
80         /* Check for trailing substrings */
81
82         s = strstr_m(x, y);
83         if (s && (strlen(s) == strlen(y))) {
84                 ret = true;
85                 goto done;
86         }
87
88         s = strstr_m(y, x);
89         if (s && (strlen(s) == strlen(x))) {
90                 ret = true;
91                 goto done;
92         }
93
94 done:
95         talloc_destroy(frame);
96
97         return ret;
98 }
99
100 /**********************************************************************
101  *********************************************************************/
102
103  NTSTATUS gc_find_forest_root(struct gc_info *gc, const char *domain)
104 {
105         ADS_STRUCT *ads = NULL;
106         ADS_STATUS ads_status;
107         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
108         struct NETLOGON_SAM_LOGON_RESPONSE_EX cldap_reply;
109         TALLOC_CTX *frame = talloc_stackframe();
110         struct sockaddr_storage ss;
111
112         if (!gc || !domain) {
113                 return NT_STATUS_INVALID_PARAMETER;
114         }
115
116         ZERO_STRUCT(cldap_reply);
117
118         ads = ads_init(domain, NULL, NULL);
119         BAIL_ON_PTR_ERROR(ads, nt_status);
120
121         ads->auth.flags = ADS_AUTH_NO_BIND;
122         ads_status = ads_connect(ads);
123         if (!ADS_ERR_OK(ads_status)) {
124                 DEBUG(4, ("find_forest_root: ads_connect(%s) failed! (%s)\n",
125                           domain, ads_errstr(ads_status)));
126         }
127         nt_status = ads_ntstatus(ads_status);
128         BAIL_ON_NTSTATUS_ERROR(nt_status);
129
130         if (!resolve_name(ads->config.ldap_server_name, &ss, 0x20, true)) {
131                 DEBUG(5,("gc_find_forest_root: unable to resolve name %s\n",
132                          ads->config.ldap_server_name));
133                 nt_status = NT_STATUS_IO_TIMEOUT;
134                 /* This matches the old code which did the resolve in
135                  * ads_cldap_netlogon_5 */
136                 BAIL_ON_NTSTATUS_ERROR(nt_status);
137         }
138
139         if (!ads_cldap_netlogon_5(frame,
140                                   &ss,
141                                   ads->config.realm,
142                                   &cldap_reply))
143         {
144                 DEBUG(4,("find_forest_root: Failed to get a CLDAP reply from %s!\n",
145                          ads->server.ldap_server));
146                 nt_status = NT_STATUS_IO_TIMEOUT;
147                 BAIL_ON_NTSTATUS_ERROR(nt_status);
148         }
149
150         gc->forest_name = talloc_strdup(gc, cldap_reply.forest);
151         BAIL_ON_PTR_ERROR(gc->forest_name, nt_status);
152
153 done:
154         if (ads) {
155                 ads_destroy(&ads);
156         }
157
158         return nt_status;
159 }
160
161 /**********************************************************************
162  *********************************************************************/
163
164 static NTSTATUS gc_add_forest(const char *domain)
165 {
166         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
167         struct gc_info *gc = NULL;
168         struct gc_info *find_gc = NULL;
169         char *dn;
170         ADS_STRUCT *ads = NULL;
171         struct likewise_cell *primary_cell = NULL;
172
173         primary_cell = cell_list_head();
174         if (!primary_cell) {
175                 nt_status = NT_STATUS_INVALID_SERVER_STATE;
176                 BAIL_ON_NTSTATUS_ERROR(nt_status);
177         }
178
179         /* Check for duplicates based on domain name first as this
180            requires no connection */
181
182         find_gc = gc_list_head();
183         while (find_gc) {
184                 if (strequal (find_gc->forest_name, domain))
185                         break;
186                 find_gc = find_gc->next;
187         }
188
189         if (find_gc) {
190                 DEBUG(10,("gc_add_forest: %s already in list\n", find_gc->forest_name));
191                 return NT_STATUS_OK;
192         }
193
194         if ((gc = talloc_zero(NULL, struct gc_info)) == NULL) {
195                 nt_status = NT_STATUS_NO_MEMORY;
196                 BAIL_ON_NTSTATUS_ERROR(nt_status);
197         }
198
199         /* Query the rootDSE for the forest root naming conect first.
200            Check that the a GC server for the forest has not already
201            been added */
202
203         nt_status = gc_find_forest_root(gc, domain);
204         BAIL_ON_NTSTATUS_ERROR(nt_status);
205
206         find_gc = gc_list_head();
207         while (find_gc) {
208                 if (strequal (find_gc->forest_name, gc->forest_name))
209                         break;
210                 find_gc = find_gc->next;
211         }
212
213         if (find_gc) {
214                 DEBUG(10,("gc_add_forest: Forest %s already in list\n",
215                           find_gc->forest_name));
216                 return NT_STATUS_OK;
217         }
218
219         /* Not found, so add it here.  Make sure we connect to
220            a DC in _this_ domain and not the forest root. */
221
222         dn = ads_build_dn(gc->forest_name);
223         BAIL_ON_PTR_ERROR(dn, nt_status);
224
225         gc->search_base = talloc_strdup(gc, dn);
226         SAFE_FREE(dn);
227         BAIL_ON_PTR_ERROR(gc->search_base, nt_status);
228
229 #if 0
230         /* Can't use cell_connect_dn() here as there is no way to
231            specifiy the LWCELL_FLAG_GC_CELL flag setting for cell_connect() */
232
233         nt_status = cell_connect_dn(&gc->forest_cell, gc->search_base);
234         BAIL_ON_NTSTATUS_ERROR(nt_status);
235 #else
236
237         gc->forest_cell = cell_new();
238         BAIL_ON_PTR_ERROR(gc->forest_cell, nt_status);
239
240         /* Set the DNS domain, dn, etc ... and add it to the list */
241
242         cell_set_dns_domain(gc->forest_cell, gc->forest_name);
243         cell_set_dn(gc->forest_cell, gc->search_base);
244         cell_set_flags(gc->forest_cell, LWCELL_FLAG_GC_CELL);
245 #endif
246
247         /* It is possible to belong to a non-forest cell and a
248            non-provisioned forest (at our domain levele). In that
249            case, we should just inherit the flags from our primary
250            cell since the GC searches will match our own schema
251            model. */
252
253         if (strequal(primary_cell->forest_name, gc->forest_name)
254             || is_subdomain(primary_cell->dns_domain, gc->forest_name))
255         {
256                 cell_set_flags(gc->forest_cell, cell_flags(primary_cell));
257         } else {
258                 /* outside of our domain */
259
260                 nt_status = cell_connect(gc->forest_cell);
261                 BAIL_ON_NTSTATUS_ERROR(nt_status);
262
263                 nt_status = cell_lookup_settings(gc->forest_cell);
264                 BAIL_ON_NTSTATUS_ERROR(nt_status);
265
266                 /* Drop the connection now that we have the settings */
267
268                 ads = cell_connection(gc->forest_cell);
269                 ads_destroy(&ads);
270                 cell_set_connection(gc->forest_cell, NULL);
271         }
272
273         DLIST_ADD_END(_gc_server_list, gc, struct gc_info*);
274
275         DEBUG(10,("gc_add_forest: Added %s to Global Catalog list of servers\n",
276                   gc->forest_name));
277
278         nt_status = NT_STATUS_OK;
279
280 done:
281         if (!NT_STATUS_IS_OK(nt_status)) {
282                 talloc_destroy(gc);
283                 DEBUG(3,("LWI: Failed to add new GC connection for %s (%s)\n",
284                          domain, nt_errstr(nt_status)));
285         }
286
287         return nt_status;
288 }
289
290 /**********************************************************************
291  *********************************************************************/
292
293 static void gc_server_list_destroy(void)
294 {
295         struct gc_info *gc = gc_list_head();
296
297         while (gc) {
298                 struct gc_info *p = gc->next;
299
300                 cell_destroy(gc->forest_cell);
301                 talloc_destroy(gc);
302
303                 gc = p;
304         }
305
306         _gc_server_list = NULL;
307
308         return;
309 }
310
311 /**********************************************************************
312  Setup the initial list of forests and initial the forest cell
313  settings for each.  FIXME!!!
314  *********************************************************************/
315
316  NTSTATUS gc_init_list(void)
317 {
318         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
319         struct winbindd_tdc_domain *domains = NULL;
320         size_t num_domains = 0;
321         int i;
322
323         if (_gc_server_list != NULL) {
324                 gc_server_list_destroy();
325         }
326
327         if (!wcache_tdc_fetch_list(&domains, &num_domains)) {
328                 nt_status = NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
329                 BAIL_ON_NTSTATUS_ERROR(nt_status);
330         }
331
332         /* Find our forest first.  Have to try all domains here starting
333            with our own.  gc_add_forest() filters duplicates */
334
335         nt_status = gc_add_forest(lp_realm());
336         WARN_ON_NTSTATUS_ERROR(nt_status);
337
338         for (i=0; i<num_domains; i++) {
339                 uint32_t flags = (NETR_TRUST_FLAG_IN_FOREST);
340
341                 /* I think we should be able to break out of loop once
342                    we add a GC for our forest and not have to test every one.
343                    In fact, this entire loop is probably irrelevant since
344                    the GC location code should always find a GC given lp_realm().
345                    Will have to spend time testing before making the change.
346                    --jerry */
347
348                 if ((domains[i].trust_flags & flags) == flags) {
349                         nt_status = gc_add_forest(domains[i].dns_name);
350                         WARN_ON_NTSTATUS_ERROR(nt_status);
351                         /* Don't BAIL here since not every domain may
352                            have a GC server */
353                 }
354         }
355
356         /* Now add trusted forests.  gc_add_forest() will filter out
357            duplicates. Check everything with an incoming trust path
358            that is not in our own forest.  */
359
360         for (i=0; i<num_domains; i++) {
361                 uint32_t flags = domains[i].trust_flags;
362                 uint32_t attribs = domains[i].trust_attribs;
363
364                 /* Skip non_AD domains */
365
366                 if (strlen(domains[i].dns_name) == 0) {
367                         continue;
368                 }
369
370                 /* Only add a GC for a forest outside of our own.
371                    Ignore QUARANTINED/EXTERNAL trusts */
372
373                 if ((flags & NETR_TRUST_FLAG_INBOUND)
374                     && !(flags & NETR_TRUST_FLAG_IN_FOREST)
375                     && (attribs & NETR_TRUST_ATTRIBUTE_FOREST_TRANSITIVE))
376                 {
377                         nt_status = gc_add_forest(domains[i].dns_name);
378                         WARN_ON_NTSTATUS_ERROR(nt_status);
379                 }
380         }
381
382         nt_status = NT_STATUS_OK;
383
384 done:
385         if (!NT_STATUS_IS_OK(nt_status)) {
386                 DEBUG(2,("LWI: Failed to initialized GC list (%s)\n",
387                          nt_errstr(nt_status)));
388         }
389
390         TALLOC_FREE(domains);
391
392         return nt_status;
393 }
394
395
396 /**********************************************************************
397  *********************************************************************/
398
399  struct gc_info *gc_search_start(void)
400 {
401         NTSTATUS nt_status = NT_STATUS_OK;
402         struct gc_info *gc = gc_list_head();
403
404         if (!gc) {
405                 nt_status = gc_init_list();
406                 BAIL_ON_NTSTATUS_ERROR(nt_status);
407
408                 gc = gc_list_head();
409         }
410
411 done:
412         if (!NT_STATUS_IS_OK(nt_status)) {
413                 DEBUG(2,("LWI: Failed to initialize GC list (%s)\n",
414                          nt_errstr(nt_status)));
415         }
416
417         return gc;
418 }
419
420 /**********************************************************************
421  Search Global Catalog.  Always search our own forest.  The flags set
422  controls whether or not we search cross forest.  Assume that the
423  resulting set is always returned from one GC so that we don't have to
424  both combining the LDAPMessage * results
425  *********************************************************************/
426
427  NTSTATUS gc_search_forest(struct gc_info *gc,
428                            LDAPMessage **msg,
429                            const char *filter)
430 {
431         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
432         ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
433         const char *attrs[] = {"*", NULL};
434         LDAPMessage *m = NULL;
435
436         if (!gc || !msg || !filter) {
437                 nt_status = NT_STATUS_INVALID_PARAMETER;
438                 BAIL_ON_NTSTATUS_ERROR(nt_status);
439         }
440
441         /* When you have multiple domain trees in a forest, the
442            GC will search all naming contexts when you send it
443            and empty ("") base search suffix.   Tested against
444            Windows 2003.  */
445
446         ads_status = cell_do_search(gc->forest_cell, "",
447                                    LDAP_SCOPE_SUBTREE, filter, attrs, &m);
448         nt_status = ads_ntstatus(ads_status);
449         BAIL_ON_NTSTATUS_ERROR(nt_status);
450
451         *msg = m;
452
453 done:
454         if (!NT_STATUS_IS_OK(nt_status)) {
455                 DEBUG(2,("LWI: Forest wide search %s failed (%s)\n",
456                          filter, nt_errstr(nt_status)));
457         }
458
459         return nt_status;
460 }
461
462 /**********************************************************************
463  Search all forests via GC and return the results in an array of
464  ADS_STRUCT/LDAPMessage pairs.
465  *********************************************************************/
466
467  NTSTATUS gc_search_all_forests(const char *filter,
468                                 ADS_STRUCT ***ads_list,
469                                 LDAPMessage ***msg_list,
470                                 int *num_resp, uint32_t flags)
471 {
472         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
473         struct gc_info *gc = NULL;
474         uint32_t test_flags = ADEX_GC_SEARCH_CHECK_UNIQUE;
475
476         *ads_list = NULL;
477         *msg_list = NULL;
478         *num_resp = 0;
479
480         if ((gc = gc_search_start()) == NULL) {
481                 nt_status = NT_STATUS_INVALID_DOMAIN_STATE;
482                 BAIL_ON_NTSTATUS_ERROR(nt_status);
483         }
484
485         while (gc) {
486                 LDAPMessage *m = NULL;
487
488                 nt_status = gc_search_forest(gc, &m, filter);
489                 if (!NT_STATUS_IS_OK(nt_status)) {
490                         gc = gc->next;
491                         continue;
492                 }
493
494                 nt_status = add_ads_result_to_array(cell_connection(gc->forest_cell),
495                                                     m, ads_list, msg_list,
496                                                     num_resp);
497                 BAIL_ON_NTSTATUS_ERROR(nt_status);
498
499                 /* If there can only be one match, then we are done */
500
501                 if ((*num_resp > 0) && ((flags & test_flags) == test_flags)) {
502                         break;
503                 }
504
505                 gc = gc->next;
506         }
507
508         if (*num_resp == 0) {
509                 nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
510                 BAIL_ON_NTSTATUS_ERROR(nt_status);
511         }
512
513         nt_status = NT_STATUS_OK;
514
515 done:
516         return nt_status;
517 }
518
519 /**********************************************************************
520  Search all forests via GC and return the results in an array of
521  ADS_STRUCT/LDAPMessage pairs.
522  *********************************************************************/
523
524  NTSTATUS gc_search_all_forests_unique(const char *filter,
525                                        ADS_STRUCT **ads,
526                                        LDAPMessage **msg)
527 {
528         ADS_STRUCT **ads_list = NULL;
529         LDAPMessage **msg_list = NULL;
530         int num_resp;
531         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
532
533         nt_status = gc_search_all_forests(filter, &ads_list,
534                                           &msg_list, &num_resp,
535                                           ADEX_GC_SEARCH_CHECK_UNIQUE);
536         BAIL_ON_NTSTATUS_ERROR(nt_status);
537
538         nt_status = check_result_unique(ads_list[0], msg_list[0]);
539         BAIL_ON_NTSTATUS_ERROR(nt_status);
540
541         *ads = ads_list[0];
542         *msg = msg_list[0];
543
544 done:
545         /* Be care that we don't free the msg result being returned */
546
547         if (!NT_STATUS_IS_OK(nt_status)) {
548                 free_result_array(ads_list, msg_list, num_resp);
549         } else {
550                 talloc_destroy(ads_list);
551                 talloc_destroy(msg_list);
552         }
553
554         return nt_status;
555 }
556
557 /*********************************************************************
558  ********************************************************************/
559
560  NTSTATUS gc_name_to_sid(const char *domain,
561                          const char *name,
562                          struct dom_sid *sid,
563                          enum lsa_SidType *sid_type)
564 {
565         TALLOC_CTX *frame = talloc_stackframe();
566         char *p, *name_user;
567         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
568         char *name_filter;
569         ADS_STRUCT *ads = NULL;
570         LDAPMessage *msg = NULL;
571         LDAPMessage *e = NULL;
572         char *dn = NULL;
573         char *dns_domain = NULL;
574         ADS_STRUCT **ads_list = NULL;
575         LDAPMessage **msg_list = NULL;
576         int num_resp = 0;
577         int i;
578
579         /* Strip the "DOMAIN\" prefix if necessary and search for
580            a matching sAMAccountName in the forest */
581
582         if ((p = strchr_m( name, '\\' )) == NULL)
583                 name_user = talloc_strdup( frame, name );
584         else
585                 name_user = talloc_strdup( frame, p+1 );
586         BAIL_ON_PTR_ERROR(name_user, nt_status);
587
588         name_filter = talloc_asprintf(frame, "(sAMAccountName=%s)", name_user);
589         BAIL_ON_PTR_ERROR(name_filter, nt_status);
590
591         nt_status = gc_search_all_forests(name_filter, &ads_list,
592                                           &msg_list, &num_resp, 0);
593         BAIL_ON_NTSTATUS_ERROR(nt_status);
594
595         /* Assume failure until we know otherwise*/
596
597         nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
598
599         /* Match the domain name from the DN */
600
601         for (i=0; i<num_resp; i++) {
602                 ads = ads_list[i];
603                 msg = msg_list[i];
604
605                 e = ads_first_entry(ads, msg);
606                 while (e) {
607                         struct winbindd_tdc_domain *domain_rec;
608
609                         dn = ads_get_dn(ads, frame, e);
610                         BAIL_ON_PTR_ERROR(dn, nt_status);
611
612                         dns_domain = cell_dn_to_dns(dn);
613                         TALLOC_FREE(dn);
614                         BAIL_ON_PTR_ERROR(dns_domain, nt_status);
615
616                         domain_rec = wcache_tdc_fetch_domain(frame, dns_domain);
617                         SAFE_FREE(dns_domain);
618
619                         /* Ignore failures and continue the search */
620
621                         if (!domain_rec) {
622                                 e = ads_next_entry(ads, e);
623                                 continue;
624                         }
625
626                         /* Check for a match on the domain name */
627
628                         if (strequal(domain, domain_rec->domain_name)) {
629                                 if (!ads_pull_sid(ads, e, "objectSid", sid)) {
630                                         nt_status = NT_STATUS_INVALID_SID;
631                                         BAIL_ON_NTSTATUS_ERROR(nt_status);
632                                 }
633
634                                 talloc_destroy(domain_rec);
635
636                                 nt_status = get_sid_type(ads, msg, sid_type);
637                                 BAIL_ON_NTSTATUS_ERROR(nt_status);
638
639                                 /* We're done! */
640                                 nt_status = NT_STATUS_OK;
641                                 break;
642                         }
643
644                         /* once more around thew merry-go-round */
645
646                         talloc_destroy(domain_rec);
647                         e = ads_next_entry(ads, e);
648                 }
649         }
650
651 done:
652         free_result_array(ads_list, msg_list, num_resp);
653         talloc_destroy(frame);
654
655         return nt_status;
656 }
657
658 /********************************************************************
659  Pull an attribute string value
660  *******************************************************************/
661
662 static NTSTATUS get_object_account_name(ADS_STRUCT *ads,
663                                         LDAPMessage *msg,
664                                         char **name)
665 {
666         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
667         char *sam_name = NULL;
668         struct winbindd_tdc_domain *domain_rec = NULL;
669         char *dns_domain = NULL;
670         char *dn = NULL;
671         TALLOC_CTX *frame = talloc_stackframe();
672         int len;
673
674         /* Check parameters */
675
676         if (!ads || !msg || !name) {
677                 nt_status = NT_STATUS_INVALID_PARAMETER;
678                 BAIL_ON_NTSTATUS_ERROR(nt_status);
679         }
680
681         /* get the name and domain */
682
683         dn = ads_get_dn(ads, frame, msg);
684         BAIL_ON_PTR_ERROR(dn, nt_status);
685
686         DEBUG(10,("get_object_account_name: dn = \"%s\"\n", dn));
687
688         dns_domain = cell_dn_to_dns(dn);
689         TALLOC_FREE(dn);
690         BAIL_ON_PTR_ERROR(dns_domain, nt_status);
691
692         domain_rec = wcache_tdc_fetch_domain(frame, dns_domain);
693         SAFE_FREE(dns_domain);
694
695         if (!domain_rec) {
696                 nt_status = NT_STATUS_TRUSTED_DOMAIN_FAILURE;
697                 BAIL_ON_NTSTATUS_ERROR(nt_status);
698         }
699
700         sam_name = ads_pull_string(ads, frame, msg, "sAMAccountName");
701         BAIL_ON_PTR_ERROR(sam_name, nt_status);
702
703         len = asprintf(name, "%s\\%s", domain_rec->domain_name, sam_name);
704         if (len == -1) {
705                 *name = NULL;
706                 BAIL_ON_PTR_ERROR((*name), nt_status);
707         }
708
709         nt_status = NT_STATUS_OK;
710
711 done:
712         talloc_destroy(frame);
713
714         return nt_status;
715 }
716
717 /*********************************************************************
718  ********************************************************************/
719
720  NTSTATUS gc_sid_to_name(const struct dom_sid *sid,
721                          char **name,
722                          enum lsa_SidType *sid_type)
723 {
724         TALLOC_CTX *frame = talloc_stackframe();
725         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
726         char *filter;
727         ADS_STRUCT *ads = NULL;
728         LDAPMessage *msg = NULL;
729         char *sid_string;
730
731         *name = NULL;
732
733         sid_string = ldap_encode_ndr_dom_sid(frame, sid);
734         BAIL_ON_PTR_ERROR(sid_string, nt_status);
735
736         filter = talloc_asprintf(frame, "(objectSid=%s)", sid_string);
737         TALLOC_FREE(sid_string);
738         BAIL_ON_PTR_ERROR(filter, nt_status);
739
740         nt_status = gc_search_all_forests_unique(filter, &ads, &msg);
741         BAIL_ON_NTSTATUS_ERROR(nt_status);
742
743         nt_status = get_object_account_name(ads, msg, name);
744         BAIL_ON_NTSTATUS_ERROR(nt_status);
745
746         nt_status = get_sid_type(ads, msg, sid_type);
747         BAIL_ON_NTSTATUS_ERROR(nt_status);
748
749 done:
750         ads_msgfree(ads, msg);
751         talloc_destroy(frame);
752
753         return nt_status;
754 }
755
756 /**********************************************************************
757  *********************************************************************/
758
759  NTSTATUS add_ads_result_to_array(ADS_STRUCT *ads,
760                                   LDAPMessage *msg,
761                                   ADS_STRUCT ***ads_list,
762                                   LDAPMessage ***msg_list,
763                                   int *size)
764 {
765         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
766         ADS_STRUCT **ads_tmp = NULL;
767         LDAPMessage **msg_tmp = NULL;
768         int count = *size;
769
770         if (!ads || !msg) {
771                 nt_status = NT_STATUS_INVALID_PARAMETER;
772                 BAIL_ON_NTSTATUS_ERROR(nt_status);
773         }
774
775 #if 0
776         /* Don't add a response with no entries */
777
778         if (ads_count_replies(ads, msg) == 0) {
779                 return NT_STATUS_OK;
780         }
781 #endif
782
783         if (count == 0) {
784                 ads_tmp = talloc_array(NULL, ADS_STRUCT*, 1);
785                 BAIL_ON_PTR_ERROR(ads_tmp, nt_status);
786
787                 msg_tmp = talloc_array(NULL, LDAPMessage*, 1);
788                 BAIL_ON_PTR_ERROR(msg_tmp, nt_status);
789         } else {
790                 ads_tmp = talloc_realloc(*ads_list, *ads_list, ADS_STRUCT*,
791                                                count+1);
792                 BAIL_ON_PTR_ERROR(ads_tmp, nt_status);
793
794                 msg_tmp = talloc_realloc(*msg_list, *msg_list, LDAPMessage*,
795                                                count+1);
796                 BAIL_ON_PTR_ERROR(msg_tmp, nt_status);
797         }
798
799         ads_tmp[count] = ads;
800         msg_tmp[count] = msg;
801         count++;
802
803         *ads_list = ads_tmp;
804         *msg_list = msg_tmp;
805         *size = count;
806
807         nt_status = NT_STATUS_OK;
808
809 done:
810         if (!NT_STATUS_IS_OK(nt_status)) {
811                 talloc_destroy(ads_tmp);
812                 talloc_destroy(msg_tmp);
813         }
814
815         return nt_status;
816 }
817
818 /**********************************************************************
819  Frees search results.  Do not free the ads_list as these are
820  references back to the GC search structures.
821  *********************************************************************/
822
823  void free_result_array(ADS_STRUCT **ads_list,
824                         LDAPMessage **msg_list,
825                         int num_resp)
826 {
827         int i;
828
829         for (i=0; i<num_resp; i++) {
830                 ads_msgfree(ads_list[i], msg_list[i]);
831         }
832
833         talloc_destroy(ads_list);
834         talloc_destroy(msg_list);
835 }
836
837 /**********************************************************************
838  Check that we have exactly one entry from the search
839  *********************************************************************/
840
841  NTSTATUS check_result_unique(ADS_STRUCT *ads, LDAPMessage *msg)
842 {
843         NTSTATUS nt_status;
844         int count;
845
846         count = ads_count_replies(ads, msg);
847
848         if (count <= 0) {
849                 nt_status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
850                 BAIL_ON_NTSTATUS_ERROR(nt_status);
851         }
852
853         if (count > 1) {
854                 nt_status = NT_STATUS_DUPLICATE_NAME;
855                 BAIL_ON_NTSTATUS_ERROR(nt_status);
856         }
857
858         nt_status = NT_STATUS_OK;
859
860 done:
861         return nt_status;
862 }