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

NTSTATUS dbwrap_trans_store_uint32_bystring(struct db_context *db,        const char *keystr,        uint32_t v){    uint32_t v_store;    SIVAL(&v_store, 0, v);    return dbwrap_trans_store(db, string_term_tdb_data(keystr),                              make_tdb_data((const uint8_t *)&v_store,                                            sizeof(v_store)),                              TDB_REPLACE);}

static NTSTATUS fss_state_sc_store(TALLOC_CTX *mem_ctx,				   struct db_context *db,				   const char *sc_set_key_str,				   struct fss_sc *sc){	NTSTATUS status;	TDB_DATA val;	const char *sc_key_str;	struct fsrvp_state_sc sc_state;	struct fss_sc_smap *smap;	enum ndr_err_code ndr_ret;	DATA_BLOB sc_state_blob;	/* becomes sc_set/@sc_set.id/sc/@sc_id */	sc_key_str = talloc_asprintf(mem_ctx, "%s/%s%s", sc_set_key_str,				     FSS_DB_KEY_PFX_SC, sc->id_str);	if (sc_key_str == NULL) {		return NT_STATUS_NO_MEMORY;	}	sc_state.id_str = sc->id_str;	sc_state.volume_name = sc->volume_name;	/* @sc->sc_path may be null if not committed, store empty str */	sc_state.sc_path = (sc->sc_path ? sc->sc_path : "");	sc_state.create_ts = sc->create_ts;	sc_state.smaps_count = sc->smaps_count;	ndr_ret = ndr_push_struct_blob(&sc_state_blob, mem_ctx,				       &sc_state,				(ndr_push_flags_fn_t)ndr_push_fsrvp_state_sc);	if (ndr_ret != NDR_ERR_SUCCESS) {		return NT_STATUS_INTERNAL_ERROR;	}	val.dsize = sc_state_blob.length;	val.dptr = sc_state_blob.data;	status = dbwrap_store(db, string_term_tdb_data(sc_key_str), val, 0);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	for (smap = sc->smaps; smap; smap = smap->next) {		status = fss_state_smap_store(mem_ctx, db, sc_key_str, smap);		if (!NT_STATUS_IS_OK(status)) {			return status;		}	}	return NT_STATUS_OK;}

static void cache_mangled_name( const char mangled_name[13],				const char *raw_name ){	TDB_DATA data_val;	char mangled_name_key[13];	char *s1 = NULL;	char *s2 = NULL;	/* If the cache isn't initialized, give up. */	if( !tdb_mangled_cache )		return;	/* Init the string lengths. */	strlcpy(mangled_name_key, mangled_name, sizeof(mangled_name_key));	/* See if the extensions are unmangled.  If so, store the entry	 * without the extension, thus creating a "group" reverse map.	 */	s1 = strrchr( mangled_name_key, '.' );	if( s1 && (s2 = strrchr( raw_name, '.' )) ) {		size_t i = 1;		while( s1[i] && (tolower_m( s1[i] ) == s2[i]) )			i++;		if( !s1[i] && !s2[i] ) {			/* Truncate at the '.' */			*s1 = '/0';			/*			 * DANGER WILL ROBINSON - this			 * is changing a const string via			 * an aliased pointer ! Remember to			 * put it back once we've used it.			 * JRA			 */			*s2 = '/0';		}	}	/* Allocate a new cache entry.  If the allocation fails, just return. */	data_val = string_term_tdb_data(raw_name);	if (tdb_store_bystring(tdb_mangled_cache, mangled_name_key, data_val, TDB_REPLACE) != 0) {		DEBUG(0,("cache_mangled_name: Error storing entry %s -> %s/n", mangled_name_key, raw_name));	} else {		DEBUG(5,("cache_mangled_name: Stored entry %s -> %s/n", mangled_name_key, raw_name));	}	/* Restore the change we made to the const string. */	if (s2) {		*s2 = '.';	}}

static bool group_map_remove(const struct dom_sid *sid){	char *key;	NTSTATUS status;	key = group_mapping_key(talloc_tos(), sid);	if (key == NULL) {		return false;	}	status = dbwrap_trans_delete(db, string_term_tdb_data(key));	TALLOC_FREE(key);	return NT_STATUS_IS_OK(status);}

static int regdb_normalize_keynames_fn(struct db_record *rec,				       void *private_data){	TALLOC_CTX *mem_ctx = talloc_tos();	const char *keyname;	NTSTATUS status;	if (rec->key.dptr == NULL || rec->key.dsize == 0) {		return 0;	}	keyname = strchr((const char *) rec->key.dptr, '/');	if (keyname) {		struct db_record new_rec;		keyname = talloc_string_sub(mem_ctx,					    (const char *) rec->key.dptr,					    "/",					    "//");		DEBUG(2, ("regdb_normalize_keynames_fn: Convert %s to %s/n",			  (const char *) rec->key.dptr,			  keyname));		new_rec.value = rec->value;		new_rec.key = string_term_tdb_data(keyname);		new_rec.private_data = rec->private_data;		/* Delete the original record and store the normalized key */		status = rec->delete_rec(rec);		if (!NT_STATUS_IS_OK(status)) {			DEBUG(0,("regdb_normalize_keynames_fn: "				 "tdb_delete for [%s] failed!/n",				 rec->key.dptr));			return 1;		}		status = rec->store(&new_rec, new_rec.value, TDB_REPLACE);		if (!NT_STATUS_IS_OK(status)) {			DEBUG(0,("regdb_normalize_keynames_fn: "				 "failed to store new record for [%s]!/n",				 keyname));			return 1;		}	}	return 0;}

static NTSTATUS fss_state_sc_set_store(TALLOC_CTX *mem_ctx,				       struct db_context *db,				       struct fss_sc_set *sc_set){	NTSTATUS status;	TDB_DATA val;	const char *sc_set_key_str;	struct fss_sc *sc;	struct fsrvp_state_sc_set sc_set_state;	DATA_BLOB sc_set_state_blob;	enum ndr_err_code ndr_ret;	sc_set_key_str = talloc_asprintf(mem_ctx, "%s%s",					 FSS_DB_KEY_PFX_SC_SET,					 sc_set->id_str);	if (sc_set_key_str == NULL) {		return NT_STATUS_NO_MEMORY;	}	sc_set_state.id_str = sc_set->id_str;	sc_set_state.state = sc_set->state;	sc_set_state.context = sc_set->context;	sc_set_state.scs_count = sc_set->scs_count;	ndr_ret = ndr_push_struct_blob(&sc_set_state_blob, mem_ctx,				       &sc_set_state,			(ndr_push_flags_fn_t)ndr_push_fsrvp_state_sc_set);	if (ndr_ret != NDR_ERR_SUCCESS) {		return NT_STATUS_INTERNAL_ERROR;	}	val.dsize = sc_set_state_blob.length;	val.dptr = sc_set_state_blob.data;	status = dbwrap_store(db, string_term_tdb_data(sc_set_key_str), val, 0);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	for (sc = sc_set->scs; sc; sc = sc->next) {		status = fss_state_sc_store(mem_ctx, db, sc_set_key_str, sc);		if (!NT_STATUS_IS_OK(status)) {			return status;		}	}	return NT_STATUS_OK;}

static int dbwrap_tool_exists(struct db_context *db,			      const char *keyname,			      const char *data){	bool result;	result = dbwrap_exists(db, string_term_tdb_data(keyname));	if (result) {		d_fprintf(stdout, "Key %s exists/n", keyname);	} else {		d_fprintf(stdout, "Key %s does not exist/n", keyname);	}	return (result)?0:1;}

NTSTATUS dbwrap_trans_change_int32_atomic_bystring(struct db_context *db,						   const char *keystr,						   int32_t *oldval,						   int32_t change_val){	NTSTATUS ret;	struct dbwrap_change_int32_atomic_context state;	state.key = string_term_tdb_data(keystr);	state.oldval = oldval;	state.change_val = change_val;	ret = dbwrap_trans_do(db, dbwrap_change_int32_atomic_action, &state);	return ret;}

static NTSTATUS fss_state_smap_store(TALLOC_CTX *mem_ctx,				     struct db_context *db,				     const char *sc_key_str,				     struct fss_sc_smap *smap){	NTSTATUS status;	TDB_DATA val;	const char *smap_key_str;	struct fsrvp_state_smap smap_state;	enum ndr_err_code ndr_ret;	DATA_BLOB smap_state_blob;	/* becomes sc_set/@sc_set_id/sc/@sc_id/smap/@sc_share_name */	smap_key_str = talloc_asprintf(mem_ctx, "%s/%s%s", sc_key_str,				       FSS_DB_KEY_PFX_SMAP,				       smap->sc_share_name);	if (smap_key_str == NULL) {		return NT_STATUS_NO_MEMORY;	}	smap_state.share_name = smap->share_name;	smap_state.sc_share_name = smap->sc_share_name;	/* @smap->sc_share_comment may be null if not exposed. */	if (smap->sc_share_comment != NULL) {		smap_state.sc_share_comment = smap->sc_share_comment;	} else {		smap_state.sc_share_comment = "";	}	smap_state.is_exposed = smap->is_exposed;	ndr_ret = ndr_push_struct_blob(&smap_state_blob, mem_ctx,				       &smap_state,				(ndr_push_flags_fn_t)ndr_push_fsrvp_state_smap);	if (ndr_ret != NDR_ERR_SUCCESS) {		return NT_STATUS_INTERNAL_ERROR;	}	val.dsize = smap_state_blob.length;	val.dptr = smap_state_blob.data;	status = dbwrap_store(db, string_term_tdb_data(smap_key_str), val, 0);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	return NT_STATUS_OK;}

/* load a msg file into the tdb */static bool load_msg(const char *msg_file){	char **lines;	int num_lines, i;	char *msgid, *msgstr;	TDB_DATA data;	lines = file_lines_load(msg_file, &num_lines, 0, NULL);	if (!lines) {		return False;	}	if (tdb_lockall(tdb) != 0) {		TALLOC_FREE(lines);		return False;	}	/* wipe the db */	tdb_wipe_all(tdb);	msgid = NULL;		for (i=0;i<num_lines;i++) {		if (strncmp(lines[i], "msgid /"", 7) == 0) {			msgid = lines[i] + 7;		}		if (msgid && strncmp(lines[i], "msgstr /"", 8) == 0) {			msgstr = lines[i] + 8;			trim_char(msgid, '/0', '/"');			trim_char(msgstr, '/0', '/"');			if (*msgstr == 0) {				msgstr = msgid;			}			all_string_sub(msgid, "//n", "/n", 0);			all_string_sub(msgstr, "//n", "/n", 0);			data = string_term_tdb_data(msgstr);			tdb_store_bystring(tdb, msgid, data, 0);			msgid = NULL;		}	}	TALLOC_FREE(lines);	tdb_unlockall(tdb);	return True;}

bool dbwrap_fetch_uint32(struct db_context *db, const char *keystr,			 uint32_t *val){	TDB_DATA dbuf;	if (db->fetch(db, NULL, string_term_tdb_data(keystr), &dbuf) != 0) {		return false;	}	if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(uint32_t))) {		TALLOC_FREE(dbuf.dptr);		return false;	}	*val = IVAL(dbuf.dptr, 0);	TALLOC_FREE(dbuf.dptr);	return true;}

int32_t dbwrap_fetch_int32(struct db_context *db, const char *keystr){	TDB_DATA dbuf;	int32 ret;	if (db->fetch(db, NULL, string_term_tdb_data(keystr), &dbuf) != 0) {		return -1;	}	if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(int32_t))) {		TALLOC_FREE(dbuf.dptr);		return -1;	}	ret = IVAL(dbuf.dptr, 0);	TALLOC_FREE(dbuf.dptr);	return ret;}

static NTSTATUS dbwrap_change_uint32_atomic_action(struct db_context *db,						   void *private_data){	struct db_record *rec;	uint32_t val = (uint32_t)-1;	uint32_t v_store;	NTSTATUS ret;	struct dbwrap_change_uint32_atomic_context *state;	TDB_DATA value;	state = (struct dbwrap_change_uint32_atomic_context *)private_data;	rec = dbwrap_fetch_locked(db, talloc_tos(),				  string_term_tdb_data(state->keystr));	if (!rec) {		return NT_STATUS_UNSUCCESSFUL;	}	value = dbwrap_record_get_value(rec);	if (value.dptr == NULL) {		val = *(state->oldval);	} else if (value.dsize == sizeof(val)) {		val = IVAL(value.dptr, 0);		*(state->oldval) = val;	} else {		ret = NT_STATUS_UNSUCCESSFUL;		goto done;	}	val += state->change_val;	SIVAL(&v_store, 0, val);	ret = dbwrap_record_store(rec,				  make_tdb_data((const uint8_t *)&v_store,						sizeof(v_store)),				  TDB_REPLACE);done:	TALLOC_FREE(rec);	return ret;}

int dbwrap_store_uint32(struct db_context *db, const char *keystr, uint32_t v){	struct db_record *rec;	uint32 v_store;	NTSTATUS status;	rec = db->fetch_locked(db, NULL, string_term_tdb_data(keystr));	if (rec == NULL) {		return -1;	}	SIVAL(&v_store, 0, v);	status = rec->store(rec, make_tdb_data((const uint8 *)&v_store,					       sizeof(v_store)),			    TDB_REPLACE);	TALLOC_FREE(rec);	return NT_STATUS_IS_OK(status) ? 0 : -1;}

bool set_share_security(const char *share_name, SEC_DESC *psd){	TALLOC_CTX *frame;	char *key;	bool ret = False;	TDB_DATA blob;	NTSTATUS status;	if (!share_info_db_init()) {		return False;	}	frame = talloc_stackframe();	status = marshall_sec_desc(frame, psd, &blob.dptr, &blob.dsize);	if (!NT_STATUS_IS_OK(status)) {		DEBUG(0, ("marshall_sec_desc failed: %s/n",			  nt_errstr(status)));		goto out;	}	if (!(key = talloc_asprintf(frame, "SECDESC/%s", share_name))) {		DEBUG(0, ("talloc_asprintf failed/n"));		goto out;	}	status = dbwrap_trans_store(share_db, string_term_tdb_data(key), blob,				    TDB_REPLACE);	if (!NT_STATUS_IS_OK(status)) {		DEBUG(1, ("set_share_security: Failed to store secdesc for "			  "%s: %s/n", share_name, nt_errstr(status)));		goto out;	}	DEBUG(5,("set_share_security: stored secdesc for %s/n", share_name ));	ret = True; out:	TALLOC_FREE(frame);	return ret;}

bool run_dbwrap_watch1(int dummy){	struct tevent_context *ev = NULL;	struct messaging_context *msg = NULL;	struct db_context *backend = NULL;	struct db_context *db = NULL;	const char *keystr = "key";	TDB_DATA key = string_term_tdb_data(keystr);	struct db_record *rec = NULL;	struct tevent_req *req = NULL;	NTSTATUS status;	bool ret = false;	ev = samba_tevent_context_init(talloc_tos());	if (ev == NULL) {		fprintf(stderr, "tevent_context_init failed/n");		goto fail;	}	msg = messaging_init(ev, ev);	if (msg == NULL) {		fprintf(stderr, "messaging_init failed/n");		goto fail;	}	backend = db_open(msg, "test_watch.tdb", 0, TDB_DEFAULT,			  O_CREAT|O_RDWR, 0644, DBWRAP_LOCK_ORDER_1,			  DBWRAP_FLAG_NONE);	if (backend == NULL) {		fprintf(stderr, "db_open failed: %s/n", strerror(errno));		goto fail;	}	db = db_open_watched(ev, backend, msg);	rec = dbwrap_fetch_locked(db, db, key);	if (rec == NULL) {		fprintf(stderr, "dbwrap_fetch_locked failed/n");		goto fail;	}	req = dbwrap_watched_watch_send(talloc_tos(), ev, rec,					(struct server_id){0});

NTSTATUS dbwrap_store_int32_bystring(struct db_context *db, const char *keystr,				     int32_t v){	struct db_record *rec;	int32_t v_store;	NTSTATUS status;	rec = dbwrap_fetch_locked(db, talloc_tos(),				  string_term_tdb_data(keystr));	if (rec == NULL) {		return NT_STATUS_UNSUCCESSFUL;	}	SIVAL(&v_store, 0, v);	status = dbwrap_record_store(rec,				     make_tdb_data((const uint8_t *)&v_store,						   sizeof(v_store)),				     TDB_REPLACE);	TALLOC_FREE(rec);	return status;}

NTSTATUS dbwrap_fetch_uint32_bystring(struct db_context *db,                                      const char *keystr, uint32_t *val){    struct dbwrap_fetch_uint32_state state;    NTSTATUS status;    if (val == NULL) {        return NT_STATUS_INVALID_PARAMETER;    }    state.status = NT_STATUS_INTERNAL_ERROR;    status = dbwrap_parse_record(db, string_term_tdb_data(keystr),                                 dbwrap_fetch_uint32_parser, &state);    if (!NT_STATUS_IS_OK(status)) {        return status;    }    if (NT_STATUS_IS_OK(state.status)) {        *val = state.result;    }    return state.status;}

static void cache_mangled_name( const char mangled_name[13],				const char *raw_name ){	TDB_DATA data_val;	char mangled_name_key[13];	char *s1;	char *s2;	/* If the cache isn't initialized, give up. */	if( !tdb_mangled_cache )		return;	/* Init the string lengths. */	safe_strcpy(mangled_name_key, mangled_name, sizeof(mangled_name_key)-1);	/* See if the extensions are unmangled.  If so, store the entry	 * without the extension, thus creating a "group" reverse map.	 */	s1 = strrchr( mangled_name_key, '.' );	if( s1 && (s2 = strrchr( raw_name, '.' )) ) {		size_t i = 1;		while( s1[i] && (tolower_ascii( s1[i] ) == s2[i]) )			i++;		if( !s1[i] && !s2[i] ) {			/* Truncate at the '.' */			*s1 = '/0';			*s2 = '/0';		}	}	/* Allocate a new cache entry.  If the allocation fails, just return. */	data_val = string_term_tdb_data(raw_name);	if (tdb_store_bystring(tdb_mangled_cache, mangled_name_key, data_val, TDB_REPLACE) != 0) {		DEBUG(0,("cache_mangled_name: Error storing entry %s -> %s/n", mangled_name_key, raw_name));	} else {		DEBUG(5,("cache_mangled_name: Stored entry %s -> %s/n", mangled_name_key, raw_name));	}}

static void test_store_records(struct db_context *db, struct tevent_context *ev){	TDB_DATA key;	uint32_t *counters;	TALLOC_CTX *tmp_ctx = talloc_stackframe();	struct timeval start;	key = string_term_tdb_data("testkey");	start = timeval_current();	while ((timelimit == 0) || (timeval_elapsed(&start) < timelimit)) {		struct db_record *rec;		TDB_DATA data;		TDB_DATA value;		int ret;		NTSTATUS status;		if (!no_trans) {			if (verbose) DEBUG(1, ("starting transaction/n"));			ret = dbwrap_transaction_start(db);			if (ret != 0) {				DEBUG(0, ("Failed to start transaction on node "					  "%d/n", pnn));				goto fail;			}			if (verbose) DEBUG(1, ("transaction started/n"));			do_sleep(torture_delay);		}		if (verbose) DEBUG(1, ("calling fetch_lock/n"));		rec = dbwrap_fetch_locked(db, tmp_ctx, key);		if (rec == NULL) {			DEBUG(0, ("Failed to fetch record/n"));			goto fail;		}		if (verbose) DEBUG(1, ("fetched record ok/n"));		do_sleep(torture_delay);		value = dbwrap_record_get_value(rec);		data.dsize = MAX(value.dsize, sizeof(uint32_t) * (pnn+1));		data.dptr = (unsigned char *)talloc_zero_size(tmp_ctx,							      data.dsize);		if (data.dptr == NULL) {			DEBUG(0, ("Failed to allocate data/n"));			goto fail;		}		memcpy(data.dptr, value.dptr, value.dsize);		counters = (uint32_t *)data.dptr;		/* bump our counter */		counters[pnn]++;		if (verbose) DEBUG(1, ("storing data/n"));		status = dbwrap_record_store(rec, data, TDB_REPLACE);		if (!NT_STATUS_IS_OK(status)) {			DEBUG(0, ("Failed to store record/n"));			if (!no_trans) {				ret = dbwrap_transaction_cancel(db);				if (ret != 0) {					DEBUG(0, ("Error cancelling transaction./n"));				}			}			goto fail;		}		talloc_free(rec);		if (verbose) DEBUG(1, ("stored data ok/n"));		do_sleep(torture_delay);		if (!no_trans) {			if (verbose) DEBUG(1, ("calling transaction_commit/n"));			ret = dbwrap_transaction_commit(db);			if (ret != 0) {				DEBUG(0, ("Failed to commit transaction/n"));				goto fail;			}			if (verbose) DEBUG(1, ("transaction committed/n"));		}		/* store the counters and verify that they are sane */		if (verbose || (pnn == 0)) {			if (!check_counters(db, data)) {				goto fail;			}		}		talloc_free(data.dptr);		do_sleep(torture_delay);	}	goto done;fail:	success = false;done:	talloc_free(tmp_ctx);	return;}

bool run_dbwrap_watch1(int dummy){	struct tevent_context *ev = NULL;	struct messaging_context *msg = NULL;	struct db_context *db = NULL;	const char *keystr = "key";	TDB_DATA key = string_term_tdb_data(keystr);	struct db_record *rec = NULL;	struct tevent_req *req = NULL;	NTSTATUS status;	bool ret = false;	ev = tevent_context_init(talloc_tos());	if (ev == NULL) {		fprintf(stderr, "tevent_context_init failed/n");		goto fail;	}	msg = messaging_init(ev, ev);	if (msg == NULL) {		fprintf(stderr, "messaging_init failed/n");		goto fail;	}	db = db_open(msg, "test_watch.tdb", 0, TDB_DEFAULT,		     O_CREAT|O_RDWR, 0644, DBWRAP_LOCK_ORDER_1);	if (db == NULL) {		fprintf(stderr, "db_open failed: %s/n", strerror(errno));		goto fail;	}	dbwrap_watch_db(db, msg);	rec = dbwrap_fetch_locked(db, db, key);	if (rec == NULL) {		fprintf(stderr, "dbwrap_fetch_locked failed/n");		goto fail;	}	req = dbwrap_record_watch_send(talloc_tos(), ev, rec, msg);	if (req == NULL) {		fprintf(stderr, "dbwrap_record_watch_send failed/n");		goto fail;	}	TALLOC_FREE(rec);	status = dbwrap_store_int32(db, keystr, 1);	if (!NT_STATUS_IS_OK(status)) {		fprintf(stderr, "dbwrap_store_int32 failed: %s/n",			nt_errstr(status));		goto fail;	}	if (!tevent_req_poll(req, ev)) {		fprintf(stderr, "tevent_req_poll failed/n");		goto fail;	}	status = dbwrap_record_watch_recv(req, talloc_tos(), &rec);	if (!NT_STATUS_IS_OK(status)) {		fprintf(stderr, "dbwrap_record_watch_recv failed: %s/n",			nt_errstr(status));		goto fail;	}	ret = true;fail:	TALLOC_FREE(req);	TALLOC_FREE(rec);	TALLOC_FREE(db);	TALLOC_FREE(msg);	TALLOC_FREE(ev);	return ret;}

int tdb_lock_bystring(struct tdb_context *tdb, const char *keyval){	TDB_DATA key = string_term_tdb_data(keyval);		return tdb_chainlock(tdb, key);}

void tdb_read_unlock_bystring(struct tdb_context *tdb, const char *keyval){	TDB_DATA key = string_term_tdb_data(keyval);		tdb_chainunlock_read(tdb, key);}

NTSTATUS dbwrap_trans_delete_bystring(struct db_context *db, const char *key){	return dbwrap_trans_delete(db, string_term_tdb_data(key));}

NTSTATUS dbwrap_trans_store_bystring(struct db_context *db, const char *key,				     TDB_DATA data, int flags){	return dbwrap_trans_store(db, string_term_tdb_data(key), data, flags);}