ecd7bf455436c55a86f342324ccc602544afd37c
[ira/wip.git] / source4 / lib / ldb_wrap.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    LDB wrap functions
5
6    Copyright (C) Andrew Tridgell 2004-2009
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 /*
23   the stupidity of the unix fcntl locking design forces us to never
24   allow a database file to be opened twice in the same process. These
25   wrappers provide convenient access to a tdb or ldb, taking advantage
26   of talloc destructors to ensure that only a single open is done
27 */
28
29 #include "includes.h"
30 #include "lib/events/events.h"
31 #include "lib/ldb/include/ldb.h"
32 #include "lib/ldb/include/ldb_errors.h"
33 #include "lib/ldb-samba/ldif_handlers.h"
34 #include "ldb_wrap.h"
35 #include "dsdb/samdb/samdb.h"
36 #include "param/param.h"
37 #include "dlinklist.h"
38 #include "../tdb/include/tdb.h"
39
40 /*
41   this is used to catch debug messages from ldb
42 */
43 static void ldb_wrap_debug(void *context, enum ldb_debug_level level, 
44                            const char *fmt, va_list ap)  PRINTF_ATTRIBUTE(3,0);
45
46 static void ldb_wrap_debug(void *context, enum ldb_debug_level level, 
47                            const char *fmt, va_list ap)
48 {
49         int samba_level = -1;
50         char *s = NULL;
51         switch (level) {
52         case LDB_DEBUG_FATAL:
53                 samba_level = 0;
54                 break;
55         case LDB_DEBUG_ERROR:
56                 samba_level = 1;
57                 break;
58         case LDB_DEBUG_WARNING:
59                 samba_level = 2;
60                 break;
61         case LDB_DEBUG_TRACE:
62                 samba_level = 5;
63                 break;
64                 
65         };
66         vasprintf(&s, fmt, ap);
67         if (!s) return;
68         DEBUG(samba_level, ("ldb: %s\n", s));
69         free(s);
70 }
71
72
73 /*
74   connecting to a ldb can be a relatively expensive operation because
75   of the schema and partition loads. We keep a list of open ldb
76   contexts here, and try to re-use when possible. 
77
78   This means callers of ldb_wrap_connect() must use talloc_unlink() or
79   the free of a parent to destroy the context
80  */
81 static struct ldb_wrap {
82         struct ldb_wrap *next, *prev;
83         struct ldb_wrap_context {
84                 /* the context is what we use to tell if two ldb
85                  * connections are exactly equivalent 
86                  */              
87                 const char *url;
88                 struct tevent_context *ev;
89                 struct loadparm_context *lp_ctx;
90                 struct auth_session_info *session_info;
91                 struct cli_credentials *credentials;
92                 unsigned int flags;
93         } context;
94         struct ldb_context *ldb;
95 } *ldb_wrap_list;
96
97 /*
98   see if two database opens are equivalent
99  */
100 static bool ldb_wrap_same_context(const struct ldb_wrap_context *c1,
101                                   const struct ldb_wrap_context *c2)
102 {
103         return (c1->ev == c2->ev &&
104                 c1->lp_ctx == c2->lp_ctx &&
105                 c1->session_info == c2->session_info &&
106                 c1->credentials == c2->credentials &&
107                 c1->flags == c2->flags &&
108                 (c1->url == c2->url || strcmp(c1->url, c2->url) == 0));
109 }
110
111 /* 
112    free a ldb_wrap structure
113  */
114 static int ldb_wrap_destructor(struct ldb_wrap *w)
115 {
116         DLIST_REMOVE(ldb_wrap_list, w);
117         return 0;
118 }
119
120 /*
121   wrapped connection to a ldb database
122   to close just talloc_free() the returned ldb_context
123
124   TODO:  We need an error_string parameter
125  */
126 struct ldb_context *ldb_wrap_connect(TALLOC_CTX *mem_ctx,
127                                      struct tevent_context *ev,
128                                      struct loadparm_context *lp_ctx,
129                                      const char *url,
130                                      struct auth_session_info *session_info,
131                                      struct cli_credentials *credentials,
132                                      unsigned int flags)
133 {
134         struct ldb_context *ldb;
135         int ret;
136         char *real_url = NULL;
137         struct ldb_wrap *w;
138         struct ldb_wrap_context c;
139
140         c.url          = url;
141         c.ev           = ev;
142         c.lp_ctx       = lp_ctx;
143         c.session_info = session_info;
144         c.credentials  = credentials;
145         c.flags        = flags;
146
147         /* see if we can re-use an existing ldb */
148         for (w=ldb_wrap_list; w; w=w->next) {
149                 if (ldb_wrap_same_context(&c, &w->context)) {
150                         return talloc_reference(mem_ctx, w->ldb);
151                 }
152         }
153
154         /* we want to use the existing event context if possible. This
155            relies on the fact that in smbd, everything is a child of
156            the main event_context */
157         if (ev == NULL) {
158                 return NULL;
159         }
160
161         ldb = ldb_init(mem_ctx, ev);
162         if (ldb == NULL) {
163                 return NULL;
164         }
165
166         ldb_set_modules_dir(ldb,
167                             talloc_asprintf(ldb,
168                                             "%s/ldb",
169                                             lp_modulesdir(lp_ctx)));
170
171         if (ldb_set_opaque(ldb, "sessionInfo", session_info)) {
172                 talloc_free(ldb);
173                 return NULL;
174         }
175
176         if (ldb_set_opaque(ldb, "credentials", credentials)) {
177                 talloc_free(ldb);
178                 return NULL;
179         }
180
181         if (ldb_set_opaque(ldb, "loadparm", lp_ctx)) {
182                 talloc_free(ldb);
183                 return NULL;
184         }
185
186         /* This must be done before we load the schema, as these
187          * handlers for objectSid and objectGUID etc must take
188          * precedence over the 'binary attribute' declaration in the
189          * schema */
190         ret = ldb_register_samba_handlers(ldb);
191         if (ret == -1) {
192                 talloc_free(ldb);
193                 return NULL;
194         }
195
196         if (lp_ctx != NULL && strcmp(lp_sam_url(lp_ctx), url) == 0) {
197                 dsdb_set_global_schema(ldb);
198         }
199
200         ldb_set_debug(ldb, ldb_wrap_debug, NULL);
201
202         ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
203
204         real_url = private_path(ldb, lp_ctx, url);
205         if (real_url == NULL) {
206                 talloc_free(ldb);
207                 return NULL;
208         }
209
210         /* allow admins to force non-sync ldb for all databases */
211         if (lp_parm_bool(lp_ctx, NULL, "ldb", "nosync", false)) {
212                 flags |= LDB_FLG_NOSYNC;
213         }
214
215         if (DEBUGLVL(10)) {
216                 flags |= LDB_FLG_ENABLE_TRACING;
217         }
218
219         /* we usually want Samba databases to be private. If we later
220            find we need one public, we will need to add a parameter to
221            ldb_wrap_connect() */
222         ldb_set_create_perms(ldb, 0600);
223         
224         ret = ldb_connect(ldb, real_url, flags, NULL);
225         if (ret != LDB_SUCCESS) {
226                 talloc_free(ldb);
227                 return NULL;
228         }
229
230         /* setup for leak detection */
231         ldb_set_opaque(ldb, "wrap_url", real_url);
232         
233         /* add to the list of open ldb contexts */
234         w = talloc(ldb, struct ldb_wrap);
235         if (w == NULL) {
236                 talloc_free(ldb);
237                 return NULL;
238         }
239
240         w->context = c;
241         w->context.url = talloc_strdup(w, url);
242         if (w->context.url == NULL) {
243                 talloc_free(ldb);
244                 return NULL;
245         }
246
247         w->ldb = ldb;
248
249         DLIST_ADD(ldb_wrap_list, w);
250
251         DEBUG(3,("ldb_wrap open of %s\n", url));
252
253         talloc_set_destructor(w, ldb_wrap_destructor);
254
255         return ldb;
256 }
257
258 /*
259   when we fork() we need to make sure that any open ldb contexts have
260   any open transactions cancelled
261  */
262 void ldb_wrap_fork_hook(void)
263 {
264         struct ldb_wrap *w;
265
266         for (w=ldb_wrap_list; w; w=w->next) {
267                 if (ldb_transaction_cancel_noerr(w->ldb) != LDB_SUCCESS) {
268                         smb_panic("Failed to cancel child transactions\n");
269                 }
270         }       
271
272         if (tdb_reopen_all(1) == -1) {
273                 smb_panic("tdb_reopen_all failed\n");
274         }
275 }
276