1 /* rdnval.c - RDN value overlay */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 *
5 * Copyright 1998-2021 The OpenLDAP Foundation.
6 * Portions Copyright 2008 Pierangelo Masarati.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted only as authorized by the OpenLDAP
11 * Public License.
12 *
13 * A copy of this license is available in the file LICENSE in the
14 * top-level directory of the distribution or, alternatively, at
15 * <http://www.OpenLDAP.org/license.html>.
16 */
17 /* ACKNOWLEDGEMENTS:
18 * This work was initially developed by Pierangelo Masarati
19 * for inclusion in OpenLDAP Software.
20 */
21
22 #include "portable.h"
23
24 #ifdef SLAPD_OVER_RDNVAL
25
26 #include <stdio.h>
27
28 #include "ac/string.h"
29 #include "ac/socket.h"
30
31 #include "slap.h"
32 #include "config.h"
33
34 #include "lutil.h"
35
36 /*
37 * Maintain an attribute (rdnValue) that contains the values of each AVA
38 * that builds up the RDN of an entry. This is required for interoperation
39 * with Samba4. It mimics the "name" attribute provided by Active Directory.
40 * The naming attributes must be directoryString-valued, or compatible.
41 * For example, IA5String values are cast into directoryString unless
42 * consisting of the empty string ("").
43 */
44
45 static AttributeDescription *ad_rdnValue;
46 static Syntax *syn_IA5String;
47
48 static slap_overinst rdnval;
49
50 static int
rdnval_is_valid(AttributeDescription * desc,struct berval * value)51 rdnval_is_valid( AttributeDescription *desc, struct berval *value )
52 {
53 if ( desc->ad_type->sat_syntax == slap_schema.si_syn_directoryString ) {
54 return 1;
55 }
56
57 if ( desc->ad_type->sat_syntax == syn_IA5String
58 && !BER_BVISEMPTY( value ) )
59 {
60 return 1;
61 }
62
63 return 0;
64 }
65
66 static int
rdnval_unique_check_cb(Operation * op,SlapReply * rs)67 rdnval_unique_check_cb( Operation *op, SlapReply *rs )
68 {
69 if ( rs->sr_type == REP_SEARCH ) {
70 int *p = (int *)op->o_callback->sc_private;
71 (*p)++;
72 }
73
74 return 0;
75 }
76
77 static int
rdnval_unique_check(Operation * op,BerVarray vals)78 rdnval_unique_check( Operation *op, BerVarray vals )
79 {
80 slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
81
82 BackendDB db = *op->o_bd;
83 Operation op2 = *op;
84 SlapReply rs2 = { 0 };
85 int i;
86 BerVarray fvals;
87 char *ptr;
88 int gotit = 0;
89 slap_callback cb = { 0 };
90
91 /* short-circuit attempts to add suffix entry */
92 if ( op->o_tag == LDAP_REQ_ADD
93 && be_issuffix( op->o_bd, &op->o_req_ndn ) )
94 {
95 return LDAP_SUCCESS;
96 }
97
98 op2.o_bd = &db;
99 op2.o_bd->bd_info = (BackendInfo *)on->on_info;
100 op2.o_tag = LDAP_REQ_SEARCH;
101 op2.o_dn = op->o_bd->be_rootdn;
102 op2.o_ndn = op->o_bd->be_rootndn;
103 op2.o_callback = &cb;
104 cb.sc_response = rdnval_unique_check_cb;
105 cb.sc_private = (void *)&gotit;
106
107 dnParent( &op->o_req_ndn, &op2.o_req_dn );
108 op2.o_req_ndn = op2.o_req_dn;
109
110 op2.ors_limit = NULL;
111 op2.ors_slimit = 1;
112 op2.ors_tlimit = SLAP_NO_LIMIT;
113 op2.ors_attrs = slap_anlist_no_attrs;
114 op2.ors_attrsonly = 1;
115 op2.ors_deref = LDAP_DEREF_NEVER;
116 op2.ors_scope = LDAP_SCOPE_ONELEVEL;
117
118 for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ )
119 /* just count */ ;
120
121 fvals = op->o_tmpcalloc( sizeof( struct berval ), i + 1,
122 op->o_tmpmemctx );
123
124 op2.ors_filterstr.bv_len = 0;
125 if ( i > 1 ) {
126 op2.ors_filterstr.bv_len = STRLENOF( "(&)" );
127 }
128
129 for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ ) {
130 ldap_bv2escaped_filter_value_x( &vals[ i ], &fvals[ i ],
131 1, op->o_tmpmemctx );
132 op2.ors_filterstr.bv_len += ad_rdnValue->ad_cname.bv_len
133 + fvals[ i ].bv_len + STRLENOF( "(=)" );
134 }
135
136 op2.ors_filterstr.bv_val = op->o_tmpalloc( op2.ors_filterstr.bv_len + 1, op->o_tmpmemctx );
137
138 ptr = op2.ors_filterstr.bv_val;
139 if ( i > 1 ) {
140 ptr = lutil_strcopy( ptr, "(&" );
141 }
142 for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ ) {
143 *ptr++ = '(';
144 ptr = lutil_strncopy( ptr, ad_rdnValue->ad_cname.bv_val, ad_rdnValue->ad_cname.bv_len );
145 *ptr++ = '=';
146 ptr = lutil_strncopy( ptr, fvals[ i ].bv_val, fvals[ i ].bv_len );
147 *ptr++ = ')';
148 }
149
150 if ( i > 1 ) {
151 *ptr++ = ')';
152 }
153 *ptr = '\0';
154
155 assert( ptr == op2.ors_filterstr.bv_val + op2.ors_filterstr.bv_len );
156 op2.ors_filter = str2filter_x( op, op2.ors_filterstr.bv_val );
157 assert( op2.ors_filter != NULL );
158
159 (void)op2.o_bd->be_search( &op2, &rs2 );
160
161 filter_free_x( op, op2.ors_filter, 1 );
162 op->o_tmpfree( op2.ors_filterstr.bv_val, op->o_tmpmemctx );
163 for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ ) {
164 if ( vals[ i ].bv_val != fvals[ i ].bv_val ) {
165 op->o_tmpfree( fvals[ i ].bv_val, op->o_tmpmemctx );
166 }
167 }
168 op->o_tmpfree( fvals, op->o_tmpmemctx );
169
170 if ( rs2.sr_err != LDAP_SUCCESS || gotit > 0 ) {
171 return LDAP_CONSTRAINT_VIOLATION;
172 }
173
174 return LDAP_SUCCESS;
175 }
176
177 static int
rdnval_rdn2vals(Operation * op,SlapReply * rs,struct berval * dn,struct berval * ndn,BerVarray * valsp,BerVarray * nvalsp,int * numvalsp)178 rdnval_rdn2vals(
179 Operation *op,
180 SlapReply *rs,
181 struct berval *dn,
182 struct berval *ndn,
183 BerVarray *valsp,
184 BerVarray *nvalsp,
185 int *numvalsp )
186 {
187 LDAPRDN rdn = NULL, nrdn = NULL;
188 int nAVA, i;
189
190 assert( *valsp == NULL );
191 assert( *nvalsp == NULL );
192
193 *numvalsp = 0;
194
195 if ( ldap_bv2rdn_x( dn, &rdn, (char **)&rs->sr_text,
196 LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx ) )
197 {
198 Debug( LDAP_DEBUG_TRACE,
199 "%s rdnval: can't figure out "
200 "type(s)/value(s) of rdn DN=\"%s\"\n",
201 op->o_log_prefix, dn->bv_val, 0 );
202 rs->sr_err = LDAP_INVALID_DN_SYNTAX;
203 rs->sr_text = "unknown type(s) used in RDN";
204
205 goto done;
206 }
207
208 if ( ldap_bv2rdn_x( ndn, &nrdn,
209 (char **)&rs->sr_text, LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx ) )
210 {
211 Debug( LDAP_DEBUG_TRACE,
212 "%s rdnval: can't figure out "
213 "type(s)/value(s) of normalized rdn DN=\"%s\"\n",
214 op->o_log_prefix, ndn->bv_val, 0 );
215 rs->sr_err = LDAP_INVALID_DN_SYNTAX;
216 rs->sr_text = "unknown type(s) used in RDN";
217
218 goto done;
219 }
220
221 for ( nAVA = 0; rdn[ nAVA ]; nAVA++ )
222 /* count'em */ ;
223
224 /* NOTE: we assume rdn and nrdn contain the same AVAs! */
225
226 *valsp = SLAP_CALLOC( sizeof( struct berval ), nAVA + 1 );
227 *nvalsp = SLAP_CALLOC( sizeof( struct berval ), nAVA + 1 );
228
229 /* Add new attribute values to the entry */
230 for ( i = 0; rdn[ i ]; i++ ) {
231 AttributeDescription *desc = NULL;
232
233 rs->sr_err = slap_bv2ad( &rdn[ i ]->la_attr,
234 &desc, &rs->sr_text );
235
236 if ( rs->sr_err != LDAP_SUCCESS ) {
237 Debug( LDAP_DEBUG_TRACE,
238 "%s rdnval: %s: %s\n",
239 op->o_log_prefix,
240 rs->sr_text,
241 rdn[ i ]->la_attr.bv_val );
242 goto done;
243 }
244
245 if ( !rdnval_is_valid( desc, &rdn[ i ]->la_value ) ) {
246 Debug( LDAP_DEBUG_TRACE,
247 "%s rdnval: syntax of naming attribute '%s' "
248 "not compatible with directoryString",
249 op->o_log_prefix, rdn[ i ]->la_attr.bv_val, 0 );
250 continue;
251 }
252
253 if ( value_find_ex( desc,
254 SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
255 SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
256 *nvalsp,
257 &nrdn[ i ]->la_value,
258 op->o_tmpmemctx )
259 == LDAP_NO_SUCH_ATTRIBUTE )
260 {
261 ber_dupbv( &(*valsp)[ *numvalsp ], &rdn[ i ]->la_value );
262 ber_dupbv( &(*nvalsp)[ *numvalsp ], &nrdn[ i ]->la_value );
263
264 (*numvalsp)++;
265 }
266 }
267
268 if ( rdnval_unique_check( op, *valsp ) != LDAP_SUCCESS ) {
269 rs->sr_err = LDAP_CONSTRAINT_VIOLATION;
270 rs->sr_text = "rdnValue not unique within siblings";
271 goto done;
272 }
273
274 done:;
275 if ( rdn != NULL ) {
276 ldap_rdnfree_x( rdn, op->o_tmpmemctx );
277 }
278
279 if ( nrdn != NULL ) {
280 ldap_rdnfree_x( nrdn, op->o_tmpmemctx );
281 }
282
283 if ( rs->sr_err != LDAP_SUCCESS ) {
284 if ( *valsp != NULL ) {
285 ber_bvarray_free( *valsp );
286 ber_bvarray_free( *nvalsp );
287 *valsp = NULL;
288 *nvalsp = NULL;
289 *numvalsp = 0;
290 }
291 }
292
293 return rs->sr_err;
294 }
295
296 static int
rdnval_op_add(Operation * op,SlapReply * rs)297 rdnval_op_add( Operation *op, SlapReply *rs )
298 {
299 Attribute *a, **ap;
300 int numvals = 0;
301 BerVarray vals = NULL, nvals = NULL;
302 int rc;
303
304 /* NOTE: should we accept an entry still in mods format? */
305 assert( op->ora_e != NULL );
306
307 if ( BER_BVISEMPTY( &op->ora_e->e_nname ) ) {
308 return SLAP_CB_CONTINUE;
309 }
310
311 a = attr_find( op->ora_e->e_attrs, ad_rdnValue );
312 if ( a != NULL ) {
313 /* TODO: check consistency? */
314 return SLAP_CB_CONTINUE;
315 }
316
317 rc = rdnval_rdn2vals( op, rs, &op->ora_e->e_name, &op->ora_e->e_nname,
318 &vals, &nvals, &numvals );
319 if ( rc != LDAP_SUCCESS ) {
320 send_ldap_result( op, rs );
321 }
322
323 a = attr_alloc( ad_rdnValue );
324
325 a->a_vals = vals;
326 a->a_nvals = nvals;
327 a->a_numvals = numvals;
328
329 for ( ap = &op->ora_e->e_attrs; *ap != NULL; ap = &(*ap)->a_next )
330 /* goto tail */ ;
331
332 *ap = a;
333
334 return SLAP_CB_CONTINUE;
335 }
336
337 static int
rdnval_op_rename(Operation * op,SlapReply * rs)338 rdnval_op_rename( Operation *op, SlapReply *rs )
339 {
340 Modifications *ml, **mlp;
341 int numvals = 0;
342 BerVarray vals = NULL, nvals = NULL;
343 struct berval old;
344 int rc;
345
346 dnRdn( &op->o_req_ndn, &old );
347 if ( dn_match( &old, &op->orr_nnewrdn ) ) {
348 return SLAP_CB_CONTINUE;
349 }
350
351 rc = rdnval_rdn2vals( op, rs, &op->orr_newrdn, &op->orr_nnewrdn,
352 &vals, &nvals, &numvals );
353 if ( rc != LDAP_SUCCESS ) {
354 send_ldap_result( op, rs );
355 }
356
357 ml = SLAP_CALLOC( sizeof( Modifications ), 1 );
358 ml->sml_values = vals;
359 ml->sml_nvalues = nvals;
360
361 ml->sml_numvals = numvals;
362
363 ml->sml_op = LDAP_MOD_REPLACE;
364 ml->sml_flags = SLAP_MOD_INTERNAL;
365 ml->sml_desc = ad_rdnValue;
366 ml->sml_type = ad_rdnValue->ad_cname;
367
368 for ( mlp = &op->orr_modlist; *mlp != NULL; mlp = &(*mlp)->sml_next )
369 /* goto tail */ ;
370
371 *mlp = ml;
372
373 return SLAP_CB_CONTINUE;
374 }
375
376 static int
rdnval_db_init(BackendDB * be,ConfigReply * cr)377 rdnval_db_init(
378 BackendDB *be,
379 ConfigReply *cr)
380 {
381 if ( SLAP_ISGLOBALOVERLAY( be ) ) {
382 Log0( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
383 "rdnval_db_init: rdnval cannot be used as global overlay.\n" );
384 return 1;
385 }
386
387 if ( be->be_nsuffix == NULL ) {
388 Log0( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
389 "rdnval_db_init: database must have suffix\n" );
390 return 1;
391 }
392
393 if ( BER_BVISNULL( &be->be_rootndn ) || BER_BVISEMPTY( &be->be_rootndn ) ) {
394 Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
395 "rdnval_db_init: missing rootdn for database DN=\"%s\", YMMV\n",
396 be->be_suffix[ 0 ].bv_val );
397 }
398
399 return 0;
400 }
401
402 typedef struct rdnval_mod_t {
403 struct berval ndn;
404 BerVarray vals;
405 BerVarray nvals;
406 int numvals;
407 struct rdnval_mod_t *next;
408 } rdnval_mod_t;
409
410 typedef struct {
411 BackendDB *bd;
412 rdnval_mod_t *mods;
413 } rdnval_repair_cb_t;
414
415 static int
rdnval_repair_cb(Operation * op,SlapReply * rs)416 rdnval_repair_cb( Operation *op, SlapReply *rs )
417 {
418 int rc;
419 rdnval_repair_cb_t *rcb = op->o_callback->sc_private;
420 rdnval_mod_t *mod;
421 BerVarray vals = NULL, nvals = NULL;
422 int numvals = 0;
423 ber_len_t len;
424 BackendDB *save_bd = op->o_bd;
425
426 switch ( rs->sr_type ) {
427 case REP_SEARCH:
428 break;
429
430 case REP_SEARCHREF:
431 case REP_RESULT:
432 return rs->sr_err;
433
434 default:
435 assert( 0 );
436 }
437
438 assert( rs->sr_entry != NULL );
439
440 op->o_bd = rcb->bd;
441 rc = rdnval_rdn2vals( op, rs, &rs->sr_entry->e_name, &rs->sr_entry->e_nname,
442 &vals, &nvals, &numvals );
443 op->o_bd = save_bd;
444 if ( rc != LDAP_SUCCESS ) {
445 return 0;
446 }
447
448 len = sizeof( rdnval_mod_t ) + rs->sr_entry->e_nname.bv_len + 1;
449 mod = op->o_tmpalloc( len, op->o_tmpmemctx );
450 mod->ndn.bv_len = rs->sr_entry->e_nname.bv_len;
451 mod->ndn.bv_val = (char *)&mod[1];
452 lutil_strncopy( mod->ndn.bv_val, rs->sr_entry->e_nname.bv_val, rs->sr_entry->e_nname.bv_len );
453 mod->vals = vals;
454 mod->nvals = nvals;
455 mod->numvals = numvals;
456
457 mod->next = rcb->mods;
458 rcb->mods = mod;
459
460 Debug( LDAP_DEBUG_TRACE, "%s: rdnval_repair_cb: scheduling entry DN=\"%s\" for repair\n",
461 op->o_log_prefix, rs->sr_entry->e_name.bv_val, 0 );
462
463 return 0;
464 }
465
466 static int
rdnval_repair(BackendDB * be)467 rdnval_repair( BackendDB *be )
468 {
469 slap_overinst *on = (slap_overinst *)be->bd_info;
470 void *ctx = ldap_pvt_thread_pool_context();
471 Connection conn = { 0 };
472 OperationBuffer opbuf;
473 Operation *op;
474 BackendDB db;
475 slap_callback sc = { 0 };
476 rdnval_repair_cb_t rcb = { 0 };
477 SlapReply rs = { REP_RESULT };
478 rdnval_mod_t *rmod;
479 int nrepaired = 0;
480
481 connection_fake_init2( &conn, &opbuf, ctx, 0 );
482 op = &opbuf.ob_op;
483
484 op->o_tag = LDAP_REQ_SEARCH;
485 memset( &op->oq_search, 0, sizeof( op->oq_search ) );
486
487 assert( !BER_BVISNULL( &be->be_nsuffix[ 0 ] ) );
488
489 op->o_bd = select_backend( &be->be_nsuffix[ 0 ], 0 );
490 assert( op->o_bd != NULL );
491 assert( op->o_bd->be_nsuffix != NULL );
492
493 op->o_req_dn = op->o_bd->be_suffix[ 0 ];
494 op->o_req_ndn = op->o_bd->be_nsuffix[ 0 ];
495
496 op->o_dn = op->o_bd->be_rootdn;
497 op->o_ndn = op->o_bd->be_rootndn;
498
499 op->ors_scope = LDAP_SCOPE_SUBTREE;
500 op->ors_tlimit = SLAP_NO_LIMIT;
501 op->ors_slimit = SLAP_NO_LIMIT;
502 op->ors_attrs = slap_anlist_no_attrs;
503
504 op->ors_filterstr.bv_len = STRLENOF( "(!(=*))" ) + ad_rdnValue->ad_cname.bv_len;
505 op->ors_filterstr.bv_val = op->o_tmpalloc( op->ors_filterstr.bv_len + 1, op->o_tmpmemctx );
506 snprintf( op->ors_filterstr.bv_val, op->ors_filterstr.bv_len + 1,
507 "(!(%s=*))", ad_rdnValue->ad_cname.bv_val );
508
509 op->ors_filter = str2filter_x( op, op->ors_filterstr.bv_val );
510 if ( op->ors_filter == NULL ) {
511 rs.sr_err = LDAP_OTHER;
512 goto done_search;
513 }
514
515 op->o_callback = ≻
516 sc.sc_response = rdnval_repair_cb;
517 sc.sc_private = &rcb;
518 rcb.bd = &db;
519 db = *be;
520 db.bd_info = (BackendInfo *)on;
521
522 (void)op->o_bd->bd_info->bi_op_search( op, &rs );
523
524 op->o_tag = LDAP_REQ_MODIFY;
525 sc.sc_response = slap_null_cb;
526 sc.sc_private = NULL;
527 memset( &op->oq_modify, 0, sizeof( req_modify_s ) );
528
529 for ( rmod = rcb.mods; rmod != NULL; ) {
530 rdnval_mod_t *rnext;
531
532 Modifications *mod;
533 SlapReply rs2 = { REP_RESULT };
534
535 mod = (Modifications *) ch_malloc( sizeof( Modifications ) );
536 mod->sml_flags = SLAP_MOD_INTERNAL;
537 mod->sml_op = LDAP_MOD_REPLACE;
538 mod->sml_desc = ad_rdnValue;
539 mod->sml_type = ad_rdnValue->ad_cname;
540 mod->sml_values = rmod->vals;
541 mod->sml_nvalues = rmod->nvals;
542 mod->sml_numvals = rmod->numvals;
543 mod->sml_next = NULL;
544
545 op->o_req_dn = rmod->ndn;
546 op->o_req_ndn = rmod->ndn;
547
548 op->orm_modlist = mod;
549
550 op->o_bd->be_modify( op, &rs2 );
551
552 slap_mods_free( op->orm_modlist, 1 );
553 if ( rs2.sr_err == LDAP_SUCCESS ) {
554 Debug( LDAP_DEBUG_TRACE, "%s: rdnval_repair: entry DN=\"%s\" repaired\n",
555 op->o_log_prefix, rmod->ndn.bv_val, 0 );
556 nrepaired++;
557
558 } else {
559 Debug( LDAP_DEBUG_ANY, "%s: rdnval_repair: entry DN=\"%s\" repair failed (%d)\n",
560 op->o_log_prefix, rmod->ndn.bv_val, rs2.sr_err );
561 }
562
563 rnext = rmod->next;
564 op->o_tmpfree( rmod, op->o_tmpmemctx );
565 rmod = rnext;
566 }
567
568 done_search:;
569 op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx );
570 filter_free_x( op, op->ors_filter, 1 );
571
572 Log1( LDAP_DEBUG_STATS, LDAP_LEVEL_INFO,
573 "rdnval: repaired=%d\n", nrepaired );
574
575 return 0;
576 }
577
578 /* search all entries without parentUUID; "repair" them */
579 static int
rdnval_db_open(BackendDB * be,ConfigReply * cr)580 rdnval_db_open(
581 BackendDB *be,
582 ConfigReply *cr )
583 {
584 if ( SLAP_SINGLE_SHADOW( be ) ) {
585 Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
586 "rdnval incompatible with shadow database \"%s\".\n",
587 be->be_suffix[ 0 ].bv_val );
588 return 1;
589 }
590
591 return rdnval_repair( be );
592 }
593
594 static struct {
595 char *desc;
596 AttributeDescription **adp;
597 } as[] = {
598 { "( 1.3.6.1.4.1.4203.666.1.58 "
599 "NAME 'rdnValue' "
600 "DESC 'the value of the naming attributes' "
601 "SYNTAX '1.3.6.1.4.1.1466.115.121.1.15' "
602 "EQUALITY caseIgnoreMatch "
603 "USAGE dSAOperation "
604 "NO-USER-MODIFICATION "
605 ")",
606 &ad_rdnValue },
607 { NULL }
608 };
609
610 int
rdnval_initialize(void)611 rdnval_initialize(void)
612 {
613 int code, i;
614
615 for ( i = 0; as[ i ].desc != NULL; i++ ) {
616 code = register_at( as[ i ].desc, as[ i ].adp, 0 );
617 if ( code ) {
618 Debug( LDAP_DEBUG_ANY,
619 "rdnval_initialize: register_at #%d failed\n",
620 i, 0, 0 );
621 return code;
622 }
623
624 /* Allow Manager to set these as needed */
625 if ( is_at_no_user_mod( (*as[ i ].adp)->ad_type ) ) {
626 (*as[ i ].adp)->ad_type->sat_flags |=
627 SLAP_AT_MANAGEABLE;
628 }
629 }
630
631 syn_IA5String = syn_find( "1.3.6.1.4.1.1466.115.121.1.26" );
632 if ( syn_IA5String == NULL ) {
633 Debug( LDAP_DEBUG_ANY,
634 "rdnval_initialize: unable to find syntax '1.3.6.1.4.1.1466.115.121.1.26' (IA5String)\n",
635 0, 0, 0 );
636 return LDAP_OTHER;
637 }
638
639 rdnval.on_bi.bi_type = "rdnval";
640
641 rdnval.on_bi.bi_op_add = rdnval_op_add;
642 rdnval.on_bi.bi_op_modrdn = rdnval_op_rename;
643
644 rdnval.on_bi.bi_db_init = rdnval_db_init;
645 rdnval.on_bi.bi_db_open = rdnval_db_open;
646
647 return overlay_register( &rdnval );
648 }
649
650 #if SLAPD_OVER_RDNVAL == SLAPD_MOD_DYNAMIC
651 int
init_module(int argc,char * argv[])652 init_module( int argc, char *argv[] )
653 {
654 return rdnval_initialize();
655 }
656 #endif /* SLAPD_OVER_RDNVAL == SLAPD_MOD_DYNAMIC */
657
658 #endif /* SLAPD_OVER_RDNVAL */
659