dptr               35 examples/perfcounter/perf_writer_util.c   key.dptr = keystring;
dptr               37 examples/perfcounter/perf_writer_util.c   data.dptr = databuf;
dptr               47 examples/perfcounter/perf_writer_util.c   key.dptr = keystring;
dptr               49 examples/perfcounter/perf_writer_util.c   data.dptr = datastring;
dptr               41 lib/tdb/common/freelistcheck.c 	key.dptr = (unsigned char *)&rec_ptr;
dptr              425 lib/tdb/common/io.c 		data.dptr = offset + (unsigned char *)tdb->map_ptr;
dptr              429 lib/tdb/common/io.c 	if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
dptr              434 lib/tdb/common/io.c 	free(data.dptr);
dptr               42 lib/tdb/common/open.c 		value = (value + (key->dptr[i] << (i*5 % 24)));
dptr               73 lib/tdb/common/tdb.c 	return memcmp(data.dptr, key.dptr, data.dsize);
dptr              143 lib/tdb/common/tdb.c 		      dbuf.dptr, dbuf.dsize) == -1)
dptr              173 lib/tdb/common/tdb.c 	ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
dptr              485 lib/tdb/common/tdb.c 	memcpy(p, key.dptr, key.dsize);
dptr              487 lib/tdb/common/tdb.c 		memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
dptr              584 lib/tdb/common/tdb.c 	if (dbuf.dptr == NULL) {
dptr              585 lib/tdb/common/tdb.c 		dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
dptr              587 lib/tdb/common/tdb.c 		unsigned char *new_dptr = (unsigned char *)realloc(dbuf.dptr,
dptr              590 lib/tdb/common/tdb.c 			free(dbuf.dptr);
dptr              592 lib/tdb/common/tdb.c 		dbuf.dptr = new_dptr;
dptr              595 lib/tdb/common/tdb.c 	if (dbuf.dptr == NULL) {
dptr              600 lib/tdb/common/tdb.c 	memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
dptr              607 lib/tdb/common/tdb.c 	SAFE_FREE(dbuf.dptr);
dptr              158 lib/tdb/common/traverse.c 		key.dptr = tdb_alloc_read(tdb, tl->off + sizeof(rec), 
dptr              160 lib/tdb/common/traverse.c 		if (!key.dptr) {
dptr              169 lib/tdb/common/traverse.c 		dbuf.dptr = key.dptr + rec.key_len;
dptr              175 lib/tdb/common/traverse.c 			SAFE_FREE(key.dptr);
dptr              185 lib/tdb/common/traverse.c 			SAFE_FREE(key.dptr);
dptr              188 lib/tdb/common/traverse.c 		SAFE_FREE(key.dptr);
dptr              281 lib/tdb/common/traverse.c 	key.dptr =tdb_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),key.dsize);
dptr              304 lib/tdb/common/traverse.c 		    || memcmp(k, oldkey.dptr, oldkey.dsize) != 0) {
dptr              337 lib/tdb/common/traverse.c 		key.dptr = tdb_alloc_read(tdb, tdb->travlocks.off+sizeof(rec),
dptr               64 lib/tdb/include/tdb.h 	unsigned char *dptr;
dptr               55 lib/tdb/pytdb.c 	ret.dptr = (unsigned char *)PyString_AsString(data);
dptr               62 lib/tdb/pytdb.c 	if (data.dptr == NULL && data.dsize == 0) {
dptr               65 lib/tdb/pytdb.c 		PyObject *ret = PyString_FromStringAndSize((const char *)data.dptr, 
dptr               67 lib/tdb/pytdb.c 		free(data.dptr);
dptr              280 lib/tdb/pytdb.c 	if (self->current.dptr == NULL && self->current.dsize == 0)
dptr              417 lib/tdb/pytdb.c 	tkey.dptr = (unsigned char *)PyString_AsString(key);
dptr              421 lib/tdb/pytdb.c 	if (val.dptr == NULL) {
dptr               29 lib/tdb/tools/tdbdump.c 	unsigned char *p = (unsigned char *)d.dptr;
dptr               68 lib/tdb/tools/tdbdump.c 		key.dptr = discard_const_p(uint8_t,keyname);
dptr               71 lib/tdb/tools/tdbdump.c 		if (!value.dptr) {
dptr               75 lib/tdb/tools/tdbdump.c 			free(value.dptr);
dptr               56 lib/tdb/tools/tdbtest.c 	while (key.dptr) {
dptr               58 lib/tdb/tools/tdbtest.c 		gkey.dptr = key.dptr;
dptr               63 lib/tdb/tools/tdbtest.c 		if (!gd.dptr) fatal("key not in gdbm");
dptr               65 lib/tdb/tools/tdbtest.c 		if (memcmp(gd.dptr, d.dptr, d.dsize)) {
dptr               70 lib/tdb/tools/tdbtest.c 		free(key.dptr);
dptr               71 lib/tdb/tools/tdbtest.c 		free(d.dptr);
dptr               72 lib/tdb/tools/tdbtest.c 		free(gd.dptr);
dptr               77 lib/tdb/tools/tdbtest.c 	while (gkey.dptr) {
dptr               79 lib/tdb/tools/tdbtest.c 		key.dptr = gkey.dptr;
dptr               84 lib/tdb/tools/tdbtest.c 		if (!d.dptr) fatal("key not in db");
dptr               86 lib/tdb/tools/tdbtest.c 		if (memcmp(d.dptr, gd.dptr, gd.dsize)) {
dptr               91 lib/tdb/tools/tdbtest.c 		free(gkey.dptr);
dptr               92 lib/tdb/tools/tdbtest.c 		free(gd.dptr);
dptr               93 lib/tdb/tools/tdbtest.c 		free(d.dptr);
dptr              123 lib/tdb/tools/tdbtest.c 	key.dptr = k;
dptr              126 lib/tdb/tools/tdbtest.c 	data.dptr = d;
dptr              137 lib/tdb/tools/tdbtest.c 		if (data.dptr) free(data.dptr);
dptr              156 lib/tdb/tools/tdbtest.c 	key.dptr = k;
dptr              159 lib/tdb/tools/tdbtest.c 	data.dptr = d;
dptr              170 lib/tdb/tools/tdbtest.c 		if (data.dptr) free(data.dptr);
dptr              180 lib/tdb/tools/tdbtest.c 	printf("[%s] [%s]\n", key.dptr, dbuf.dptr);
dptr              195 lib/tdb/tools/tdbtest.c 		key.dptr = keys[i];
dptr              198 lib/tdb/tools/tdbtest.c 		data.dptr = tdata;
dptr              206 lib/tdb/tools/tdbtest.c 	key.dptr = keys[0];
dptr              208 lib/tdb/tools/tdbtest.c 	key.dptr = keys[4];
dptr              210 lib/tdb/tools/tdbtest.c 	key.dptr = keys[2];
dptr              212 lib/tdb/tools/tdbtest.c 	key.dptr = keys[1];
dptr              214 lib/tdb/tools/tdbtest.c 	key.dptr = keys[3];
dptr              226 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
dptr              228 lib/tdb/tools/tdbtool.c 	dbuf.dptr = (unsigned char *)data;
dptr              250 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
dptr              252 lib/tdb/tools/tdbtool.c 	dbuf.dptr = (unsigned char *)data;
dptr              272 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
dptr              276 lib/tdb/tools/tdbtool.c 	if (!dbuf.dptr) {
dptr              283 lib/tdb/tools/tdbtool.c 	free( dbuf.dptr );
dptr              297 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
dptr              320 lib/tdb/tools/tdbtool.c 	key.dptr = (unsigned char *)keyname;
dptr              324 lib/tdb/tools/tdbtool.c 	if (!dbuf.dptr) {
dptr              351 lib/tdb/tools/tdbtool.c 	print_asc((const char *)key.dptr, key.dsize);
dptr              353 lib/tdb/tools/tdbtool.c 	print_data((const char *)dbuf.dptr, dbuf.dsize);
dptr              360 lib/tdb/tools/tdbtool.c 	print_asc((const char *)key.dptr, key.dsize);
dptr              368 lib/tdb/tools/tdbtool.c 	print_data((const char *)key.dptr, key.dsize);
dptr              440 lib/tdb/tools/tdbtool.c 	if (!dbuf.dptr) terror("fetch failed");
dptr              452 lib/tdb/tools/tdbtool.c 	if (!dbuf.dptr) 
dptr               97 lib/tdb/tools/tdbtorture.c 	key.dptr = (unsigned char *)k;
dptr              100 lib/tdb/tools/tdbtorture.c 	data.dptr = (unsigned char *)d;
dptr              166 lib/tdb/tools/tdbtorture.c 		if (data.dptr) free(data.dptr);
dptr              187 lib/tdb/tools/tdbtorture.c 	if (data.dptr) free(data.dptr);
dptr               33 lib/util/util_tdb.c TDB_DATA make_tdb_data(const uint8_t *dptr, size_t dsize)
dptr               36 lib/util/util_tdb.c 	ret.dptr = discard_const_p(uint8_t, dptr);
dptr              107 lib/util/util_tdb.c 	if (!data.dptr || data.dsize != sizeof(int32_t)) {
dptr              108 lib/util/util_tdb.c 		SAFE_FREE(data.dptr);
dptr              112 lib/util/util_tdb.c 	ret = IVAL(data.dptr,0);
dptr              113 lib/util/util_tdb.c 	SAFE_FREE(data.dptr);
dptr              138 lib/util/util_tdb.c 	data.dptr = (unsigned char *)&v_store;
dptr              164 lib/util/util_tdb.c 	if (!data.dptr || data.dsize != sizeof(uint32_t)) {
dptr              165 lib/util/util_tdb.c 		SAFE_FREE(data.dptr);
dptr              169 lib/util/util_tdb.c 	*value = IVAL(data.dptr,0);
dptr              170 lib/util/util_tdb.c 	SAFE_FREE(data.dptr);
dptr              196 lib/util/util_tdb.c 	data.dptr = (unsigned char *)&v_store;
dptr                8 lib/util/util_tdb.h TDB_DATA make_tdb_data(const uint8_t *dptr, size_t dsize);
dptr              552 source3/groupdb/mapping_ldb.c 	if (strncmp((char *)key.dptr, GROUP_PREFIX, 
dptr              557 source3/groupdb/mapping_ldb.c 	if (!string_to_sid(&map.sid, strlen(GROUP_PREFIX) + (const char *)key.dptr)) {
dptr              558 source3/groupdb/mapping_ldb.c 		DEBUG(0,("Bad sid key '%s' during upgrade\n", (const char *)key.dptr));
dptr              563 source3/groupdb/mapping_ldb.c 	ret = tdb_unpack(data.dptr, data.dsize, "ddff",
dptr              593 source3/groupdb/mapping_ldb.c 	const char *p = (const char *)data.dptr;
dptr              598 source3/groupdb/mapping_ldb.c 	if (strncmp((char *)key.dptr, MEMBEROF_PREFIX, 
dptr              603 source3/groupdb/mapping_ldb.c 	if (!string_to_sid(&member, strlen(MEMBEROF_PREFIX) + (const char *)key.dptr)) {
dptr              605 source3/groupdb/mapping_ldb.c 			 (const char *)key.dptr));
dptr              172 source3/groupdb/mapping_tdb.c 	if (dbuf.dptr == NULL) {
dptr              177 source3/groupdb/mapping_tdb.c 	ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
dptr              196 source3/groupdb/mapping_tdb.c 	    || (strncmp((char *)rec->key.dptr, GROUP_PREFIX,
dptr              201 source3/groupdb/mapping_tdb.c 	if (!string_to_sid(&map->sid, (const char *)rec->key.dptr
dptr              206 source3/groupdb/mapping_tdb.c 	return tdb_unpack(rec->value.dptr, rec->value.dsize, "ddff",
dptr              395 source3/groupdb/mapping_tdb.c 	if (dbuf.dptr == NULL) {
dptr              400 source3/groupdb/mapping_tdb.c 	p = (const char *)dbuf.dptr;
dptr              499 source3/groupdb/mapping_tdb.c 	if (rec->value.dptr != NULL) {
dptr              501 source3/groupdb/mapping_tdb.c 			key, "%s %s", (char *)(rec->value.dptr), string_sid);
dptr              550 source3/groupdb/mapping_tdb.c 	if (strncmp((const char *)rec->key.dptr, MEMBEROF_PREFIX,
dptr              554 source3/groupdb/mapping_tdb.c 	p = (const char *)rec->value.dptr;
dptr              572 source3/groupdb/mapping_tdb.c 		member_string = strchr((const char *)rec->key.dptr, '/');
dptr              528 source3/include/proto.h void gencache_iterate(void (*fn)(const char* key, const char *value, time_t timeout, void* dptr),
dptr             6259 source3/include/proto.h int dptr_CloseDir(struct dptr_struct *dptr);
dptr             6260 source3/include/proto.h void dptr_SeekDir(struct dptr_struct *dptr, long offset);
dptr             6261 source3/include/proto.h long dptr_TellDir(struct dptr_struct *dptr);
dptr             6262 source3/include/proto.h bool dptr_has_wild(struct dptr_struct *dptr);
dptr             6263 source3/include/proto.h int dptr_dnum(struct dptr_struct *dptr);
dptr             6265 source3/include/proto.h 			struct dptr_struct *dptr,
dptr             6268 source3/include/proto.h bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst);
dptr             6269 source3/include/proto.h void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset);
dptr             6270 source3/include/proto.h void dptr_init_search_op(struct dptr_struct *dptr);
dptr              226 source3/intl/lang_tdb.c 	if (!data.dptr)
dptr              229 source3/intl/lang_tdb.c 	return (const char *)data.dptr;
dptr               68 source3/lib/conn_tdb.c 	key.dptr = (uint8 *)&ckey;
dptr               91 source3/lib/conn_tdb.c 	return state->fn(rec, (const struct connections_key *)rec->key.dptr,
dptr               92 source3/lib/conn_tdb.c 			 (const struct connections_data *)rec->value.dptr,
dptr              736 source3/lib/ctdbd_conn.c 		data_blob_const(data.dptr, data.dsize));
dptr              768 source3/lib/ctdbd_conn.c 		if (!(outdata->dptr = (uint8 *)talloc_memdup(
dptr              796 source3/lib/ctdbd_conn.c 	data.dptr = (uint8_t*)&pid;
dptr              820 source3/lib/ctdbd_conn.c 	data.dptr = (uint8_t*)&db_id;
dptr              831 source3/lib/ctdbd_conn.c 	return (char *)data.dptr;
dptr              845 source3/lib/ctdbd_conn.c 	data.dptr = (uint8_t*)name;
dptr              864 source3/lib/ctdbd_conn.c 	*db_id = *(uint32_t *)data.dptr;
dptr              865 source3/lib/ctdbd_conn.c 	talloc_free(data.dptr);
dptr              871 source3/lib/ctdbd_conn.c 	data.dptr = (uint8_t *)db_id;
dptr              915 source3/lib/ctdbd_conn.c 		data_blob_const(key.dptr, key.dsize));
dptr              974 source3/lib/ctdbd_conn.c 		data_blob_const(key.dptr, key.dsize));
dptr             1003 source3/lib/ctdbd_conn.c 		data->dptr = NULL;
dptr             1007 source3/lib/ctdbd_conn.c 	data->dptr = (uint8 *)talloc_memdup(mem_ctx, &reply->data[0],
dptr             1009 source3/lib/ctdbd_conn.c 	if (data->dptr == NULL) {
dptr             1058 source3/lib/ctdbd_conn.c 	key.dptr  = &d->data[0];
dptr             1060 source3/lib/ctdbd_conn.c 	data.dptr = &d->data[d->keylen];		
dptr             1074 source3/lib/ctdbd_conn.c 	data.dptr += sizeof(struct ctdb_ltdb_header);
dptr             1114 source3/lib/ctdbd_conn.c 	data.dptr = (uint8_t *)&t;
dptr             1247 source3/lib/ctdbd_conn.c 		data.dptr = (uint8_t *)&p4;
dptr             1254 source3/lib/ctdbd_conn.c 		data.dptr = (uint8_t *)&p;
dptr               40 source3/lib/dbwrap.c 	data->dptr = talloc_move(mem_ctx, &rec->value.dptr);
dptr               64 source3/lib/dbwrap.c 	TALLOC_FREE(data.dptr);
dptr              100 source3/lib/dbwrap_ctdb.c 	memcpy(&d->data[0], key.dptr, key.dsize);
dptr              104 source3/lib/dbwrap_ctdb.c 		memcpy(&d->data[key.dsize+sizeof(*header)], data.dptr, data.dsize);
dptr              107 source3/lib/dbwrap_ctdb.c 		memcpy(&d->data[key.dsize], data.dptr, data.dsize);
dptr              164 source3/lib/dbwrap_ctdb.c 	data.dptr = (uint8_t *)m;
dptr              191 source3/lib/dbwrap_ctdb.c 		key->dptr   = &r->data[0];
dptr              195 source3/lib/dbwrap_ctdb.c 		data->dptr  = &r->data[r->keylen];
dptr              198 source3/lib/dbwrap_ctdb.c 			data->dptr += sizeof(*header);
dptr              233 source3/lib/dbwrap_ctdb.c 	key.dptr = (uint8_t *)discard_const(keyname);
dptr              255 source3/lib/dbwrap_ctdb.c 	if ((data.dptr == NULL) ||
dptr              257 source3/lib/dbwrap_ctdb.c 	    ((struct ctdb_ltdb_header *)data.dptr)->dmaster != get_my_vnn()) {
dptr              258 source3/lib/dbwrap_ctdb.c 		SAFE_FREE(data.dptr);
dptr              264 source3/lib/dbwrap_ctdb.c 	SAFE_FREE(data.dptr);
dptr              326 source3/lib/dbwrap_ctdb.c 	if (data->dptr != NULL) {
dptr              327 source3/lib/dbwrap_ctdb.c 		uint8_t *oldptr = (uint8_t *)data->dptr;
dptr              330 source3/lib/dbwrap_ctdb.c 			data->dptr = NULL;
dptr              332 source3/lib/dbwrap_ctdb.c 			data->dptr = (uint8 *)
dptr              334 source3/lib/dbwrap_ctdb.c 					mem_ctx, data->dptr+sizeof(struct ctdb_ltdb_header),
dptr              338 source3/lib/dbwrap_ctdb.c 		if (data->dptr == NULL && data->dsize != 0) {
dptr              348 source3/lib/dbwrap_ctdb.c 			talloc_free(data->dptr);
dptr              375 source3/lib/dbwrap_ctdb.c 	result->key.dptr = (uint8 *)talloc_memdup(result, key.dptr, key.dsize);
dptr              376 source3/lib/dbwrap_ctdb.c 	if (result->key.dptr == NULL) {
dptr              386 source3/lib/dbwrap_ctdb.c 	if (ctdb_data.dptr == NULL) {
dptr              393 source3/lib/dbwrap_ctdb.c 	result->value.dptr = NULL;
dptr              396 source3/lib/dbwrap_ctdb.c 	    && !(result->value.dptr = (uint8 *)talloc_memdup(
dptr              397 source3/lib/dbwrap_ctdb.c 			 result, ctdb_data.dptr + sizeof(struct ctdb_ltdb_header),
dptr              403 source3/lib/dbwrap_ctdb.c 	SAFE_FREE(ctdb_data.dptr);
dptr              467 source3/lib/dbwrap_ctdb.c 	if (rec.dptr == NULL) {
dptr              474 source3/lib/dbwrap_ctdb.c 		memcpy(&header, rec.dptr, sizeof(struct ctdb_ltdb_header));
dptr              478 source3/lib/dbwrap_ctdb.c 		    memcmp(data.dptr, rec.dptr + sizeof(struct ctdb_ltdb_header), data.dsize) == 0) {
dptr              479 source3/lib/dbwrap_ctdb.c 			SAFE_FREE(rec.dptr);
dptr              483 source3/lib/dbwrap_ctdb.c 		SAFE_FREE(rec.dptr);
dptr              505 source3/lib/dbwrap_ctdb.c 	rec.dptr = (uint8_t *)talloc_size(tmp_ctx, rec.dsize);
dptr              506 source3/lib/dbwrap_ctdb.c 	if (rec.dptr == NULL) {
dptr              511 source3/lib/dbwrap_ctdb.c 	memcpy(rec.dptr, &header, sizeof(struct ctdb_ltdb_header));
dptr              512 source3/lib/dbwrap_ctdb.c 	memcpy(sizeof(struct ctdb_ltdb_header) + (uint8_t *)rec.dptr, data.dptr, data.dsize);
dptr              595 source3/lib/dbwrap_ctdb.c 			    memcmp(data2.dptr, data.dptr, data.dsize) != 0) {
dptr              783 source3/lib/dbwrap_ctdb.c 	if (!(cdata.dptr = SMB_MALLOC_ARRAY(uint8, cdata.dsize))) {
dptr              787 source3/lib/dbwrap_ctdb.c 	memcpy(cdata.dptr, &crec->header, sizeof(crec->header));
dptr              788 source3/lib/dbwrap_ctdb.c 	memcpy(cdata.dptr + sizeof(crec->header), data.dptr, data.dsize);
dptr              792 source3/lib/dbwrap_ctdb.c 	SAFE_FREE(cdata.dptr);
dptr              824 source3/lib/dbwrap_ctdb.c 		   hex_encode_talloc(data, (unsigned char *)data->key.dptr,
dptr              861 source3/lib/dbwrap_ctdb.c 	result->key.dptr = (uint8 *)talloc_memdup(result, key.dptr, key.dsize);
dptr              862 source3/lib/dbwrap_ctdb.c 	if (result->key.dptr == NULL) {
dptr              874 source3/lib/dbwrap_ctdb.c 		char *keystr = hex_encode_talloc(result, key.dptr, key.dsize);
dptr              899 source3/lib/dbwrap_ctdb.c 	if ((ctdb_data.dptr == NULL) ||
dptr              901 source3/lib/dbwrap_ctdb.c 	    ((struct ctdb_ltdb_header *)ctdb_data.dptr)->dmaster != get_my_vnn()
dptr              906 source3/lib/dbwrap_ctdb.c 		SAFE_FREE(ctdb_data.dptr);
dptr              913 source3/lib/dbwrap_ctdb.c 			   ctdb_data.dptr, ctdb_data.dptr ?
dptr              914 source3/lib/dbwrap_ctdb.c 			   ((struct ctdb_ltdb_header *)ctdb_data.dptr)->dmaster : -1,
dptr              933 source3/lib/dbwrap_ctdb.c 	memcpy(&crec->header, ctdb_data.dptr, sizeof(crec->header));
dptr              936 source3/lib/dbwrap_ctdb.c 	result->value.dptr = NULL;
dptr              939 source3/lib/dbwrap_ctdb.c 	    && !(result->value.dptr = (uint8 *)talloc_memdup(
dptr              940 source3/lib/dbwrap_ctdb.c 			 result, ctdb_data.dptr + sizeof(crec->header),
dptr              946 source3/lib/dbwrap_ctdb.c 	SAFE_FREE(ctdb_data.dptr);
dptr              992 source3/lib/dbwrap_ctdb.c 	if ((ctdb_data.dptr != NULL) &&
dptr              995 source3/lib/dbwrap_ctdb.c 	     ((struct ctdb_ltdb_header *)ctdb_data.dptr)->dmaster == get_my_vnn())) {
dptr             1000 source3/lib/dbwrap_ctdb.c 			SAFE_FREE(ctdb_data.dptr);
dptr             1001 source3/lib/dbwrap_ctdb.c 			data->dptr = NULL;
dptr             1005 source3/lib/dbwrap_ctdb.c 		data->dptr = (uint8 *)talloc_memdup(
dptr             1006 source3/lib/dbwrap_ctdb.c 			mem_ctx, ctdb_data.dptr+sizeof(struct ctdb_ltdb_header),
dptr             1009 source3/lib/dbwrap_ctdb.c 		SAFE_FREE(ctdb_data.dptr);
dptr             1011 source3/lib/dbwrap_ctdb.c 		if (data->dptr == NULL) {
dptr             1017 source3/lib/dbwrap_ctdb.c 	SAFE_FREE(ctdb_data.dptr);
dptr             1126 source3/lib/dbwrap_ctdb.c 	rec.value.dptr += sizeof(struct ctdb_ltdb_header);
dptr               99 source3/lib/dbwrap_file.c 	result->key.dptr = (uint8 *)talloc_memdup(result, key.dptr, key.dsize);
dptr              100 source3/lib/dbwrap_file.c 	if (result->key.dptr == NULL) {
dptr              107 source3/lib/dbwrap_file.c 	file->hash = fsh(key.dptr, key.dsize);
dptr              108 source3/lib/dbwrap_file.c 	file->name = hex_encode_talloc(file, (unsigned char *)key.dptr, key.dsize);
dptr              167 source3/lib/dbwrap_file.c 	result->value.dptr = NULL;
dptr              171 source3/lib/dbwrap_file.c 		result->value.dptr = TALLOC_ARRAY(result, uint8,
dptr              173 source3/lib/dbwrap_file.c 		if (result->value.dptr == NULL) {
dptr              179 source3/lib/dbwrap_file.c 		nread = read_data(file->fd, (char *)result->value.dptr,
dptr              201 source3/lib/dbwrap_file.c 	if (write_data(fd, (char *)data.dptr, data.dsize) != data.dsize) {
dptr              298 source3/lib/dbwrap_file.c 			key.dptr = keyblob.data;
dptr              303 source3/lib/dbwrap_file.c 			    (memcmp(key.dptr, ctx->locked_record->key.dptr,
dptr              320 source3/lib/dbwrap_file.c 			if (rec->value.dptr == NULL) {
dptr               66 source3/lib/dbwrap_rbt.c 	res = memcmp(a.dptr, b.dptr, MIN(a.dsize, b.dsize));
dptr               84 source3/lib/dbwrap_rbt.c 	key->dptr = ((uint8 *)node) + offsetof(struct db_rbt_node, data);
dptr               86 source3/lib/dbwrap_rbt.c 	value->dptr = key->dptr + node->keysize;
dptr              109 source3/lib/dbwrap_rbt.c 		SMB_ASSERT(memcmp(this_key.dptr, rec->key.dptr,
dptr              116 source3/lib/dbwrap_rbt.c 			memcpy(this_val.dptr, data.dptr, data.dsize);
dptr              150 source3/lib/dbwrap_rbt.c 	memcpy(this_key.dptr, rec->key.dptr, node->keysize);
dptr              153 source3/lib/dbwrap_rbt.c 	memcpy(this_val.dptr, data.dptr, node->valuesize);
dptr              276 source3/lib/dbwrap_rbt.c 		result->key.dptr = (uint8 *)
dptr              279 source3/lib/dbwrap_rbt.c 		memcpy(result->key.dptr, key.dptr, key.dsize);
dptr              327 source3/lib/dbwrap_rbt.c 	result = (uint8 *)talloc_memdup(mem_ctx, search_val.dptr,
dptr              333 source3/lib/dbwrap_rbt.c 	data->dptr = result;
dptr               41 source3/lib/dbwrap_tdb.c 		   hex_encode_talloc(data, (unsigned char *)data->key.dptr,
dptr               71 source3/lib/dbwrap_tdb.c 	state->result->key.dptr = ((uint8 *)state->result)
dptr               73 source3/lib/dbwrap_tdb.c 	memcpy(state->result->key.dptr, key.dptr, key.dsize);
dptr               78 source3/lib/dbwrap_tdb.c 		state->result->value.dptr = state->result->key.dptr+key.dsize;
dptr               79 source3/lib/dbwrap_tdb.c 		memcpy(state->result->value.dptr, data.dptr, data.dsize);
dptr               82 source3/lib/dbwrap_tdb.c 		state->result->value.dptr = NULL;
dptr               97 source3/lib/dbwrap_tdb.c 		char *keystr = hex_encode_talloc(NULL, (unsigned char*)key.dptr, key.dsize);
dptr              146 source3/lib/dbwrap_tdb.c 	state->data.dptr = (uint8 *)talloc_memdup(state->mem_ctx, data.dptr,
dptr              148 source3/lib/dbwrap_tdb.c 	if (state->data.dptr == NULL) {
dptr               32 source3/lib/dbwrap_util.c 	if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(int32_t))) {
dptr               33 source3/lib/dbwrap_util.c 		TALLOC_FREE(dbuf.dptr);
dptr               37 source3/lib/dbwrap_util.c 	ret = IVAL(dbuf.dptr, 0);
dptr               38 source3/lib/dbwrap_util.c 	TALLOC_FREE(dbuf.dptr);
dptr               71 source3/lib/dbwrap_util.c 	if ((dbuf.dptr == NULL) || (dbuf.dsize != sizeof(uint32_t))) {
dptr               72 source3/lib/dbwrap_util.c 		TALLOC_FREE(dbuf.dptr);
dptr               76 source3/lib/dbwrap_util.c 	*val = IVAL(dbuf.dptr, 0);
dptr               77 source3/lib/dbwrap_util.c 	TALLOC_FREE(dbuf.dptr);
dptr              120 source3/lib/dbwrap_util.c 	if (rec->value.dptr == NULL) {
dptr              123 source3/lib/dbwrap_util.c 		val = IVAL(rec->value.dptr, 0);
dptr              132 source3/lib/dbwrap_util.c 	data.dptr = (uint8 *)&val;
dptr              160 source3/lib/dbwrap_util.c 	if (rec->value.dptr == NULL) {
dptr              163 source3/lib/dbwrap_util.c 		val = IVAL(rec->value.dptr, 0);
dptr              172 source3/lib/dbwrap_util.c 	data.dptr = (uint8 *)&val;
dptr              187 source3/lib/eventlog/eventlog.c 		key.dptr = (unsigned char *)&i;
dptr              198 source3/lib/eventlog/eventlog.c 		len = tdb_unpack( ret.dptr, ret.dsize, "ddddd", &reclen,
dptr              203 source3/lib/eventlog/eventlog.c 			SAFE_FREE( ret.dptr );
dptr              211 source3/lib/eventlog/eventlog.c 		SAFE_FREE( ret.dptr );
dptr              233 source3/lib/eventlog/eventlog.c 			key.dptr = (unsigned char *)&i;
dptr              661 source3/lib/eventlog/eventlog.c 	key.dptr = (unsigned char *)&srecno;
dptr              677 source3/lib/eventlog/eventlog.c 	blob = data_blob_const(data.dptr, data.dsize);
dptr              696 source3/lib/eventlog/eventlog.c 	SAFE_FREE(data.dptr);
dptr              783 source3/lib/eventlog/eventlog.c 	kbuf.dptr = (uint8_t *)&r->record_number;
dptr              786 source3/lib/eventlog/eventlog.c 	ebuf.dptr  = blob.data;
dptr              192 source3/lib/gencache.c 	if (databuf.dptr == NULL) {
dptr              198 source3/lib/gencache.c 	t = strtol((const char *)databuf.dptr, &endptr, 10);
dptr              201 source3/lib/gencache.c 		DEBUG(2, ("Invalid gencache data format: %s\n", databuf.dptr));
dptr              202 source3/lib/gencache.c 		SAFE_FREE(databuf.dptr);
dptr              215 source3/lib/gencache.c 		SAFE_FREE(databuf.dptr);
dptr              222 source3/lib/gencache.c 			SAFE_FREE(databuf.dptr);
dptr              228 source3/lib/gencache.c 	SAFE_FREE(databuf.dptr);
dptr              267 source3/lib/gencache.c 	if (!databuf.dptr) {
dptr              273 source3/lib/gencache.c 	buf = (unsigned char *)databuf.dptr;
dptr              310 source3/lib/gencache.c 	SAFE_FREE(databuf.dptr);
dptr              419 source3/lib/gencache.c 	if (key.dptr[key.dsize-1] == '\0') {
dptr              420 source3/lib/gencache.c 		keystr = (char *)key.dptr;
dptr              423 source3/lib/gencache.c 		keystr = SMB_STRNDUP((char *)key.dptr, key.dsize);
dptr              427 source3/lib/gencache.c 	if ((value.dptr == NULL) || (value.dsize <= TIMEOUT_LEN)) {
dptr              435 source3/lib/gencache.c 	if (value.dptr[value.dsize-1] == '\0') {
dptr              436 source3/lib/gencache.c 		valstr = (char *)value.dptr;
dptr              439 source3/lib/gencache.c 		valstr = SMB_STRNDUP((char *)value.dptr, value.dsize);
dptr              463 source3/lib/gencache.c void gencache_iterate(void (*fn)(const char* key, const char *value, time_t timeout, void* dptr),
dptr             1087 source3/lib/ldb/ldb_tdb/ldb_index.c 	if (strncmp((char *)key.dptr, dn, strlen(dn)) == 0) {
dptr             1104 source3/lib/ldb/ldb_tdb/ldb_index.c 	if (strncmp((char *)key.dptr, "DN=@", 4) == 0 ||
dptr             1105 source3/lib/ldb/ldb_tdb/ldb_index.c 	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
dptr             1123 source3/lib/ldb/ldb_tdb/ldb_index.c 	if (key2.dptr == NULL) {
dptr             1130 source3/lib/ldb/ldb_tdb/ldb_index.c 	if (strcmp((char *)key2.dptr, (char *)key.dptr) != 0) {
dptr             1134 source3/lib/ldb/ldb_tdb/ldb_index.c 	talloc_free(key2.dptr);
dptr             1137 source3/lib/ldb/ldb_tdb/ldb_index.c 		dn = (char *)key.dptr + 3;
dptr              116 source3/lib/ldb/ldb_tdb/ldb_pack.c 	data->dptr = talloc_array(ldb, uint8_t, size);
dptr              117 source3/lib/ldb/ldb_tdb/ldb_pack.c 	if (!data->dptr) {
dptr              124 source3/lib/ldb/ldb_tdb/ldb_pack.c 	p = (uint8_t *)data->dptr;
dptr              175 source3/lib/ldb/ldb_tdb/ldb_pack.c 	p = (uint8_t *)data->dptr;
dptr              222 source3/lib/ldb/ldb_tdb/ldb_search.c 	if (!tdb_key.dptr) {
dptr              227 source3/lib/ldb/ldb_tdb/ldb_search.c 	talloc_free(tdb_key.dptr);
dptr              228 source3/lib/ldb/ldb_tdb/ldb_search.c 	if (!tdb_data.dptr) {
dptr              236 source3/lib/ldb/ldb_tdb/ldb_search.c 	free(tdb_data.dptr);
dptr              372 source3/lib/ldb/ldb_tdb/ldb_search.c 	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
dptr              399 source3/lib/ldb/ldb_tdb/ldb_search.c 		ares->message->dn = ldb_dn_explode(ares->message, (char *)key.dptr + 3);
dptr              153 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dptr = (uint8_t *)key_str;
dptr              160 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dptr = NULL;
dptr              227 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	if (!tdb_key.dptr) {
dptr              233 source3/lib/ldb/ldb_tdb/ldb_tdb.c 		talloc_free(tdb_key.dptr);
dptr              249 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_key.dptr);
dptr              250 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_data.dptr);
dptr              341 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	if (!tdb_key.dptr) {
dptr              346 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_key.dptr);
dptr              602 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	if (!tdb_key.dptr) {
dptr              607 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	if (!tdb_data.dptr) {
dptr              608 source3/lib/ldb/ldb_tdb/ldb_tdb.c 		talloc_free(tdb_key.dptr);
dptr              612 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	msg2 = talloc(tdb_key.dptr, struct ldb_message);
dptr              614 source3/lib/ldb/ldb_tdb/ldb_tdb.c 		talloc_free(tdb_key.dptr);
dptr              747 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_key.dptr);
dptr              748 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	free(tdb_data.dptr);
dptr              752 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_key.dptr);
dptr              753 source3/lib/ldb/ldb_tdb/ldb_tdb.c 	free(tdb_data.dptr);
dptr              152 source3/lib/messages_local.c 	kbuf.dptr = (uint8 *)key;
dptr              177 source3/lib/messages_local.c 	if (data.dptr == NULL) {
dptr              182 source3/lib/messages_local.c 	blob = data_blob_const(data.dptr, data.dsize);
dptr              188 source3/lib/messages_local.c 	SAFE_FREE(data.dptr);
dptr              241 source3/lib/messages_local.c 	data.dptr = blob.data;
dptr              405 source3/lib/messages_local.c 		TALLOC_FREE(key.dptr);
dptr              421 source3/lib/messages_local.c 	TALLOC_FREE(key.dptr);
dptr               61 source3/lib/privileges.c 	if ( !data.dptr ) {
dptr               69 source3/lib/privileges.c 	se_priv_copy( mask, (SE_PRIV*)data.dptr );
dptr               70 source3/lib/privileges.c 	TALLOC_FREE(data.dptr);
dptr              102 source3/lib/privileges.c 	data.dptr  = (uint8 *)mask;
dptr              157 source3/lib/privileges.c 	if ( strncmp((char *)rec->key.dptr, PRIVPREFIX, prefixlen) != 0)
dptr              165 source3/lib/privileges.c 		se_priv_copy( &mask, (SE_PRIV*)rec->value.dptr );
dptr              174 source3/lib/privileges.c 	fstrcpy( sid_string, (char *)&(rec->key.dptr[strlen(PRIVPREFIX)]) );
dptr              177 source3/lib/sharesec.c 	if (data.dptr == NULL) {
dptr              182 source3/lib/sharesec.c 	status = unmarshall_sec_desc(ctx, data.dptr, data.dsize, &psd);
dptr              184 source3/lib/sharesec.c 	TALLOC_FREE(data.dptr);
dptr              216 source3/lib/sharesec.c 	status = marshall_sec_desc(frame, psd, &blob.dptr, &blob.dsize);
dptr               69 source3/lib/util_tdb.c 				timeout, key.dptr, tdb_name(tdb)));
dptr               31 source3/libads/sasl.c 	uint8 *dptr = ads->ldap.out.buf + (4 + NTLMSSP_SIG_SIZE);
dptr               34 source3/libads/sasl.c 	memcpy(dptr, buf, len);
dptr               39 source3/libads/sasl.c 						dptr, len,
dptr               40 source3/libads/sasl.c 						dptr, len,
dptr               44 source3/libads/sasl.c 						dptr, len,
dptr               45 source3/libads/sasl.c 						dptr, len,
dptr               70 source3/libads/sasl.c 	uint8 *dptr = ads->ldap.in.buf + (4 + NTLMSSP_SIG_SIZE);
dptr               79 source3/libads/sasl.c 						  dptr, dlen,
dptr               80 source3/libads/sasl.c 						  dptr, dlen,
dptr               84 source3/libads/sasl.c 						 dptr, dlen,
dptr               85 source3/libads/sasl.c 						 dptr, dlen,
dptr              122 source3/libsmb/conncache.c     time_t timeout, void *dptr)
dptr              261 source3/libsmb/namecache.c 			void *dptr)
dptr              154 source3/libsmb/samlogon_cache.c 	data.dptr = blob.data;
dptr              190 source3/libsmb/samlogon_cache.c 	if (!data.dptr) {
dptr              199 source3/libsmb/samlogon_cache.c 	blob = data_blob_const(data.dptr, data.dsize);
dptr              219 source3/libsmb/samlogon_cache.c 	SAFE_FREE(data.dptr);
dptr              106 source3/libsmb/smb_share_modes.c 	ld.dptr = (uint8 *)lk;
dptr              201 source3/libsmb/smb_share_modes.c 	if (!db_data.dptr) {
dptr              205 source3/libsmb/smb_share_modes.c 	ld = (struct locking_data *)db_data.dptr;
dptr              209 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              215 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              221 source3/libsmb/smb_share_modes.c 	shares = (struct share_mode_entry *)(db_data.dptr + sizeof(struct locking_data));
dptr              253 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              260 source3/libsmb/smb_share_modes.c 	free(db_data.dptr);
dptr              286 source3/libsmb/smb_share_modes.c 	if (!db_data.dptr) {
dptr              288 source3/libsmb/smb_share_modes.c 		db_data.dptr = (uint8 *)malloc(
dptr              293 source3/libsmb/smb_share_modes.c 		if (!db_data.dptr) {
dptr              296 source3/libsmb/smb_share_modes.c 		ld = (struct locking_data *)db_data.dptr;
dptr              301 source3/libsmb/smb_share_modes.c 		shares = (struct share_mode_entry *)(db_data.dptr + sizeof(struct locking_data));
dptr              304 source3/libsmb/smb_share_modes.c 		memcpy(db_data.dptr + sizeof(struct locking_data) + sizeof(struct share_mode_entry),
dptr              307 source3/libsmb/smb_share_modes.c 		memcpy(db_data.dptr + sizeof(struct locking_data) + sizeof(struct share_mode_entry) +
dptr              316 source3/libsmb/smb_share_modes.c 			free(db_data.dptr);
dptr              319 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              327 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              331 source3/libsmb/smb_share_modes.c 	ld = (struct locking_data *)db_data.dptr;
dptr              335 source3/libsmb/smb_share_modes.c 	memcpy(new_data_p, db_data.dptr, sizeof(struct locking_data) + (orig_num_share_modes * sizeof(struct share_mode_entry)));
dptr              348 source3/libsmb/smb_share_modes.c 		db_data.dptr + sizeof(struct locking_data) + (orig_num_share_modes * sizeof(struct share_mode_entry)),
dptr              353 source3/libsmb/smb_share_modes.c 	free(db_data.dptr);
dptr              355 source3/libsmb/smb_share_modes.c 	db_data.dptr = new_data_p;
dptr              359 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              362 source3/libsmb/smb_share_modes.c 	free(db_data.dptr);
dptr              404 source3/libsmb/smb_share_modes.c 	if (!db_data.dptr) {
dptr              408 source3/libsmb/smb_share_modes.c 	ld = (struct locking_data *)db_data.dptr;
dptr              410 source3/libsmb/smb_share_modes.c 	shares = (struct share_mode_entry *)(db_data.dptr + sizeof(struct locking_data));
dptr              416 source3/libsmb/smb_share_modes.c 			free(db_data.dptr);
dptr              420 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              428 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              433 source3/libsmb/smb_share_modes.c 	memcpy(new_data_p, db_data.dptr, sizeof(struct locking_data));
dptr              458 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              464 source3/libsmb/smb_share_modes.c 	remaining_ptr = db_data.dptr + sizeof(struct locking_data) + (orig_num_share_modes * sizeof(struct share_mode_entry));
dptr              465 source3/libsmb/smb_share_modes.c 	remaining_size = db_data.dsize - (remaining_ptr - db_data.dptr);
dptr              471 source3/libsmb/smb_share_modes.c 	free(db_data.dptr);
dptr              473 source3/libsmb/smb_share_modes.c 	db_data.dptr = new_data_p;
dptr              476 source3/libsmb/smb_share_modes.c 	ld = (struct locking_data *)db_data.dptr;
dptr              482 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              485 source3/libsmb/smb_share_modes.c 	free(db_data.dptr);
dptr              506 source3/libsmb/smb_share_modes.c 	if (!db_data.dptr) {
dptr              510 source3/libsmb/smb_share_modes.c 	ld = (struct locking_data *)db_data.dptr;
dptr              512 source3/libsmb/smb_share_modes.c 	shares = (struct share_mode_entry *)(db_data.dptr + sizeof(struct locking_data));
dptr              531 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              537 source3/libsmb/smb_share_modes.c 		free(db_data.dptr);
dptr              540 source3/libsmb/smb_share_modes.c 	free(db_data.dptr);
dptr              258 source3/libsmb/trustdom_cache.c static void flush_trustdom_name(const char* key, const char *value, time_t timeout, void* dptr)
dptr               72 source3/libsmb/unexpected.c 	kbuf.dptr = (uint8_t *)&key;
dptr               74 source3/libsmb/unexpected.c 	dbuf.dptr = (uint8_t *)buf;
dptr               95 source3/libsmb/unexpected.c 	memcpy(&key, kbuf.dptr, sizeof(key));
dptr              147 source3/libsmb/unexpected.c 	memcpy(&key, kbuf.dptr, sizeof(key));
dptr              156 source3/libsmb/unexpected.c 	enc_ip = IVAL(dbuf.dptr,0);
dptr              158 source3/libsmb/unexpected.c 	port = SVAL(dbuf.dptr,4);
dptr              160 source3/libsmb/unexpected.c 	p = parse_packet((char *)&dbuf.dptr[6],
dptr             1641 source3/locking/brlock.c 	locks = (struct lock_struct *)memdup(rec->value.dptr,
dptr             1647 source3/locking/brlock.c 	key = (struct file_id *)rec->key.dptr;
dptr             1660 source3/locking/brlock.c 			data.dptr = (uint8_t *)locks;
dptr             1733 source3/locking/brlock.c 		data.dptr = (uint8 *)br_lck->lock_data;
dptr             1773 source3/locking/brlock.c 	key.dptr = (uint8 *)&br_lck->key;
dptr             1818 source3/locking/brlock.c 		memcpy(br_lck->lock_data, data.dptr, data.dsize);
dptr              536 source3/locking/locking.c 	memcpy(&data, dbuf.dptr, sizeof(data));
dptr              572 source3/locking/locking.c 				      dbuf.dptr+sizeof(struct locking_data),
dptr              583 source3/locking/locking.c 		uint8 *p = dbuf.dptr + sizeof(struct locking_data) +
dptr              629 source3/locking/locking.c 	lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
dptr              633 source3/locking/locking.c 	lck->filename = (const char *)dbuf.dptr + sizeof(struct locking_data) +
dptr              672 source3/locking/locking.c 	result.dptr = NULL;
dptr              694 source3/locking/locking.c 	result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
dptr              696 source3/locking/locking.c 	if (result.dptr == NULL) {
dptr              700 source3/locking/locking.c 	data = (struct locking_data *)result.dptr;
dptr              718 source3/locking/locking.c 	memcpy(result.dptr + sizeof(*data), lck->share_modes,
dptr              725 source3/locking/locking.c 		uint8 *p = result.dptr + offset;
dptr              737 source3/locking/locking.c 		offset = p - result.dptr;
dptr              740 source3/locking/locking.c 	safe_strcpy((char *)result.dptr + offset, lck->servicepath,
dptr              743 source3/locking/locking.c 	safe_strcpy((char *)result.dptr + offset, lck->filename,
dptr              764 source3/locking/locking.c 	if (data.dptr == NULL) {
dptr              811 source3/locking/locking.c 	lck->fresh = (share_mode_data.dptr == NULL);
dptr             1486 source3/locking/locking.c 	data = (struct locking_data *)rec->value.dptr;
dptr             1487 source3/locking/locking.c 	shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
dptr             1488 source3/locking/locking.c 	sharepath = (const char *)rec->value.dptr + sizeof(*data) +
dptr             1491 source3/locking/locking.c 	fname = (const char *)rec->value.dptr + sizeof(*data) +
dptr              411 source3/locking/posix.c 	if (rec->value.dptr != NULL) {
dptr              413 source3/locking/posix.c 		memcpy(&lock_ref_count, rec->value.dptr,
dptr              446 source3/locking/posix.c 		   && (rec->value.dptr != NULL)
dptr              449 source3/locking/posix.c 	memcpy(&lock_ref_count, rec->value.dptr, sizeof(lock_ref_count));
dptr              490 source3/locking/posix.c 		memcpy(&lock_ref_count, dbuf.dptr, sizeof(lock_ref_count));
dptr              491 source3/locking/posix.c 		TALLOC_FREE(dbuf.dptr);
dptr              545 source3/locking/posix.c 	memcpy(new_data, rec->value.dptr, rec->value.dsize);
dptr              600 source3/locking/posix.c 	*entries = (int *)dbuf.dptr;
dptr              503 source3/modules/nfs4_acls.c 	if ((data.dptr == NULL) || (data.dsize <= 0)
dptr              504 source3/modules/nfs4_acls.c 	    || (data.dptr[data.dsize-1] != '\0')) {
dptr              507 source3/modules/nfs4_acls.c 		TALLOC_FREE(data.dptr);
dptr              511 source3/modules/nfs4_acls.c 	if (!string_to_sid(dst, (char *)data.dptr)) {
dptr              513 source3/modules/nfs4_acls.c 			  (char *)data.dptr, sid_string_dbg(src)));
dptr              514 source3/modules/nfs4_acls.c 		TALLOC_FREE(data.dptr);
dptr              518 source3/modules/nfs4_acls.c 	TALLOC_FREE(data.dptr);
dptr              221 source3/modules/vfs_acl_tdb.c 	pblob->data = data.dptr;
dptr              312 source3/modules/vfs_acl_tdb.c 	data.dptr = pblob->data;
dptr              362 source3/modules/vfs_acl_tdb.c 	data.dptr = pblob->data;
dptr               48 source3/modules/vfs_xattr_tdb.c 	blob = data_blob_const(data->dptr, data->dsize);
dptr              113 source3/modules/vfs_xattr_tdb.c 	TALLOC_FREE(data.dptr);
dptr              153 source3/modules/vfs_xattr_tdb.c 	TALLOC_FREE(data.dptr);
dptr               71 source3/nmbd/nmbd_winsserver.c 	if (data.dptr == NULL || data.dsize == 0) {
dptr               80 source3/nmbd/nmbd_winsserver.c 	len = tdb_unpack(data.dptr, data.dsize,
dptr              105 source3/nmbd/nmbd_winsserver.c 	push_ascii_nstring(namerec->name.name, (const char *)key.dptr);
dptr              106 source3/nmbd/nmbd_winsserver.c 	namerec->name.name_type = key.dptr[sizeof(unstring)];
dptr              134 source3/nmbd/nmbd_winsserver.c 		namerec->data.ip[i].s_addr = IVAL(data.dptr, len + (i*4));
dptr              161 source3/nmbd/nmbd_winsserver.c 	data.dptr = (uint8 *)SMB_MALLOC(len);
dptr              162 source3/nmbd/nmbd_winsserver.c 	if (!data.dptr) {
dptr              167 source3/nmbd/nmbd_winsserver.c 	len = tdb_pack(data.dptr, data.dsize, "wbddddddd",
dptr              179 source3/nmbd/nmbd_winsserver.c 		SIVAL(data.dptr, len + (i*4), namerec->data.ip[i].s_addr);
dptr              199 source3/nmbd/nmbd_winsserver.c 	key.dptr = (uint8 *)keydata;
dptr              231 source3/nmbd/nmbd_winsserver.c 	SAFE_FREE( data.dptr );
dptr              277 source3/nmbd/nmbd_winsserver.c 	if (data.dptr == NULL) {
dptr              283 source3/nmbd/nmbd_winsserver.c 	SAFE_FREE(data.dptr);
dptr             1757 source3/nmbd/nmbd_winsserver.c 	if (kbuf.dptr[sizeof(unstring)] != 0x1b) {
dptr             6592 source3/param/loadparm.c 	if ((data.dptr != NULL) && (data.dsize == sizeof(iService))) {
dptr             6593 source3/param/loadparm.c 		iService = *(int *)data.dptr;
dptr             8573 source3/param/loadparm.c 		if ((data.dptr != NULL) && (data.dsize == sizeof(iService))) {
dptr             8574 source3/param/loadparm.c 			iService = *(int *)data.dptr;
dptr               92 source3/passdb/login_cache.c 		SAFE_FREE(databuf.dptr);
dptr               96 source3/passdb/login_cache.c 	if (tdb_unpack (databuf.dptr, databuf.dsize, SAM_CACHE_FORMAT,
dptr              102 source3/passdb/login_cache.c 		SAFE_FREE(databuf.dptr);
dptr              106 source3/passdb/login_cache.c 	SAFE_FREE(databuf.dptr);
dptr              141 source3/passdb/login_cache.c 	databuf.dptr = SMB_MALLOC_ARRAY(uint8, databuf.dsize);
dptr              142 source3/passdb/login_cache.c 	if (!databuf.dptr) {
dptr              147 source3/passdb/login_cache.c 	if (tdb_pack(databuf.dptr, databuf.dsize, SAM_CACHE_FORMAT,
dptr              154 source3/passdb/login_cache.c 		SAFE_FREE(databuf.dptr);
dptr              160 source3/passdb/login_cache.c 	SAFE_FREE(databuf.dptr);
dptr               73 source3/passdb/pdb_tdb.c 	if (strncmp((char *)rec->key.dptr, USERPREFIX, USERPREFIX_LEN) != 0) {
dptr               85 source3/passdb/pdb_tdb.c 		  "(version:%d)\n", rec->key.dptr, state->from));
dptr               90 source3/passdb/pdb_tdb.c 					    (uint8 *)rec->value.dptr,
dptr               95 source3/passdb/pdb_tdb.c 					    (uint8 *)rec->value.dptr,
dptr              100 source3/passdb/pdb_tdb.c 					    (uint8 *)rec->value.dptr,
dptr              105 source3/passdb/pdb_tdb.c 					    (uint8 *)rec->value.dptr,
dptr              110 source3/passdb/pdb_tdb.c 					    (uint8 *)rec->value.dptr,
dptr              119 source3/passdb/pdb_tdb.c 			 "from TDB (key:%s) (version:%d)\n", rec->key.dptr,
dptr              126 source3/passdb/pdb_tdb.c 	data.dsize = init_buffer_from_samu(&data.dptr, user, false);
dptr              556 source3/passdb/pdb_tdb.c 	if (!data.dptr) {
dptr              564 source3/passdb/pdb_tdb.c 	if (!init_samu_from_buffer(user, SAMU_BUFFER_LATEST, data.dptr, data.dsize)) {
dptr              566 source3/passdb/pdb_tdb.c 		SAFE_FREE(data.dptr);
dptr              572 source3/passdb/pdb_tdb.c 	TALLOC_FREE(data.dptr);
dptr              608 source3/passdb/pdb_tdb.c 	if (!data.dptr) {
dptr              613 source3/passdb/pdb_tdb.c 	fstrcpy(name, (const char *)data.dptr);
dptr              614 source3/passdb/pdb_tdb.c 	TALLOC_FREE(data.dptr);
dptr              751 source3/passdb/pdb_tdb.c 	data.dptr = buf;
dptr             1115 source3/passdb/pdb_tdb.c 	    || (strncmp((char *)rec->key.dptr, RIDPREFIX, prefixlen))) {
dptr             1119 source3/passdb/pdb_tdb.c 	rid = strtoul((char *)rec->key.dptr+prefixlen, NULL, 16);
dptr              126 source3/passdb/secrets.c 	result = memdup(dbuf.dptr, dbuf.dsize);
dptr              130 source3/passdb/secrets.c 	TALLOC_FREE(dbuf.dptr);
dptr              965 source3/passdb/secrets.c 	    || (strncmp((char *)rec->key.dptr, SECRETS_DOMTRUST_ACCT_PASS,
dptr              971 source3/passdb/secrets.c 		rec->value.dptr, rec->value.dsize, &pass);
dptr             1156 source3/passdb/secrets.c 	if (vers.dptr == NULL) {
dptr             1159 source3/passdb/secrets.c 		vers.dptr = (uint8 *)&ver;
dptr             1162 source3/passdb/secrets.c 		vers.dptr = NULL;
dptr             1164 source3/passdb/secrets.c 		ver = IVAL(vers.dptr,0);
dptr             1178 source3/passdb/secrets.c 	SAFE_FREE(vers.dptr);
dptr             1215 source3/passdb/secrets.c 	value.dptr = TALLOC_ARRAY(mem_ctx, uint8, value.dsize);
dptr             1216 source3/passdb/secrets.c 	if (!value.dptr) {
dptr             1221 source3/passdb/secrets.c 	value.dsize = tdb_pack(value.dptr, value.dsize, "dBBBBBfff",
dptr             1235 source3/passdb/secrets.c 		TALLOC_FREE(value.dptr);
dptr             1246 source3/passdb/secrets.c 	TALLOC_FREE(value.dptr);
dptr             1286 source3/passdb/secrets.c 	if (!value.dptr) {
dptr             1296 source3/passdb/secrets.c 	ret = tdb_unpack(value.dptr, value.dsize, "dBBBBBfff",
dptr             1318 source3/passdb/secrets.c 		SAFE_FREE(value.dptr);
dptr             1344 source3/passdb/secrets.c 	SAFE_FREE(value.dptr);
dptr              571 source3/printing/notify.c 	if (!data.dptr) {
dptr              588 source3/printing/notify.c 		pid_list[i] = (pid_t)IVAL(data.dptr, offset);
dptr              600 source3/printing/notify.c 	SAFE_FREE(data.dptr);
dptr              268 source3/printing/nt_printing.c 	for (kbuf = tdb_firstkey(tdb_drivers); kbuf.dptr;
dptr              269 source3/printing/nt_printing.c 			newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
dptr              273 source3/printing/nt_printing.c 		if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) == 0) {
dptr              276 source3/printing/nt_printing.c 				SAFE_FREE(dbuf.dptr);
dptr              281 source3/printing/nt_printing.c 				SAFE_FREE(dbuf.dptr);
dptr              287 source3/printing/nt_printing.c 		if (strncmp((const char *)kbuf.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX)) == 0) {
dptr              290 source3/printing/nt_printing.c 				SAFE_FREE(dbuf.dptr);
dptr              295 source3/printing/nt_printing.c 				SAFE_FREE(dbuf.dptr);
dptr              301 source3/printing/nt_printing.c 		if (strncmp((const char *)kbuf.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX)) == 0) {
dptr              304 source3/printing/nt_printing.c 				SAFE_FREE(dbuf.dptr);
dptr              309 source3/printing/nt_printing.c 				SAFE_FREE(dbuf.dptr);
dptr              315 source3/printing/nt_printing.c 		SAFE_FREE(dbuf.dptr);
dptr              341 source3/printing/nt_printing.c 	if (!data.dptr || data.dsize == 0) {
dptr              345 source3/printing/nt_printing.c 	if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) != 0 ) {
dptr              351 source3/printing/nt_printing.c 	status = unmarshall_sec_desc_buf(ctx, data.dptr, data.dsize, &sd_orig);
dptr              355 source3/printing/nt_printing.c 			(const char *)key.dptr ));
dptr              406 source3/printing/nt_printing.c 		DEBUG(0,("sec_desc_upg_fn: Failed to update sec_desc for %s\n", key.dptr ));
dptr              415 source3/printing/nt_printing.c 	status = marshall_sec_desc_buf(ctx, sd_store, &data.dptr, &data.dsize);
dptr              417 source3/printing/nt_printing.c 		DEBUG(0,("sec_desc_upg_fn: Failed to parse new sec_desc for %s\n", key.dptr ));
dptr              462 source3/printing/nt_printing.c 	if (!data.dptr || data.dsize == 0)
dptr              467 source3/printing/nt_printing.c 	if ( strncmp((const char *) key.dptr, PRINTERS_PREFIX, strlen(PRINTERS_PREFIX) ) == 0 ) {
dptr              468 source3/printing/nt_printing.c 		new_key = make_printer_tdbkey(ctx, (const char *)key.dptr+strlen(PRINTERS_PREFIX) );
dptr              470 source3/printing/nt_printing.c 	else if ( strncmp((const char *) key.dptr, SECDESC_PREFIX, strlen(SECDESC_PREFIX) ) == 0 ) {
dptr              471 source3/printing/nt_printing.c 		new_key = make_printers_secdesc_tdbkey(ctx, (const char *)key.dptr+strlen(SECDESC_PREFIX) );
dptr              482 source3/printing/nt_printing.c 			key.dptr));
dptr              488 source3/printing/nt_printing.c 			key.dptr));
dptr              667 source3/printing/nt_printing.c 	if (memcmp(PRINTERS_PREFIX, key.dptr, sizeof(PRINTERS_PREFIX)-1) == 0) {
dptr              669 source3/printing/nt_printing.c 		DEBUG(10,("traverse_counting_printers: printer = [%s]  printer_count = %d\n", key.dptr, *printer_count));
dptr              771 source3/printing/nt_printing.c 	     kbuf.dptr;
dptr              772 source3/printing/nt_printing.c 	     newkey = tdb_nextkey(tdb_forms, kbuf), free(kbuf.dptr), kbuf=newkey)
dptr              774 source3/printing/nt_printing.c 		if (strncmp((const char *)kbuf.dptr, FORMS_PREFIX, strlen(FORMS_PREFIX)) != 0)
dptr              778 source3/printing/nt_printing.c 		if (!dbuf.dptr)
dptr              781 source3/printing/nt_printing.c 		fstrcpy(form.name, (const char *)kbuf.dptr+strlen(FORMS_PREFIX));
dptr              782 source3/printing/nt_printing.c 		ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "dddddddd",
dptr              785 source3/printing/nt_printing.c 		SAFE_FREE(dbuf.dptr);
dptr              837 source3/printing/nt_printing.c 		dbuf.dptr = (uint8 *)buf;
dptr              981 source3/printing/nt_printing.c 	     kbuf.dptr;
dptr              982 source3/printing/nt_printing.c 	     newkey = tdb_nextkey(tdb_drivers, kbuf), free(kbuf.dptr), kbuf=newkey) {
dptr              984 source3/printing/nt_printing.c 		if (strncmp((const char *)kbuf.dptr, key, strlen(key)) != 0)
dptr              993 source3/printing/nt_printing.c 		fstrcpy((*list)[total], (const char *)kbuf.dptr+strlen(key));
dptr             2153 source3/printing/nt_printing.c 	dbuf.dptr = buf;
dptr             2252 source3/printing/nt_printing.c 	if (!dbuf.dptr) {
dptr             2257 source3/printing/nt_printing.c 	len += tdb_unpack(dbuf.dptr, dbuf.dsize, "dffffffff",
dptr             2276 source3/printing/nt_printing.c 		len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "f",
dptr             2284 source3/printing/nt_printing.c 	SAFE_FREE(dbuf.dptr);
dptr             2596 source3/printing/nt_printing.c 	dbuf.dptr = buf;
dptr             3989 source3/printing/nt_printing.c 	if (!dbuf.dptr) {
dptr             3994 source3/printing/nt_printing.c 	len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "dddddddddddfffffPfffff",
dptr             4047 source3/printing/nt_printing.c 	len += unpack_devicemode(&info->devmode,dbuf.dptr+len, dbuf.dsize-len);
dptr             4070 source3/printing/nt_printing.c 		SAFE_FREE(dbuf.dptr);
dptr             4073 source3/printing/nt_printing.c 	len += unpack_values( info->data, dbuf.dptr+len, dbuf.dsize-len );
dptr             4079 source3/printing/nt_printing.c 		SAFE_FREE(dbuf.dptr);
dptr             4089 source3/printing/nt_printing.c 	SAFE_FREE(dbuf.dptr);
dptr             4270 source3/printing/nt_printing.c 	if (!dbuf.dptr) {
dptr             4285 source3/printing/nt_printing.c 	len += unpack_devicemode(&info.devmode,dbuf.dptr+len, dbuf.dsize-len);
dptr             4324 source3/printing/nt_printing.c 	len += unpack_values( info_ptr->data, dbuf.dptr+len, dbuf.dsize-len );
dptr             4326 source3/printing/nt_printing.c 	SAFE_FREE(dbuf.dptr);
dptr             4429 source3/printing/nt_printing.c 	dbuf.dptr = buf;
dptr             5257 source3/printing/nt_printing.c 	if ( !dbuf.dptr ) {
dptr             5263 source3/printing/nt_printing.c 	SAFE_FREE( dbuf.dptr );
dptr             5372 source3/printing/nt_printing.c 	dbuf.dptr = (unsigned char *)blob.data;
dptr             5497 source3/printing/nt_printing.c 	if (dbuf.dptr) {
dptr             5499 source3/printing/nt_printing.c 		status = unmarshall_sec_desc_buf(ctx, dbuf.dptr, dbuf.dsize,
dptr             5501 source3/printing/nt_printing.c 		SAFE_FREE(dbuf.dptr);
dptr             5516 source3/printing/nt_printing.c 		dbuf.dptr = (unsigned char *)blob.data;
dptr               76 source3/printing/printing.c 	key.dptr = (uint8 *)&jinfo;
dptr               80 source3/printing/printing.c 	if (data.dptr && data.dsize == sizeof(uint16)) {
dptr               81 source3/printing/printing.c 		rap_jobid = SVAL(data.dptr, 0);
dptr               82 source3/printing/printing.c 		SAFE_FREE(data.dptr);
dptr               87 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr               93 source3/printing/printing.c 	data.dptr = buf;
dptr              114 source3/printing/printing.c 	key.dptr = buf;
dptr              117 source3/printing/printing.c 	if ( data.dptr && data.dsize == sizeof(struct rap_jobid_key) )
dptr              119 source3/printing/printing.c 		struct rap_jobid_key *jinfo = (struct rap_jobid_key*)data.dptr;
dptr              126 source3/printing/printing.c 		SAFE_FREE(data.dptr);
dptr              132 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr              151 source3/printing/printing.c 	key.dptr = (uint8 *)&jinfo;
dptr              155 source3/printing/printing.c 	if (!data.dptr || (data.dsize != sizeof(uint16))) {
dptr              158 source3/printing/printing.c 		SAFE_FREE(data.dptr);
dptr              165 source3/printing/printing.c 	rap_jobid = SVAL(data.dptr, 0);
dptr              166 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr              168 source3/printing/printing.c 	data.dptr = buf;
dptr              272 source3/printing/printing.c 	ret.dptr = (uint8 *)tmp;
dptr              349 source3/printing/printing.c 	if (!ret.dptr) {
dptr              360 source3/printing/printing.c 	if ( unpack_pjob( ret.dptr, ret.dsize, &pjob ) == -1 ) {
dptr              362 source3/printing/printing.c 		SAFE_FREE(ret.dptr);
dptr              366 source3/printing/printing.c 	SAFE_FREE(ret.dptr);
dptr              388 source3/printing/printing.c 	if (!data.dptr || data.dsize == 0)
dptr              391 source3/printing/printing.c 	pjob = (struct printjob *)data.dptr;
dptr              396 source3/printing/printing.c 		uint32 jobid = IVAL(key.dptr,0);
dptr              573 source3/printing/printing.c 	new_data.dptr = buf;
dptr              587 source3/printing/printing.c 			if ( unpack_pjob( old_data.dptr, old_data.dsize, &old_pjob ) != -1 )
dptr              600 source3/printing/printing.c 	SAFE_FREE( old_data.dptr );
dptr              727 source3/printing/printing.c 	jobid = IVAL(key.dptr, 0);
dptr              728 source3/printing/printing.c 	if ( unpack_pjob( data.dptr, data.dsize, &pjob ) == -1 )
dptr              880 source3/printing/printing.c 	if (!data.dptr || data.dsize != sizeof(pid_t)) {
dptr              881 source3/printing/printing.c 		SAFE_FREE(data.dptr);
dptr              885 source3/printing/printing.c 	updating_pid = IVAL(data.dptr, 0);
dptr              886 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr              926 source3/printing/printing.c 	data.dptr = buffer;
dptr              993 source3/printing/printing.c 	if ((data.dptr = (uint8 *)SMB_MALLOC(data.dsize)) == NULL)
dptr              997 source3/printing/printing.c 	len += tdb_pack(data.dptr + len, data.dsize - len, "d", qcount);
dptr             1002 source3/printing/printing.c 		len += tdb_pack(data.dptr + len, data.dsize - len, "ddddddff",
dptr             1015 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr             1026 source3/printing/printing.c 	if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0)) {
dptr             1027 source3/printing/printing.c 		SAFE_FREE(data.dptr);
dptr             1042 source3/printing/printing.c 		ch_jobid = IVAL(data.dptr, i*4);
dptr             1208 source3/printing/printing.c 	SAFE_FREE(jcdata.dptr);
dptr             1243 source3/printing/printing.c 	data.dptr = (uint8 *)&status;
dptr             1664 source3/printing/printing.c 		if (IVAL(data.dptr,i) == mypid) {
dptr             1665 source3/printing/printing.c 			uint32 new_refcount = IVAL(data.dptr, i+4) + 1;
dptr             1666 source3/printing/printing.c 			SIVAL(data.dptr, i+4, new_refcount);
dptr             1673 source3/printing/printing.c 		data.dptr = (uint8 *)SMB_REALLOC(data.dptr, data.dsize + 8);
dptr             1674 source3/printing/printing.c 		if (!data.dptr) {
dptr             1680 source3/printing/printing.c 		SIVAL(data.dptr,data.dsize - 8,mypid);
dptr             1681 source3/printing/printing.c 		SIVAL(data.dptr,data.dsize - 4,1); /* Refcount. */
dptr             1698 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr             1754 source3/printing/printing.c 		if (IVAL(data.dptr,i) == mypid) {
dptr             1755 source3/printing/printing.c 			uint32 refcount = IVAL(data.dptr, i+4);
dptr             1761 source3/printing/printing.c 					memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
dptr             1765 source3/printing/printing.c 			SIVAL(data.dptr, i+4, refcount);
dptr             1772 source3/printing/printing.c 		SAFE_FREE(data.dptr);
dptr             1788 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr             1908 source3/printing/printing.c 	if (data.dptr == NULL || data.dsize == 0 || (data.dsize % 4 != 0))
dptr             1915 source3/printing/printing.c 		ch_jobid = IVAL(data.dptr, i*4);
dptr             1918 source3/printing/printing.c 				memmove(data.dptr + (i*4), data.dptr + (i*4) + 4, (job_count - i - 1)*4 );
dptr             1931 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr             2256 source3/printing/printing.c 		if (data.dptr) {
dptr             2260 source3/printing/printing.c 				memcpy(status, data.dptr, sizeof(print_status_struct));
dptr             2261 source3/printing/printing.c 			SAFE_FREE(data.dptr);
dptr             2355 source3/printing/printing.c 		dum.dptr = NULL;
dptr             2379 source3/printing/printing.c 	data.dptr = (uint8 *)&store_jobid;
dptr             2652 source3/printing/printing.c 	if (data.dptr && data.dsize >= sizeof(qcount))
dptr             2653 source3/printing/printing.c 		len += tdb_unpack(data.dptr + len, data.dsize - len, "d", &qcount);
dptr             2657 source3/printing/printing.c 	if (cgdata.dptr != NULL && (cgdata.dsize % 4 == 0))
dptr             2673 source3/printing/printing.c 		len += tdb_unpack(data.dptr + len, data.dsize - len, "ddddddff",
dptr             2697 source3/printing/printing.c 		jobid = IVAL(cgdata.dptr, i*4);
dptr             2734 source3/printing/printing.c 	SAFE_FREE(data.dptr);
dptr             2735 source3/printing/printing.c 	SAFE_FREE(cgdata.dptr);
dptr             2780 source3/printing/printing.c 	if (data.dptr) {
dptr             2784 source3/printing/printing.c 			memcpy(status, data.dptr, sizeof(*status));
dptr             2786 source3/printing/printing.c 		SAFE_FREE(data.dptr);
dptr              170 source3/printing/printing_db.c 	if (!data.dptr) {
dptr              178 source3/printing/printing_db.c 		SAFE_FREE(data.dptr);
dptr              191 source3/printing/printing_db.c 		pid_t pid = (pid_t)IVAL(data.dptr, i);
dptr              198 source3/printing/printing_db.c 		while ((i < data.dsize) && ((IVAL(data.dptr, i + 4) == 0) || !process_exists_by_pid(pid))) {
dptr              201 source3/printing/printing_db.c 			if (IVAL(data.dptr, i + 4) == 0) {
dptr              207 source3/printing/printing_db.c 				memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);
dptr               57 source3/printing/tests/vlp.c 	*job_list = (struct vlp_job *)data.dptr;
dptr               71 source3/printing/tests/vlp.c 	data.dptr = (unsigned char *)job_list;
dptr              119 source3/printing/tests/vlp.c 	data.dptr = (unsigned char *)keystr;
dptr              254 source3/printing/tests/vlp.c 	if (value.dptr) {
dptr              258 source3/printing/tests/vlp.c 		queue.dptr = (unsigned char *)SMB_MALLOC(value.dsize +
dptr              260 source3/printing/tests/vlp.c 		if (!queue.dptr) return 1;
dptr              262 source3/printing/tests/vlp.c 		memcpy(queue.dptr, value.dptr, value.dsize);
dptr              263 source3/printing/tests/vlp.c 		memcpy(queue.dptr + value.dsize, &job, sizeof(struct vlp_job));
dptr              269 source3/printing/tests/vlp.c 		free(queue.dptr);
dptr              274 source3/printing/tests/vlp.c 		queue.dptr = (unsigned char *)&job;
dptr              675 source3/registry/reg_backend_db.c 	dbuf.dptr = buffer;
dptr             1222 source3/registry/reg_backend_db.c 	tdb_unpack(data.dptr, data.dsize, "d", &num_subkeys);
dptr             1229 source3/registry/reg_backend_db.c 		char *s = (char *)data.dptr + IVAL(data.dptr, 4 + 4*idx);
dptr             1326 source3/registry/reg_backend_db.c 		ret = (value.dptr != NULL);
dptr             1368 source3/registry/reg_backend_db.c 	if (value.dptr == NULL) {
dptr             1375 source3/registry/reg_backend_db.c 	buf = value.dptr;
dptr             1503 source3/registry/reg_backend_db.c 	if (!value.dptr) {
dptr             1508 source3/registry/reg_backend_db.c 	regdb_unpack_values(values, value.dptr, value.dsize);
dptr             1533 source3/registry/reg_backend_db.c 	len = regdb_pack_values(values, data.dptr, data.dsize);
dptr             1539 source3/registry/reg_backend_db.c 	data.dptr = TALLOC_ARRAY(ctx, uint8, len);
dptr             1542 source3/registry/reg_backend_db.c 	len = regdb_pack_values(values, data.dptr, data.dsize);
dptr             1557 source3/registry/reg_backend_db.c 	if ((old_data.dptr != NULL)
dptr             1559 source3/registry/reg_backend_db.c 	    && (memcmp(old_data.dptr, data.dptr, data.dsize) == 0))
dptr             1598 source3/registry/reg_backend_db.c 	if (data.dptr == NULL) {
dptr             1603 source3/registry/reg_backend_db.c 	status = unmarshall_sec_desc(mem_ctx, (uint8 *)data.dptr, data.dsize,
dptr             1644 source3/registry/reg_backend_db.c 						   &tdbdata.dptr,
dptr              131 source3/registry/reg_objects.c 	if (data.dptr == NULL) {
dptr              136 source3/registry/reg_objects.c 		talloc_free(data.dptr);
dptr              141 source3/registry/reg_objects.c 		*idx = *(uint32 *)data.dptr;
dptr              144 source3/registry/reg_objects.c 	talloc_free(data.dptr);
dptr              103 source3/registry/reg_perfcount.c 	if(dbuf.dptr == NULL)
dptr              113 source3/registry/reg_perfcount.c 		memcpy(buf, dbuf.dptr, dbuf.dsize);
dptr              115 source3/registry/reg_perfcount.c 		SAFE_FREE(dbuf.dptr);
dptr              170 source3/registry/reg_perfcount.c 	if(dbuf.dptr == NULL)
dptr              185 source3/registry/reg_perfcount.c 	init_unistr2(&name_index, (const char *)kbuf.dptr, UNI_STR_TERMINATE);
dptr              196 source3/registry/reg_perfcount.c 	memcpy(temp, dbuf.dptr, dbuf.dsize);
dptr              197 source3/registry/reg_perfcount.c 	SAFE_FREE(dbuf.dptr);
dptr              322 source3/registry/reg_perfcount.c 		if(data.dptr[0] == 'p')
dptr              337 source3/registry/reg_perfcount.c 		if(data.dptr[0] == 'c')
dptr              356 source3/registry/reg_perfcount.c 	if(data.dptr == NULL)
dptr              360 source3/registry/reg_perfcount.c 	memcpy(buf, data.dptr, data.dsize);
dptr              361 source3/registry/reg_perfcount.c 	SAFE_FREE(data.dptr);
dptr              491 source3/registry/reg_perfcount.c 	if(data.dptr == NULL)
dptr              497 source3/registry/reg_perfcount.c 	memcpy(buf, data.dptr, data.dsize);
dptr              501 source3/registry/reg_perfcount.c 	SAFE_FREE(data.dptr);
dptr              506 source3/registry/reg_perfcount.c 	if(data.dptr == NULL)
dptr              518 source3/registry/reg_perfcount.c 		memcpy(buf, data.dptr, data.dsize);
dptr              531 source3/registry/reg_perfcount.c 		memcpy(buf, data.dptr, data.dsize);
dptr              544 source3/registry/reg_perfcount.c 		memcpy(buf, data.dptr, data.dsize);
dptr              546 source3/registry/reg_perfcount.c 	SAFE_FREE(data.dptr);
dptr              615 source3/registry/reg_perfcount.c 	memcpy(buf, data.dptr, data.dsize);
dptr              682 source3/registry/reg_perfcount.c 	if(data.dptr == NULL)
dptr              696 source3/registry/reg_perfcount.c 	memcpy(inst->counter_data.data, data.dptr, data.dsize);
dptr              697 source3/registry/reg_perfcount.c 	SAFE_FREE(data.dptr);
dptr              704 source3/registry/reg_perfcount.c 	if(data.dptr == NULL)
dptr              714 source3/registry/reg_perfcount.c 		memcpy(buf, data.dptr, MIN(PERFCOUNT_MAX_LEN-1,data.dsize));
dptr              718 source3/registry/reg_perfcount.c 			SAFE_FREE(data.dptr);
dptr              726 source3/registry/reg_perfcount.c 			SAFE_FREE(data.dptr);
dptr              730 source3/registry/reg_perfcount.c 		SAFE_FREE(data.dptr);
dptr              796 source3/registry/reg_perfcount.c 		if(data.dptr != NULL)
dptr              804 source3/registry/reg_perfcount.c 				DEBUG(3, ("Bogus relationship [%s] for counter [%d].\n", data.dptr, j));
dptr              812 source3/registry/reg_perfcount.c 			SAFE_FREE(data.dptr);
dptr              834 source3/registry/reg_perfcount.c 	if(data.dptr == NULL)
dptr              836 source3/registry/reg_perfcount.c 		DEBUG(3,("_reg_perfcount_get_64: No data found for key [%s].\n", key.dptr));
dptr              841 source3/registry/reg_perfcount.c 	memcpy(buf, data.dptr, data.dsize);
dptr              842 source3/registry/reg_perfcount.c 	SAFE_FREE(data.dptr);
dptr             1339 source3/rpc_parse/parse_prs.c 	dbuf.dptr = (uint8 *)ps->data_p;
dptr             1352 source3/rpc_parse/parse_prs.c 	if (!dbuf.dptr)
dptr             1355 source3/rpc_parse/parse_prs.c 	prs_give_memory(ps, (char *)dbuf.dptr, dbuf.dsize, True);
dptr               65 source3/rpc_server/srv_srvsvc_nt.c 	memcpy(&prec, rec->value.dptr, sizeof(struct pipe_open_rec));
dptr              168 source3/smbd/connection.c 	dbuf.dptr = (uint8 *)&crec;
dptr              205 source3/smbd/connection.c 	pcrec = (struct connections_data *)rec->value.dptr;
dptr              133 source3/smbd/dir.c static void dptr_idle(struct dptr_struct *dptr)
dptr              135 source3/smbd/dir.c 	if (dptr->dir_hnd) {
dptr              136 source3/smbd/dir.c 		DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
dptr              137 source3/smbd/dir.c 		TALLOC_FREE(dptr->dir_hnd);
dptr              147 source3/smbd/dir.c 	struct dptr_struct *dptr;
dptr              152 source3/smbd/dir.c 	for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
dptr              155 source3/smbd/dir.c 	if(!dptr) {
dptr              164 source3/smbd/dir.c 	for(; dptr; dptr = dptr->prev) {
dptr              165 source3/smbd/dir.c 		if (dptr->dir_hnd) {
dptr              166 source3/smbd/dir.c 			dptr_idle(dptr);
dptr              178 source3/smbd/dir.c 	struct dptr_struct *dptr;
dptr              180 source3/smbd/dir.c 	for(dptr = dirptrs; dptr; dptr = dptr->next) {
dptr              181 source3/smbd/dir.c 		if(dptr->dnum == key) {
dptr              182 source3/smbd/dir.c 			if (!forclose && !dptr->dir_hnd) {
dptr              186 source3/smbd/dir.c 				if (!(dptr->dir_hnd = OpenDir(
dptr              187 source3/smbd/dir.c 					      NULL, dptr->conn, dptr->path,
dptr              188 source3/smbd/dir.c 					      dptr->wcard, dptr->attr))) {
dptr              189 source3/smbd/dir.c 					DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
dptr              194 source3/smbd/dir.c 			DLIST_PROMOTE(dirptrs,dptr);
dptr              195 source3/smbd/dir.c 			return dptr;
dptr              207 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
dptr              208 source3/smbd/dir.c 	if (dptr)
dptr              209 source3/smbd/dir.c 		return(dptr->path);
dptr              219 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
dptr              220 source3/smbd/dir.c 	if (dptr)
dptr              221 source3/smbd/dir.c 		return(dptr->wcard);
dptr              231 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
dptr              232 source3/smbd/dir.c 	if (dptr)
dptr              233 source3/smbd/dir.c 		return(dptr->attr);
dptr              241 source3/smbd/dir.c static void dptr_close_internal(struct dptr_struct *dptr)
dptr              243 source3/smbd/dir.c 	DEBUG(4,("closing dptr key %d\n",dptr->dnum));
dptr              245 source3/smbd/dir.c 	DLIST_REMOVE(dirptrs, dptr);
dptr              252 source3/smbd/dir.c 	if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
dptr              254 source3/smbd/dir.c 			dptr->dnum ));
dptr              257 source3/smbd/dir.c 	bitmap_clear(dptr_bmap, dptr->dnum - 1);
dptr              259 source3/smbd/dir.c 	TALLOC_FREE(dptr->dir_hnd);
dptr              262 source3/smbd/dir.c 	SAFE_FREE(dptr->wcard);
dptr              263 source3/smbd/dir.c 	string_set(&dptr->path,"");
dptr              264 source3/smbd/dir.c 	SAFE_FREE(dptr);
dptr              273 source3/smbd/dir.c 	struct dptr_struct *dptr;
dptr              281 source3/smbd/dir.c 		for(dptr = dirptrs; dptr; dptr = next) {
dptr              282 source3/smbd/dir.c 			next = dptr->next;
dptr              283 source3/smbd/dir.c 			dptr_close_internal(dptr);
dptr              289 source3/smbd/dir.c 	dptr = dptr_get(*key, True);
dptr              291 source3/smbd/dir.c 	if (!dptr) {
dptr              296 source3/smbd/dir.c 	dptr_close_internal(dptr);
dptr              307 source3/smbd/dir.c 	struct dptr_struct *dptr, *next;
dptr              308 source3/smbd/dir.c 	for(dptr = dirptrs; dptr; dptr = next) {
dptr              309 source3/smbd/dir.c 		next = dptr->next;
dptr              310 source3/smbd/dir.c 		if (dptr->conn == conn)
dptr              311 source3/smbd/dir.c 			dptr_close_internal(dptr);
dptr              321 source3/smbd/dir.c 	struct dptr_struct *dptr;
dptr              322 source3/smbd/dir.c 	for(dptr = dirptrs; dptr; dptr = dptr->next) {
dptr              323 source3/smbd/dir.c 		if (dptr->conn == conn && dptr->dir_hnd)
dptr              324 source3/smbd/dir.c 			dptr_idle(dptr);
dptr              334 source3/smbd/dir.c 	struct dptr_struct *dptr, *next;
dptr              335 source3/smbd/dir.c 	for(dptr = dirptrs; dptr; dptr = next) {
dptr              336 source3/smbd/dir.c 		next = dptr->next;
dptr              337 source3/smbd/dir.c 		if (spid == dptr->spid && strequal(dptr->path,path))
dptr              338 source3/smbd/dir.c 			dptr_close_internal(dptr);
dptr              350 source3/smbd/dir.c 	struct dptr_struct *dptr;
dptr              355 source3/smbd/dir.c 	for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
dptr              358 source3/smbd/dir.c 	if(!dptr) {
dptr              369 source3/smbd/dir.c 	for(; dptr; dptr = dptr->prev) {
dptr              370 source3/smbd/dir.c 		if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
dptr              371 source3/smbd/dir.c 			(!old && (dptr->dnum > 255))) {
dptr              372 source3/smbd/dir.c 				dptr_close_internal(dptr);
dptr              390 source3/smbd/dir.c 	struct dptr_struct *dptr = NULL;
dptr              416 source3/smbd/dir.c 	dptr = SMB_MALLOC_P(struct dptr_struct);
dptr              417 source3/smbd/dir.c 	if(!dptr) {
dptr              423 source3/smbd/dir.c 	ZERO_STRUCTP(dptr);
dptr              432 source3/smbd/dir.c 		dptr->dnum = bitmap_find(dptr_bmap, 0);
dptr              434 source3/smbd/dir.c 		if(dptr->dnum == -1 || dptr->dnum > 254) {
dptr              445 source3/smbd/dir.c 			dptr->dnum = bitmap_find(dptr_bmap, 0);
dptr              446 source3/smbd/dir.c 			if(dptr->dnum == -1 || dptr->dnum > 254) {
dptr              447 source3/smbd/dir.c 				DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
dptr              448 source3/smbd/dir.c 				SAFE_FREE(dptr);
dptr              460 source3/smbd/dir.c 		dptr->dnum = bitmap_find(dptr_bmap, 255);
dptr              462 source3/smbd/dir.c 		if(dptr->dnum == -1 || dptr->dnum < 255) {
dptr              474 source3/smbd/dir.c 			dptr->dnum = bitmap_find(dptr_bmap, 255);
dptr              476 source3/smbd/dir.c 			if(dptr->dnum == -1 || dptr->dnum < 255) {
dptr              477 source3/smbd/dir.c 				DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
dptr              478 source3/smbd/dir.c 				SAFE_FREE(dptr);
dptr              485 source3/smbd/dir.c 	bitmap_set(dptr_bmap, dptr->dnum);
dptr              487 source3/smbd/dir.c 	dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
dptr              489 source3/smbd/dir.c 	string_set(&dptr->path,path);
dptr              490 source3/smbd/dir.c 	dptr->conn = conn;
dptr              491 source3/smbd/dir.c 	dptr->dir_hnd = dir_hnd;
dptr              492 source3/smbd/dir.c 	dptr->spid = spid;
dptr              493 source3/smbd/dir.c 	dptr->expect_close = expect_close;
dptr              494 source3/smbd/dir.c 	dptr->wcard = SMB_STRDUP(wcard);
dptr              495 source3/smbd/dir.c 	if (!dptr->wcard) {
dptr              496 source3/smbd/dir.c 		bitmap_clear(dptr_bmap, dptr->dnum - 1);
dptr              497 source3/smbd/dir.c 		SAFE_FREE(dptr);
dptr              502 source3/smbd/dir.c 		dptr->has_wild = True;
dptr              504 source3/smbd/dir.c 		dptr->has_wild = wcard_has_wild;
dptr              507 source3/smbd/dir.c 	dptr->attr = attr;
dptr              509 source3/smbd/dir.c 	DLIST_ADD(dirptrs, dptr);
dptr              512 source3/smbd/dir.c 		dptr->dnum,path,expect_close));  
dptr              514 source3/smbd/dir.c 	*dptr_ret = dptr;
dptr              524 source3/smbd/dir.c int dptr_CloseDir(struct dptr_struct *dptr)
dptr              526 source3/smbd/dir.c 	DLIST_REMOVE(dirptrs, dptr);
dptr              527 source3/smbd/dir.c 	TALLOC_FREE(dptr->dir_hnd);
dptr              531 source3/smbd/dir.c void dptr_SeekDir(struct dptr_struct *dptr, long offset)
dptr              533 source3/smbd/dir.c 	SeekDir(dptr->dir_hnd, offset);
dptr              536 source3/smbd/dir.c long dptr_TellDir(struct dptr_struct *dptr)
dptr              538 source3/smbd/dir.c 	return TellDir(dptr->dir_hnd);
dptr              541 source3/smbd/dir.c bool dptr_has_wild(struct dptr_struct *dptr)
dptr              543 source3/smbd/dir.c 	return dptr->has_wild;
dptr              546 source3/smbd/dir.c int dptr_dnum(struct dptr_struct *dptr)
dptr              548 source3/smbd/dir.c 	return dptr->dnum;
dptr              555 source3/smbd/dir.c static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
dptr              560 source3/smbd/dir.c 	while ((name = ReadDirName(dptr->dir_hnd, poffset, pst)) != NULL) {
dptr              561 source3/smbd/dir.c 		if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
dptr              573 source3/smbd/dir.c 			struct dptr_struct *dptr,
dptr              585 source3/smbd/dir.c 	if (dptr->has_wild || dptr->did_stat) {
dptr              586 source3/smbd/dir.c 		name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
dptr              602 source3/smbd/dir.c 	dptr->did_stat = true;
dptr              605 source3/smbd/dir.c 	if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
dptr              616 source3/smbd/dir.c 		name = talloc_strdup(ctx, dptr->wcard);
dptr              622 source3/smbd/dir.c 				dptr->path,
dptr              623 source3/smbd/dir.c 				dptr->wcard);
dptr              627 source3/smbd/dir.c 	if (SMB_VFS_STAT(dptr->conn, pathreal, pst) == 0) {
dptr              628 source3/smbd/dir.c 		name = talloc_strdup(ctx, dptr->wcard);
dptr              634 source3/smbd/dir.c 			name = talloc_strdup(ctx, dptr->wcard);
dptr              643 source3/smbd/dir.c 	if (dptr->conn->case_sensitive ||
dptr              644 source3/smbd/dir.c 	    !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
dptr              653 source3/smbd/dir.c 	ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
dptr              665 source3/smbd/dir.c 	name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
dptr              675 source3/smbd/dir.c 	dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
dptr              683 source3/smbd/dir.c bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
dptr              687 source3/smbd/dir.c 	if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
dptr              693 source3/smbd/dir.c 	return SearchDir(dptr->dir_hnd, name, poffset);
dptr              700 source3/smbd/dir.c void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
dptr              702 source3/smbd/dir.c 	DirCacheAdd(dptr->dir_hnd, name, offset);
dptr              708 source3/smbd/dir.c void dptr_init_search_op(struct dptr_struct *dptr)
dptr              710 source3/smbd/dir.c 	SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
dptr              720 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
dptr              722 source3/smbd/dir.c 	if (!dptr) {
dptr              726 source3/smbd/dir.c 	offset = (uint32)TellDir(dptr->dir_hnd);
dptr              728 source3/smbd/dir.c 		(long)dptr->dir_hnd,(int)offset));
dptr              741 source3/smbd/dir.c 	struct dptr_struct *dptr = dptr_get(key, False);
dptr              745 source3/smbd/dir.c 	if (!dptr) {
dptr              756 source3/smbd/dir.c 	SeekDir(dptr->dir_hnd,seekoff);
dptr              759 source3/smbd/dir.c 	return(dptr);
dptr              768 source3/smbd/dir.c 	struct dptr_struct *dptr  = dptr_get(dptr_num, False);
dptr              770 source3/smbd/dir.c 	if (!dptr) {
dptr              775 source3/smbd/dir.c 	return(dptr);
dptr              481 source3/smbd/mangle_hash.c 	if(data_val.dptr == NULL || data_val.dsize == 0) {
dptr              500 source3/smbd/mangle_hash.c 	if(data_val.dptr == NULL || data_val.dsize == 0) {
dptr              509 source3/smbd/mangle_hash.c 					(char *)data_val.dptr,
dptr              512 source3/smbd/mangle_hash.c 		*out = talloc_strdup(ctx, (char *)data_val.dptr);
dptr              517 source3/smbd/mangle_hash.c 	SAFE_FREE(data_val.dptr);
dptr              163 source3/smbd/notify_internal.c 	blob.data = (uint8 *)dbuf.dptr;
dptr              182 source3/smbd/notify_internal.c 		talloc_free(dbuf.dptr);
dptr              235 source3/smbd/notify_internal.c 	dbuf.dptr = blob.data;
dptr               87 source3/smbd/session.c 	data.dptr = NULL;
dptr              116 source3/smbd/session.c 			       ((char *)rec->value.dptr)
dptr              189 source3/smbd/session.c 	data.dptr = (uint8 *)&sessionid;
dptr              242 source3/smbd/session.c 	memcpy(&sessionid, rec->value.dptr, sizeof(sessionid));
dptr              289 source3/smbd/session.c 		(const struct sessionid *) rec->value.dptr;
dptr              373 source3/smbd/statcache.c         for (p = (const char *)key->dptr; *p != '\0'; p++) {
dptr               87 source3/torture/mangle_test.c 	if (data.dptr) {
dptr               89 source3/torture/mangle_test.c 		if (!strequal(name, (const char *)data.dptr)) {
dptr               94 source3/torture/mangle_test.c 				name, data.dptr, shortname, collisions, total);
dptr               96 source3/torture/mangle_test.c 		free(data.dptr);
dptr              100 source3/torture/mangle_test.c 		namedata.dptr = CONST_DISCARD(uint8 *, name);
dptr             5564 source3/torture/torture.c 	    || (memcmp(rec->value.dptr, data.dptr, data.dsize) != 0)) {
dptr              143 source3/utils/dbwrap_tool.c 	unsigned char *p = (unsigned char *)rec->key.dptr;
dptr               37 source3/utils/net_cache.c                               const time_t timeout, void* dptr)
dptr               81 source3/utils/net_cache.c                                const time_t timeout, void* dptr)
dptr               38 source3/utils/net_idmap.c 	if (strcmp((char *)key.dptr, "USER HWM") == 0) {
dptr               39 source3/utils/net_idmap.c 		printf("USER HWM %d\n", IVAL(data.dptr,0));
dptr               43 source3/utils/net_idmap.c 	if (strcmp((char *)key.dptr, "GROUP HWM") == 0) {
dptr               44 source3/utils/net_idmap.c 		printf("GROUP HWM %d\n", IVAL(data.dptr,0));
dptr               48 source3/utils/net_idmap.c 	if (strncmp((char *)key.dptr, "S-", 2) != 0)
dptr               51 source3/utils/net_idmap.c 	printf("%s %s\n", data.dptr, key.dptr);
dptr               39 source3/utils/net_status.c 	memcpy(&sessionid, rec->value.dptr, sizeof(sessionid));
dptr              135 source3/utils/net_status.c 	memcpy(&sessionid, rec->value.dptr, sizeof(sessionid));
dptr              927 source3/utils/smbcontrol.c 		d.dptr = buf;
dptr              938 source3/utils/smbcontrol.c 		if (!d.dptr || d.dsize != 4) {
dptr              939 source3/utils/smbcontrol.c 			SAFE_FREE(d.dptr);
dptr              942 source3/utils/smbcontrol.c 			SAFE_FREE(d.dptr);
dptr              253 source3/utils/status.c 	memcpy(&sessionid, db->value.dptr, sizeof(sessionid));
dptr               70 source3/winbindd/idmap_tdb.c 	DEBUG(10,("Converting %s\n", (const char *)rec->key.dptr));
dptr               72 source3/winbindd/idmap_tdb.c 	p = strchr((const char *)rec->key.dptr, '/');
dptr               77 source3/winbindd/idmap_tdb.c 	fstrcpy(dom_name, (const char *)rec->key.dptr);
dptr               84 source3/winbindd/idmap_tdb.c 		DEBUG(0,("deleting record %s\n", (const char *)rec->key.dptr ));
dptr               89 source3/winbindd/idmap_tdb.c 				(const char *)rec->key.dptr,
dptr              109 source3/winbindd/idmap_tdb.c 			(const char *)key2.dptr,
dptr              118 source3/winbindd/idmap_tdb.c 			(const char *)rec->value.dptr,
dptr              127 source3/winbindd/idmap_tdb.c 			(const char *)rec->key.dptr,
dptr              714 source3/winbindd/idmap_tdb.c 	data.dptr = NULL;
dptr              727 source3/winbindd/idmap_tdb.c 	if (!data.dptr) {
dptr              733 source3/winbindd/idmap_tdb.c 	if (!string_to_sid(map->sid, (const char *)data.dptr)) {
dptr              735 source3/winbindd/idmap_tdb.c 			(const char *)data.dptr, keystr));
dptr              740 source3/winbindd/idmap_tdb.c 	DEBUG(10,("Found record %s -> %s\n", keystr, (const char *)data.dptr));
dptr              744 source3/winbindd/idmap_tdb.c 	talloc_free(data.dptr);
dptr              772 source3/winbindd/idmap_tdb.c 	if (!data.dptr) {
dptr              779 source3/winbindd/idmap_tdb.c 	if (sscanf((const char *)data.dptr, "UID %lu", &rec_id) == 1) { /* Try a UID record. */
dptr              782 source3/winbindd/idmap_tdb.c 		DEBUG(10,("Found uid record %s -> %s \n", keystr, (const char *)data.dptr ));
dptr              785 source3/winbindd/idmap_tdb.c 	} else if (sscanf((const char *)data.dptr, "GID %lu", &rec_id) == 1) { /* Try a GID record. */
dptr              788 source3/winbindd/idmap_tdb.c 		DEBUG(10,("Found gid record %s -> %s \n", keystr, (const char *)data.dptr ));
dptr              792 source3/winbindd/idmap_tdb.c 		DEBUG(2, ("Found INVALID record %s -> %s\n", keystr, (const char *)data.dptr));
dptr             1008 source3/winbindd/idmap_tdb.c 	data.dptr = NULL;
dptr             1056 source3/winbindd/idmap_tdb.c 	if (!data.dptr) {
dptr             1065 source3/winbindd/idmap_tdb.c 	    (memcmp(data.dptr, kid.dptr, data.dsize) != 0)) {
dptr             1069 source3/winbindd/idmap_tdb.c 			 (const char *)data.dptr));
dptr             1104 source3/winbindd/idmap_tdb.c 	talloc_free(data.dptr);
dptr             1138 source3/winbindd/idmap_tdb.c 	if (strncmp((const char *)rec->key.dptr, "S-", 2) == 0) {
dptr             1154 source3/winbindd/idmap_tdb.c 		if (!string_to_sid(maps[num_maps].sid, (const char *)rec->key.dptr)) {
dptr             1155 source3/winbindd/idmap_tdb.c 			DEBUG(10,("INVALID record %s\n", (const char *)rec->key.dptr));
dptr             1161 source3/winbindd/idmap_tdb.c 		if (sscanf((const char *)rec->value.dptr, "UID %u", &(maps[num_maps].xid.id)) == 1) {
dptr             1168 source3/winbindd/idmap_tdb.c 		if (sscanf((const char *)rec->value.dptr, "GID %u", &(maps[num_maps].xid.id)) == 1) {
dptr             1177 source3/winbindd/idmap_tdb.c 				(const char *)rec->key.dptr,
dptr             1178 source3/winbindd/idmap_tdb.c 				(const char *)rec->value.dptr));
dptr              546 source3/winbindd/idmap_tdb2.c 	data.dptr = NULL;
dptr              559 source3/winbindd/idmap_tdb2.c 	if (!data.dptr) {
dptr              587 source3/winbindd/idmap_tdb2.c 	if (!string_to_sid(map->sid, (const char *)data.dptr)) {
dptr              589 source3/winbindd/idmap_tdb2.c 			(const char *)data.dptr, keystr));
dptr              594 source3/winbindd/idmap_tdb2.c 	DEBUG(10,("Found record %s -> %s\n", keystr, (const char *)data.dptr));
dptr              628 source3/winbindd/idmap_tdb2.c 	if (!data.dptr) {
dptr              656 source3/winbindd/idmap_tdb2.c 	if (sscanf((const char *)data.dptr, "UID %lu", &rec_id) == 1) { /* Try a UID record. */
dptr              659 source3/winbindd/idmap_tdb2.c 		DEBUG(10,("Found uid record %s -> %s \n", keystr, (const char *)data.dptr ));
dptr              662 source3/winbindd/idmap_tdb2.c 	} else if (sscanf((const char *)data.dptr, "GID %lu", &rec_id) == 1) { /* Try a GID record. */
dptr              665 source3/winbindd/idmap_tdb2.c 		DEBUG(10,("Found gid record %s -> %s \n", keystr, (const char *)data.dptr ));
dptr              669 source3/winbindd/idmap_tdb2.c 		DEBUG(2, ("Found INVALID record %s -> %s\n", keystr, (const char *)data.dptr));
dptr              833 source3/winbindd/idmap_tdb2.c 	if (data.dptr) {
dptr               65 source3/winbindd/winbindd_cache.c 	if (kbuf.dptr == NULL || kbuf.dsize == 0) {
dptr               73 source3/winbindd/winbindd_cache.c 		if (strncmp(non_centry_keys[i], (const char *)kbuf.dptr, namelen) == 0) {
dptr              404 source3/winbindd/winbindd_cache.c 	if ( !data.dptr || data.dsize!=8 ) {
dptr              409 source3/winbindd/winbindd_cache.c 	domain->sequence_number = IVAL(data.dptr, 0);
dptr              410 source3/winbindd/winbindd_cache.c 	domain->last_seq_check  = IVAL(data.dptr, 4);
dptr              412 source3/winbindd/winbindd_cache.c 	SAFE_FREE(data.dptr);
dptr              446 source3/winbindd/winbindd_cache.c 	data.dptr = buf;
dptr              596 source3/winbindd/winbindd_cache.c 	if (!data.dptr) {
dptr              602 source3/winbindd/winbindd_cache.c 	centry->data = (unsigned char *)data.dptr;
dptr              845 source3/winbindd/winbindd_cache.c 	data.dptr = centry->data;
dptr             1192 source3/winbindd/winbindd_cache.c 	if (!data.dptr) {
dptr             1196 source3/winbindd/winbindd_cache.c 	SAFE_FREE(data.dptr);
dptr             2460 source3/winbindd/winbindd_cache.c 	if (strncmp((const char *)kbuf.dptr, "UL/", 3) == 0 ||
dptr             2461 source3/winbindd/winbindd_cache.c 	    strncmp((const char *)kbuf.dptr, "GL/", 3) == 0)
dptr             2699 source3/winbindd/winbindd_cache.c 	if (data.dptr == NULL)
dptr             2705 source3/winbindd/winbindd_cache.c 	memcpy(response, data.dptr, data.dsize);
dptr             2706 source3/winbindd/winbindd_cache.c 	SAFE_FREE(data.dptr);
dptr             2721 source3/winbindd/winbindd_cache.c 	if (data.dptr == NULL) {
dptr             2728 source3/winbindd/winbindd_cache.c 		SAFE_FREE(data.dptr);
dptr             2732 source3/winbindd/winbindd_cache.c 	dump_data(11, (uint8 *)data.dptr, data.dsize);
dptr             2734 source3/winbindd/winbindd_cache.c 	response->extra_data.data = data.dptr;
dptr             2867 source3/winbindd/winbindd_cache.c 	centry = wcache_fetch_raw((char *)kbuf.dptr);
dptr             2873 source3/winbindd/winbindd_cache.c 		DEBUG(10,("deleting centry %s\n", (const char *)kbuf.dptr));
dptr             2917 source3/winbindd/winbindd_cache.c 	if (strncmp((const char *)kbuf.dptr, "CRED/", 5) == 0) {
dptr             2951 source3/winbindd/winbindd_cache.c 	if (strncmp((const char *)kbuf.dptr, "CRED/", 5) == 0) {
dptr             2963 source3/winbindd/winbindd_cache.c 		fstrcpy(cred->name, (const char *)kbuf.dptr);		
dptr             3010 source3/winbindd/winbindd_cache.c 		if (!data.dptr) {
dptr             3017 source3/winbindd/winbindd_cache.c 		t = IVAL(data.dptr, 0);
dptr             3018 source3/winbindd/winbindd_cache.c 		SAFE_FREE(data.dptr);
dptr             3077 source3/winbindd/winbindd_cache.c 	if (!data.dptr || data.dsize != 4) {
dptr             3079 source3/winbindd/winbindd_cache.c 		SAFE_FREE(data.dptr);
dptr             3084 source3/winbindd/winbindd_cache.c 		SAFE_FREE(data.dptr);
dptr             3127 source3/winbindd/winbindd_cache.c 	centry->data = (unsigned char *)memdup(data.dptr, data.dsize);
dptr             3660 source3/winbindd/winbindd_cache.c 	if (strncmp("UA/", (const char *)kbuf.dptr, 3) == 0) {
dptr             3673 source3/winbindd/winbindd_cache.c 				strncmp(key_val[i].keyname, (const char *)kbuf.dptr, namelen)) == 0) {
dptr             3682 source3/winbindd/winbindd_cache.c 			memcpy(keystr, kbuf.dptr, kbuf.dsize);
dptr             3701 source3/winbindd/winbindd_cache.c 	dump_data(0, (uint8 *)kbuf.dptr, kbuf.dsize);
dptr             3703 source3/winbindd/winbindd_cache.c 	dump_data(0, (uint8 *)dbuf.dptr, dbuf.dsize);
dptr             4028 source3/winbindd/winbindd_cache.c 	if ( !key.dptr )
dptr             4038 source3/winbindd/winbindd_cache.c 	data.dsize = pack_tdc_domains( domains, num_domains, &data.dptr );
dptr             4040 source3/winbindd/winbindd_cache.c 	if ( !data.dptr ) {
dptr             4048 source3/winbindd/winbindd_cache.c 	SAFE_FREE( data.dptr );
dptr             4049 source3/winbindd/winbindd_cache.c 	SAFE_FREE( key.dptr );
dptr             4065 source3/winbindd/winbindd_cache.c 	if ( !key.dptr )
dptr             4070 source3/winbindd/winbindd_cache.c 	SAFE_FREE( key.dptr );
dptr             4072 source3/winbindd/winbindd_cache.c 	if ( !data.dptr ) 
dptr             4075 source3/winbindd/winbindd_cache.c 	*num_domains = unpack_tdc_domains( data.dptr, data.dsize, domains );
dptr             4077 source3/winbindd/winbindd_cache.c 	SAFE_FREE( data.dptr );
dptr               92 source4/heimdal/lib/hdb/ndbm.c     if(key.dptr == NULL)
dptr               94 source4/heimdal/lib/hdb/ndbm.c     key_data.data = key.dptr;
dptr              100 source4/heimdal/lib/hdb/ndbm.c     data.data = value.dptr;
dptr              210 source4/heimdal/lib/hdb/ndbm.c     k.dptr  = key.data;
dptr              217 source4/heimdal/lib/hdb/ndbm.c     if(v.dptr == NULL)
dptr              220 source4/heimdal/lib/hdb/ndbm.c     krb5_data_copy(reply, v.dptr, v.dsize);
dptr              232 source4/heimdal/lib/hdb/ndbm.c     k.dptr  = key.data;
dptr              234 source4/heimdal/lib/hdb/ndbm.c     v.dptr  = value.data;
dptr              257 source4/heimdal/lib/hdb/ndbm.c     k.dptr = key.data;
dptr             1508 source4/lib/ldb/ldb_tdb/ldb_index.c 	if (strncmp((char *)key.dptr, dn, strlen(dn)) == 0) {
dptr             1528 source4/lib/ldb/ldb_tdb/ldb_index.c 	if (strncmp((char *)key.dptr, "DN=@", 4) == 0 ||
dptr             1529 source4/lib/ldb/ldb_tdb/ldb_index.c 	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
dptr             1547 source4/lib/ldb/ldb_tdb/ldb_index.c 	if (key2.dptr == NULL) {
dptr             1554 source4/lib/ldb/ldb_tdb/ldb_index.c 	if (strcmp((char *)key2.dptr, (char *)key.dptr) != 0) {
dptr             1558 source4/lib/ldb/ldb_tdb/ldb_index.c 	talloc_free(key2.dptr);
dptr             1561 source4/lib/ldb/ldb_tdb/ldb_index.c 		dn = (char *)key.dptr + 3;
dptr              115 source4/lib/ldb/ldb_tdb/ldb_pack.c 	data->dptr = talloc_array(ldb, uint8_t, size);
dptr              116 source4/lib/ldb/ldb_tdb/ldb_pack.c 	if (!data->dptr) {
dptr              122 source4/lib/ldb/ldb_tdb/ldb_pack.c 	p = data->dptr;
dptr              173 source4/lib/ldb/ldb_tdb/ldb_pack.c 	p = data->dptr;
dptr              220 source4/lib/ldb/ldb_tdb/ldb_search.c 	if (!tdb_key.dptr) {
dptr              225 source4/lib/ldb/ldb_tdb/ldb_search.c 	talloc_free(tdb_key.dptr);
dptr              226 source4/lib/ldb/ldb_tdb/ldb_search.c 	if (!tdb_data.dptr) {
dptr              230 source4/lib/ldb/ldb_tdb/ldb_search.c 	free(tdb_data.dptr);
dptr              252 source4/lib/ldb/ldb_tdb/ldb_search.c 	if (!tdb_key.dptr) {
dptr              257 source4/lib/ldb/ldb_tdb/ldb_search.c 	talloc_free(tdb_key.dptr);
dptr              258 source4/lib/ldb/ldb_tdb/ldb_search.c 	if (!tdb_data.dptr) {
dptr              266 source4/lib/ldb/ldb_tdb/ldb_search.c 	free(tdb_data.dptr);
dptr              385 source4/lib/ldb/ldb_tdb/ldb_search.c 	    strncmp((char *)key.dptr, "DN=", 3) != 0) {
dptr              403 source4/lib/ldb/ldb_tdb/ldb_search.c 				     (char *)key.dptr + 3);
dptr              148 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dptr = (uint8_t *)key_str;
dptr              155 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	key.dptr = NULL;
dptr              224 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	if (!tdb_key.dptr) {
dptr              230 source4/lib/ldb/ldb_tdb/ldb_tdb.c 		talloc_free(tdb_key.dptr);
dptr              246 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_key.dptr);
dptr              247 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_data.dptr);
dptr              323 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	if (!tdb_key.dptr) {
dptr              328 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_key.dptr);
dptr              574 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	if (!tdb_key.dptr) {
dptr              579 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	if (!tdb_data.dptr) {
dptr              580 source4/lib/ldb/ldb_tdb/ldb_tdb.c 		talloc_free(tdb_key.dptr);
dptr              584 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	msg2 = talloc(tdb_key.dptr, struct ldb_message);
dptr              586 source4/lib/ldb/ldb_tdb/ldb_tdb.c 		talloc_free(tdb_key.dptr);
dptr              736 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_key.dptr);
dptr              737 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	free(tdb_data.dptr);
dptr              741 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	talloc_free(tdb_key.dptr);
dptr              742 source4/lib/ldb/ldb_tdb/ldb_tdb.c 	free(tdb_data.dptr);
dptr              998 source4/lib/messaging/messaging.c 	rec.dptr = (unsigned char *)realloc_p(rec.dptr, struct server_id, count+1);
dptr             1000 source4/lib/messaging/messaging.c 	if (rec.dptr == NULL) {
dptr             1005 source4/lib/messaging/messaging.c 	((struct server_id *)rec.dptr)[count] = msg_ctx->server_id;
dptr             1009 source4/lib/messaging/messaging.c 	free(rec.dptr);
dptr             1041 source4/lib/messaging/messaging.c 	if (rec.dptr == NULL) {
dptr             1054 source4/lib/messaging/messaging.c 		ret[i] = ((struct server_id *)rec.dptr)[i];
dptr             1057 source4/lib/messaging/messaging.c 	free(rec.dptr);
dptr             1086 source4/lib/messaging/messaging.c 	if (rec.dptr == NULL) {
dptr             1093 source4/lib/messaging/messaging.c 		free(rec.dptr);
dptr             1098 source4/lib/messaging/messaging.c 	ids = (struct server_id *)rec.dptr;
dptr             1110 source4/lib/messaging/messaging.c 	free(rec.dptr);
dptr              299 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
dptr              337 source4/ntvfs/common/brlock_tdb.c 	if (dbuf.dptr) {
dptr              339 source4/ntvfs/common/brlock_tdb.c 		locks = (struct lock_struct *)dbuf.dptr;
dptr              355 source4/ntvfs/common/brlock_tdb.c 		dbuf.dptr = (uint8_t *)locks;
dptr              365 source4/ntvfs/common/brlock_tdb.c 	free(dbuf.dptr);
dptr              379 source4/ntvfs/common/brlock_tdb.c 	free(dbuf.dptr);
dptr              449 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
dptr              457 source4/ntvfs/common/brlock_tdb.c 	if (!dbuf.dptr) {
dptr              467 source4/ntvfs/common/brlock_tdb.c 	locks = (struct lock_struct *)dbuf.dptr;
dptr              520 source4/ntvfs/common/brlock_tdb.c 		free(dbuf.dptr);
dptr              529 source4/ntvfs/common/brlock_tdb.c 	free(dbuf.dptr);
dptr              549 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
dptr              557 source4/ntvfs/common/brlock_tdb.c 	if (!dbuf.dptr) {
dptr              563 source4/ntvfs/common/brlock_tdb.c 	locks = (struct lock_struct *)dbuf.dptr;
dptr              591 source4/ntvfs/common/brlock_tdb.c 			free(dbuf.dptr);
dptr              601 source4/ntvfs/common/brlock_tdb.c 	free(dbuf.dptr);
dptr              620 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
dptr              624 source4/ntvfs/common/brlock_tdb.c 	if (dbuf.dptr == NULL) {
dptr              637 source4/ntvfs/common/brlock_tdb.c 	locks = (struct lock_struct *)dbuf.dptr;
dptr              642 source4/ntvfs/common/brlock_tdb.c 			free(dbuf.dptr);
dptr              647 source4/ntvfs/common/brlock_tdb.c 	free(dbuf.dptr);
dptr              663 source4/ntvfs/common/brlock_tdb.c 	kbuf.dptr = brlh->key.data;
dptr              671 source4/ntvfs/common/brlock_tdb.c 	if (!dbuf.dptr) {
dptr              677 source4/ntvfs/common/brlock_tdb.c 	locks = (struct lock_struct *)dbuf.dptr;
dptr              716 source4/ntvfs/common/brlock_tdb.c 	free(dbuf.dptr);
dptr              173 source4/ntvfs/common/notify.c 	if (dbuf.dptr == NULL) {
dptr              177 source4/ntvfs/common/notify.c 	blob.data = dbuf.dptr;
dptr              183 source4/ntvfs/common/notify.c 	free(dbuf.dptr);
dptr              236 source4/ntvfs/common/notify.c 	dbuf.dptr = blob.data;
dptr              141 source4/ntvfs/common/opendb_tdb.c 	lck->key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
dptr              143 source4/ntvfs/common/opendb_tdb.c 	if (lck->key.dptr == NULL) {
dptr              171 source4/ntvfs/common/opendb_tdb.c 	return data_blob_talloc(mem_ctx, lck->key.dptr, lck->key.dsize);
dptr              242 source4/ntvfs/common/opendb_tdb.c 	if (dbuf.dptr == NULL) {
dptr              246 source4/ntvfs/common/opendb_tdb.c 	blob.data = dbuf.dptr;
dptr              250 source4/ntvfs/common/opendb_tdb.c 	free(dbuf.dptr);
dptr              282 source4/ntvfs/common/opendb_tdb.c 	dbuf.dptr = blob.data;
dptr               98 source4/ntvfs/posix/xattr_tdb.c 	key->dptr = talloc_array(mem_ctx, uint8_t, 16 + len);
dptr               99 source4/ntvfs/posix/xattr_tdb.c 	if (key->dptr == NULL) {
dptr              104 source4/ntvfs/posix/xattr_tdb.c 	SBVAL(key->dptr, 0, st.st_dev);
dptr              105 source4/ntvfs/posix/xattr_tdb.c 	SBVAL(key->dptr, 8, st.st_ino);
dptr              106 source4/ntvfs/posix/xattr_tdb.c 	memcpy(key->dptr+16, attr_name, len);
dptr              131 source4/ntvfs/posix/xattr_tdb.c 	if (tdata.dptr == NULL) {
dptr              135 source4/ntvfs/posix/xattr_tdb.c 	*blob = data_blob_talloc(mem_ctx, tdata.dptr, tdata.dsize);
dptr              136 source4/ntvfs/posix/xattr_tdb.c 	free(tdata.dptr);
dptr              161 source4/ntvfs/posix/xattr_tdb.c 	tdata.dptr = blob->data;
dptr              165 source4/ntvfs/posix/xattr_tdb.c 		talloc_free(tkey.dptr);
dptr              180 source4/ntvfs/posix/xattr_tdb.c 	talloc_free(tkey.dptr);
dptr              200 source4/ntvfs/posix/xattr_tdb.c 		talloc_free(tkey.dptr);
dptr              204 source4/ntvfs/posix/xattr_tdb.c 	talloc_free(tkey.dptr);
dptr               93 source4/torture/basic/mangle_test.c 	if (data.dptr) {
dptr               95 source4/torture/basic/mangle_test.c 		if (strcasecmp(name, (const char *)data.dptr) != 0) {
dptr              100 source4/torture/basic/mangle_test.c 				name, data.dptr, shortname, collisions, total);
dptr              102 source4/torture/basic/mangle_test.c 		free(data.dptr);
dptr              106 source4/torture/basic/mangle_test.c 		namedata.dptr = discard_const_p(uint8_t, name);
dptr               39 source4/torture/local/dbspeed.c 	key.dptr = (uint8_t *)talloc_asprintf(tdbw, fmt1, i);
dptr               40 source4/torture/local/dbspeed.c 	key.dsize = strlen((char *)key.dptr)+1;
dptr               41 source4/torture/local/dbspeed.c 	data.dptr = (uint8_t *)talloc_asprintf(tdbw, fmt2, i+10000);
dptr               42 source4/torture/local/dbspeed.c 	data.dsize = strlen((char *)data.dptr)+1;
dptr               46 source4/torture/local/dbspeed.c 	talloc_free(key.dptr);
dptr               47 source4/torture/local/dbspeed.c 	talloc_free(data.dptr);
dptr               98 source4/torture/local/dbspeed.c 		key.dptr = (uint8_t *)talloc_asprintf(tmp_ctx, "S-1-5-21-53173311-3623041448-2049097239-%u", i);
dptr               99 source4/torture/local/dbspeed.c 		key.dsize = strlen((char *)key.dptr)+1;
dptr              101 source4/torture/local/dbspeed.c 		talloc_free(key.dptr);
dptr              102 source4/torture/local/dbspeed.c 		if (data.dptr == NULL) {
dptr              106 source4/torture/local/dbspeed.c 		free(data.dptr);
dptr              107 source4/torture/local/dbspeed.c 		key.dptr = (uint8_t *)talloc_asprintf(tmp_ctx, "UID %u", i);
dptr              108 source4/torture/local/dbspeed.c 		key.dsize = strlen((char *)key.dptr)+1;
dptr              110 source4/torture/local/dbspeed.c 		talloc_free(key.dptr);
dptr              111 source4/torture/local/dbspeed.c 		if (data.dptr == NULL) {
dptr              115 source4/torture/local/dbspeed.c 		free(data.dptr);