Branch data Line data Source code
1 : : /*
2 : : ldb database library
3 : :
4 : : Copyright (C) Simo Sorce 2008
5 : :
6 : : ** NOTE! The following LGPL license applies to the ldb
7 : : ** library. This does NOT imply that all of Samba is released
8 : : ** under the LGPL
9 : :
10 : : This library is free software; you can redistribute it and/or
11 : : modify it under the terms of the GNU Lesser General Public
12 : : License as published by the Free Software Foundation; either
13 : : version 3 of the License, or (at your option) any later version.
14 : :
15 : : This library is distributed in the hope that it will be useful,
16 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
17 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 : : Lesser General Public License for more details.
19 : :
20 : : You should have received a copy of the GNU Lesser General Public
21 : : License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 : : */
23 : :
24 : : /*
25 : : * Name: ldb
26 : : *
27 : : * Component: ldb module header
28 : : *
29 : : * Description: defines ldb modules structures and helpers
30 : : *
31 : : */
32 : :
33 : : #ifndef _LDB_MODULE_H_
34 : : #define _LDB_MODULE_H_
35 : :
36 : : #include <ldb.h>
37 : :
38 : : struct ldb_context;
39 : : struct ldb_module;
40 : :
41 : : /**
42 : : internal flag bits on message elements. Must be within LDB_FLAG_INTERNAL_MASK
43 : : */
44 : : #define LDB_FLAG_INTERNAL_DISABLE_VALIDATION 0x10
45 : :
46 : : /* disable any single value checking on this attribute */
47 : : #define LDB_FLAG_INTERNAL_DISABLE_SINGLE_VALUE_CHECK 0x20
48 : :
49 : : /* attribute has failed access check and must not be exposed */
50 : : #define LDB_FLAG_INTERNAL_INACCESSIBLE_ATTRIBUTE 0x40
51 : :
52 : : /* force single value checking on this attribute */
53 : : #define LDB_FLAG_INTERNAL_FORCE_SINGLE_VALUE_CHECK 0x80
54 : :
55 : : /* an extended match rule that always fails to match */
56 : : #define SAMBA_LDAP_MATCH_ALWAYS_FALSE "1.3.6.1.4.1.7165.4.5.1"
57 : :
58 : : /*
59 : : these function pointers define the operations that a ldb module can intercept
60 : : */
61 : : struct ldb_module_ops {
62 : : const char *name;
63 : : int (*init_context) (struct ldb_module *);
64 : : int (*search)(struct ldb_module *, struct ldb_request *); /* search */
65 : : int (*add)(struct ldb_module *, struct ldb_request *); /* add */
66 : : int (*modify)(struct ldb_module *, struct ldb_request *); /* modify */
67 : : int (*del)(struct ldb_module *, struct ldb_request *); /* delete */
68 : : int (*rename)(struct ldb_module *, struct ldb_request *); /* rename */
69 : : int (*request)(struct ldb_module *, struct ldb_request *); /* match any other operation */
70 : : int (*extended)(struct ldb_module *, struct ldb_request *); /* extended operations */
71 : : int (*start_transaction)(struct ldb_module *);
72 : : int (*prepare_commit)(struct ldb_module *);
73 : : int (*end_transaction)(struct ldb_module *);
74 : : int (*del_transaction)(struct ldb_module *);
75 : : int (*sequence_number)(struct ldb_module *, struct ldb_request *);
76 : : void *private_data;
77 : : };
78 : :
79 : :
80 : : /* The following definitions come from lib/ldb/common/ldb_debug.c */
81 : : void ldb_debug(struct ldb_context *ldb, enum ldb_debug_level level, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
82 : : void ldb_debug_set(struct ldb_context *ldb, enum ldb_debug_level level,
83 : : const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
84 : : void ldb_debug_add(struct ldb_context *ldb, const char *fmt, ...) PRINTF_ATTRIBUTE(2, 3);
85 : : void ldb_debug_end(struct ldb_context *ldb, enum ldb_debug_level level);
86 : :
87 : : #define ldb_error(ldb, ecode, reason) ldb_error_at(ldb, ecode, reason, __FILE__, __LINE__)
88 : : #define ldb_module_error(module, ecode, reason) ldb_error_at(ldb_module_get_ctx(module), ecode, reason, __FILE__, __LINE__)
89 : :
90 : : #define ldb_oom(ldb) ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "ldb out of memory")
91 : : #define ldb_module_oom(module) ldb_oom(ldb_module_get_ctx(module))
92 : : #define ldb_operr(ldb) ldb_error(ldb, LDB_ERR_OPERATIONS_ERROR, "operations error")
93 : : #define ldb_module_operr(module) ldb_error(ldb_module_get_ctx(module), LDB_ERR_OPERATIONS_ERROR, "operations error")
94 : :
95 : : /* The following definitions come from lib/ldb/common/ldb.c */
96 : :
97 : : void ldb_request_set_state(struct ldb_request *req, int state);
98 : : int ldb_request_get_status(struct ldb_request *req);
99 : :
100 : : unsigned int ldb_get_create_perms(struct ldb_context *ldb);
101 : :
102 : : const struct ldb_schema_syntax *ldb_standard_syntax_by_name(struct ldb_context *ldb,
103 : : const char *syntax);
104 : :
105 : : /* The following definitions come from lib/ldb/common/ldb_attributes.c */
106 : :
107 : : int ldb_schema_attribute_add_with_syntax(struct ldb_context *ldb,
108 : : const char *name,
109 : : unsigned flags,
110 : : const struct ldb_schema_syntax *syntax);
111 : : int ldb_schema_attribute_add(struct ldb_context *ldb,
112 : : const char *name,
113 : : unsigned flags,
114 : : const char *syntax);
115 : : void ldb_schema_attribute_remove(struct ldb_context *ldb, const char *name);
116 : :
117 : : /* we allow external code to override the name -> schema_attribute function */
118 : : typedef const struct ldb_schema_attribute *(*ldb_attribute_handler_override_fn_t)(struct ldb_context *, void *, const char *);
119 : :
120 : : void ldb_schema_attribute_set_override_handler(struct ldb_context *ldb,
121 : : ldb_attribute_handler_override_fn_t override,
122 : : void *private_data);
123 : :
124 : : /* A useful function to build comparison functions with */
125 : : int ldb_any_comparison(struct ldb_context *ldb, void *mem_ctx,
126 : : ldb_attr_handler_t canonicalise_fn,
127 : : const struct ldb_val *v1,
128 : : const struct ldb_val *v2);
129 : :
130 : : /* The following definitions come from lib/ldb/common/ldb_controls.c */
131 : : int ldb_save_controls(struct ldb_control *exclude, struct ldb_request *req, struct ldb_control ***saver);
132 : : /* Returns a list of controls, except the one specified. Included
133 : : * controls become a child of returned list if they were children of
134 : : * controls_in */
135 : : struct ldb_control **ldb_controls_except_specified(struct ldb_control **controls_in,
136 : : TALLOC_CTX *mem_ctx,
137 : : struct ldb_control *exclude);
138 : : int ldb_check_critical_controls(struct ldb_control **controls);
139 : :
140 : : /* The following definitions come from lib/ldb/common/ldb_ldif.c */
141 : : int ldb_should_b64_encode(struct ldb_context *ldb, const struct ldb_val *val);
142 : :
143 : : /* The following definitions come from lib/ldb/common/ldb_match.c */
144 : : int ldb_match_msg(struct ldb_context *ldb,
145 : : const struct ldb_message *msg,
146 : : const struct ldb_parse_tree *tree,
147 : : struct ldb_dn *base,
148 : : enum ldb_scope scope);
149 : :
150 : : int ldb_match_msg_error(struct ldb_context *ldb,
151 : : const struct ldb_message *msg,
152 : : const struct ldb_parse_tree *tree,
153 : : struct ldb_dn *base,
154 : : enum ldb_scope scope,
155 : : bool *matched);
156 : :
157 : : int ldb_match_msg_objectclass(const struct ldb_message *msg,
158 : : const char *objectclass);
159 : :
160 : : /* The following definitions come from lib/ldb/common/ldb_modules.c */
161 : :
162 : : struct ldb_module *ldb_module_new(TALLOC_CTX *memctx,
163 : : struct ldb_context *ldb,
164 : : const char *module_name,
165 : : const struct ldb_module_ops *ops);
166 : :
167 : : const char * ldb_module_get_name(struct ldb_module *module);
168 : : struct ldb_context *ldb_module_get_ctx(struct ldb_module *module);
169 : : void *ldb_module_get_private(struct ldb_module *module);
170 : : void ldb_module_set_private(struct ldb_module *module, void *private_data);
171 : : const struct ldb_module_ops *ldb_module_get_ops(struct ldb_module *module);
172 : :
173 : : int ldb_next_request(struct ldb_module *module, struct ldb_request *request);
174 : : int ldb_next_start_trans(struct ldb_module *module);
175 : : int ldb_next_end_trans(struct ldb_module *module);
176 : : int ldb_next_del_trans(struct ldb_module *module);
177 : : int ldb_next_prepare_commit(struct ldb_module *module);
178 : : int ldb_next_init(struct ldb_module *module);
179 : :
180 : : void ldb_set_errstring(struct ldb_context *ldb, const char *err_string);
181 : : void ldb_asprintf_errstring(struct ldb_context *ldb, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
182 : : void ldb_reset_err_string(struct ldb_context *ldb);
183 : : int ldb_error_at(struct ldb_context *ldb, int ecode, const char *reason, const char *file, int line);
184 : :
185 : : const char *ldb_default_modules_dir(void);
186 : :
187 : : int ldb_register_module(const struct ldb_module_ops *);
188 : :
189 : : typedef int (*ldb_connect_fn)(struct ldb_context *ldb, const char *url,
190 : : unsigned int flags, const char *options[],
191 : : struct ldb_module **module);
192 : :
193 : : struct ldb_backend_ops {
194 : : const char *name;
195 : : ldb_connect_fn connect_fn;
196 : : };
197 : :
198 : : const char *ldb_default_modules_dir(void);
199 : :
200 : : int ldb_register_backend(const char *url_prefix, ldb_connect_fn, bool);
201 : :
202 : : struct ldb_handle *ldb_handle_new(TALLOC_CTX *mem_ctx, struct ldb_context *ldb);
203 : :
204 : : int ldb_module_send_entry(struct ldb_request *req,
205 : : struct ldb_message *msg,
206 : : struct ldb_control **ctrls);
207 : :
208 : : int ldb_module_send_referral(struct ldb_request *req,
209 : : char *ref);
210 : :
211 : : int ldb_module_done(struct ldb_request *req,
212 : : struct ldb_control **ctrls,
213 : : struct ldb_extended *response,
214 : : int error);
215 : :
216 : : int ldb_mod_register_control(struct ldb_module *module, const char *oid);
217 : :
218 : : void ldb_set_default_dns(struct ldb_context *ldb);
219 : : /**
220 : : Add a ldb_control to a ldb_reply
221 : :
222 : : \param ares the reply struct where to add the control
223 : : \param oid the object identifier of the control as string
224 : : \param critical whether the control should be critical or not
225 : : \param data a talloc pointer to the control specific data
226 : :
227 : : \return result code (LDB_SUCCESS on success, or a failure code)
228 : : */
229 : : int ldb_reply_add_control(struct ldb_reply *ares, const char *oid, bool critical, void *data);
230 : :
231 : : /**
232 : : mark a request as untrusted. This tells the rootdse module to remove
233 : : unregistered controls
234 : : */
235 : : void ldb_req_mark_untrusted(struct ldb_request *req);
236 : :
237 : : /**
238 : : mark a request as trusted.
239 : : */
240 : : void ldb_req_mark_trusted(struct ldb_request *req);
241 : :
242 : : /**
243 : : return true is a request is untrusted
244 : : */
245 : : bool ldb_req_is_untrusted(struct ldb_request *req);
246 : :
247 : : /**
248 : : set custom flags. Those flags are set by applications using ldb,
249 : : they are application dependent and the same bit can have different
250 : : meaning in different application.
251 : : */
252 : : void ldb_req_set_custom_flags(struct ldb_request *req, uint32_t flags);
253 : :
254 : : /**
255 : : get custom flags. Those flags are set by applications using ldb,
256 : : they are application dependent and the same bit can have different
257 : : meaning in different application.
258 : : */
259 : : uint32_t ldb_req_get_custom_flags(struct ldb_request *req);
260 : :
261 : : /* load all modules from the given directory */
262 : : int ldb_modules_load(const char *modules_path, const char *version);
263 : :
264 : : /* init functions prototype */
265 : : typedef int (*ldb_module_init_fn)(const char *);
266 : :
267 : : /*
268 : : general ldb hook function
269 : : */
270 : : enum ldb_module_hook_type { LDB_MODULE_HOOK_CMDLINE_OPTIONS = 1,
271 : : LDB_MODULE_HOOK_CMDLINE_PRECONNECT = 2,
272 : : LDB_MODULE_HOOK_CMDLINE_POSTCONNECT = 3 };
273 : :
274 : : typedef int (*ldb_hook_fn)(struct ldb_context *, enum ldb_module_hook_type );
275 : :
276 : : /*
277 : : register a ldb hook function
278 : : */
279 : : int ldb_register_hook(ldb_hook_fn hook_fn);
280 : :
281 : : /*
282 : : call ldb hooks of a given type
283 : : */
284 : : int ldb_modules_hook(struct ldb_context *ldb, enum ldb_module_hook_type t);
285 : :
286 : : #define LDB_MODULE_CHECK_VERSION(version) do { \
287 : : if (strcmp(version, LDB_VERSION) != 0) { \
288 : : fprintf(stderr, "ldb: module version mismatch in %s : ldb_version=%s module_version=%s\n", \
289 : : __FILE__, version, LDB_VERSION); \
290 : : return LDB_ERR_UNAVAILABLE; \
291 : : }} while (0)
292 : :
293 : :
294 : : /*
295 : : return a string representation of the calling chain for the given
296 : : ldb request
297 : : */
298 : : char *ldb_module_call_chain(struct ldb_request *req, TALLOC_CTX *mem_ctx);
299 : :
300 : : /*
301 : : return the next module in the chain
302 : : */
303 : : struct ldb_module *ldb_module_next(struct ldb_module *module);
304 : :
305 : : /*
306 : : set the next module in the module chain
307 : : */
308 : : void ldb_module_set_next(struct ldb_module *module, struct ldb_module *next);
309 : :
310 : : /*
311 : : load a list of modules
312 : : */
313 : : int ldb_module_load_list(struct ldb_context *ldb, const char **module_list,
314 : : struct ldb_module *backend, struct ldb_module **out);
315 : :
316 : : /*
317 : : get the popt_options pointer in the ldb structure. This allows a ldb
318 : : module to change the command line parsing
319 : : */
320 : : struct poptOption **ldb_module_popt_options(struct ldb_context *ldb);
321 : :
322 : : /* modules are called in inverse order on the stack.
323 : : Lets place them as an admin would think the right order is.
324 : : Modules order is important */
325 : : const char **ldb_modules_list_from_string(struct ldb_context *ldb, TALLOC_CTX *mem_ctx, const char *string);
326 : :
327 : : /*
328 : : return the current ldb flags LDB_FLG_*
329 : : */
330 : : uint32_t ldb_module_flags(struct ldb_context *ldb);
331 : :
332 : : int ldb_module_connect_backend(struct ldb_context *ldb,
333 : : const char *url,
334 : : const char *options[],
335 : : struct ldb_module **backend_module);
336 : :
337 : : /*
338 : : initialise a chain of modules
339 : : */
340 : : int ldb_module_init_chain(struct ldb_context *ldb, struct ldb_module *module);
341 : :
342 : : /*
343 : : * prototype for the init function defined by dynamically loaded modules
344 : : */
345 : 625 : int ldb_init_module(const char *version);
346 : :
347 : : /* replace the components of a DN with those from another DN, without
348 : : * touching the extended components
349 : : *
350 : : * return true if successful and false if not
351 : : * if false is returned the dn may be marked invalid
352 : : */
353 : : bool ldb_dn_replace_components(struct ldb_dn *dn, struct ldb_dn *new_dn);
354 : :
355 : : /*
356 : : walk a parse tree, calling the provided callback on each node
357 : : */
358 : : int ldb_parse_tree_walk(struct ldb_parse_tree *tree,
359 : : int (*callback)(struct ldb_parse_tree *tree, void *),
360 : : void *private_context);
361 : :
362 : : /* compare two message elements with ordering - used by modify */
363 : : bool ldb_msg_element_equal_ordered(const struct ldb_message_element *el1,
364 : : const struct ldb_message_element *el2);
365 : :
366 : :
367 : : #endif
|
