自学教程：C++ tdb_fetch函数代码示例

static void show_tdb(void){	char *k = get_token(1);	TDB_DATA key, dbuf;	if (!k) {		help();		return;	}	key.dptr = k;	key.dsize = strlen(k)+1;	dbuf = tdb_fetch(tdb, key);	if (!dbuf.dptr) {		/* maybe it is non-NULL terminated key? */		key.dsize = strlen(k); 		dbuf = tdb_fetch(tdb, key);				if ( !dbuf.dptr ) {			terror("fetch failed");			return;		}	}		/* printf("%s : %*.*s/n", k, (int)dbuf.dsize, (int)dbuf.dsize, dbuf.dptr); */	print_rec(tdb, key, dbuf, NULL);		free( dbuf.dptr );		return;}

static void iterate_bundle_links(void (*func)(char *)){	TDB_DATA key, rec, pp;	char *p, *q;	key.dptr = blinks_id;	key.dsize = strlen(blinks_id);	rec = tdb_fetch(pppdb, key);	if (rec.dptr == NULL || rec.dsize <= 0) {		error("bundle link list not found (iterating list)");		if (rec.dptr != NULL)			free(rec.dptr);		return;	}	p = rec.dptr;	p[rec.dsize-1] = 0;	while ((q = strchr(p, ';')) != NULL) {		*q = 0;		key.dptr = p;		key.dsize = q - p;		pp = tdb_fetch(pppdb, key);		if (pp.dptr != NULL && pp.dsize > 0) {			pp.dptr[pp.dsize-1] = 0;			func(pp.dptr);		}		if (pp.dptr != NULL)			free(pp.dptr);		p = q + 1;	}	free(rec.dptr);}

int main(int argc, char *argv[]){	struct tdb_context *tdb;	TDB_DATA key, data;	plan_tests(10);	tdb = tdb_open_ex("run.tdb", 1024, TDB_CLEAR_IF_FIRST,			  O_CREAT|O_TRUNC|O_RDWR, 0600, &taplogctx, NULL);	ok1(tdb);	key.dsize = strlen("hi");	key.dptr = (void *)"hi";	data.dsize = strlen("world");	data.dptr = (void *)"world";	ok1(tdb_store(tdb, key, data, TDB_MODIFY) < 0);	ok1(tdb_error(tdb) == TDB_ERR_NOEXIST);	ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);	ok1(tdb_store(tdb, key, data, TDB_INSERT) < 0);	ok1(tdb_error(tdb) == TDB_ERR_EXISTS);	ok1(tdb_store(tdb, key, data, TDB_MODIFY) == 0);	data = tdb_fetch(tdb, key);	ok1(data.dsize == strlen("world"));	ok1(memcmp(data.dptr, "world", strlen("world")) == 0);	free(data.dptr);	key.dsize++;	data = tdb_fetch(tdb, key);	ok1(data.dptr == NULL);	tdb_close(tdb);	return exit_status();}

/*  write a record to a normal database*/int ctdb_ltdb_store(struct ctdb_db_context *ctdb_db, TDB_DATA key, 		    struct ctdb_ltdb_header *header, TDB_DATA data){	struct ctdb_context *ctdb = ctdb_db->ctdb;	TDB_DATA rec;	int ret;	bool seqnum_suppressed = false;	if (ctdb_db->ctdb_ltdb_store_fn) {		return ctdb_db->ctdb_ltdb_store_fn(ctdb_db, key, header, data);	}	if (ctdb->flags & CTDB_FLAG_TORTURE) {		struct ctdb_ltdb_header *h2;		rec = tdb_fetch(ctdb_db->ltdb->tdb, key);		h2 = (struct ctdb_ltdb_header *)rec.dptr;		if (rec.dptr && rec.dsize >= sizeof(h2) && h2->rsn > header->rsn) {			DEBUG(DEBUG_CRIT,("RSN regression! %llu %llu/n",				 (unsigned long long)h2->rsn, (unsigned long long)header->rsn));		}		if (rec.dptr) free(rec.dptr);	}	rec.dsize = sizeof(*header) + data.dsize;	rec.dptr = talloc_size(ctdb, rec.dsize);	CTDB_NO_MEMORY(ctdb, rec.dptr);	memcpy(rec.dptr, header, sizeof(*header));	memcpy(rec.dptr + sizeof(*header), data.dptr, data.dsize);	/* Databases with seqnum updates enabled only get their seqnum	   changes when/if we modify the data */	if (ctdb_db->seqnum_update != NULL) {		TDB_DATA old;		old = tdb_fetch(ctdb_db->ltdb->tdb, key);		if ( (old.dsize == rec.dsize)		&& !memcmp(old.dptr+sizeof(struct ctdb_ltdb_header),			  rec.dptr+sizeof(struct ctdb_ltdb_header),			  rec.dsize-sizeof(struct ctdb_ltdb_header)) ) {			tdb_remove_flags(ctdb_db->ltdb->tdb, TDB_SEQNUM);			seqnum_suppressed = true;		}		if (old.dptr) free(old.dptr);	}	ret = tdb_store(ctdb_db->ltdb->tdb, key, rec, TDB_REPLACE);	if (ret != 0) {		DEBUG(DEBUG_ERR, (__location__ " Failed to store dynamic data/n"));	}	if (seqnum_suppressed) {		tdb_add_flags(ctdb_db->ltdb->tdb, TDB_SEQNUM);	}	talloc_free(rec.dptr);	return ret;}

int main(int argc, char *argv[]){	unsigned int i;	struct tdb_context *tdb;	int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,			TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,			TDB_NOMMAP|TDB_CONVERT,			TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,			TDB_NOMMAP|TDB_VERSION1,			TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,			TDB_CONVERT|TDB_VERSION1,			TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };	struct tdb_data key = tdb_mkdata("key", 3);	struct tdb_data data = tdb_mkdata("data", 4);	failtest_init(argc, argv);	failtest_hook = block_repeat_failures;	failtest_exit_check = exit_check_log;	failtest_suppress = true;	plan_tests(sizeof(flags) / sizeof(flags[0]) * 8 + 1);	for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {		tdb = tdb_open("run-11-simple-fetch.tdb", flags[i],			       O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);		ok1(tdb);		if (tdb) {			struct tdb_data d = { NULL, 0 }; /* Bogus GCC warning */			/* fetch should fail. */			failtest_suppress = false;			if (!ok1(tdb_fetch(tdb, key, &d) == TDB_ERR_NOEXIST))				goto fail;			failtest_suppress = true;			ok1(tdb_check(tdb, NULL, NULL) == 0);			/* Insert should succeed. */			ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);			ok1(tdb_check(tdb, NULL, NULL) == 0);			/* Fetch should now work. */			failtest_suppress = false;			if (!ok1(tdb_fetch(tdb, key, &d) == TDB_SUCCESS))				goto fail;			failtest_suppress = true;			ok1(tdb_deq(d, data));			free(d.dptr);			ok1(tdb_check(tdb, NULL, NULL) == 0);			tdb_close(tdb);		}	}	ok1(tap_log_messages == 0);	failtest_exit(exit_status());fail:	failtest_suppress = true;	tdb_close(tdb);	failtest_exit(exit_status());}

static int check_filesystem(TDB_CONTEXT *tdb, io_channel channel){	__u32   s_mtime;	__u8    s_uuid[16];	errcode_t retval;	TDB_DATA tdb_key, tdb_data;	struct ext2_super_block super;	io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);	retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);	if (retval) {		com_err(prg_name,			retval, _("Failed to read the file system data /n"));		return retval;	}	tdb_key.dptr = mtime_key;	tdb_key.dsize = sizeof(mtime_key);	tdb_data = tdb_fetch(tdb, tdb_key);	if (!tdb_data.dptr) {		retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);		com_err(prg_name, retval,			_("Failed tdb_fetch %s/n"), tdb_errorstr(tdb));		return retval;	}	s_mtime = *(__u32 *)tdb_data.dptr;	if (super.s_mtime != s_mtime) {		com_err(prg_name, 0,			_("The file system Mount time didn't match %u/n"),			s_mtime);		return  -1;	}	tdb_key.dptr = uuid_key;	tdb_key.dsize = sizeof(uuid_key);	tdb_data = tdb_fetch(tdb, tdb_key);	if (!tdb_data.dptr) {		retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);		com_err(prg_name, retval,			_("Failed tdb_fetch %s/n"), tdb_errorstr(tdb));		return retval;	}	memcpy(s_uuid, tdb_data.dptr, sizeof(s_uuid));	if (memcmp(s_uuid, super.s_uuid, sizeof(s_uuid))) {		com_err(prg_name, 0,			_("The file system UUID didn't match /n"));		return -1;	}	return 0;}

static void move_rec(void){	char *k = get_token(1);	char *file = get_token(0);		TDB_DATA key, dbuf;	TDB_CONTEXT *dst_tdb;	if (!k) {		help();		return;	}		if ( !file ) {		terror("need destination tdb name");		return;	}	key.dptr = k;	key.dsize = strlen(k)+1;	dbuf = tdb_fetch(tdb, key);	if (!dbuf.dptr) {		/* maybe it is non-NULL terminated key? */		key.dsize = strlen(k); 		dbuf = tdb_fetch(tdb, key);				if ( !dbuf.dptr ) {			terror("fetch failed");			return;		}	}		print_rec(tdb, key, dbuf, NULL);		dst_tdb = tdb_open(file, 0, 0, O_RDWR, 0600);	if ( !dst_tdb ) {		terror("unable to open destination tdb");		return;	}		if ( tdb_store( dst_tdb, key, dbuf, TDB_REPLACE ) == -1 ) {		terror("failed to move record");	}	else		printf("record moved/n");		tdb_close( dst_tdb );		return;}

pa_datum* pa_database_next(pa_database *db, const pa_datum *key, pa_datum *next, pa_datum *data) {    TDB_DATA tdb_key, tdb_data;    pa_assert(db);    pa_assert(key);    tdb_key = tdb_nextkey(MAKE_TDB_CONTEXT(db), *datum_to_tdb(&tdb_key, key));    if (!tdb_key.dptr)        return NULL;    if (data) {        tdb_data = tdb_fetch(MAKE_TDB_CONTEXT(db), tdb_key);        if (!tdb_data.dptr) {            free(tdb_key.dptr);            return NULL;        }        datum_from_tdb(data, &tdb_data);    }    datum_from_tdb(next, &tdb_key);    return next;}

/******************************************************************* Get all share mode entries for a dev/inode pair.********************************************************************/int get_share_modes(struct vfs_connection_struct *conn,		    SMB_DEV_T dev, SMB_INO_T inode,		    share_mode_entry ** shares){	TDB_DATA dbuf;	struct locking_data *data;	int ret;	*shares = NULL;	dbuf = tdb_fetch(tdb, locking_key(dev, inode));	if (!dbuf.dptr)		return 0;	data = (struct locking_data *)dbuf.dptr;	ret = data->num_share_mode_entries;	if (ret)		*shares =			(share_mode_entry *) memdup(dbuf.dptr + sizeof(*data),						    ret * sizeof(**shares));	free(dbuf.dptr);	if (!*shares)		return 0;	return ret;}

int main(int argc, char *argv[]){	struct tdb_context *tdb;	TDB_DATA key, data;	plan_tests(4);	tdb = tdb_open_ex(NULL, 1024, TDB_INTERNAL, O_CREAT|O_TRUNC|O_RDWR,			  0600, &taplogctx, NULL);	ok1(tdb);	/* Tickle bug on appending zero length buffer to zero length buffer. */	key.dsize = strlen("hi");	key.dptr = (void *)"hi";	data.dptr = (void *)"world";	data.dsize = 0;	ok1(tdb_append(tdb, key, data) == 0);	ok1(tdb_append(tdb, key, data) == 0);	data = tdb_fetch(tdb, key);	ok1(data.dsize == 0);	tdb_close(tdb);	free(data.dptr);	return exit_status();}

/*    fetch an integer value from the config database, with a default value*/int config_get_int(const char *name, int default_v){	TDB_DATA data;	TDB_DATA key;	int v;	key.dptr = name;	key.dsize = strlen(name)+1;	data = tdb_fetch(config_db, key);	/* this trick allows config variables to show up in 'aconfig' as	   soon as they are used */	if (!data.dptr) {		char *s = NULL;		data.dsize = asprintf(&s, "%d", default_v) + 1;		data.dptr = s;		tdb_store(config_db, key, data, TDB_REPLACE);	}	v = atoi(data.dptr);	free(data.dptr);	return v;}

/** * data read * * @param int total read total */int _db_read_test(int total, char *df){	char n[16];	char *dat = NULL;	int i = 0;	int success = 0;	int s = 0;	if (total <= 0){		return 0;	}	clock_t start, finish;   	double duration;   	start=clock();	TDB *db = tdb_open(df, "r");	if ( !db ){		printf("db_open() %s fail./n", df);		return 0;	}	for (i=0; i<total; i++){		sprintf(n, "num%d", i);		dat = tdb_fetch(db, n);		if (NULL != dat){			success++;		}	}	tdb_close(db);	finish=clock();   	duration=(double)(finish-start)/CLOCKS_PER_SEC;   	printf("db read data test success: %d, used time: %fs/n", success, duration);	return success;}

static void remove_bundle_link(){	TDB_DATA key, rec;	char entry[32];	char *p, *q;	int l;	key.dptr = blinks_id;	key.dsize = strlen(blinks_id);	slprintf(entry, sizeof(entry), "%s;", db_key);	rec = tdb_fetch(pppdb, key);	if (rec.dptr == NULL || rec.dsize <= 0) {		if (rec.dptr != NULL)			free(rec.dptr);		return;	}	rec.dptr[rec.dsize-1] = 0;	p = strstr(rec.dptr, entry);	if (p != NULL) {		q = p + strlen(entry);		l = strlen(q) + 1;		memmove(p, q, l);		rec.dsize = p - rec.dptr + l;		if (tdb_store(pppdb, key, rec, TDB_REPLACE))			error("couldn't update bundle link list (removal)");	}	free(rec.dptr);}

/*  fetch a record from the ltdb, separating out the header information  and returning the body of the record.  if the record does not exist, *header will be NULL  and data = {0, NULL}*/int ctdb_ltdb_fetch_with_header(struct ctdb_db_context *ctdb_db, 		    TDB_DATA key, struct ctdb_ltdb_header *header, 		    TALLOC_CTX *mem_ctx, TDB_DATA *data){	TDB_DATA rec;	rec = tdb_fetch(ctdb_db->ltdb->tdb, key);	if (rec.dsize < sizeof(*header)) {		free(rec.dptr);		data->dsize = 0;		data->dptr = NULL;		return -1;	}	*header = *(struct ctdb_ltdb_header *)rec.dptr;	if (data) {		data->dsize = rec.dsize - sizeof(struct ctdb_ltdb_header);		data->dptr = talloc_memdup(mem_ctx, 					   sizeof(struct ctdb_ltdb_header)+rec.dptr,					   data->dsize);	}	free(rec.dptr);	return 0;}

int main(int argc, char *argv[]){	struct tdb_context *tdb;	TDB_DATA key, data;	union tdb_attribute hsize;	hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;	hsize.base.next = &tap_log_attr;	hsize.tdb1_hashsize.hsize = 1024;	plan_tests(5);	tdb = tdb_open(NULL, TDB_INTERNAL|TDB_VERSION1, O_CREAT|O_TRUNC|O_RDWR,		       0600, &hsize);	ok1(tdb);	/* Tickle bug on appending zero length buffer to zero length buffer. */	key = tdb_mkdata("hi", strlen("hi"));	data = tdb_mkdata("world", 0);	ok1(tdb_append(tdb, key, data) == TDB_SUCCESS);	ok1(tdb_append(tdb, key, data) == TDB_SUCCESS);	ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);	ok1(data.dsize == 0);	free(data.dptr);	tdb_close(tdb);	return exit_status();}

pa_datum* pa_database_first(pa_database *db, pa_datum *key, pa_datum *data) {    TDB_DATA tdb_key, tdb_data;    pa_assert(db);    pa_assert(key);    tdb_key = tdb_firstkey(MAKE_TDB_CONTEXT(db));    if (!tdb_key.dptr)        return NULL;    if (data) {        tdb_data = tdb_fetch(MAKE_TDB_CONTEXT(db), tdb_key);        if (!tdb_data.dptr) {            free(tdb_key.dptr);            return NULL;        }        datum_from_tdb(data, &tdb_data);    }    datum_from_tdb(key, &tdb_key);    return key;}

/** * Returns a single value from the database * * @warning The caller must free the returned data. * * @param [out]	   value	pointer to the value being read * @param [out]    size	    number of bytes of @c value parameter * @param [in]     key		pointer to a string containing the key in the ENV db * @param [in]     db		pointer of a tdb object; * * @return error code * 	@retval ERR_OK = OK * 	@retval ERR_DB_INVALID = failed to access tdb * 	@retval ERR_STRING_NULL = key not found */int get_value(const unsigned char *key,              unsigned char **value,              int *size,              DATABASE *db){                 int ret = ERR_OK;    TDB_DATA dkey,dvalue ;    if( NULL == db )        return ERR_DB_INVALID;        dkey = string_to_tdb(key);    if( 0 == dkey.dsize )        return ERR_STRING_NULL;    while( sem_wait( &db->sem ) == -1 && errno == EINTR );	dvalue = tdb_fetch(db->tdb, dkey);	sem_post( &db->sem );	if (NULL == dvalue.dptr)		ret = ERR_STRING_NULL;	*value =  dvalue.dptr;	*size = dvalue.dsize;	free(dkey.dptr);    return ret;}

/* Append to an entry. Create if not exist. */int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf){	u32 hash;	TDB_DATA dbuf;	int ret = -1;	/* find which hash bucket it is in */	hash = tdb->hash_fn(&key);	if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)		return -1;	dbuf = tdb_fetch(tdb, key);	if (dbuf.dptr == NULL) {		dbuf.dptr = (char *)malloc(new_dbuf.dsize);	} else {		dbuf.dptr = (char *)realloc(dbuf.dptr,					    dbuf.dsize + new_dbuf.dsize);	}	if (dbuf.dptr == NULL) {		tdb->ecode = TDB_ERR_OOM;		goto failed;	}	memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);	dbuf.dsize += new_dbuf.dsize;	ret = tdb_store(tdb, key, dbuf, 0);	failed:	tdb_unlock(tdb, BUCKET(hash), F_WRLCK);	SAFE_FREE(dbuf.dptr);	return ret;}

static void addrec_db(void){	int klen, dlen;	char *k, *d;	TDB_DATA key, data;	klen = 1 + (rand() % 4);	dlen = 1 + (rand() % 100);	k = randbuf(klen);	d = randbuf(dlen);	key.dptr = k;	key.dsize = klen+1;	data.dptr = d;	data.dsize = dlen+1;	if (rand() % DELETE_PROB == 0) {		tdb_delete(db, key);	} else if (rand() % STORE_PROB == 0) {		if (tdb_store(db, key, data, TDB_REPLACE) != 0) {			fatal("tdb_store failed");		}	} else {		data = tdb_fetch(db, key);		if (data.dptr) free(data.dptr);	}	free(k);	free(d);}

static errcode_t get_inode_count(ext2_icount_t icount, ext2_ino_t ino,				 __u32 *count){	struct ext2_icount_el 	*el;	TDB_DATA key, data;	if (icount->tdb) {		key.dptr = (unsigned char *) &ino;		key.dsize = sizeof(ext2_ino_t);		data = tdb_fetch(icount->tdb, key);		if (data.dptr == NULL) {			*count = 0;			return tdb_error(icount->tdb) + EXT2_ET_TDB_SUCCESS;		}		*count = *((__u32 *) data.dptr);		free(data.dptr);		return 0;	}	el = get_icount_el(icount, ino, 0);	if (!el) {		*count = 0;		return ENOENT;	}	*count = el->count;	return 0;}

BOOL modify_delete_flag( SMB_DEV_T dev, SMB_INO_T inode, BOOL delete_on_close){	TDB_DATA dbuf;	struct locking_data *data;	int i;	share_mode_entry *shares;	/* read in the existing share modes */	dbuf = tdb_fetch(tdb, locking_key(dev, inode));	if (!dbuf.dptr)		return False;	data = (struct locking_data *)dbuf.dptr;	shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data));	/* Set/Unset the delete on close element. */	for (i=0;i<data->u.num_share_mode_entries;i++,shares++) {		shares->share_mode = (delete_on_close ?			    (shares->share_mode | DELETE_ON_CLOSE_FLAG) :			    (shares->share_mode & ~DELETE_ON_CLOSE_FLAG) );	}	/* store it back */	if (data->u.num_share_mode_entries) {		if (tdb_store(tdb, locking_key(dev,inode), dbuf, TDB_REPLACE)==-1) {			SAFE_FREE(dbuf.dptr);			return False;		}	}	SAFE_FREE(dbuf.dptr);	return True;}

static bool _reg_perfcount_get_counter_data(TDB_DATA key, TDB_DATA *data){	TDB_CONTEXT *counters;	char *fname;	fname = counters_directory(DATA_DB);	if (fname == NULL) {		return false;	}	counters = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);	if (counters == NULL) {		DEBUG(1, ("reg_perfcount_get_counter_data: unable to open [%s]./n", fname));		TALLOC_FREE(fname);		return False;	}	TALLOC_FREE(fname);	*data = tdb_fetch(counters, key);	tdb_close(counters);	return True;}

static int dump_tdb(const char *fname, const char *keyname, bool emergency){	TDB_CONTEXT *tdb;	TDB_DATA key, value;	struct tdb_logging_context logfn = { log_stderr };	tdb = tdb_open_ex(fname, 0, 0, O_RDONLY, 0, &logfn, NULL);	if (!tdb) {		printf("Failed to open %s/n", fname);		return 1;	}	if (emergency) {		return tdb_rescue(tdb, emergency_walk, keyname) == 0;	}	if (!keyname) {		return tdb_traverse(tdb, traverse_fn, NULL) == -1 ? 1 : 0;	} else {		key.dptr = discard_const_p(uint8_t, keyname);		key.dsize = strlen(keyname);		value = tdb_fetch(tdb, key);		if (!value.dptr) {			return 1;		} else {			print_data(value);			free(value.dptr);		}	}	return 0;}

/* returns the size of the uncompressed file, or 0 if it could not be * determined. */static off_t get_uncompressed_size(const char *path){        struct ecm *ecm;        size_t pos;        TDB_DATA key, data;        LOG("GET_UNCOMPRESSED_SIZE [%s]/n", path);        key.dptr = discard_const(path);        key.dsize = strlen(path);        data = tdb_fetch(filesize_tdb, key);        if (data.dptr) {                off_t size = *(off_t *)data.dptr;                free(data.dptr);                return size;        }        LOG("GET_UNCOMPRESSED_SIZE SLOW PATH [%s]/n", path);        ecm = ecm_open_file(dir_fd, path);        if (ecm == NULL) {                LOG("Failed to open ECM file %s in get_uncompressed_size/n",                    path);                return 0;        }        pos = ecm_get_file_size(ecm);        ecm_close_file(ecm);        LOG("GET_UNCOMPRESSED_SIZE [%s] %zu/n", path, pos);        data.dptr = (uint8_t *)&pos;        data.dsize = sizeof(pos);        tdb_store(filesize_tdb, key, data, TDB_REPLACE);        return pos;}

static PyObject *get_urn_by_id(BaseTDBResolver *self, PyObject *args, PyObject *kwds) {  static char *kwlist[] = {"id", NULL};  char buff[BUFF_SIZE];  uint32_t id;  PyObject *result, *id_obj;  TDB_DATA urn;  TDB_DATA key;  if(!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, 				  &id_obj))    return NULL;  id_obj = PyNumber_Long(id_obj);  if(!id_obj) return NULL;  id = PyLong_AsUnsignedLongLong(id_obj);  Py_DECREF(id_obj);  /* We get given an ID and we retrieve the URN it belongs to */  key.dptr = (unsigned char *)buff;  key.dsize = from_int(id, buff, BUFF_SIZE);  urn = tdb_fetch(self->urn_db, key);    if(urn.dptr) {    result = PyString_FromStringAndSize((char *)urn.dptr, urn.dsize);    free(urn.dptr);    return result;  };  Py_RETURN_NONE;};

/** returns the list head in the data file for the uri and attribute    specified. Return 1 if found, 0 if not found. */static uint32_t get_data_head(BaseTDBResolver *self, TDB_DATA uri, TDB_DATA attribute, 			 TDB_DATA_LIST *result) {  char buff[BUFF_SIZE];  TDB_DATA data_key;  data_key.dptr = (unsigned char *)buff;  data_key.dsize = calculate_key(self, uri, attribute, buff, BUFF_SIZE, 0);  if(data_key.dsize > 0) {    // We found these attribute/urn    TDB_DATA offset_serialised = tdb_fetch(self->data_db, data_key);    if(offset_serialised.dptr) {      // We found the head - read the struct      uint32_t offset = to_int(offset_serialised);      lseek(self->data_store_fd, offset, SEEK_SET);      if(read(self->data_store_fd, result, sizeof(*result)) == sizeof(*result)) {	return offset;      };            free(offset_serialised.dptr);    };  };  return 0;};

static void compare_db(void){	TDB_DATA d, key, nextkey;	datum gd, gkey, gnextkey;	key = tdb_firstkey(db);	while (key.dptr) {		d = tdb_fetch(db, key);		gkey.dptr = key.dptr;		gkey.dsize = key.dsize;		gd = gdbm_fetch(gdbm, gkey);		if (!gd.dptr) fatal("key not in gdbm");		if (gd.dsize != d.dsize) fatal("data sizes differ");		if (memcmp(gd.dptr, d.dptr, d.dsize)) {			fatal("data differs");		}		nextkey = tdb_nextkey(db, key);		free(key.dptr);		free(d.dptr);		free(gd.dptr);		key = nextkey;	}	gkey = gdbm_firstkey(gdbm);	while (gkey.dptr) {		gd = gdbm_fetch(gdbm, gkey);		key.dptr = gkey.dptr;		key.dsize = gkey.dsize;		d = tdb_fetch(db, key);		if (!d.dptr) fatal("key not in db");		if (d.dsize != gd.dsize) fatal("data sizes differ");		if (memcmp(d.dptr, gd.dptr, gd.dsize)) {			fatal("data differs");		}		gnextkey = gdbm_nextkey(gdbm, gkey);		free(gkey.dptr);		free(gd.dptr);		free(d.dptr);		gkey = gnextkey;	}}

static uint32_t _reg_perfcount_multi_sz_from_tdb(TDB_CONTEXT *tdb,					       int keyval,					       char **retbuf,					       uint32_t buffer_size){	TDB_DATA kbuf, dbuf;	char temp[PERFCOUNT_MAX_LEN] = {0};	char *buf1 = *retbuf;	uint32_t working_size = 0;	DATA_BLOB name_index, name;	bool ok;	snprintf(temp, sizeof(temp), "%d", keyval);	kbuf = string_tdb_data(temp);	dbuf = tdb_fetch(tdb, kbuf);	if(dbuf.dptr == NULL)	{		/* If a key isn't there, just bypass it -- this really shouldn't 		   happen unless someone's mucking around with the tdb */		DEBUG(3, ("_reg_perfcount_multi_sz_from_tdb: failed to find key [%s] in [%s]./n",			  temp, tdb_name(tdb)));		return buffer_size;	}	/* First encode the name_index */	working_size = (kbuf.dsize + 1)*sizeof(uint16_t);	buf1 = (char *)SMB_REALLOC(buf1, buffer_size + working_size);	if(!buf1) {		buffer_size = 0;		return buffer_size;	}	ok = push_reg_sz(talloc_tos(), &name_index, (const char *)kbuf.dptr);	if (!ok) {		buffer_size = 0;		return buffer_size;	}	memcpy(buf1+buffer_size, (char *)name_index.data, working_size);	buffer_size += working_size;	/* Now encode the actual name */	working_size = (dbuf.dsize + 1)*sizeof(uint16_t);	buf1 = (char *)SMB_REALLOC(buf1, buffer_size + working_size);	if(!buf1) {		buffer_size = 0;		return buffer_size;	}	memset(temp, 0, sizeof(temp));	memcpy(temp, dbuf.dptr, dbuf.dsize);	SAFE_FREE(dbuf.dptr);	ok = push_reg_sz(talloc_tos(), &name, temp);	if (!ok) {		buffer_size = 0;		return buffer_size;	}	memcpy(buf1+buffer_size, (char *)name.data, working_size);	buffer_size += working_size;	*retbuf = buf1;	return buffer_size;}