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