自学教程：C++ BER_BVC函数代码示例

//.........这里部分代码省略.........			if ( !BER_BVISNULL( &bdb->bi_db_crypt_key )) {				ch_free( bdb->bi_db_crypt_key.bv_val );				BER_BVZERO( &bdb->bi_db_crypt_key );			}			break;		case BDB_DIRECTORY:			bdb->bi_flags |= BDB_RE_OPEN;			bdb->bi_flags ^= BDB_HAS_CONFIG;			ch_free( bdb->bi_dbenv_home );			bdb->bi_dbenv_home = NULL;			ch_free( bdb->bi_db_config_path );			bdb->bi_db_config_path = NULL;			c->cleanup = bdb_cf_cleanup;			ldap_pvt_thread_pool_purgekey( bdb->bi_dbenv );			break;		case BDB_NOSYNC:			bdb->bi_dbenv->set_flags( bdb->bi_dbenv, DB_TXN_NOSYNC, 0 );			break;		case BDB_CHECKSUM:			bdb->bi_flags &= ~BDB_CHKSUM;			break;		case BDB_INDEX:			if ( c->valx == -1 ) {				int i;				/* delete all (FIXME) */				for ( i = 0; i < bdb->bi_nattrs; i++ ) {					bdb->bi_attrs[i]->ai_indexmask |= BDB_INDEX_DELETING;				}				bdb->bi_flags |= BDB_DEL_INDEX;				c->cleanup = bdb_cf_cleanup;			} else {				struct berval bv, def = BER_BVC("default");				char *ptr;				for (ptr = c->line; !isspace( (unsigned char) *ptr ); ptr++);				bv.bv_val = c->line;				bv.bv_len = ptr - bv.bv_val;				if ( bvmatch( &bv, &def )) {					bdb->bi_defaultmask = 0;				} else {					int i;					char **attrs;					char sep;					sep = bv.bv_val[ bv.bv_len ];					bv.bv_val[ bv.bv_len ] = '/0';					attrs = ldap_str2charray( bv.bv_val, "," );					for ( i = 0; attrs[ i ]; i++ ) {						AttributeDescription *ad = NULL;						const char *text;						AttrInfo *ai;						slap_str2ad( attrs[ i ], &ad, &text );						/* if we got here... */						assert( ad != NULL );						ai = bdb_attr_mask( bdb, ad );						/* if we got here... */						assert( ai != NULL );						ai->ai_indexmask |= BDB_INDEX_DELETING;

static intlimits_get( 	Operation		*op,	struct slap_limits_set 	**limit){	static struct berval empty_dn = BER_BVC( "" );	struct slap_limits **lm;	struct berval		*ndns[2];	assert( op != NULL );	assert( limit != NULL );	ndns[0] = &op->o_ndn;	ndns[1] = &op->o_req_ndn;	Debug( LDAP_DEBUG_TRACE, "==> limits_get: %s self=/"%s/" this=/"%s/"/n",			op->o_log_prefix,			BER_BVISNULL( ndns[0] ) ? "[anonymous]" : ndns[0]->bv_val,			BER_BVISNULL( ndns[1] ) ? "" : ndns[1]->bv_val );	/*	 * default values	 */	*limit = &op->o_bd->be_def_limit;	if ( op->o_bd->be_limits == NULL ) {		return( 0 );	}	for ( lm = op->o_bd->be_limits; lm[0] != NULL; lm++ ) {		unsigned	style = lm[0]->lm_flags & SLAP_LIMITS_MASK;		unsigned	type = lm[0]->lm_flags & SLAP_LIMITS_TYPE_MASK;		unsigned	isthis = type == SLAP_LIMITS_TYPE_THIS;		struct berval *ndn = ndns[isthis];		if ( style == SLAP_LIMITS_ANY )			goto found_any;		if ( BER_BVISEMPTY( ndn ) ) {			if ( style == SLAP_LIMITS_ANONYMOUS )				goto found_nodn;			if ( !isthis )				continue;			ndn = &empty_dn;		}		switch ( style ) {		case SLAP_LIMITS_EXACT:			if ( type == SLAP_LIMITS_TYPE_GROUP ) {				int	rc = backend_group( op, NULL,						&lm[0]->lm_pat, ndn,						lm[0]->lm_group_oc,						lm[0]->lm_group_ad );				if ( rc == 0 ) {					goto found_group;				}			} else {				if ( dn_match( &lm[0]->lm_pat, ndn ) ) {					goto found_dn;				}			}			break;		case SLAP_LIMITS_ONE:		case SLAP_LIMITS_SUBTREE:		case SLAP_LIMITS_CHILDREN: {			ber_len_t d;						/* ndn shorter than lm_pat */			if ( ndn->bv_len < lm[0]->lm_pat.bv_len ) {				break;			}			d = ndn->bv_len - lm[0]->lm_pat.bv_len;			if ( d == 0 ) {				/* allow exact match for SUBTREE only */				if ( style != SLAP_LIMITS_SUBTREE ) {					break;				}			} else {				/* check for unescaped rdn separator */				if ( !DN_SEPARATOR( ndn->bv_val[d - 1] ) ) {					break;				}			}			/* check that ndn ends with lm_pat */			if ( strcmp( lm[0]->lm_pat.bv_val, &ndn->bv_val[d] ) != 0 ) {				break;			}			/* in case of ONE, require exactly one rdn below lm_pat */			if ( style == SLAP_LIMITS_ONE ) {				if ( dn_rdnlen( NULL, ndn ) != d - 1 ) {					break;				}			}			goto found_dn;		}//.........这里部分代码省略.........

static intrwm_int_filter_map_rewrite(	Operation		*op,	dncookie		*dc,	Filter			*f,	struct berval		*fstr ){	int		i;	Filter		*p;	AttributeDescription *ad;	struct berval	atmp,			vtmp,			*tmp;	static struct berval			/* better than nothing... */			ber_bvfalse = BER_BVC( "(!(objectClass=*))" ),			ber_bvtf_false = BER_BVC( "(|)" ),			/* better than nothing... */			ber_bvtrue = BER_BVC( "(objectClass=*)" ),			ber_bvtf_true = BER_BVC( "(&)" ),#if 0			/* no longer needed; preserved for completeness */			ber_bvundefined = BER_BVC( "(?=undefined)" ),#endif			ber_bverror = BER_BVC( "(?=error)" ),			ber_bvunknown = BER_BVC( "(?=unknown)" ),			ber_bvnone = BER_BVC( "(?=none)" );	ber_len_t	len;	assert( fstr != NULL );	BER_BVZERO( fstr );	if ( f == NULL ) {		ber_dupbv_x( fstr, &ber_bvnone, op->o_tmpmemctx );		return LDAP_OTHER;	}	if ( f->f_choice & SLAPD_FILTER_UNDEFINED ) {		goto computed;	}	switch ( f->f_choice & SLAPD_FILTER_MASK ) {	case LDAP_FILTER_EQUALITY:		ad = f->f_av_desc;		if ( map_attr_value( dc, &ad, &atmp,			&f->f_av_value, &vtmp, RWM_MAP, op->o_tmpmemctx ) )		{			goto computed;		}		fstr->bv_len = atmp.bv_len + vtmp.bv_len + STRLENOF( "(=)" );		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=%s)",			atmp.bv_val, vtmp.bv_len ? vtmp.bv_val : "" );		op->o_tmpfree( vtmp.bv_val, op->o_tmpmemctx );		break;	case LDAP_FILTER_GE:		ad = f->f_av_desc;		if ( map_attr_value( dc, &ad, &atmp,			&f->f_av_value, &vtmp, RWM_MAP, op->o_tmpmemctx ) )		{			goto computed;		}		fstr->bv_len = atmp.bv_len + vtmp.bv_len + STRLENOF( "(>=)" );		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s>=%s)",			atmp.bv_val, vtmp.bv_len ? vtmp.bv_val : "" );		op->o_tmpfree( vtmp.bv_val, op->o_tmpmemctx );		break;	case LDAP_FILTER_LE:		ad = f->f_av_desc;		if ( map_attr_value( dc, &ad, &atmp,			&f->f_av_value, &vtmp, RWM_MAP, op->o_tmpmemctx ) )		{			goto computed;		}		fstr->bv_len = atmp.bv_len + vtmp.bv_len + STRLENOF( "(<=)" );		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s<=%s)",			atmp.bv_val, vtmp.bv_len ? vtmp.bv_val : "" );		op->o_tmpfree( vtmp.bv_val, op->o_tmpmemctx );		break;	case LDAP_FILTER_APPROX:		ad = f->f_av_desc;		if ( map_attr_value( dc, &ad, &atmp,			&f->f_av_value, &vtmp, RWM_MAP, op->o_tmpmemctx ) )		{			goto computed;		}//.........这里部分代码省略.........

}static struct extop_list *find_extop( struct extop_list *list, struct berval *oid ){	struct extop_list *ext;	for (ext = list; ext; ext = ext->next) {		if (bvmatch(&ext->oid, oid))			return(ext);	}	return(NULL);}const struct berval slap_EXOP_WHOAMI = BER_BVC(LDAP_EXOP_WHO_AM_I);static intwhoami_extop (	Operation *op,	SlapReply *rs ){	struct berval *bv;	if ( op->ore_reqdata != NULL ) {		/* no request data should be provided */		rs->sr_text = "no request data expected";		return LDAP_PROTOCOL_ERROR;	}	Debug( LDAP_DEBUG_STATS, "%s WHOAMI/n",

static sasl_security_properties_t sasl_secprops;#elif defined( SLAP_BUILTIN_SASL )/* * built-in SASL implementation *	only supports EXTERNAL */typedef struct sasl_ctx {	slap_ssf_t sc_external_ssf;	struct berval sc_external_id;} SASL_CTX;#endif#include <lutil.h>static struct berval ext_bv = BER_BVC( "EXTERNAL" );char *slap_sasl_auxprops;#ifdef HAVE_CYRUS_SASL/* Just use our internal auxprop by default */static intslap_sasl_getopt(	void *context,	const char *plugin_name,	const char *option,	const char **result,	unsigned *len){	if ( strcmp( option, "auxprop_plugin" )) {

//.........这里部分代码省略.........						}						mdb->mi_dbenv_flags ^= mdb_envflags[i].mask;					}				}			} else {				int i = verb_to_mask( c->line, mdb_envflags );				if ( mdb_envflags[i].mask & mdb->mi_dbenv_flags ) {					rc = mdb_env_set_flags( mdb->mi_dbenv, mdb_envflags[i].mask, 0 );					if ( rc ) {						mdb->mi_flags |= MDB_RE_OPEN;						c->cleanup = mdb_cf_cleanup;						rc = 0;					}					mdb->mi_dbenv_flags ^= mdb_envflags[i].mask;				} else {					/* unknown keyword */					rc = 1;				}			}			break;		case MDB_INDEX:			if ( c->valx == -1 ) {				int i;				/* delete all (FIXME) */				for ( i = 0; i < mdb->mi_nattrs; i++ ) {					mdb->mi_attrs[i]->ai_indexmask |= MDB_INDEX_DELETING;				}				mdb->mi_flags |= MDB_DEL_INDEX;				c->cleanup = mdb_cf_cleanup;			} else {				struct berval bv, def = BER_BVC("default");				char *ptr;				for (ptr = c->line; !isspace( (unsigned char) *ptr ); ptr++);				bv.bv_val = c->line;				bv.bv_len = ptr - bv.bv_val;				if ( bvmatch( &bv, &def )) {					mdb->mi_defaultmask = 0;				} else {					int i;					char **attrs;					char sep;					sep = bv.bv_val[ bv.bv_len ];					bv.bv_val[ bv.bv_len ] = '/0';					attrs = ldap_str2charray( bv.bv_val, "," );					for ( i = 0; attrs[ i ]; i++ ) {						AttributeDescription *ad = NULL;						const char *text;						AttrInfo *ai;						slap_str2ad( attrs[ i ], &ad, &text );						/* if we got here... */						assert( ad != NULL );						ai = mdb_attr_mask( mdb, ad );						/* if we got here... */						assert( ai != NULL );						ai->ai_indexmask |= MDB_INDEX_DELETING;

			"%s: %s/n", c->log, c->cr_msg, 0 );		return ARG_BAD_CONF;	}	*an = a2;	return 0;}static slap_overinst translucent;/*** glue_parent()**	call syncrepl_add_glue() with the parent suffix;***/static struct berval glue[] = { BER_BVC("top"), BER_BVC("glue"), BER_BVNULL };void glue_parent(Operation *op) {	Operation nop = *op;	slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;	struct berval ndn = BER_BVNULL;	Attribute *a;	Entry *e;	struct berval	pdn;	dnParent( &op->o_req_ndn, &pdn );	ber_dupbv_x( &ndn, &pdn, op->o_tmpmemctx );	Debug(LDAP_DEBUG_TRACE, "=> glue_parent: fabricating glue for <%s>/n", ndn.bv_val, 0, 0);	e = entry_alloc();

int ldap_dn2domain(    LDAP_CONST char *dn_in,    char **domainp){    int i, j;    char *ndomain;    LDAPDN dn = NULL;    LDAPRDN rdn = NULL;    LDAPAVA *ava = NULL;    struct berval domain = BER_BVNULL;    static const struct berval DC = BER_BVC("DC");    static const struct berval DCOID = BER_BVC("0.9.2342.19200300.100.1.25");    assert( dn_in != NULL );    assert( domainp != NULL );    *domainp = NULL;    if ( ldap_str2dn( dn_in, &dn, LDAP_DN_FORMAT_LDAP ) != LDAP_SUCCESS ) {        return -2;    }    if( dn ) for( i=0; dn[i] != NULL; i++ ) {            rdn = dn[i];            for( j=0; rdn[j] != NULL; j++ ) {                ava = rdn[j];                if( rdn[j+1] == NULL &&                        (ava->la_flags & LDAP_AVA_STRING) &&                        ava->la_value.bv_len &&                        ( ber_bvstrcasecmp( &ava->la_attr, &DC ) == 0                          || ber_bvcmp( &ava->la_attr, &DCOID ) == 0 ) )                {                    if( domain.bv_len == 0 ) {                        ndomain = LDAP_REALLOC( domain.bv_val,                                                ava->la_value.bv_len + 1);                        if( ndomain == NULL ) {                            goto return_error;                        }                        domain.bv_val = ndomain;                        AC_MEMCPY( domain.bv_val, ava->la_value.bv_val,                                   ava->la_value.bv_len );                        domain.bv_len = ava->la_value.bv_len;                        domain.bv_val[domain.bv_len] = '/0';                    } else {                        ndomain = LDAP_REALLOC( domain.bv_val,                                                ava->la_value.bv_len + sizeof(".") + domain.bv_len );                        if( ndomain == NULL ) {                            goto return_error;                        }                        domain.bv_val = ndomain;                        domain.bv_val[domain.bv_len++] = '.';                        AC_MEMCPY( &domain.bv_val[domain.bv_len],                                   ava->la_value.bv_val, ava->la_value.bv_len );                        domain.bv_len += ava->la_value.bv_len;                        domain.bv_val[domain.bv_len] = '/0';                    }                } else {                    domain.bv_len = 0;                }            }        }    if( domain.bv_len == 0 && domain.bv_val != NULL ) {        LDAP_FREE( domain.bv_val );        domain.bv_val = NULL;    }    ldap_dnfree( dn );    *domainp = domain.bv_val;    return 0;return_error:    ldap_dnfree( dn );    LDAP_FREE( domain.bv_val );    return -1;}

static intdo_base( char *uri, char *dn, struct berval *pass, char *base, char *filter, char *pwattr,	int maxloop, int force, int chaserefs, int noinit, int delay,	int action_type, void *action ){	LDAP	*ld = NULL;	int  	i = 0;	int     rc = LDAP_SUCCESS;	ber_int_t msgid;	LDAPMessage *res, *msg;	char **dns = NULL;	struct berval *creds = NULL;	char *attrs[] = { LDAP_NO_ATTRS, NULL };	int ndns = 0;#ifdef _WIN32	DWORD beg, end;#else	struct timeval beg, end;#endif	int version = LDAP_VERSION3;	char *nullstr = "";	ldap_initialize( &ld, uri );	if ( ld == NULL ) {		tester_perror( "ldap_initialize", NULL );		exit( EXIT_FAILURE );	}	(void) ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version );	(void) ldap_set_option( ld, LDAP_OPT_REFERRALS,		chaserefs ? LDAP_OPT_ON: LDAP_OPT_OFF );	rc = ldap_sasl_bind_s( ld, dn, LDAP_SASL_SIMPLE, pass, NULL, NULL, NULL );	if ( rc != LDAP_SUCCESS ) {		tester_ldap_error( ld, "ldap_sasl_bind_s", NULL );		exit( EXIT_FAILURE );	}	fprintf( stderr, "PID=%ld - Bind(%d): base=/"%s/", filter=/"%s/" attr=/"%s/"./n",			(long) pid, maxloop, base, filter, pwattr );	if ( pwattr != NULL ) {		attrs[ 0 ] = pwattr;	}	rc = ldap_search_ext( ld, base, LDAP_SCOPE_SUBTREE,			filter, attrs, 0, NULL, NULL, 0, 0, &msgid );	if ( rc != LDAP_SUCCESS ) {		tester_ldap_error( ld, "ldap_search_ext", NULL );		exit( EXIT_FAILURE );	}	while ( ( rc = ldap_result( ld, LDAP_RES_ANY, LDAP_MSG_ONE, NULL, &res ) ) > 0 )	{		BerElement *ber;		struct berval bv;		int done = 0;		for ( msg = ldap_first_message( ld, res ); msg;			msg = ldap_next_message( ld, msg ) )		{			switch ( ldap_msgtype( msg ) ) {			case LDAP_RES_SEARCH_ENTRY:				rc = ldap_get_dn_ber( ld, msg, &ber, &bv );				dns = realloc( dns, (ndns + 1)*sizeof(char *) );				dns[ndns] = ber_strdup( bv.bv_val );				if ( pwattr != NULL ) {					struct berval	**values = ldap_get_values_len( ld, msg, pwattr );					creds = realloc( creds, (ndns + 1)*sizeof(struct berval) );					if ( values == NULL ) {novals:;						creds[ndns].bv_len = 0;						creds[ndns].bv_val = nullstr;					} else {						static struct berval	cleartext = BER_BVC( "{CLEARTEXT} " );						struct berval		value = *values[ 0 ];						if ( value.bv_val[ 0 ] == '{' ) {							char *end = ber_bvchr( &value, '}' );							if ( end ) {								if ( ber_bvcmp( &value, &cleartext ) == 0 ) {									value.bv_val += cleartext.bv_len;									value.bv_len -= cleartext.bv_len;								} else {									ldap_value_free_len( values );									goto novals;								}							}						}						ber_dupbv( &creds[ndns], &value );						ldap_value_free_len( values );					}				}				ndns++;				ber_free( ber, 0 );//.........这里部分代码省略.........

#include "lutil.h"#include <ac/stdlib.h>#include <ac/ctype.h>#include <ac/string.h>/* include socket.h to get sys/types.h and/or winsock2.h */#include <ac/socket.h>#include <openssl/sha.h>#include <openssl/hmac.h>#include "slap.h"#include "config.h"static LUTIL_PASSWD_CHK_FUNC chk_totp1, chk_totp256, chk_totp512;static LUTIL_PASSWD_HASH_FUNC hash_totp1, hash_totp256, hash_totp512;static const struct berval scheme_totp1 = BER_BVC("{TOTP1}");static const struct berval scheme_totp256 = BER_BVC("{TOTP256}");static const struct berval scheme_totp512 = BER_BVC("{TOTP512}");static AttributeDescription *ad_authTimestamp;/* This is the definition used by ISODE, as supplied to us in * ITS#6238 Followup #9 */static struct schema_info {	char *def;	AttributeDescription **ad;} totp_OpSchema[] = {	{	"( 1.3.6.1.4.1.453.16.2.188 "		"NAME 'authTimestamp' "		"DESC 'last successful authentication using any method/mech' "

intbacksql_db_open(	BackendDB 	*bd,	ConfigReply	*cr ){	backsql_info 	*bi = (backsql_info*)bd->be_private;	struct berbuf	bb = BB_NULL;	Connection	conn = { 0 };	OperationBuffer opbuf;	Operation*	op;	SQLHDBC		dbh = SQL_NULL_HDBC;	void		*thrctx = ldap_pvt_thread_pool_context();	Debug( LDAP_DEBUG_TRACE, "==>backsql_db_open(): "		"testing RDBMS connection/n", 0, 0, 0 );	if ( bi->sql_dbname == NULL ) {		Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "			"datasource name not specified "			"(use /"dbname/" directive in slapd.conf)/n", 0, 0, 0 );		return 1;	}	if ( bi->sql_concat_func == NULL ) {		Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "			"concat func not specified (use /"concat_pattern/" "			"directive in slapd.conf)/n", 0, 0, 0 );		if ( backsql_split_pattern( backsql_def_concat_func, 				&bi->sql_concat_func, 2 ) ) {			Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "				"unable to parse pattern /"%s/"",				backsql_def_concat_func, 0, 0 );			return 1;		}	}	/*	 * see back-sql.h for default values	 */	if ( BER_BVISNULL( &bi->sql_aliasing ) ) {		ber_str2bv( BACKSQL_ALIASING,			STRLENOF( BACKSQL_ALIASING ),			1, &bi->sql_aliasing );	}	if ( BER_BVISNULL( &bi->sql_aliasing_quote ) ) {		ber_str2bv( BACKSQL_ALIASING_QUOTE,			STRLENOF( BACKSQL_ALIASING_QUOTE ),			1, &bi->sql_aliasing_quote );	}	/*	 * Prepare cast string as required	 */	if ( bi->sql_upper_func.bv_val ) {		char buf[1024];		if ( BACKSQL_UPPER_NEEDS_CAST( bi ) ) {			snprintf( buf, sizeof( buf ), 				"%s(cast (" /* ? as varchar(%d))) */ , 				bi->sql_upper_func.bv_val );			ber_str2bv( buf, 0, 1, &bi->sql_upper_func_open );			snprintf( buf, sizeof( buf ),				/* (cast(? */ " as varchar(%d)))",				BACKSQL_MAX_DN_LEN );			ber_str2bv( buf, 0, 1, &bi->sql_upper_func_close );		} else {			snprintf( buf, sizeof( buf ), "%s(" /* ?) */ ,					bi->sql_upper_func.bv_val );			ber_str2bv( buf, 0, 1, &bi->sql_upper_func_open );			ber_str2bv( /* (? */ ")", 0, 1, &bi->sql_upper_func_close );		}	}	/* normalize filter values only if necessary */	bi->sql_caseIgnoreMatch = mr_find( "caseIgnoreMatch" );	assert( bi->sql_caseIgnoreMatch != NULL );	bi->sql_telephoneNumberMatch = mr_find( "telephoneNumberMatch" );	assert( bi->sql_telephoneNumberMatch != NULL );	if ( bi->sql_dbuser == NULL ) {		Debug( LDAP_DEBUG_TRACE, "backsql_db_open(): "			"user name not specified "			"(use /"dbuser/" directive in slapd.conf)/n", 0, 0, 0 );		return 1;	}		if ( BER_BVISNULL( &bi->sql_subtree_cond ) ) {		/*		 * Prepare concat function for subtree search condition		 */		struct berval	concat;		struct berval	values[] = {			BER_BVC( "'%'" ),			BER_BVC( "?" ),//.........这里部分代码省略.........

 */#include "portable.h"#include <stdio.h>#include <ac/ctype.h>#include <ac/errno.h>#include <ac/socket.h>#include <ac/string.h>#include <ac/time.h>#include "slap.h"#include "lutil.h"static struct berval bv_no_attrs = BER_BVC( LDAP_NO_ATTRS );static struct berval bv_all_user_attrs = BER_BVC( "*" );static struct berval bv_all_operational_attrs = BER_BVC( "+" );static AttributeName anlist_no_attrs[] = {    { BER_BVC( LDAP_NO_ATTRS ), NULL, 0, NULL },    { BER_BVNULL, NULL, 0, NULL }};static AttributeName anlist_all_user_attributes[] = {    { BER_BVC( LDAP_ALL_USER_ATTRIBUTES ), NULL, 0, NULL },    { BER_BVNULL, NULL, 0, NULL }};static AttributeName anlist_all_operational_attributes[] = {    { BER_BVC( LDAP_ALL_OPERATIONAL_ATTRIBUTES ), NULL, 0, NULL },

#include "reldap.h"#include <stdio.h>#include <ac/socket.h>#include <ac/string.h>#include <ac/unistd.h>#include "slap.h"#include <lber_pvt.h>#include <lutil.h>#ifdef LDAP_X_TXNconst struct berval slap_EXOP_TXN_START = BER_BVC(LDAP_EXOP_X_TXN_START);const struct berval slap_EXOP_TXN_END = BER_BVC(LDAP_EXOP_X_TXN_END);int txn_start_extop(	Operation *op, SlapReply *rs ){	int rc;	struct berval *bv;	Statslog( LDAP_DEBUG_STATS, "%s TXN START/n",		op->o_log_prefix );	if( op->ore_reqdata != NULL ) {		rs->sr_text = "no request data expected";		return LDAP_PROTOCOL_ERROR;	}

intmain( int argc, char **argv ){	int		i;	char		*uri = NULL;	char		*host = "localhost";	char		*dn = NULL;	char		*base = NULL;	char		*filter = "(objectClass=person)";	struct berval	pass = { 0, NULL };	char		*pwattr = NULL;	int		port = -1;	int		loops = LOOPS;	int		outerloops = 1;	int		force = 0;	int		chaserefs = 0;	int		noinit = 1;	int		delay = 0;	/* extra action to do after bind... */	struct berval	type[] = {		BER_BVC( "tester=" ),		BER_BVC( "add=" ),		BER_BVC( "bind=" ),		BER_BVC( "modify=" ),		BER_BVC( "modrdn=" ),		BER_BVC( "read=" ),		BER_BVC( "search=" ),		BER_BVNULL	};	LDAPURLDesc	*extra_ludp = NULL;	tester_init( "slapd-bind", TESTER_BIND );	/* by default, tolerate invalid credentials */	tester_ignore_str2errlist( "INVALID_CREDENTIALS" );	while ( ( i = getopt( argc, argv, "a:B:b:D:Ff:H:h:Ii:L:l:p:t:w:" ) ) != EOF )	{		switch ( i ) {		case 'a':			pwattr = optarg;			break;		case 'b':		/* base DN of a tree of user DNs */			base = optarg;			break;		case 'B':			{			int	c;			for ( c = 0; type[c].bv_val; c++ ) {				if ( strncasecmp( optarg, type[c].bv_val, type[c].bv_len ) == 0 )				{					break;				}			}			if ( type[c].bv_val == NULL ) {				usage( argv[0], 'B' );			}			switch ( c ) {			case TESTER_TESTER:			case TESTER_BIND:				/* invalid */				usage( argv[0], 'B' );			case TESTER_SEARCH:				{				if ( ldap_url_parse( &optarg[type[c].bv_len], &extra_ludp ) != LDAP_URL_SUCCESS )				{					usage( argv[0], 'B' );				}				} break;			case TESTER_ADDEL:			case TESTER_MODIFY:			case TESTER_MODRDN:			case TESTER_READ:				/* nothing to do */				break;			default:				assert( 0 );			}			} break;		case 'C':			chaserefs++;			break;		case 'H':		/* the server uri */			uri = optarg;			break;		case 'h':		/* the servers host *///.........这里部分代码省略.........

static ConfigOCs mdbocs[] = {	{		"( OLcfgDbOc:12.1 "		"NAME 'olcMdbConfig' "		"DESC 'MDB backend configuration' "		"SUP olcDatabaseConfig "		"MUST olcDbDirectory "		"MAY ( olcDbCheckpoint $ olcDbEnvFlags $ "		"olcDbNoSync $ olcDbIndex $ olcDbMaxReaders $ olcDbMaxsize $ "		"olcDbMode $ olcDbSearchStack ) )",		 	Cft_Database, mdbcfg },	{ NULL, 0, NULL }};static slap_verbmasks mdb_envflags[] = {	{ BER_BVC("nosync"),	MDB_NOSYNC },	{ BER_BVC("nometasync"),	MDB_NOMETASYNC },	{ BER_BVC("writemap"),	MDB_WRITEMAP },	{ BER_BVC("mapasync"),	MDB_MAPASYNC },	{ BER_BVC("nordahead"),	MDB_NORDAHEAD },	{ BER_BVNULL, 0 }};/* perform periodic syncs */static void *mdb_checkpoint( void *ctx, void *arg ){	struct re_s *rtask = arg;	struct mdb_info *mdb = rtask->arg;	mdb_env_sync( mdb->mi_dbenv, 1 );

 * This code references portions of the nss-ldapd package * written by Arthur de Jong. The nss-ldapd code was forked * from the nss-ldap library written by Luke Howard. */#include "nssov.h"#include <ac/ctype.h>/* ( nisSchema.2.8 NAME 'nisNetgroup' SUP top STRUCTURAL *   DESC 'Abstraction of a netgroup. May refer to other netgroups' *   MUST cn *   MAY ( nisNetgroupTriple $ memberNisNetgroup $ description ) ) *//* the basic search filter for searches */static struct berval netgroup_filter = BER_BVC("(objectClass=nisNetgroup)");/* the attributes to request with searches */static struct berval netgroup_keys[] = {	BER_BVC("cn"),	BER_BVC("nisNetgroupTriple"),	BER_BVC("memberNisNetgroup"),	BER_BVNULL};NSSOV_INIT(netgroup)NSSOV_CBPRIV(netgroup,	char buf[256];	struct berval name;);

#include <ac/string.h>#include "slap.h"#include "back-ldap.h"#include "lber_pvt.h"typedef int (ldap_back_exop_f)( Operation *op, SlapReply *rs, ldapconn_t **lc );static ldap_back_exop_f ldap_back_exop_passwd;static ldap_back_exop_f ldap_back_exop_generic;static struct exop {	struct berval		oid;	ldap_back_exop_f	*extended;} exop_table[] = {	{ BER_BVC(LDAP_EXOP_MODIFY_PASSWD),	ldap_back_exop_passwd },	{ BER_BVNULL, NULL }};static intldap_back_extended_one( Operation *op, SlapReply *rs, ldap_back_exop_f exop ){	ldapinfo_t	*li = (ldapinfo_t *) op->o_bd->be_private;	ldapconn_t	*lc = NULL;	LDAPControl	**ctrls = NULL, **oldctrls = NULL;	int		rc;	/* FIXME: this needs to be called here, so it is	 * called twice; maybe we could avoid the 	 * ldap_back_dobind() call inside each extended()

 * written by Arthur de Jong. The nss-ldapd code was forked * from the nss-ldap library written by Luke Howard. */#include "nssov.h"/* Vendor-specific attributes and object classes. * (Mainly from Sun.) * ( 1.3.6.1.4.1.42.2.27.1.2.5 NAME 'nisMailAlias' SUP top STRUCTURAL *   DESC 'NIS mail alias' *   MUST cn *   MAY rfc822MailMember ) *//* the basic search filter for searches */static struct berval alias_filter = BER_BVC("(objectClass=nisMailAlias)");/* the attributes to request with searches */static struct berval alias_keys[] = {	BER_BVC("cn"),	BER_BVC("rfc822MailMember"),	BER_BVNULL};NSSOV_INIT(alias)NSSOV_CBPRIV(alias,	struct berval name;	char buf[256];);static int write_alias(nssov_alias_cbp *cbp,Entry *entry)

 */#include "nssov.h"struct ether_addr {  uint8_t ether_addr_octet[6];};/* ( nisSchema.2.11 NAME 'ieee802Device' SUP top AUXILIARY *   DESC 'A device with a MAC address; device SHOULD be *         used as a structural class' *   MAY macAddress ) *//* the basic search filter for searches */static struct berval ether_filter = BER_BVC("(objectClass=ieee802Device)");/* the attributes to request with searches */static struct berval ether_keys[] = {	BER_BVC("cn"),	BER_BVC("macAddress"),	BER_BVNULL};NSSOV_INIT(ether)NSSOV_CBPRIV(ether,	char buf[256];	struct berval name;	struct berval addr;);

static intasyncmeta_proxy_authz_bind(	a_metaconn_t *mc,	int candidate,	Operation *op,	SlapReply *rs,	ldap_back_send_t sendok,	int dolock ){	a_metainfo_t		*mi = mc->mc_info;	a_metatarget_t		*mt = mi->mi_targets[ candidate ];	a_metasingleconn_t	*msc = &mc->mc_conns[ candidate ];	struct berval		binddn = BER_BVC( "" ),				cred = BER_BVC( "" );	int			method = LDAP_AUTH_NONE,				rc;	rc = asyncmeta_back_proxy_authz_cred( mc, candidate, op, rs, sendok, &binddn, &cred, &method );	if ( rc == LDAP_SUCCESS && !LDAP_BACK_CONN_ISBOUND( msc ) ) {		int	msgid;		switch ( method ) {		case LDAP_AUTH_NONE:		case LDAP_AUTH_SIMPLE:			for (;;) {				rs->sr_err = ldap_sasl_bind( msc->msc_ld,					binddn.bv_val, LDAP_SASL_SIMPLE,					&cred, NULL, NULL, &msgid );				if ( rs->sr_err != LDAP_X_CONNECTING ) {					break;				}				ldap_pvt_thread_yield();			}			rc = asyncmeta_bind_op_result( op, rs, mc, candidate, msgid, sendok, dolock );			if ( rc == LDAP_SUCCESS ) {				/* set rebind stuff in case of successful proxyAuthz bind,				 * so that referral chasing is attempted using the right				 * identity */				LDAP_BACK_CONN_ISBOUND_SET( msc );				ber_bvreplace( &msc->msc_bound_ndn, &binddn );				if ( META_BACK_TGT_SAVECRED( mt ) ) {					if ( !BER_BVISNULL( &msc->msc_cred ) ) {						memset( msc->msc_cred.bv_val, 0,							msc->msc_cred.bv_len );					}					ber_bvreplace( &msc->msc_cred, &cred );					ldap_set_rebind_proc( msc->msc_ld, mt->mt_rebind_f, msc );				}			}			break;		default:			assert( 0 );			break;		}	}	return LDAP_BACK_CONN_ISBOUND( msc );}

				(void *)tls_imp->ti_sbio )#endif /* HAVE_TLS */#define LDAP_USE_NON_BLOCKING_TLS/* RFC2459 minimum required set of supported attribute types * in a certificate DN */typedef struct oid_name {	struct berval oid;	struct berval name;} oid_name;static oid_name oids[] = {	{ BER_BVC("2.5.4.3"), BER_BVC("cn") },	{ BER_BVC("2.5.4.4"), BER_BVC("sn") },	{ BER_BVC("2.5.4.6"), BER_BVC("c") },	{ BER_BVC("2.5.4.7"), BER_BVC("l") },	{ BER_BVC("2.5.4.8"), BER_BVC("st") },	{ BER_BVC("2.5.4.10"), BER_BVC("o") },	{ BER_BVC("2.5.4.11"), BER_BVC("ou") },	{ BER_BVC("2.5.4.12"), BER_BVC("title") },	{ BER_BVC("2.5.4.41"), BER_BVC("name") },	{ BER_BVC("2.5.4.42"), BER_BVC("givenName") },	{ BER_BVC("2.5.4.43"), BER_BVC("initials") },	{ BER_BVC("2.5.4.44"), BER_BVC("generationQualifier") },	{ BER_BVC("2.5.4.46"), BER_BVC("dnQualifier") },	{ BER_BVC("1.2.840.113549.1.9.1"), BER_BVC("email") },	{ BER_BVC("0.9.2342.19200300.100.1.25"), BER_BVC("dc") },	{ BER_BVNULL, BER_BVNULL }

/* * asyncmeta_back_single_dobind */intasyncmeta_back_single_dobind(	Operation		*op,	SlapReply		*rs,	a_metaconn_t		**mcp,	int			candidate,	ldap_back_send_t	sendok,	int			nretries,	int			dolock ){	a_metaconn_t		*mc = *mcp;	a_metainfo_t		*mi = mc->mc_info;	a_metatarget_t		*mt = mi->mi_targets[ candidate ];	a_metasingleconn_t	*msc = &mc->mc_conns[ candidate ];	int			msgid;	assert( !LDAP_BACK_CONN_ISBOUND( msc ) );	if ( op->o_conn != NULL &&		!op->o_do_not_cache &&		( BER_BVISNULL( &msc->msc_bound_ndn ) ||			BER_BVISEMPTY( &msc->msc_bound_ndn ) ||			( LDAP_BACK_CONN_ISPRIV( mc ) && dn_match( &msc->msc_bound_ndn, &mt->mt_idassert_authcDN ) ) ||			( mt->mt_idassert_flags & LDAP_BACK_AUTH_OVERRIDE ) ) )	{		(void)asyncmeta_proxy_authz_bind( mc, candidate, op, rs, sendok, dolock );	} else {		char *binddn = "";		struct berval cred = BER_BVC( "" );		/* use credentials if available */		if ( !BER_BVISNULL( &msc->msc_bound_ndn )			&& !BER_BVISNULL( &msc->msc_cred ) )		{			binddn = msc->msc_bound_ndn.bv_val;			cred = msc->msc_cred;		}		for (;;) {			rs->sr_err = ldap_sasl_bind( msc->msc_ld,				binddn, LDAP_SASL_SIMPLE, &cred,				NULL, NULL, &msgid );			if ( rs->sr_err != LDAP_X_CONNECTING ) {				break;			}			ldap_pvt_thread_yield();		}		rs->sr_err = asyncmeta_bind_op_result( op, rs, mc, candidate, msgid, sendok, dolock );		/* if bind succeeded, but anonymous, clear msc_bound_ndn */		if ( rs->sr_err != LDAP_SUCCESS || binddn[0] == '/0' ) {			if ( !BER_BVISNULL( &msc->msc_bound_ndn ) ) {				ber_memfree( msc->msc_bound_ndn.bv_val );				BER_BVZERO( &msc->msc_bound_ndn );			}			if ( !BER_BVISNULL( &msc->msc_cred ) ) {				memset( msc->msc_cred.bv_val, 0, msc->msc_cred.bv_len );				ber_memfree( msc->msc_cred.bv_val );				BER_BVZERO( &msc->msc_cred );			}		}	}	if ( META_BACK_TGT_QUARANTINE( mt ) ) {		asyncmeta_quarantine( op, mi, rs, candidate );	}	return rs->sr_err;}

#include "portable.h"#include <stdio.h>#include <ac/ctype.h>#include <ac/regex.h>#include <ac/string.h>#include "slap.h"#include "lutil.h"/* define to get an error if requesting limit higher than hard */#undef ABOVE_HARD_LIMIT_IS_ERRORstatic const struct berval lmpats[] = {	BER_BVC( "base" ),	BER_BVC( "base" ),	BER_BVC( "onelevel" ),	BER_BVC( "subtree" ),	BER_BVC( "children" ),	BER_BVC( "regex" ),	BER_BVC( "anonymous" ),	BER_BVC( "users" ),	BER_BVC( "*" )};#ifdef LDAP_DEBUGstatic const char *const dn_source[2] = { "DN", "DN.THIS" };static const char *const lmpats_out[] = {	"UNDEFINED",	"EXACT",

	ACI_BV_GRANT,	ACI_BV_DENY,	ACI_BV_GROUP_CLASS,	ACI_BV_GROUP_ATTR,	ACI_BV_ROLE_CLASS,	ACI_BV_ROLE_ATTR,	ACI_BV_SET_ATTR,	ACI_BV_LAST};static const struct berval	aci_bv[] = {	/* scope */	BER_BVC("entry"),	BER_BVC("children"),	BER_BVC("onelevel"),	BER_BVC("subtree"),	/* */	BER_BVC("[entry]"),	BER_BVC("[children]"),	BER_BVC("[all]"),	/* type */	BER_BVC("access-id"),	BER_BVC("public"),	BER_BVC("users"),	BER_BVC("self"),	BER_BVC("dnattr"),

/* ACKNOWLEDGEMENTS: * This code references portions of the nss-ldapd package * written by Arthur de Jong. The nss-ldapd code was forked * from the nss-ldap library written by Luke Howard. */#include "nssov.h"/* ( nisSchema.2.0 NAME 'posixAccount' SUP top AUXILIARY *	 DESC 'Abstraction of an account with POSIX attributes' *	 MUST ( cn $ uid $ uidNumber $ gidNumber $ homeDirectory ) *	 MAY ( userPassword $ loginShell $ gecos $ description ) ) *//* the basic search filter for searches */static struct berval passwd_filter = BER_BVC("(objectClass=posixAccount)");/* the attributes used in searches */static struct berval passwd_keys[] = {	BER_BVC("uid"),	BER_BVC("userPassword"),	BER_BVC("uidNumber"),	BER_BVC("gidNumber"),	BER_BVC("gecos"),	BER_BVC("cn"),	BER_BVC("homeDirectory"),	BER_BVC("loginShell"),	BER_BVC("objectClass"),	BER_BVNULL};

			"SYNTAX OMsDirectoryString )", NULL, NULL },	{ NULL }};static ConfigOCs valsort_cfocs[] = {	{ "( OLcfgOvOc:5.1 "		"NAME 'olcValSortConfig' "		"DESC 'Value Sorting configuration' "		"SUP olcOverlayConfig "		"MUST olcValSortAttr )",			Cft_Overlay, valsort_cfats },	{ NULL }};static slap_verbmasks sorts[] = {	{ BER_BVC("alpha-ascend"), VALSORT_ASCEND|VALSORT_ALPHA },	{ BER_BVC("alpha-descend"), VALSORT_DESCEND|VALSORT_ALPHA },	{ BER_BVC("numeric-ascend"), VALSORT_ASCEND|VALSORT_NUMERIC },	{ BER_BVC("numeric-descend"), VALSORT_DESCEND|VALSORT_NUMERIC },	{ BER_BVC("weighted"), VALSORT_WEIGHTED },	{ BER_BVNULL, 0 }};static Syntax *syn_numericString;static intvalsort_cf_func(ConfigArgs *c) {	slap_overinst *on = (slap_overinst *)c->bi;	valsort_info vitmp, *vi;	const char *text = NULL;	int i, is_numeric;

//.........这里部分代码省略.........		case 'H':		/* slapd uri */			uri = strdup( optarg );			break;		case 'h':		/* slapd host */			host = strdup( optarg );			break;		case 'I':			noinit = 0;			break;		case 'i':			ignore = optarg;			break;		case 'j':		/* the number of parallel clients */			if ( lutil_atoi( &maxkids, optarg ) != 0 ) {				usage( argv[0], 'j' );			}			break;		case 'l':		/* the number of loops per client */			if ( !isdigit( (unsigned char) optarg[0] ) ) {				char	**p,					**l = ldap_str2charray( optarg, "," );				for ( p = l; p[0]; p++) {					struct {						struct berval	type;						char		*buf;					} types[] = {						{ BER_BVC( "add=" ),	aloops },						{ BER_BVC( "bind=" ),	bloops },						{ BER_BVC( "modify=" ),	mloops },						{ BER_BVC( "modrdn=" ),	nloops },						{ BER_BVC( "read=" ),	rloops },						{ BER_BVC( "search=" ),	sloops },						{ BER_BVNULL,		NULL }					};					int	c, n;					for ( c = 0; types[c].type.bv_val; c++ ) {						if ( strncasecmp( p[0], types[c].type.bv_val, types[c].type.bv_len ) == 0 ) {							break;						}					}					if ( types[c].type.bv_val == NULL ) {						usage( argv[0], 'l' );					}					if ( lutil_atoi( &n, &p[0][types[c].type.bv_len] ) != 0 ) {						usage( argv[0], 'l' );					}					snprintf( types[c].buf, sizeof( aloops ), "%d", n );				}				ldap_charray_free( l );			} else if ( lutil_atoi( &loops, optarg ) != 0 ) {				usage( argv[0], 'l' );			}			break;

		"DESC 'BDB backend configuration' "#endif		"SUP olcDatabaseConfig "		"MUST olcDbDirectory "		"MAY ( olcDbCacheSize $ olcDbCheckpoint $ olcDbConfig $ "		"olcDbCryptFile $ olcDbCryptKey $ "		"olcDbNoSync $ olcDbDirtyRead $ olcDbIDLcacheSize $ "		"olcDbIndex $ olcDbLinearIndex $ olcDbLockDetect $ "		"olcDbMode $ olcDbSearchStack $ olcDbShmKey $ "		"olcDbCacheFree $ olcDbDNcacheSize $ olcDbPageSize ) )",		 	Cft_Database, bdbcfg },	{ NULL, 0, NULL }};static slap_verbmasks bdb_lockd[] = {	{ BER_BVC("default"), DB_LOCK_DEFAULT },	{ BER_BVC("oldest"), DB_LOCK_OLDEST },	{ BER_BVC("random"), DB_LOCK_RANDOM },	{ BER_BVC("youngest"), DB_LOCK_YOUNGEST },	{ BER_BVC("fewest"), DB_LOCK_MINLOCKS },	{ BER_BVNULL, 0 }};/* perform periodic checkpoints */static void *bdb_checkpoint( void *ctx, void *arg ){	struct re_s *rtask = arg;	struct bdb_info *bdb = rtask->arg;		TXN_CHECKPOINT( bdb->bi_dbenv, bdb->bi_txn_cp_kbyte,