servers/slapd/overlays/rwm.c - diff

Return to rwm.c CVS log

Up to [OpenLDAP] / servers / slapd / overlays

Diff for /servers/slapd/overlays/rwm.c between versions 1.37 and 1.37.2.16

version 1.37, 2004/12/01 20:47:13	version 1.37.2.16, 2007/01/02 21:44:08
Line 1	Line 1
/* rwm.c - rewrite/remap operations */	/* rwm.c - rewrite/remap operations */
/* $OpenLDAP: pkg/ldap/servers/slapd/overlays/rwm.c,v 1.36 2004/11/13 16:27:15 ando Exp $ */	/* $OpenLDAP: pkg/ldap/servers/slapd/overlays/rwm.c,v 1.37.2.15 2006/01/03 22:16:25 kurt Exp $ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.	/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*	*
* Copyright 2003-2004 The OpenLDAP Foundation.	* Copyright 2003-2007 The OpenLDAP Foundation.
* Portions Copyright 2003 Pierangelo Masarati.	* Portions Copyright 2003 Pierangelo Masarati.
* All rights reserved.	* All rights reserved.
*	*
Line 34 rwm_op_dn_massage( Operation *op, SlapRe	Line 34 rwm_op_dn_massage( Operation *op, SlapRe
(struct ldaprwmap *)on->on_bi.bi_private;	(struct ldaprwmap *)on->on_bi.bi_private;

struct berval dn = BER_BVNULL,	struct berval dn = BER_BVNULL,
*dnp = NULL,
ndn = BER_BVNULL;	ndn = BER_BVNULL;
int rc = 0;	int rc = 0;
dncookie dc;	dncookie dc;
Line 56 rwm_op_dn_massage( Operation *op, SlapRe	Line 55 rwm_op_dn_massage( Operation *op, SlapRe
* and the caller sets op->o_req_dn = op->o_req_ndn,	* and the caller sets op->o_req_dn = op->o_req_ndn,
* only rewrite the op->o_req_ndn and use it as	* only rewrite the op->o_req_ndn and use it as
* op->o_req_dn as well */	* op->o_req_dn as well */
	ndn = op->o_req_ndn;
if ( op->o_req_dn.bv_val != op->o_req_ndn.bv_val ) {	if ( op->o_req_dn.bv_val != op->o_req_ndn.bv_val ) {
dnp = &dn;	dn = op->o_req_dn;
	rc = rwm_dn_massage_pretty_normalize( &dc, &op->o_req_dn, &dn, &ndn );
	} else {
	rc = rwm_dn_massage_normalize( &dc, &op->o_req_ndn, &ndn );
}	}

rc = rwm_dn_massage( &dc, &op->o_req_dn, dnp, &ndn );
if ( rc != LDAP_SUCCESS ) {	if ( rc != LDAP_SUCCESS ) {
return rc;	return rc;
}	}

if ( ( dnp && dn.bv_val == op->o_req_dn.bv_val ) \|\|	if ( ( op->o_req_dn.bv_val != op->o_req_ndn.bv_val && dn.bv_val == op->o_req_dn.bv_val )
( !dnp && ndn.bv_val == op->o_req_ndn.bv_val ) ) {	\|\| ndn.bv_val == op->o_req_ndn.bv_val )
	{
return LDAP_SUCCESS;	return LDAP_SUCCESS;
}	}

op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx );	if ( op->o_req_dn.bv_val != op->o_req_ndn.bv_val ) {
if ( dnp ) {
op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx );	op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx );
op->o_req_dn = dn;	op->o_req_dn = dn;
} else {	} else {
op->o_req_dn = ndn;	op->o_req_dn = ndn;
}	}
	op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx );
op->o_req_ndn = ndn;	op->o_req_ndn = ndn;

return LDAP_SUCCESS;	return LDAP_SUCCESS;
}	}

static int	static int
rwm_add( Operation op, SlapReply rs )	rwm_op_add( Operation op, SlapReply rs )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
struct ldaprwmap *rwmap =	struct ldaprwmap *rwmap =
Line 93 rwm_add( Operation op, SlapReply rs )	Line 96 rwm_add( Operation op, SlapReply rs )
i;	i;
Attribute **ap = NULL;	Attribute **ap = NULL;
char *olddn = op->o_req_dn.bv_val;	char *olddn = op->o_req_dn.bv_val;
	int isupdate;

#ifdef ENABLE_REWRITE	#ifdef ENABLE_REWRITE
rc = rwm_op_dn_massage( op, rs, "addDN" );	rc = rwm_op_dn_massage( op, rs, "addDN" );
Line 107 rwm_add( Operation op, SlapReply rs )	Line 111 rwm_add( Operation op, SlapReply rs )
}	}

if ( olddn != op->o_req_dn.bv_val ) {	if ( olddn != op->o_req_dn.bv_val ) {
ch_free( op->ora_e->e_name.bv_val );	ber_bvreplace( &op->ora_e->e_name, &op->o_req_dn );
ch_free( op->ora_e->e_nname.bv_val );	ber_bvreplace( &op->ora_e->e_nname, &op->o_req_ndn );

ber_dupbv( &op->ora_e->e_name, &op->o_req_dn );
ber_dupbv( &op->ora_e->e_nname, &op->o_req_ndn );
}	}

/* Count number of attributes in entry */	/* Count number of attributes in entry */
	isupdate = be_shadow_update( op );
for ( i = 0, ap = &op->oq_add.rs_e->e_attrs; *ap; ) {	for ( i = 0, ap = &op->oq_add.rs_e->e_attrs; *ap; ) {
struct berval mapped;
Attribute *a;	Attribute *a;

if ( (*ap)->a_desc->ad_type->sat_no_user_mod ) {	if ( (*ap)->a_desc == slap_schema.si_ad_objectClass \|\|
goto next_attr;	(*ap)->a_desc == slap_schema.si_ad_structuralObjectClass )
}	{
	int j, last;

rwm_map( &rwmap->rwm_at, &(*ap)->a_desc->ad_cname,	for ( last = 0; !BER_BVISNULL( &(*ap)->a_vals[ last ] ); last++ )
&mapped, RWM_MAP );	/* count values */ ;
if ( BER_BVISNULL( &mapped ) \|\| BER_BVISEMPTY( &mapped ) ) {	last--;
goto cleanup_attr;	for ( j = 0; !BER_BVISNULL( &(*ap)->a_vals[ j ] ); j++ ) {
}	struct ldapmapping *mapping = NULL;

	( void )rwm_mapping( &rwmap->rwm_oc, &(*ap)->a_vals[ j ],
	&mapping, RWM_MAP );
	if ( mapping == NULL ) {
	if ( rwmap->rwm_at.drop_missing ) {
	/* FIXME: we allow to remove objectClasses as well;
	* if the resulting entry is inconsistent, that's
	* the relayed database's business...
	*/
	ch_free( (*ap)->a_vals[ j ].bv_val );
	if ( last > j ) {
	(ap)->a_vals[ j ] = (ap)->a_vals[ last ];
	}
	BER_BVZERO( &(*ap)->a_vals[ last ] );
	last--;
	j--;
	}

if ( (*ap)->a_desc->ad_type->sat_syntax	} else {
== slap_schema.si_syn_distinguishedName )	ch_free( (*ap)->a_vals[ j ].bv_val );
	ber_dupbv( &(*ap)->a_vals[ j ], &mapping->m_dst );
	}
	}

	} else if ( !isupdate && !get_manageDIT( op ) && (*ap)->a_desc->ad_type->sat_no_user_mod )
{	{
/*	goto next_attr;
* FIXME: rewrite could fail; in this case
* the operation should give up, right?	} else {
*/	struct ldapmapping *mapping = NULL;
#ifdef ENABLE_REWRITE
rc = rwm_dnattr_rewrite( op, rs, "addAttrDN",	( void )rwm_mapping( &rwmap->rwm_at, &(*ap)->a_desc->ad_cname,
(*ap)->a_vals,	&mapping, RWM_MAP );
(ap)->a_nvals ? &(ap)->a_nvals : NULL );	if ( mapping == NULL ) {
	if ( rwmap->rwm_at.drop_missing ) {
	goto cleanup_attr;
	}
	}

	if ( (*ap)->a_desc->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName
	\|\| ( mapping != NULL && mapping->m_dst_ad->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName ) )
	{
	/*
	* FIXME: rewrite could fail; in this case
	* the operation should give up, right?
	*/
	#ifdef ENABLE_REWRITE
	rc = rwm_dnattr_rewrite( op, rs, "addAttrDN",
	(*ap)->a_vals,
	(ap)->a_nvals ? &(ap)->a_nvals : NULL );
#else /* ! ENABLE_REWRITE */	#else /* ! ENABLE_REWRITE */
rc = 1;	rc = 1;
rc = rwm_dnattr_rewrite( op, rs, &rc, (*ap)->a_vals,	rc = rwm_dnattr_rewrite( op, rs, &rc, (*ap)->a_vals,
(ap)->a_nvals ? &(ap)->a_nvals : NULL );	(ap)->a_nvals ? &(ap)->a_nvals : NULL );
#endif /* ! ENABLE_REWRITE */	#endif /* ! ENABLE_REWRITE */
if ( rc ) {	if ( rc ) {
goto cleanup_attr;	goto cleanup_attr;
}	}

} else if ( (*ap)->a_desc == slap_schema.si_ad_ref ) {	} else if ( (*ap)->a_desc == slap_schema.si_ad_ref ) {
#ifdef ENABLE_REWRITE	#ifdef ENABLE_REWRITE
rc = rwm_referral_rewrite( op, rs, "referralAttrDN",	rc = rwm_referral_rewrite( op, rs, "referralAttrDN",
(*ap)->a_vals,	(*ap)->a_vals,
(ap)->a_nvals ? &(ap)->a_nvals : NULL );	(ap)->a_nvals ? &(ap)->a_nvals : NULL );
#else /* ! ENABLE_REWRITE */	#else /* ! ENABLE_REWRITE */
rc = 1;	rc = 1;
rc = rwm_referral_rewrite( op, rs, &rc, (*ap)->a_vals,	rc = rwm_referral_rewrite( op, rs, &rc, (*ap)->a_vals,
(ap)->a_nvals ? &(ap)->a_nvals : NULL );	(ap)->a_nvals ? &(ap)->a_nvals : NULL );
#endif /* ! ENABLE_REWRITE */	#endif /* ! ENABLE_REWRITE */
if ( rc != LDAP_SUCCESS ) {	if ( rc != LDAP_SUCCESS ) {
goto cleanup_attr;	goto cleanup_attr;
	}
	}

	if ( mapping != NULL ) {
	assert( mapping->m_dst_ad != NULL );
	(*ap)->a_desc = mapping->m_dst_ad;
}	}
}	}


next_attr:;	next_attr:;
ap = &(*ap)->a_next;	ap = &(*ap)->a_next;
continue;	continue;
Line 181 cleanup_attr:;	Line 226 cleanup_attr:;
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}

	#ifdef ENABLE_REWRITE
static int	static int
rwm_bind( Operation op, SlapReply rs )	rwm_conn_init( BackendDB be, Connection conn )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) be->bd_info;
struct ldaprwmap *rwmap =	struct ldaprwmap *rwmap =
(struct ldaprwmap *)on->on_bi.bi_private;	(struct ldaprwmap *)on->on_bi.bi_private;

	( void )rewrite_session_init( rwmap->rwm_rw, conn );

	return SLAP_CB_CONTINUE;
	}

	static int
	rwm_conn_destroy( BackendDB be, Connection conn )
	{
	slap_overinst on = (slap_overinst ) be->bd_info;
	struct ldaprwmap *rwmap =
	(struct ldaprwmap *)on->on_bi.bi_private;

	( void )rewrite_session_delete( rwmap->rwm_rw, conn );

	return SLAP_CB_CONTINUE;
	}
	#endif /* ENABLE_REWRITE */

	static int
	rwm_op_bind( Operation op, SlapReply rs )
	{
	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
int rc;	int rc;

#ifdef ENABLE_REWRITE	#ifdef ENABLE_REWRITE
( void )rewrite_session_delete( rwmap->rwm_rw, op->o_conn );
( void )rewrite_session_init( rwmap->rwm_rw, op->o_conn );

rc = rwm_op_dn_massage( op, rs, "bindDN" );	rc = rwm_op_dn_massage( op, rs, "bindDN" );
#else /* ! ENABLE_REWRITE */	#else /* ! ENABLE_REWRITE */
rc = 1;	rc = 1;
Line 208 rwm_bind( Operation op, SlapReply rs )	Line 274 rwm_bind( Operation op, SlapReply rs )
}	}

static int	static int
rwm_unbind( Operation op, SlapReply rs )	rwm_op_unbind( Operation op, SlapReply rs )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
struct ldaprwmap *rwmap =	struct ldaprwmap *rwmap =
Line 222 rwm_unbind( Operation op, SlapReply rs	Line 288 rwm_unbind( Operation op, SlapReply rs
}	}

static int	static int
rwm_compare( Operation op, SlapReply rs )	rwm_op_compare( Operation op, SlapReply rs )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
struct ldaprwmap *rwmap =	struct ldaprwmap *rwmap =
Line 257 rwm_compare( Operation op, SlapReply r	Line 323 rwm_compare( Operation op, SlapReply r
return -1;	return -1;

} else if ( mapped_vals[0].bv_val != op->orc_ava->aa_value.bv_val ) {	} else if ( mapped_vals[0].bv_val != op->orc_ava->aa_value.bv_val ) {
free( op->orc_ava->aa_value.bv_val );	ber_bvreplace_x( &op->orc_ava->aa_value, &mapped_vals[0], op->o_tmpmemctx );
op->orc_ava->aa_value = mapped_vals[0];
}	}
mapped_at = op->orc_ava->aa_desc->ad_cname;	mapped_at = op->orc_ava->aa_desc->ad_cname;

} else {	} else {
rwm_map( &rwmap->rwm_at, &op->orc_ava->aa_desc->ad_cname,	struct ldapmapping *mapping = NULL;
&mapped_at, RWM_MAP );	AttributeDescription *ad = op->orc_ava->aa_desc;
if ( BER_BVISNULL( &mapped_at ) \|\| BER_BVISEMPTY( &mapped_at ) )
{	( void )rwm_mapping( &rwmap->rwm_at, &op->orc_ava->aa_desc->ad_cname,
op->o_bd->bd_info = (BackendInfo *)on->on_info;	&mapping, RWM_MAP );
send_ldap_error( op, rs, LDAP_OTHER, "compare attributeType map error" );	if ( mapping == NULL ) {
return -1;	if ( rwmap->rwm_at.drop_missing ) {
	op->o_bd->bd_info = (BackendInfo *)on->on_info;
	send_ldap_error( op, rs, LDAP_OTHER, "compare attributeType map error" );
	return -1;
	}

	} else {
	assert( mapping->m_dst_ad != NULL );
	ad = mapping->m_dst_ad;
}	}
if ( op->orc_ava->aa_desc->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName )
	if ( op->orc_ava->aa_desc->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName
	\|\| ( mapping != NULL && mapping->m_dst_ad->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName ) )
{	{
struct berval *mapped_valsp[2];	struct berval *mapped_valsp[2];

Line 293 rwm_compare( Operation op, SlapReply r	Line 368 rwm_compare( Operation op, SlapReply r
return -1;	return -1;
}	}

op->orc_ava->aa_value = mapped_vals[0];	if ( mapped_vals[ 0 ].bv_val != op->orc_ava->aa_value.bv_val ) {
	/* NOTE: if we get here, rwm_dnattr_rewrite()
	* already freed the old value, so now
	* it's invalid */
	ber_dupbv_x( &op->orc_ava->aa_value, &mapped_vals[0],
	op->o_tmpmemctx );
	ber_memfree_x( mapped_vals[ 0 ].bv_val, NULL );
	}
}	}
	op->orc_ava->aa_desc = ad;
}	}

return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}

static int	static int
rwm_delete( Operation op, SlapReply rs )	rwm_op_delete( Operation op, SlapReply rs )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
int rc;	int rc;
Line 322 rwm_delete( Operation op, SlapReply rs	Line 405 rwm_delete( Operation op, SlapReply rs
}	}

static int	static int
rwm_modify( Operation op, SlapReply rs )	rwm_op_modify( Operation op, SlapReply rs )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
struct ldaprwmap *rwmap =	struct ldaprwmap *rwmap =
(struct ldaprwmap *)on->on_bi.bi_private;	(struct ldaprwmap *)on->on_bi.bi_private;

	int isupdate;
Modifications **mlp;	Modifications **mlp;
int rc;	int rc;

Line 343 rwm_modify( Operation op, SlapReply rs	Line 427 rwm_modify( Operation op, SlapReply rs
return -1;	return -1;
}	}

	isupdate = be_shadow_update( op );
for ( mlp = &op->oq_modify.rs_modlist; *mlp; ) {	for ( mlp = &op->oq_modify.rs_modlist; *mlp; ) {
int is_oc = 0;	int is_oc = 0;
Modifications *ml;	Modifications *ml;
	struct ldapmapping *mapping = NULL;
if ( (*mlp)->sml_desc->ad_type->sat_no_user_mod ) {
goto next_mod;
}

if ( (*mlp)->sml_desc == slap_schema.si_ad_objectClass	if ( (*mlp)->sml_desc == slap_schema.si_ad_objectClass
\|\| (*mlp)->sml_desc == slap_schema.si_ad_structuralObjectClass ) {	\|\| (*mlp)->sml_desc == slap_schema.si_ad_structuralObjectClass )
	{
is_oc = 1;	is_oc = 1;

	} else if ( !isupdate && !get_manageDIT( op ) && (*mlp)->sml_desc->ad_type->sat_no_user_mod )
	{
	goto next_mod;

} else {	} else {
struct ldapmapping *m;
int drop_missing;	int drop_missing;

drop_missing = rwm_mapping( &rwmap->rwm_at, &(*mlp)->sml_desc->ad_cname, &m, RWM_MAP );	drop_missing = rwm_mapping( &rwmap->rwm_at,
if ( drop_missing \|\| ( m != NULL && BER_BVISNULL( &m->m_dst ) ) )	&(*mlp)->sml_desc->ad_cname,
	&mapping, RWM_MAP );
	if ( drop_missing \|\| ( mapping != NULL && BER_BVISNULL( &mapping->m_dst ) ) )
{	{
goto cleanup_mod;	goto cleanup_mod;
}	}

if ( m ) {
/* use new attribute description */
assert( m->m_dst_ad );
(*mlp)->sml_desc = m->m_dst_ad;
}
}	}

if ( (*mlp)->sml_values != NULL ) {	if ( (*mlp)->sml_values != NULL ) {
if ( is_oc ) {	if ( is_oc ) {
int last, j;	int last, j;

for ( last = 0; !BER_BVISNULL( &(*mlp)->sml_values[last] ); last++ )	for ( last = 0; !BER_BVISNULL( &(*mlp)->sml_values[ last ] ); last++ )
/* count values */ ;	/* count values */ ;
last--;	last--;

for ( j = 0; !BER_BVISNULL( &(*mlp)->sml_values[j] ); j++ ) {	for ( j = 0; !BER_BVISNULL( &(*mlp)->sml_values[ j ] ); j++ ) {
struct berval mapped = BER_BVNULL;	struct ldapmapping *oc_mapping = NULL;

rwm_map( &rwmap->rwm_oc,	( void )rwm_mapping( &rwmap->rwm_oc, &(*mlp)->sml_values[ j ],
&(*mlp)->sml_values[j],	&oc_mapping, RWM_MAP );
&mapped, RWM_MAP );	if ( oc_mapping == NULL ) {
if ( BER_BVISNULL( &mapped ) \|\| BER_BVISEMPTY( &mapped ) ) {	if ( rwmap->rwm_at.drop_missing ) {
/* FIXME: we allow to remove objectClasses as well;	/* FIXME: we allow to remove objectClasses as well;
* if the resulting entry is inconsistent, that's	* if the resulting entry is inconsistent, that's
* the relayed database's business...	* the relayed database's business...
*/	*/
#if 0	ch_free( (*mlp)->sml_values[ j ].bv_val );
goto cleanup_mod;	if ( last > j ) {
#endif	(mlp)->sml_values[ j ] = (mlp)->sml_values[ last ];
if ( last > j ) {	}
(mlp)->sml_values[j] = (mlp)->sml_values[last];	BER_BVZERO( &(*mlp)->sml_values[ last ] );
BER_BVZERO( &(*mlp)->sml_values[last] );	last--;
	j--;
}	}
last--;

} else {	} else {
ch_free( (*mlp)->sml_values[j].bv_val );	ch_free( (*mlp)->sml_values[ j ].bv_val );
ber_dupbv( &(*mlp)->sml_values[j], &mapped );	ber_dupbv( &(*mlp)->sml_values[ j ], &oc_mapping->m_dst );
}	}
}	}

} else {	} else {
if ( (*mlp)->sml_desc->ad_type->sat_syntax ==	if ( (*mlp)->sml_desc->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName
slap_schema.si_syn_distinguishedName )	\|\| ( mapping != NULL && mapping->m_dst_ad->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName ) )
{	{
#ifdef ENABLE_REWRITE	#ifdef ENABLE_REWRITE
rc = rwm_dnattr_rewrite( op, rs, "modifyAttrDN",	rc = rwm_dnattr_rewrite( op, rs, "modifyAttrDN",
Line 445 rwm_modify( Operation op, SlapReply rs	Line 527 rwm_modify( Operation op, SlapReply rs
}	}

next_mod:;	next_mod:;
	if ( mapping != NULL ) {
	/* use new attribute description */
	assert( mapping->m_dst_ad != NULL );
	(*mlp)->sml_desc = mapping->m_dst_ad;
	}

mlp = &(*mlp)->sml_next;	mlp = &(*mlp)->sml_next;
continue;	continue;

Line 455 cleanup_mod:;	Line 543 cleanup_mod:;
free( ml );	free( ml );
}	}

/* TODO: rewrite attribute types, values of DN-valued attributes ... */
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}

static int	static int
rwm_modrdn( Operation op, SlapReply rs )	rwm_op_modrdn( Operation op, SlapReply rs )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
struct ldaprwmap *rwmap =	struct ldaprwmap *rwmap =
Line 485 rwm_modrdn( Operation op, SlapReply rs	Line 572 rwm_modrdn( Operation op, SlapReply rs
dc.tofrom = 0;	dc.tofrom = 0;
dc.normalized = 0;	dc.normalized = 0;
#endif /* ! ENABLE_REWRITE */	#endif /* ! ENABLE_REWRITE */
rc = rwm_dn_massage( &dc, op->orr_newSup, &newSup, &nnewSup );	newSup = *op->orr_newSup;
	nnewSup = *op->orr_nnewSup;
	rc = rwm_dn_massage_pretty_normalize( &dc, op->orr_newSup, &newSup, &nnewSup );
if ( rc != LDAP_SUCCESS ) {	if ( rc != LDAP_SUCCESS ) {
op->o_bd->bd_info = (BackendInfo *)on->on_info;	op->o_bd->bd_info = (BackendInfo *)on->on_info;
send_ldap_error( op, rs, rc, "newSuperiorDN massage error" );	send_ldap_error( op, rs, rc, "newSuperiorDN massage error" );
Line 515 rwm_modrdn( Operation op, SlapReply rs	Line 604 rwm_modrdn( Operation op, SlapReply rs
return -1;	return -1;
}	}

/* TODO: rewrite attribute types, values of DN-valued attributes ... */	/* TODO: rewrite newRDN, attribute types,
	* values of DN-valued attributes ... */
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}

	static slap_callback rwm_cb;

	static void
	rwm_keyfree(
	void *key,
	void *data )
	{
	ber_memfree_x( data, NULL );
	}

	static slap_callback *
	rwm_callback_get( Operation *op )
	{
	void *data = NULL;

	if ( op->o_threadctx == NULL ) {
	return &rwm_cb;
	}

	ldap_pvt_thread_pool_getkey( op->o_threadctx,
	rwm_keyfree, &data, NULL );
	if ( data == NULL ) {
	data = ch_calloc( sizeof( slap_callback ), 1 );
	ldap_pvt_thread_pool_setkey( op->o_threadctx,
	rwm_keyfree, data, rwm_keyfree );
	}

	return (slap_callback *)data;
	}

static int	static int
rwm_swap_attrs( Operation op, SlapReply rs )	rwm_swap_attrs( Operation op, SlapReply rs )
{	{
Line 530 rwm_swap_attrs( Operation *op, SlapReply	Line 650 rwm_swap_attrs( Operation *op, SlapReply
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}

static int rwm_freeself( Operation op, SlapReply rs )
{
if ( op->o_tag == LDAP_REQ_SEARCH && rs->sr_type == REP_RESULT ) {
assert( op->o_callback );

op->o_tmpfree( op->o_callback, op->o_tmpmemctx );
op->o_callback = NULL;
}

return SLAP_CB_CONTINUE;
}

static int	static int
rwm_search( Operation op, SlapReply rs )	rwm_op_search( Operation op, SlapReply rs )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
struct ldaprwmap *rwmap =	struct ldaprwmap *rwmap =
Line 555 rwm_search( Operation op, SlapReply rs	Line 663 rwm_search( Operation op, SlapReply rs
struct berval fstr = BER_BVNULL;	struct berval fstr = BER_BVNULL;
Filter *f = NULL;	Filter *f = NULL;

slap_callback *cb;	slap_callback *cb = NULL;
AttributeName *an = NULL;	AttributeName *an = NULL;

char *text = NULL;	char *text = NULL;

#ifdef ENABLE_REWRITE	#ifdef ENABLE_REWRITE
rc = rwm_op_dn_massage( op, rs, "searchDN" );	rc = rewrite_session_var_set( rwmap->rwm_rw, op->o_conn,
	"searchFilter", op->ors_filterstr.bv_val );
	if ( rc == LDAP_SUCCESS )
	rc = rwm_op_dn_massage( op, rs, "searchDN" );
#else /* ! ENABLE_REWRITE */	#else /* ! ENABLE_REWRITE */
rc = 1;	rc = 1;
rc = rwm_op_dn_massage( op, rs, &rc );	rc = rwm_op_dn_massage( op, rs, &rc );
Line 584 rwm_search( Operation op, SlapReply rs	Line 695 rwm_search( Operation op, SlapReply rs
dc.normalized = 0;	dc.normalized = 0;
#endif /* ! ENABLE_REWRITE */	#endif /* ! ENABLE_REWRITE */

rc = rwm_filter_map_rewrite( &dc, op->ors_filter, &fstr );	rc = rwm_filter_map_rewrite( op, &dc, op->ors_filter, &fstr );
if ( rc != LDAP_SUCCESS ) {	if ( rc != LDAP_SUCCESS ) {
text = "searchFilter/searchFilterAttrDN massage error";	text = "searchFilter/searchFilterAttrDN massage error";
goto error_return;	goto error_return;
Line 615 rwm_search( Operation op, SlapReply rs	Line 726 rwm_search( Operation op, SlapReply rs
goto error_return;	goto error_return;
}	}

cb = (slap_callback *) op->o_tmpcalloc( sizeof( slap_callback ),	cb = rwm_callback_get( op );
1, op->o_tmpmemctx );
if ( cb == NULL ) {
rc = LDAP_NO_MEMORY;
goto error_return;
}

cb->sc_response = rwm_swap_attrs;	cb->sc_response = rwm_swap_attrs;
cb->sc_cleanup = rwm_freeself;	cb->sc_cleanup = NULL;
cb->sc_private = (void *)op->ors_attrs;	cb->sc_private = (void *)op->ors_attrs;
cb->sc_next = op->o_callback;	cb->sc_next = op->o_callback;

Line 699 rwm_matched( Operation op, SlapReply r	Line 805 rwm_matched( Operation op, SlapReply r
dc.normalized = 0;	dc.normalized = 0;
#endif /* ! ENABLE_REWRITE */	#endif /* ! ENABLE_REWRITE */
ber_str2bv( rs->sr_matched, 0, 0, &dn );	ber_str2bv( rs->sr_matched, 0, 0, &dn );
rc = rwm_dn_massage( &dc, &dn, &mdn, NULL );	mdn = dn;
	rc = rwm_dn_massage_pretty( &dc, &dn, &mdn );
if ( rc != LDAP_SUCCESS ) {	if ( rc != LDAP_SUCCESS ) {
rs->sr_err = rc;	rs->sr_err = rc;
rs->sr_text = "Rewrite error";	rs->sr_text = "Rewrite error";
Line 720 rwm_matched( Operation op, SlapReply r	Line 827 rwm_matched( Operation op, SlapReply r
}	}

static int	static int
rwm_attrs( Operation op, SlapReply rs, Attribute** a_first )	rwm_attrs( Operation op, SlapReply rs, Attribute** a_first, int stripEntryDN )
{	{
slap_overinst on = (slap_overinst ) op->o_bd->bd_info;	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
struct ldaprwmap *rwmap =	struct ldaprwmap *rwmap =
Line 729 rwm_attrs( Operation op, SlapReply rs,	Line 836 rwm_attrs( Operation op, SlapReply rs,
dncookie dc;	dncookie dc;
int rc;	int rc;
Attribute **ap;	Attribute **ap;
	int isupdate;

/*	/*
* Rewrite the dn attrs, if needed	* Rewrite the dn attrs, if needed
Line 754 rwm_attrs( Operation op, SlapReply rs,	Line 862 rwm_attrs( Operation op, SlapReply rs,
* an error (because multiple instances of attrs in	* an error (because multiple instances of attrs in
* response are not valid), or merge the values (what	* response are not valid), or merge the values (what
* about duplicate values?) */	* about duplicate values?) */
	isupdate = be_shadow_update( op );
for ( ap = a_first; *ap; ) {	for ( ap = a_first; *ap; ) {
struct ldapmapping *m;	struct ldapmapping *mapping = NULL;
int drop_missing;	int drop_missing;
int last;	int last;
Attribute *a;	Attribute *a;
Line 764 rwm_attrs( Operation op, SlapReply rs,	Line 873 rwm_attrs( Operation op, SlapReply rs,
{	{
/* go on */ ;	/* go on */ ;

} else if ( op->ors_attrs != NULL &&	} else {
!SLAP_USERATTRS( rs->sr_attr_flags ) &&	if ( op->ors_attrs != NULL &&
!ad_inlist( (*ap)->a_desc, op->ors_attrs ) )	!SLAP_USERATTRS( rs->sr_attr_flags ) &&
{	!ad_inlist( (*ap)->a_desc, op->ors_attrs ) )
goto cleanup_attr;	{
	goto cleanup_attr;
	}

	drop_missing = rwm_mapping( &rwmap->rwm_at,
	&(*ap)->a_desc->ad_cname, &mapping, RWM_REMAP );
	if ( drop_missing \|\| ( mapping != NULL && BER_BVISEMPTY( &mapping->m_dst ) ) )
	{
	goto cleanup_attr;
	}

	if ( mapping != NULL ) {
	(*ap)->a_desc = mapping->m_dst_ad;
	}
}	}

if ( (*ap)->a_desc->ad_type->sat_no_user_mod	if ( (*ap)->a_desc == slap_schema.si_ad_entryDN ) {
	if ( stripEntryDN ) {
	/* will be generated by frontend */
	goto cleanup_attr;
	}

	} else if ( !isupdate
	&& !get_manageDIT( op )
	&& (*ap)->a_desc->ad_type->sat_no_user_mod
&& (*ap)->a_desc->ad_type != slap_schema.si_at_undefined )	&& (*ap)->a_desc->ad_type != slap_schema.si_at_undefined )
{	{
goto next_attr;	goto next_attr;
}	}

drop_missing = rwm_mapping( &rwmap->rwm_at,
&(*ap)->a_desc->ad_cname, &m, RWM_REMAP );
if ( drop_missing \|\| ( m != NULL && BER_BVISEMPTY( &m->m_dst ) ) ) {
goto cleanup_attr;
}

for ( last = 0; !BER_BVISNULL( &(*ap)->a_vals[last] ); last++ )	for ( last = 0; !BER_BVISNULL( &(*ap)->a_vals[last] ); last++ )
/* just count */ ;	/* just count */ ;

if ( last == 0 ) {	if ( last == 0 ) {
/* empty? for now, we leave it in place */	/* empty? leave it in place because of attrsonly and vlv */
goto next_attr;	goto next_attr;
}	}
last--;	last--;
Line 817 rwm_attrs( Operation op, SlapReply rs,	Line 941 rwm_attrs( Operation op, SlapReply rs,
* the value is replaced by	* the value is replaced by
* ch_alloc'ed memory	* ch_alloc'ed memory
*/	*/
ch_free( bv[0].bv_val );	ber_bvreplace( &bv[0], &mapped );
ber_dupbv( &bv[0], &mapped );
}	}
}	}

Line 834 rwm_attrs( Operation op, SlapReply rs,	Line 957 rwm_attrs( Operation op, SlapReply rs,
* everything pass thru the ldap backend. */	* everything pass thru the ldap backend. */
/* FIXME: handle distinguishedName-like syntaxes, like	/* FIXME: handle distinguishedName-like syntaxes, like
* nameAndOptionalUID */	* nameAndOptionalUID */
} else if ( (*ap)->a_desc->ad_type->sat_syntax ==	} else if ( (*ap)->a_desc->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName
slap_schema.si_syn_distinguishedName )	\|\| ( mapping != NULL && mapping->m_src_ad->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName ) )
{	{
#ifdef ENABLE_REWRITE	#ifdef ENABLE_REWRITE
dc.ctx = "searchAttrDN";	dc.ctx = "searchAttrDN";
Line 855 rwm_attrs( Operation op, SlapReply rs,	Line 978 rwm_attrs( Operation op, SlapReply rs,
}	}
}	}

if ( m != NULL ) {	if ( mapping != NULL ) {
/* rewrite the attribute description */	/* rewrite the attribute description */
assert( m->m_dst_ad );	assert( mapping->m_dst_ad != NULL );
(*ap)->a_desc = m->m_dst_ad;	(*ap)->a_desc = mapping->m_dst_ad;
}	}

next_attr:;	next_attr:;
Line 883 rwm_send_entry( Operation *op, SlapReply	Line 1006 rwm_send_entry( Operation *op, SlapReply
(struct ldaprwmap *)on->on_bi.bi_private;	(struct ldaprwmap *)on->on_bi.bi_private;

Entry *e = NULL;	Entry *e = NULL;
int flags;	slap_mask_t flags;
struct berval dn = BER_BVNULL,	struct berval dn = BER_BVNULL,
ndn = BER_BVNULL;	ndn = BER_BVNULL;
dncookie dc;	dncookie dc;
int rc;	int rc;

assert( rs->sr_entry );	assert( rs->sr_entry != NULL );

/*	/*
* Rewrite the dn of the result, if needed	* Rewrite the dn of the result, if needed
Line 920 rwm_send_entry( Operation *op, SlapReply	Line 1043 rwm_send_entry( Operation *op, SlapReply
goto fail;	goto fail;
}	}

	flags &= ~REP_ENTRY_MUSTRELEASE;
flags \|= ( REP_ENTRY_MODIFIABLE \| REP_ENTRY_MUSTBEFREED );	flags \|= ( REP_ENTRY_MODIFIABLE \| REP_ENTRY_MUSTBEFREED );
}	}

Line 928 rwm_send_entry( Operation *op, SlapReply	Line 1052 rwm_send_entry( Operation *op, SlapReply
* from the one known to the meta, and a DN with unknown	* from the one known to the meta, and a DN with unknown
* attributes is returned.	* attributes is returned.
*/	*/
rc = rwm_dn_massage( &dc, &e->e_name, &dn, &ndn );	dn = e->e_name;
	ndn = e->e_nname;
	rc = rwm_dn_massage_pretty_normalize( &dc, &e->e_name, &dn, &ndn );
if ( rc != LDAP_SUCCESS ) {	if ( rc != LDAP_SUCCESS ) {
rc = 1;	rc = 1;
goto fail;	goto fail;
Line 948 rwm_send_entry( Operation *op, SlapReply	Line 1074 rwm_send_entry( Operation *op, SlapReply
/* FIXME: the entries are in the remote mapping form;	/* FIXME: the entries are in the remote mapping form;
* so we need to select those attributes we are willing	* so we need to select those attributes we are willing
* to return, and remap them accordingly */	* to return, and remap them accordingly */
(void)rwm_attrs( op, rs, &e->e_attrs );	(void)rwm_attrs( op, rs, &e->e_attrs, 1 );

	if ( rs->sr_flags & REP_ENTRY_MUSTRELEASE ) {
	be_entry_release_rw( op, rs->sr_entry, 0 );
	}

rs->sr_entry = e;	rs->sr_entry = e;
rs->sr_flags = flags;	rs->sr_flags = flags;
Line 956 rwm_send_entry( Operation *op, SlapReply	Line 1086 rwm_send_entry( Operation *op, SlapReply
return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;

fail:;	fail:;
	if ( e != NULL && e != rs->sr_entry ) {
	if ( e->e_name.bv_val == dn.bv_val ) {
	BER_BVZERO( &e->e_name );
	}

	if ( e->e_nname.bv_val == ndn.bv_val ) {
	BER_BVZERO( &e->e_nname );
	}

	entry_free( e );
	}

if ( !BER_BVISNULL( &dn ) ) {	if ( !BER_BVISNULL( &dn ) ) {
ch_free( dn.bv_val );	ch_free( dn.bv_val );
}	}
Line 964 fail:;	Line 1106 fail:;
ch_free( ndn.bv_val );	ch_free( ndn.bv_val );
}	}

if ( e != NULL && e != rs->sr_entry ) {
entry_free( e );
}

return rc;	return rc;
}	}

Line 978 rwm_operational( Operation *op, SlapRepl	Line 1116 rwm_operational( Operation *op, SlapRepl
* so we need to select those attributes we are willing	* so we need to select those attributes we are willing
* to return, and remap them accordingly */	* to return, and remap them accordingly */
if ( rs->sr_operational_attrs ) {	if ( rs->sr_operational_attrs ) {
rwm_attrs( op, rs, &rs->sr_operational_attrs );	rwm_attrs( op, rs, &rs->sr_operational_attrs, 1 );
	}

	return SLAP_CB_CONTINUE;
	}

	#if 0
	/* don't use this; it cannot be reverted, and leaves op->o_req_dn
	* rewritten for subsequent operations; fine for plain suffixmassage,
	* but destroys everything else */
	static int
	rwm_chk_referrals( Operation op, SlapReply rs )
	{
	slap_overinst on = (slap_overinst ) op->o_bd->bd_info;
	int rc;

	#ifdef ENABLE_REWRITE
	rc = rwm_op_dn_massage( op, rs, "referralCheckDN" );
	#else /* ! ENABLE_REWRITE */
	rc = 1;
	rc = rwm_op_dn_massage( op, rs, &rc );
	#endif /* ! ENABLE_REWRITE */
	if ( rc != LDAP_SUCCESS ) {
	op->o_bd->bd_info = (BackendInfo *)on->on_info;
	send_ldap_error( op, rs, rc, "referralCheckDN massage error" );
	return -1;
}	}

return SLAP_CB_CONTINUE;	return SLAP_CB_CONTINUE;
}	}
	#endif

static int	static int
rwm_rw_config(	rwm_rw_config(
Line 1138 rwm_response( Operation op, SlapReply	Line 1302 rwm_response( Operation op, SlapReply
switch( op->o_tag ) {	switch( op->o_tag ) {
case LDAP_REQ_SEARCH:	case LDAP_REQ_SEARCH:
/* Note: the operation attrs are remapped */	/* Note: the operation attrs are remapped */
if ( op->ors_attrs != NULL && op->ors_attrs != rs->sr_attrs )	if ( rs->sr_type == REP_RESULT
	&& op->ors_attrs != NULL
	&& op->ors_attrs != rs->sr_attrs )
{	{
ch_free( op->ors_attrs );	ch_free( op->ors_attrs );
op->ors_attrs = rs->sr_attrs;	op->ors_attrs = rs->sr_attrs;
Line 1193 rwm_db_config(	Line 1359 rwm_db_config(
char **argv	char **argv
)	)
{	{
	slap_overinst on = (slap_overinst ) be->bd_info;
	struct ldaprwmap *rwmap =
	(struct ldaprwmap *)on->on_bi.bi_private;

int rc = 0;	int rc = 0;
char *argv0 = NULL;	char *argv0 = NULL;

Line 1210 rwm_db_config(	Line 1380 rwm_db_config(
} else if ( strcasecmp( argv[0], "suffixmassage" ) == 0 ) {	} else if ( strcasecmp( argv[0], "suffixmassage" ) == 0 ) {
rc = rwm_suffixmassage_config( be, fname, lineno, argc, argv );	rc = rwm_suffixmassage_config( be, fname, lineno, argc, argv );

	} else if ( strcasecmp( argv[0], "t-f-support" ) == 0 ) {
	if ( argc != 2 ) {
	fprintf( stderr,
	"%s: line %d: \"t-f-support {no\|yes\|discover}\" needs 1 argument.\n",
	fname, lineno );
	return( 1 );
	}

	if ( strcasecmp( argv[ 1 ], "no" ) == 0 ) {
	rwmap->rwm_flags &= ~(RWM_F_SUPPORT_T_F\|RWM_F_SUPPORT_T_F_DISCOVER);

	} else if ( strcasecmp( argv[ 1 ], "yes" ) == 0 ) {
	rwmap->rwm_flags \|= RWM_F_SUPPORT_T_F;

	/* TODO: not implemented yet */
	} else if ( strcasecmp( argv[ 1 ], "discover" ) == 0 ) {
	fprintf( stderr,
	"%s: line %d: \"discover\" not supported yet "
	"in \"t-f-support {no\|yes\|discover}\".\n",
	fname, lineno );
	return( 1 );
	#if 0
	rwmap->rwm_flags \|= RWM_F_SUPPORT_T_F_DISCOVER;
	#endif

	} else {
	fprintf( stderr,
	"%s: line %d: unknown value \"%s\" for \"t-f-support {no\|yes\|discover}\".\n",
	fname, lineno, argv[ 1 ] );
	return 1;
	}

} else {	} else {
rc = SLAP_CONF_UNKNOWN;	rc = SLAP_CONF_UNKNOWN;
}	}
Line 1229 rwm_db_init(	Line 1431 rwm_db_init(
slap_overinst on = (slap_overinst ) be->bd_info;	slap_overinst on = (slap_overinst ) be->bd_info;
struct ldapmapping *mapping = NULL;	struct ldapmapping *mapping = NULL;
struct ldaprwmap *rwmap;	struct ldaprwmap *rwmap;
	#ifdef ENABLE_REWRITE
	char *rargv[ 3 ];
	#endif /* ENABLE_REWRITE */

rwmap = (struct ldaprwmap *)ch_malloc(sizeof(struct ldaprwmap));	rwmap = (struct ldaprwmap *)ch_calloc( 1, sizeof( struct ldaprwmap ) );
memset(rwmap, 0, sizeof(struct ldaprwmap));

#ifdef ENABLE_REWRITE	#ifdef ENABLE_REWRITE
rwmap->rwm_rw = rewrite_info_init( REWRITE_MODE_USE_DEFAULT );	rwmap->rwm_rw = rewrite_info_init( REWRITE_MODE_USE_DEFAULT );
Line 1240 rwm_db_init(	Line 1444 rwm_db_init(
return -1;	return -1;
}	}

{	/* this rewriteContext by default must be null;
char *rargv[3];	* rules can be added if required */
	rargv[ 0 ] = "rewriteContext";
/* this rewriteContext by default must be null;	rargv[ 1 ] = "searchFilter";
* rules can be added if required */	rargv[ 2 ] = NULL;
rargv[ 0 ] = "rewriteContext";	rewrite_parse( rwmap->rwm_rw, "<suffix massage>", 1, 2, rargv );
rargv[ 1 ] = "searchFilter";
rargv[ 2 ] = NULL;	rargv[ 0 ] = "rewriteContext";
rewrite_parse( rwmap->rwm_rw, "<suffix massage>", 1, 2, rargv );	rargv[ 1 ] = "default";
	rargv[ 2 ] = NULL;
rargv[ 0 ] = "rewriteContext";	rewrite_parse( rwmap->rwm_rw, "<suffix massage>", 2, 2, rargv );
rargv[ 1 ] = "default";
rargv[ 2 ] = NULL;
rewrite_parse( rwmap->rwm_rw, "<suffix massage>", 2, 2, rargv );
}

#endif /* ENABLE_REWRITE */	#endif /* ENABLE_REWRITE */

if ( rwm_map_init( &rwmap->rwm_oc, &mapping ) != LDAP_SUCCESS \|\|	if ( rwm_map_init( &rwmap->rwm_oc, &mapping ) != LDAP_SUCCESS \|\|
Line 1282 rwm_db_destroy(	Line 1481 rwm_db_destroy(
(struct ldaprwmap *)on->on_bi.bi_private;	(struct ldaprwmap *)on->on_bi.bi_private;

#ifdef ENABLE_REWRITE	#ifdef ENABLE_REWRITE
if (rwmap->rwm_rw) {	if ( rwmap->rwm_rw ) {
rewrite_info_delete( &rwmap->rwm_rw );	rewrite_info_delete( &rwmap->rwm_rw );
}	}
#else /* !ENABLE_REWRITE */	#else /* !ENABLE_REWRITE */
Line 1291 rwm_db_destroy(	Line 1490 rwm_db_destroy(
}	}
#endif /* !ENABLE_REWRITE */	#endif /* !ENABLE_REWRITE */

avl_free( rwmap->rwm_oc.remap, NULL );	avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_oc.map, rwm_mapping_free );	avl_free( rwmap->rwm_oc.map, rwm_mapping_free );
avl_free( rwmap->rwm_at.remap, NULL );	avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_at.map, rwm_mapping_free );	avl_free( rwmap->rwm_at.map, rwm_mapping_free );

	ch_free( rwmap );
}	}

return rc;	return rc;
Line 1303 rwm_db_destroy(	Line 1504 rwm_db_destroy(
static slap_overinst rwm = { { NULL } };	static slap_overinst rwm = { { NULL } };

int	int
rwm_init(void)	rwm_initialize(void)
{	{
memset( &rwm, 0, sizeof( slap_overinst ) );	memset( &rwm, 0, sizeof( slap_overinst ) );

Line 1313 rwm_init(void)	Line 1514 rwm_init(void)
rwm.on_bi.bi_db_config = rwm_db_config;	rwm.on_bi.bi_db_config = rwm_db_config;
rwm.on_bi.bi_db_destroy = rwm_db_destroy;	rwm.on_bi.bi_db_destroy = rwm_db_destroy;

rwm.on_bi.bi_op_bind = rwm_bind;	rwm.on_bi.bi_op_bind = rwm_op_bind;
rwm.on_bi.bi_op_search = rwm_search;	rwm.on_bi.bi_op_search = rwm_op_search;
rwm.on_bi.bi_op_compare = rwm_compare;	rwm.on_bi.bi_op_compare = rwm_op_compare;
rwm.on_bi.bi_op_modify = rwm_modify;	rwm.on_bi.bi_op_modify = rwm_op_modify;
rwm.on_bi.bi_op_modrdn = rwm_modrdn;	rwm.on_bi.bi_op_modrdn = rwm_op_modrdn;
rwm.on_bi.bi_op_add = rwm_add;	rwm.on_bi.bi_op_add = rwm_op_add;
rwm.on_bi.bi_op_delete = rwm_delete;	rwm.on_bi.bi_op_delete = rwm_op_delete;
rwm.on_bi.bi_op_unbind = rwm_unbind;	rwm.on_bi.bi_op_unbind = rwm_op_unbind;
rwm.on_bi.bi_extended = rwm_extended;	rwm.on_bi.bi_extended = rwm_extended;

rwm.on_bi.bi_operational = rwm_operational;	rwm.on_bi.bi_operational = rwm_operational;
	rwm.on_bi.bi_chk_referrals = 0 /* rwm_chk_referrals */ ;

	#ifdef ENABLE_REWRITE
	rwm.on_bi.bi_connection_init = rwm_conn_init;
	rwm.on_bi.bi_connection_destroy = rwm_conn_destroy;
	#endif /* ENABLE_REWRITE */

rwm.on_response = rwm_response;	rwm.on_response = rwm_response;

Line 1333 rwm_init(void)	Line 1541 rwm_init(void)
int	int
init_module( int argc, char *argv[] )	init_module( int argc, char *argv[] )
{	{
return rwm_init();	return rwm_initialize();
}	}
#endif /* SLAPD_OVER_RWM == SLAPD_MOD_DYNAMIC */	#endif /* SLAPD_OVER_RWM == SLAPD_MOD_DYNAMIC */

Removed from v.1.37
changed lines
	Added in v.1.37.2.16