/*
* snmp_collator_create_semaphore()
*
* Create a semaphore to synchronize access to the stats file with
* the SNMP sub-agent. NSPR doesn't support a trywait function
* for semaphores, so we just use POSIX semaphores directly.
*/
static void
snmp_collator_create_semaphore()
{
/* First just try to create the semaphore. This should usually just work. */
if ((stats_sem = sem_open(stats_sem_name, O_CREAT | O_EXCL, SLAPD_DEFAULT_FILE_MODE, 1)) == SEM_FAILED) {
if (errno == EEXIST) {
/* It appears that we didn't exit cleanly last time and left the semaphore
* around. Recreate it since we don't know what state it is in. */
if (sem_unlink(stats_sem_name) != 0) {
LDAPDebug( LDAP_DEBUG_ANY, "Failed to delete old semaphore for stats file (%s). "
"Error %d (%s).\n", szStatsFile, errno, slapd_system_strerror(errno) );
exit(1);
}
if ((stats_sem = sem_open(stats_sem_name, O_CREAT | O_EXCL, SLAPD_DEFAULT_FILE_MODE, 1)) == SEM_FAILED) {
/* No dice */
LDAPDebug( LDAP_DEBUG_ANY, "Failed to create semaphore for stats file (%s). Error %d (%s).\n",
szStatsFile, errno, slapd_system_strerror(errno) );
exit(1);
}
} else {
/* Some other problem occurred creating the semaphore. */
LDAPDebug( LDAP_DEBUG_ANY, "Failed to create semaphore for stats file (%s). Error %d.(%s)\n",
szStatsFile, errno, slapd_system_strerror(errno) );
exit(1);
}
}
/* If we've reached this point, everything should be good. */
return;
}
static int
bitwise_filter_create (Slapi_PBlock* pb)
{
auto int rc = LDAP_UNAVAILABLE_CRITICAL_EXTENSION; /* failed to initialize */
auto char* mrOID = NULL;
auto char* mrTYPE = NULL;
auto struct berval* mrVALUE = NULL;
if (!slapi_pblock_get (pb, SLAPI_PLUGIN_MR_OID, &mrOID) && mrOID != NULL &&
!slapi_pblock_get (pb, SLAPI_PLUGIN_MR_TYPE, &mrTYPE) && mrTYPE != NULL &&
!slapi_pblock_get (pb, SLAPI_PLUGIN_MR_VALUE, &mrVALUE) && mrVALUE != NULL) {
struct bitwise_match_cb *bmc = NULL;
if (strcmp(mrOID, "1.2.840.113556.1.4.803") == 0) {
slapi_pblock_set (pb, SLAPI_PLUGIN_MR_FILTER_MATCH_FN, (void*)bitwise_filter_match_and);
} else if (strcmp(mrOID, "1.2.840.113556.1.4.804") == 0) {
slapi_pblock_set (pb, SLAPI_PLUGIN_MR_FILTER_MATCH_FN, (void*)bitwise_filter_match_or);
} else { /* this oid not handled by this plugin */
LDAPDebug (LDAP_DEBUG_FILTER, "=> bitwise_filter_create OID (%s) not handled\n", mrOID, 0, 0);
return rc;
}
bmc = new_bitwise_match_cb(mrTYPE, mrVALUE);
slapi_pblock_set (pb, SLAPI_PLUGIN_OBJECT, bmc);
slapi_pblock_set (pb, SLAPI_PLUGIN_DESTROY_FN, (void*)bitwise_filter_destroy);
rc = LDAP_SUCCESS;
} else {
LDAPDebug (LDAP_DEBUG_FILTER, "=> bitwise_filter_create missing parameter(s)\n", 0, 0, 0);
}
LDAPDebug (LDAP_DEBUG_FILTER, "<= bitwise_filter_create %i\n", rc, 0, 0);
return LDAP_SUCCESS;
}
static int
memory_record_dump( caddr_t data, caddr_t arg )
{
int frame= 0;
char b1[MR_DUMP_AMOUNT*2+1];
char b2[MR_DUMP_AMOUNT+1];
char b3[128];
int size= 0;
struct memory_record *mr = (struct memory_record *)data;
if(!IsBadReadPtr(mr->p, MR_DUMP_AMOUNT))
{
size= MR_DUMP_AMOUNT;
}
mr_to_hex_dump(b1, mr->p, size, MR_DUMP_AMOUNT);
mr_to_char_dump(b2, mr->p, size, MR_DUMP_AMOUNT);
PR_snprintf(b3,sizeof(b3),"%p %ld %s %s",mr->p,mr->size,b1,b2);
LDAPDebug( LDAP_DEBUG_ANY, "%s\n",b3,0,0);
while(mr->ra[frame]!=0)
{
char fn[100];
AddressToName(mr->ra[frame], fn, 100);
LDAPDebug( LDAP_DEBUG_ANY, "%d %p %s\n",frame,mr->ra[frame],fn);
frame++;
}
return 0;
}
int
nsldapi_is_read_ready( LDAP *ld, Sockbuf *sb )
{
struct selectinfo *sip;
short i;
if (( sip = (struct selectinfo *)ld->ld_selectinfo ) == NULL ) {
return( 0 ); /* punt */
}
if ( ld->ld_select_fn != NULL ) {
return( FD_ISSET( (int)sb->sb_sd, &sip->si_stdinfo.ssi_use_readfds ));
}
if ( sip->si_count > 0 && sip->si_streaminfo != NULL ) {
for ( i = 0; i < sip->si_count; ++i ) {
if ( sip->si_streaminfo[ i ].tcpsi_stream == (tcpstream *)sb->sb_sd ) {
#ifdef LDAP_DEBUG
if ( sip->si_streaminfo[ i ].tcpsi_is_read_ready ) {
LDAPDebug( LDAP_DEBUG_TRACE, "is_read_ready: stream %x READY\n",
(tcpstream *)sb->sb_sd, 0, 0 );
} else {
LDAPDebug( LDAP_DEBUG_TRACE, "is_read_ready: stream %x Not Ready\n",
(tcpstream *)sb->sb_sd, 0, 0 );
}
#endif /* LDAP_DEBUG */
return( sip->si_streaminfo[ i ].tcpsi_is_read_ready ? 1 : 0 );
}
}
}
LDAPDebug( LDAP_DEBUG_TRACE, "is_read_ready: stream %x: NOT FOUND\n", (tcpstream *)sb->sb_sd, 0, 0 );
return( 0 );
}
int dblayer_copy_file_resetlsns(char *home_dir ,char *source_file_name, char *destination_file_name, int overwrite, dblayer_private *priv)
{
int retval = 0;
DB_ENV *env = NULL;
LDAPDebug( LDAP_DEBUG_TRACE, "=> dblayer_copy_file_resetlsns\n", 0, 0, 0 );
/* Make the environment */
retval = dblayer_make_private_simple_env(home_dir,&env);
if (retval || !env) {
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_resetlsns: Call to dblayer_make_private_simple_env failed!\n"
"Unable to open an environment.", 0, 0, 0);
goto out;
}
/* Do the copy */
retval = dblayer_copy_file_keybykey(env, source_file_name, destination_file_name, overwrite, priv);
if (retval) {
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_resetlsns: Copy not completed successfully.", 0, 0, 0);
}
out:
/* Close the environment */
if (env) {
int retval2 = 0;
retval2 = env->close(env,0);
if (retval2) {
if (0 == retval) {
retval = retval2;
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_copy_file_resetlsns, error %d: %s\n", retval, db_strerror(retval), 0);
}
}
}
LDAPDebug( LDAP_DEBUG_TRACE, "<= dblayer_copy_file_resetlsns\n", 0, 0, 0 );
return retval;
}
/* Make an environment to be used for isolated recovery (e.g. during a partial restore operation) */
int dblayer_make_private_recovery_env(char *db_home_dir, dblayer_private *priv, DB_ENV **env)
{
int retval = 0;
DB_ENV *ret_env = NULL;
LDAPDebug( LDAP_DEBUG_TRACE, "=> dblayer_make_private_recovery_env\n", 0, 0, 0 );
if (NULL == env) {
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_recovery_env: Null environment. Cannot continue.", 0, 0, 0);
return -1;
}
*env = NULL;
retval = db_env_create(&ret_env,0);
if (retval) {
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_recovery_env, Create error %d: %s\n", retval, db_strerror(retval), 0);
goto error;
}
dblayer_set_env_debugging(ret_env, priv);
retval = (ret_env->open)(ret_env,db_home_dir, DB_INIT_TXN | DB_RECOVER_FATAL | DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE,0);
if (0 == retval) {
*env = ret_env;
} else {
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_recovery_env, Open error %d: %s\n", retval, db_strerror(retval), 0);
goto error;
}
error:
LDAPDebug( LDAP_DEBUG_TRACE, "<= dblayer_make_private_recovery_env\n", 0, 0, 0 );
return retval;
}
/* Make an environment to be used for simple non-transacted database operations, e.g. fixup during upgrade */
int dblayer_make_private_simple_env(char *db_home_dir, DB_ENV **env)
{
int retval = 0;
DB_ENV *ret_env = NULL;
LDAPDebug( LDAP_DEBUG_TRACE, "=> dblayer_make_private_simple_env\n", 0, 0, 0 );
if (NULL == env) {
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_simple_env: Null environment. Cannot continue.", 0, 0, 0);
return -1;
}
*env = NULL;
retval = db_env_create(&ret_env,0);
if (retval) {
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_simple_env, error %d: %s\n", retval, db_strerror(retval), 0);
goto error;
}
retval = (ret_env->open)(ret_env,db_home_dir,DB_CREATE | DB_INIT_MPOOL | DB_PRIVATE,0);
if (0 == retval) {
*env = ret_env;
} else {
LDAPDebug(LDAP_DEBUG_ANY, "dblayer_make_private_simple_env, error %d: %s\n", retval, db_strerror(retval), 0);
goto error;
}
error:
LDAPDebug( LDAP_DEBUG_TRACE, "<= dblayer_make_private_simple_env\n", 0, 0, 0 );
return retval;
}
int
int_init( Slapi_PBlock *pb )
{
int rc, flags;
LDAPDebug( LDAP_DEBUG_PLUGIN, "=> int_init\n", 0, 0, 0 );
rc = slapi_pblock_set( pb, SLAPI_PLUGIN_VERSION,
(void *) SLAPI_PLUGIN_VERSION_01 );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_DESCRIPTION,
(void *)&pdesc );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_FILTER_AVA,
(void *) int_filter_ava );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_VALUES2KEYS,
(void *) int_values2keys );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_ASSERTION2KEYS_AVA,
(void *) int_assertion2keys );
flags = SLAPI_PLUGIN_SYNTAX_FLAG_ORDERING;
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_FLAGS,
(void *) &flags );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_NAMES,
(void *) names );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_OID,
(void *) INTEGER_SYNTAX_OID );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_COMPARE,
(void *) int_compare );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_VALIDATE,
(void *) int_validate );
rc |= slapi_pblock_set( pb, SLAPI_PLUGIN_SYNTAX_NORMALIZE,
(void *) int_normalize );
rc |= register_matching_rule_plugins();
LDAPDebug( LDAP_DEBUG_PLUGIN, "<= int_init %d\n", rc, 0, 0 );
return( rc );
}
/* Checks if created attributes are used in the RDN.
* Returns 1 if created attrs are in the RDN, and
* 0 if created attrs are not in the RDN. Returns
* -1 if an error occurs.
*/
static int check_rdn_for_created_attrs(const char *newrdn)
{
int i, rc = 0;
Slapi_RDN *rdn = NULL;
char *value = NULL;
char *type[] = {"modifytimestamp", "createtimestamp",
"creatorsname", "modifiersname", 0};
if (newrdn && *newrdn && (rdn = slapi_rdn_new())) {
slapi_rdn_init_dn(rdn, newrdn);
for (i = 0; type[i] != NULL; i++) {
if (slapi_rdn_contains_attr(rdn, type[i], &value)) {
LDAPDebug(LDAP_DEBUG_TRACE, "Invalid DN. RDN contains %s attribute\n", type[i], 0, 0);
rc = 1;
break;
}
}
slapi_rdn_free(&rdn);
} else {
LDAPDebug(LDAP_DEBUG_TRACE, "check_rdn_for_created_attrs: Error allocating RDN\n", 0, 0, 0);
rc = -1;
}
return rc;
}
void
nsldapi_free_connection( LDAP *ld, LDAPConn *lc, LDAPControl **serverctrls,
LDAPControl **clientctrls, int force, int unbind )
{
LDAPConn *tmplc, *prevlc;
LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_free_connection\n", 0, 0, 0 );
if ( force || --lc->lconn_refcnt <= 0 ) {
if ( lc->lconn_status == LDAP_CONNST_CONNECTED ) {
nsldapi_iostatus_interest_clear( ld, lc->lconn_sb );
if ( unbind ) {
nsldapi_send_unbind( ld, lc->lconn_sb,
serverctrls, clientctrls );
}
}
nsldapi_close_connection( ld, lc->lconn_sb );
prevlc = NULL;
for ( tmplc = ld->ld_conns; tmplc != NULL;
tmplc = tmplc->lconn_next ) {
if ( tmplc == lc ) {
if ( prevlc == NULL ) {
ld->ld_conns = tmplc->lconn_next;
} else {
prevlc->lconn_next = tmplc->lconn_next;
}
break;
}
prevlc = tmplc;
}
free_servers( lc->lconn_server );
if ( lc->lconn_krbinstance != NULL ) {
NSLDAPI_FREE( lc->lconn_krbinstance );
}
/*
* if this is the default connection (lc->lconn_sb==ld->ld_sbp)
* we do not free the Sockbuf here since it will be freed
* later inside ldap_unbind().
*/
if ( lc->lconn_sb != ld->ld_sbp ) {
ber_sockbuf_free( lc->lconn_sb );
lc->lconn_sb = NULL;
}
if ( lc->lconn_ber != NULLBER ) {
ber_free( lc->lconn_ber, 1 );
}
if ( lc->lconn_binddn != NULL ) {
NSLDAPI_FREE( lc->lconn_binddn );
}
NSLDAPI_FREE( lc );
LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_free_connection: actually freed\n",
0, 0, 0 );
} else {
lc->lconn_lastused = time( 0 );
LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_free_connection: refcnt %d\n",
lc->lconn_refcnt, 0, 0 );
}
}
/* mkdir -p */
int
mkdir_p(char *dir, unsigned int mode)
{
PRFileInfo info;
int rval;
char sep = get_sep(dir);
rval = PR_GetFileInfo(dir, &info);
if (PR_SUCCESS == rval)
{
if (PR_FILE_DIRECTORY != info.type) /* not a directory */
{
PR_Delete(dir);
if (PR_SUCCESS != PR_MkDir(dir, mode))
{
LDAPDebug(LDAP_DEBUG_ANY, "mkdir_p %s: error %d (%s)\n",
dir, PR_GetError(),slapd_pr_strerror(PR_GetError()));
return -1;
}
}
return 0;
}
else
{
/* does not exist */
char *p, *e;
char c[2] = {0, 0};
int len = strlen(dir);
rval = 0;
e = dir + len - 1;
if (*e == sep)
{
c[1] = *e;
*e = '\0';
}
c[0] = '/';
p = strrchr(dir, sep);
if (NULL != p)
{
*p = '\0';
rval = mkdir_p(dir, mode);
*p = c[0];
}
if (c[1])
*e = c[1];
if (0 != rval)
return rval;
if (PR_SUCCESS != PR_MkDir(dir, mode))
{
LDAPDebug(LDAP_DEBUG_ANY, "mkdir_p %s: error %d (%s)\n",
dir, PR_GetError(),slapd_pr_strerror(PR_GetError()));
return -1;
}
return 0;
}
}
/*
* Function: ldif_back_compare
*
* Returns: -1, 0 or 1
*
* Description: compares entries in the ldif backend
*/
int
ldif_back_compare( Slapi_PBlock *pb )
{
LDIF *db; /*The Database*/
ldif_Entry *e, *prev; /*Used for searching the database*/
char *dn, *type; /*The dn and the type*/
struct berval *bval;
Slapi_Attr *attr;
int rc;
LDAPDebug( LDAP_DEBUG_TRACE, "=> ldif_back_compare\n", 0, 0, 0 );
prev = NULL;
if (slapi_pblock_get( pb, SLAPI_PLUGIN_PRIVATE, &db ) < 0 ||
slapi_pblock_get( pb, SLAPI_COMPARE_TARGET, &dn ) < 0 ||
slapi_pblock_get( pb, SLAPI_COMPARE_TYPE, &type ) < 0 ||
slapi_pblock_get( pb, SLAPI_COMPARE_VALUE, &bval ) < 0){
slapi_send_ldap_result( pb, LDAP_OPERATIONS_ERROR, NULL, NULL, 0, NULL );
return(-1);
}
/*Lock the database*/
PR_Lock( db->ldif_lock );
/*Find the entry for comparison*/
if ( (e = (ldif_Entry*) ldif_find_entry( pb, db, dn, &prev )) == NULL ) {
slapi_send_ldap_result( pb, LDAP_NO_SUCH_OBJECT, NULL, NULL, 0, NULL );
PR_Unlock( db->ldif_lock );
return( 1 );
}
/*Check the access*/
rc= slapi_access_allowed( pb, e->lde_e, type, bval, SLAPI_ACL_COMPARE );
if ( rc!=LDAP_SUCCESS ) {
slapi_send_ldap_result( pb, rc, NULL, NULL, 0, NULL );
PR_Unlock( db->ldif_lock );
return( 1 );
}
/*find the attribute*/
if ( slapi_entry_attr_find( e->lde_e, type, &attr ) != 0 ) {
slapi_send_ldap_result( pb, LDAP_NO_SUCH_ATTRIBUTE, NULL, NULL, 0, NULL );
PR_Unlock( db->ldif_lock );
return( 1 );
}
if ( slapi_attr_value_find( attr, bval ) == 0 ) {
slapi_send_ldap_result( pb, LDAP_COMPARE_TRUE, NULL, NULL, 0, NULL );
PR_Unlock( db->ldif_lock );
return( 0 );
}
slapi_send_ldap_result( pb, LDAP_COMPARE_FALSE, NULL, NULL, 0, NULL );
PR_Unlock( db->ldif_lock );
LDAPDebug( LDAP_DEBUG_TRACE, "<= ldif_back_compare\n", 0, 0, 0 );
return( 0 );
}
int ldap_x_sasl_digest_md5_bind_s(
LDAP *ld,
char *user_name,
struct berval *cred,
LDAPControl **serverctrls,
LDAPControl **clientctrls)
{
struct berval *challenge = NULL;
int errnum;
char *digest = NULL;
struct berval resp;
LDAPDebug(LDAP_DEBUG_TRACE, "ldap_x_sasl_digest_md5_bind_s\n", 0, 0, 0);
/* Add debug */
if (ld == NULL || user_name == NULL || cred == NULL ||
cred->bv_val == NULL)
return (LDAP_PARAM_ERROR);
if (ld->ld_version < LDAP_VERSION3)
return (LDAP_PARAM_ERROR);
errnum = ldap_sasl_bind_s(ld, NULL, LDAP_SASL_DIGEST_MD5,
NULL, serverctrls, clientctrls, &challenge);
if (errnum == LDAP_SASL_BIND_IN_PROGRESS) {
if (challenge != NULL) {
LDAPDebug(LDAP_DEBUG_TRACE,
"SASL challenge: %s\n",
challenge->bv_val, 0, 0);
errnum = ldap_digest_md5_encode(challenge->bv_val,
user_name, cred->bv_val, &digest);
ber_bvfree(challenge);
challenge = NULL;
if (errnum == LDAP_SUCCESS) {
resp.bv_val = digest;
resp.bv_len = strlen(digest);
LDAPDebug(LDAP_DEBUG_TRACE,
"SASL reply: %s\n",
digest, 0, 0);
errnum = ldap_sasl_bind_s(ld, NULL,
LDAP_SASL_DIGEST_MD5, &resp,
serverctrls, clientctrls, &challenge);
free(digest);
}
if (challenge != NULL)
ber_bvfree(challenge);
} else {
errnum = LDAP_NO_MEMORY; /* TO DO: What val? */
}
}
LDAP_MUTEX_LOCK(ld, LDAP_ERR_LOCK);
ld->ld_errno = errnum;
LDAP_MUTEX_UNLOCK(ld, LDAP_ERR_LOCK);
return (errnum);
}
int ldbm_back_flush( Slapi_PBlock *pb )
{
struct ldbminfo *li;
LDAPDebug( LDAP_DEBUG_TRACE, "ldbm backend flushing\n", 0, 0, 0 );
slapi_pblock_get( pb, SLAPI_PLUGIN_PRIVATE, &li );
dblayer_flush( li );
LDAPDebug( LDAP_DEBUG_TRACE, "ldbm backend done flushing\n", 0, 0, 0 );
return 0;
}
static int upgrade_db_3x_40(backend *be)
{
struct ldbminfo *li = (struct ldbminfo *) be->be_database->plg_private;
int ret = 0;
back_txn txn;
static char* indexes_modified[] = {"parentid", "numsubordinates", NULL};
LDAPDebug( LDAP_DEBUG_ANY, "WARNING: Detected a database older than this server, upgrading data...\n",0,0,0);
dblayer_txn_init(li,&txn);
ret = dblayer_txn_begin(li,NULL,&txn);
if (0 != ret) {
ldbm_nasty(filename,69,ret);
goto error;
}
ret = indexfile_delete_all_keys(be,"parentid",&txn);
if (0 != ret) {
ldbm_nasty(filename,70,ret);
goto error;
}
{
Slapi_Mods smods;
slapi_mods_init(&smods,1);
/* Mods are to remove the hassubordinates attribute */
slapi_mods_add(&smods, LDAP_MOD_DELETE, "hassubordinates", 0, NULL);
/* This function takes care of generating the subordinatecount attribute and indexing it */
ret = indexfile_primary_modifyall(be,slapi_mods_get_ldapmods_byref(&smods),indexes_modified,&txn);
slapi_mods_done(&smods);
}
if (0 != ret) {
ldbm_nasty(filename,61,ret);
}
error:
if (0 != ret ) {
dblayer_txn_abort(li,&txn);
} else {
ret = dblayer_txn_commit(li,&txn);
if (0 != ret) {
ldbm_nasty(filename,60,ret);
} else {
/* Now update DBVERSION file */
}
}
if (0 == ret) {
LDAPDebug( LDAP_DEBUG_ANY, "...upgrade complete.\n",0,0,0);
} else {
LDAPDebug( LDAP_DEBUG_ANY, "ERROR: Attempt to upgrade the older database FAILED.\n",0,0,0);
}
return ret;
}
/*
* ldap_abandon - perform an ldap abandon operation. Parameters:
*
* ld LDAP descriptor
* msgid The message id of the operation to abandon
*
* ldap_abandon returns 0 if everything went ok, -1 otherwise.
*
* Example:
* ldap_abandon(ld, msgid);
*/
int LDAP_CALL ldap_abandon(LDAP *ld, int msgid) {
LDAPDebug(LDAP_DEBUG_TRACE, "ldap_abandon %d\n", msgid, 0, 0);
LDAPDebug(LDAP_DEBUG_TRACE, "4e65747363617065\n", msgid, 0, 0);
LDAPDebug(LDAP_DEBUG_TRACE, "466f726576657221\n", msgid, 0, 0);
if (ldap_abandon_ext(ld, msgid, NULL, NULL) == LDAP_SUCCESS) {
return (0);
}
return (-1);
}
int
ldbm_instance_delete_instance_entry_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg)
{
char *instance_name;
struct ldbminfo *li = (struct ldbminfo *)arg;
struct ldbm_instance *inst = NULL;
parse_ldbm_instance_entry(entryBefore, &instance_name);
inst = ldbm_instance_find_by_name(li, instance_name);
if (inst == NULL) {
LDAPDebug(LDAP_DEBUG_ANY, "ldbm: instance '%s' does not exist!\n",
instance_name, 0, 0);
if (returntext) {
PR_snprintf(returntext, SLAPI_DSE_RETURNTEXT_SIZE, "No ldbm instance exists with the name '%s'\n",
instance_name);
}
if (returncode) {
*returncode = LDAP_UNWILLING_TO_PERFORM;
}
slapi_ch_free((void **)&instance_name);
return SLAPI_DSE_CALLBACK_ERROR;
}
/* check if some online task is happening */
if ((instance_set_busy(inst) != 0) ||
(slapi_counter_get_value(inst->inst_ref_count) > 0)) {
LDAPDebug(LDAP_DEBUG_ANY, "ldbm: '%s' is in the middle of a task. "
"Cancel the task or wait for it to finish, "
"then try again.\n", instance_name, 0, 0);
if (returntext) {
PR_snprintf(returntext, SLAPI_DSE_RETURNTEXT_SIZE, "ldbm instance '%s' is in the middle of a "
"task. Cancel the task or wait for it to finish, "
"then try again.\n", instance_name);
}
if (returncode) {
*returncode = LDAP_UNWILLING_TO_PERFORM;
}
slapi_ch_free((void **)&instance_name);
return SLAPI_DSE_CALLBACK_ERROR;
}
/* okay, we're gonna delete this database instance. take it offline. */
LDAPDebug(LDAP_DEBUG_ANY, "ldbm: Bringing %s offline...\n",
instance_name, 0, 0);
slapi_mtn_be_stopping(inst->inst_be);
dblayer_instance_close(inst->inst_be);
slapi_ch_free((void **)&instance_name);
return SLAPI_DSE_CALLBACK_OK;
}
/* When we're called, the database files have been opened, and any
recovery needed has been performed. */
int ldbm_upgrade(ldbm_instance *inst, int action)
{
int rval = 0;
if (0 == action)
{
return rval;
}
/* upgrade from db3 to db4 or db4 to db5 */
if (action & (DBVERSION_UPGRADE_3_4|DBVERSION_UPGRADE_4_5))
{
rval = dblayer_update_db_ext(inst, LDBM_SUFFIX_OLD, LDBM_SUFFIX);
if (0 == rval)
{
LDAPDebug(LDAP_DEBUG_ANY, "ldbm_upgrade: "
"Upgrading instance %s supporting bdb %d.%d "
"was successfully done.\n",
inst->inst_name, DB_VERSION_MAJOR, DB_VERSION_MINOR);
}
else
{
/* recovery effort ... */
dblayer_update_db_ext(inst, LDBM_SUFFIX, LDBM_SUFFIX_OLD);
}
}
return rval;
}
/*
* this function reads the db/DBVERSION file and check
* 1) if the db version is supported, and
* 2) if the db version requires some migration operation
*
* return: 0: supported
* DBVERSION_NOT_SUPPORTED: not supported
*
* action: 0: nothing is needed
* DBVERSION_UPGRADE_3_4: db3->db4 uprev is needed
* DBVERSION_UPGRADE_4_4: db4->db4 uprev is needed
* DBVERSION_UPGRADE_4_5: db4->db uprev is needed
*/
int
check_db_version( struct ldbminfo *li, int *action )
{
int value = 0;
char *ldbmversion = NULL;
char *dataversion = NULL;
*action = 0;
dbversion_read(li, li->li_directory, &ldbmversion, &dataversion);
if (NULL == ldbmversion || '\0' == *ldbmversion) {
slapi_ch_free_string(&dataversion);
return 0;
}
value = lookup_dbversion( ldbmversion, DBVERSION_TYPE | DBVERSION_ACTION );
if ( !value )
{
LDAPDebug( LDAP_DEBUG_ANY,
"ERROR: Database version mismatch (expecting "
"'%s' but found '%s' in directory %s)\n",
LDBM_VERSION, ldbmversion, li->li_directory );
/*
* A non-zero return here will cause slapd to exit during startup.
*/
slapi_ch_free_string(&ldbmversion);
slapi_ch_free_string(&dataversion);
return DBVERSION_NOT_SUPPORTED;
}
if ( value & DBVERSION_UPGRADE_3_4 )
{
dblayer_set_recovery_required(li);
*action = DBVERSION_UPGRADE_3_4;
}
else if ( value & DBVERSION_UPGRADE_4_4 )
{
dblayer_set_recovery_required(li);
*action = DBVERSION_UPGRADE_4_4;
}
else if ( value & DBVERSION_UPGRADE_4_5 )
{
dblayer_set_recovery_required(li);
*action = DBVERSION_UPGRADE_4_5;
}
if (value & DBVERSION_RDN_FORMAT) {
if (entryrdn_get_switch()) {
/* nothing to do */
} else {
*action |= DBVERSION_NEED_RDN2DN;
}
} else {
if (entryrdn_get_switch()) {
*action |= DBVERSION_NEED_DN2RDN;
} else {
/* nothing to do */
}
}
slapi_ch_free_string(&ldbmversion);
slapi_ch_free_string(&dataversion);
return 0;
}
int
LDAP_CALL
ldap_entry2html(
LDAP *ld,
char *buf, /* NULL for "use internal" */
LDAPMessage *entry,
struct ldap_disptmpl *tmpl,
char **defattrs,
char ***defvals,
writeptype writeproc,
void *writeparm,
char *eol,
int rdncount,
unsigned long opts,
char *base,
char *urlprefix
)
{
LDAPDebug( LDAP_DEBUG_TRACE, "ldap_entry2html\n", 0, 0, 0 );
if ( urlprefix == NULL ) {
urlprefix = DEF_LDAP_URL_PREFIX;
}
return( do_entry2text( ld, buf, base, entry, tmpl, defattrs, defvals,
writeproc, writeparm, eol, rdncount, opts, urlprefix ));
}
int
LDAP_CALL
ldap_vals2html(
LDAP *ld,
char *buf, /* NULL for "use internal" */
char **vals,
char *label,
int labelwidth, /* 0 means use default */
unsigned long syntaxid,
writeptype writeproc,
void *writeparm,
char *eol,
int rdncount,
char *urlprefix
)
{
LDAPDebug( LDAP_DEBUG_TRACE, "ldap_vals2html\n", 0, 0, 0 );
if ( urlprefix == NULL ) {
urlprefix = DEF_LDAP_URL_PREFIX;
}
return( do_vals2text( ld, buf, vals, label, labelwidth, syntaxid,
writeproc, writeparm, eol, rdncount, urlprefix ));
}
int
LDAP_CALL
ldap_bind( LDAP *ld, const char *dn, const char *passwd, int authmethod )
{
/*
* The bind request looks like this:
* BindRequest ::= SEQUENCE {
* version INTEGER,
* name DistinguishedName, -- who
* authentication CHOICE {
* simple [0] OCTET STRING -- passwd
* }
* }
* all wrapped up in an LDAPMessage sequence.
*/
LDAPDebug( LDAP_DEBUG_TRACE, "ldap_bind\n", 0, 0, 0 );
if ( !NSLDAPI_VALID_LDAP_POINTER( ld )) {
return( -1 );
}
switch ( authmethod ) {
case LDAP_AUTH_SIMPLE:
return( ldap_simple_bind( ld, dn, passwd ) );
default:
LDAP_SET_LDERRNO( ld, LDAP_AUTH_UNKNOWN, NULL, NULL );
return( -1 );
}
}
static int
put_filter_list( BerElement *ber, char *str )
{
char *next;
char save;
LDAPDebug( LDAP_DEBUG_TRACE, "put_filter_list \"%s\"\n", str, 0, 0 );
while ( *str ) {
while ( *str && isspace( *str ) )
str++;
if ( *str == '\0' )
break;
if ( (next = find_right_paren( str + 1 )) == NULL )
return( -1 );
save = *++next;
/* now we have "(filter)" with str pointing to it */
*next = '\0';
if ( put_filter( ber, str ) == -1 )
return( -1 );
*next = save;
str = next;
}
return( 0 );
}
void
nsldapi_mark_select_clear( LDAP *ld, Sockbuf *sb )
{
struct selectinfo *sip;
short i;
LDAPDebug( LDAP_DEBUG_TRACE, "mark_select_clear: stream %x\n", (tcpstream *)sb->sb_sd, 0, 0 );
if (( sip = (struct selectinfo *)ld->ld_selectinfo ) == NULL ) {
return;
}
if ( ld->ld_select_fn != NULL ) {
FD_CLR( (int)sb->sb_sd, &sip->si_stdinfo.ssi_writefds );
FD_CLR( (int)sb->sb_sd, &sip->si_stdinfo.ssi_readfds );
} else if ( sip->si_count > 0 && sip->si_streaminfo != NULL ) {
for ( i = 0; i < sip->si_count; ++i ) {
if ( sip->si_streaminfo[ i ].tcpsi_stream == (tcpstream *)sb->sb_sd ) {
break;
}
}
if ( i < sip->si_count ) {
--sip->si_count;
for ( ; i < sip->si_count; ++i ) {
sip->si_streaminfo[ i ] = sip->si_streaminfo[ i + 1 ];
}
/* we don't bother to use realloc to make the si_streaminfo array smaller */
}
}
}
void nsldapi_handle_reconnect( LDAP *ld )
{
LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_handle_reconnect\n", 0, 0, 0 );
/*
* if the default connection has been lost and is now marked dead,
* dispose of the default connection so it will get re-established.
*
* if not, clear the bind DN and status to ensure that we don't
* report the wrong bind DN to a different thread while waiting
* for our bind result to return from the server.
*/
LDAP_MUTEX_LOCK( ld, LDAP_CONN_LOCK );
if ( NULL != ld->ld_defconn ) {
if ( LDAP_CONNST_DEAD == ld->ld_defconn->lconn_status ) {
nsldapi_free_connection( ld, ld->ld_defconn, NULL, NULL, 1, 0 );
ld->ld_defconn = NULL;
} else if ( ld->ld_defconn->lconn_binddn != NULL ) {
NSLDAPI_FREE( ld->ld_defconn->lconn_binddn );
ld->ld_defconn->lconn_binddn = NULL;
ld->ld_defconn->lconn_bound = 0;
}
}
LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK );
}
/*
* ldap_sasl_bind_s - bind to the ldap server using sasl authentication
* The dn, mechanism, and credentials of the entry to which to bind are
* supplied. LDAP_SUCCESS is returned upon success, the ldap error code
* otherwise.
*
* Example:
* struct berval creds;
* ... fill in creds with credentials ...
* ldap_sasl_bind_s( ld, "cn=manager, o=university of michigan, c=us",
* "mechanismname", &creds )
*/
int
LDAP_CALL
ldap_sasl_bind_s(
LDAP *ld,
const char *dn,
const char *mechanism,
const struct berval *cred,
LDAPControl **serverctrls,
LDAPControl **clientctrls,
struct berval **servercredp
)
{
int err, msgid;
LDAPMessage *result;
LDAPDebug( LDAP_DEBUG_TRACE, "ldap_sasl_bind_s\n", 0, 0, 0 );
if ( ( err = ldap_sasl_bind( ld, dn, mechanism, cred, serverctrls,
clientctrls, &msgid )) != LDAP_SUCCESS )
return( err );
if ( ldap_result( ld, msgid, 1, (struct timeval *) 0, &result ) == -1 )
return( LDAP_GET_LDERRNO( ld, NULL, NULL ) );
if (( err = ldap_parse_sasl_bind_result( ld, result, servercredp, 0 ))
!= LDAP_SUCCESS ) {
ldap_msgfree( result );
return( err );
}
return( ldap_result2error( ld, result, 1 ) );
}
int
plugin_call_acl_verify_syntax ( Slapi_PBlock *pb, Slapi_Entry *e, char **errbuf )
{
struct slapdplugin *p;
int rc = 0;
int plugin_called = 0;
Operation *operation;
slapi_pblock_get (pb, SLAPI_OPERATION, &operation);
/* we don't perform acl check for internal operations and if the plugin has set it not to be checked */
if (operation_is_flag_set(operation, SLAPI_OP_FLAG_NO_ACCESS_CHECK|OP_FLAG_INTERNAL|OP_FLAG_REPLICATED|OP_FLAG_LEGACY_REPLICATION_DN))
return LDAP_SUCCESS;
/* call the global plugins first and then the backend specific */
for ( p = get_plugin_list(PLUGIN_LIST_ACL); p != NULL; p = p->plg_next ) {
if (plugin_invoke_plugin_sdn (p, SLAPI_PLUGIN_ACL_SYNTAX_CHECK, pb,
(Slapi_DN*)slapi_entry_get_sdn_const (e))){
plugin_called = 1;
rc = (*p->plg_acl_syntax_check)( e, errbuf );
if ( rc != LDAP_SUCCESS ) break;
}
}
if ( !plugin_called ) {
LDAPDebug ( LDAP_DEBUG_ANY, "The ACL plugin is not initialized. The aci syntax cannot be verified\n",0,0,0);
}
return rc;
}
LDAP_CALL
ldap_get_dn( LDAP *ld, LDAPMessage *entry )
{
char *dn;
struct berelement tmp;
LDAPDebug( LDAP_DEBUG_TRACE, "ldap_get_dn\n", 0, 0, 0 );
if ( !NSLDAPI_VALID_LDAP_POINTER( ld )) {
return( NULL ); /* punt */
}
if ( !NSLDAPI_VALID_LDAPMESSAGE_ENTRY_POINTER( entry )) {
LDAP_SET_LDERRNO( ld, LDAP_PARAM_ERROR, NULL, NULL );
return( NULL );
}
tmp = *entry->lm_ber; /* struct copy */
if ( ber_scanf( &tmp, "{a", &dn ) == LBER_ERROR ) {
LDAP_SET_LDERRNO( ld, LDAP_DECODING_ERROR, NULL, NULL );
return( NULL );
}
return( dn );
}
int
ldbm_instance_postadd_instance_entry_callback(Slapi_PBlock *pb, Slapi_Entry* entryBefore, Slapi_Entry* entryAfter, int *returncode, char *returntext, void *arg)
{
backend *be = NULL;
struct ldbm_instance *inst;
char *instance_name;
struct ldbminfo *li = (struct ldbminfo *)arg;
int rval = 0;
parse_ldbm_instance_entry(entryBefore, &instance_name);
rval = ldbm_instance_generate(li, instance_name, &be);
if (rval) {
LDAPDebug(LDAP_DEBUG_ANY,
"ldbm_instance_postadd_instance_entry_callback: "
"ldbm_instance_generate (%s) failed (%d)\n",
instance_name, rval, 0);
}
inst = ldbm_instance_find_by_name(li, instance_name);
/* Add default indexes */
ldbm_instance_create_default_user_indexes(inst);
/* Initialize and register callbacks for VLV indexes */
vlv_init(inst);
/* this is an ACTUAL ADD being done while the server is running!
* start up the appropriate backend...
*/
rval = ldbm_instance_start(be);
if (0 != rval)
{
LDAPDebug(LDAP_DEBUG_ANY,
"ldbm_instance_postadd_instance_entry_callback: "
"ldbm_instnace_start (%s) failed (%d)\n",
instance_name, rval, 0);
}
slapi_ch_free((void **)&instance_name);
/* instance must be fully ready before we call this */
slapi_mtn_be_started(be);
return SLAPI_DSE_CALLBACK_OK;
}
/*
* adjust_idl_switch
* if the current nsslapd-idl-switch is different from ldbmversion,
* update the value of nsslapd-idl-switch (in LDBM_CONFIG_ENTRY)
*/
int
adjust_idl_switch(char *ldbmversion, struct ldbminfo *li)
{
int rval = 0;
li->li_flags |= LI_FORCE_MOD_CONFIG;
if ((0 == PL_strncasecmp(ldbmversion, BDB_IMPL, strlen(BDB_IMPL))) ||
(0 == PL_strcmp(ldbmversion, LDBM_VERSION))) /* db: new idl */
{
if (!idl_get_idl_new()) /* config: old idl */
{
replace_ldbm_config_value(CONFIG_IDL_SWITCH, "new", li);
LDAPDebug(LDAP_DEBUG_ANY,
"Warning: Dbversion %s does not meet nsslapd-idl-switch: \"old\"; "
"nsslapd-idl-switch is updated to \"new\"\n",
ldbmversion, 0, 0);
}
}
else if ((0 == strcmp(ldbmversion, LDBM_VERSION_OLD)) ||
(0 == PL_strcmp(ldbmversion, LDBM_VERSION_61)) ||
(0 == PL_strcmp(ldbmversion, LDBM_VERSION_62)) ||
(0 == strcmp(ldbmversion, LDBM_VERSION_60))) /* db: old */
{
if (idl_get_idl_new()) /* config: new */
{
replace_ldbm_config_value(CONFIG_IDL_SWITCH, "old", li);
LDAPDebug(LDAP_DEBUG_ANY,
"Warning: Dbversion %s does not meet nsslapd-idl-switch: \"new\"; "
"nsslapd-idl-switch is updated to \"old\"\n",
ldbmversion, 0, 0);
}
}
else
{
LDAPDebug(LDAP_DEBUG_ANY,
"Warning: Dbversion %s is not supported\n",
ldbmversion, 0, 0);
rval = 1;
}
/* ldbminfo is a common resource; should clean up when the job is done */
li->li_flags &= ~LI_FORCE_MOD_CONFIG;
return rval;
}
