/*
 * metaconn_alloc
 * 
 * Allocates a connection structure, making room for all the referenced targets
 */
static struct metaconn *
metaconn_alloc( int ntargets )
{
	struct metaconn *lc;

	assert( ntargets > 0 );

	lc = ch_calloc( sizeof( struct metaconn ), 1 );
	if ( lc == NULL ) {
		return NULL;
	}
	
	/*
	 * make it a null-terminated array ...
	 */
	lc->conns = ch_calloc( sizeof( struct metasingleconn ), ntargets+1 );
	if ( lc->conns == NULL ) {
		free( lc );
		return NULL;
	}
	lc->conns[ ntargets ].candidate = META_LAST_CONN;

	lc->bound_target = META_BOUND_NONE;

	return lc;
}

static int sssvlv_db_open(
	BackendDB		*be,
	ConfigReply		*cr )
{
	slap_overinst	*on = (slap_overinst *)be->bd_info;
	sssvlv_info *si = on->on_bi.bi_private;
	int rc;
	int conn_index;

	/* If not set, default to 1/2 of available threads */
	if ( !si->svi_max )
		si->svi_max = connection_pool_max / 2;

	if ( dtblsize && !sort_conns ) {
		ldap_pvt_thread_mutex_init( &sort_conns_mutex );
		/* accommodate for c_conn_idx == -1 */
		sort_conns = ch_calloc( dtblsize + 1, sizeof(sort_op **) );
		for ( conn_index = 0 ; conn_index < dtblsize + 1 ; conn_index++ ) {
			sort_conns[conn_index] = ch_calloc( si->svi_max_percon, sizeof(sort_op *) );
		}
		sort_conns++;
	}

	rc = overlay_register_control( be, LDAP_CONTROL_SORTREQUEST );
	if ( rc == LDAP_SUCCESS )
		rc = overlay_register_control( be, LDAP_CONTROL_VLVREQUEST );
	return rc;
}

void
ldap_back_map_init ( struct ldapmap *lm, struct ldapmapping **m )
{
	struct ldapmapping *mapping;

	assert( m != NULL );

	*m = NULL;

	mapping = (struct ldapmapping *)ch_calloc( 2, 
			sizeof( struct ldapmapping ) );
	if ( mapping == NULL ) {
		return;
	}

	ber_str2bv( "objectclass", STRLENOF("objectclass"), 1, &mapping[0].src);
	ber_dupbv( &mapping[0].dst, &mapping[0].src );
	mapping[1].src = mapping[0].src;
	mapping[1].dst = mapping[0].dst;

	avl_insert( &lm->map, (caddr_t)&mapping[0], 
			mapping_cmp, mapping_dup );
	avl_insert( &lm->remap, (caddr_t)&mapping[1], 
			mapping_cmp, mapping_dup );
	*m = mapping;
}

static int
mdb_db_init( BackendDB *be, ConfigReply *cr )
{
	struct mdb_info	*mdb;
	int rc;

	Debug( LDAP_DEBUG_TRACE,
		LDAP_XSTRING(mdb_db_init) ": Initializing mdb database\n",
		0, 0, 0 );

	/* allocate backend-database-specific stuff */
	mdb = (struct mdb_info *) ch_calloc( 1, sizeof(struct mdb_info) );

	/* DBEnv parameters */
	mdb->mi_dbenv_home = ch_strdup( SLAPD_DEFAULT_DB_DIR );
	mdb->mi_dbenv_flags = 0;
	mdb->mi_dbenv_mode = SLAPD_DEFAULT_DB_MODE;

	mdb->mi_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;
	mdb->mi_search_stack = NULL;

	mdb->mi_mapsize = DEFAULT_MAPSIZE;

	be->be_private = mdb;
	be->be_cf_ocs = be->bd_info->bi_cf_ocs;

#ifndef MDB_MULTIPLE_SUFFIXES
	SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_ONE_SUFFIX;
#endif

	rc = mdb_monitor_db_init( be );

	return rc;
}

Operation *
slap_op_alloc(
    BerElement		*ber,
    ber_int_t	msgid,
    ber_tag_t	tag,
    ber_int_t	id
)
{
	Operation	*op;

	ldap_pvt_thread_mutex_lock( &slap_op_mutex );
	if (op = LDAP_STAILQ_FIRST( &slap_free_ops )) {
		LDAP_STAILQ_REMOVE_HEAD( &slap_free_ops, o_next );
	}
	ldap_pvt_thread_mutex_unlock( &slap_op_mutex );

	if (!op)
		op = (Operation *) ch_calloc( 1, sizeof(Operation) );

	op->o_ber = ber;
	op->o_msgid = msgid;
	op->o_tag = tag;

	op->o_time = slap_get_time();
	op->o_opid = id;
#ifdef LDAP_CONNECTIONLESS
	op->o_res_ber = NULL;
#endif

#if defined( LDAP_SLAPI )
	op->o_pb = slapi_pblock_new();
#endif /* defined( LDAP_SLAPI ) */

	return( op );
}

static int
vernum_db_init(
	BackendDB	*be,
	ConfigReply	*cr)
{
	slap_overinst	*on = (slap_overinst *) be->bd_info;
	vernum_t	*vn = NULL;

	if ( SLAP_ISGLOBALOVERLAY( be ) ) {
		Log0( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
			"vernum_db_init: vernum cannot be used as global overlay.\n" );
		return 1;
	}

	if ( be->be_nsuffix == NULL ) {
		Log0( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
			"vernum_db_init: database must have suffix\n" );
		return 1;
	}

	if ( BER_BVISNULL( &be->be_rootndn ) || BER_BVISEMPTY( &be->be_rootndn ) ) {
		Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
			"vernum_db_init: missing rootdn for database DN=\"%s\", YMMV\n",
			be->be_suffix[ 0 ].bv_val );
	}

	vn = (vernum_t *)ch_calloc( 1, sizeof( vernum_t ) );

	on->on_bi.bi_private = (void *)vn;

	return 0;
}

static int
ndb_db_init( BackendDB *be, ConfigReply *cr )
{
	struct ndb_info	*ni;
	int rc = 0;

	Debug( LDAP_DEBUG_TRACE,
		LDAP_XSTRING(ndb_db_init) ": Initializing ndb database\n",
		0, 0, 0 );

	/* allocate backend-database-specific stuff */
	ni = (struct ndb_info *) ch_calloc( 1, sizeof(struct ndb_info) );

	be->be_private = ni;
	be->be_cf_ocs = be->bd_info->bi_cf_ocs;

	ni->ni_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;

	ldap_pvt_thread_rdwr_init( &ni->ni_ai_rwlock );
	ldap_pvt_thread_rdwr_init( &ni->ni_oc_rwlock );
	ldap_pvt_thread_mutex_init( &ni->ni_conn_mutex );

#ifdef DO_MONITORING
	rc = ndb_monitor_db_init( be );
#endif

	return rc;
}

int
entry_prealloc( int num )
{
	Entry *e, **prev, *tmp;
	slap_list *s;
	int i, j;

	if (!num) return 0;

#if STRIDE_FACTOR > 1
	/* Round up to our stride factor */
	num += STRIDE_FACTOR-1;
	num /= STRIDE_FACTOR;
	num *= STRIDE_FACTOR;
#endif

	s = ch_calloc( 1, sizeof(slap_list) + num * sizeof(Entry));
	s->next = entry_chunks;
	entry_chunks = s;

	prev = &tmp;
	for (i=0; i<STRIPE; i++) {
		e = (Entry *)(s+1);
		e += i;
		for (j=i; j<num; j+= STRIDE) {
			*prev = e;
			prev = (Entry **)&e->e_private;
			e += STRIDE;
		}
	}
	*prev = entry_list;
	entry_list = (Entry *)(s+1);

	return 0;
}

int
kinit_initialize(void)
{
	Log( LDAP_DEBUG_TRACE, LDAP_LEVEL_DEBUG, "kinit_initialize\n" );
	krb5_error_code rc;
	struct re_s *task = NULL;

	kid = ch_calloc(1, sizeof(kinit_data) );

	rc = krb5_init_context( &kid->ctx );
	if ( !rc )
		rc = krb5_cc_default(kid->ctx, &kid->ccache );

	if ( !rc ) {
		if (!principal) {
			int len=STRLENOF("ldap/")+global_host_bv.bv_len+1;
			principal=ch_calloc(len, 1);
			snprintf(principal, len, "ldap/%s", global_host_bv.bv_val);
			Log(LDAP_DEBUG_TRACE, LDAP_LEVEL_DEBUG, "Principal <%s>\n", principal );

		}
		rc = krb5_parse_name(kid->ctx, principal, &kid->princ);
	}

	if ( !rc && kt_name) {
		rc = krb5_kt_resolve(kid->ctx, kt_name, &kid->keytab);
	}

	if ( !rc )
		rc = krb5_get_init_creds_opt_alloc(kid->ctx, &kid->opts);

	if ( !rc )
		rc = krb5_get_init_creds_opt_set_out_ccache( kid->ctx, kid->opts, kid->ccache);

	if ( !rc ) {
		ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
		task = ldap_pvt_runqueue_insert( &slapd_rq, 10, kinit_qtask, (void*)kid,
				"kinit_qtask", "ldap/[email protected]" );
		ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
	}

	if (rc) {
		log_krb5_errmsg(kid->ctx, "kinit_initialize", rc);
		rc = -1;
	}
	return rc;
}

int
meta_back_db_init(
	Backend		*be,
	ConfigReply	*cr)
{
	metainfo_t	*mi;
	int		i;
	BackendInfo	*bi;

	bi = backend_info( "ldap" );
	if ( !bi || !bi->bi_extra ) {
		Debug( LDAP_DEBUG_ANY,
			"meta_back_db_init: needs back-ldap\n" );
		return 1;
	}

	mi = ch_calloc( 1, sizeof( metainfo_t ) );
	if ( mi == NULL ) {
 		return -1;
 	}

	/* set default flags */
	mi->mi_flags =
		META_BACK_F_DEFER_ROOTDN_BIND
		| META_BACK_F_PROXYAUTHZ_ALWAYS
		| META_BACK_F_PROXYAUTHZ_ANON
		| META_BACK_F_PROXYAUTHZ_NOANON;

	/*
	 * At present the default is no default target;
	 * this may change
	 */
	mi->mi_defaulttarget = META_DEFAULT_TARGET_NONE;
	mi->mi_bind_timeout.tv_sec = 0;
	mi->mi_bind_timeout.tv_usec = META_BIND_TIMEOUT;

	mi->mi_rebind_f = meta_back_default_rebind;
	mi->mi_urllist_f = meta_back_default_urllist;

	ldap_pvt_thread_mutex_init( &mi->mi_conninfo.lai_mutex );
	ldap_pvt_thread_mutex_init( &mi->mi_cache.mutex );

	/* safe default */
	mi->mi_nretries = META_RETRY_DEFAULT;
	mi->mi_version = LDAP_VERSION3;

	for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {
		mi->mi_conn_priv[ i ].mic_num = 0;
		LDAP_TAILQ_INIT( &mi->mi_conn_priv[ i ].mic_priv );
	}
	mi->mi_conn_priv_max = LDAP_BACK_CONN_PRIV_DEFAULT;

	mi->mi_ldap_extra = (ldap_extra_t *)bi->bi_extra;

	be->be_private = mi;
	be->be_cf_ocs = be->bd_info->bi_cf_ocs;

	return 0;
}

int
ch_init_plugin_out(struct ch_device *device, struct ch_dl_cx *cx)
{
    cx->b_per_pix = avpicture_get_size(cx->out_pixfmt, 1, 1);

    // If the output stride was uninitialized by the plugin, use the width.
    if (cx->out_stride == 0)
        cx->out_stride = device->framesize.width * cx->b_per_pix;

    uint32_t length = cx->out_stride * device->framesize.height;

    size_t idx;
    for (idx = 0; idx < CH_DL_NUMBUF; idx++) {
        // Get size needed for output buffer.
        cx->out_buffer[idx].length = length;

        // Allocate output buffer.
        cx->out_buffer[idx].start =
            (uint8_t *) ch_calloc(length, sizeof(uint8_t));

        if (cx->out_buffer[idx].start == NULL)
            goto clean;
    }

    if (device->calib) {
        device->calib->temp1 = (uint8_t *) ch_calloc(length, sizeof(uint8_t));
        if (device->calib->temp1 == NULL)
            goto clean;

        device->calib->temp2 = (uint8_t *) ch_calloc(length, sizeof(uint8_t));
        if (device->calib->temp2 == NULL)
            goto clean;
    }

    cx->frame_out = av_frame_alloc();
    if (cx->frame_out == NULL) {
        ch_error("Failed to allocated output frame.");
        goto clean;
    }

    return (0);

clean:
    ch_destroy_plugin_out(cx);
    return (-1);
}

static int example_init(BackendDB *be, ConfigReply *cr) {
  slap_overinst *on = (slap_overinst *)be->bd_info;
  example_data *ex = ch_calloc(1, sizeof(example_data));
  (void)cr;

  on->on_bi.bi_private = ex;
  return LDAP_SUCCESS;
}

static int
null_back_db_init( BackendDB *be, ConfigReply *cr )
{
	struct null_info *ni = ch_calloc( 1, sizeof(struct null_info) );
	ni->ni_bind_allowed = 0;
	ni->ni_nextid = 1;
	be->be_private = ni;
	be->be_cf_ocs = be->bd_info->bi_cf_ocs;
	return 0;
}

static int autoPosixIds_db_init( BackendDB *be, ConfigReply *cr ) {

	slap_overinst *on = (slap_overinst *)be->bd_info;
	autoPosixIds_data *ad = ch_calloc(1, sizeof(autoPosixIds_data));

	on->on_bi.bi_private = ad;
	ldap_pvt_thread_mutex_init( &ad->mutex );
	ad->max_uid_number = 0;

	return 0;
}

static int
mdb_db_init( BackendDB *be, ConfigReply *cr )
{
	struct mdb_info	*mdb;
	int rc;

	Debug( LDAP_DEBUG_TRACE,
		LDAP_XSTRING(mdb_db_init) ": Initializing mdb database\n" );

#if MDBX_MODE_ENABLED
	unsigned flags = mdbx_setup_debug(MDBX_DBG_DNT, mdbx_debug, MDBX_DBG_DNT);
	flags &= ~(MDBX_DBG_TRACE | MDBX_DBG_EXTRA | MDBX_DBG_ASSERT);

	if (reopenldap_mode_check())
		flags |= MDBX_DBG_ASSERT;
#	if LDAP_DEBUG > 1
		flags |= MDBX_DBG_PRINT | MDBX_DBG_TRACE;
#	endif /* LDAP_DEBUG > 1 */
#	if LDAP_DEBUG > 2
		flags |= MDBX_DBG_EXTRA;
#	endif /* LDAP_DEBUG > 2 */
	mdbx_setup_debug(flags, (MDBX_debug_func*) MDBX_DBG_DNT, MDBX_DBG_DNT);
#endif /* MDBX_MODE_ENABLED */

	/* allocate backend-database-specific stuff */
	mdb = (struct mdb_info *) ch_calloc( 1, sizeof(struct mdb_info) );

	/* DBEnv parameters */
	mdb->mi_dbenv_home = ch_strdup( SLAPD_DEFAULT_DB_DIR );
	mdb->mi_dbenv_flags = 0;
	mdb->mi_dbenv_mode = SLAPD_DEFAULT_DB_MODE;

	mdb->mi_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;
	mdb->mi_search_stack = NULL;

	mdb->mi_mapsize = DEFAULT_MAPSIZE;
	mdb->mi_rtxn_size = DEFAULT_RTXN_SIZE;

	be->be_private = mdb;
	be->be_cf_ocs = be->bd_info->bi_cf_ocs;

#ifndef MDB_MULTIPLE_SUFFIXES
	SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_ONE_SUFFIX;
#endif

	slap_backtrace_set_dir( mdb->mi_dbenv_home );

	ldap_pvt_thread_mutex_init( &mdb->mi_ads_mutex );

	rc = mdb_monitor_db_init( be );

	return rc;
}

static void quorum_be_init(BackendDB *bd) {
	slap_quorum_t *q;

	assert(quorum_list != QR_POISON);
	q = ch_calloc(1, sizeof(slap_quorum_t));

	q->qr_bd = bd;
	q->qr_next = quorum_list;
	bd->bd_quorum = q;
	bd->bd_quorum_cache = 1;
	quorum_list = q;
}

static int
lastbind_db_init(
	BackendDB *be,
	ConfigReply *cr
)
{
	slap_overinst *on = (slap_overinst *) be->bd_info;

	/* initialize private structure to store configuration */
	on->on_bi.bi_private = ch_calloc( 1, sizeof(lastbind_info) );

	return 0;
}

static int
auditlog_db_init(
	BackendDB *be,
	ConfigReply *cr
)
{
	slap_overinst *on = (slap_overinst *)be->bd_info;
	auditlog_data *ad = ch_calloc(1, sizeof(auditlog_data));

	on->on_bi.bi_private = ad;
	ldap_pvt_thread_mutex_init( &ad->ad_mutex );
	return 0;
}

static int
gssattr_dynacl_parse(
	const char	*fname,
	int 		lineno,
	const char	*opts,
	slap_style_t	style,
	const char	*pattern,
	void		**privp )
{
	gssattr_t	*gssattr;

	gssattr = (gssattr_t *)ch_calloc( 1, sizeof( gssattr_t ) );

	if ( opts == NULL || opts[0] == '\0' ) {
		fprintf( stderr, "%s line %d: GSS ACL: no attribute specified.\n",
			 fname, lineno );
		goto cleanup;
	}

	if ( pattern == NULL || pattern[0] == '\0' ) {
		fprintf( stderr, "%s line %d: GSS ACL: no attribute value specified.\n",
			 fname, lineno );
		goto cleanup;
	}

	gssattr->gssattr_style = style;

	switch ( gssattr->gssattr_style ) {
	case ACL_STYLE_BASE:
	case ACL_STYLE_REGEX:
	case ACL_STYLE_EXPAND:
		break;
	default:
		fprintf( stderr, "%s line %d: GSS ACL: unsupported style \"%s\".\n",
			 fname, lineno, style_strings[style] );
		goto cleanup;
		break;
	}

	ber_str2bv( opts,    0, 1, &gssattr->gssattr_name );
	ber_str2bv( pattern, 0, 1, &gssattr->gssattr_value );

	*privp = (void *)gssattr;
	return 0;

cleanup:
	(void)gssattr_dynacl_destroy( (void *)gssattr );

	return 1;
}

int
shell_back_db_init(
	Backend	*be,
	ConfigReply *cr
)
{
	struct shellinfo	*si;

	si = (struct shellinfo *) ch_calloc( 1, sizeof(struct shellinfo) );

	be->be_private = si;

	return si == NULL;
}