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