int slapi_register_object_extension(
const char *pluginname,
const char *objectname,
slapi_extension_constructor_fnptr constructor,
slapi_extension_destructor_fnptr destructor,
int *objecttype,
int *extensionhandle)
{
int rc;
slapi_extension_t type;
struct slapi_registered_extension *re;
ldap_pvt_thread_mutex_lock( ®istered_extensions.mutex );
rc = map_extension_type( objectname, &type );
if ( rc != 0 ) {
ldap_pvt_thread_mutex_unlock( ®istered_extensions.mutex );
return rc;
}
*objecttype = (int)type;
re = ®istered_extensions.extensions[*objecttype];
*extensionhandle = re->count;
if ( re->active ) {
/* can't add new extensions after objects have been created */
ldap_pvt_thread_mutex_unlock( ®istered_extensions.mutex );
return -1;
}
re->count++;
if ( re->constructors == NULL ) {
re->constructors = (slapi_extension_constructor_fnptr *)slapi_ch_calloc( re->count,
sizeof( slapi_extension_constructor_fnptr ) );
} else {
re->constructors = (slapi_extension_constructor_fnptr *)slapi_ch_realloc( (char *)re->constructors,
re->count * sizeof( slapi_extension_constructor_fnptr ) );
}
re->constructors[*extensionhandle] = constructor;
if ( re->destructors == NULL ) {
re->destructors = (slapi_extension_destructor_fnptr *)slapi_ch_calloc( re->count,
sizeof( slapi_extension_destructor_fnptr ) );
} else {
re->destructors = (slapi_extension_destructor_fnptr *)slapi_ch_realloc( (char *)re->destructors,
re->count * sizeof( slapi_extension_destructor_fnptr ) );
}
re->destructors[*extensionhandle] = destructor;
ldap_pvt_thread_mutex_unlock( ®istered_extensions.mutex );
return 0;
}
int slapi_int_create_object_extensions(int objecttype, void *object)
{
int i;
struct slapi_extension_block *eblock;
void **peblock;
void *parent;
switch ((slapi_extension_t) objecttype) {
case SLAPI_X_EXT_CONNECTION:
peblock = &(((Connection *)object)->c_extensions);
parent = NULL;
break;
case SLAPI_X_EXT_OPERATION:
peblock = &(((Operation *)object)->o_hdr->oh_extensions);
parent = ((Operation *)object)->o_conn;
break;
default:
return -1;
break;
}
*peblock = NULL;
ldap_pvt_thread_mutex_lock( ®istered_extensions.mutex );
if ( registered_extensions.extensions[objecttype].active == 0 ) {
/*
* once we've created some extensions, no new extensions can
* be registered.
*/
registered_extensions.extensions[objecttype].active = 1;
}
ldap_pvt_thread_mutex_unlock( ®istered_extensions.mutex );
eblock = (struct slapi_extension_block *)slapi_ch_calloc( 1, sizeof(*eblock) );
if ( registered_extensions.extensions[objecttype].count ) {
eblock->extensions = (void **)slapi_ch_calloc( registered_extensions.extensions[objecttype].count, sizeof(void *) );
for ( i = 0; i < registered_extensions.extensions[objecttype].count; i++ ) {
new_extension( eblock, objecttype, object, parent, i );
}
} else {
eblock->extensions = NULL;
}
*peblock = eblock;
return 0;
}
Slapi_Backend *
slapi_be_new( const char *type, const char *name, int isprivate, int logchanges )
{
Slapi_Backend *be;
int i;
/* should add some locking here to prevent concurrent access */
if ( nbackends == maxbackends )
{
int oldsize = maxbackends;
maxbackends += BACKEND_GRAB_SIZE;
backends = (Slapi_Backend **) slapi_ch_realloc( (char *) backends, maxbackends * sizeof(Slapi_Backend *) );
memset( &backends[oldsize], '\0', BACKEND_GRAB_SIZE * sizeof(Slapi_Backend *) );
}
for (i=0; ((i<maxbackends) && (backends[i])); i++)
;
PR_ASSERT(i<maxbackends);
be = (Slapi_Backend *) slapi_ch_calloc(1, sizeof(Slapi_Backend));
be->be_lock = slapi_new_rwlock();
be_init( be, type, name, isprivate, logchanges, defsize, deftime );
backends[i] = be;
nbackends++;
slapi_log_err(SLAPI_LOG_TRACE, "slapi_be_new",
"Added new backend name [%s] type [%s] nbackends [%d]\n",
name, type, nbackends);
return( be );
}
int
sync_send_entry_from_changelog(Slapi_PBlock *pb,int chg_req, char *uniqueid)
{
Slapi_Entry *db_entry = NULL;
int chg_type = LDAP_SYNC_ADD;
int rv;
Slapi_PBlock *search_pb = NULL;
Slapi_Entry **entries = NULL;
char *origbase;
char *filter = slapi_ch_smprintf("(nsuniqueid=%s)",uniqueid);
slapi_pblock_get( pb, SLAPI_ORIGINAL_TARGET_DN, &origbase );
search_pb = slapi_pblock_new();
slapi_search_internal_set_pb(search_pb, origbase,
LDAP_SCOPE_SUBTREE, filter,
NULL, 0, NULL, NULL, plugin_get_default_component_id(), 0);
slapi_search_internal_pb(search_pb);
slapi_pblock_get(search_pb, SLAPI_PLUGIN_INTOP_RESULT, &rv);
if ( rv == LDAP_SUCCESS) {
slapi_pblock_get(search_pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries);
if (entries)
db_entry = *entries; /* there can only be one */
}
if (db_entry && sync_is_entry_in_scope(pb, db_entry)) {
LDAPControl **ctrl = (LDAPControl **)slapi_ch_calloc(2, sizeof (LDAPControl *));
sync_create_state_control(db_entry, &ctrl[0], chg_type, NULL);
slapi_send_ldap_search_entry (pb, db_entry, ctrl, NULL, 0);
ldap_controls_free(ctrl);
}
slapi_free_search_results_internal(search_pb);
slapi_pblock_destroy(search_pb);
slapi_ch_free((void **)&filter);
return (0);
}
/*
* Create a new protocol instance.
*/
Repl_Protocol *
prot_new(Repl_Agmt *agmt, int protocol_state)
{
Slapi_DN *replarea_sdn = NULL;
Repl_Protocol *rp = (Repl_Protocol *)slapi_ch_calloc(1, sizeof(Repl_Protocol));
rp->prp_incremental = rp->prp_total = rp->prp_active_protocol = NULL;
if (protocol_state == STATE_PERFORMING_TOTAL_UPDATE)
{
rp->state = STATE_PERFORMING_TOTAL_UPDATE;
}
else
{
rp->state = STATE_PERFORMING_INCREMENTAL_UPDATE;
}
rp->next_state = STATE_PERFORMING_INCREMENTAL_UPDATE;
if ((rp->lock = PR_NewLock()) == NULL)
{
goto loser;
}
rp->agmt = agmt;
rp->conn = NULL;
/* Acquire the local replica object */
replarea_sdn = agmt_get_replarea(agmt);
rp->replica_object = replica_get_replica_from_dn(replarea_sdn);
if (NULL == rp->replica_object)
{
/* Whoa, no local replica!?!? */
slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name,
"prot_new - %s: Unable to locate replica object for local replica %s\n",
agmt_get_long_name(agmt),
slapi_sdn_get_dn(replarea_sdn));
goto loser;
}
if (get_agmt_agreement_type(agmt) == REPLICA_TYPE_MULTIMASTER)
{
rp->prp_incremental = private_protocol_factory(rp, PROTOCOL_5_INCREMENTAL);
rp->prp_total = private_protocol_factory(rp, PROTOCOL_5_TOTAL);
rp->delete_conn = conn_delete;
}
else if (get_agmt_agreement_type(agmt) == REPLICA_TYPE_WINDOWS)
{
rp->prp_incremental = private_protocol_factory(rp, PROTOCOL_WINDOWS_INCREMENTAL);
rp->prp_total = private_protocol_factory(rp, PROTOCOL_WINDOWS_TOTAL);
rp->delete_conn = windows_conn_delete;
}
/* XXXggood register callback handlers for entries updated, and
schedule window enter/leave. */
goto done;
loser:
prot_delete(&rp);
done:
slapi_sdn_free(&replarea_sdn);
return rp;
}
int sync_srch_refresh_post_search(Slapi_PBlock *pb)
{
int rc = 0;
SyncOpInfo *info = sync_get_operation_extension(pb);
if (!info) {
return (0); /* nothing to do */
}
if (info->send_flag & SYNC_FLAG_SEND_INTERMEDIATE) {
rc = sync_intermediate_msg(pb, LDAP_TAG_SYNC_REFRESH_DELETE, info->cookie, NULL);
/* the refresh phase is over, now the post op
* plugins will create the state control
* depending on the operation type, reset flag
*/
info->send_flag &= ~SYNC_FLAG_ADD_STATE_CTRL;
/* activate the persistent phase thread*/
sync_persist_startup(info->tid, info->cookie);
}
if (info->send_flag & SYNC_FLAG_ADD_DONE_CTRL) {
LDAPControl **ctrl = (LDAPControl **)slapi_ch_calloc(2, sizeof (LDAPControl *));
char *cookiestr = sync_cookie2str(info->cookie);
sync_create_sync_done_control( &ctrl[0], 0, cookiestr);
slapi_pblock_set(pb, SLAPI_RESCONTROLS, ctrl);
slapi_ch_free((void **)&cookiestr);
}
return(rc);
}
static struct berval*
ss_filter_key (indexer_t* ix, struct berval* val)
{
struct berval* key = (struct berval*) slapi_ch_calloc (1, sizeof(struct berval));
if (val->bv_len > 0) {
struct berval** keys = NULL;
auto struct berval* vals[2];
vals[0] = val;
vals[1] = NULL;
keys = ix->ix_index (ix, vals, NULL);
if (keys && keys[0]) {
/* why +1 in the len? you need the +1 to old the trailing NULL,
to guard against someone accidentally doing a strcmp or
other str function, but a bvcmp is going to use the bv_len
which includes the trailing NULL which the value being
compared against might not have - not only are bervals
not guaranteed to be properly NULL terminated, but they
also contain binary data - see slapi_ber_bvcpy() */
key->bv_len = keys[0]->bv_len + 1;
key->bv_val = slapi_ch_malloc (key->bv_len);
memcpy (key->bv_val, keys[0]->bv_val, keys[0]->bv_len);
key->bv_val[key->bv_len-1] = '\0';
}
}
return key;
}
void
ReplGenericListAddObject(ReplGenericList *list,
void *newObject)
{
if(list) {
ReplGenericList *new_struct = (ReplGenericList *)
slapi_ch_calloc(1, sizeof(ReplGenericList));
if (!new_struct)
return;
/* set back pointer of old first element */
if(list->next) {
list->next->prev = new_struct;
}
/* we might have a next but since we are the first we WONT have
a previous */
new_struct->object = newObject;
new_struct->next = list->next;
new_struct->prev = NULL;
/* the new element is the first one */
list->next = new_struct;
/* if this is the only element it is the end too */
if(NULL == list->prev)
list->prev = new_struct;
}
return;
}
/*
* mempool_init creates NSPR thread private index,
* then allocates per-thread-private.
* mempool is initialized at the first mempool_return
*/
static void
mempool_init(struct mempool **my_mempool)
{
int i;
if (NULL == my_mempool) {
return;
}
#ifdef SHARED_MEMPOOL
for (i = 0; MEMPOOL_END != mempool[i].mempool_name; i++) {
mempool[i].mempool_mutex = PR_NewLock();
if (NULL == mempool[i].mempool_mutex) {
PRErrorCode ec = PR_GetError();
slapi_log_err(SLAPI_LOG_ERR, "mempool", "mempool_init: "
"failed to create mutex - (%d - %s); mempool(%s) is disabled",
ec, slapd_pr_strerror(ec), mempool[i].mempool_name);
rc = LDAP_OPERATIONS_ERROR;
}
}
#else
PR_NewThreadPrivateIndex (&mempool_index, mempool_destroy);
*my_mempool = (struct mempool *)slapi_ch_calloc(MAX_MEMPOOL, sizeof(struct mempool));
for (i = 0; i < MAX_MEMPOOL; i++) {
(*my_mempool)[i].mempool_name = mempool_names[i];
}
#endif
}
/*
Converts generalized time to UNIX GMT time. For example:
"20060807211257Z" -> 1154981577
*/
time_t
gentimeToEpochtime( char *gentimestr ) {
time_t epochtime, cur_local_epochtime, cur_gm_epochtime, zone_offset;
struct tm t, *cur_gm_time;
/* Find the local offset from GMT */
cur_gm_time = (struct tm*)slapi_ch_calloc( 1, sizeof( struct tm ) );
cur_local_epochtime = time( (time_t *)0 );
gmtime_r( &cur_local_epochtime, cur_gm_time );
cur_gm_epochtime = mktime( cur_gm_time );
free( cur_gm_time );
zone_offset = cur_gm_epochtime - cur_local_epochtime;
/* Parse generalizedtime string into a tm struct */
t.tm_year = antoi( gentimestr, 0, 4 ) - 1900;
t.tm_mon = antoi( gentimestr, 4, 2 ) - 1;
t.tm_mday = antoi( gentimestr, 6, 2 );
t.tm_hour = antoi( gentimestr, 8, 2 );
t.tm_min = antoi( gentimestr, 10, 2 );
t.tm_sec = antoi( gentimestr, 12, 2 );
t.tm_isdst = 0; /* DST does not apply to UTC */
/* Turn tm object into local epoch time */
epochtime = mktime( &t );
/* Turn local epoch time into GMT epoch time */
epochtime -= zone_offset;
return( epochtime );
}
static SyncOpInfo*
new_SyncOpInfo(int flag, PRThread *tid, Sync_Cookie *cookie) {
SyncOpInfo *spec = (SyncOpInfo *)slapi_ch_calloc(1, sizeof(SyncOpInfo));
spec->send_flag = flag;
spec->cookie = cookie;
spec->tid = tid;
return spec;
}
/*
* **************************************************************************
* API
* **************************************************************************
*/
CSNGen*
csngen_new (ReplicaId rid, Slapi_Attr *state)
{
int rc = CSN_SUCCESS;
CSNGen *gen = NULL;
gen = (CSNGen*)slapi_ch_calloc (1, sizeof (CSNGen));
if (gen == NULL)
{
slapi_log_err(SLAPI_LOG_ERR, "csngen_new", "Memory allocation failed\n");
return NULL;
}
/* create lock to control the access to the state information */
gen->lock = slapi_new_rwlock();
if (gen->lock == NULL)
{
slapi_log_err(SLAPI_LOG_ERR, "csngen_new", "Failed to create lock\n");
rc = CSN_NSPR_ERROR;
goto done;
}
/* initialize callback list */
_csngen_init_callbacks (gen);
gen->state.rid = rid;
if (state)
{
rc = _csngen_parse_state (gen, state);
if (rc != CSN_SUCCESS)
{
goto done;
}
}
else
{
/* new generator */
gen->state.sampled_time = current_time ();
gen->state.local_offset = 0;
gen->state.remote_offset = 0;
gen->state.seq_num = 0;
}
done:
if (rc != CSN_SUCCESS)
{
if (gen)
{
csngen_free (&gen);
}
return NULL;
}
return gen;
}
/*
The type and val pointers are assumed to have sufficient lifetime -
we don't have to copy them - they are usually just pointers into
the SLAPI_PLUGIN_MR_TYPE and SLAPI_PLUGIN_MR_VALUE fields of the
operation pblock, whose lifetime should encompass the creation
and destruction of the bitwise_match_cb object.
*/
static struct bitwise_match_cb *
new_bitwise_match_cb(char *type, struct berval *val)
{
struct bitwise_match_cb *bmc = (struct bitwise_match_cb *)slapi_ch_calloc(1, sizeof(struct bitwise_match_cb));
bmc->type = slapi_ch_strdup(type);
bmc->val = val;
return bmc;
}
Slapi_ValueSet *
slapi_valueset_new()
{
Slapi_ValueSet *vs = (Slapi_ValueSet *)slapi_ch_calloc(1,sizeof(Slapi_ValueSet));
if(vs)
slapi_valueset_init(vs);
return vs;
}
Slapi_ValueSet *
valueset_dup(const Slapi_ValueSet *dupee)
{
Slapi_ValueSet *duped= (Slapi_ValueSet *)slapi_ch_calloc(1,sizeof(Slapi_ValueSet));
if (NULL!=duped)
{
valueset_add_valuearray( duped, dupee->va );
}
return duped;
}
int
aclgroup_init ()
{
aclUserGroups = ( aclGroupCache * ) slapi_ch_calloc (1, sizeof ( aclGroupCache ) );
if ( NULL == (aclUserGroups->aclg_rwlock = slapi_new_rwlock())) {
slapi_log_error(SLAPI_LOG_FATAL, plugin_name, "Unable to allocate RWLOCK for group cache\n");
return 1;
}
return 0;
}
/*
* This is the conversation function passed into pam_start(). This is what sets the password
* that PAM uses to authenticate. This function is sort of stupid - it assumes all echo off
* or binary prompts are for the password, and other prompts are for the username. Time will
* tell if this is actually the case.
*/
static int
pam_conv_func(int num_msg, const struct pam_message **msg, struct pam_response **resp, void *mydata)
{
int ii;
struct berval *creds;
struct my_pam_conv_str *my_data = (struct my_pam_conv_str *)mydata;
struct pam_response *reply;
int ret = PAM_SUCCESS;
if (num_msg <= 0) {
return PAM_CONV_ERR;
}
/* empty reply structure */
reply = (struct pam_response *)slapi_ch_calloc(num_msg,
sizeof(struct pam_response));
slapi_pblock_get( my_data->pb, SLAPI_BIND_CREDENTIALS, &creds ); /* the password */
for (ii = 0; ii < num_msg; ++ii) {
slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
"pam msg [%d] = %d %s\n", ii, msg[ii]->msg_style,
msg[ii]->msg);
/* hard to tell what prompt is for . . . */
/* assume prompts for password are either BINARY or ECHO_OFF */
if (msg[ii]->msg_style == PAM_PROMPT_ECHO_OFF) {
reply[ii].resp = strdupbv(creds);
#ifdef LINUX
} else if (msg[ii]->msg_style == PAM_BINARY_PROMPT) {
reply[ii].resp = strdupbv(creds);
#endif
} else if (msg[ii]->msg_style == PAM_PROMPT_ECHO_ON) { /* assume username */
reply[ii].resp = slapi_ch_strdup(my_data->pam_identity);
} else if (msg[ii]->msg_style == PAM_ERROR_MSG) {
slapi_log_error(SLAPI_LOG_FATAL, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
"pam msg [%d] error [%s]\n", ii, msg[ii]->msg);
} else if (msg[ii]->msg_style == PAM_TEXT_INFO) {
slapi_log_error(SLAPI_LOG_PLUGIN, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
"pam msg [%d] text info [%s]\n", ii, msg[ii]->msg);
} else {
slapi_log_error(SLAPI_LOG_FATAL, PAM_PASSTHRU_PLUGIN_SUBSYSTEM,
"Error: unknown pam message type (%d: %s)\n",
msg[ii]->msg_style, msg[ii]->msg);
ret = PAM_CONV_ERR;
}
}
if (ret == PAM_CONV_ERR) {
free_pam_response(num_msg, reply);
reply = NULL;
}
*resp = reply;
return ret;
}
static struct factory_type*
new_factory_type(const char *name, size_t offset)
{
struct factory_type* ft= (struct factory_type*)slapi_ch_calloc(1, sizeof(struct factory_type));
ft->name= slapi_ch_strdup(name);
ft->extension_lock = PR_NewLock();
ft->extension_count= 0;
ft->extension_offset= offset;
ft->existence_count= 0;
return ft;
}
static void
ldbm_instance_attrcrypt_enable(struct attrinfo *ai, int cipher)
{
attrcrypt_private *priv = NULL;
if (NULL == ai->ai_attrcrypt) {
/* No existing private structure, allocate one */
ai->ai_attrcrypt = (attrcrypt_private*) slapi_ch_calloc(1, sizeof(attrcrypt_private));
}
priv = ai->ai_attrcrypt;
priv->attrcrypt_cipher = cipher;
}
static
sasl_map_private *sasl_map_new_private(void)
{
Slapi_RWLock *new_lock = slapi_new_rwlock();
sasl_map_private *new_priv = NULL;
if (NULL == new_lock) {
return NULL;
}
new_priv = (sasl_map_private *)slapi_ch_calloc(1,sizeof(sasl_map_private));
new_priv->lock = new_lock;
return new_priv;
}
CSN *csn_new()
{
#ifdef DEBUG
if(!counters_created)
{
csn_create_counters();
}
slapi_counter_increment(slapi_csn_counter_created);
slapi_counter_increment(slapi_csn_counter_exist);
#endif
return (CSN*)slapi_ch_calloc(sizeof(CSN),1);
}
/* create per-domain config object */
void *
ipa_winsync_config_new_domain(
const Slapi_DN *ds_subtree,
const Slapi_DN *ad_subtree
)
{
IPA_WinSync_Domain_Config *iwdc =
(IPA_WinSync_Domain_Config *)
slapi_ch_calloc(1, sizeof(IPA_WinSync_Domain_Config));
return (void *)iwdc;
}
/* This function does a shallow copy on the payload data supplied, so the caller should not free it, and it needs to be allocated using slapi_ch_malloc() */
static
sasl_map_data *sasl_map_new_data(char *name, char *regex, char *dntemplate, char *filtertemplate, int priority)
{
sasl_map_data *new_dp = (sasl_map_data *) slapi_ch_calloc(1,sizeof(sasl_map_data));
new_dp->name = name;
new_dp->regular_expression = regex;
new_dp->template_base_dn = dntemplate;
new_dp->template_search_filter = filtertemplate;
new_dp->priority = priority;
new_dp->next = NULL;
new_dp->prev = NULL;
return new_dp;
}
ReplGenericList *
ReplGenericListNew(void)
{
ReplGenericList *list=NULL;
if(NULL == (list = (ReplGenericList *)
slapi_ch_calloc(1,sizeof(ReplGenericList)))) {
return(NULL);
}
list->object = NULL;
list->next = NULL;
list->prev = NULL;
return(list);
}
void dl_init (DataList *dl, int init_alloc)
{
PR_ASSERT (dl);
memset (dl, 0, sizeof (*dl));
if (init_alloc <= 0)
dl->alloc_count = INIT_ALLOC;
else
dl->alloc_count = init_alloc;
dl->elements = (void**)slapi_ch_calloc (dl->alloc_count, sizeof (void*));
}
/*
* Construct a new ec structure
*/
static slapi_eq_context *
eq_new(slapi_eq_fn_t fn, void *arg, time_t when, unsigned long interval)
{
slapi_eq_context *retptr = (slapi_eq_context *)slapi_ch_calloc(1, sizeof(slapi_eq_context));
time_t now;
retptr->ec_fn = fn;
retptr->ec_arg = arg;
now = current_time();
retptr->ec_when = when < now ? now : when;
retptr->ec_interval = interval == 0UL ? 0UL : (interval + 999) / 1000;
retptr->ec_id = (Slapi_Eq_Context)retptr;
return retptr;
}
/*
* aclanom_init ();
* Generate a profile for the anonymous user. We can use this profile
* later to determine what resources the client is allowed to.
*
* Dependency:
* Before calling this, it is assumed that all the ACLs have been read
* and parsed.
*
* We will go thru all the ACL and pick the ANYONE ACL and generate the anom
* profile.
*
*/
int
aclanom_init ()
{
acl_anom_profile = (struct anom_profile * )
slapi_ch_calloc (1, sizeof ( struct anom_profile ) );
if (( anom_rwlock = slapi_new_rwlock()) == NULL ) {
slapi_log_err(SLAPI_LOG_ERR, plugin_name,
"aclanom_init - Failed in getting the ANOM rwlock\n" );
return 1;
}
return 0;
}
static struct factory_extension*
new_factory_extension(
const char *pluginname,
slapi_extension_constructor_fnptr constructor,
slapi_extension_destructor_fnptr destructor)
{
struct factory_extension* fe = (struct factory_extension*)slapi_ch_calloc(1, sizeof(struct factory_extension));
fe->pluginname= slapi_ch_strdup(pluginname);
fe->constructor= constructor;
fe->destructor= destructor;
return fe;
}
int sync_srch_refresh_pre_entry(Slapi_PBlock *pb)
{
int rc = 0;
SyncOpInfo *info = sync_get_operation_extension(pb);
if (!info) {
rc = 0; /* nothing to do */
} else if (info->send_flag & SYNC_FLAG_ADD_STATE_CTRL) {
Slapi_Entry *e;
slapi_pblock_get(pb, SLAPI_SEARCH_RESULT_ENTRY, &e);
LDAPControl **ctrl = (LDAPControl **)slapi_ch_calloc(2, sizeof (LDAPControl *));
sync_create_state_control(e, &ctrl[0], LDAP_SYNC_ADD, NULL);
slapi_pblock_set(pb, SLAPI_SEARCH_CTRLS, ctrl);
}
return(rc);
}
static int
convert_to_string(Slapi_DN *dn, void *arg)
{
struct list_to_string_data *data = (struct list_to_string_data *)arg;
int newlen = slapi_sdn_get_ndn_len(dn) + strlen(data->delimiter) + 1;
if (data->string) {
newlen += strlen(data->string);
data->string = slapi_ch_realloc(data->string, newlen);
} else {
data->string = slapi_ch_calloc(1, newlen);
}
strcat(data->string, slapi_sdn_get_dn(dn));
strcat(data->string, data->delimiter);
return 1;
}