24343eb554627765696fd1c5961a525f4e2476a5
[nivanova/samba-autobuild/.git] / source3 / winbindd / idmap_adex / likewise_cell.c
1 /*
2  * idmap_adex: Support for AD Forests
3  *
4  * Copyright (C) Gerald (Jerry) Carter 2006-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_adex.h"
24
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_IDMAP
27
28 static struct likewise_cell *_lw_cell_list = NULL;
29
30 /**********************************************************************
31  Return the current HEAD of the list
32  *********************************************************************/
33
34  struct likewise_cell *cell_list_head(void)
35 {
36         return _lw_cell_list;
37 }
38
39
40 /**********************************************************************
41  *********************************************************************/
42
43  void cell_destroy(struct likewise_cell *c)
44 {
45         if (!c)
46                 return;
47
48         if (c->conn)
49                 ads_destroy(&c->conn);
50
51         talloc_destroy(c);
52 }
53
54 /**********************************************************************
55  Free all cell entries and reset the list head to NULL
56  *********************************************************************/
57
58  void cell_list_destroy(void)
59 {
60         struct likewise_cell *p = _lw_cell_list;
61
62         while (p) {
63                 struct likewise_cell *q = p->next;
64
65                 cell_destroy(p);
66
67                 p = q;
68         }
69
70         _lw_cell_list = NULL;
71
72         return;
73 }
74
75 /**********************************************************************
76  Add a new cell structure to the list
77  *********************************************************************/
78
79  struct likewise_cell* cell_new(void)
80 {
81         struct likewise_cell *c;
82
83         /* Each cell struct is a TALLOC_CTX* */
84
85         c = TALLOC_ZERO_P(NULL, struct likewise_cell);
86         if (!c) {
87                 DEBUG(0,("cell_new: memory allocation failure!\n"));
88                 return NULL;
89         }
90
91         return c;
92 }
93
94 /**********************************************************************
95  Add a new cell structure to the list
96  *********************************************************************/
97
98  bool cell_list_add(struct likewise_cell * cell)
99 {
100         if (!cell) {
101                 return false;
102         }
103
104         /* Always add to the end */
105
106         DLIST_ADD_END(_lw_cell_list, cell, struct likewise_cell *);
107
108         return true;
109 }
110
111 /**********************************************************************
112  Add a new cell structure to the list
113  *********************************************************************/
114
115  bool cell_list_remove(struct likewise_cell * cell)
116 {
117         if (!cell) {
118                 return false;
119         }
120
121         /* Remove and drop the cell structure */
122
123         DLIST_REMOVE(_lw_cell_list, cell);
124         talloc_destroy(cell);
125
126         return true;
127 }
128
129 /**********************************************************************
130  Set the containing DNS domain for a cell
131  *********************************************************************/
132
133  void cell_set_dns_domain(struct likewise_cell *c, const char *dns_domain)
134 {
135         c->dns_domain = talloc_strdup(c, dns_domain);
136 }
137
138 /**********************************************************************
139  Set ADS connection for a cell
140  *********************************************************************/
141
142  void cell_set_connection(struct likewise_cell *c, ADS_STRUCT *ads)
143 {
144         c->conn = ads;
145 }
146
147 /**********************************************************************
148  *********************************************************************/
149
150  void cell_set_flags(struct likewise_cell *c, uint32_t flags)
151 {
152         c->flags |= flags;
153 }
154
155 /**********************************************************************
156  *********************************************************************/
157
158  void cell_clear_flags(struct likewise_cell *c, uint32_t flags)
159 {
160         c->flags &= ~flags;
161 }
162
163 /**********************************************************************
164  Set the Cell's DN
165  *********************************************************************/
166
167  void cell_set_dn(struct likewise_cell *c, const char *dn)
168 {
169         if ( c->dn) {
170                 talloc_free(c->dn);
171                 c->dn = NULL;
172         }
173
174         c->dn = talloc_strdup(c, dn);
175 }
176
177 /**********************************************************************
178  *********************************************************************/
179
180  void cell_set_domain_sid(struct likewise_cell *c, struct dom_sid *sid)
181 {
182         sid_copy(&c->domain_sid, sid);
183 }
184
185 /*
186  * Query Routines
187  */
188
189 /**********************************************************************
190  *********************************************************************/
191
192  const char* cell_search_base(struct likewise_cell *c)
193 {
194         if (!c)
195                 return NULL;
196
197         return talloc_asprintf(c, "cn=%s,%s", ADEX_CELL_RDN, c->dn);
198 }
199
200 /**********************************************************************
201  *********************************************************************/
202
203  bool cell_search_forest(struct likewise_cell *c)
204 {
205         uint32_t test_flags = LWCELL_FLAG_SEARCH_FOREST;
206
207         return ((c->flags & test_flags) == test_flags);
208 }
209
210 /**********************************************************************
211  *********************************************************************/
212
213  uint32_t cell_flags(struct likewise_cell *c)
214 {
215         if (!c)
216                 return 0;
217
218         return c->flags;
219 }
220
221 /**********************************************************************
222  *********************************************************************/
223
224  const char *cell_dns_domain(struct likewise_cell *c)
225 {
226         if (!c)
227                 return NULL;
228
229         return c->dns_domain;
230 }
231
232 /**********************************************************************
233  *********************************************************************/
234
235  ADS_STRUCT *cell_connection(struct likewise_cell *c)
236 {
237         if (!c)
238                 return NULL;
239
240         return c->conn;
241 }
242
243 /*
244  * Connection functions
245  */
246
247 /********************************************************************
248  *******************************************************************/
249
250  NTSTATUS cell_connect(struct likewise_cell *c)
251 {
252         ADS_STRUCT *ads = NULL;
253         ADS_STATUS ads_status;
254         fstring dc_name;
255         struct sockaddr_storage dcip;
256         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
257
258         /* have to at least have the AD domain name */
259
260         if (!c->dns_domain) {
261                 nt_status = NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
262                 BAIL_ON_NTSTATUS_ERROR(nt_status);
263         }
264
265         /* clear out any old information */
266
267         if (c->conn) {
268                 ads_destroy(&c->conn);
269                 c->conn = NULL;
270         }
271
272         /* now setup the new connection */
273
274         ads = ads_init(c->dns_domain, NULL, NULL);
275         BAIL_ON_PTR_ERROR(ads, nt_status);
276
277         ads->auth.password =
278             secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
279         ads->auth.realm = SMB_STRDUP(lp_realm());
280
281         /* Make the connection.  We should already have an initial
282            TGT using the machine creds */
283
284         if (cell_flags(c) & LWCELL_FLAG_GC_CELL) {
285                 ads_status = ads_connect_gc(ads);
286         } else {
287           /* Set up server affinity for normal cells and the client
288              site name cache */
289
290           if (!get_dc_name("", c->dns_domain, dc_name, &dcip)) {
291             nt_status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
292             BAIL_ON_NTSTATUS_ERROR(nt_status);
293           }
294
295           ads_status = ads_connect(ads);
296         }
297
298
299         c->conn = ads;
300
301         nt_status = ads_ntstatus(ads_status);
302
303 done:
304         if (!NT_STATUS_IS_OK(nt_status)) {
305                 ads_destroy(&ads);
306                 c->conn = NULL;
307         }
308
309         return nt_status;
310 }
311
312 /********************************************************************
313  *******************************************************************/
314
315  NTSTATUS cell_connect_dn(struct likewise_cell **c, const char *dn)
316 {
317         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
318         struct likewise_cell *new_cell = NULL;
319         char *dns_domain = NULL;
320
321         if (*c || !dn) {
322                 nt_status = NT_STATUS_INVALID_PARAMETER;
323                 BAIL_ON_NTSTATUS_ERROR(nt_status);
324         }
325
326         if ((new_cell = cell_new()) == NULL) {
327                 nt_status = NT_STATUS_NO_MEMORY;
328                 BAIL_ON_NTSTATUS_ERROR(nt_status);
329         }
330
331         /* Set the DNS domain, dn, etc ... and add it to the list */
332
333         dns_domain = cell_dn_to_dns(dn);
334         cell_set_dns_domain(new_cell, dns_domain);
335         SAFE_FREE(dns_domain);
336
337         cell_set_dn(new_cell, dn);
338
339         nt_status = cell_connect(new_cell);
340         BAIL_ON_NTSTATUS_ERROR(nt_status);
341
342         *c = new_cell;
343
344 done:
345         if (!NT_STATUS_IS_OK(nt_status)) {
346                 DEBUG(1,("LWI: Failled to connect to cell \"%s\" (%s)\n",
347                          dn ? dn : "NULL", nt_errstr(nt_status)));
348                 talloc_destroy(new_cell);
349         }
350
351         return nt_status;
352 }
353
354
355 /********************************************************************
356  *******************************************************************/
357
358 #define MAX_SEARCH_COUNT    2
359
360  ADS_STATUS cell_do_search(struct likewise_cell *c,
361                           const char *search_base,
362                           int scope,
363                           const char *expr,
364                           const char **attrs,
365                           LDAPMessage ** msg)
366 {
367         int search_count = 0;
368         ADS_STATUS status;
369         NTSTATUS nt_status;
370
371         /* check for a NULL connection */
372
373         if (!c->conn) {
374                 nt_status = cell_connect(c);
375                 if (!NT_STATUS_IS_OK(nt_status)) {
376                         status = ADS_ERROR_NT(nt_status);
377                         return status;
378                 }
379         }
380
381         DEBUG(10, ("cell_do_search: Base = %s,  Filter = %s, Scope = %d, GC = %s\n",
382                    search_base, expr, scope,
383                    c->conn->server.gc ? "yes" : "no"));
384
385         /* we try multiple times in case the ADS_STRUCT is bad
386            and we need to reconnect */
387
388         while (search_count < MAX_SEARCH_COUNT) {
389                 *msg = NULL;
390                 status = ads_do_search(c->conn, search_base,
391                                        scope, expr, attrs, msg);
392                 if (ADS_ERR_OK(status)) {
393                         if (DEBUGLEVEL >= 10) {
394                                 LDAPMessage *e = NULL;
395
396                                 int n = ads_count_replies(c->conn, *msg);
397
398                                 DEBUG(10,("cell_do_search: Located %d entries\n", n));
399
400                                 for (e=ads_first_entry(c->conn, *msg);
401                                      e!=NULL;
402                                      e = ads_next_entry(c->conn, e))
403                                 {
404                                         char *dn = ads_get_dn(c->conn, talloc_tos(), e);
405
406                                         DEBUGADD(10,("   dn: %s\n", dn ? dn : "<NULL>"));
407                                         TALLOC_FREE(dn);
408                                 }
409                         }
410
411                         return status;
412                 }
413
414
415                 DEBUG(5, ("cell_do_search: search[%d] failed (%s)\n",
416                           search_count, ads_errstr(status)));
417
418                 search_count++;
419
420                 /* Houston, we have a problem */
421
422                 if (status.error_type == ENUM_ADS_ERROR_LDAP) {
423                         switch (status.err.rc) {
424                         case LDAP_TIMELIMIT_EXCEEDED:
425                         case LDAP_TIMEOUT:
426                         case -1:        /* we get this error if we cannot contact
427                                            the LDAP server */
428                                 nt_status = cell_connect(c);
429                                 if (!NT_STATUS_IS_OK(nt_status)) {
430                                         status = ADS_ERROR_NT(nt_status);
431                                         return status;
432                                 }
433                                 break;
434                         default:
435                                 /* we're all done here */
436                                 return status;
437                         }
438                 }
439         }
440
441         DEBUG(5, ("cell_do_search: exceeded maximum search count!\n"));
442
443         return ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
444 }