NEOERR* lutil_fetch_count(HDF *hdf, mdb_conn *conn, char *table, char *cond)
{
if (!table || !cond) return nerr_raise(NERR_ASSERT, "paramter null");
char *buf;
size_t datalen;
int count = 0;
NEOERR *err;
buf = mmc_getf(&datalen, 0, PRE_MMC_COUNT".%s.%s", table, cond);
if (buf == NULL) {
err = mdb_exec(conn, NULL, "SELECT count(*) FROM %s WHERE %s;",
NULL, table, cond);
if (err != STATUS_OK) return nerr_pass(err);
err = mdb_get(conn, "s", &buf);
if (err != STATUS_OK) return nerr_pass(err);
count = atoi(buf);
mmc_storef(MMC_OP_SET, (void*)buf, 0, ONE_HOUR, 0,
PRE_MMC_COUNT".%s.%s", table, cond);
} else {
count = atoi(buf);
}
hdf_set_int_value(hdf, PRE_OUTPUT".ttnum", count);
return STATUS_OK;
}
int64 LMDBFileIndex::get(const LMDBFileIndex::SIndexKey& key)
{
begin_txn(MDB_RDONLY);
MDB_val mdb_tkey;
mdb_tkey.mv_data=const_cast<void*>(static_cast<const void*>(&key));
mdb_tkey.mv_size=sizeof(SIndexKey);
MDB_val mdb_tvalue;
int rc=mdb_get(txn, dbi, &mdb_tkey, &mdb_tvalue);
int64 ret = 0;
if(rc==MDB_NOTFOUND)
{
}
else if(rc)
{
Server->Log("LMDB: Failed to read ("+(std::string)mdb_strerror(rc)+")", LL_ERROR);
_has_error=true;
}
else
{
CRData data((const char*)mdb_tvalue.mv_data, mdb_tvalue.mv_size);
data.getVarInt(&ret);
}
abort_transaction();
return ret;
}
long gcache_get(struct gcache *gc, char *k, char *buf, long buflen)
{
MDB_val key, data;
MDB_txn *txn;
int rc;
long len = -1;
if (gc == NULL)
return (-1);
rc = mdb_txn_begin(gc->env, NULL, MDB_RDONLY, &txn);
if (rc) {
olog(LOG_ERR, "gcache_get: mdb_txn_begin: (%d) %s", rc, mdb_strerror(rc));
return (-1);
}
key.mv_data = k;
key.mv_size = strlen(k);
rc = mdb_get(txn, gc->dbi, &key, &data);
if (rc != 0) {
if (rc != MDB_NOTFOUND) {
printf("get: %s\n", mdb_strerror(rc));
} else {
// printf(" [%s] not found\n", k);
}
} else {
len = (data.mv_size < buflen) ? data.mv_size : buflen;
memcpy(buf, data.mv_data, len);
// printf("%s\n", (char *)data.mv_data);
}
mdb_txn_commit(txn);
return (len);
}
char* user_login_auth(mdb_conn *conn, char *uid, char *pass)
{
if (!conn || !uid || !pass) return NULL;
char *p, *r;
int ret, x;
mdb_exec(conn, NULL, "SELECT password from account WHERE userid=$1;", "s", uid);
if (mdb_get(conn, "s", &p) == MDB_ERR_NONE) {
if (!strcmp(p, pass)) {
r = calloc(1, LEN_SKEY+1);
for (x = 0; x < LEN_SKEY; x++) {
r[x] = (char)(65 + neo_rand(90-65));
}
r[x] = '\0';
ret = mdb_exec(conn, NULL, "UPDATE account SET skey='$1' WHERE "
" userid=$2;", "ss", r, uid);
if (ret != MDB_ERR_NONE) {
mtc_err("exec failure %s", mdb_get_errmsg(conn));
free(r);
return NULL;
}
return r;
}
}
return NULL;
}
int LMDBEngine::Get(const Slice& key, std::string* value, bool fill_cache)
{
MDB_val k, v;
k.mv_data = const_cast<char*>(key.data());
k.mv_size = key.size();
int rc;
LMDBContext& holder = m_ctx_local.GetValue();
MDB_txn *txn = holder.readonly_txn;
if (NULL == holder.readonly_txn)
{
rc = mdb_txn_begin(m_env, NULL, MDB_RDONLY, &txn);
if (rc != 0)
{
ERROR_LOG("Failed to create txn for get for reason:%s", mdb_strerror(rc));
return -1;
}
}
rc = mdb_get(txn, m_dbi, &k, &v);
if (NULL == holder.readonly_txn)
{
mdb_txn_commit(txn);
}
if (0 == rc && NULL != value && NULL != v.mv_data)
{
value->assign((const char*) v.mv_data, v.mv_size);
}
return rc;
}
/*
* input : pname(STR) aname(STR)
* return: NORMAL
* reply : NULL
*/
static NEOERR* aic_cmd_app_setsecy(struct queue_entry *q, struct cache *cd, mdb_conn *db)
{
char *pname, *aname;
int pid, aid, upid;
NEOERR *err;
REQ_GET_PARAM_STR(q->hdfrcv, "pname", pname);
REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname);
pid = hash_string(pname);
aid = hash_string(aname);
MDB_EXEC(db, NULL, "UPDATE appinfo SET tune=tune & %d WHERE aid=%d OR pid=%d "
" RETURNING aid", NULL, ~LCS_TUNE_SECY, pid, pid);
upid = aid;
err = mdb_get(db, "i", &upid);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "UPDATE appinfo SET tune=tune | %d WHERE aid=%d",
NULL, LCS_TUNE_SECY, aid);
cache_delf(cd, PREFIX_APPINFO"%d", upid);
cache_delf(cd, PREFIX_APPINFO"%d", aid);
cache_delf(cd, PREFIX_APPOUSER"%d_0", pid);
cache_delf(cd, PREFIX_SECY"%d", pid);
return STATUS_OK;
}
int slmdb_get(SLMDB *slmdb, MDB_val *mdb_key, MDB_val *mdb_value)
{
MDB_txn *txn;
int status;
/*
* Start a read transaction if there's no bulk-mode txn.
*/
if (slmdb->txn)
txn = slmdb->txn;
else if ((status = slmdb_txn_begin(slmdb, MDB_RDONLY, &txn)) != 0)
SLMDB_API_RETURN(slmdb, status);
/*
* Do the lookup.
*/
if ((status = mdb_get(txn, slmdb->dbi, mdb_key, mdb_value)) != 0
&& status != MDB_NOTFOUND) {
mdb_txn_abort(txn);
if ((status = slmdb_recover(slmdb, status)) == 0)
status = slmdb_get(slmdb, mdb_key, mdb_value);
SLMDB_API_RETURN(slmdb, status);
}
/*
* Close the read txn if it's not the bulk-mode txn.
*/
if (slmdb->txn == 0)
mdb_txn_abort(txn);
SLMDB_API_RETURN(slmdb, status);
}
int mail_cache_db_get_size(struct mail_cache_db * cache_db,
const void * key, size_t key_len, size_t * pvalue_len)
{
int r;
MDB_env *env;
MDB_txn *txn;
MDB_dbi dbi;
MDB_val mdb_key;
MDB_val mdb_val;
env = cache_db->internal_database;
mdb_key.mv_size = key_len;
mdb_key.mv_data = (void *) key;
r = mdb_txn_begin(env, NULL, 0, &txn);
if (r != 0)
return -1;
r = mdb_dbi_open(txn, NULL, 0, &dbi);
if (r != 0)
goto error;
r = mdb_get(txn, dbi, &mdb_key, &mdb_val);
if (r != 0)
goto error;
* pvalue_len = mdb_val.mv_size;
mdb_txn_commit(txn);
return 0;
error:
mdb_txn_abort(txn);
return -1;
}
/*
* Initialize ENTRYID and USN sequence.
*/
static
DWORD
MDBInitSequence(
PVDIR_MDB_DB pDB,
VDIR_DB mdbDbi
)
{
DWORD dwError = 0;
PVDIR_DB_TXN pTxn = NULL;
VDIR_DB_DBT key = {0};
VDIR_DB_DBT value = {0};
unsigned char EidBytes[sizeof( ENTRYID )] = {0};
ENTRYID initEIDValue = ENTRY_ID_SEQ_INITIAL_VALUE;
ENTRYID initUNSValue = USN_SEQ_INITIAL_VALUE;
assert(pDB);
dwError = mdb_txn_begin( pDB->mdbEnv, NULL, BE_DB_FLAGS_ZERO, &pTxn );
BAIL_ON_VMDIR_ERROR(dwError);
key.mv_data = &EidBytes[0];
MDBEntryIdToDBT(BE_MDB_ENTRYID_SEQ_KEY, &key);
dwError = mdb_get(pTxn, mdbDbi, &key, &value);
if (dwError == MDB_NOTFOUND)
{
// first time, initialize two sequence records
value.mv_data = &initEIDValue;
value.mv_size = sizeof(initEIDValue);
// set entryid sequence record
dwError = mdb_put(pTxn, mdbDbi, &key, &value, MDB_NOOVERWRITE);
BAIL_ON_VMDIR_ERROR(dwError);
MDBEntryIdToDBT(BE_MDB_USN_SEQ_KEY, &key);
value.mv_data = &initUNSValue;
value.mv_size = sizeof(initUNSValue);
// set usn sequence record
dwError = mdb_put(pTxn, mdbDbi, &key, &value, MDB_NOOVERWRITE);
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = mdb_txn_commit(pTxn);
pTxn = NULL;
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
return dwError;
error:
if (pTxn)
{
mdb_txn_abort(pTxn);
}
goto cleanup;
}
bool DBPrivRead(DBPriv *db, const void *key, int key_size, void *dest, int dest_size)
{
MDB_val mkey, data;
DBTxn *txn;
int rc;
bool ret = false;
rc = GetReadTransaction(db, &txn);
if (rc == MDB_SUCCESS)
{
assert(!txn->cursor_open);
mkey.mv_data = (void *)key;
mkey.mv_size = key_size;
rc = mdb_get(txn->txn, db->dbi, &mkey, &data);
if (rc == MDB_SUCCESS)
{
if (dest_size > data.mv_size)
{
dest_size = data.mv_size;
}
memcpy(dest, data.mv_data, dest_size);
ret = true;
}
else if (rc != MDB_NOTFOUND)
{
Log(LOG_LEVEL_ERR, "Could not read database entry: %s", mdb_strerror(rc));
AbortTransaction(db);
}
}
return ret;
}
NEOERR* blog_data_add(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "aux");
mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");
char *aname, command[1024];
char *title, *content;
int id = 0;
NEOERR *err;
LPRE_DBOP(cgi->hdf, conn);
APP_CHECK_LOGIN();
if (hdf_get_int_value(evt->hdfrcv, "state", 0) < LCS_ST_ADMIN)
return nerr_raise(LERR_LIMIT, "%s wan't be admin", aname);
HDF_GET_STR(cgi->hdf, PRE_QUERY".title", title);
HDF_GET_STR(cgi->hdf, PRE_QUERY".content", content);
MDB_EXEC(conn, NULL, "INSERT INTO blog (title, content, author) "
" VALUES ($1::varchar(256), $2, "
" $3::varchar(256)) RETURNING id",
"sss", title, content, aname);
err = mdb_get(conn, "i", &id);
if (err != STATUS_OK) return nerr_pass(err);
snprintf(command, sizeof(command), PATH_PAGER"blg -i 0 -b %d", id);
mtc_dbg("%s", command);
system(command);
return STATUS_OK;
}
bool LmdbDataset<K, V, KCoder, VCoder>::get(const K& key, V* value) {
DLOG(INFO) << "LMDB: Get";
vector<char> serialized_key;
if (!KCoder::serialize(key, &serialized_key)) {
LOG(ERROR) << "failed to serialized key";
return false;
}
MDB_val mdbkey, mdbdata;
mdbkey.mv_data = serialized_key.data();
mdbkey.mv_size = serialized_key.size();
int retval;
retval = mdb_get(read_txn_, dbi_, &mdbkey, &mdbdata);
if (MDB_SUCCESS != retval) {
LOG(ERROR) << "mdb_get failed " << mdb_strerror(retval);
return false;
}
if (!VCoder::deserialize(reinterpret_cast<char*>(mdbdata.mv_data),
mdbdata.mv_size, value)) {
LOG(ERROR) << "failed to deserialize value";
return false;
}
return true;
}
int kvdb_lmdb_get(kvdb_t *kvdb, const char *key, uint32_t klen, void **ppVal, uint32_t *pnVal)
{
kvdb_lmdb_t *lmdb = (kvdb_lmdb_t*)kvdb;
kvenv_lmdb_t *kvenv_lmdb = (kvenv_lmdb_t*)kvdb->kvenv;
MDB_val m_key;
MDB_txn *txn;
m_key.mv_size = klen;
m_key.mv_data = (void*)key;
int rc = mdb_txn_begin(kvenv_lmdb->env, NULL, MDB_RDONLY, &txn);
if( rc==0 ){
MDB_val m_val = {0, 0};
rc = mdb_get(txn, lmdb->dbi, &m_key, &m_val);
if ( rc == 0 ) {
uint32_t nVal = m_val.mv_size;
char *pVal = m_val.mv_data;
char *result = (char*)zmalloc(nVal);
memcpy(result, pVal, nVal);
*ppVal = result;
*pnVal = nVal;
} else if( rc==MDB_NOTFOUND ){
rc = 0;
*ppVal = 0;
*pnVal = -1;
}else{
error_log("kvdb_lmdb_get() failure. error: %s", mdb_strerror(rc));
}
mdb_txn_commit(txn);
}
return rc;
}
static int
lmdb_storage_get(void* handle, iid_t iid, paxos_accepted* out)
{
struct lmdb_storage* s = handle;
int result;
MDB_val key, data;
memset(&data, 0, sizeof(data));
key.mv_data = &iid;
key.mv_size = sizeof(iid_t);
if ((result = mdb_get(s->txn, s->dbi, &key, &data)) != 0) {
if (result == MDB_NOTFOUND) {
paxos_log_debug("There is no record for iid: %d", iid);
} else {
paxos_log_error("Could not find record for iid: %d : %s",
iid, mdb_strerror(result));
}
return 0;
}
paxos_accepted_from_buffer(data.mv_data, out);
assert(iid == out->iid);
return 1;
}
/**
* This function works in stages. First we clean up the given key to prevent
* any trickery by users. Then we retrieve the existing value, increment it,
* and store it back in the db.
*/
uint64_t counter_inc(counter_t *lc, const char *key) {
char clean_key[KEYSZ] = { 0 };
key_clean(clean_key, key);
clean_key[15] = '\0';
MDB_val mkey, data, update;
MDB_txn *txn = NULL;
mkey.mv_size = (KEYSZ) * sizeof(char);
mkey.mv_data = (void *)clean_key;
mdb_txn_begin(lc->env, NULL, 0, &txn);
uint64_t stored_counter = 0;
// We only care about success here, since if mdb_get fails it is because
// the key doesn't exist and we need to make it.
if(mdb_get(txn, *lc->dbi, &mkey, &data) == MDB_SUCCESS) {
stored_counter = *(uint64_t *)data.mv_data;
}
stored_counter++;
update.mv_size = sizeof(uint64_t);
update.mv_data = (void *)&stored_counter;
if(mdb_put(txn, *lc->dbi, &mkey, &update, 0) != MDB_SUCCESS) {
perror("mdb_put");
mdb_txn_abort(txn);
return 0;
}
MDB_CHECK(mdb_txn_commit(txn), MDB_SUCCESS, 0);
return stored_counter;
}
void counter_dump(counter_t *lc, buffer_t *output) {
MDB_val key, data, rps_key, rps_data;
MDB_txn *txn = NULL;
MDB_cursor *cursor = NULL;
mdb_txn_begin(lc->env, NULL, MDB_RDONLY, &txn);
mdb_cursor_open(txn, *lc->dbi, &cursor);
int rc = 0;
char *tmp_str = NULL;
int size = 0;
uint64_t rps = 0;
while((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
if((*(char *)key.mv_data) == '_') {
continue;
}
size = asprintf(&tmp_str, "_%s_rps", (char *)key.mv_data);
rps_key.mv_size = size;
rps_key.mv_data = tmp_str;
if(mdb_get(txn, *lc->dbi, &rps_key, &rps_data) == MDB_SUCCESS) {
rps = *(uint64_t *)rps_data.mv_data;
}
free(tmp_str);
size = asprintf(&tmp_str, "%s: %lu - %lurps\n", (char *)key.mv_data, *(uint64_t *)data.mv_data, rps);
buffer_append(output, tmp_str, size);
free(tmp_str);
}
mdb_cursor_close(cursor);
mdb_txn_abort(txn);
}
int CDbxMdb::Load(bool bSkipInit)
{
if (!Remap())
return EGROKPRF_CANTREAD;
if (!bSkipInit) {
txn_ptr trnlck(m_pMdbEnv);
mdb_open(trnlck, "global", MDB_CREATE | MDB_INTEGERKEY, &m_dbGlobal);
mdb_open(trnlck, "contacts", MDB_CREATE | MDB_INTEGERKEY, &m_dbContacts);
mdb_open(trnlck, "modules", MDB_CREATE | MDB_INTEGERKEY, &m_dbModules);
mdb_open(trnlck, "events", MDB_CREATE | MDB_INTEGERKEY, &m_dbEvents);
mdb_open(trnlck, "eventsrt", MDB_CREATE | MDB_INTEGERKEY, &m_dbEventsSort);
mdb_open(trnlck, "settings", MDB_CREATE, &m_dbSettings);
DWORD keyVal = 1;
MDB_val key = { sizeof(DWORD), &keyVal }, data;
if (mdb_get(trnlck, m_dbGlobal, &key, &data) == MDB_SUCCESS) {
DBHeader *hdr = (DBHeader*)data.mv_data;
if (hdr->dwSignature != DBHEADER_SIGNATURE)
DatabaseCorruption(NULL);
memcpy(&m_header, data.mv_data, sizeof(m_header));
}
else {
m_header.dwSignature = DBHEADER_SIGNATURE;
m_header.dwVersion = 1;
data.mv_data = &m_header; data.mv_size = sizeof(m_header);
mdb_put(trnlck, m_dbGlobal, &key, &data, 0);
keyVal = 0;
DBContact dbc = { DBCONTACT_SIGNATURE, 0, 0, 0 };
data.mv_data = &dbc; data.mv_size = sizeof(dbc);
mdb_put(trnlck, m_dbContacts, &key, &data, 0);
}
trnlck.commit();
if (InitModuleNames()) return EGROKPRF_CANTREAD;
if (InitCrypt()) return EGROKPRF_CANTREAD;
// everything is ok, go on
if (!m_bReadOnly) {
// we don't need events in the service mode
if (ServiceExists(MS_DB_SETSAFETYMODE)) {
hContactDeletedEvent = CreateHookableEvent(ME_DB_CONTACT_DELETED);
hContactAddedEvent = CreateHookableEvent(ME_DB_CONTACT_ADDED);
hSettingChangeEvent = CreateHookableEvent(ME_DB_CONTACT_SETTINGCHANGED);
hEventMarkedRead = CreateHookableEvent(ME_DB_EVENT_MARKED_READ);
hEventAddedEvent = CreateHookableEvent(ME_DB_EVENT_ADDED);
hEventDeletedEvent = CreateHookableEvent(ME_DB_EVENT_DELETED);
hEventFilterAddedEvent = CreateHookableEvent(ME_DB_EVENT_FILTER_ADD);
}
}
FillContacts();
}
return ERROR_SUCCESS;
}
Status fetch (void const* key, NodeObject::Ptr* pObject)
{
pObject->reset ();
Status status (ok);
MDB_txn* txn = nullptr;
int error = 0;
error = mdb_txn_begin (m_env, NULL, MDB_RDONLY, &txn);
if (error == 0)
{
MDB_val dbkey;
MDB_val data;
dbkey.mv_size = m_keyBytes;
dbkey.mv_data = mdb_cast (key);
error = mdb_get (txn, m_dbi, &dbkey, &data);
if (error == 0)
{
DecodedBlob decoded (key, data.mv_data, data.mv_size);
if (decoded.wasOk ())
{
*pObject = decoded.createObject ();
}
else
{
status = dataCorrupt;
}
}
else if (error == MDB_NOTFOUND)
{
status = notFound;
}
else
{
status = unknown;
WriteLog (lsWARNING, NodeObject) << "MDB txn failed, code=" << error;
}
mdb_txn_abort (txn);
}
else
{
status = unknown;
WriteLog (lsWARNING, NodeObject) << "MDB txn failed, code=" << error;
}
return status;
}
/*
* Class: jmdb_DatabaseWrapper
* Method: get
* Signature: (JI[BII[BII)I
*/
JNIEXPORT jint JNICALL Java_jmdb_DatabaseWrapper_get(JNIEnv *vm, jclass clazz,
jlong txnL, jint dbi, jbyteArray keyA, jint kofs, jint klen,
jbyteArray valueA, jint vofs, jint vlen) {
MDB_txn *txnC = (MDB_txn*) txnL;
enum {
NONE, OOM, MDB, IOOB
} result = NONE;
jint ret;
char lenHolder[64];
MDB_val key, value;
jbyte *keyC = (*vm)->GetPrimitiveArrayCritical(vm, keyA, NULL);
jbyte *valueC = (*vm)->GetPrimitiveArrayCritical(vm, valueA, NULL);
if (keyC == NULL || valueC == NULL) {
result = OOM;
ret = -1;
} else {
key.mv_size = klen;
key.mv_data = keyC + kofs;
ret = mdb_get(txnC, (MDB_dbi) dbi, &key, &value);
if (ret == MDB_NOTFOUND) {
ret = -1;
} else if (ret) {
result = MDB;
} else if ((jlong) value.mv_size > vlen) {
sprintf(lenHolder, "V%d/%d", (int ) value.mv_size, vlen);
result = IOOB;
} else if ((jlong) key.mv_size > klen) {
sprintf(lenHolder, "K%d/%d", (int ) key.mv_size, klen);
result = IOOB;
} else {
memcpy(valueC + vofs, value.mv_data, value.mv_size);
ret = value.mv_size;
}
}
(*vm)->ReleasePrimitiveArrayCritical(vm, valueA, valueC, 0);
(*vm)->ReleasePrimitiveArrayCritical(vm, keyA, keyC, JNI_ABORT);
switch (result) {
case NONE:
return ret;
case OOM:
throwNew(vm, "java/lang/OutOfMemoryError", "");
return -1;
case MDB:
throwDatabaseException(vm, ret);
return -1;
case IOOB:
throwNew(vm, "java/lang/IndexOutOfBoundsException", lenHolder);
return -1;
default:
throwNew(vm, "java/lang/RuntimeException", "Flow control error in jni");
return -1;
}
}
static ngx_int_t
ngx_http_tcache_mdb_get(ngx_http_tcache_t *cache, ngx_http_tcache_ctx_t *ctx,
ngx_flag_t lookup)
{
int expire;
ngx_buf_t *buf;
ngx_int_t rc;
ngx_mdb_t *mdb;
data_entry_t key, value;
key.data = (char *) ctx->key;
key.size = NGX_HTTP_CACHE_KEY_LEN;
mdb = cache->mdb;
if (lookup) {
rc = mdb_lookup(mdb->db, mdb->area, &key);
if (rc == true) {
return NGX_OK;
} else {
return NGX_DECLINED;
}
}
rc = mdb_get(mdb->db, mdb->area, &key, &value, NULL, &expire);
if (rc != 0) {
return NGX_DECLINED;
}
rc = NGX_OK;
if (value.size == 0) {
return rc;
}
ctx->cache_length = value.size;
buf = ngx_create_temp_buf(ctx->pool, value.size);
if (buf == NULL) {
rc = NGX_ERROR;
goto end;
}
buf->last = buf->end = ngx_copy(buf->pos, value.data, value.size);
ctx->cache_content = buf;
ctx->payload = buf->pos;
end:
free(value.data);
return rc;
}
accurate_payload *B_ACCURATE_LMDB::lookup_payload(JCR *jcr, char *fname)
{
int result;
int lstat_length;
MDB_val key, data;
accurate_payload *payload = NULL;
key.mv_data = fname;
key.mv_size = strlen(fname) + 1;
result = mdb_get(m_db_ro_txn, m_db_dbi, &key, &data);
switch (result) {
case 0:
/*
* Success.
*
* We need to make a private copy of the LDMB data as we are not
* allowed to change its content and we need to update the lstat
* and chksum pointer to point to the actual lstat and chksum that
* is stored behind the accurate_payload structure in the LMDB.
*/
m_pay_load = check_pool_memory_size(m_pay_load, data.mv_size);
payload = (accurate_payload *)m_pay_load;
memcpy(payload, data.mv_data, data.mv_size);
payload->lstat = (char *)payload + sizeof(accurate_payload);
lstat_length = strlen(payload->lstat);
payload->chksum = (char *)payload->lstat + lstat_length + 1;
/*
* We keep the transaction as short a possible so after a lookup
* and copying the actual data out we reset the read transaction
* and do a renew of the read transaction for a new run.
*/
mdb_txn_reset(m_db_ro_txn);
result = mdb_txn_renew(m_db_ro_txn);
if (result != 0) {
Jmsg1(jcr, M_FATAL, 0, _("Unable to renew read transaction: %s\n"), mdb_strerror(result));
return NULL;
}
break;
case MDB_NOTFOUND:
/*
* Failed to find the given key.
*/
break;
default:
break;
}
return payload;
}
static int fetch(struct dbengine *db, const char *key, size_t keylen,
const char **data, size_t *datalen, struct txn **tidptr)
{
MDB_val mkey, mval;
struct txn *tid;
int r, r2 = 0, mr;
PDEBUG("cyrusdb_lmdb(%s)[fetch] tidptr=%p *tidptr=%p key='%.*s'",
db->fname, tidptr, tidptr ? *tidptr : NULL, (int) keylen, key);
assert(db && key);
mkey.mv_data = (void*) key;
mkey.mv_size = keylen;
/* Open or reuse transaction */
r = getorset_txn(db, tidptr, &tid, !tidptr /*readonly*/);
if (r) goto fail;
mr = mdb_get(tid->mtxn, tid->dbi, &mkey, &mval);
if (mr == MDB_NOTFOUND) {
/* That's not an error */
r = CYRUSDB_NOTFOUND;
if (datalen) *datalen = 0;
if (data) *data = NULL;
} else if (mr) {
/* That's an error */
syslog(LOG_ERR, "cryusdb_lmdb(%s): %s", db->fname, mdb_strerror(mr));
r = CYRUSDB_INTERNAL;
goto fail;
} else if (data && datalen) {
/* Cache the fetched data from LMDB memory in own buffer */
r = bufferval(db, mval, data, datalen);
if (r) goto fail;
}
/* Commit or export the transaction */
if (!tidptr) {
r2 = commit_txn(db, tid);
if (r2) goto fail;
} else {
*tidptr = tid;
r2 = CYRUSDB_OK;
}
return r ? r : r2;
fail:
if (tid && (!tidptr || !*tidptr)) abort_txn(db, tid);
return r ? r : r2;
}
int LMDBEngine::Get(const Slice& key, std::string* value, bool fill_cache)
{
MDB_val k, v;
k.mv_data = const_cast<char*>(key.data());
k.mv_size = key.size();
int rc;
BatchHolder& holder = m_batch_local.GetValue();
if (!holder.EmptyRef())
{
rc = mdb_get(holder.txn, m_dbi, &k, &v);
}
else
{
MDB_txn *txn = NULL;
mdb_txn_begin(m_env, NULL, 0, &txn);
rc = mdb_get(txn, m_dbi, &k, &v);
mdb_txn_commit(txn);
}
if (0 == rc && NULL != value && NULL != v.mv_data)
{
value->assign((const char*) v.mv_data, v.mv_size);
}
return rc;
}
bool user_has_login(mdb_conn *conn, char *uid, char *skey)
{
if (!conn || !uid || !skey) return false;
char *s;
mdb_exec(conn, NULL, "SELECT skey from account WHERE userid=$1;", "s", uid);
if (mdb_get(conn, "s", &s) == MDB_ERR_NONE) {
if (!strcmp(s, skey))
return true;
}
return false;
}
// To get the current max ENTRYID
DWORD
VmDirMDBMaxEntryId(
PVDIR_BACKEND_CTX pBECtx,
ENTRYID* pEId)
{
DWORD dwError = 0;
PVDIR_DB_TXN pTxn = NULL;
MDB_val key = {0};
MDB_val value = {0};
unsigned char EIDBytes[sizeof( ENTRYID )] = {0};
assert(pBECtx && pEId);
dwError = mdb_txn_begin( gVdirMdbGlobals.mdbEnv, NULL, MDB_RDONLY, &pTxn );
BAIL_ON_VMDIR_ERROR(dwError);
key.mv_data = &EIDBytes[0];
MDBEntryIdToDBT(BE_MDB_ENTRYID_SEQ_KEY, &key);
dwError = mdb_get(pTxn, gVdirMdbGlobals.mdbSeqDBi, &key, &value);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = mdb_txn_commit(pTxn);
pTxn = NULL;
BAIL_ON_VMDIR_ERROR(dwError);
assert(value.mv_size == sizeof(ENTRYID));
*pEId = *((ENTRYID*)value.mv_data);
cleanup:
return dwError;
error:
if (pTxn)
{
mdb_txn_abort(pTxn);
}
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"VmDirMDBMaxEntryId: failed with error (%d),(%s)",
dwError, mdb_strerror(dwError) );
dwError = MDBToBackendError(dwError, 0, ERROR_BACKEND_ERROR, pBECtx, "MaxEntryId");
goto cleanup;
}
// Return a value from database.
void database_get(MDB_env *db, MDB_val *key, MDB_val *value) {
MDB_dbi dbi;
MDB_txn *txn;
// transaction init
mdb_txn_begin(db, NULL, MDB_RDONLY, &txn);
// open database in read-write mode
mdb_dbi_open(txn, NULL, 0, &dbi);
// get data
if (mdb_get(txn, dbi, key, value))
bzero(value, sizeof(*value));
// end of transaction
mdb_txn_abort(txn);
// close database
mdb_dbi_close(db, dbi);
}
/*
bool Context::Write(size_t ksz, void* key,
size_t dsz, void* data){
Error(0);
if (envHandle==nullptr){
return false;
}
else{
MDB_txn *txn;
int txnret = mdb_txn_begin(envHandle,nullptr,0,&txn);
if (txnret != 0) {
Error(txnret);
return false;
}
else{
MDB_dbi dbi;
int dbiret = mdb_dbi_open(txn,"Entity",MDB_CREATE,&dbi);
if (dbiret != 0){
Error(dbiret);
mdb_txn_abort(txn);
return false;
}
else{
MDB_val kkey { ksz, key };
MDB_val ddata { dsz, data};
putReturn = mdb_put(txn,dbi,&kkey,&ddata,0);
if (putReturn !=0){
Error(putReturn);
mdb_txn_abort(txn);
return false;
}
else{
int commit = mdb_txn_commit(txn);
if (commit!=0){
Error(commit);
return false;
}
else return true;
}
}
}
}
}
*/
bool Context::GetCopy(size_t ksz, void* key,
void** data){
Error(0);
if (envHandle==nullptr){
return false;
}
else{
MDB_txn *txn;
int txnret = mdb_txn_begin(envHandle,nullptr,0,&txn);
if (txnret != 0){
Error(txnret);
return false;
}
else{
MDB_dbi dbi;
int dbiret = mdb_dbi_open(txn,"Entity",0,&dbi);
if (dbiret !=0){
Error(dbiret);
mdb_txn_abort(txn);
return false;
}
else{
MDB_val kkey { ksz, key };
MDB_val ddata;
int get = mdb_get(txn,dbi,&kkey,&ddata);
if (get!=0){
Error(get);
mdb_txn_abort(txn);
return false;
}
else {
*data = new char[ddata.mv_size];
memcpy(*data, (void*)ddata.mv_data, (ddata.mv_size)*sizeof(char));
int commit = mdb_txn_commit(txn);
if (commit!=0){
Error(commit);
delete (char*)(*data);
return false;
}
else return true;
}
}
}
}
}
uint64_t counter_get(counter_t *lc, const char *key) {
MDB_dbi dbi;
MDB_val mkey, data;
MDB_txn *txn;
mdb_txn_begin(lc->env, NULL, 0, &txn);
mdb_dbi_open(txn, NULL, 0, &dbi);
mkey.mv_size = strlen(key) * sizeof(char);
mkey.mv_data = (void *)key;
// First we get our data from the db
uint64_t stored_counter = 0;
if(mdb_get(txn, dbi, &mkey, &data) == MDB_SUCCESS) {
stored_counter = *(uint64_t *)data.mv_data;
}
mdb_dbi_close(lc->env, dbi);
return stored_counter;
}
/** Check if the ticket has already been issued
* @return 0 if not unique; otherwise 1 */
static int __check_if_ticket_exists(const unsigned int ticket)
{
MDB_txn *txn;
int e = mdb_txn_begin(sv->db_env, NULL, MDB_RDONLY, &txn);
if (0 != e)
mdb_fatal(e);
MDB_val k = { .mv_size = sizeof(ticket), .mv_data = (void*)&ticket };
MDB_val v;
e = mdb_get(txn, sv->tickets, &k, &v);
switch (e)
{
case 0:
break;
case MDB_NOTFOUND:
e = mdb_txn_commit(txn);
if (0 != e)
mdb_fatal(e);
return 0;
default:
mdb_fatal(e);
}
e = mdb_txn_commit(txn);
if (0 != e)
mdb_fatal(e);
return 1;
}
static unsigned int __generate_ticket()
{
unsigned int ticket;
do
{
// TODO need better random number generator
ticket = rand();
}
while (__check_if_ticket_exists(ticket));
return ticket;
}
CAMLprim value caml_mdb_get(value txn,value dbi,value key){
CAMLparam3(txn,dbi,key);
CAMLlocal1(mldata);
MDB_val key_,data_;
key_.mv_data=String_val(key);
key_.mv_size=caml_string_length(key);
int ret;
if((ret=mdb_get( (MDB_txn*)txn, (MDB_dbi) Int_val(dbi), &key_, &data_ ))){
if(ret==MDB_NOTFOUND) {
static value *exn=NULL;
if(exn==NULL) exn=caml_named_value("lmdb_not_found");
caml_raise_constant(*exn);
} else
caml_failwith("error in mdb_get");
}
mldata=caml_alloc_string(data_.mv_size);
memcpy(String_val(mldata),data_.mv_data,data_.mv_size);
CAMLreturn(mldata);
}