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