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

static errcode_t set_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.dptr = (unsigned char *) &count;		data.dsize = sizeof(__u32);		if (count) {			if (tdb_store(icount->tdb, key, data, TDB_REPLACE))				return tdb_error(icount->tdb) +					EXT2_ET_TDB_SUCCESS;		} else {			if (tdb_delete(icount->tdb, key))				return tdb_error(icount->tdb) +					EXT2_ET_TDB_SUCCESS;		}		return 0;	}	el = get_icount_el(icount, ino, 1);	if (!el)		return EXT2_ET_NO_MEMORY;	el->count = count;	return 0;}

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();}

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;}

/*  store a record into the db*/int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs){	void *data = ldb_module_get_private(module);	struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);	TDB_DATA tdb_key, tdb_data;	int ret;	tdb_key = ltdb_key(module, msg->dn);	if (!tdb_key.dptr) {		return LDB_ERR_OTHER;	}	ret = ltdb_pack_data(module, msg, &tdb_data);	if (ret == -1) {		talloc_free(tdb_key.dptr);		return LDB_ERR_OTHER;	}	ret = tdb_store(ltdb->tdb, tdb_key, tdb_data, flgs);	if (ret == -1) {		ret = ltdb_err_map(tdb_error(ltdb->tdb));		goto done;	}	ret = ltdb_index_add(module, msg);	if (ret != LDB_SUCCESS) {		tdb_delete(ltdb->tdb, tdb_key);	}done:	talloc_free(tdb_key.dptr);	talloc_free(tdb_data.dptr);	return ret;}

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;}

static BOOL allowable_number_of_smbd_processes(void){	int max_processes = lp_max_smbd_processes();	if (!max_processes)		return True;	{		TDB_CONTEXT *tdb = conn_tdb_ctx();		int32 val;		if (!tdb) {			DEBUG(0,("allowable_number_of_smbd_processes: can't open connection tdb./n" ));			return False;		}		val = tdb_fetch_int32(tdb, "INFO/total_smbds");		if (val == -1 && (tdb_error(tdb) != TDB_ERR_NOEXIST)) {			DEBUG(0,("allowable_number_of_smbd_processes: can't fetch INFO/total_smbds. Error %s/n",				tdb_errorstr(tdb) ));			return False;		}		if (val > max_processes) {			DEBUG(0,("allowable_number_of_smbd_processes: number of processes (%d) is over allowed limit (%d)/n",				val, max_processes ));			return False;		}	}	return True;}

int main(int argc, char *argv[]){    struct tdb_context *tdb;    TDB_DATA key, data;    plan_tests(11);    tdb = tdb_open_ex("run-readonly-check.tdb", 1024,                      TDB_DEFAULT,                      O_CREAT|O_TRUNC|O_RDWR, 0600, &taplogctx, NULL);    ok1(tdb);    key.dsize = strlen("hi");    key.dptr = discard_const_p(uint8_t, "hi");    data.dsize = strlen("world");    data.dptr = discard_const_p(uint8_t, "world");    ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);    ok1(tdb_check(tdb, NULL, NULL) == 0);    /* We are also allowed to do a check inside a transaction. */    ok1(tdb_transaction_start(tdb) == 0);    ok1(tdb_check(tdb, NULL, NULL) == 0);    ok1(tdb_close(tdb) == 0);    tdb = tdb_open_ex("run-readonly-check.tdb", 1024,                      TDB_DEFAULT, O_RDONLY, 0, &taplogctx, NULL);    ok1(tdb);    ok1(tdb_store(tdb, key, data, TDB_MODIFY) == -1);    ok1(tdb_error(tdb) == TDB_ERR_RDONLY);    ok1(tdb_check(tdb, NULL, NULL) == 0);    ok1(tdb_close(tdb) == 0);    return exit_status();}

/*  store a record into the db*/int ltdb_store(struct ldb_module *module, const struct ldb_message *msg, int flgs){	void *data = ldb_module_get_private(module);	struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);	TDB_DATA tdb_key, tdb_data;	struct ldb_val ldb_data;	int ret = LDB_SUCCESS;	tdb_key = ltdb_key(module, msg->dn);	if (tdb_key.dptr == NULL) {		return LDB_ERR_OTHER;	}	ret = ldb_pack_data(ldb_module_get_ctx(module),			    msg, &ldb_data);	if (ret == -1) {		talloc_free(tdb_key.dptr);		return LDB_ERR_OTHER;	}	tdb_data.dptr = ldb_data.data;	tdb_data.dsize = ldb_data.length;	ret = tdb_store(ltdb->tdb, tdb_key, tdb_data, flgs);	if (ret != 0) {		ret = ltdb_err_map(tdb_error(ltdb->tdb));		goto done;	}done:	talloc_free(tdb_key.dptr);	talloc_free(ldb_data.data);	return ret;}

static errcode_t write_file_system_identity(io_channel undo_channel,							TDB_CONTEXT *tdb){	errcode_t retval;	struct ext2_super_block super;	TDB_DATA tdb_key, tdb_data;	struct undo_private_data *data;	io_channel channel;	int block_size ;	data = (struct undo_private_data *) undo_channel->private_data;	channel = data->real;	block_size = channel->block_size;	io_channel_set_blksize(channel, SUPERBLOCK_OFFSET);	retval = io_channel_read_blk64(channel, 1, -SUPERBLOCK_SIZE, &super);	if (retval)		goto err_out;	/* Write to tdb file in the file system byte order */	tdb_key.dptr = mtime_key;	tdb_key.dsize = sizeof(mtime_key);	tdb_data.dptr = (unsigned char *) &(super.s_mtime);	tdb_data.dsize = sizeof(super.s_mtime);	retval = tdb_store(tdb, tdb_key, tdb_data, TDB_INSERT);	if (retval == -1) {		retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);		goto err_out;	}	tdb_key.dptr = uuid_key;	tdb_key.dsize = sizeof(uuid_key);	tdb_data.dptr = (unsigned char *)&(super.s_uuid);	tdb_data.dsize = sizeof(super.s_uuid);	retval = tdb_store(tdb, tdb_key, tdb_data, TDB_INSERT);	if (retval == -1) {		retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);	}err_out:	io_channel_set_blksize(channel, block_size);	return retval;}

static int ltdb_del_trans(struct ldb_module *module){	void *data = ldb_module_get_private(module);	struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);	ltdb->in_transaction--;	if (ltdb_index_transaction_cancel(module) != 0) {		tdb_transaction_cancel(ltdb->tdb);		return ltdb_err_map(tdb_error(ltdb->tdb));	}	if (tdb_transaction_cancel(ltdb->tdb) != 0) {		return ltdb_err_map(tdb_error(ltdb->tdb));	}	return LDB_SUCCESS;}

static NTSTATUS db_tdb_transaction_start_nonblock(struct db_context *db){	struct db_tdb_ctx *db_ctx =		talloc_get_type_abort(db->private_data, struct db_tdb_ctx);	int ret;	ret = tdb_transaction_start_nonblock(db_ctx->wtdb->tdb);	if (ret != 0) {		return map_nt_error_from_tdb(tdb_error(db_ctx->wtdb->tdb));	}	return NT_STATUS_OK;}

/* * Read a key with uint64 value */static int partition_metadata_get_uint64(struct ldb_module *module,					 const char *key, uint64_t *value,					 uint64_t default_value){	struct partition_private_data *data;	struct tdb_context *tdb;	TDB_DATA tdb_key, tdb_data;	char *value_str;	TALLOC_CTX *tmp_ctx;	data = talloc_get_type_abort(ldb_module_get_private(module),				     struct partition_private_data);	if (!data || !data->metadata || !data->metadata->db) {		return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,					"partition_metadata: metadata tdb not initialized");	}	tmp_ctx = talloc_new(NULL);	if (tmp_ctx == NULL) {		return ldb_module_oom(module);	}	tdb = data->metadata->db->tdb;	tdb_key.dptr = (uint8_t *)discard_const_p(char, key);	tdb_key.dsize = strlen(key);	tdb_data = tdb_fetch(tdb, tdb_key);	if (!tdb_data.dptr) {		if (tdb_error(tdb) == TDB_ERR_NOEXIST) {			*value = default_value;			return LDB_SUCCESS;		} else {			return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,						tdb_errorstr(tdb));		}	}	value_str = talloc_strndup(tmp_ctx, (char *)tdb_data.dptr, tdb_data.dsize);	if (value_str == NULL) {		SAFE_FREE(tdb_data.dptr);		talloc_free(tmp_ctx);		return ldb_module_oom(module);	}	*value = strtoull(value_str, NULL, 10);	SAFE_FREE(tdb_data.dptr);	talloc_free(tmp_ctx);	return LDB_SUCCESS;}

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 = 1;	plan_tests(13);	tdb = tdb_open("run-check.tdb1", TDB_VERSION1,		       O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);	key = tdb_mkdata("hi", strlen("hi"));	data = tdb_mkdata("world", strlen("world"));	ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);	ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);	tdb_close(tdb);	tdb = tdb_open("run-check.tdb1", TDB_VERSION1, O_RDWR, 0, &tap_log_attr);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);	tdb_close(tdb);	tdb = tdb_open("test/tdb1.corrupt", TDB_VERSION1, O_RDWR, 0,			&tap_log_attr);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == TDB_ERR_CORRUPT);	ok1(tdb_error(tdb) == TDB_ERR_CORRUPT);	tdb_close(tdb);	/* Big and little endian should work! */	tdb = tdb_open("test/old-nohash-le.tdb1", TDB_VERSION1, O_RDWR, 0,		       &tap_log_attr);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);	tdb_close(tdb);	tdb = tdb_open("test/old-nohash-be.tdb1", TDB_VERSION1, O_RDWR, 0,			&tap_log_attr);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);	tdb_close(tdb);	return exit_status();}

int main(int argc, char *argv[]){	struct tdb_context *tdb;	TDB_DATA key, data;	plan_tests(13);	tdb = tdb_open_ex("run-check.tdb", 1, TDB_CLEAR_IF_FIRST,			  O_CREAT|O_TRUNC|O_RDWR, 0600, &taplogctx, NULL);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == 0);	key.dsize = strlen("hi");	key.dptr = discard_const_p(uint8_t, "hi");	data.dsize = strlen("world");	data.dptr = discard_const_p(uint8_t, "world");	ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);	ok1(tdb_check(tdb, NULL, NULL) == 0);	tdb_close(tdb);	tdb = tdb_open_ex("run-check.tdb", 1024, 0, O_RDWR, 0,			  &taplogctx, NULL);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == 0);	tdb_close(tdb);	tdb = tdb_open_ex("test/tdb.corrupt", 1024, 0, O_RDWR, 0,			  &taplogctx, NULL);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == -1);	ok1(tdb_error(tdb) == TDB_ERR_CORRUPT);	tdb_close(tdb);	/* Big and little endian should work! */	tdb = tdb_open_ex("test/old-nohash-le.tdb", 1024, 0, O_RDWR, 0,			  &taplogctx, NULL);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == 0);	tdb_close(tdb);	tdb = tdb_open_ex("test/old-nohash-be.tdb", 1024, 0, O_RDWR, 0,			  &taplogctx, NULL);	ok1(tdb);	ok1(tdb_check(tdb, NULL, NULL) == 0);	tdb_close(tdb);	return exit_status();}

static int ltdb_prepare_commit(struct ldb_module *module){	void *data = ldb_module_get_private(module);	struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);	if (ltdb->in_transaction != 1) {		return LDB_SUCCESS;	}	if (ltdb_index_transaction_commit(module) != 0) {		tdb_transaction_cancel(ltdb->tdb);		ltdb->in_transaction--;		return ltdb_err_map(tdb_error(ltdb->tdb));	}	if (tdb_transaction_prepare_commit(ltdb->tdb) != 0) {		ltdb->in_transaction--;		return ltdb_err_map(tdb_error(ltdb->tdb));	}	ltdb->prepared_commit = true;	return LDB_SUCCESS;}

static int ltdb_start_trans(struct ldb_module *module){	void *data = ldb_module_get_private(module);	struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);	if (tdb_transaction_start(ltdb->tdb) != 0) {		return ltdb_err_map(tdb_error(ltdb->tdb));	}	ltdb->in_transaction++;	ltdb_index_transaction_start(module);	return LDB_SUCCESS;}

static NTSTATUS db_tdb_delete(struct db_record *rec){	struct db_tdb_ctx *ctx = talloc_get_type_abort(rec->private_data,						       struct db_tdb_ctx);	if (tdb_delete(ctx->wtdb->tdb, rec->key) == 0) {		return NT_STATUS_OK;	}	if (tdb_error(ctx->wtdb->tdb) == TDB_ERR_NOEXIST) {		return NT_STATUS_NOT_FOUND;	}	return NT_STATUS_UNSUCCESSFUL;}

static errcode_t write_block_size(TDB_CONTEXT *tdb, int block_size){	errcode_t retval;	TDB_DATA tdb_key, tdb_data;	tdb_key.dptr = blksize_key;	tdb_key.dsize = sizeof(blksize_key);	tdb_data.dptr = (unsigned char *)&(block_size);	tdb_data.dsize = sizeof(block_size);	retval = tdb_store(tdb, tdb_key, tdb_data, TDB_INSERT);	if (retval == -1) {		retval = EXT2_ET_TDB_SUCCESS + tdb_error(tdb);	}	return retval;}

static NTSTATUS tdb_error_to_ntstatus(struct tdb_context *tdb){	NTSTATUS status;	enum TDB_ERROR tret = tdb_error(tdb);	switch (tret) {	case TDB_ERR_EXISTS:		status = NT_STATUS_OBJECT_NAME_COLLISION;		break;	case TDB_ERR_NOEXIST:		status = NT_STATUS_OBJECT_NAME_NOT_FOUND;		break;	default:		status = NT_STATUS_INTERNAL_DB_CORRUPTION;		break;	}	return status;}

static NTSTATUS db_tdb_parse(struct db_context *db, TDB_DATA key,			     void (*parser)(TDB_DATA key, TDB_DATA data,					   void *private_data),			     void *private_data){	struct db_tdb_ctx *ctx = talloc_get_type_abort(		db->private_data, struct db_tdb_ctx);	struct db_tdb_parse_state state;	int ret;	state.parser = parser;	state.private_data = private_data;	ret = tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_parser, &state);	if (ret != 0) {		return map_nt_error_from_tdb(tdb_error(ctx->wtdb->tdb));	}	return NT_STATUS_OK;}

static int ltdb_end_trans(struct ldb_module *module){	void *data = ldb_module_get_private(module);	struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);	if (!ltdb->prepared_commit) {		int ret = ltdb_prepare_commit(module);		if (ret != LDB_SUCCESS) {			return ret;		}	}	ltdb->in_transaction--;	ltdb->prepared_commit = false;	if (tdb_transaction_commit(ltdb->tdb) != 0) {		return ltdb_err_map(tdb_error(ltdb->tdb));	}	return LDB_SUCCESS;}

BOOL yield_connection(connection_struct *conn, const char *name){	struct connections_key key;	TDB_DATA kbuf;	if (!tdb)		return False;	DEBUG(3,("Yielding connection to %s/n",name));	make_conn_key(conn, name, &kbuf, &key);	if (tdb_delete(tdb, kbuf) != 0) {		int dbg_lvl = (!conn && (tdb_error(tdb) == TDB_ERR_NOEXIST)) ? 3 : 0;		DEBUG(dbg_lvl,("yield_connection: tdb_delete for name %s failed with error %s./n",			name, tdb_errorstr(tdb) ));		return (False);	}	return(True);}

/*  delete a record from the database, not updating indexes (used for deleting  index records)*/int ltdb_delete_noindex(struct ldb_module *module, struct ldb_dn *dn){	void *data = ldb_module_get_private(module);	struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);	TDB_DATA tdb_key;	int ret;	tdb_key = ltdb_key(module, dn);	if (!tdb_key.dptr) {		return LDB_ERR_OTHER;	}	ret = tdb_delete(ltdb->tdb, tdb_key);	talloc_free(tdb_key.dptr);	if (ret != 0) {		ret = ltdb_err_map(tdb_error(ltdb->tdb));	}	return ret;}

static int db_hash_map_tdb_error(struct db_hash_context *dh){	enum TDB_ERROR tdb_err;	int ret;	tdb_err = tdb_error(dh->db);	switch (tdb_err) {		case TDB_SUCCESS:			ret = 0; break;		case TDB_ERR_OOM:			ret = ENOMEM; break;		case TDB_ERR_EXISTS:			ret = EEXIST; break;		case TDB_ERR_NOEXIST:			ret = ENOENT; break;		case TDB_ERR_EINVAL:			ret = EINVAL; break;		default:			ret = EIO; break;	}	return ret;}

bool tdb_change_uint32_atomic(struct tdb_context *tdb, const char *keystr, uint32_t *oldval, uint32_t change_val){	uint32_t val;	bool ret = false;	if (tdb_lock_bystring(tdb, keystr) == -1)		return false;	if (!tdb_fetch_uint32(tdb, keystr, &val)) {		/* It failed */		if (tdb_error(tdb) != TDB_ERR_NOEXIST) { 			/* and not because it didn't exist */			goto err_out;		}		/* Start with 'old' value */		val = *oldval;	} else {		/* it worked, set return value (oldval) to tdb data */		*oldval = val;	}	/* get a new value to store */	val += change_val;			if (!tdb_store_uint32(tdb, keystr, val))		goto err_out;	ret = true;  err_out:	tdb_unlock_bystring(tdb, keystr);	return ret;}

static int set_blk_size(TDB_CONTEXT *tdb, io_channel channel){	int block_size;	errcode_t retval;	TDB_DATA tdb_key, tdb_data;	tdb_key.dptr = blksize_key;	tdb_key.dsize = sizeof(blksize_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;	}	block_size = *(int *)tdb_data.dptr;#ifdef DEBUG	printf("Block size %d/n", block_size);#endif	io_channel_set_blksize(channel, block_size);	return 0;}

static struct db_record *db_tdb_fetch_locked_internal(	struct db_context *db, TALLOC_CTX *mem_ctx, TDB_DATA key){	struct db_tdb_ctx *ctx = talloc_get_type_abort(db->private_data,						       struct db_tdb_ctx);	struct tdb_fetch_locked_state state;	state.mem_ctx = mem_ctx;	state.result = NULL;	if ((tdb_parse_record(ctx->wtdb->tdb, key, db_tdb_fetchlock_parse,			      &state) < 0) &&	    (tdb_error(ctx->wtdb->tdb) != TDB_ERR_NOEXIST)) {		tdb_chainunlock(ctx->wtdb->tdb, key);		return NULL;	}	if (state.result == NULL) {		db_tdb_fetchlock_parse(key, tdb_null, &state);	}	if (state.result == NULL) {		tdb_chainunlock(ctx->wtdb->tdb, key);		return NULL;	}	talloc_set_destructor(state.result, db_tdb_record_destr);	state.result->private_data = talloc_reference(state.result, ctx);	state.result->store = db_tdb_store;	state.result->delete_rec = db_tdb_delete;	DEBUG(10, ("Allocated locked data 0x%p/n", state.result));	return state.result;}

int32_t tdb_change_int32_atomic(struct tdb_context *tdb, const char *keystr, int32_t *oldval, int32_t change_val){	int32_t val;	int32_t ret = -1;	if (tdb_lock_bystring(tdb, keystr) == -1)		return -1;	if ((val = tdb_fetch_int32(tdb, keystr)) == -1) {		/* The lookup failed */		if (tdb_error(tdb) != TDB_ERR_NOEXIST) {			/* but not because it didn't exist */			goto err_out;		}				/* Start with 'old' value */		val = *oldval;	} else {		/* It worked, set return value (oldval) to tdb data */		*oldval = val;	}	/* Increment value for storage and return next time */	val += change_val;			if (tdb_store_int32(tdb, keystr, val) == -1)		goto err_out;	ret = 0;  err_out:	tdb_unlock_bystring(tdb, keystr);	return ret;}

static NTSTATUS tdb_error_to_ntstatus(struct tdb_context *tdb){	enum TDB_ERROR tret = tdb_error(tdb);	return map_nt_error_from_tdb(tret);}

/*  modify a record - internal interface  yuck - this is O(n^2). Luckily n is usually small so we probably  get away with it, but if we ever have really large attribute lists  then we'll need to look at this again  'req' is optional, and is used to specify controls if supplied*/int ltdb_modify_internal(struct ldb_module *module,			 const struct ldb_message *msg,			 struct ldb_request *req){	struct ldb_context *ldb = ldb_module_get_ctx(module);	void *data = ldb_module_get_private(module);	struct ltdb_private *ltdb = talloc_get_type(data, struct ltdb_private);	TDB_DATA tdb_key, tdb_data;	struct ldb_val ldb_data;	struct ldb_message *msg2;	unsigned int i, j, k;	int ret = LDB_SUCCESS, idx;	struct ldb_control *control_permissive = NULL;	if (req) {		control_permissive = ldb_request_get_control(req,					LDB_CONTROL_PERMISSIVE_MODIFY_OID);	}	tdb_key = ltdb_key(module, msg->dn);	if (!tdb_key.dptr) {		return LDB_ERR_OTHER;	}	tdb_data = tdb_fetch(ltdb->tdb, tdb_key);	if (!tdb_data.dptr) {		talloc_free(tdb_key.dptr);		return ltdb_err_map(tdb_error(ltdb->tdb));	}	msg2 = ldb_msg_new(tdb_key.dptr);	if (msg2 == NULL) {		free(tdb_data.dptr);		ret = LDB_ERR_OTHER;		goto done;	}	ldb_data.data = tdb_data.dptr;	ldb_data.length = tdb_data.dsize;	ret = ldb_unpack_data(ldb_module_get_ctx(module), &ldb_data, msg2);	free(tdb_data.dptr);	if (ret == -1) {		ret = LDB_ERR_OTHER;		goto done;	}	if (!msg2->dn) {		msg2->dn = msg->dn;	}	for (i=0; i<msg->num_elements; i++) {		struct ldb_message_element *el = &msg->elements[i], *el2;		struct ldb_val *vals;		const struct ldb_schema_attribute *a = ldb_schema_attribute_by_name(ldb, el->name);		const char *dn;		switch (msg->elements[i].flags & LDB_FLAG_MOD_MASK) {		case LDB_FLAG_MOD_ADD:			if (el->num_values == 0) {				ldb_asprintf_errstring(ldb,						       "attribute '%s': attribute on '%s' specified, but with 0 values (illegal)",						       el->name, ldb_dn_get_linearized(msg2->dn));				ret = LDB_ERR_CONSTRAINT_VIOLATION;				goto done;			}			/* make a copy of the array so that a permissive			 * control can remove duplicates without changing the			 * original values, but do not copy data as we do not			 * need to keep it around once the operation is			 * finished */			if (control_permissive) {				el = talloc(msg2, struct ldb_message_element);				if (!el) {					ret = LDB_ERR_OTHER;					goto done;				}				*el = msg->elements[i];				el->values = talloc_array(el, struct ldb_val, el->num_values);				if (el->values == NULL) {					ret = LDB_ERR_OTHER;					goto done;				}				for (j = 0; j < el->num_values; j++) {					el->values[j] = msg->elements[i].values[j];				}			}			if (el->num_values > 1 && ldb_tdb_single_valued(a, el)) {//.........这里部分代码省略.........