1*cf1d77f7Schristos /* $NetBSD: rdnval.c,v 1.3 2021/08/14 16:14:53 christos Exp $ */
20bafdad3Sadam
30bafdad3Sadam /* rdnval.c - RDN value overlay */
433197c6aStron /* $OpenLDAP$ */
50bafdad3Sadam /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
60bafdad3Sadam *
7*cf1d77f7Schristos * Copyright 1998-2021 The OpenLDAP Foundation.
80bafdad3Sadam * Portions Copyright 2008 Pierangelo Masarati.
90bafdad3Sadam * All rights reserved.
100bafdad3Sadam *
110bafdad3Sadam * Redistribution and use in source and binary forms, with or without
120bafdad3Sadam * modification, are permitted only as authorized by the OpenLDAP
130bafdad3Sadam * Public License.
140bafdad3Sadam *
150bafdad3Sadam * A copy of this license is available in the file LICENSE in the
160bafdad3Sadam * top-level directory of the distribution or, alternatively, at
170bafdad3Sadam * <http://www.OpenLDAP.org/license.html>.
180bafdad3Sadam */
190bafdad3Sadam /* ACKNOWLEDGEMENTS:
200bafdad3Sadam * This work was initially developed by Pierangelo Masarati
210bafdad3Sadam * for inclusion in OpenLDAP Software.
220bafdad3Sadam */
230bafdad3Sadam
248bd9f7cdSchristos #include <sys/cdefs.h>
25*cf1d77f7Schristos __RCSID("$NetBSD: rdnval.c,v 1.3 2021/08/14 16:14:53 christos Exp $");
268bd9f7cdSchristos
270bafdad3Sadam #include "portable.h"
280bafdad3Sadam
290bafdad3Sadam #ifdef SLAPD_OVER_RDNVAL
300bafdad3Sadam
310bafdad3Sadam #include <stdio.h>
320bafdad3Sadam
330bafdad3Sadam #include "ac/string.h"
340bafdad3Sadam #include "ac/socket.h"
350bafdad3Sadam
360bafdad3Sadam #include "slap.h"
37*cf1d77f7Schristos #include "slap-config.h"
380bafdad3Sadam
390bafdad3Sadam #include "lutil.h"
400bafdad3Sadam
410bafdad3Sadam /*
420bafdad3Sadam * Maintain an attribute (rdnValue) that contains the values of each AVA
430bafdad3Sadam * that builds up the RDN of an entry. This is required for interoperation
440bafdad3Sadam * with Samba4. It mimics the "name" attribute provided by Active Directory.
450bafdad3Sadam * The naming attributes must be directoryString-valued, or compatible.
460bafdad3Sadam * For example, IA5String values are cast into directoryString unless
470bafdad3Sadam * consisting of the empty string ("").
480bafdad3Sadam */
490bafdad3Sadam
500bafdad3Sadam static AttributeDescription *ad_rdnValue;
510bafdad3Sadam static Syntax *syn_IA5String;
520bafdad3Sadam
530bafdad3Sadam static slap_overinst rdnval;
540bafdad3Sadam
550bafdad3Sadam static int
rdnval_is_valid(AttributeDescription * desc,struct berval * value)560bafdad3Sadam rdnval_is_valid( AttributeDescription *desc, struct berval *value )
570bafdad3Sadam {
580bafdad3Sadam if ( desc->ad_type->sat_syntax == slap_schema.si_syn_directoryString ) {
590bafdad3Sadam return 1;
600bafdad3Sadam }
610bafdad3Sadam
620bafdad3Sadam if ( desc->ad_type->sat_syntax == syn_IA5String
630bafdad3Sadam && !BER_BVISEMPTY( value ) )
640bafdad3Sadam {
650bafdad3Sadam return 1;
660bafdad3Sadam }
670bafdad3Sadam
680bafdad3Sadam return 0;
690bafdad3Sadam }
700bafdad3Sadam
710bafdad3Sadam static int
rdnval_unique_check_cb(Operation * op,SlapReply * rs)720bafdad3Sadam rdnval_unique_check_cb( Operation *op, SlapReply *rs )
730bafdad3Sadam {
740bafdad3Sadam if ( rs->sr_type == REP_SEARCH ) {
750bafdad3Sadam int *p = (int *)op->o_callback->sc_private;
760bafdad3Sadam (*p)++;
770bafdad3Sadam }
780bafdad3Sadam
790bafdad3Sadam return 0;
800bafdad3Sadam }
810bafdad3Sadam
820bafdad3Sadam static int
rdnval_unique_check(Operation * op,BerVarray vals)830bafdad3Sadam rdnval_unique_check( Operation *op, BerVarray vals )
840bafdad3Sadam {
850bafdad3Sadam slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
860bafdad3Sadam
870bafdad3Sadam BackendDB db = *op->o_bd;
880bafdad3Sadam Operation op2 = *op;
890bafdad3Sadam SlapReply rs2 = { 0 };
900bafdad3Sadam int i;
910bafdad3Sadam BerVarray fvals;
920bafdad3Sadam char *ptr;
930bafdad3Sadam int gotit = 0;
940bafdad3Sadam slap_callback cb = { 0 };
950bafdad3Sadam
960bafdad3Sadam /* short-circuit attempts to add suffix entry */
970bafdad3Sadam if ( op->o_tag == LDAP_REQ_ADD
980bafdad3Sadam && be_issuffix( op->o_bd, &op->o_req_ndn ) )
990bafdad3Sadam {
1000bafdad3Sadam return LDAP_SUCCESS;
1010bafdad3Sadam }
1020bafdad3Sadam
1030bafdad3Sadam op2.o_bd = &db;
1040bafdad3Sadam op2.o_bd->bd_info = (BackendInfo *)on->on_info;
1050bafdad3Sadam op2.o_tag = LDAP_REQ_SEARCH;
1060bafdad3Sadam op2.o_dn = op->o_bd->be_rootdn;
1070bafdad3Sadam op2.o_ndn = op->o_bd->be_rootndn;
1080bafdad3Sadam op2.o_callback = &cb;
1090bafdad3Sadam cb.sc_response = rdnval_unique_check_cb;
1100bafdad3Sadam cb.sc_private = (void *)&gotit;
1110bafdad3Sadam
1120bafdad3Sadam dnParent( &op->o_req_ndn, &op2.o_req_dn );
1130bafdad3Sadam op2.o_req_ndn = op2.o_req_dn;
1140bafdad3Sadam
1150bafdad3Sadam op2.ors_limit = NULL;
1160bafdad3Sadam op2.ors_slimit = 1;
1170bafdad3Sadam op2.ors_tlimit = SLAP_NO_LIMIT;
1180bafdad3Sadam op2.ors_attrs = slap_anlist_no_attrs;
1190bafdad3Sadam op2.ors_attrsonly = 1;
1200bafdad3Sadam op2.ors_deref = LDAP_DEREF_NEVER;
1210bafdad3Sadam op2.ors_scope = LDAP_SCOPE_ONELEVEL;
1220bafdad3Sadam
1230bafdad3Sadam for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ )
1240bafdad3Sadam /* just count */ ;
1250bafdad3Sadam
1260bafdad3Sadam fvals = op->o_tmpcalloc( sizeof( struct berval ), i + 1,
1270bafdad3Sadam op->o_tmpmemctx );
1280bafdad3Sadam
1290bafdad3Sadam op2.ors_filterstr.bv_len = 0;
1300bafdad3Sadam if ( i > 1 ) {
1310bafdad3Sadam op2.ors_filterstr.bv_len = STRLENOF( "(&)" );
1320bafdad3Sadam }
1330bafdad3Sadam
1340bafdad3Sadam for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ ) {
1350bafdad3Sadam ldap_bv2escaped_filter_value_x( &vals[ i ], &fvals[ i ],
1360bafdad3Sadam 1, op->o_tmpmemctx );
1370bafdad3Sadam op2.ors_filterstr.bv_len += ad_rdnValue->ad_cname.bv_len
1380bafdad3Sadam + fvals[ i ].bv_len + STRLENOF( "(=)" );
1390bafdad3Sadam }
1400bafdad3Sadam
1410bafdad3Sadam op2.ors_filterstr.bv_val = op->o_tmpalloc( op2.ors_filterstr.bv_len + 1, op->o_tmpmemctx );
1420bafdad3Sadam
1430bafdad3Sadam ptr = op2.ors_filterstr.bv_val;
1440bafdad3Sadam if ( i > 1 ) {
1450bafdad3Sadam ptr = lutil_strcopy( ptr, "(&" );
1460bafdad3Sadam }
1470bafdad3Sadam for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ ) {
1480bafdad3Sadam *ptr++ = '(';
1490bafdad3Sadam ptr = lutil_strncopy( ptr, ad_rdnValue->ad_cname.bv_val, ad_rdnValue->ad_cname.bv_len );
1500bafdad3Sadam *ptr++ = '=';
1510bafdad3Sadam ptr = lutil_strncopy( ptr, fvals[ i ].bv_val, fvals[ i ].bv_len );
1520bafdad3Sadam *ptr++ = ')';
1530bafdad3Sadam }
1540bafdad3Sadam
1550bafdad3Sadam if ( i > 1 ) {
1560bafdad3Sadam *ptr++ = ')';
1570bafdad3Sadam }
1580bafdad3Sadam *ptr = '\0';
1590bafdad3Sadam
1600bafdad3Sadam assert( ptr == op2.ors_filterstr.bv_val + op2.ors_filterstr.bv_len );
1610bafdad3Sadam op2.ors_filter = str2filter_x( op, op2.ors_filterstr.bv_val );
1620bafdad3Sadam assert( op2.ors_filter != NULL );
1630bafdad3Sadam
1640bafdad3Sadam (void)op2.o_bd->be_search( &op2, &rs2 );
1650bafdad3Sadam
1660bafdad3Sadam filter_free_x( op, op2.ors_filter, 1 );
1670bafdad3Sadam op->o_tmpfree( op2.ors_filterstr.bv_val, op->o_tmpmemctx );
1680bafdad3Sadam for ( i = 0; !BER_BVISNULL( &vals[ i ] ); i++ ) {
1690bafdad3Sadam if ( vals[ i ].bv_val != fvals[ i ].bv_val ) {
1700bafdad3Sadam op->o_tmpfree( fvals[ i ].bv_val, op->o_tmpmemctx );
1710bafdad3Sadam }
1720bafdad3Sadam }
1730bafdad3Sadam op->o_tmpfree( fvals, op->o_tmpmemctx );
1740bafdad3Sadam
1750bafdad3Sadam if ( rs2.sr_err != LDAP_SUCCESS || gotit > 0 ) {
1760bafdad3Sadam return LDAP_CONSTRAINT_VIOLATION;
1770bafdad3Sadam }
1780bafdad3Sadam
1790bafdad3Sadam return LDAP_SUCCESS;
1800bafdad3Sadam }
1810bafdad3Sadam
1820bafdad3Sadam static int
rdnval_rdn2vals(Operation * op,SlapReply * rs,struct berval * dn,struct berval * ndn,BerVarray * valsp,BerVarray * nvalsp,int * numvalsp)1830bafdad3Sadam rdnval_rdn2vals(
1840bafdad3Sadam Operation *op,
1850bafdad3Sadam SlapReply *rs,
1860bafdad3Sadam struct berval *dn,
1870bafdad3Sadam struct berval *ndn,
1880bafdad3Sadam BerVarray *valsp,
1890bafdad3Sadam BerVarray *nvalsp,
1900bafdad3Sadam int *numvalsp )
1910bafdad3Sadam {
1920bafdad3Sadam LDAPRDN rdn = NULL, nrdn = NULL;
1930bafdad3Sadam int nAVA, i;
1940bafdad3Sadam
1950bafdad3Sadam assert( *valsp == NULL );
1960bafdad3Sadam assert( *nvalsp == NULL );
1970bafdad3Sadam
1980bafdad3Sadam *numvalsp = 0;
1990bafdad3Sadam
2000bafdad3Sadam if ( ldap_bv2rdn_x( dn, &rdn, (char **)&rs->sr_text,
2010bafdad3Sadam LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx ) )
2020bafdad3Sadam {
2030bafdad3Sadam Debug( LDAP_DEBUG_TRACE,
2040bafdad3Sadam "%s rdnval: can't figure out "
2050bafdad3Sadam "type(s)/value(s) of rdn DN=\"%s\"\n",
206*cf1d77f7Schristos op->o_log_prefix, dn->bv_val );
2070bafdad3Sadam rs->sr_err = LDAP_INVALID_DN_SYNTAX;
2080bafdad3Sadam rs->sr_text = "unknown type(s) used in RDN";
2090bafdad3Sadam
2100bafdad3Sadam goto done;
2110bafdad3Sadam }
2120bafdad3Sadam
2130bafdad3Sadam if ( ldap_bv2rdn_x( ndn, &nrdn,
2140bafdad3Sadam (char **)&rs->sr_text, LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx ) )
2150bafdad3Sadam {
2160bafdad3Sadam Debug( LDAP_DEBUG_TRACE,
2170bafdad3Sadam "%s rdnval: can't figure out "
2180bafdad3Sadam "type(s)/value(s) of normalized rdn DN=\"%s\"\n",
219*cf1d77f7Schristos op->o_log_prefix, ndn->bv_val );
2200bafdad3Sadam rs->sr_err = LDAP_INVALID_DN_SYNTAX;
2210bafdad3Sadam rs->sr_text = "unknown type(s) used in RDN";
2220bafdad3Sadam
2230bafdad3Sadam goto done;
2240bafdad3Sadam }
2250bafdad3Sadam
2260bafdad3Sadam for ( nAVA = 0; rdn[ nAVA ]; nAVA++ )
2270bafdad3Sadam /* count'em */ ;
2280bafdad3Sadam
2290bafdad3Sadam /* NOTE: we assume rdn and nrdn contain the same AVAs! */
2300bafdad3Sadam
231*cf1d77f7Schristos *valsp = ch_calloc( sizeof( struct berval ), nAVA + 1 );
232*cf1d77f7Schristos *nvalsp = ch_calloc( sizeof( struct berval ), nAVA + 1 );
2330bafdad3Sadam
2340bafdad3Sadam /* Add new attribute values to the entry */
2350bafdad3Sadam for ( i = 0; rdn[ i ]; i++ ) {
2360bafdad3Sadam AttributeDescription *desc = NULL;
2370bafdad3Sadam
2380bafdad3Sadam rs->sr_err = slap_bv2ad( &rdn[ i ]->la_attr,
2390bafdad3Sadam &desc, &rs->sr_text );
2400bafdad3Sadam
2410bafdad3Sadam if ( rs->sr_err != LDAP_SUCCESS ) {
2420bafdad3Sadam Debug( LDAP_DEBUG_TRACE,
2430bafdad3Sadam "%s rdnval: %s: %s\n",
2440bafdad3Sadam op->o_log_prefix,
2450bafdad3Sadam rs->sr_text,
2460bafdad3Sadam rdn[ i ]->la_attr.bv_val );
2470bafdad3Sadam goto done;
2480bafdad3Sadam }
2490bafdad3Sadam
2500bafdad3Sadam if ( !rdnval_is_valid( desc, &rdn[ i ]->la_value ) ) {
2510bafdad3Sadam Debug( LDAP_DEBUG_TRACE,
2520bafdad3Sadam "%s rdnval: syntax of naming attribute '%s' "
2530bafdad3Sadam "not compatible with directoryString",
254*cf1d77f7Schristos op->o_log_prefix, rdn[ i ]->la_attr.bv_val );
2550bafdad3Sadam continue;
2560bafdad3Sadam }
2570bafdad3Sadam
2580bafdad3Sadam if ( value_find_ex( desc,
2590bafdad3Sadam SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH |
2600bafdad3Sadam SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH,
2610bafdad3Sadam *nvalsp,
2620bafdad3Sadam &nrdn[ i ]->la_value,
2630bafdad3Sadam op->o_tmpmemctx )
2640bafdad3Sadam == LDAP_NO_SUCH_ATTRIBUTE )
2650bafdad3Sadam {
2660bafdad3Sadam ber_dupbv( &(*valsp)[ *numvalsp ], &rdn[ i ]->la_value );
2670bafdad3Sadam ber_dupbv( &(*nvalsp)[ *numvalsp ], &nrdn[ i ]->la_value );
2680bafdad3Sadam
2690bafdad3Sadam (*numvalsp)++;
2700bafdad3Sadam }
2710bafdad3Sadam }
2720bafdad3Sadam
2730bafdad3Sadam if ( rdnval_unique_check( op, *valsp ) != LDAP_SUCCESS ) {
2740bafdad3Sadam rs->sr_err = LDAP_CONSTRAINT_VIOLATION;
2750bafdad3Sadam rs->sr_text = "rdnValue not unique within siblings";
2760bafdad3Sadam goto done;
2770bafdad3Sadam }
2780bafdad3Sadam
2790bafdad3Sadam done:;
2800bafdad3Sadam if ( rdn != NULL ) {
2810bafdad3Sadam ldap_rdnfree_x( rdn, op->o_tmpmemctx );
2820bafdad3Sadam }
2830bafdad3Sadam
2840bafdad3Sadam if ( nrdn != NULL ) {
2850bafdad3Sadam ldap_rdnfree_x( nrdn, op->o_tmpmemctx );
2860bafdad3Sadam }
2870bafdad3Sadam
2880bafdad3Sadam if ( rs->sr_err != LDAP_SUCCESS ) {
2890bafdad3Sadam if ( *valsp != NULL ) {
2900bafdad3Sadam ber_bvarray_free( *valsp );
2910bafdad3Sadam ber_bvarray_free( *nvalsp );
2920bafdad3Sadam *valsp = NULL;
2930bafdad3Sadam *nvalsp = NULL;
2940bafdad3Sadam *numvalsp = 0;
2950bafdad3Sadam }
2960bafdad3Sadam }
2970bafdad3Sadam
2980bafdad3Sadam return rs->sr_err;
2990bafdad3Sadam }
3000bafdad3Sadam
3010bafdad3Sadam static int
rdnval_op_add(Operation * op,SlapReply * rs)3020bafdad3Sadam rdnval_op_add( Operation *op, SlapReply *rs )
3030bafdad3Sadam {
3040bafdad3Sadam Attribute *a, **ap;
3050bafdad3Sadam int numvals = 0;
3060bafdad3Sadam BerVarray vals = NULL, nvals = NULL;
3070bafdad3Sadam int rc;
3080bafdad3Sadam
3090bafdad3Sadam /* NOTE: should we accept an entry still in mods format? */
3100bafdad3Sadam assert( op->ora_e != NULL );
3110bafdad3Sadam
3120bafdad3Sadam if ( BER_BVISEMPTY( &op->ora_e->e_nname ) ) {
3130bafdad3Sadam return SLAP_CB_CONTINUE;
3140bafdad3Sadam }
3150bafdad3Sadam
3160bafdad3Sadam a = attr_find( op->ora_e->e_attrs, ad_rdnValue );
3170bafdad3Sadam if ( a != NULL ) {
3180bafdad3Sadam /* TODO: check consistency? */
3190bafdad3Sadam return SLAP_CB_CONTINUE;
3200bafdad3Sadam }
3210bafdad3Sadam
3220bafdad3Sadam rc = rdnval_rdn2vals( op, rs, &op->ora_e->e_name, &op->ora_e->e_nname,
3230bafdad3Sadam &vals, &nvals, &numvals );
3240bafdad3Sadam if ( rc != LDAP_SUCCESS ) {
3250bafdad3Sadam send_ldap_result( op, rs );
3260bafdad3Sadam }
3270bafdad3Sadam
3280bafdad3Sadam a = attr_alloc( ad_rdnValue );
3290bafdad3Sadam
3300bafdad3Sadam a->a_vals = vals;
3310bafdad3Sadam a->a_nvals = nvals;
3320bafdad3Sadam a->a_numvals = numvals;
3330bafdad3Sadam
3340bafdad3Sadam for ( ap = &op->ora_e->e_attrs; *ap != NULL; ap = &(*ap)->a_next )
3350bafdad3Sadam /* goto tail */ ;
3360bafdad3Sadam
3370bafdad3Sadam *ap = a;
3380bafdad3Sadam
3390bafdad3Sadam return SLAP_CB_CONTINUE;
3400bafdad3Sadam }
3410bafdad3Sadam
3420bafdad3Sadam static int
rdnval_op_rename(Operation * op,SlapReply * rs)3430bafdad3Sadam rdnval_op_rename( Operation *op, SlapReply *rs )
3440bafdad3Sadam {
3450bafdad3Sadam Modifications *ml, **mlp;
3460bafdad3Sadam int numvals = 0;
3470bafdad3Sadam BerVarray vals = NULL, nvals = NULL;
3480bafdad3Sadam struct berval old;
3490bafdad3Sadam int rc;
3500bafdad3Sadam
3510bafdad3Sadam dnRdn( &op->o_req_ndn, &old );
3520bafdad3Sadam if ( dn_match( &old, &op->orr_nnewrdn ) ) {
3530bafdad3Sadam return SLAP_CB_CONTINUE;
3540bafdad3Sadam }
3550bafdad3Sadam
3560bafdad3Sadam rc = rdnval_rdn2vals( op, rs, &op->orr_newrdn, &op->orr_nnewrdn,
3570bafdad3Sadam &vals, &nvals, &numvals );
3580bafdad3Sadam if ( rc != LDAP_SUCCESS ) {
3590bafdad3Sadam send_ldap_result( op, rs );
3600bafdad3Sadam }
3610bafdad3Sadam
362*cf1d77f7Schristos ml = ch_calloc( sizeof( Modifications ), 1 );
3630bafdad3Sadam ml->sml_values = vals;
3640bafdad3Sadam ml->sml_nvalues = nvals;
3650bafdad3Sadam
3660bafdad3Sadam ml->sml_numvals = numvals;
3670bafdad3Sadam
3680bafdad3Sadam ml->sml_op = LDAP_MOD_REPLACE;
3690bafdad3Sadam ml->sml_flags = SLAP_MOD_INTERNAL;
3700bafdad3Sadam ml->sml_desc = ad_rdnValue;
3710bafdad3Sadam ml->sml_type = ad_rdnValue->ad_cname;
3720bafdad3Sadam
3730bafdad3Sadam for ( mlp = &op->orr_modlist; *mlp != NULL; mlp = &(*mlp)->sml_next )
3740bafdad3Sadam /* goto tail */ ;
3750bafdad3Sadam
3760bafdad3Sadam *mlp = ml;
3770bafdad3Sadam
3780bafdad3Sadam return SLAP_CB_CONTINUE;
3790bafdad3Sadam }
3800bafdad3Sadam
3810bafdad3Sadam static int
rdnval_db_init(BackendDB * be,ConfigReply * cr)3820bafdad3Sadam rdnval_db_init(
3830bafdad3Sadam BackendDB *be,
3840bafdad3Sadam ConfigReply *cr)
3850bafdad3Sadam {
3860bafdad3Sadam if ( SLAP_ISGLOBALOVERLAY( be ) ) {
387*cf1d77f7Schristos Log( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
3880bafdad3Sadam "rdnval_db_init: rdnval cannot be used as global overlay.\n" );
3890bafdad3Sadam return 1;
3900bafdad3Sadam }
3910bafdad3Sadam
3920bafdad3Sadam if ( be->be_nsuffix == NULL ) {
393*cf1d77f7Schristos Log( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
3940bafdad3Sadam "rdnval_db_init: database must have suffix\n" );
3950bafdad3Sadam return 1;
3960bafdad3Sadam }
3970bafdad3Sadam
3980bafdad3Sadam if ( BER_BVISNULL( &be->be_rootndn ) || BER_BVISEMPTY( &be->be_rootndn ) ) {
399*cf1d77f7Schristos Log( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
4000bafdad3Sadam "rdnval_db_init: missing rootdn for database DN=\"%s\", YMMV\n",
4010bafdad3Sadam be->be_suffix[ 0 ].bv_val );
4020bafdad3Sadam }
4030bafdad3Sadam
4040bafdad3Sadam return 0;
4050bafdad3Sadam }
4060bafdad3Sadam
4070bafdad3Sadam typedef struct rdnval_mod_t {
4080bafdad3Sadam struct berval ndn;
4090bafdad3Sadam BerVarray vals;
4100bafdad3Sadam BerVarray nvals;
4110bafdad3Sadam int numvals;
4120bafdad3Sadam struct rdnval_mod_t *next;
4130bafdad3Sadam } rdnval_mod_t;
4140bafdad3Sadam
4150bafdad3Sadam typedef struct {
4160bafdad3Sadam BackendDB *bd;
4170bafdad3Sadam rdnval_mod_t *mods;
4180bafdad3Sadam } rdnval_repair_cb_t;
4190bafdad3Sadam
4200bafdad3Sadam static int
rdnval_repair_cb(Operation * op,SlapReply * rs)4210bafdad3Sadam rdnval_repair_cb( Operation *op, SlapReply *rs )
4220bafdad3Sadam {
4230bafdad3Sadam int rc;
4240bafdad3Sadam rdnval_repair_cb_t *rcb = op->o_callback->sc_private;
4250bafdad3Sadam rdnval_mod_t *mod;
4260bafdad3Sadam BerVarray vals = NULL, nvals = NULL;
4270bafdad3Sadam int numvals = 0;
4280bafdad3Sadam ber_len_t len;
4290bafdad3Sadam BackendDB *save_bd = op->o_bd;
4300bafdad3Sadam
4310bafdad3Sadam switch ( rs->sr_type ) {
4320bafdad3Sadam case REP_SEARCH:
4330bafdad3Sadam break;
4340bafdad3Sadam
4350bafdad3Sadam case REP_SEARCHREF:
4360bafdad3Sadam case REP_RESULT:
4370bafdad3Sadam return rs->sr_err;
4380bafdad3Sadam
4390bafdad3Sadam default:
4400bafdad3Sadam assert( 0 );
4410bafdad3Sadam }
4420bafdad3Sadam
4430bafdad3Sadam assert( rs->sr_entry != NULL );
4440bafdad3Sadam
4450bafdad3Sadam op->o_bd = rcb->bd;
4460bafdad3Sadam rc = rdnval_rdn2vals( op, rs, &rs->sr_entry->e_name, &rs->sr_entry->e_nname,
4470bafdad3Sadam &vals, &nvals, &numvals );
4480bafdad3Sadam op->o_bd = save_bd;
4490bafdad3Sadam if ( rc != LDAP_SUCCESS ) {
4500bafdad3Sadam return 0;
4510bafdad3Sadam }
4520bafdad3Sadam
4530bafdad3Sadam len = sizeof( rdnval_mod_t ) + rs->sr_entry->e_nname.bv_len + 1;
4540bafdad3Sadam mod = op->o_tmpalloc( len, op->o_tmpmemctx );
4550bafdad3Sadam mod->ndn.bv_len = rs->sr_entry->e_nname.bv_len;
4560bafdad3Sadam mod->ndn.bv_val = (char *)&mod[1];
4570bafdad3Sadam lutil_strncopy( mod->ndn.bv_val, rs->sr_entry->e_nname.bv_val, rs->sr_entry->e_nname.bv_len );
4580bafdad3Sadam mod->vals = vals;
4590bafdad3Sadam mod->nvals = nvals;
4600bafdad3Sadam mod->numvals = numvals;
4610bafdad3Sadam
4620bafdad3Sadam mod->next = rcb->mods;
4630bafdad3Sadam rcb->mods = mod;
4640bafdad3Sadam
4650bafdad3Sadam Debug( LDAP_DEBUG_TRACE, "%s: rdnval_repair_cb: scheduling entry DN=\"%s\" for repair\n",
466*cf1d77f7Schristos op->o_log_prefix, rs->sr_entry->e_name.bv_val );
4670bafdad3Sadam
4680bafdad3Sadam return 0;
4690bafdad3Sadam }
4700bafdad3Sadam
4710bafdad3Sadam static int
rdnval_repair(BackendDB * be)4720bafdad3Sadam rdnval_repair( BackendDB *be )
4730bafdad3Sadam {
4740bafdad3Sadam slap_overinst *on = (slap_overinst *)be->bd_info;
4750bafdad3Sadam void *ctx = ldap_pvt_thread_pool_context();
4760bafdad3Sadam Connection conn = { 0 };
4770bafdad3Sadam OperationBuffer opbuf;
4780bafdad3Sadam Operation *op;
4790bafdad3Sadam BackendDB db;
4800bafdad3Sadam slap_callback sc = { 0 };
4810bafdad3Sadam rdnval_repair_cb_t rcb = { 0 };
4820bafdad3Sadam SlapReply rs = { REP_RESULT };
4830bafdad3Sadam rdnval_mod_t *rmod;
4840bafdad3Sadam int nrepaired = 0;
4850bafdad3Sadam
4860bafdad3Sadam connection_fake_init2( &conn, &opbuf, ctx, 0 );
4870bafdad3Sadam op = &opbuf.ob_op;
4880bafdad3Sadam
4890bafdad3Sadam op->o_tag = LDAP_REQ_SEARCH;
4900bafdad3Sadam memset( &op->oq_search, 0, sizeof( op->oq_search ) );
4910bafdad3Sadam
4920bafdad3Sadam assert( !BER_BVISNULL( &be->be_nsuffix[ 0 ] ) );
4930bafdad3Sadam
4940bafdad3Sadam op->o_bd = select_backend( &be->be_nsuffix[ 0 ], 0 );
4950bafdad3Sadam assert( op->o_bd != NULL );
4960bafdad3Sadam assert( op->o_bd->be_nsuffix != NULL );
4970bafdad3Sadam
4980bafdad3Sadam op->o_req_dn = op->o_bd->be_suffix[ 0 ];
4990bafdad3Sadam op->o_req_ndn = op->o_bd->be_nsuffix[ 0 ];
5000bafdad3Sadam
5010bafdad3Sadam op->o_dn = op->o_bd->be_rootdn;
5020bafdad3Sadam op->o_ndn = op->o_bd->be_rootndn;
5030bafdad3Sadam
5040bafdad3Sadam op->ors_scope = LDAP_SCOPE_SUBTREE;
5050bafdad3Sadam op->ors_tlimit = SLAP_NO_LIMIT;
5060bafdad3Sadam op->ors_slimit = SLAP_NO_LIMIT;
5070bafdad3Sadam op->ors_attrs = slap_anlist_no_attrs;
5080bafdad3Sadam
5090bafdad3Sadam op->ors_filterstr.bv_len = STRLENOF( "(!(=*))" ) + ad_rdnValue->ad_cname.bv_len;
5100bafdad3Sadam op->ors_filterstr.bv_val = op->o_tmpalloc( op->ors_filterstr.bv_len + 1, op->o_tmpmemctx );
5110bafdad3Sadam snprintf( op->ors_filterstr.bv_val, op->ors_filterstr.bv_len + 1,
5120bafdad3Sadam "(!(%s=*))", ad_rdnValue->ad_cname.bv_val );
5130bafdad3Sadam
5140bafdad3Sadam op->ors_filter = str2filter_x( op, op->ors_filterstr.bv_val );
5150bafdad3Sadam if ( op->ors_filter == NULL ) {
5160bafdad3Sadam rs.sr_err = LDAP_OTHER;
5170bafdad3Sadam goto done_search;
5180bafdad3Sadam }
5190bafdad3Sadam
5200bafdad3Sadam op->o_callback = ≻
5210bafdad3Sadam sc.sc_response = rdnval_repair_cb;
5220bafdad3Sadam sc.sc_private = &rcb;
5230bafdad3Sadam rcb.bd = &db;
5240bafdad3Sadam db = *be;
5250bafdad3Sadam db.bd_info = (BackendInfo *)on;
5260bafdad3Sadam
5270bafdad3Sadam (void)op->o_bd->bd_info->bi_op_search( op, &rs );
5280bafdad3Sadam
5290bafdad3Sadam op->o_tag = LDAP_REQ_MODIFY;
5300bafdad3Sadam sc.sc_response = slap_null_cb;
5310bafdad3Sadam sc.sc_private = NULL;
5320bafdad3Sadam memset( &op->oq_modify, 0, sizeof( req_modify_s ) );
5330bafdad3Sadam
5340bafdad3Sadam for ( rmod = rcb.mods; rmod != NULL; ) {
5350bafdad3Sadam rdnval_mod_t *rnext;
5360bafdad3Sadam
5370bafdad3Sadam Modifications *mod;
5380bafdad3Sadam SlapReply rs2 = { REP_RESULT };
5390bafdad3Sadam
5400bafdad3Sadam mod = (Modifications *) ch_malloc( sizeof( Modifications ) );
5410bafdad3Sadam mod->sml_flags = SLAP_MOD_INTERNAL;
5420bafdad3Sadam mod->sml_op = LDAP_MOD_REPLACE;
5430bafdad3Sadam mod->sml_desc = ad_rdnValue;
5440bafdad3Sadam mod->sml_type = ad_rdnValue->ad_cname;
5450bafdad3Sadam mod->sml_values = rmod->vals;
5460bafdad3Sadam mod->sml_nvalues = rmod->nvals;
5470bafdad3Sadam mod->sml_numvals = rmod->numvals;
5480bafdad3Sadam mod->sml_next = NULL;
5490bafdad3Sadam
5500bafdad3Sadam op->o_req_dn = rmod->ndn;
5510bafdad3Sadam op->o_req_ndn = rmod->ndn;
5520bafdad3Sadam
5530bafdad3Sadam op->orm_modlist = mod;
5540bafdad3Sadam
5550bafdad3Sadam op->o_bd->be_modify( op, &rs2 );
5560bafdad3Sadam
5570bafdad3Sadam slap_mods_free( op->orm_modlist, 1 );
5580bafdad3Sadam if ( rs2.sr_err == LDAP_SUCCESS ) {
5590bafdad3Sadam Debug( LDAP_DEBUG_TRACE, "%s: rdnval_repair: entry DN=\"%s\" repaired\n",
560*cf1d77f7Schristos op->o_log_prefix, rmod->ndn.bv_val );
5610bafdad3Sadam nrepaired++;
5620bafdad3Sadam
5630bafdad3Sadam } else {
5640bafdad3Sadam Debug( LDAP_DEBUG_ANY, "%s: rdnval_repair: entry DN=\"%s\" repair failed (%d)\n",
5650bafdad3Sadam op->o_log_prefix, rmod->ndn.bv_val, rs2.sr_err );
5660bafdad3Sadam }
5670bafdad3Sadam
5680bafdad3Sadam rnext = rmod->next;
5690bafdad3Sadam op->o_tmpfree( rmod, op->o_tmpmemctx );
5700bafdad3Sadam rmod = rnext;
5710bafdad3Sadam }
5720bafdad3Sadam
5730bafdad3Sadam done_search:;
5740bafdad3Sadam op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx );
5750bafdad3Sadam filter_free_x( op, op->ors_filter, 1 );
5760bafdad3Sadam
577*cf1d77f7Schristos Log( LDAP_DEBUG_STATS, LDAP_LEVEL_INFO,
5780bafdad3Sadam "rdnval: repaired=%d\n", nrepaired );
5790bafdad3Sadam
5800bafdad3Sadam return 0;
5810bafdad3Sadam }
5820bafdad3Sadam
5830bafdad3Sadam /* search all entries without parentUUID; "repair" them */
5840bafdad3Sadam static int
rdnval_db_open(BackendDB * be,ConfigReply * cr)5850bafdad3Sadam rdnval_db_open(
5860bafdad3Sadam BackendDB *be,
5870bafdad3Sadam ConfigReply *cr )
5880bafdad3Sadam {
5890bafdad3Sadam if ( SLAP_SINGLE_SHADOW( be ) ) {
590*cf1d77f7Schristos Log( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
5910bafdad3Sadam "rdnval incompatible with shadow database \"%s\".\n",
5920bafdad3Sadam be->be_suffix[ 0 ].bv_val );
5930bafdad3Sadam return 1;
5940bafdad3Sadam }
5950bafdad3Sadam
5960bafdad3Sadam return rdnval_repair( be );
5970bafdad3Sadam }
5980bafdad3Sadam
5990bafdad3Sadam static struct {
6000bafdad3Sadam char *desc;
6010bafdad3Sadam AttributeDescription **adp;
6020bafdad3Sadam } as[] = {
6030bafdad3Sadam { "( 1.3.6.1.4.1.4203.666.1.58 "
6040bafdad3Sadam "NAME 'rdnValue' "
6050bafdad3Sadam "DESC 'the value of the naming attributes' "
6060bafdad3Sadam "SYNTAX '1.3.6.1.4.1.1466.115.121.1.15' "
6070bafdad3Sadam "EQUALITY caseIgnoreMatch "
6080bafdad3Sadam "USAGE dSAOperation "
6090bafdad3Sadam "NO-USER-MODIFICATION "
6100bafdad3Sadam ")",
6110bafdad3Sadam &ad_rdnValue },
6120bafdad3Sadam { NULL }
6130bafdad3Sadam };
6140bafdad3Sadam
6150bafdad3Sadam int
rdnval_initialize(void)6160bafdad3Sadam rdnval_initialize(void)
6170bafdad3Sadam {
6180bafdad3Sadam int code, i;
6190bafdad3Sadam
6200bafdad3Sadam for ( i = 0; as[ i ].desc != NULL; i++ ) {
6210bafdad3Sadam code = register_at( as[ i ].desc, as[ i ].adp, 0 );
6220bafdad3Sadam if ( code ) {
6230bafdad3Sadam Debug( LDAP_DEBUG_ANY,
6240bafdad3Sadam "rdnval_initialize: register_at #%d failed\n",
625*cf1d77f7Schristos i );
6260bafdad3Sadam return code;
6270bafdad3Sadam }
6280bafdad3Sadam
6290bafdad3Sadam /* Allow Manager to set these as needed */
6300bafdad3Sadam if ( is_at_no_user_mod( (*as[ i ].adp)->ad_type ) ) {
6310bafdad3Sadam (*as[ i ].adp)->ad_type->sat_flags |=
6320bafdad3Sadam SLAP_AT_MANAGEABLE;
6330bafdad3Sadam }
6340bafdad3Sadam }
6350bafdad3Sadam
6360bafdad3Sadam syn_IA5String = syn_find( "1.3.6.1.4.1.1466.115.121.1.26" );
6370bafdad3Sadam if ( syn_IA5String == NULL ) {
6380bafdad3Sadam Debug( LDAP_DEBUG_ANY,
639*cf1d77f7Schristos "rdnval_initialize: unable to find syntax '1.3.6.1.4.1.1466.115.121.1.26' (IA5String)\n" );
6400bafdad3Sadam return LDAP_OTHER;
6410bafdad3Sadam }
6420bafdad3Sadam
6430bafdad3Sadam rdnval.on_bi.bi_type = "rdnval";
6440bafdad3Sadam
6450bafdad3Sadam rdnval.on_bi.bi_op_add = rdnval_op_add;
6460bafdad3Sadam rdnval.on_bi.bi_op_modrdn = rdnval_op_rename;
6470bafdad3Sadam
6480bafdad3Sadam rdnval.on_bi.bi_db_init = rdnval_db_init;
6490bafdad3Sadam rdnval.on_bi.bi_db_open = rdnval_db_open;
6500bafdad3Sadam
6510bafdad3Sadam return overlay_register( &rdnval );
6520bafdad3Sadam }
6530bafdad3Sadam
6540bafdad3Sadam #if SLAPD_OVER_RDNVAL == SLAPD_MOD_DYNAMIC
6550bafdad3Sadam int
init_module(int argc,char * argv[])6560bafdad3Sadam init_module( int argc, char *argv[] )
6570bafdad3Sadam {
6580bafdad3Sadam return rdnval_initialize();
6590bafdad3Sadam }
6600bafdad3Sadam #endif /* SLAPD_OVER_RDNVAL == SLAPD_MOD_DYNAMIC */
6610bafdad3Sadam
6620bafdad3Sadam #endif /* SLAPD_OVER_RDNVAL */
663