int bdb_modrdn( Operation *op, SlapReply *rs ) { struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private; AttributeDescription *children = slap_schema.si_ad_children; AttributeDescription *entry = slap_schema.si_ad_entry; struct berval p_dn, p_ndn; struct berval new_dn = {0, NULL}, new_ndn = {0, NULL}; Entry *e = NULL; Entry *p = NULL; EntryInfo *ei = NULL, *eip = NULL, *nei = NULL, *neip = NULL; /* LDAP v2 supporting correct attribute handling. */ char textbuf[SLAP_TEXT_BUFLEN]; size_t textlen = sizeof textbuf; DB_TXN *ltid = NULL, *lt2; struct bdb_op_info opinfo = {{{ 0 }}}; Entry dummy = {0}; Entry *np = NULL; /* newSuperior Entry */ struct berval *np_dn = NULL; /* newSuperior dn */ struct berval *np_ndn = NULL; /* newSuperior ndn */ struct berval *new_parent_dn = NULL; /* np_dn, p_dn, or NULL */ int manageDSAit = get_manageDSAit( op ); DB_LOCK lock, plock, nplock; int num_retries = 0; LDAPControl **preread_ctrl = NULL; LDAPControl **postread_ctrl = NULL; LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS]; int num_ctrls = 0; int rc; int parent_is_glue = 0; int parent_is_leaf = 0; #ifdef LDAP_X_TXN int settle = 0; #endif Debug( LDAP_DEBUG_TRACE, "==>" LDAP_XSTRING(bdb_modrdn) "(%s,%s,%s)\n", op->o_req_dn.bv_val,op->oq_modrdn.rs_newrdn.bv_val, op->oq_modrdn.rs_newSup ? op->oq_modrdn.rs_newSup->bv_val : "NULL" ); #ifdef LDAP_X_TXN if( op->o_txnSpec ) { /* acquire connection lock */ ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex ); if( op->o_conn->c_txn == CONN_TXN_INACTIVE ) { rs->sr_text = "invalid transaction identifier"; rs->sr_err = LDAP_X_TXN_ID_INVALID; goto txnReturn; } else if( op->o_conn->c_txn == CONN_TXN_SETTLE ) { settle=1; goto txnReturn; } if( op->o_conn->c_txn_backend == NULL ) { op->o_conn->c_txn_backend = op->o_bd; } else if( op->o_conn->c_txn_backend != op->o_bd ) { rs->sr_text = "transaction cannot span multiple database contexts"; rs->sr_err = LDAP_AFFECTS_MULTIPLE_DSAS; goto txnReturn; } /* insert operation into transaction */ rs->sr_text = "transaction specified"; rs->sr_err = LDAP_X_TXN_SPECIFY_OKAY; txnReturn: /* release connection lock */ ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); if( !settle ) { send_ldap_result( op, rs ); return rs->sr_err; } } #endif ctrls[num_ctrls] = NULL; slap_mods_opattrs( op, &op->orr_modlist, 1 ); if( 0 ) { retry: /* transaction retry */ if ( dummy.e_attrs ) { attrs_free( dummy.e_attrs ); dummy.e_attrs = NULL; } if (e != NULL) { bdb_unlocked_cache_return_entry_w(&bdb->bi_cache, e); e = NULL; } if (p != NULL) { bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, p); p = NULL; } if (np != NULL) { bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, np); np = NULL; } Debug( LDAP_DEBUG_TRACE, "==>" LDAP_XSTRING(bdb_modrdn) ": retrying...\n", 0, 0, 0 ); rs->sr_err = TXN_ABORT( ltid ); ltid = NULL; LDAP_SLIST_REMOVE( &op->o_extra, &opinfo.boi_oe, OpExtra, oe_next ); opinfo.boi_oe.oe_key = NULL; op->o_do_not_cache = opinfo.boi_acl_cache; if( rs->sr_err != 0 ) { rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } if ( op->o_abandon ) { rs->sr_err = SLAPD_ABANDON; goto return_results; } parent_is_glue = 0; parent_is_leaf = 0; bdb_trans_backoff( ++num_retries ); } /* begin transaction */ rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, NULL, <id, bdb->bi_db_opflags ); rs->sr_text = NULL; if( rs->sr_err != 0 ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": txn_begin failed: " "%s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 ); rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": txn1 id: %x\n", ltid->id(ltid), 0, 0 ); opinfo.boi_oe.oe_key = bdb; opinfo.boi_txn = ltid; opinfo.boi_err = 0; opinfo.boi_acl_cache = op->o_do_not_cache; LDAP_SLIST_INSERT_HEAD( &op->o_extra, &opinfo.boi_oe, oe_next ); /* get entry */ rs->sr_err = bdb_dn2entry( op, ltid, &op->o_req_ndn, &ei, 1, &lock ); switch( rs->sr_err ) { case 0: case DB_NOTFOUND: break; case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; case LDAP_BUSY: rs->sr_text = "ldap server busy"; goto return_results; default: rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } e = ei->bei_e; /* FIXME: dn2entry() should return non-glue entry */ if (( rs->sr_err == DB_NOTFOUND ) || ( !manageDSAit && e && is_entry_glue( e ))) { if( e != NULL ) { rs->sr_matched = ch_strdup( e->e_dn ); rs->sr_ref = is_entry_referral( e ) ? get_entry_referrals( op, e ) : NULL; bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, e); e = NULL; } else { rs->sr_ref = referral_rewrite( default_referral, NULL, &op->o_req_dn, LDAP_SCOPE_DEFAULT ); } rs->sr_err = LDAP_REFERRAL; send_ldap_result( op, rs ); ber_bvarray_free( rs->sr_ref ); free( (char *)rs->sr_matched ); rs->sr_ref = NULL; rs->sr_matched = NULL; goto done; } if ( get_assert( op ) && ( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE )) { rs->sr_err = LDAP_ASSERTION_FAILED; goto return_results; } /* check write on old entry */ rs->sr_err = access_allowed( op, e, entry, NULL, ACL_WRITE, NULL ); if ( ! rs->sr_err ) { switch( opinfo.boi_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } Debug( LDAP_DEBUG_TRACE, "no access to entry\n", 0, 0, 0 ); rs->sr_text = "no write access to old entry"; rs->sr_err = LDAP_INSUFFICIENT_ACCESS; goto return_results; } #ifndef BDB_HIER rs->sr_err = bdb_cache_children( op, ltid, e ); if ( rs->sr_err != DB_NOTFOUND ) { switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; case 0: Debug(LDAP_DEBUG_ARGS, "<=- " LDAP_XSTRING(bdb_modrdn) ": non-leaf %s\n", op->o_req_dn.bv_val, 0, 0); rs->sr_err = LDAP_NOT_ALLOWED_ON_NONLEAF; rs->sr_text = "subtree rename not supported"; break; default: Debug(LDAP_DEBUG_ARGS, "<=- " LDAP_XSTRING(bdb_modrdn) ": has_children failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 ); rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; } goto return_results; } ei->bei_state |= CACHE_ENTRY_NO_KIDS; #endif if (!manageDSAit && is_entry_referral( e ) ) { /* parent is a referral, don't allow add */ rs->sr_ref = get_entry_referrals( op, e ); Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": entry %s is referral\n", e->e_dn, 0, 0 ); rs->sr_err = LDAP_REFERRAL, rs->sr_matched = e->e_name.bv_val; send_ldap_result( op, rs ); ber_bvarray_free( rs->sr_ref ); rs->sr_ref = NULL; rs->sr_matched = NULL; goto done; } if ( be_issuffix( op->o_bd, &e->e_nname ) ) { #ifdef BDB_MULTIPLE_SUFFIXES /* Allow renaming one suffix entry to another */ p_ndn = slap_empty_bv; #else /* There can only be one suffix entry */ rs->sr_err = LDAP_NAMING_VIOLATION; rs->sr_text = "cannot rename suffix entry"; goto return_results; #endif } else { dnParent( &e->e_nname, &p_ndn ); } np_ndn = &p_ndn; eip = ei->bei_parent; if ( eip && eip->bei_id ) { /* Make sure parent entry exist and we can write its * children. */ rs->sr_err = bdb_cache_find_id( op, ltid, eip->bei_id, &eip, 0, &plock ); switch( rs->sr_err ) { case 0: case DB_NOTFOUND: break; case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; case LDAP_BUSY: rs->sr_text = "ldap server busy"; goto return_results; default: rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } p = eip->bei_e; if( p == NULL) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": parent does not exist\n", 0, 0, 0); rs->sr_err = LDAP_OTHER; rs->sr_text = "old entry's parent does not exist"; goto return_results; } } else { p = (Entry *)&slap_entry_root; } /* check parent for "children" acl */ rs->sr_err = access_allowed( op, p, children, NULL, op->oq_modrdn.rs_newSup == NULL ? ACL_WRITE : ACL_WDEL, NULL ); if ( !p_ndn.bv_len ) p = NULL; if ( ! rs->sr_err ) { switch( opinfo.boi_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } rs->sr_err = LDAP_INSUFFICIENT_ACCESS; Debug( LDAP_DEBUG_TRACE, "no access to parent\n", 0, 0, 0 ); rs->sr_text = "no write access to old parent's children"; goto return_results; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": wr to children " "of entry %s OK\n", p_ndn.bv_val, 0, 0 ); if ( p_ndn.bv_val == slap_empty_bv.bv_val ) { p_dn = slap_empty_bv; } else { dnParent( &e->e_name, &p_dn ); } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": parent dn=%s\n", p_dn.bv_val, 0, 0 ); new_parent_dn = &p_dn; /* New Parent unless newSuperior given */ if ( op->oq_modrdn.rs_newSup != NULL ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": new parent \"%s\" requested...\n", op->oq_modrdn.rs_newSup->bv_val, 0, 0 ); /* newSuperior == oldParent? */ if( dn_match( &p_ndn, op->oq_modrdn.rs_nnewSup ) ) { Debug( LDAP_DEBUG_TRACE, "bdb_back_modrdn: " "new parent \"%s\" same as the old parent \"%s\"\n", op->oq_modrdn.rs_newSup->bv_val, p_dn.bv_val, 0 ); op->oq_modrdn.rs_newSup = NULL; /* ignore newSuperior */ } } /* There's a BDB_MULTIPLE_SUFFIXES case here that this code doesn't * support. E.g., two suffixes dc=foo,dc=com and dc=bar,dc=net. * We do not allow modDN * dc=foo,dc=com * newrdn dc=bar * newsup dc=net * and we probably should. But since MULTIPLE_SUFFIXES is deprecated * I'm ignoring this problem for now. */ if ( op->oq_modrdn.rs_newSup != NULL ) { if ( op->oq_modrdn.rs_newSup->bv_len ) { np_dn = op->oq_modrdn.rs_newSup; np_ndn = op->oq_modrdn.rs_nnewSup; /* newSuperior == oldParent? - checked above */ /* newSuperior == entry being moved?, if so ==> ERROR */ if ( dnIsSuffix( np_ndn, &e->e_nname )) { rs->sr_err = LDAP_NO_SUCH_OBJECT; rs->sr_text = "new superior not found"; goto return_results; } /* Get Entry with dn=newSuperior. Does newSuperior exist? */ rs->sr_err = bdb_dn2entry( op, ltid, np_ndn, &neip, 0, &nplock ); switch( rs->sr_err ) { case 0: np = neip->bei_e; case DB_NOTFOUND: break; case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; case LDAP_BUSY: rs->sr_text = "ldap server busy"; goto return_results; default: rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } if( np == NULL) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": newSup(ndn=%s) not here!\n", np_ndn->bv_val, 0, 0); rs->sr_text = "new superior not found"; rs->sr_err = LDAP_NO_SUCH_OBJECT; goto return_results; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": wr to new parent OK np=%p, id=%ld\n", (void *) np, (long) np->e_id, 0 ); /* check newSuperior for "children" acl */ rs->sr_err = access_allowed( op, np, children, NULL, ACL_WADD, NULL ); if( ! rs->sr_err ) { switch( opinfo.boi_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": no wr to newSup children\n", 0, 0, 0 ); rs->sr_text = "no write access to new superior's children"; rs->sr_err = LDAP_INSUFFICIENT_ACCESS; goto return_results; } if ( is_entry_alias( np ) ) { /* parent is an alias, don't allow add */ Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": entry is alias\n", 0, 0, 0 ); rs->sr_text = "new superior is an alias"; rs->sr_err = LDAP_ALIAS_PROBLEM; goto return_results; } if ( is_entry_referral( np ) ) { /* parent is a referral, don't allow add */ Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": entry is referral\n", 0, 0, 0 ); rs->sr_text = "new superior is a referral"; rs->sr_err = LDAP_OTHER; goto return_results; } } else { np_dn = NULL; /* no parent, modrdn entry directly under root */ if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv ) || be_isupdate( op ) ) { np = (Entry *)&slap_entry_root; /* check parent for "children" acl */ rs->sr_err = access_allowed( op, np, children, NULL, ACL_WADD, NULL ); np = NULL; if ( ! rs->sr_err ) { switch( opinfo.boi_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } rs->sr_err = LDAP_INSUFFICIENT_ACCESS; Debug( LDAP_DEBUG_TRACE, "no access to new superior\n", 0, 0, 0 ); rs->sr_text = "no write access to new superior's children"; goto return_results; } } } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": wr to new parent's children OK\n", 0, 0, 0 ); new_parent_dn = np_dn; } /* Build target dn and make sure target entry doesn't exist already. */ if (!new_dn.bv_val) { build_new_dn( &new_dn, new_parent_dn, &op->oq_modrdn.rs_newrdn, NULL ); } if (!new_ndn.bv_val) { struct berval bv = {0, NULL}; dnNormalize( 0, NULL, NULL, &new_dn, &bv, op->o_tmpmemctx ); ber_dupbv( &new_ndn, &bv ); /* FIXME: why not call dnNormalize() w/o ctx? */ op->o_tmpfree( bv.bv_val, op->o_tmpmemctx ); } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": new ndn=%s\n", new_ndn.bv_val, 0, 0 ); /* Shortcut the search */ nei = neip ? neip : eip; rs->sr_err = bdb_cache_find_ndn ( op, ltid, &new_ndn, &nei ); if ( nei ) bdb_cache_entryinfo_unlock( nei ); switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; case DB_NOTFOUND: break; case 0: /* Allow rename to same DN */ if ( nei == ei ) break; rs->sr_err = LDAP_ALREADY_EXISTS; goto return_results; default: rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } assert( op->orr_modlist != NULL ); if( op->o_preread ) { if( preread_ctrl == NULL ) { preread_ctrl = &ctrls[num_ctrls++]; ctrls[num_ctrls] = NULL; } if( slap_read_controls( op, rs, e, &slap_pre_read_bv, preread_ctrl ) ) { Debug( LDAP_DEBUG_TRACE, "<=- " LDAP_XSTRING(bdb_modrdn) ": pre-read failed!\n", 0, 0, 0 ); if ( op->o_preread & SLAP_CONTROL_CRITICAL ) { /* FIXME: is it correct to abort * operation if control fails? */ goto return_results; } } } /* nested transaction */ rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, ltid, <2, bdb->bi_db_opflags ); rs->sr_text = NULL; if( rs->sr_err != 0 ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": txn_begin(2) failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 ); rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": txn2 id: %x\n", lt2->id(lt2), 0, 0 ); /* delete old DN */ rs->sr_err = bdb_dn2id_delete( op, lt2, eip, e ); if ( rs->sr_err != 0 ) { Debug(LDAP_DEBUG_TRACE, "<=- " LDAP_XSTRING(bdb_modrdn) ": dn2id del failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 ); switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } rs->sr_err = LDAP_OTHER; rs->sr_text = "DN index delete fail"; goto return_results; } /* copy the entry, then override some fields */ dummy = *e; dummy.e_name = new_dn; dummy.e_nname = new_ndn; dummy.e_attrs = NULL; /* add new DN */ rs->sr_err = bdb_dn2id_add( op, lt2, neip ? neip : eip, &dummy ); if ( rs->sr_err != 0 ) { Debug(LDAP_DEBUG_TRACE, "<=- " LDAP_XSTRING(bdb_modrdn) ": dn2id add failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 ); switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } rs->sr_err = LDAP_OTHER; rs->sr_text = "DN index add failed"; goto return_results; } dummy.e_attrs = e->e_attrs; /* modify entry */ rs->sr_err = bdb_modify_internal( op, lt2, op->orr_modlist, &dummy, &rs->sr_text, textbuf, textlen ); if( rs->sr_err != LDAP_SUCCESS ) { Debug(LDAP_DEBUG_TRACE, "<=- " LDAP_XSTRING(bdb_modrdn) ": modify failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 ); if ( ( rs->sr_err == LDAP_INSUFFICIENT_ACCESS ) && opinfo.boi_err ) { rs->sr_err = opinfo.boi_err; } if ( dummy.e_attrs == e->e_attrs ) dummy.e_attrs = NULL; switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } goto return_results; } /* id2entry index */ rs->sr_err = bdb_id2entry_update( op->o_bd, lt2, &dummy ); if ( rs->sr_err != 0 ) { Debug(LDAP_DEBUG_TRACE, "<=- " LDAP_XSTRING(bdb_modrdn) ": id2entry failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 ); switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } rs->sr_err = LDAP_OTHER; rs->sr_text = "entry update failed"; goto return_results; } if ( p_ndn.bv_len != 0 ) { parent_is_glue = is_entry_glue(p); rs->sr_err = bdb_cache_children( op, lt2, p ); if ( rs->sr_err != DB_NOTFOUND ) { switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; case 0: break; default: Debug(LDAP_DEBUG_ARGS, "<=- " LDAP_XSTRING(bdb_modrdn) ": has_children failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 ); rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } parent_is_leaf = 1; } bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, p); p = NULL; } if ( TXN_COMMIT( lt2, 0 ) != 0 ) { rs->sr_err = LDAP_OTHER; rs->sr_text = "txn_commit(2) failed"; goto return_results; } if( op->o_postread ) { if( postread_ctrl == NULL ) { postread_ctrl = &ctrls[num_ctrls++]; ctrls[num_ctrls] = NULL; } if( slap_read_controls( op, rs, &dummy, &slap_post_read_bv, postread_ctrl ) ) { Debug( LDAP_DEBUG_TRACE, "<=- " LDAP_XSTRING(bdb_modrdn) ": post-read failed!\n", 0, 0, 0 ); if ( op->o_postread & SLAP_CONTROL_CRITICAL ) { /* FIXME: is it correct to abort * operation if control fails? */ goto return_results; } } } if( op->o_noop ) { if(( rs->sr_err=TXN_ABORT( ltid )) != 0 ) { rs->sr_text = "txn_abort (no-op) failed"; } else { rs->sr_err = LDAP_X_NO_OPERATION; ltid = NULL; /* Only free attrs if they were dup'd. */ if ( dummy.e_attrs == e->e_attrs ) dummy.e_attrs = NULL; goto return_results; } } else { rc = bdb_cache_modrdn( bdb, e, &op->orr_nnewrdn, &dummy, neip, ltid, &lock ); switch( rc ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } dummy.e_attrs = NULL; new_dn.bv_val = NULL; new_ndn.bv_val = NULL; if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) { rs->sr_text = "txn_commit failed"; } else { rs->sr_err = LDAP_SUCCESS; } } ltid = NULL; LDAP_SLIST_REMOVE( &op->o_extra, &opinfo.boi_oe, OpExtra, oe_next ); opinfo.boi_oe.oe_key = NULL; if( rs->sr_err != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": %s : %s (%d)\n", rs->sr_text, db_strerror(rs->sr_err), rs->sr_err ); rs->sr_err = LDAP_OTHER; goto return_results; } Debug(LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_modrdn) ": rdn modified%s id=%08lx dn=\"%s\"\n", op->o_noop ? " (no-op)" : "", dummy.e_id, op->o_req_dn.bv_val ); rs->sr_text = NULL; if( num_ctrls ) rs->sr_ctrls = ctrls; return_results: if ( dummy.e_attrs ) { attrs_free( dummy.e_attrs ); } send_ldap_result( op, rs ); if( rs->sr_err == LDAP_SUCCESS && bdb->bi_txn_cp_kbyte ) { TXN_CHECKPOINT( bdb->bi_dbenv, bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 ); } if ( rs->sr_err == LDAP_SUCCESS && parent_is_glue && parent_is_leaf ) { op->o_delete_glue_parent = 1; } done: slap_graduate_commit_csn( op ); if( new_dn.bv_val != NULL ) free( new_dn.bv_val ); if( new_ndn.bv_val != NULL ) free( new_ndn.bv_val ); /* LDAP v3 Support */ if( np != NULL ) { /* free new parent and reader lock */ bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, np); } if( p != NULL ) { /* free parent and reader lock */ bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, p); } /* free entry */ if( e != NULL ) { bdb_unlocked_cache_return_entry_w( &bdb->bi_cache, e); } if( ltid != NULL ) { TXN_ABORT( ltid ); } if ( opinfo.boi_oe.oe_key ) { LDAP_SLIST_REMOVE( &op->o_extra, &opinfo.boi_oe, OpExtra, oe_next ); } if( preread_ctrl != NULL && (*preread_ctrl) != NULL ) { slap_sl_free( (*preread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx ); slap_sl_free( *preread_ctrl, op->o_tmpmemctx ); } if( postread_ctrl != NULL && (*postread_ctrl) != NULL ) { slap_sl_free( (*postread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx ); slap_sl_free( *postread_ctrl, op->o_tmpmemctx ); } return rs->sr_err; }
/* * Query table for specified rows * _con: structure representing database connection * _k: key names * _op: operators * _v: values of the keys that must match * _c: column names to return * _n: number of key=values pairs to compare * _nc: number of columns to return * _o: order by the specified column */ int bdb_query(db_con_t* _con, db_key_t* _k, db_op_t* _op, db_val_t* _v, db_key_t* _c, int _n, int _nc, db_key_t _o, db_res_t** _r) { tbl_cache_p _tbc = NULL; table_p _tp = NULL; char kbuf[MAX_ROW_SIZE]; char dbuf[MAX_ROW_SIZE]; u_int32_t i, len, ret; int klen=MAX_ROW_SIZE; int *lkey=NULL, *lres=NULL; str s; DBT key, data; DB *db; DBC *dbcp; if ((!_con) || (!_r) || !CON_TABLE(_con)) { #ifdef BDB_EXTRA_DEBUG LM_ERR("Invalid parameter value\n"); #endif return -1; } *_r = NULL; /*check if underlying DB file has changed inode */ if(auto_reload) bdb_check_reload(_con); s.s = (char*)CON_TABLE(_con); s.len = strlen(CON_TABLE(_con)); _tbc = bdblib_get_table(BDB_CON_CONNECTION(_con), &s); if(!_tbc) { LM_WARN("table does not exist!\n"); return -1; } _tp = _tbc->dtp; if(!_tp) { LM_WARN("table not loaded!\n"); return -1; } #ifdef BDB_EXTRA_DEBUG LM_DBG("QUERY in %.*s\n", _tp->name.len, _tp->name.s); if (_o) LM_DBG("DONT-CARE : _o: order by the specified column \n"); if (_op) LM_DBG("DONT-CARE : _op: operators for refining query \n"); #endif db = _tp->db; if(!db) return -1; memset(&key, 0, sizeof(DBT)); memset(kbuf, 0, MAX_ROW_SIZE); memset(&data, 0, sizeof(DBT)); memset(dbuf, 0, MAX_ROW_SIZE); data.data = dbuf; data.ulen = MAX_ROW_SIZE; data.flags = DB_DBT_USERMEM; /* if _c is NULL and _nc is zero, you will get all table columns in the result */ if (_c) { lres = bdb_get_colmap(_tbc->dtp, _c, _nc); if(!lres) { ret = -1; goto error; } } if(_k) { lkey = bdb_get_colmap(_tbc->dtp, _k, _n); if(!lkey) { ret = -1; goto error; } } else { DB_HASH_STAT st; memset(&st, 0, sizeof(DB_HASH_STAT)); i =0 ; #ifdef BDB_EXTRA_DEBUG LM_DBG("SELECT * FROM %.*s\n", _tp->name.len, _tp->name.s); #endif /* Acquire a cursor for the database. */ if ((ret = db->cursor(db, NULL, &dbcp, 0)) != 0) { LM_ERR("Error creating cursor\n"); goto error; } /*count the number of records*/ while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) { if(!strncasecmp((char*)key.data,"METADATA",8)) continue; i++; } dbcp->c_close(dbcp); ret=0; #ifdef BDB_EXTRA_DEBUG LM_DBG("%i = SELECT COUNT(*) FROM %.*s\n", i, _tp->name.len, _tp->name.s); #endif *_r = db_new_result(); if (!*_r) { LM_ERR("no memory left for result \n"); ret = -2; goto error; } if(i == 0) { /*return empty table*/ RES_ROW_N(*_r) = 0; BDB_CON_RESULT(_con) = *_r; return 0; } /*allocate N rows in the result*/ RES_ROW_N(*_r) = i; len = sizeof(db_row_t) * i; RES_ROWS(*_r) = (db_row_t*)pkg_malloc( len ); memset(RES_ROWS(*_r), 0, len); /*fill in the column part of db_res_t (metadata) */ if ((ret = bdb_get_columns(_tbc->dtp, *_r, lres, _nc)) < 0) { LM_ERR("Error while getting column names\n"); goto error; } /* Acquire a cursor for the database. */ if ((ret = db->cursor(db, NULL, &dbcp, 0)) != 0) { LM_ERR("Error creating cursor\n"); goto error; } /*convert each record into a row in the result*/ i =0 ; while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) { if(!strncasecmp((char*)key.data,"METADATA",8)) continue; #ifdef BDB_EXTRA_DEBUG LM_DBG("KEY: [%.*s]\nDATA: [%.*s]\n" , (int) key.size , (char *)key.data , (int) data.size , (char *)data.data); #endif /*fill in the row part of db_res_t */ if ((ret=bdb_append_row( *_r, dbuf, lres, i)) < 0) { LM_ERR("Error while converting row\n"); goto error; } i++; } dbcp->c_close(dbcp); BDB_CON_RESULT(_con) = *_r; return 0; } if ( (ret = bdblib_valtochar(_tp, lkey, kbuf, &klen, _v, _n, BDB_KEY)) != 0 ) { LM_ERR("error in query key \n"); goto error; } key.data = kbuf; key.ulen = MAX_ROW_SIZE; key.flags = DB_DBT_USERMEM; key.size = klen; data.data = dbuf; data.ulen = MAX_ROW_SIZE; data.flags = DB_DBT_USERMEM; /*create an empty db_res_t which gets returned even if no result*/ *_r = db_new_result(); if (!*_r) { LM_ERR("no memory left for result \n"); ret = -2; goto error; } RES_ROW_N(*_r) = 0; BDB_CON_RESULT(_con) = *_r; #ifdef BDB_EXTRA_DEBUG LM_DBG("SELECT KEY: [%.*s]\n" , (int) key.size , (char *)key.data ); #endif /*query Berkely DB*/ if ((ret = db->get(db, NULL, &key, &data, 0)) == 0) { #ifdef BDB_EXTRA_DEBUG LM_DBG("RESULT\nKEY: [%.*s]\nDATA: [%.*s]\n" , (int) key.size , (char *)key.data , (int) data.size , (char *)data.data); #endif /*fill in the col part of db_res_t */ if ((ret = bdb_get_columns(_tbc->dtp, *_r, lres, _nc)) < 0) { LM_ERR("Error while getting column names\n"); goto error; } /*fill in the row part of db_res_t */ if ((ret=bdb_convert_row( *_r, dbuf, lres)) < 0) { LM_ERR("Error while converting row\n"); goto error; } } else { /*Berkeley DB error handler*/ switch(ret) { case DB_NOTFOUND: #ifdef BDB_EXTRA_DEBUG LM_DBG("NO RESULT for QUERY \n"); #endif ret=0; break; /*The following are all critical/fatal */ case DB_LOCK_DEADLOCK: // The operation was selected to resolve a deadlock. case DB_SECONDARY_BAD: // A secondary index references a nonexistent primary key. case DB_RUNRECOVERY: default: LM_CRIT("DB->get error: %s.\n", db_strerror(ret)); bdblib_recover(_tp,ret); goto error; } } if(lkey) pkg_free(lkey); if(lres) pkg_free(lres); return ret; error: if(lkey) pkg_free(lkey); if(lres) pkg_free(lres); if(*_r) bdb_free_result(*_r); *_r = NULL; return ret; }
/* * Delete a row from table * * To delete ALL rows: * do Not specify any keys, or values, and _n <=0 * */ int bdb_delete(db_con_t* _h, db_key_t* _k, db_op_t* _op, db_val_t* _v, int _n) { tbl_cache_p _tbc = NULL; table_p _tp = NULL; char kbuf[MAX_ROW_SIZE]; int i, j, ret, klen; int *lkey=NULL; DBT key; DB *db; DBC *dbcp; str s; i = j = ret = 0; klen=MAX_ROW_SIZE; if (_op) return ( _bdb_delete_cursor(_h, _k, _op, _v, _n) ); if ((!_h) || !CON_TABLE(_h)) return -1; s.s = (char*)CON_TABLE(_h); s.len = strlen(CON_TABLE(_h)); _tbc = bdblib_get_table(BDB_CON_CONNECTION(_h), &s); if(!_tbc) { LM_WARN("table does not exist!\n"); return -3; } _tp = _tbc->dtp; if(!_tp) { LM_WARN("table not loaded!\n"); return -4; } #ifdef BDB_EXTRA_DEBUG LM_DBG("DELETE in %.*s\n", _tp->name.len, _tp->name.s ); #endif db = _tp->db; memset(&key, 0, sizeof(DBT)); memset(kbuf, 0, klen); if(!_k || !_v || _n<=0) { /* Acquire a cursor for the database. */ if ((ret = db->cursor(db, NULL, &dbcp, DB_WRITECURSOR) ) != 0) { LM_ERR("Error creating cursor\n"); goto error; } while ((ret = dbcp->c_get(dbcp, &key, NULL, DB_NEXT)) == 0) { if(!strncasecmp((char*)key.data,"METADATA",8)) continue; #ifdef BDB_EXTRA_DEBUG LM_DBG("KEY: [%.*s]\n" , (int) key.size , (char *)key.data); #endif ret = dbcp->c_del(dbcp, 0); } dbcp->c_close(dbcp); return 0; } lkey = bdb_get_colmap(_tp, _k, _n); if(!lkey) return -5; /* make the key */ if ( (ret = bdblib_valtochar(_tp, lkey, kbuf, &klen, _v, _n, BDB_KEY)) != 0 ) { LM_ERR("Error in bdblib_makekey\n"); ret = -6; goto error; } key.data = kbuf; key.ulen = MAX_ROW_SIZE; key.flags = DB_DBT_USERMEM; key.size = klen; if ((ret = db->del(db, NULL, &key, 0)) == 0) { bdblib_log(JLOG_DELETE, _tp, kbuf, klen); #ifdef BDB_EXTRA_DEBUG LM_DBG("DELETED ROW \n KEY: %s \n", (char *)key.data); #endif } else { /*Berkeley DB error handler*/ switch(ret) { case DB_NOTFOUND: ret = 0; break; /*The following are all critical/fatal */ case DB_LOCK_DEADLOCK: /* The operation was selected to resolve a deadlock. */ case DB_SECONDARY_BAD: /* A secondary index references a nonexistent primary key. */ case DB_RUNRECOVERY: default: LM_CRIT("DB->del error: %s.\n" , db_strerror(ret)); bdblib_recover(_tp, ret); goto error; } } ret = 0; error: if(lkey) pkg_free(lkey); return ret; }
static int bdb_db_close( BackendDB *be, ConfigReply *cr ) { int rc; struct bdb_info *bdb = (struct bdb_info *) be->be_private; struct bdb_db_info *db; bdb_idl_cache_entry_t *entry, *next_entry; /* monitor handling */ (void)bdb_monitor_db_close( be ); { Entry *e = bdb->bi_cache.c_dntree.bei_e; if ( e ) { bdb->bi_cache.c_dntree.bei_e = NULL; e->e_private = NULL; bdb_entry_return( e ); } } bdb->bi_flags &= ~BDB_IS_OPEN; ber_bvarray_free( bdb->bi_db_config ); bdb->bi_db_config = NULL; if( bdb->bi_dbenv ) { /* Free cache locker if we enabled locking. * TXNs must all be closed before DBs... */ if ( !( slapMode & SLAP_TOOL_QUICK ) && bdb->bi_cache.c_txn ) { TXN_ABORT( bdb->bi_cache.c_txn ); bdb->bi_cache.c_txn = NULL; } bdb_reader_flush( bdb->bi_dbenv ); } while( bdb->bi_databases && bdb->bi_ndatabases-- ) { db = bdb->bi_databases[bdb->bi_ndatabases]; rc = db->bdi_db->close( db->bdi_db, 0 ); /* Lower numbered names are not strdup'd */ if( bdb->bi_ndatabases >= BDB_NDB ) free( db->bdi_name.bv_val ); free( db ); } free( bdb->bi_databases ); bdb->bi_databases = NULL; bdb_cache_release_all (&bdb->bi_cache); if ( bdb->bi_idl_cache_size ) { avl_free( bdb->bi_idl_tree, NULL ); bdb->bi_idl_tree = NULL; entry = bdb->bi_idl_lru_head; do { next_entry = entry->idl_lru_next; if ( entry->idl ) free( entry->idl ); free( entry->kstr.bv_val ); free( entry ); entry = next_entry; } while ( entry != bdb->bi_idl_lru_head ); bdb->bi_idl_lru_head = bdb->bi_idl_lru_tail = NULL; } /* close db environment */ if( bdb->bi_dbenv ) { /* force a checkpoint, but not if we were ReadOnly, * and not in Quick mode since there are no transactions there. */ if ( !( slapMode & ( SLAP_TOOL_QUICK|SLAP_TOOL_READONLY ))) { rc = TXN_CHECKPOINT( bdb->bi_dbenv, 0, 0, DB_FORCE ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, "bdb_db_close: database \"%s\": " "txn_checkpoint failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); } } rc = bdb->bi_dbenv->close( bdb->bi_dbenv, 0 ); bdb->bi_dbenv = NULL; if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, "bdb_db_close: database \"%s\": " "close failed: %s (%d)\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); return rc; } } rc = alock_close( &bdb->bi_alock_info, slapMode & SLAP_TOOL_QUICK ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, "bdb_db_close: database \"%s\": alock_close failed\n", be->be_suffix[0].bv_val, 0, 0 ); return -1; } return 0; }
int bdb_db_cache( Backend *be, struct berval *name, DB **dbout ) { int i, flags; int rc; struct bdb_info *bdb = (struct bdb_info *) be->be_private; struct bdb_db_info *db; char *file; *dbout = NULL; for( i=BDB_NDB; i < bdb->bi_ndatabases; i++ ) { if( !ber_bvcmp( &bdb->bi_databases[i]->bdi_name, name) ) { *dbout = bdb->bi_databases[i]->bdi_db; return 0; } } ldap_pvt_thread_mutex_lock( &bdb->bi_database_mutex ); /* check again! may have been added by another thread */ for( i=BDB_NDB; i < bdb->bi_ndatabases; i++ ) { if( !ber_bvcmp( &bdb->bi_databases[i]->bdi_name, name) ) { *dbout = bdb->bi_databases[i]->bdi_db; ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex ); return 0; } } if( i >= BDB_INDICES ) { ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex ); return -1; } db = (struct bdb_db_info *) ch_calloc(1, sizeof(struct bdb_db_info)); ber_dupbv( &db->bdi_name, name ); rc = db_create( &db->bdi_db, bdb->bi_dbenv, 0 ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, "bdb_db_cache: db_create(%s) failed: %s (%d)\n", bdb->bi_dbenv_home, db_strerror(rc), rc ); ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex ); ch_free( db ); return rc; } if( !BER_BVISNULL( &bdb->bi_db_crypt_key )) { rc = db->bdi_db->set_flags( db->bdi_db, DB_ENCRYPT ); if ( rc ) { Debug( LDAP_DEBUG_ANY, "bdb_db_cache: db set_flags(DB_ENCRYPT)(%s) failed: %s (%d)\n", bdb->bi_dbenv_home, db_strerror(rc), rc ); ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex ); db->bdi_db->close( db->bdi_db, 0 ); ch_free( db ); return rc; } } if( bdb->bi_flags & BDB_CHKSUM ) { rc = db->bdi_db->set_flags( db->bdi_db, DB_CHKSUM ); if ( rc ) { Debug( LDAP_DEBUG_ANY, "bdb_db_cache: db set_flags(DB_CHKSUM)(%s) failed: %s (%d)\n", bdb->bi_dbenv_home, db_strerror(rc), rc ); ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex ); db->bdi_db->close( db->bdi_db, 0 ); ch_free( db ); return rc; } } /* If no explicit size set, use the FS default */ flags = bdb_db_findsize( bdb, name ); if ( flags ) rc = db->bdi_db->set_pagesize( db->bdi_db, flags ); #ifdef BDB_INDEX_USE_HASH rc = db->bdi_db->set_h_hash( db->bdi_db, bdb_db_hash ); #endif rc = db->bdi_db->set_flags( db->bdi_db, DB_DUP | DB_DUPSORT ); file = ch_malloc( db->bdi_name.bv_len + sizeof(BDB_SUFFIX) ); strcpy( file, db->bdi_name.bv_val ); strcpy( file+db->bdi_name.bv_len, BDB_SUFFIX ); #ifdef HAVE_EBCDIC __atoe( file ); #endif flags = DB_CREATE | DB_THREAD; #ifdef DB_AUTO_COMMIT if ( !( slapMode & SLAP_TOOL_QUICK )) flags |= DB_AUTO_COMMIT; #endif /* Cannot Truncate when Transactions are in use */ if ( (slapMode & (SLAP_TOOL_QUICK|SLAP_TRUNCATE_MODE)) == (SLAP_TOOL_QUICK|SLAP_TRUNCATE_MODE)) flags |= DB_TRUNCATE; rc = DB_OPEN( db->bdi_db, file, NULL /* name */, BDB_INDEXTYPE, bdb->bi_db_opflags | flags, bdb->bi_dbenv_mode ); ch_free( file ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, "bdb_db_cache: db_open(%s) failed: %s (%d)\n", name->bv_val, db_strerror(rc), rc ); ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex ); return rc; } bdb->bi_databases[i] = db; bdb->bi_ndatabases = i+1; *dbout = db->bdi_db; ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex ); return 0; }
/** probe if the directory contains an environment, and if so, * if it has transactions */ e_txn probe_txn(bfpath *bfp) { DB_ENV *dbe; int r; #if DB_AT_LEAST(4,2) u_int32_t flags; #endif r = db_env_create(&dbe, 0); if (r) { print_error(__FILE__, __LINE__, "cannot create environment handle: %s", db_strerror(r)); return T_ERROR; } /* we might call dbe->set_flags here to set DB_NOPANIC, but this is * only supported from 4.1 onwards and probably not worth the * effort, we'll just check for DB_RUNRECOVERY */ #if DB_AT_LEAST(3,2) r = dbe->open(dbe, bfp->dirname, DB_JOINENV, DS_MODE); #else r = ENOENT; #endif if (r == DB_RUNRECOVERY) { dbe->close(dbe, 0); return T_ENABLED; } if (r == ENOENT) { struct stat st; int w; char *t = bfp->filepath; struct dirent *de; e_txn rc = T_DONT_KNOW; DIR *d; /* no environment found by JOINENV, but clean up handle */ dbe->close(dbe, 0); /* retry, looking for log\.[0-9]{10} files - needed for instance * after bogoutil --db-remove DIR or when DB_JOINENV is * unsupported */ d = opendir(bfp->dirname); if (d == NULL) { print_error(__FILE__, __LINE__, "cannot open directory %s: %s", t, strerror(r)); rc = T_ERROR; } else { while ((errno = 0, de = readdir(d))) { if (strlen(de->d_name) == 14 && strncmp(de->d_name, "log.", 4) == 0 && strspn(de->d_name + 4, "0123456789") == 10) { rc = T_ENABLED; break; } } if (errno) rc = T_ERROR; closedir(d); if (rc != T_ERROR && rc != T_ENABLED) { w = stat(t, &st); if (w == 0) { rc = T_DISABLED; } else if (errno != ENOENT) { rc = T_ERROR; print_error(__FILE__, __LINE__, "cannot stat %s: %s", t, db_strerror(r)); } } } return rc; } /* if (r == ENOENT) for environment join */ if (r != 0) { print_error(__FILE__, __LINE__, "cannot join environment: %s", db_strerror(r)); return T_ERROR; } /* environment found, validate if it has transactions */ #if DB_AT_LEAST(4,2) r = dbe->get_open_flags(dbe, &flags); if (r) { print_error(__FILE__, __LINE__, "cannot query flags: %s", db_strerror(r)); return T_ERROR; } dbe->close(dbe, 0); if ((flags & DB_INIT_TXN) == 0) { print_error(__FILE__, __LINE__, "environment found but does not support transactions."); return T_ERROR; } #else dbe->close(dbe, 0); #endif return T_ENABLED; }
item *item_cget(DBC *cursorp, char *start, size_t nstart, u_int32_t flags){ item *it = NULL; DBT dbkey, dbdata; bool stop; int ret; /* first, alloc a fixed size */ it = item_alloc2(settings.item_buf_size); if (it == 0) { return NULL; } BDB_CLEANUP_DBT(); dbkey.data = start; dbkey.size = nstart; dbkey.dlen = 0; dbkey.doff = 0; dbkey.flags = DB_DBT_PARTIAL; dbdata.ulen = settings.item_buf_size; dbdata.data = it; dbdata.flags = DB_DBT_USERMEM; stop = false; /* try to get a item from bdb */ while (!stop) { switch (ret = cursorp->get(cursorp, &dbkey, &dbdata, flags)) { case DB_BUFFER_SMALL: /* user mem small */ if (settings.verbose > 1) { fprintf(stderr, "cursorp->get: %s\n", db_strerror(ret)); } /* free the original smaller buffer */ item_free(it); /* alloc the correct size */ it = item_alloc2(dbdata.size); if (it == NULL) { return NULL; } dbkey.data = start; dbkey.size = nstart; dbdata.ulen = dbdata.size; dbdata.data = it; break; case 0: /* Success. */ stop = true; break; case DB_NOTFOUND: stop = true; item_free(it); it = NULL; break; default: /* TODO: may cause bug here, if return DB_BUFFER_SMALL then retun non-zero again * here 'it' may not a full one. a item buffer larger than item_buf_size may be added to freelist */ stop = true; item_free(it); it = NULL; if (settings.verbose > 1) { fprintf(stderr, "cursorp->get: %s\n", db_strerror(ret)); } } } return it; }
/* * Update a Job record -- allows you to change the * date fields in a Job record. This helps when * providing migration from other vendors. */ static bool update_job(UAContext *ua) { int i; char ed1[50], ed2[50]; POOL_MEM cmd(PM_MESSAGE); JOB_DBR jr; CLIENT_DBR cr; utime_t StartTime; char *client_name = NULL; char *start_time = NULL; const char *kw[] = { NT_("starttime"), /* 0 */ NT_("client"), /* 1 */ NULL }; Dmsg1(200, "cmd=%s\n", ua->cmd); i = find_arg_with_value(ua, NT_("jobid")); if (i < 0) { ua->error_msg(_("Expect JobId keyword, not found.\n")); return false; } memset(&jr, 0, sizeof(jr)); memset(&cr, 0, sizeof(cr)); jr.JobId = str_to_int64(ua->argv[i]); if (!db_get_job_record(ua->jcr, ua->db, &jr)) { ua->error_msg("%s", db_strerror(ua->db)); return false; } for (i=0; kw[i]; i++) { int j; if ((j=find_arg_with_value(ua, kw[i])) >= 0) { switch (i) { case 0: /* start time */ start_time = ua->argv[j]; break; case 1: /* Client name */ client_name = ua->argv[j]; break; } } } if (!client_name && !start_time) { ua->error_msg(_("Neither Client nor StartTime specified.\n")); return 0; } if (client_name) { if (!get_client_dbr(ua, &cr)) { return false; } jr.ClientId = cr.ClientId; } if (start_time) { utime_t delta_start; StartTime = str_to_utime(start_time); if (StartTime == 0) { ua->error_msg(_("Improper date format: %s\n"), ua->argv[i]); return false; } delta_start = StartTime - jr.StartTime; Dmsg3(200, "ST=%lld jr.ST=%lld delta=%lld\n", StartTime, (utime_t)jr.StartTime, delta_start); jr.StartTime = (time_t)StartTime; jr.SchedTime += (time_t)delta_start; jr.EndTime += (time_t)delta_start; jr.JobTDate += delta_start; /* Convert to DB times */ bstrutime(jr.cStartTime, sizeof(jr.cStartTime), jr.StartTime); bstrutime(jr.cSchedTime, sizeof(jr.cSchedTime), jr.SchedTime); bstrutime(jr.cEndTime, sizeof(jr.cEndTime), jr.EndTime); } Mmsg(cmd, "UPDATE Job SET ClientId=%s,StartTime='%s',SchedTime='%s'," "EndTime='%s',JobTDate=%s WHERE JobId=%s", edit_int64(jr.ClientId, ed1), jr.cStartTime, jr.cSchedTime, jr.cEndTime, edit_uint64(jr.JobTDate, ed1), edit_int64(jr.JobId, ed2)); if (!db_sql_query(ua->db, cmd.c_str(), NULL, NULL)) { ua->error_msg("%s", db_strerror(ua->db)); return false; } return true; }
int GalaxDBopen_internal(DB **dbp, char * dbname, DBTYPE type, unsigned int open_flags, unsigned int set_flags, int buffsize, int bfixed, int fixed_length) { int retval, i; char * argument[2]; #ifdef DEBUG printf("C: creating database : %s and %d size | open flags %d\n", dbname, buffsize,open_flags); fflush(stdout); #endif retval = db_create(dbp, NULL, open_flags); if(retval != 0) { #ifdef DEBUG printf("C: Error in creating Database: %s\n", db_strerror(retval)); fflush(stdout); #endif return retval; } #ifdef DEBUG printf("C: database created [name: %s|dbp: %X], now setting flags = %u\n", dbname, *dbp, set_flags); fflush(stdout); #endif retval = (*dbp)->set_flags((*dbp), set_flags); if(retval != 0) { #ifdef DEBUG printf("C: Error in setting flags : %s\n", db_strerror(retval)); fflush(stdout); #endif (*dbp)->err((*dbp), retval, "%s", "GalaxDB", dbname); return retval; } #ifdef DEBUG printf("C: flag set now opening database\n"); printf("C: Setting Cachesize: %d\n", buffsize); fflush(stdout); #endif retval = (*dbp)->set_cachesize((*dbp), 0, buffsize, 1); if(retval != 0) { printf("C: Error in setting such a large cache\n"); fflush(stdout); (*dbp)->err((*dbp), retval, "%s", "GalaxDB", dbname); return retval; } if (bfixed) { if ((retval = (*dbp)->set_re_len(*dbp, fixed_length)) != 0) { #ifdef DEBUG printf("C: Error in setting to fixed length : %s\n", db_strerror(retval)); fflush(stdout); #endif (*dbp)->err(*dbp, retval, "%s", "GalaxDBrec_fixed_length [fixed]"); return retval; } if((retval = (*dbp)->set_re_pad(*dbp, 0)) != 0) { #ifdef DEBUG printf("C: Error in setting padding : %s\n", db_strerror(retval)); fflush(stdout); #endif (*dbp)->err(*dbp, retval, "%s", "GalaxDBrec_fixed_length [pad]"); } #ifdef DEBUG printf("C: Succeded in setting fixed size of %d\n", fixed_length); fflush(stdout); #endif } retval = (*dbp)->open((*dbp), NULL, dbname, NULL, type, DB_CREATE, 0664); if(retval != 0) { (*dbp)->err((*dbp), retval, "%s", "GalaxDB", dbname); return retval; } #ifdef DEBUG printf("C: Database %s opened \n", dbname); fflush(stdout); #endif return retval; }
int bdb_add(Operation *op, SlapReply *rs ) { struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private; struct berval pdn; Entry *p = NULL, *oe = op->ora_e; EntryInfo *ei; char textbuf[SLAP_TEXT_BUFLEN]; size_t textlen = sizeof textbuf; AttributeDescription *children = slap_schema.si_ad_children; AttributeDescription *entry = slap_schema.si_ad_entry; DB_TXN *ltid = NULL, *lt2; ID eid = NOID; struct bdb_op_info opinfo = {{{ 0 }}}; int subentry; DB_LOCK lock; int num_retries = 0; int success; LDAPControl **postread_ctrl = NULL; LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS]; int num_ctrls = 0; #ifdef LDAP_X_TXN int settle = 0; #endif Debug(LDAP_DEBUG_ARGS, "==> " LDAP_XSTRING(bdb_add) ": %s\n", op->ora_e->e_name.bv_val); #ifdef LDAP_X_TXN if( op->o_txnSpec ) { /* acquire connection lock */ ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex ); if( op->o_conn->c_txn == CONN_TXN_INACTIVE ) { rs->sr_text = "invalid transaction identifier"; rs->sr_err = LDAP_X_TXN_ID_INVALID; goto txnReturn; } else if( op->o_conn->c_txn == CONN_TXN_SETTLE ) { settle=1; goto txnReturn; } if( op->o_conn->c_txn_backend == NULL ) { op->o_conn->c_txn_backend = op->o_bd; } else if( op->o_conn->c_txn_backend != op->o_bd ) { rs->sr_text = "transaction cannot span multiple database contexts"; rs->sr_err = LDAP_AFFECTS_MULTIPLE_DSAS; goto txnReturn; } /* insert operation into transaction */ rs->sr_text = "transaction specified"; rs->sr_err = LDAP_X_TXN_SPECIFY_OKAY; txnReturn: /* release connection lock */ ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); if( !settle ) { send_ldap_result( op, rs ); return rs->sr_err; } } #endif ctrls[num_ctrls] = 0; /* check entry's schema */ rs->sr_err = entry_schema_check( op, op->ora_e, NULL, get_relax(op), 1, NULL, &rs->sr_text, textbuf, textlen ); if ( rs->sr_err != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": entry failed schema check: " "%s (%d)\n", rs->sr_text, rs->sr_err ); goto return_results; } /* add opattrs to shadow as well, only missing attrs will actually * be added; helps compatibility with older OL versions */ rs->sr_err = slap_add_opattrs( op, &rs->sr_text, textbuf, textlen, 1 ); if ( rs->sr_err != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": entry failed op attrs add: " "%s (%d)\n", rs->sr_text, rs->sr_err ); goto return_results; } if ( get_assert( op ) && ( test_filter( op, op->ora_e, get_assertion( op )) != LDAP_COMPARE_TRUE )) { rs->sr_err = LDAP_ASSERTION_FAILED; goto return_results; } subentry = is_entry_subentry( op->ora_e ); if( 0 ) { retry: /* transaction retry */ if( p ) { /* free parent and reader lock */ if ( p != (Entry *)&slap_entry_root ) { bdb_unlocked_cache_return_entry_r( bdb, p ); } p = NULL; } rs->sr_err = TXN_ABORT( ltid ); ltid = NULL; LDAP_SLIST_REMOVE( &op->o_extra, &opinfo.boi_oe, OpExtra, oe_next ); opinfo.boi_oe.oe_key = NULL; op->o_do_not_cache = opinfo.boi_acl_cache; if( rs->sr_err != 0 ) { rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } if ( slap_get_op_abandon(op) ) { rs->sr_err = SLAPD_ABANDON; goto return_results; } bdb_trans_backoff( ++num_retries ); } /* begin transaction */ rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, NULL, <id, bdb->bi_db_opflags ); rs->sr_text = NULL; if( rs->sr_err != 0 ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": txn_begin failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err ); rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": txn1 id: %x\n", ltid->id(ltid) ); opinfo.boi_oe.oe_key = bdb; opinfo.boi_txn = ltid; opinfo.boi_err = 0; opinfo.boi_acl_cache = op->o_do_not_cache; LDAP_SLIST_INSERT_HEAD( &op->o_extra, &opinfo.boi_oe, oe_next ); /* * Get the parent dn and see if the corresponding entry exists. */ if ( be_issuffix( op->o_bd, &op->ora_e->e_nname ) ) { pdn = slap_empty_bv; } else { dnParent( &op->ora_e->e_nname, &pdn ); } /* get entry or parent */ rs->sr_err = bdb_dn2entry( op, ltid, &op->ora_e->e_nname, &ei, 1, &lock ); switch( rs->sr_err ) { case 0: rs->sr_err = LDAP_ALREADY_EXISTS; goto return_results; case DB_NOTFOUND: break; case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; case LDAP_BUSY: rs->sr_text = "ldap server busy"; goto return_results; default: rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } p = ei->bei_e; if ( !p ) p = (Entry *)&slap_entry_root; if ( !bvmatch( &pdn, &p->e_nname ) ) { rs->sr_matched = ber_strdup_x( p->e_name.bv_val, op->o_tmpmemctx ); rs->sr_ref = is_entry_referral( p ) ? get_entry_referrals( op, p ) : NULL; if ( p != (Entry *)&slap_entry_root ) bdb_unlocked_cache_return_entry_r( bdb, p ); p = NULL; Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": parent " "does not exist\n" ); rs->sr_err = LDAP_REFERRAL; rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED; goto return_results; } rs->sr_err = access_allowed( op, p, children, NULL, ACL_WADD, NULL ); if ( ! rs->sr_err ) { switch( opinfo.boi_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } if ( p != (Entry *)&slap_entry_root ) bdb_unlocked_cache_return_entry_r( bdb, p ); p = NULL; Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": no write access to parent\n" ); rs->sr_err = LDAP_INSUFFICIENT_ACCESS; rs->sr_text = "no write access to parent"; goto return_results; } if ( p != (Entry *)&slap_entry_root ) { if ( is_entry_subentry( p ) ) { bdb_unlocked_cache_return_entry_r( bdb, p ); p = NULL; /* parent is a subentry, don't allow add */ Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": parent is subentry\n" ); rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION; rs->sr_text = "parent is a subentry"; goto return_results; } if ( is_entry_alias( p ) ) { bdb_unlocked_cache_return_entry_r( bdb, p ); p = NULL; /* parent is an alias, don't allow add */ Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": parent is alias\n" ); rs->sr_err = LDAP_ALIAS_PROBLEM; rs->sr_text = "parent is an alias"; goto return_results; } if ( is_entry_referral( p ) ) { /* parent is a referral, don't allow add */ rs->sr_matched = ber_strdup_x( p->e_name.bv_val, op->o_tmpmemctx ); rs->sr_ref = get_entry_referrals( op, p ); bdb_unlocked_cache_return_entry_r( bdb, p ); p = NULL; Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": parent is referral\n" ); rs->sr_err = LDAP_REFERRAL; rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED; goto return_results; } } if ( subentry ) { /* FIXME: */ /* parent must be an administrative point of the required kind */ } /* free parent and reader lock */ if ( p != (Entry *)&slap_entry_root ) { if ( p->e_nname.bv_len ) { struct berval ppdn; /* ITS#5326: use parent's DN if differs from provided one */ dnParent( &op->ora_e->e_name, &ppdn ); if ( !dn_match( &p->e_name, &ppdn ) ) { struct berval rdn; struct berval newdn; dnRdn( &op->ora_e->e_name, &rdn ); build_new_dn( &newdn, &p->e_name, &rdn, NULL ); if ( op->ora_e->e_name.bv_val != op->o_req_dn.bv_val ) ber_memfree( op->ora_e->e_name.bv_val ); op->ora_e->e_name = newdn; /* FIXME: should check whether * dnNormalize(newdn) == e->e_nname ... */ } } bdb_unlocked_cache_return_entry_r( bdb, p ); } p = NULL; rs->sr_err = access_allowed( op, op->ora_e, entry, NULL, ACL_WADD, NULL ); if ( ! rs->sr_err ) { switch( opinfo.boi_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": no write access to entry\n" ); rs->sr_err = LDAP_INSUFFICIENT_ACCESS; rs->sr_text = "no write access to entry"; goto return_results; } /* * Check ACL for attribute write access */ if (!acl_check_modlist(op, oe, op->ora_modlist)) { switch( opinfo.boi_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": no write access to attribute\n" ); rs->sr_err = LDAP_INSUFFICIENT_ACCESS; rs->sr_text = "no write access to attribute"; goto return_results; } if ( eid == NOID ) { rs->sr_err = bdb_next_id( op->o_bd, &eid ); if( rs->sr_err != 0 ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": next_id failed (%d)\n", rs->sr_err ); rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } op->ora_e->e_id = eid; } /* nested transaction */ rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, ltid, <2, bdb->bi_db_opflags ); rs->sr_text = NULL; if( rs->sr_err != 0 ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": txn_begin(2) failed: " "%s (%d)\n", db_strerror(rs->sr_err), rs->sr_err ); rs->sr_err = LDAP_OTHER; rs->sr_text = "internal error"; goto return_results; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": txn2 id: %x\n", lt2->id(lt2) ); /* dn2id index */ rs->sr_err = bdb_dn2id_add( op, lt2, ei, op->ora_e ); if ( rs->sr_err != 0 ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": dn2id_add failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err ); switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; case DB_KEYEXIST: rs->sr_err = LDAP_ALREADY_EXISTS; break; default: rs->sr_err = LDAP_OTHER; } goto return_results; } /* attribute indexes */ rs->sr_err = bdb_index_entry_add( op, lt2, op->ora_e ); if ( rs->sr_err != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": index_entry_add failed\n" ); switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; default: rs->sr_err = LDAP_OTHER; } rs->sr_text = "index generation failed"; goto return_results; } /* id2entry index */ rs->sr_err = bdb_id2entry_add( op->o_bd, lt2, op->ora_e ); if ( rs->sr_err != 0 ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": id2entry_add failed\n" ); switch( rs->sr_err ) { case DB_LOCK_DEADLOCK: case DB_LOCK_NOTGRANTED: goto retry; default: rs->sr_err = LDAP_OTHER; } rs->sr_text = "entry store failed"; goto return_results; } if ( TXN_COMMIT( lt2, 0 ) != 0 ) { rs->sr_err = LDAP_OTHER; rs->sr_text = "txn_commit(2) failed"; goto return_results; } /* post-read */ if( op->o_postread ) { if( postread_ctrl == NULL ) { postread_ctrl = &ctrls[num_ctrls++]; ctrls[num_ctrls] = NULL; } if ( slap_read_controls( op, rs, op->ora_e, &slap_post_read_bv, postread_ctrl ) ) { Debug( LDAP_DEBUG_TRACE, "<=- " LDAP_XSTRING(bdb_add) ": post-read " "failed!\n" ); if ( op->o_postread & SLAP_CONTROL_CRITICAL ) { /* FIXME: is it correct to abort * operation if control fails? */ goto return_results; } } } if ( op->o_noop ) { if (( rs->sr_err=TXN_ABORT( ltid )) != 0 ) { rs->sr_text = "txn_abort (no-op) failed"; } else { rs->sr_err = LDAP_X_NO_OPERATION; ltid = NULL; goto return_results; } } else { struct berval nrdn; /* pick the RDN if not suffix; otherwise pick the entire DN */ if (pdn.bv_len) { nrdn.bv_val = op->ora_e->e_nname.bv_val; nrdn.bv_len = pdn.bv_val - op->ora_e->e_nname.bv_val - 1; } else { nrdn = op->ora_e->e_nname; } bdb_cache_add( bdb, ei, op->ora_e, &nrdn, ltid, &lock ); if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) { rs->sr_text = "txn_commit failed"; } else { rs->sr_err = LDAP_SUCCESS; } } ltid = NULL; LDAP_SLIST_REMOVE( &op->o_extra, &opinfo.boi_oe, OpExtra, oe_next ); opinfo.boi_oe.oe_key = NULL; if ( rs->sr_err != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": %s : %s (%d)\n", rs->sr_text, db_strerror(rs->sr_err), rs->sr_err ); rs->sr_err = LDAP_OTHER; goto return_results; } Debug(LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_add) ": added%s id=%08lx dn=\"%s\"\n", op->o_noop ? " (no-op)" : "", op->ora_e->e_id, op->ora_e->e_dn ); rs->sr_text = NULL; if( num_ctrls ) rs->sr_ctrls = ctrls; return_results: success = rs->sr_err; send_ldap_result( op, rs ); rs_send_cleanup( rs ); if( ltid != NULL ) { TXN_ABORT( ltid ); } if ( opinfo.boi_oe.oe_key ) { LDAP_SLIST_REMOVE( &op->o_extra, &opinfo.boi_oe, OpExtra, oe_next ); } if( success == LDAP_SUCCESS ) { /* We own the entry now, and it can be purged at will * Check to make sure it's the same entry we entered with. * Possibly a callback may have mucked with it, although * in general callbacks should treat the entry as read-only. */ bdb_cache_deref( oe->e_private ); if ( op->ora_e == oe ) op->ora_e = NULL; if ( bdb->bi_txn_cp_kbyte ) { TXN_CHECKPOINT( bdb->bi_dbenv, bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 ); } } slap_graduate_commit_csn( op ); if( postread_ctrl != NULL && (*postread_ctrl) != NULL ) { slap_sl_free( (*postread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx ); slap_sl_free( *postread_ctrl, op->o_tmpmemctx ); } return rs->sr_err; }
/* * Update a media record -- allows you to change the * Volume status. E.g. if you want Bacula to stop * writing on the volume, set it to anything other * than Append. */ static int update_volume(UAContext *ua) { MEDIA_DBR mr; POOL *pool; POOL_DBR pr; POOLMEM *query; POOL_MEM ret; char buf[1000]; char ed1[130]; bool done = false; int i; const char *kw[] = { NT_("VolStatus"), /* 0 */ NT_("VolRetention"), /* 1 */ NT_("VolUse"), /* 2 */ NT_("MaxVolJobs"), /* 3 */ NT_("MaxVolFiles"), /* 4 */ NT_("MaxVolBytes"), /* 5 */ NT_("Recycle"), /* 6 */ NT_("InChanger"), /* 7 */ NT_("Slot"), /* 8 */ NT_("Pool"), /* 9 */ NT_("FromPool"), /* 10 */ NT_("AllFromPool"), /* 11 !!! see below !!! */ NT_("Enabled"), /* 12 */ NT_("RecyclePool"), /* 13 */ NT_("ActionOnPurge"), /* 14 */ NULL }; #define AllFromPool 11 /* keep this updated with above */ for (i=0; kw[i]; i++) { int j; POOL_DBR pr; if ((j=find_arg_with_value(ua, kw[i])) > 0) { /* If all from pool don't select a media record */ if (i != AllFromPool && !select_media_dbr(ua, &mr)) { return 0; } switch (i) { case 0: update_volstatus(ua, ua->argv[j], &mr); break; case 1: update_volretention(ua, ua->argv[j], &mr); break; case 2: update_voluseduration(ua, ua->argv[j], &mr); break; case 3: update_volmaxjobs(ua, ua->argv[j], &mr); break; case 4: update_volmaxfiles(ua, ua->argv[j], &mr); break; case 5: update_volmaxbytes(ua, ua->argv[j], &mr); break; case 6: update_volrecycle(ua, ua->argv[j], &mr); break; case 7: update_volinchanger(ua, ua->argv[j], &mr); break; case 8: update_volslot(ua, ua->argv[j], &mr); break; case 9: memset(&pr, 0, sizeof(POOL_DBR)); pr.PoolId = mr.PoolId; if (!db_get_pool_record(ua->jcr, ua->db, &pr)) { ua->error_msg("%s", db_strerror(ua->db)); break; } update_vol_pool(ua, ua->argv[j], &mr, &pr); break; case 10: update_vol_from_pool(ua, &mr); return 1; case 11: update_all_vols_from_pool(ua, ua->argv[j]); return 1; case 12: update_volenabled(ua, ua->argv[j], &mr); break; case 13: update_vol_recyclepool(ua, ua->argv[j], &mr); break; case 14: update_vol_actiononpurge(ua, ua->argv[j], &mr); break; } done = true; } } /* Allow user to simply update all volumes */ if (find_arg(ua, NT_("fromallpools")) > 0) { update_all_vols(ua); return 1; } for ( ; !done; ) { start_prompt(ua, _("Parameters to modify:\n")); add_prompt(ua, _("Volume Status")); /* 0 */ add_prompt(ua, _("Volume Retention Period")); /* 1 */ add_prompt(ua, _("Volume Use Duration")); /* 2 */ add_prompt(ua, _("Maximum Volume Jobs")); /* 3 */ add_prompt(ua, _("Maximum Volume Files")); /* 4 */ add_prompt(ua, _("Maximum Volume Bytes")); /* 5 */ add_prompt(ua, _("Recycle Flag")); /* 6 */ add_prompt(ua, _("Slot")); /* 7 */ add_prompt(ua, _("InChanger Flag")); /* 8 */ add_prompt(ua, _("Volume Files")); /* 9 */ add_prompt(ua, _("Pool")); /* 10 */ add_prompt(ua, _("Volume from Pool")); /* 11 */ add_prompt(ua, _("All Volumes from Pool")); /* 12 */ add_prompt(ua, _("All Volumes from all Pools")); /* 13 */ add_prompt(ua, _("Enabled")), /* 14 */ add_prompt(ua, _("RecyclePool")), /* 15 */ add_prompt(ua, _("Action On Purge")), /* 16 */ add_prompt(ua, _("Done")); /* 17 */ i = do_prompt(ua, "", _("Select parameter to modify"), NULL, 0); /* For All Volumes, All Volumes from Pool, and Done, we don't need * a Volume record */ if ( i != 12 && i != 13 && i != 17) { if (!select_media_dbr(ua, &mr)) { /* Get Volume record */ return 0; } ua->info_msg(_("Updating Volume \"%s\"\n"), mr.VolumeName); } switch (i) { case 0: /* Volume Status */ /* Modify Volume Status */ ua->info_msg(_("Current Volume status is: %s\n"), mr.VolStatus); start_prompt(ua, _("Possible Values are:\n")); add_prompt(ua, NT_("Append")); add_prompt(ua, NT_("Archive")); add_prompt(ua, NT_("Disabled")); add_prompt(ua, NT_("Full")); add_prompt(ua, NT_("Used")); add_prompt(ua, NT_("Cleaning")); if (strcmp(mr.VolStatus, NT_("Purged")) == 0) { add_prompt(ua, NT_("Recycle")); } add_prompt(ua, NT_("Read-Only")); if (do_prompt(ua, "", _("Choose new Volume Status"), ua->cmd, sizeof(mr.VolStatus)) < 0) { return 1; } update_volstatus(ua, ua->cmd, &mr); break; case 1: /* Retention */ ua->info_msg(_("Current retention period is: %s\n"), edit_utime(mr.VolRetention, ed1, sizeof(ed1))); if (!get_cmd(ua, _("Enter Volume Retention period: "))) { return 0; } update_volretention(ua, ua->cmd, &mr); break; case 2: /* Use Duration */ ua->info_msg(_("Current use duration is: %s\n"), edit_utime(mr.VolUseDuration, ed1, sizeof(ed1))); if (!get_cmd(ua, _("Enter Volume Use Duration: "))) { return 0; } update_voluseduration(ua, ua->cmd, &mr); break; case 3: /* Max Jobs */ ua->info_msg(_("Current max jobs is: %u\n"), mr.MaxVolJobs); if (!get_pint(ua, _("Enter new Maximum Jobs: "))) { return 0; } update_volmaxjobs(ua, ua->cmd, &mr); break; case 4: /* Max Files */ ua->info_msg(_("Current max files is: %u\n"), mr.MaxVolFiles); if (!get_pint(ua, _("Enter new Maximum Files: "))) { return 0; } update_volmaxfiles(ua, ua->cmd, &mr); break; case 5: /* Max Bytes */ ua->info_msg(_("Current value is: %s\n"), edit_uint64(mr.MaxVolBytes, ed1)); if (!get_cmd(ua, _("Enter new Maximum Bytes: "))) { return 0; } update_volmaxbytes(ua, ua->cmd, &mr); break; case 6: /* Recycle */ ua->info_msg(_("Current recycle flag is: %s\n"), mr.Recycle==1?_("yes"):_("no")); if (!get_yesno(ua, _("Enter new Recycle status: "))) { return 0; } update_volrecycle(ua, ua->cmd, &mr); break; case 7: /* Slot */ ua->info_msg(_("Current Slot is: %d\n"), mr.Slot); if (!get_pint(ua, _("Enter new Slot: "))) { return 0; } update_volslot(ua, ua->cmd, &mr); break; case 8: /* InChanger */ ua->info_msg(_("Current InChanger flag is: %d\n"), mr.InChanger); bsnprintf(buf, sizeof(buf), _("Set InChanger flag for Volume \"%s\": yes/no: "), mr.VolumeName); if (!get_yesno(ua, buf)) { return 0; } mr.InChanger = ua->pint32_val; /* * Make sure to use db_update... rather than doing this directly, * so that any Slot is handled correctly. */ if (!db_update_media_record(ua->jcr, ua->db, &mr)) { ua->error_msg(_("Error updating media record Slot: ERR=%s"), db_strerror(ua->db)); } else { ua->info_msg(_("New InChanger flag is: %d\n"), mr.InChanger); } break; case 9: /* Volume Files */ int32_t VolFiles; ua->warning_msg(_("Warning changing Volume Files can result\n" "in loss of data on your Volume\n\n")); ua->info_msg(_("Current Volume Files is: %u\n"), mr.VolFiles); if (!get_pint(ua, _("Enter new number of Files for Volume: "))) { return 0; } VolFiles = ua->pint32_val; if (VolFiles != (int)(mr.VolFiles + 1)) { ua->warning_msg(_("Normally, you should only increase Volume Files by one!\n")); if (!get_yesno(ua, _("Increase Volume Files? (yes/no): ")) || ua->pint32_val == 0) { break; } } query = get_pool_memory(PM_MESSAGE); Mmsg(query, "UPDATE Media SET VolFiles=%u WHERE MediaId=%s", VolFiles, edit_int64(mr.MediaId, ed1)); if (!db_sql_query(ua->db, query, NULL, NULL)) { ua->error_msg("%s", db_strerror(ua->db)); } else { ua->info_msg(_("New Volume Files is: %u\n"), VolFiles); } free_pool_memory(query); break; case 10: /* Volume's Pool */ memset(&pr, 0, sizeof(POOL_DBR)); pr.PoolId = mr.PoolId; if (!db_get_pool_record(ua->jcr, ua->db, &pr)) { ua->error_msg("%s", db_strerror(ua->db)); return 0; } ua->info_msg(_("Current Pool is: %s\n"), pr.Name); if (!get_cmd(ua, _("Enter new Pool name: "))) { return 0; } update_vol_pool(ua, ua->cmd, &mr, &pr); return 1; case 11: update_vol_from_pool(ua, &mr); return 1; case 12: pool = select_pool_resource(ua); if (pool) { update_all_vols_from_pool(ua, pool->name()); } return 1; case 13: update_all_vols(ua); return 1; case 14: ua->info_msg(_("Current Enabled is: %d\n"), mr.Enabled); if (!get_cmd(ua, _("Enter new Enabled: "))) { return 0; } if (strcasecmp(ua->cmd, "yes") == 0 || strcasecmp(ua->cmd, "true") == 0) { mr.Enabled = 1; } else if (strcasecmp(ua->cmd, "no") == 0 || strcasecmp(ua->cmd, "false") == 0) { mr.Enabled = 0; } else if (strcasecmp(ua->cmd, "archived") == 0) { mr.Enabled = 2; } else { mr.Enabled = atoi(ua->cmd); } update_volenabled(ua, ua->cmd, &mr); break; case 15: memset(&pr, 0, sizeof(POOL_DBR)); pr.PoolId = mr.RecyclePoolId; if (db_get_pool_record(ua->jcr, ua->db, &pr)) { ua->info_msg(_("Current RecyclePool is: %s\n"), pr.Name); } else { ua->info_msg(_("No current RecyclePool\n")); } if (!select_pool_dbr(ua, &pr, NT_("recyclepool"))) { return 0; } update_vol_recyclepool(ua, pr.Name, &mr); return 1; case 16: pm_strcpy(ret, ""); ua->info_msg(_("Current ActionOnPurge is: %s\n"), action_on_purge_to_string(mr.ActionOnPurge, ret)); if (!get_cmd(ua, _("Enter new ActionOnPurge (one of: Truncate, None): "))) { return 0; } update_vol_actiononpurge(ua, ua->cmd, &mr); break; default: /* Done or error */ ua->info_msg(_("Selection terminated.\n")); return 1; } } return 1; }
int main(int argc, char *argv[]) { /* Initialize our handles */ DB *dbp = NULL; DB_ENV *envp = NULL; thread_t writer_threads[NUMWRITERS]; int ch, i, ret, ret_t; u_int32_t env_flags; char *db_home_dir; /* Application name */ const char *prog_name = "txn_guide"; /* Database file name */ const char *file_name = "mydb.db"; /* Parse the command line arguments */ #ifdef _WIN32 db_home_dir = ".\\"; #else db_home_dir = "./"; #endif while ((ch = getopt(argc, argv, "h:")) != EOF) switch (ch) { case 'h': db_home_dir = optarg; break; case '?': default: return (usage()); } /* Create the environment */ ret = db_env_create(&envp, 0); if (ret != 0) { fprintf(stderr, "Error creating environment handle: %s\n", db_strerror(ret)); goto err; } /* * Indicate that we want db to perform lock detection internally. * Also indicate that the transaction with the fewest number of * write locks will receive the deadlock notification in * the event of a deadlock. */ ret = envp->set_lk_detect(envp, DB_LOCK_MINWRITE); if (ret != 0) { fprintf(stderr, "Error setting lock detect: %s\n", db_strerror(ret)); goto err; } env_flags = DB_CREATE | /* Create the environment if it does not exist */ DB_RECOVER | /* Run normal recovery. */ DB_INIT_LOCK | /* Initialize the locking subsystem */ DB_INIT_LOG | /* Initialize the logging subsystem */ DB_INIT_TXN | /* Initialize the transactional subsystem. This * also turns on logging. */ DB_INIT_MPOOL | /* Initialize the memory pool (in-memory cache) */ DB_THREAD; /* Cause the environment to be free-threaded */ /* Now actually open the environment */ ret = envp->open(envp, db_home_dir, env_flags, 0); if (ret != 0) { fprintf(stderr, "Error opening environment: %s\n", db_strerror(ret)); goto err; } /* * If we had utility threads (for running checkpoints or * deadlock detection, for example) we would spawn those * here. However, for a simple example such as this, * that is not required. */ /* Open the database */ ret = open_db(&dbp, prog_name, file_name, envp, DB_DUPSORT); if (ret != 0) goto err; /* Initialize a mutex. Used to help provide thread ids. */ (void)mutex_init(&thread_num_lock, NULL); /* Start the writer threads. */ for (i = 0; i < NUMWRITERS; i++) (void)thread_create( &writer_threads[i], NULL, writer_thread, (void *)dbp); /* Join the writers */ for (i = 0; i < NUMWRITERS; i++) (void)thread_join(writer_threads[i], NULL); err: /* Close our database handle, if it was opened. */ if (dbp != NULL) { ret_t = dbp->close(dbp, 0); if (ret_t != 0) { fprintf(stderr, "%s database close failed: %s\n", file_name, db_strerror(ret_t)); ret = ret_t; } } /* Close our environment, if it was opened. */ if (envp != NULL) { ret_t = envp->close(envp, 0); if (ret_t != 0) { fprintf(stderr, "environment close failed: %s\n", db_strerror(ret_t)); ret = ret_t; } } /* Final status message and return. */ printf("I'm all done.\n"); return (ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE); }
static void SLNFilterResultsWrite(SLNSessionRef const session, SLNFilterRef const filter, SLNFilterOpts *const opts, HTTPConnectionRef const conn) { // TODO: Accept count and use it for the total number of results. opts->count = 0; // We're sending a series of batches, so reversing one batch // doesn't make sense. opts->outdir = opts->dir; static strarg_t const fields[] = { "wait" }; str_t *values[numberof(fields)] = {}; QSValuesParse(qs, values, fields, numberof(fields)); bool const wait = parse_wait(values[0]); QSValuesCleanup(values, numberof(values)); // I'm aware that we're abusing HTTP for sending real-time push data. // I'd also like to support WebSocket at some point, but this is simpler // and frankly probably more widely supported. // Note that the protocol doesn't really break even if this data is // cached. It DOES break if a proxy tries to buffer the whole response // before passing it back to the client. I'd be curious to know whether // such proxies still exist in 2015. HTTPConnectionWriteResponse(conn, 200, "OK"); HTTPConnectionWriteHeader(conn, "Transfer-Encoding", "chunked"); HTTPConnectionWriteHeader(conn, "Content-Type", "text/uri-list; charset=utf-8"); HTTPConnectionWriteHeader(conn, "Cache-Control", "no-store"); HTTPConnectionWriteHeader(conn, "Vary", "*"); HTTPConnectionBeginBody(conn); int rc; for(;;) { rc = sendURIBatch(session, filter, opts, conn); if(DB_NOTFOUND == rc) break; if(DB_SUCCESS == rc) continue; fprintf(stderr, "Query error: %s\n", db_strerror(rc)); goto cleanup; } if(!wait || opts->dir < 0) goto cleanup; SLNRepoRef const repo = SLNSessionGetRepo(session); for(;;) { uint64_t const timeout = uv_now(async_loop)+(1000 * 30); rc = SLNRepoSubmissionWait(repo, opts->sortID, timeout); if(UV_ETIMEDOUT == rc) { uv_buf_t const parts[] = { uv_buf_init((char *)STR_LEN("\r\n")) }; rc = HTTPConnectionWriteChunkv(conn, parts, numberof(parts)); if(rc < 0) break; continue; } assert(rc >= 0); // TODO: Handle cancellation? for(;;) { rc = sendURIBatch(session, filter, opts, conn); if(DB_NOTFOUND == rc) break; if(DB_SUCCESS == rc) continue; fprintf(stderr, "Query error: %s\n", db_strerror(rc)); goto cleanup; } } cleanup: HTTPConnectionWriteChunkEnd(conn); HTTPConnectionEnd(conn); SLNFilterOptsCleanup(opts); }
/* ------------------------ */ cnid_t cnid_cdb_rebuild_add(struct _cnid_db *cdb, const struct stat *st, const cnid_t did, char *name, const size_t len, cnid_t hint) { CNID_private *db; DBT key, data; int rc; if (!cdb || !(db = cdb->_private) || !st || !name || hint == CNID_INVALID || hint < CNID_START) { errno = CNID_ERR_PARAM; return CNID_INVALID; } #if 0 /* FIXME: Bjoern does a lookup. Should we not overwrite unconditionally? */ /* Do a lookup. */ id = cnid_cdb_lookup(cdb, st, did, name, len); /* ... Return id if it is valid, or if Rootinfo is read-only. */ if (id || (db->flags & CNIDFLAG_DB_RO)) { #ifdef DEBUG LOG(log_debug9, logtype_default, "cnid_add: Looked up did %u, name %s as %u", ntohl(did), name, ntohl(id)); #endif return id; } #endif /* Initialize our DBT data structures. */ memset(&key, 0, sizeof(key)); memset(&data, 0, sizeof(data)); if ((data.data = make_cnid_data(cdb->flags, st, did, name, len)) == NULL) { LOG(log_error, logtype_default, "cnid_add: Path name is too long"); errno = CNID_ERR_PATH; return CNID_INVALID; } data.size = CNID_HEADER_LEN + len + 1; memcpy(data.data, &hint, sizeof(hint)); key.data = &hint; key.size = sizeof(hint); /* Now we need to add the CNID data to the databases. */ if ((rc = db->db_cnid->put(db->db_cnid, tid, &key, &data, 0))) { LOG(log_error, logtype_default , "cnid_add: Failed to add CNID for %s to database using hint %u: %s", name, ntohl(hint), db_strerror(rc)); errno = CNID_ERR_DB; goto cleanup; } if (set_max_cnid(db, hint) == CNID_INVALID) { errno = CNID_ERR_DB; goto cleanup; } #ifdef DEBUG LOG(log_debug9, logtype_default, "cnid_add: Returned CNID for did %u, name %s as %u", ntohl(did), name, ntohl(hint)); #endif return hint; cleanup: return CNID_INVALID; }
int bdb_tool_entry_reindex( BackendDB *be, ID id, AttributeDescription **adv ) { struct bdb_info *bi = (struct bdb_info *) be->be_private; int rc; Entry *e; DB_TXN *tid = NULL; Operation op = {0}; Opheader ohdr = {0}; Debug( LDAP_DEBUG_ARGS, "=> " LDAP_XSTRING(bdb_tool_entry_reindex) "( %ld )\n", (long) id, 0, 0 ); assert( tool_base == NULL ); assert( tool_filter == NULL ); /* No indexes configured, nothing to do. Could return an * error here to shortcut things. */ if (!bi->bi_attrs) { return 0; } /* Check for explicit list of attrs to index */ if ( adv ) { int i, j, n; if ( bi->bi_attrs[0]->ai_desc != adv[0] ) { /* count */ for ( n = 0; adv[n]; n++ ) ; /* insertion sort */ for ( i = 0; i < n; i++ ) { AttributeDescription *ad = adv[i]; for ( j = i-1; j>=0; j--) { if ( SLAP_PTRCMP( adv[j], ad ) <= 0 ) break; adv[j+1] = adv[j]; } adv[j+1] = ad; } } for ( i = 0; adv[i]; i++ ) { if ( bi->bi_attrs[i]->ai_desc != adv[i] ) { for ( j = i+1; j < bi->bi_nattrs; j++ ) { if ( bi->bi_attrs[j]->ai_desc == adv[i] ) { AttrInfo *ai = bi->bi_attrs[i]; bi->bi_attrs[i] = bi->bi_attrs[j]; bi->bi_attrs[j] = ai; break; } } if ( j == bi->bi_nattrs ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_tool_entry_reindex) ": no index configured for %s\n", adv[i]->ad_cname.bv_val, 0, 0 ); return -1; } } } bi->bi_nattrs = i; } /* Get the first attribute to index */ if (bi->bi_linear_index && !index_nattrs) { index_nattrs = bi->bi_nattrs - 1; bi->bi_nattrs = 1; } e = bdb_tool_entry_get( be, id ); if( e == NULL ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_tool_entry_reindex) ": could not locate id=%ld\n", (long) id, 0, 0 ); return -1; } if (! (slapMode & SLAP_TOOL_QUICK)) { rc = TXN_BEGIN( bi->bi_dbenv, NULL, &tid, bi->bi_db_opflags ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_reindex) ": " "txn_begin failed: %s (%d)\n", db_strerror(rc), rc, 0 ); goto done; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_tool_entry_reindex) ": txn id: %x\n", tid->id(tid), 0, 0 ); } /* * just (re)add them for now * assume that some other routine (not yet implemented) * will zap index databases * */ Debug( LDAP_DEBUG_TRACE, "=> " LDAP_XSTRING(bdb_tool_entry_reindex) "( %ld, \"%s\" )\n", (long) id, e->e_dn, 0 ); op.o_hdr = &ohdr; op.o_bd = be; op.o_tmpmemctx = NULL; op.o_tmpmfuncs = &ch_mfuncs; rc = bdb_tool_index_add( &op, tid, e ); done: if( rc == 0 ) { if (! (slapMode & SLAP_TOOL_QUICK)) { rc = TXN_COMMIT( tid, 0 ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_reindex) ": txn_commit failed: %s (%d)\n", db_strerror(rc), rc, 0 ); e->e_id = NOID; } } } else { if (! (slapMode & SLAP_TOOL_QUICK)) { TXN_ABORT( tid ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_reindex) ": txn_aborted! %s (%d)\n", db_strerror(rc), rc, 0 ); } e->e_id = NOID; } bdb_entry_release( &op, e, 0 ); return rc; }
int find_record(struct bdb_t *bdbp, DBT **dbt_ptr, void *key_ptr, size_t key_len, size_t *value_len) { assert(dbt_ptr != NULL); assert(key_ptr != NULL); assert(value_len != NULL); void *value_ptr = NULL; int ret; DBT query_cond; int alloc_flag; alloc_flag = 0; if (*dbt_ptr == NULL) { if ((*dbt_ptr = slab_alloc(sizeof **dbt_ptr)) == NULL) { ret = -1; REPORT_ERR("memory is not enough"); } alloc_flag = alloc_flag | FIND_RECORD_ALLOC_DBT_PTR; } if ((value_ptr = slab_alloc(*value_len)) == NULL) { ret = -1; REPORT_ERR("memory is not enough"); } alloc_flag = alloc_flag | FIND_RECORD_ALLOC_VAL_PTR; memset(&query_cond, 0, sizeof query_cond); memset(*dbt_ptr, 0, sizeof **dbt_ptr); memset(value_ptr, 0, *value_len); query_cond.data = key_ptr; query_cond.size = key_len; (*dbt_ptr)->data = value_ptr; (*dbt_ptr)->ulen = *value_len; (*dbt_ptr)->flags = DB_DBT_USERMEM; BUILD_DB_PREFIX; if ((ret = bdbp->dbp->get(bdbp->dbp, NULL, &query_cond, *dbt_ptr, 0)) != 0) { if (ret != DB_NOTFOUND) REPORT_ERR("bdb query failed: %s", db_strerror(ret)); } err: if (ret != 0) { if ((alloc_flag & FIND_RECORD_ALLOC_DBT_PTR) && (*dbt_ptr != NULL)) { slab_free(*dbt_ptr); *dbt_ptr = NULL; } if ((alloc_flag & FIND_RECORD_ALLOC_VAL_PTR) && (value_ptr != NULL)) { slab_free(value_ptr); if (*dbt_ptr != NULL) (*dbt_ptr)->data = NULL; } } return ret; }
ID bdb_tool_entry_modify( BackendDB *be, Entry *e, struct berval *text ) { int rc; struct bdb_info *bdb; DB_TXN *tid = NULL; Operation op = {0}; Opheader ohdr = {0}; assert( be != NULL ); assert( slapMode & SLAP_TOOL_MODE ); assert( text != NULL ); assert( text->bv_val != NULL ); assert( text->bv_val[0] == '\0' ); /* overconservative? */ assert ( e->e_id != NOID ); Debug( LDAP_DEBUG_TRACE, "=> " LDAP_XSTRING(bdb_tool_entry_modify) "( %ld, \"%s\" )\n", (long) e->e_id, e->e_dn, 0 ); bdb = (struct bdb_info *) be->be_private; if (! (slapMode & SLAP_TOOL_QUICK)) { if( cursor ) { cursor->c_close( cursor ); cursor = NULL; } rc = TXN_BEGIN( bdb->bi_dbenv, NULL, &tid, bdb->bi_db_opflags ); if( rc != 0 ) { snprintf( text->bv_val, text->bv_len, "txn_begin failed: %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_modify) ": %s\n", text->bv_val, 0, 0 ); return NOID; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_tool_entry_modify) ": txn id: %x\n", tid->id(tid), 0, 0 ); } op.o_hdr = &ohdr; op.o_bd = be; op.o_tmpmemctx = NULL; op.o_tmpmfuncs = &ch_mfuncs; /* id2entry index */ rc = bdb_id2entry_update( be, tid, e ); if( rc != 0 ) { snprintf( text->bv_val, text->bv_len, "id2entry_add failed: %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_modify) ": %s\n", text->bv_val, 0, 0 ); goto done; } done: if( rc == 0 ) { if (! (slapMode & SLAP_TOOL_QUICK)) { rc = TXN_COMMIT( tid, 0 ); if( rc != 0 ) { snprintf( text->bv_val, text->bv_len, "txn_commit failed: %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_modify) ": " "%s\n", text->bv_val, 0, 0 ); e->e_id = NOID; } } } else { if (! (slapMode & SLAP_TOOL_QUICK)) { TXN_ABORT( tid ); snprintf( text->bv_val, text->bv_len, "txn_aborted! %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_modify) ": %s\n", text->bv_val, 0, 0 ); } e->e_id = NOID; } if ( cursor == NULL ) { int rc = bdb->bi_id2entry->bdi_db->cursor( bdb->bi_id2entry->bdi_db, bdb->bi_cache.c_txn, &cursor, bdb->bi_db_opflags ); if ( rc != 0 ) e->e_id = NOID; } return e->e_id; }
static void tags_cache_gc (struct tags_cache *c) { DBC *cur; DBT key; DBT serialized_cache_rec; int ret; char *last_referenced = NULL; time_t last_referenced_atime = time (NULL) + 1; int nitems = 0; c->db->cursor (c->db, NULL, &cur, 0); memset (&key, 0, sizeof(key)); memset (&serialized_cache_rec, 0, sizeof(serialized_cache_rec)); key.flags = DB_DBT_MALLOC; serialized_cache_rec.flags = DB_DBT_MALLOC; while (true) { struct cache_record rec; #if DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR < 6 ret = cur->c_get (cur, &key, &serialized_cache_rec, DB_NEXT); #else ret = cur->get (cur, &key, &serialized_cache_rec, DB_NEXT); #endif if (ret != 0) break; if (cache_record_deserialize (&rec, serialized_cache_rec.data, serialized_cache_rec.size, 1) && rec.atime < last_referenced_atime) { last_referenced_atime = rec.atime; if (last_referenced) free (last_referenced); last_referenced = (char *)xmalloc (key.size + 1); memcpy (last_referenced, key.data, key.size); last_referenced[key.size] = '\0'; } // TODO: remove objects with serialization error. nitems++; free (key.data); free (serialized_cache_rec.data); } if (ret != DB_NOTFOUND) logit ("Searching for element to remove failed (cursor): %s", db_strerror (ret)); #if DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR < 6 cur->c_close (cur); #else cur->close (cur); #endif debug ("Elements in cache: %d (limit %d)", nitems, c->max_items); if (last_referenced) { if (nitems >= c->max_items) tags_cache_remove_rec (c, last_referenced); free (last_referenced); } else debug ("Cache empty"); }
int listusers(const char *path, listcb_t *cb) { int result; DB *mbdb = NULL; DBC *cursor; DBT key, data; /* open the db */ result=berkeleydb_open(path, &mbdb); if (result!=SASL_OK) goto cleanup; /* make cursor */ #if DB_VERSION_FULL < 0x03060000 result = mbdb->cursor(mbdb, NULL,&cursor); #else result = mbdb->cursor(mbdb, NULL,&cursor, 0); #endif /* DB_VERSION_FULL < 0x03060000 */ if (result!=0) { fprintf(stderr,"Making cursor failure: %s\n",db_strerror(result)); result = SASL_FAIL; goto cleanup; } memset(&key,0, sizeof(key)); memset(&data,0,sizeof(data)); /* loop thru */ result = cursor->c_get(cursor, &key, &data, DB_FIRST); while (result != DB_NOTFOUND) { char *authid; char *realm; char *tmp; unsigned int len; char mech[1024]; int numnulls = 0; unsigned int lup; /* make sure there are exactly 2 null's */ for (lup=0;lup<key.size;lup++) if (((char *)key.data)[lup]=='\0') numnulls++; if (numnulls != 2) { fprintf(stderr,"warning: probable database corruption\n"); result = cursor->c_get(cursor, &key, &data, DB_NEXT); continue; } authid = key.data; realm = authid + strlen(authid)+1; tmp = realm + strlen(realm)+1; len = key.size - (tmp - authid); /* make sure we have enough space of mech */ if (len >=sizeof(mech)) { fprintf(stderr,"warning: absurdly long mech name\n"); result = cursor->c_get(cursor, &key, &data, DB_NEXT); continue; } memcpy(mech, tmp, key.size - (tmp - ((char *)key.data))); mech[key.size - (tmp - ((char *)key.data))] = '\0'; if (*authid) { /* don't check return values */ cb(authid,realm,mech,data.data,data.size); } result = cursor->c_get(cursor, &key, &data, DB_NEXT); } if (result != DB_NOTFOUND) { fprintf(stderr,"failure: %s\n",db_strerror(result)); result = SASL_FAIL; goto cleanup; } result = cursor->c_close(cursor); if (result!=0) result = SASL_FAIL; result = SASL_OK; cleanup: if (mbdb != NULL) berkeleydb_close(mbdb); return result; }
int getInfo(int id) { DB_ENV *dbenv = radacct_dbenv; DB *dbp = radacct_dbp; DB_TXN *tid = NULL; DBT key, data; db_recno_t recno; int info = 0; char buf[REC_SIZE]; int ret; clock_t t1, t2; clock_t t3, t4; struct tms buf1, buf2; struct tms buf3, buf4; memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); key.data = &recno; key.size = key.ulen = sizeof(recno); key.flags = DB_DBT_USERMEM; data.data = buf; data.ulen = sizeof(buf); data.flags = DB_DBT_USERMEM; if((ret = dbenv->txn_begin(dbenv, NULL, &tid, 0)) != 0) { printf("getInfo: transaction failed: %s\n", db_strerror(ret)); return 0; } t1 = times(&buf1); ret = dbp->get(dbp, tid, &key, &data, DB_CONSUME); t2 = times(&buf2); get_total_time[id] += (t2 - t1); get_time_buf[id].tms_utime += (buf2.tms_utime - buf1.tms_utime); get_time_buf[id].tms_stime += (buf2.tms_stime - buf1.tms_stime); get_time_buf[id].tms_cutime += (buf2.tms_cutime - buf1.tms_cutime); get_time_buf[id].tms_cstime += (buf2.tms_cstime - buf1.tms_cstime); switch(ret) { case DB_LOCK_DEADLOCK: printf("getInfo: deadlock: %s\n", db_strerror(ret)); break; case 0: t3 = times(&buf3); removeInfo(tid); t4 = times(&buf4); remove_total_time[id] = (t4 - t3); remove_time_buf[id].tms_utime += (buf4.tms_utime - buf3.tms_utime); remove_time_buf[id].tms_stime += (buf4.tms_stime - buf3.tms_stime); remove_time_buf[id].tms_cutime += (buf4.tms_cutime - buf3.tms_cutime); remove_time_buf[id].tms_cstime += (buf4.tms_cstime - buf3.tms_cstime); break; default: printf("getInfo: oops: %d\n", ret); break; } return info; }
static int bdb_db_open( BackendDB *be, ConfigReply *cr ) { int rc, i; struct bdb_info *bdb = (struct bdb_info *) be->be_private; struct stat stat1, stat2; u_int32_t flags; char path[MAXPATHLEN]; char *dbhome; Entry *e = NULL; int do_recover = 0, do_alock_recover = 0; int alockt, quick = 0; int do_retry = 1; if ( be->be_suffix == NULL ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": need suffix.\n", 1, 0, 0 ); return -1; } Debug( LDAP_DEBUG_ARGS, LDAP_XSTRING(bdb_db_open) ": \"%s\"\n", be->be_suffix[0].bv_val, 0, 0 ); /* Check existence of dbenv_home. Any error means trouble */ rc = stat( bdb->bi_dbenv_home, &stat1 ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "cannot access database directory \"%s\" (%d).\n", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, errno ); return -1; } /* Perform database use arbitration/recovery logic */ alockt = (slapMode & SLAP_TOOL_READONLY) ? ALOCK_LOCKED : ALOCK_UNIQUE; if ( slapMode & SLAP_TOOL_QUICK ) { alockt |= ALOCK_NOSAVE; quick = 1; } rc = alock_open( &bdb->bi_alock_info, "slapd", bdb->bi_dbenv_home, alockt ); /* alockt is TRUE if the existing environment was created in Quick mode */ alockt = (rc & ALOCK_NOSAVE) ? 1 : 0; rc &= ~ALOCK_NOSAVE; if( rc == ALOCK_RECOVER ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "unclean shutdown detected; attempting recovery.\n", be->be_suffix[0].bv_val, 0, 0 ); do_alock_recover = 1; do_recover = DB_RECOVER; } else if( rc == ALOCK_BUSY ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "database already in use.\n", be->be_suffix[0].bv_val, 0, 0 ); return -1; } else if( rc != ALOCK_CLEAN ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "alock package is unstable.\n", be->be_suffix[0].bv_val, 0, 0 ); return -1; } if ( rc == ALOCK_CLEAN ) be->be_flags |= SLAP_DBFLAG_CLEAN; /* * The DB_CONFIG file may have changed. If so, recover the * database so that new settings are put into effect. Also * note the possible absence of DB_CONFIG in the log. */ if( stat( bdb->bi_db_config_path, &stat1 ) == 0 ) { if ( !do_recover ) { char *ptr = lutil_strcopy(path, bdb->bi_dbenv_home); *ptr++ = LDAP_DIRSEP[0]; strcpy( ptr, "__db.001" ); if( stat( path, &stat2 ) == 0 ) { if( stat2.st_mtime < stat1.st_mtime ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": DB_CONFIG for suffix \"%s\" has changed.\n", be->be_suffix[0].bv_val, 0, 0 ); if ( quick ) { Debug( LDAP_DEBUG_ANY, "Cannot use Quick mode; perform manual recovery first.\n", 0, 0, 0 ); slapMode ^= SLAP_TOOL_QUICK; rc = -1; goto fail; } else { Debug( LDAP_DEBUG_ANY, "Performing database recovery to activate new settings.\n", 0, 0, 0 ); } do_recover = DB_RECOVER; } } } } else { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": warning - no DB_CONFIG file found " "in directory %s: (%d).\n" "Expect poor performance for suffix \"%s\".\n", bdb->bi_dbenv_home, errno, be->be_suffix[0].bv_val ); } /* Always let slapcat run, regardless of environment state. * This can be used to cause a cache flush after an unclean * shutdown. */ if ( do_recover && ( slapMode & SLAP_TOOL_READONLY )) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "recovery skipped in read-only mode. " "Run manual recovery if errors are encountered.\n", be->be_suffix[0].bv_val, 0, 0 ); do_recover = 0; do_alock_recover = 0; quick = alockt; } /* An existing environment in Quick mode has nothing to recover. */ if ( alockt && do_recover ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "cannot recover, database must be reinitialized.\n", be->be_suffix[0].bv_val, 0, 0 ); rc = -1; goto fail; } rc = db_env_create( &bdb->bi_dbenv, 0 ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "db_env_create failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); goto fail; } #ifdef HAVE_EBCDIC strcpy( path, bdb->bi_dbenv_home ); __atoe( path ); dbhome = path; #else dbhome = bdb->bi_dbenv_home; #endif /* If existing environment is clean but doesn't support * currently requested modes, remove it. */ if ( !do_recover && ( alockt ^ quick )) { shm_retry: rc = bdb->bi_dbenv->remove( bdb->bi_dbenv, dbhome, DB_FORCE ); if ( rc ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "dbenv remove failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); bdb->bi_dbenv = NULL; goto fail; } rc = db_env_create( &bdb->bi_dbenv, 0 ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "db_env_create failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); goto fail; } } bdb->bi_dbenv->set_errpfx( bdb->bi_dbenv, be->be_suffix[0].bv_val ); bdb->bi_dbenv->set_errcall( bdb->bi_dbenv, bdb_errcall ); bdb->bi_dbenv->set_lk_detect( bdb->bi_dbenv, bdb->bi_lock_detect ); if ( !BER_BVISNULL( &bdb->bi_db_crypt_key )) { rc = bdb->bi_dbenv->set_encrypt( bdb->bi_dbenv, bdb->bi_db_crypt_key.bv_val, DB_ENCRYPT_AES ); if ( rc ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "dbenv set_encrypt failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); goto fail; } } /* One long-lived TXN per thread, two TXNs per write op */ bdb->bi_dbenv->set_tx_max( bdb->bi_dbenv, connection_pool_max * 3 ); if( bdb->bi_dbenv_xflags != 0 ) { rc = bdb->bi_dbenv->set_flags( bdb->bi_dbenv, bdb->bi_dbenv_xflags, 1); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "dbenv_set_flags failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); goto fail; } } #define BDB_TXN_FLAGS (DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_TXN) Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "dbenv_open(%s).\n", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, 0); flags = DB_INIT_MPOOL | DB_CREATE | DB_THREAD; if ( !quick ) flags |= BDB_TXN_FLAGS; /* If a key was set, use shared memory for the BDB environment */ if ( bdb->bi_shm_key ) { bdb->bi_dbenv->set_shm_key( bdb->bi_dbenv, bdb->bi_shm_key ); flags |= DB_SYSTEM_MEM; } rc = (bdb->bi_dbenv->open)( bdb->bi_dbenv, dbhome, flags | do_recover, bdb->bi_dbenv_mode ); if ( rc ) { /* Regular open failed, probably a missing shm environment. * Start over, do a recovery. */ if ( !do_recover && bdb->bi_shm_key && do_retry ) { bdb->bi_dbenv->close( bdb->bi_dbenv, 0 ); rc = db_env_create( &bdb->bi_dbenv, 0 ); if( rc == 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "shared memory env open failed, assuming stale env.\n", be->be_suffix[0].bv_val, 0, 0 ); do_retry = 0; goto shm_retry; } } Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\" cannot be %s, err %d. " "Restore from backup!\n", be->be_suffix[0].bv_val, do_recover ? "recovered" : "opened", rc ); goto fail; } if ( do_alock_recover && alock_recover (&bdb->bi_alock_info) != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": alock_recover failed\n", be->be_suffix[0].bv_val, 0, 0 ); rc = -1; goto fail; } #ifdef SLAP_ZONE_ALLOC if ( bdb->bi_cache.c_maxsize ) { bdb->bi_cache.c_zctx = slap_zn_mem_create( SLAP_ZONE_INITSIZE, SLAP_ZONE_MAXSIZE, SLAP_ZONE_DELTA, SLAP_ZONE_SIZE); } #endif /* dncache defaults to 0 == unlimited * must be >= entrycache */ if ( bdb->bi_cache.c_eimax && bdb->bi_cache.c_eimax < bdb->bi_cache.c_maxsize ) { bdb->bi_cache.c_eimax = bdb->bi_cache.c_maxsize; } if ( bdb->bi_idl_cache_max_size ) { bdb->bi_idl_tree = NULL; bdb->bi_idl_cache_size = 0; } flags = DB_THREAD | bdb->bi_db_opflags; #ifdef DB_AUTO_COMMIT if ( !quick ) flags |= DB_AUTO_COMMIT; #endif bdb->bi_databases = (struct bdb_db_info **) ch_malloc( BDB_INDICES * sizeof(struct bdb_db_info *) ); /* open (and create) main database */ for( i = 0; bdbi_databases[i].name.bv_val; i++ ) { struct bdb_db_info *db; db = (struct bdb_db_info *) ch_calloc(1, sizeof(struct bdb_db_info)); rc = db_create( &db->bdi_db, bdb->bi_dbenv, 0 ); if( rc != 0 ) { snprintf(cr->msg, sizeof(cr->msg), "database \"%s\": db_create(%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); goto fail; } if( !BER_BVISNULL( &bdb->bi_db_crypt_key )) { rc = db->bdi_db->set_flags( db->bdi_db, DB_ENCRYPT ); if ( rc ) { snprintf(cr->msg, sizeof(cr->msg), "database \"%s\": db set_flags(DB_ENCRYPT)(%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); goto fail; } } if( bdb->bi_flags & BDB_CHKSUM ) { rc = db->bdi_db->set_flags( db->bdi_db, DB_CHKSUM ); if ( rc ) { snprintf(cr->msg, sizeof(cr->msg), "database \"%s\": db set_flags(DB_CHKSUM)(%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); goto fail; } } rc = bdb_db_findsize( bdb, (struct berval *)&bdbi_databases[i].name ); if( i == BDB_ID2ENTRY ) { if ( !rc ) rc = BDB_ID2ENTRY_PAGESIZE; rc = db->bdi_db->set_pagesize( db->bdi_db, rc ); if ( slapMode & SLAP_TOOL_MODE ) db->bdi_db->mpf->set_priority( db->bdi_db->mpf, DB_PRIORITY_VERY_LOW ); if ( slapMode & SLAP_TOOL_READMAIN ) { flags |= DB_RDONLY; } else { flags |= DB_CREATE; } } else { /* Use FS default size if not configured */ if ( rc ) rc = db->bdi_db->set_pagesize( db->bdi_db, rc ); rc = db->bdi_db->set_flags( db->bdi_db, DB_DUP | DB_DUPSORT ); #ifndef BDB_HIER if ( slapMode & SLAP_TOOL_READONLY ) { flags |= DB_RDONLY; } else { flags |= DB_CREATE; } #else rc = db->bdi_db->set_dup_compare( db->bdi_db, bdb_dup_compare ); if ( slapMode & (SLAP_TOOL_READONLY|SLAP_TOOL_READMAIN) ) { flags |= DB_RDONLY; } else { flags |= DB_CREATE; } #endif } #ifdef HAVE_EBCDIC strcpy( path, bdbi_databases[i].file ); __atoe( path ); rc = DB_OPEN( db->bdi_db, path, /* bdbi_databases[i].name, */ NULL, bdbi_databases[i].type, bdbi_databases[i].flags | flags, bdb->bi_dbenv_mode ); #else rc = DB_OPEN( db->bdi_db, bdbi_databases[i].file, /* bdbi_databases[i].name, */ NULL, bdbi_databases[i].type, bdbi_databases[i].flags | flags, bdb->bi_dbenv_mode ); #endif if ( rc != 0 ) { snprintf( cr->msg, sizeof(cr->msg), "database \"%s\": " "db_open(%s/%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, bdbi_databases[i].file, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); db->bdi_db->close( db->bdi_db, 0 ); goto fail; } flags &= ~(DB_CREATE | DB_RDONLY); db->bdi_name = bdbi_databases[i].name; bdb->bi_databases[i] = db; } bdb->bi_databases[i] = NULL; bdb->bi_ndatabases = i; /* get nextid */ rc = bdb_last_id( be, NULL ); if( rc != 0 ) { snprintf( cr->msg, sizeof(cr->msg), "database \"%s\": " "last_id(%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); goto fail; } if ( !quick ) { TXN_BEGIN(bdb->bi_dbenv, NULL, &bdb->bi_cache.c_txn, DB_READ_COMMITTED | DB_TXN_NOWAIT); } entry_prealloc( bdb->bi_cache.c_maxsize ); attr_prealloc( bdb->bi_cache.c_maxsize * 20 ); /* setup for empty-DN contexts */ if ( BER_BVISEMPTY( &be->be_nsuffix[0] )) { rc = bdb_id2entry( be, NULL, 0, &e ); } if ( !e ) { struct berval gluebv = BER_BVC("glue"); Operation op = {0}; Opheader ohdr = {0}; e = entry_alloc(); e->e_id = 0; ber_dupbv( &e->e_name, (struct berval *)&slap_empty_bv ); ber_dupbv( &e->e_nname, (struct berval *)&slap_empty_bv ); attr_merge_one( e, slap_schema.si_ad_objectClass, &gluebv, NULL ); attr_merge_one( e, slap_schema.si_ad_structuralObjectClass, &gluebv, NULL ); op.o_hdr = &ohdr; op.o_bd = be; op.ora_e = e; op.o_dn = be->be_rootdn; op.o_ndn = be->be_rootndn; slap_add_opattrs( &op, NULL, NULL, 0, 0 ); } e->e_ocflags = SLAP_OC_GLUE|SLAP_OC__END; e->e_private = &bdb->bi_cache.c_dntree; bdb->bi_cache.c_dntree.bei_e = e; /* monitor setup */ rc = bdb_monitor_db_open( be ); if ( rc != 0 ) { goto fail; } bdb->bi_flags |= BDB_IS_OPEN; return 0; fail: bdb_db_close( be, NULL ); return rc; }
int main(void) { /* Initialize our handles */ DB *dbp = NULL; DB_ENV *envp = NULL; thread_t writer_threads[NUMWRITERS]; int i, ret, ret_t; u_int32_t env_flags; /* Application name */ const char *prog_name = "txn_guide_inmemory"; /* Create the environment */ ret = db_env_create(&envp, 0); if (ret != 0) { fprintf(stderr, "Error creating environment handle: %s\n", db_strerror(ret)); goto err; } env_flags = DB_CREATE | /* Create the environment if it does not exist */ DB_INIT_LOCK | /* Initialize the locking subsystem */ DB_INIT_LOG | /* Initialize the logging subsystem */ DB_INIT_TXN | /* Initialize the transactional subsystem. This * also turns on logging. */ DB_INIT_MPOOL | /* Initialize the memory pool (in-memory cache) */ DB_PRIVATE | /* Region files are backed by heap memory. */ DB_THREAD; /* Cause the environment to be free-threaded */ /* Specify in-memory logging */ ret = envp->log_set_config(envp, DB_LOG_IN_MEMORY, 1); if (ret != 0) { fprintf(stderr, "Error setting log subsystem to in-memory: %s\n", db_strerror(ret)); goto err; } /* * Specify the size of the in-memory log buffer. */ ret = envp->set_lg_bsize(envp, 10 * 1024 * 1024); if (ret != 0) { fprintf(stderr, "Error increasing the log buffer size: %s\n", db_strerror(ret)); goto err; } /* * Specify the size of the in-memory cache. */ ret = envp->set_cachesize(envp, 0, 10 * 1024 * 1024, 1); if (ret != 0) { fprintf(stderr, "Error increasing the cache size: %s\n", db_strerror(ret)); goto err; } /* * Indicate that we want db to perform lock detection internally. * Also indicate that the transaction with the fewest number of * write locks will receive the deadlock notification in * the event of a deadlock. */ ret = envp->set_lk_detect(envp, DB_LOCK_MINWRITE); if (ret != 0) { fprintf(stderr, "Error setting lock detect: %s\n", db_strerror(ret)); goto err; } /* Now actually open the environment */ ret = envp->open(envp, NULL, env_flags, 0); if (ret != 0) { fprintf(stderr, "Error opening environment: %s\n", db_strerror(ret)); goto err; } /* * If we had utility threads (for running checkpoints or * deadlock detection, for example) we would spawn those * here. However, for a simple example such as this, * that is not required. */ /* Open the database */ ret = open_db(&dbp, prog_name, NULL, envp, DB_DUPSORT); if (ret != 0) goto err; /* Initialize a mutex. Used to help provide thread ids. */ (void)mutex_init(&thread_num_lock, NULL); /* Start the writer threads. */ for (i = 0; i < NUMWRITERS; i++) (void)thread_create( &writer_threads[i], NULL, writer_thread, (void *)dbp); /* Join the writers */ for (i = 0; i < NUMWRITERS; i++) (void)thread_join(writer_threads[i], NULL); err: /* Close our database handle, if it was opened. */ if (dbp != NULL) { ret_t = dbp->close(dbp, 0); if (ret_t != 0) { fprintf(stderr, "%s database close failed.\n", db_strerror(ret_t)); ret = ret_t; } } /* Close our environment, if it was opened. */ if (envp != NULL) { ret_t = envp->close(envp, 0); if (ret_t != 0) { fprintf(stderr, "environment close failed: %s\n", db_strerror(ret_t)); ret = ret_t; } } /* Final status message and return. */ printf("I'm all done.\n"); return (ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE); }
int gw_acct_db_open(gw_boolean_t server) { int rc; u_int32_t flags; u_int32_t env_flags; DB *db; DB_ENV *db_env; char env_dir[PATH_MAX]; char * gw_location; mode_t mask; gw_location = getenv("GW_LOCATION"); if ( gw_location == NULL) { if (server == GW_TRUE) gw_log_print("GW",'E',"Variable GW_LOCATION is not defined.\n"); else fprintf(stderr,"Variable GW_LOCATION is not defined!\n"); return -1; } snprintf(env_dir, PATH_MAX-1, "%s/" GW_VAR_DIR "/acct/", gw_location); /* ----- Open the environment ------ */ mask = umask(002); rc = db_env_create(&(gw_acct_db.env_db), 0); if ( rc != 0 ) { if (server == GW_TRUE) gw_log_print("DB",'E',"Error initializing environment structure (%s).\n", db_strerror(rc)); else fprintf(stderr,"Error initializing environment structure (%s).\n", db_strerror(rc)); return -1; } db_env = gw_acct_db.env_db; env_flags = DB_INIT_CDB | DB_INIT_MPOOL; if (server == GW_TRUE) env_flags = env_flags | DB_CREATE | DB_THREAD; rc = db_env->open(db_env,env_dir,env_flags,0664); if (rc!=0) { if (server == GW_TRUE) gw_log_print("DB",'E',"Error openning environment (%s).\n",db_strerror(rc)); else fprintf(stderr,"Error openning environment (%s).\n",db_strerror(rc)); return -1; } umask(mask); /* ----- Primary Database, acct.db ------ */ rc = db_create(&(gw_acct_db.acct_db), db_env, 0); if ( rc != 0 ) { if (server == GW_TRUE) gw_log_print("DB",'E',"Error initializing database structure (%s).\n", db_strerror(rc)); else fprintf(stderr,"Error initializing database structure (%s).\n", db_strerror(rc)); return -1; } db = gw_acct_db.acct_db; if (server == GW_TRUE) { db->set_errcall(db,gw_acct_db_error); db->set_errpfx(db,"ACCT-DB"); flags = DB_CREATE | DB_THREAD; } else flags = DB_RDONLY; rc = db->open(db, NULL, "acct.db", NULL, DB_BTREE, flags, 0644); if (rc!=0) { if (server == GW_TRUE) gw_log_print("DB",'E',"Error openning database.\n"); else fprintf(stderr,"Error openning database.\n"); return -1; } /* ----- Secondary Database (user index), uidx.db ------ */ rc = db_create(&(gw_acct_db.uinx_db), db_env, 0); if ( rc != 0 ) { if (server == GW_TRUE) gw_log_print("DB",'E',"Error initializing database structure (%s).\n", db_strerror(rc)); else fprintf(stderr,"Error initializing database structure (%s).\n", db_strerror(rc)); return -1; } db = gw_acct_db.uinx_db; db->set_flags(db,DB_DUPSORT); if (server == GW_TRUE) { db->set_errcall(db,gw_acct_db_error); db->set_errpfx(db,"UINX-DB"); flags = DB_CREATE | DB_THREAD; } else flags = DB_RDONLY; rc = db->open(db, NULL, "uinx.db", NULL, DB_BTREE, flags, 0644); if (rc!=0) { if (server == GW_TRUE) gw_log_print("DB",'E',"Error openning database.\n"); else fprintf(stderr,"Error openning database.\n"); return -1; } gw_acct_db.acct_db->associate(gw_acct_db.acct_db, NULL, db, gw_acct_uidx_cb, DB_CREATE); /* ----- Secondary Database (host index), hidx.db ------ */ rc = db_create(&(gw_acct_db.hinx_db), db_env, 0); if ( rc != 0 ) { if (server == GW_TRUE) gw_log_print("DB",'E',"Error initializing database structure (%s).\n", db_strerror(rc)); else fprintf(stderr,"Error initializing database structure (%s).\n", db_strerror(rc)); return -1; } db = gw_acct_db.hinx_db; db->set_flags(db,DB_DUPSORT); if (server == GW_TRUE) { db->set_errcall(db,gw_acct_db_error); db->set_errpfx(db,"HINX-DB"); flags = DB_CREATE | DB_THREAD; } else flags = DB_RDONLY; rc = db->open(db, NULL, "hinx.db", NULL, DB_BTREE, flags, 0644); if (rc!=0) { if (server == GW_TRUE) gw_log_print("DB",'E',"Error openning database.\n"); else fprintf(stderr,"Error openning database.\n"); return -1; } gw_acct_db.acct_db->associate(gw_acct_db.acct_db, NULL, db, gw_acct_hidx_cb, DB_CREATE); if (server == GW_TRUE) gw_log_print ("DB",'I',"Accounting databases opened.\n"); return 0; }
///------------------------------------------------------------------------------------------------- /// Scan a single file. Everything that applies to ms_scan also applies to this function. If /// you know the type of the file, set the type paramter to one of TYPE_AUDIO, TYPE_VIDEO, or /// TYPE_IMAGE. Set it to TYPE_UNKNOWN to have it determined automatically. /// /// @author Andy Grundman /// @date 03/15/2011 /// /// @param [in,out] s If non-null, the. /// @param full_path Full pathname of the full file. /// /// ### remarks . ///------------------------------------------------------------------------------------------------- void ms_scan_file(MediaScan *s, const char *full_path, enum media_type type) { MediaScanError *e = NULL; MediaScanResult *r = NULL; int ret; uint32_t hash; int mtime = 0; uint64_t size = 0; DBT key, data; char tmp_full_path[MAX_PATH_STR_LEN]; #ifdef WIN32 char *ext = strrchr(full_path, '.'); #endif if (s == NULL) { ms_errno = MSENO_NULLSCANOBJ; LOG_ERROR("MediaScan = NULL, aborting scan\n"); return; } if (s->on_result == NULL) { ms_errno = MSENO_NORESULTCALLBACK; LOG_ERROR("Result callback not set, aborting scan\n"); return; } #if (defined(__APPLE__) && defined(__MACH__)) if (isAlias(full_path)) { LOG_INFO("File %s is a mac alias\n", full_path); // Check if this file is a shortcut and if so resolve it if (!CheckMacAlias(full_path, tmp_full_path)) { LOG_ERROR("Failure to follow symlink or alias, skipping file\n"); return; } } else { strcpy(tmp_full_path, full_path); } #elif defined(__unix__) || defined(__unix) if (isAlias(full_path)) { LOG_INFO("File %s is a unix symlink\n", full_path); // Check if this file is a shortcut and if so resolve it FollowLink(full_path, tmp_full_path); } else { strcpy(tmp_full_path, full_path); } #elif defined(WIN32) if (strcasecmp(ext, ".lnk") == 0) { // Check if this file is a shortcut and if so resolve it parse_lnk(full_path, tmp_full_path, MAX_PATH_STR_LEN); if (PathIsDirectory(tmp_full_path)) return; } else { strcpy(tmp_full_path, full_path); } #endif // Check if the file has been recently scanned hash = HashFile(tmp_full_path, &mtime, &size); // Skip 0-byte files if (unlikely(size == 0)) { LOG_WARN("Skipping 0-byte file: %s\n", tmp_full_path); return; } // Setup DBT values memset(&key, 0, sizeof(DBT)); memset(&data, 0, sizeof(DBT)); key.data = (char *)full_path; key.size = strlen(full_path) + 1; data.data = &hash; data.size = sizeof(uint32_t); if ((s->flags & MS_RESCAN) || (s->flags & MS_FULL_SCAN)) { // s->dbp will be null if this function is called directly, if not check if this file is // already scanned. if (s->dbp != NULL) { // DB_GET_BOTH will only return OK if both key and data match, this avoids the need to check // the returned data against hash int ret = s->dbp->get(s->dbp, NULL, &key, &data, DB_GET_BOTH); if (ret != DB_NOTFOUND) { // LOG_INFO("File %s already scanned, skipping\n", tmp_full_path); return; } } } LOG_INFO("Scanning file %s\n", tmp_full_path); if (type == TYPE_UNKNOWN || type == TYPE_LNK) { // auto-detect type type = _should_scan(s, tmp_full_path); if (!type) { if (s->on_error) { ms_errno = MSENO_SCANERROR; e = error_create(tmp_full_path, MS_ERROR_TYPE_UNKNOWN, "Unrecognized file extension"); send_error(s, e); return; } } } r = result_create(s); if (r == NULL) return; r->type = type; r->path = strdup(full_path); if (result_scan(r)) { // These were determined by HashFile r->mtime = mtime; r->size = size; r->hash = hash; // Store path -> hash data in cache if (s->dbp != NULL) { memset(&data, 0, sizeof(DBT)); data.data = &hash; data.size = sizeof(uint32_t); ret = s->dbp->put(s->dbp, NULL, &key, &data, 0); if (ret != 0) { s->dbp->err(s->dbp, ret, "Cache store failed: %s", db_strerror(ret)); } } send_result(s, r); } else { if (s->on_error && r->error) { // Copy the error, because the original will be cleaned up by result_destroy below MediaScanError *ecopy = error_copy(r->error); send_error(s, ecopy); } result_destroy(r); } } /* ms_scan_file() */
/* * Updates a row in table * Limitation: only knows how to update a single row * * _con: structure representing database connection * _k: key names * _op: operators * _v: values of the keys that must match * _uk: update keys; cols that need to be updated * _uv: update values; col values that need to be commited * _un: number of rows to update */ int bdb_update(db_con_t* _con, db_key_t* _k, db_op_t* _op, db_val_t* _v, db_key_t* _uk, db_val_t* _uv, int _n, int _un) { str s; char *c, *t; int ret, i, qcol, len, sum; int *lkey=NULL; tbl_cache_p _tbc = NULL; table_p _tp = NULL; char kbuf[MAX_ROW_SIZE]; char qbuf[MAX_ROW_SIZE]; char ubuf[MAX_ROW_SIZE]; DBT key, qdata, udata; DB *db; sum = ret = i = qcol = len = 0; if (!_con || !CON_TABLE(_con) || !_uk || !_uv || _un <= 0) return -1; s.s = (char*)CON_TABLE(_con); s.len = strlen(CON_TABLE(_con)); _tbc = bdblib_get_table(BDB_CON_CONNECTION(_con), &s); if(!_tbc) { LM_ERR("table does not exist\n"); return -1; } _tp = _tbc->dtp; if(!_tp) { LM_ERR("table not loaded\n"); return -1; } db = _tp->db; if(!db) { LM_ERR("DB null ptr\n"); return -1; } #ifdef BDB_EXTRA_DEBUG LM_DBG("UPDATE in %.*s\n", _tp->name.len, _tp->name.s); if (_op) LM_DBG("DONT-CARE : _op: operators for refining query \n"); #endif memset(&key, 0, sizeof(DBT)); memset(kbuf, 0, MAX_ROW_SIZE); memset(&qdata, 0, sizeof(DBT)); memset(qbuf, 0, MAX_ROW_SIZE); qdata.data = qbuf; qdata.ulen = MAX_ROW_SIZE; qdata.flags = DB_DBT_USERMEM; if(_k) { lkey = bdb_get_colmap(_tbc->dtp, _k, _n); if(!lkey) return -4; } else { LM_ERR("Null keys in update _k=0 \n"); return -1; } len = MAX_ROW_SIZE; if ( (ret = bdblib_valtochar(_tp, lkey, kbuf, &len, _v, _n, BDB_KEY)) != 0 ) { LM_ERR("Error in query key \n"); goto cleanup; } if(lkey) pkg_free(lkey); key.data = kbuf; key.ulen = MAX_ROW_SIZE; key.flags = DB_DBT_USERMEM; key.size = len; /*stage 1: QUERY Berkely DB*/ if ((ret = db->get(db, NULL, &key, &qdata, 0)) == 0) { #ifdef BDB_EXTRA_DEBUG LM_DBG("RESULT\nKEY: [%.*s]\nDATA: [%.*s]\n" , (int) key.size , (char *)key.data , (int) qdata.size , (char *)qdata.data); #endif } else { goto db_error; } /* stage 2: UPDATE row with new values */ /* map the provided keys to those in our schema */ lkey = bdb_get_colmap(_tbc->dtp, _uk, _un); if(!lkey) return -4; /* build a new row for update data (udata) */ memset(&udata, 0, sizeof(DBT)); memset(ubuf, 0, MAX_ROW_SIZE); /* loop over each column of the qbuf and copy it to our new ubuf unless its a field that needs to update */ c = strtok(qbuf, DELIM); t = ubuf; while( c!=NULL) { char* delim = DELIM; int k; len = strlen(c); sum+=len; if(sum > MAX_ROW_SIZE) { LM_ERR("value too long for string \n"); ret = -3; goto cleanup; } for(i=0; i<_un; i++) { k = lkey[i]; if (qcol == k) { /* update this col */ int j = MAX_ROW_SIZE - sum; if( bdb_val2str( &_uv[i], t, &j) ) { LM_ERR("value too long for string \n"); ret = -3; goto cleanup; } goto next; } } /* copy original column to the new column */ strncpy(t, c, len); next: t+=len; /* append DELIM */ sum += DELIM_LEN; if(sum > MAX_ROW_SIZE) { LM_ERR("value too long for string \n"); ret = -3; goto cleanup; } strncpy(t, delim, DELIM_LEN); t += DELIM_LEN; c = strtok(NULL, DELIM); qcol++; } ubuf[sum] = '0'; udata.data = ubuf; udata.ulen = MAX_ROW_SIZE; udata.flags = DB_DBT_USERMEM; udata.size = sum; #ifdef BDB_EXTRA_DEBUG LM_DBG("MODIFIED Data\nKEY: [%.*s]\nDATA: [%.*s]\n" , (int) key.size , (char *)key.data , (int) udata.size , (char *)udata.data); #endif /* stage 3: DELETE old row using key*/ if ((ret = db->del(db, NULL, &key, 0)) == 0) { #ifdef BDB_EXTRA_DEBUG LM_DBG("DELETED ROW\nKEY: %s \n", (char *)key.data); #endif } else { goto db_error; } /* stage 4: INSERT new row with key*/ if ((ret = db->put(db, NULL, &key, &udata, 0)) == 0) { bdblib_log(JLOG_UPDATE, _tp, ubuf, sum); #ifdef BDB_EXTRA_DEBUG LM_DBG("INSERT \nKEY: [%.*s]\nDATA: [%.*s]\n" , (int) key.size , (char *)key.data , (int) udata.size , (char *)udata.data); #endif } else { goto db_error; } #ifdef BDB_EXTRA_DEBUG LM_DBG("UPDATE COMPLETE \n"); #endif cleanup: if(lkey) pkg_free(lkey); return ret; db_error: /*Berkeley DB error handler*/ switch(ret) { case DB_NOTFOUND: #ifdef BDB_EXTRA_DEBUG LM_DBG("NO RESULT \n"); #endif return -1; /* The following are all critical/fatal */ case DB_LOCK_DEADLOCK: /* The operation was selected to resolve a deadlock. */ case DB_SECONDARY_BAD: /* A secondary index references a nonexistent primary key.*/ case DB_RUNRECOVERY: default: LM_CRIT("DB->get error: %s.\n", db_strerror(ret)); bdblib_recover(_tp,ret); } if(lkey) pkg_free(lkey); return ret; }
static int bdb_tool_next_id( Operation *op, DB_TXN *tid, Entry *e, struct berval *text, int hole ) { struct berval dn = e->e_name; struct berval ndn = e->e_nname; struct berval pdn, npdn; EntryInfo *ei = NULL, eidummy; int rc; if (ndn.bv_len == 0) { e->e_id = 0; return 0; } rc = bdb_cache_find_ndn( op, tid, &ndn, &ei ); if ( ei ) bdb_cache_entryinfo_unlock( ei ); if ( rc == DB_NOTFOUND ) { if ( !be_issuffix( op->o_bd, &ndn ) ) { ID eid = e->e_id; dnParent( &dn, &pdn ); dnParent( &ndn, &npdn ); e->e_name = pdn; e->e_nname = npdn; rc = bdb_tool_next_id( op, tid, e, text, 1 ); e->e_name = dn; e->e_nname = ndn; if ( rc ) { return rc; } /* If parent didn't exist, it was created just now * and its ID is now in e->e_id. Make sure the current * entry gets added under the new parent ID. */ if ( eid != e->e_id ) { eidummy.bei_id = e->e_id; ei = &eidummy; } } rc = bdb_next_id( op->o_bd, &e->e_id ); if ( rc ) { snprintf( text->bv_val, text->bv_len, "next_id failed: %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> bdb_tool_next_id: %s\n", text->bv_val, 0, 0 ); return rc; } rc = bdb_dn2id_add( op, tid, ei, e ); if ( rc ) { snprintf( text->bv_val, text->bv_len, "dn2id_add failed: %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> bdb_tool_next_id: %s\n", text->bv_val, 0, 0 ); } else if ( hole ) { if ( nholes == nhmax - 1 ) { if ( holes == hbuf ) { holes = ch_malloc( nhmax * sizeof(dn_id) * 2 ); AC_MEMCPY( holes, hbuf, sizeof(hbuf) ); } else { holes = ch_realloc( holes, nhmax * sizeof(dn_id) * 2 ); } nhmax *= 2; } ber_dupbv( &holes[nholes].dn, &ndn ); holes[nholes++].id = e->e_id; } } else if ( !hole ) { unsigned i, j; e->e_id = ei->bei_id; for ( i=0; i<nholes; i++) { if ( holes[i].id == e->e_id ) { free(holes[i].dn.bv_val); for (j=i;j<nholes;j++) holes[j] = holes[j+1]; holes[j].id = 0; nholes--; break; } else if ( holes[i].id > e->e_id ) { break; } } } return rc; }
/* * Insert a row into table */ int bdb_insert(db_con_t* _h, db_key_t* _k, db_val_t* _v, int _n) { tbl_cache_p _tbc = NULL; table_p _tp = NULL; char kbuf[MAX_ROW_SIZE]; char dbuf[MAX_ROW_SIZE]; int i, j, ret, klen, dlen; int *lkey=NULL; DBT key, data; DB *db; str s; i = j = ret = 0; klen=MAX_ROW_SIZE; dlen=MAX_ROW_SIZE; if ((!_h) || (!_v) || !CON_TABLE(_h)) { return -1; } if (!_k) { #ifdef BDB_EXTRA_DEBUG LM_ERR("DB INSERT without KEYs not implemented! \n"); #endif return -2; } s.s = (char*)CON_TABLE(_h); s.len = strlen(CON_TABLE(_h)); _tbc = bdblib_get_table(BDB_CON_CONNECTION(_h), &s); if(!_tbc) { LM_WARN("table does not exist!\n"); return -3; } _tp = _tbc->dtp; if(!_tp) { LM_WARN("table not loaded!\n"); return -4; } #ifdef BDB_EXTRA_DEBUG LM_DBG("INSERT in %.*s\n", _tp->name.len, _tp->name.s ); #endif db = _tp->db; memset(&key, 0, sizeof(DBT)); memset(kbuf, 0, klen); if(_tp->ncols<_n) { LM_WARN("more values than columns!!\n"); return -5; } lkey = bdb_get_colmap(_tp, _k, _n); if(!lkey) return -7; /* verify col types provided */ for(i=0; i<_n; i++) { j = (lkey)?lkey[i]:i; if(bdb_is_neq_type(_tp->colp[j]->type, _v[i].type)) { LM_WARN("incompatible types v[%d] - c[%d]!\n", i, j); ret = -8; goto error; } } /* make the key */ if ( (ret = bdblib_valtochar(_tp, lkey, kbuf, &klen, _v, _n, BDB_KEY)) != 0 ) { LM_ERR("Error in bdblib_valtochar \n"); ret = -9; goto error; } key.data = kbuf; key.ulen = MAX_ROW_SIZE; key.flags = DB_DBT_USERMEM; key.size = klen; //make the value (row) memset(&data, 0, sizeof(DBT)); memset(dbuf, 0, MAX_ROW_SIZE); if ( (ret = bdblib_valtochar(_tp, lkey, dbuf, &dlen, _v, _n, BDB_VALUE)) != 0 ) { LM_ERR("Error in bdblib_valtochar \n"); ret = -9; goto error; } data.data = dbuf; data.ulen = MAX_ROW_SIZE; data.flags = DB_DBT_USERMEM; data.size = dlen; if ((ret = db->put(db, NULL, &key, &data, 0)) == 0) { bdblib_log(JLOG_INSERT, _tp, dbuf, dlen); #ifdef BDB_EXTRA_DEBUG LM_DBG("INSERT\nKEY: [%.*s]\nDATA: [%.*s]\n" , (int) key.size , (char *)key.data , (int) data.size , (char *)data.data); #endif } else { /*Berkeley DB error handler*/ switch(ret) { /*The following are all critical/fatal */ case DB_LOCK_DEADLOCK: /* The operation was selected to resolve a deadlock. */ case DB_RUNRECOVERY: default: LM_CRIT("DB->put error: %s.\n", db_strerror(ret)); bdblib_recover(_tp, ret); goto error; } } error: if(lkey) pkg_free(lkey); return ret; }
ID bdb_tool_entry_put( BackendDB *be, Entry *e, struct berval *text ) { int rc; struct bdb_info *bdb; DB_TXN *tid = NULL; Operation op = {0}; Opheader ohdr = {0}; assert( be != NULL ); assert( slapMode & SLAP_TOOL_MODE ); assert( text != NULL ); assert( text->bv_val != NULL ); assert( text->bv_val[0] == '\0' ); /* overconservative? */ Debug( LDAP_DEBUG_TRACE, "=> " LDAP_XSTRING(bdb_tool_entry_put) "( %ld, \"%s\" )\n", (long) e->e_id, e->e_dn, 0 ); bdb = (struct bdb_info *) be->be_private; if (! (slapMode & SLAP_TOOL_QUICK)) { rc = TXN_BEGIN( bdb->bi_dbenv, NULL, &tid, bdb->bi_db_opflags ); if( rc != 0 ) { snprintf( text->bv_val, text->bv_len, "txn_begin failed: %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n", text->bv_val, 0, 0 ); return NOID; } Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_tool_entry_put) ": txn id: %x\n", tid->id(tid), 0, 0 ); } op.o_hdr = &ohdr; op.o_bd = be; op.o_tmpmemctx = NULL; op.o_tmpmfuncs = &ch_mfuncs; /* add dn2id indices */ rc = bdb_tool_next_id( &op, tid, e, text, 0 ); if( rc != 0 ) { goto done; } #ifdef USE_TRICKLE if (( slapMode & SLAP_TOOL_QUICK ) && (( e->e_id & 0xfff ) == 0xfff )) { ldap_pvt_thread_cond_signal( &bdb_tool_trickle_cond ); } #endif if ( !bdb->bi_linear_index ) rc = bdb_tool_index_add( &op, tid, e ); if( rc != 0 ) { snprintf( text->bv_val, text->bv_len, "index_entry_add failed: %s (%d)", rc == LDAP_OTHER ? "Internal error" : db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n", text->bv_val, 0, 0 ); goto done; } /* id2entry index */ rc = bdb_id2entry_add( be, tid, e ); if( rc != 0 ) { snprintf( text->bv_val, text->bv_len, "id2entry_add failed: %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n", text->bv_val, 0, 0 ); goto done; } done: if( rc == 0 ) { if ( !( slapMode & SLAP_TOOL_QUICK )) { rc = TXN_COMMIT( tid, 0 ); if( rc != 0 ) { snprintf( text->bv_val, text->bv_len, "txn_commit failed: %s (%d)", db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n", text->bv_val, 0, 0 ); e->e_id = NOID; } } } else { if ( !( slapMode & SLAP_TOOL_QUICK )) { TXN_ABORT( tid ); snprintf( text->bv_val, text->bv_len, "txn_aborted! %s (%d)", rc == LDAP_OTHER ? "Internal error" : db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n", text->bv_val, 0, 0 ); } e->e_id = NOID; } if ( cursor == NULL ) { int rc = bdb->bi_id2entry->bdi_db->cursor( bdb->bi_id2entry->bdi_db, bdb->bi_cache.c_txn, &cursor, bdb->bi_db_opflags ); if ( rc != 0 ) e->e_id = NOID; } return e->e_id; }
/* _bdb_delete_cursor -- called from bdb_delete when the query involves operators other than equal '='. Adds support for queries like this: DELETE from SomeTable WHERE _k[0] < _v[0] In this case, the keys _k are not the actually schema keys, so we need to iterate via cursor to perform this operation. */ int _bdb_delete_cursor(db_con_t* _h, db_key_t* _k, db_op_t* _op, db_val_t* _v, int _n) { tbl_cache_p _tbc = NULL; table_p _tp = NULL; db_res_t* _r = NULL; char kbuf[MAX_ROW_SIZE]; char dbuf[MAX_ROW_SIZE]; int i, ret, klen=MAX_ROW_SIZE; DBT key, data; DB *db; DBC *dbcp; int *lkey=NULL; str s; i = ret = 0; if ((!_h) || !CON_TABLE(_h)) return -1; s.s = (char*)CON_TABLE(_h); s.len = strlen(CON_TABLE(_h)); _tbc = bdblib_get_table(BDB_CON_CONNECTION(_h), &s); if(!_tbc) { LM_WARN("table does not exist!\n"); return -3; } _tp = _tbc->dtp; if(!_tp) { LM_WARN("table not loaded!\n"); return -4; } #ifdef BDB_EXTRA_DEBUG LM_DBG("DELETE by cursor in %.*s\n", _tp->name.len, _tp->name.s ); #endif if(_k) { lkey = bdb_get_colmap(_tp, _k, _n); if(!lkey) { ret = -1; goto error; } } /* create an empty db_res_t which gets returned even if no result */ _r = db_new_result(); if (!_r) { LM_ERR("no memory for result \n"); } RES_ROW_N(_r) = 0; /* fill in the col part of db_res_t */ if ((ret = bdb_get_columns(_tp, _r, 0, 0)) != 0) { LM_ERR("Error while getting column names\n"); goto error; } db = _tp->db; memset(&key, 0, sizeof(DBT)); memset(kbuf, 0, klen); memset(&data, 0, sizeof(DBT)); memset(dbuf, 0, MAX_ROW_SIZE); data.data = dbuf; data.ulen = MAX_ROW_SIZE; data.flags = DB_DBT_USERMEM; /* Acquire a cursor for the database. */ if ((ret = db->cursor(db, NULL, &dbcp, DB_WRITECURSOR)) != 0) { LM_ERR("Error creating cursor\n"); } while ((ret = dbcp->c_get(dbcp, &key, &data, DB_NEXT)) == 0) { if(!strncasecmp((char*)key.data,"METADATA",8)) continue; /*fill in the row part of db_res_t */ if ((ret=bdb_convert_row( _r, dbuf, 0)) < 0) { LM_ERR("Error while converting row\n"); goto error; } if(bdb_row_match(_k, _op, _v, _n, _r, lkey )) { #ifdef BDB_EXTRA_DEBUG LM_DBG("DELETE ROW by KEY: [%.*s]\n", (int) key.size, (char *)key.data); #endif if((ret = dbcp->c_del(dbcp, 0)) != 0) { /* Berkeley DB error handler */ LM_CRIT("DB->get error: %s.\n", db_strerror(ret)); bdblib_recover(_tp,ret); } } memset(dbuf, 0, MAX_ROW_SIZE); bdb_free_rows( _r); } ret = 0; error: if(dbcp) dbcp->c_close(dbcp); if(_r) bdb_free_result(_r); if(lkey) pkg_free(lkey); return ret; }
int hdb_dn2id( Operation *op, struct berval *in, EntryInfo *ei, DB_TXN *txn, DBC **cursor ) { struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private; DB *db = bdb->bi_dn2id->bdi_db; DBT key, data; int rc = 0, nrlen; diskNode *d; char *ptr; unsigned char dlen[2]; ID idp, parentID; Debug( LDAP_DEBUG_TRACE, "=> hdb_dn2id(\"%s\")\n", in->bv_val, 0, 0 ); nrlen = dn_rdnlen( op->o_bd, in ); if (!nrlen) nrlen = in->bv_len; DBTzero(&key); key.size = sizeof(ID); key.data = &idp; key.ulen = sizeof(ID); key.flags = DB_DBT_USERMEM; parentID = ( ei->bei_parent != NULL ) ? ei->bei_parent->bei_id : 0; BDB_ID2DISK( parentID, &idp ); DBTzero(&data); data.size = sizeof(diskNode) + nrlen - sizeof(ID) - 1; data.ulen = data.size * 3; data.dlen = data.ulen; data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL; rc = db->cursor( db, txn, cursor, bdb->bi_db_opflags ); if ( rc ) return rc; d = op->o_tmpalloc( data.size * 3, op->o_tmpmemctx ); d->nrdnlen[1] = nrlen & 0xff; d->nrdnlen[0] = (nrlen >> 8) | 0x80; dlen[0] = d->nrdnlen[0]; dlen[1] = d->nrdnlen[1]; ptr = lutil_strncopy( d->nrdn, in->bv_val, nrlen ); *ptr = '\0'; data.data = d; rc = (*cursor)->c_get( *cursor, &key, &data, DB_GET_BOTH_RANGE ); if ( rc == 0 && (dlen[1] != d->nrdnlen[1] || dlen[0] != d->nrdnlen[0] || strncmp( d->nrdn, in->bv_val, nrlen ))) { rc = DB_NOTFOUND; } if ( rc == 0 ) { ptr = (char *) data.data + data.size - sizeof(ID); BDB_DISK2ID( ptr, &ei->bei_id ); ei->bei_rdn.bv_len = data.size - sizeof(diskNode) - nrlen; ptr = d->nrdn + nrlen + 1; ber_str2bv( ptr, ei->bei_rdn.bv_len, 1, &ei->bei_rdn ); if ( ei->bei_parent != NULL && !ei->bei_parent->bei_dkids ) { db_recno_t dkids; /* How many children does the parent have? */ /* FIXME: do we need to lock the parent * entryinfo? Seems safe... */ (*cursor)->c_count( *cursor, &dkids, 0 ); ei->bei_parent->bei_dkids = dkids; } } op->o_tmpfree( d, op->o_tmpmemctx ); if( rc != 0 ) { Debug( LDAP_DEBUG_TRACE, "<= hdb_dn2id: get failed: %s (%d)\n", db_strerror( rc ), rc, 0 ); } else { Debug( LDAP_DEBUG_TRACE, "<= hdb_dn2id: got id=0x%lx\n", ei->bei_id, 0, 0 ); } return rc; }