?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-pylibsmb: Factor out py_tevent_cond_wait
[Samba/gebeck_regimport.git] / source4 / dsdb / samdb / ldb_modules / extended_dn_in.c
blobc21a1ea69bc0edb40facff48fcad71a034f4af13
1 /*
2 ldb database library
3
4 Copyright (C) Simo Sorce 2005-2008
5 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2007-2008
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 /*
22 * Name: ldb
23 *
24 * Component: ldb extended dn control module
25 *
26 * Description: this module interprets DNs of the form <SID=S-1-2-4456> into normal DNs.
27 *
28 * Authors: Simo Sorce
29 * Andrew Bartlett
30 */
31
32 #include "includes.h"
33 #include <ldb.h>
34 #include <ldb_errors.h>
35 #include <ldb_module.h>
36 #include "dsdb/samdb/samdb.h"
37 #include "dsdb/samdb/ldb_modules/util.h"
38
39 /*
40 TODO: if relax is not set then we need to reject the fancy RMD_* and
41 DELETED extended DN codes
42 */
43
44 /* search */
45 struct extended_search_context {
46 struct ldb_module *module;
47 struct ldb_request *req;
48 struct ldb_dn *basedn;
49 struct ldb_dn *dn;
50 char *wellknown_object;
51 int extended_type;
52 };
53
54 static const char *wkattr[] = {
55 "wellKnownObjects",
56 "otherWellKnownObjects",
57 NULL
58 };
59 /* An extra layer of indirection because LDB does not allow the original request to be altered */
60
61 static int extended_final_callback(struct ldb_request *req, struct ldb_reply *ares)
62 {
63 int ret = LDB_ERR_OPERATIONS_ERROR;
64 struct extended_search_context *ac;
65 ac = talloc_get_type(req->context, struct extended_search_context);
66
67 if (ares->error != LDB_SUCCESS) {
68 ret = ldb_module_done(ac->req, ares->controls,
69 ares->response, ares->error);
70 } else {
71 switch (ares->type) {
72 case LDB_REPLY_ENTRY:
73
74 ret = ldb_module_send_entry(ac->req, ares->message, ares->controls);
75 break;
76 case LDB_REPLY_REFERRAL:
77
78 ret = ldb_module_send_referral(ac->req, ares->referral);
79 break;
80 case LDB_REPLY_DONE:
81
82 ret = ldb_module_done(ac->req, ares->controls,
83 ares->response, ares->error);
84 break;
85 }
86 }
87 return ret;
88 }
89
90 static int extended_base_callback(struct ldb_request *req, struct ldb_reply *ares)
91 {
92 struct extended_search_context *ac;
93 struct ldb_request *down_req;
94 struct ldb_message_element *el;
95 int ret;
96 unsigned int i, j;
97 size_t wkn_len = 0;
98 char *valstr = NULL;
99 const char *found = NULL;
100
101 ac = talloc_get_type(req->context, struct extended_search_context);
102
103 if (!ares) {
104 return ldb_module_done(ac->req, NULL, NULL,
105 LDB_ERR_OPERATIONS_ERROR);
106 }
107 if (ares->error != LDB_SUCCESS) {
108 return ldb_module_done(ac->req, ares->controls,
109 ares->response, ares->error);
110 }
111
112 switch (ares->type) {
113 case LDB_REPLY_ENTRY:
114 if (ac->basedn) {
115 /* we have more than one match! This can
116 happen as S-1-5-17 appears twice in a
117 normal provision. We need to return
118 NO_SUCH_OBJECT */
119 const char *str = talloc_asprintf(req, "Duplicate base-DN matches found for '%s'",
120 ldb_dn_get_extended_linearized(req, ac->dn, 1));
121 ldb_set_errstring(ldb_module_get_ctx(ac->module), str);
122 return ldb_module_done(ac->req, NULL, NULL,
123 LDB_ERR_NO_SUCH_OBJECT);
124 }
125
126 if (!ac->wellknown_object) {
127 ac->basedn = talloc_steal(ac, ares->message->dn);
128 break;
129 }
130
131 wkn_len = strlen(ac->wellknown_object);
132
133 for (j=0; wkattr[j]; j++) {
134
135 el = ldb_msg_find_element(ares->message, wkattr[j]);
136 if (!el) {
137 ac->basedn = NULL;
138 continue;
139 }
140
141 for (i=0; i < el->num_values; i++) {
142 valstr = talloc_strndup(ac,
143 (const char *)el->values[i].data,
144 el->values[i].length);
145 if (!valstr) {
146 ldb_oom(ldb_module_get_ctx(ac->module));
147 return ldb_module_done(ac->req, NULL, NULL,
148 LDB_ERR_OPERATIONS_ERROR);
149 }
150
151 if (strncasecmp(valstr, ac->wellknown_object, wkn_len) != 0) {
152 talloc_free(valstr);
153 continue;
154 }
155
156 found = &valstr[wkn_len];
157 break;
158 }
159 if (found) {
160 break;
161 }
162 }
163
164 if (!found) {
165 break;
166 }
167
168 ac->basedn = ldb_dn_new(ac, ldb_module_get_ctx(ac->module), found);
169 talloc_free(valstr);
170 if (!ac->basedn) {
171 ldb_oom(ldb_module_get_ctx(ac->module));
172 return ldb_module_done(ac->req, NULL, NULL,
173 LDB_ERR_OPERATIONS_ERROR);
174 }
175
176 break;
177
178 case LDB_REPLY_REFERRAL:
179 break;
180
181 case LDB_REPLY_DONE:
182
183 if (!ac->basedn) {
184 const char *str = talloc_asprintf(req, "Base-DN '%s' not found",
185 ldb_dn_get_extended_linearized(req, ac->dn, 1));
186 ldb_set_errstring(ldb_module_get_ctx(ac->module), str);
187 return ldb_module_done(ac->req, NULL, NULL,
188 LDB_ERR_NO_SUCH_OBJECT);
189 }
190
191 switch (ac->req->operation) {
192 case LDB_SEARCH:
193 ret = ldb_build_search_req_ex(&down_req,
194 ldb_module_get_ctx(ac->module), ac->req,
195 ac->basedn,
196 ac->req->op.search.scope,
197 ac->req->op.search.tree,
198 ac->req->op.search.attrs,
199 ac->req->controls,
200 ac, extended_final_callback,
201 ac->req);
202 LDB_REQ_SET_LOCATION(down_req);
203 break;
204 case LDB_ADD:
205 {
206 struct ldb_message *add_msg = ldb_msg_copy_shallow(ac, ac->req->op.add.message);
207 if (!add_msg) {
208 ldb_oom(ldb_module_get_ctx(ac->module));
209 return ldb_module_done(ac->req, NULL, NULL,
210 LDB_ERR_OPERATIONS_ERROR);
211 }
212
213 add_msg->dn = ac->basedn;
214
215 ret = ldb_build_add_req(&down_req,
216 ldb_module_get_ctx(ac->module), ac->req,
217 add_msg,
218 ac->req->controls,
219 ac, extended_final_callback,
220 ac->req);
221 LDB_REQ_SET_LOCATION(down_req);
222 break;
223 }
224 case LDB_MODIFY:
225 {
226 struct ldb_message *mod_msg = ldb_msg_copy_shallow(ac, ac->req->op.mod.message);
227 if (!mod_msg) {
228 ldb_oom(ldb_module_get_ctx(ac->module));
229 return ldb_module_done(ac->req, NULL, NULL,
230 LDB_ERR_OPERATIONS_ERROR);
231 }
232
233 mod_msg->dn = ac->basedn;
234
235 ret = ldb_build_mod_req(&down_req,
236 ldb_module_get_ctx(ac->module), ac->req,
237 mod_msg,
238 ac->req->controls,
239 ac, extended_final_callback,
240 ac->req);
241 LDB_REQ_SET_LOCATION(down_req);
242 break;
243 }
244 case LDB_DELETE:
245 ret = ldb_build_del_req(&down_req,
246 ldb_module_get_ctx(ac->module), ac->req,
247 ac->basedn,
248 ac->req->controls,
249 ac, extended_final_callback,
250 ac->req);
251 LDB_REQ_SET_LOCATION(down_req);
252 break;
253 case LDB_RENAME:
254 ret = ldb_build_rename_req(&down_req,
255 ldb_module_get_ctx(ac->module), ac->req,
256 ac->basedn,
257 ac->req->op.rename.newdn,
258 ac->req->controls,
259 ac, extended_final_callback,
260 ac->req);
261 LDB_REQ_SET_LOCATION(down_req);
262 break;
263 default:
264 return ldb_module_done(ac->req, NULL, NULL, LDB_ERR_OPERATIONS_ERROR);
265 }
266
267 if (ret != LDB_SUCCESS) {
268 return ldb_module_done(ac->req, NULL, NULL, ret);
269 }
270
271 return ldb_next_request(ac->module, down_req);
272 }
273 talloc_free(ares);
274 return LDB_SUCCESS;
275 }
276
277
278 /*
279 windows ldap searchs don't allow a baseDN with more
280 than one extended component, or an extended
281 component and a string DN
282
283 We only enforce this over ldap, not for internal
284 use, as there are just too many places where we
285 internally want to use a DN that has come from a
286 search with extended DN enabled, or comes from a DRS
287 naming context.
288
289 Enforcing this would also make debugging samba much
290 harder, as we'd need to use ldb_dn_minimise() in a
291 lot of places, and that would lose the DN string
292 which is so useful for working out what a request is
293 for
294 */
295 static bool ldb_dn_match_allowed(struct ldb_dn *dn, struct ldb_request *req)
296 {
297 int num_components = ldb_dn_get_comp_num(dn);
298 int num_ex_components = ldb_dn_get_extended_comp_num(dn);
299
300 if (num_ex_components == 0) {
301 return true;
302 }
303
304 if ((num_components != 0 || num_ex_components != 1) &&
305 ldb_req_is_untrusted(req)) {
306 return false;
307 }
308 return true;
309 }
310
311
312 struct extended_dn_filter_ctx {
313 bool test_only;
314 bool matched;
315 struct ldb_module *module;
316 struct ldb_request *req;
317 struct dsdb_schema *schema;
318 };
319
320 /*
321 create a always non-matching node from a equality node
322 */
323 static void set_parse_tree_false(struct ldb_parse_tree *tree)
324 {
325 const char *attr = tree->u.equality.attr;
326 struct ldb_val value = tree->u.equality.value;
327 tree->operation = LDB_OP_EXTENDED;
328 tree->u.extended.attr = attr;
329 tree->u.extended.value = value;
330 tree->u.extended.rule_id = SAMBA_LDAP_MATCH_ALWAYS_FALSE;
331 tree->u.extended.dnAttributes = 0;
332 }
333
334 /*
335 called on all nodes in the parse tree
336 */
337 static int extended_dn_filter_callback(struct ldb_parse_tree *tree, void *private_context)
338 {
339 struct extended_dn_filter_ctx *filter_ctx;
340 int ret;
341 struct ldb_dn *dn;
342 const struct ldb_val *sid_val, *guid_val;
343 const char *no_attrs[] = { NULL };
344 struct ldb_result *res;
345 const struct dsdb_attribute *attribute;
346 bool has_extended_component;
347 enum ldb_scope scope;
348 struct ldb_dn *base_dn;
349 const char *expression;
350 uint32_t dsdb_flags;
351
352 if (tree->operation != LDB_OP_EQUALITY) {
353 return LDB_SUCCESS;
354 }
355
356 filter_ctx = talloc_get_type_abort(private_context, struct extended_dn_filter_ctx);
357
358 if (filter_ctx->test_only && filter_ctx->matched) {
359 /* the tree already matched */
360 return LDB_SUCCESS;
361 }
362
363 if (!filter_ctx->schema) {
364 /* Schema not setup yet */
365 return LDB_SUCCESS;
366 }
367 attribute = dsdb_attribute_by_lDAPDisplayName(filter_ctx->schema, tree->u.equality.attr);
368 if (attribute == NULL) {
369 return LDB_SUCCESS;
370 }
371
372 if (attribute->dn_format != DSDB_NORMAL_DN) {
373 return LDB_SUCCESS;
374 }
375
376 has_extended_component = (memchr(tree->u.equality.value.data, '<',
377 tree->u.equality.value.length) != NULL);
378
379 if (!attribute->one_way_link && !has_extended_component) {
380 return LDB_SUCCESS;
381 }
382
383 dn = ldb_dn_from_ldb_val(filter_ctx, ldb_module_get_ctx(filter_ctx->module), &tree->u.equality.value);
384 if (dn == NULL) {
385 /* testing against windows shows that we don't raise
386 an error here */
387 return LDB_SUCCESS;
388 }
389
390 guid_val = ldb_dn_get_extended_component(dn, "GUID");
391 sid_val = ldb_dn_get_extended_component(dn, "SID");
392
393 if (!guid_val && !sid_val && (attribute->searchFlags & SEARCH_FLAG_ATTINDEX)) {
394 /* if it is indexed, then fixing the string DN will do
395 no good here, as we will not find the attribute in
396 the index. So for now fall through to a standard DN
397 component comparison */
398 return LDB_SUCCESS;
399 }
400
401 if (filter_ctx->test_only) {
402 /* we need to copy the tree */
403 filter_ctx->matched = true;
404 return LDB_SUCCESS;
405 }
406
407 if (!ldb_dn_match_allowed(dn, filter_ctx->req)) {
408 /* we need to make this element of the filter always
409 be false */
410 set_parse_tree_false(tree);
411 return LDB_SUCCESS;
412 }
413
414 dsdb_flags = DSDB_FLAG_NEXT_MODULE |
415 DSDB_SEARCH_SHOW_DELETED |
416 DSDB_SEARCH_SHOW_EXTENDED_DN;
417
418 if (guid_val) {
419 expression = talloc_asprintf(filter_ctx, "objectGUID=%s", ldb_binary_encode(filter_ctx, *guid_val));
420 scope = LDB_SCOPE_SUBTREE;
421 base_dn = NULL;
422 dsdb_flags |= DSDB_SEARCH_SEARCH_ALL_PARTITIONS;
423 } else if (sid_val) {
424 expression = talloc_asprintf(filter_ctx, "objectSID=%s", ldb_binary_encode(filter_ctx, *sid_val));
425 scope = LDB_SCOPE_SUBTREE;
426 base_dn = NULL;
427 dsdb_flags |= DSDB_SEARCH_SEARCH_ALL_PARTITIONS;
428 } else {
429 /* fallback to searching using the string DN as the base DN */
430 expression = "objectClass=*";
431 base_dn = dn;
432 scope = LDB_SCOPE_BASE;
433 }
434
435 ret = dsdb_module_search(filter_ctx->module,
436 filter_ctx,
437 &res,
438 base_dn,
439 scope,
440 no_attrs,
441 dsdb_flags,
442 filter_ctx->req,
443 "%s", expression);
444 if (scope == LDB_SCOPE_BASE && ret == LDB_ERR_NO_SUCH_OBJECT) {
445 /* note that this will need to change for multi-domain
446 support */
447 set_parse_tree_false(tree);
448 return LDB_SUCCESS;
449 }
450
451 if (ret != LDB_SUCCESS) {
452 return LDB_SUCCESS;
453 }
454
455
456 if (res->count != 1) {
457 return LDB_SUCCESS;
458 }
459
460 /* replace the search expression element with the matching DN */
461 tree->u.equality.value.data = (uint8_t *)talloc_strdup(tree,
462 ldb_dn_get_extended_linearized(tree, res->msgs[0]->dn, 1));
463 if (tree->u.equality.value.data == NULL) {
464 return ldb_oom(ldb_module_get_ctx(filter_ctx->module));
465 }
466 tree->u.equality.value.length = strlen((const char *)tree->u.equality.value.data);
467 talloc_free(res);
468
469 filter_ctx->matched = true;
470 return LDB_SUCCESS;
471 }
472
473 /*
474 fix the parse tree to change any extended DN components to their
475 caconical form
476 */
477 static int extended_dn_fix_filter(struct ldb_module *module, struct ldb_request *req)
478 {
479 struct extended_dn_filter_ctx *filter_ctx;
480 int ret;
481
482 filter_ctx = talloc_zero(req, struct extended_dn_filter_ctx);
483 if (filter_ctx == NULL) {
484 return ldb_module_oom(module);
485 }
486
487 /* first pass through the existing tree to see if anything
488 needs to be modified. Filtering DNs on the input side is rare,
489 so this avoids copying the parse tree in most cases */
490 filter_ctx->test_only = true;
491 filter_ctx->matched = false;
492 filter_ctx->module = module;
493 filter_ctx->req = req;
494 filter_ctx->schema = dsdb_get_schema(ldb_module_get_ctx(module), filter_ctx);
495
496 ret = ldb_parse_tree_walk(req->op.search.tree, extended_dn_filter_callback, filter_ctx);
497 if (ret != LDB_SUCCESS) {
498 talloc_free(filter_ctx);
499 return ret;
500 }
501
502 if (!filter_ctx->matched) {
503 /* nothing matched, no need for a new parse tree */
504 talloc_free(filter_ctx);
505 return LDB_SUCCESS;
506 }
507
508 filter_ctx->test_only = false;
509 filter_ctx->matched = false;
510
511 req->op.search.tree = ldb_parse_tree_copy_shallow(req, req->op.search.tree);
512 if (req->op.search.tree == NULL) {
513 return ldb_oom(ldb_module_get_ctx(module));
514 }
515
516 ret = ldb_parse_tree_walk(req->op.search.tree, extended_dn_filter_callback, filter_ctx);
517 if (ret != LDB_SUCCESS) {
518 talloc_free(filter_ctx);
519 return ret;
520 }
521
522 talloc_free(filter_ctx);
523 return LDB_SUCCESS;
524 }
525
526 /*
527 fix DNs and filter expressions to cope with the semantics of
528 extended DNs
529 */
530 static int extended_dn_in_fix(struct ldb_module *module, struct ldb_request *req, struct ldb_dn *dn)
531 {
532 struct extended_search_context *ac;
533 struct ldb_request *down_req;
534 int ret;
535 struct ldb_dn *base_dn = NULL;
536 enum ldb_scope base_dn_scope = LDB_SCOPE_BASE;
537 const char *base_dn_filter = NULL;
538 const char * const *base_dn_attrs = NULL;
539 char *wellknown_object = NULL;
540 static const char *no_attr[] = {
541 NULL
542 };
543 bool all_partitions = false;
544
545 if (req->operation == LDB_SEARCH) {
546 ret = extended_dn_fix_filter(module, req);
547 if (ret != LDB_SUCCESS) {
548 return ret;
549 }
550 }
551
552 if (!ldb_dn_has_extended(dn)) {
553 /* Move along there isn't anything to see here */
554 return ldb_next_request(module, req);
555 } else {
556 /* It looks like we need to map the DN */
557 const struct ldb_val *sid_val, *guid_val, *wkguid_val;
558
559 if (!ldb_dn_match_allowed(dn, req)) {
560 return ldb_error(ldb_module_get_ctx(module),
561 LDB_ERR_INVALID_DN_SYNTAX, "invalid number of DN components");
562 }
563
564 sid_val = ldb_dn_get_extended_component(dn, "SID");
565 guid_val = ldb_dn_get_extended_component(dn, "GUID");
566 wkguid_val = ldb_dn_get_extended_component(dn, "WKGUID");
567
568 /*
569 prioritise the GUID - we have had instances of
570 duplicate SIDs in the database in the
571 ForeignSecurityPrinciples due to provision errors
572 */
573 if (guid_val) {
574 all_partitions = true;
575 base_dn = NULL;
576 base_dn_filter = talloc_asprintf(req, "(objectGUID=%s)",
577 ldb_binary_encode(req, *guid_val));
578 if (!base_dn_filter) {
579 return ldb_oom(ldb_module_get_ctx(module));
580 }
581 base_dn_scope = LDB_SCOPE_SUBTREE;
582 base_dn_attrs = no_attr;
583
584 } else if (sid_val) {
585 all_partitions = true;
586 base_dn = NULL;
587 base_dn_filter = talloc_asprintf(req, "(objectSid=%s)",
588 ldb_binary_encode(req, *sid_val));
589 if (!base_dn_filter) {
590 return ldb_oom(ldb_module_get_ctx(module));
591 }
592 base_dn_scope = LDB_SCOPE_SUBTREE;
593 base_dn_attrs = no_attr;
594
595 } else if (wkguid_val) {
596 char *wkguid_dup;
597 char *tail_str;
598 char *p;
599
600 wkguid_dup = talloc_strndup(req, (char *)wkguid_val->data, wkguid_val->length);
601
602 p = strchr(wkguid_dup, ',');
603 if (!p) {
604 return ldb_error(ldb_module_get_ctx(module), LDB_ERR_INVALID_DN_SYNTAX,
605 "Invalid WKGUID format");
606 }
607
608 p[0] = '\0';
609 p++;
610
611 wellknown_object = talloc_asprintf(req, "B:32:%s:", wkguid_dup);
612 if (!wellknown_object) {
613 return ldb_oom(ldb_module_get_ctx(module));
614 }
615
616 tail_str = p;
617
618 base_dn = ldb_dn_new(req, ldb_module_get_ctx(module), tail_str);
619 talloc_free(wkguid_dup);
620 if (!base_dn) {
621 return ldb_oom(ldb_module_get_ctx(module));
622 }
623 base_dn_filter = talloc_strdup(req, "(objectClass=*)");
624 if (!base_dn_filter) {
625 return ldb_oom(ldb_module_get_ctx(module));
626 }
627 base_dn_scope = LDB_SCOPE_BASE;
628 base_dn_attrs = wkattr;
629 } else {
630 return ldb_error(ldb_module_get_ctx(module), LDB_ERR_INVALID_DN_SYNTAX,
631 "Invalid extended DN component");
632 }
633
634 ac = talloc_zero(req, struct extended_search_context);
635 if (ac == NULL) {
636 return ldb_oom(ldb_module_get_ctx(module));
637 }
638
639 ac->module = module;
640 ac->req = req;
641 ac->dn = dn;
642 ac->basedn = NULL; /* Filled in if the search finds the DN by SID/GUID etc */
643 ac->wellknown_object = wellknown_object;
644
645 /* If the base DN was an extended DN (perhaps a well known
646 * GUID) then search for that, so we can proceed with the original operation */
647
648 ret = ldb_build_search_req(&down_req,
649 ldb_module_get_ctx(module), ac,
650 base_dn,
651 base_dn_scope,
652 base_dn_filter,
653 base_dn_attrs,
654 req->controls,
655 ac, extended_base_callback,
656 req);
657 LDB_REQ_SET_LOCATION(down_req);
658 if (ret != LDB_SUCCESS) {
659 return ldb_operr(ldb_module_get_ctx(module));
660 }
661
662 if (all_partitions) {
663 struct ldb_search_options_control *control;
664 control = talloc(down_req, struct ldb_search_options_control);
665 control->search_options = 2;
666 ret = ldb_request_replace_control(down_req,
667 LDB_CONTROL_SEARCH_OPTIONS_OID,
668 true, control);
669 if (ret != LDB_SUCCESS) {
670 ldb_oom(ldb_module_get_ctx(module));
671 return ret;
672 }
673 }
674
675 /* perform the search */
676 return ldb_next_request(module, down_req);
677 }
678 }
679
680 static int extended_dn_in_search(struct ldb_module *module, struct ldb_request *req)
681 {
682 return extended_dn_in_fix(module, req, req->op.search.base);
683 }
684
685 static int extended_dn_in_modify(struct ldb_module *module, struct ldb_request *req)
686 {
687 return extended_dn_in_fix(module, req, req->op.mod.message->dn);
688 }
689
690 static int extended_dn_in_del(struct ldb_module *module, struct ldb_request *req)
691 {
692 return extended_dn_in_fix(module, req, req->op.del.dn);
693 }
694
695 static int extended_dn_in_rename(struct ldb_module *module, struct ldb_request *req)
696 {
697 return extended_dn_in_fix(module, req, req->op.rename.olddn);
698 }
699
700 static const struct ldb_module_ops ldb_extended_dn_in_module_ops = {
701 .name = "extended_dn_in",
702 .search = extended_dn_in_search,
703 .modify = extended_dn_in_modify,
704 .del = extended_dn_in_del,
705 .rename = extended_dn_in_rename,
706 };
707
708 int ldb_extended_dn_in_module_init(const char *version)
709 {
710 LDB_MODULE_CHECK_VERSION(version);
711 return ldb_register_module(&ldb_extended_dn_in_module_ops);
712 }
reg import