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

static char *get_username_from_passwd_file (void *ctx){    long pw_buf_size;    char *pw_buf;    struct passwd passwd, *ignored;    char *name;    int e;    pw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);    if (pw_buf_size == -1) pw_buf_size = 64;    pw_buf = talloc_zero_size (ctx, pw_buf_size);    while ((e = getpwuid_r (getuid (), &passwd, pw_buf,                            pw_buf_size, &ignored)) == ERANGE) {        pw_buf_size = pw_buf_size * 2;        pw_buf = talloc_zero_size(ctx, pw_buf_size);    }    if (e == 0)	name = talloc_strdup (ctx, passwd.pw_name);    else	name = talloc_strdup (ctx, "");    talloc_free (pw_buf);    return name;}

static bool wrap_ndr_inout_pull_test(struct torture_context *tctx,				     struct torture_tcase *tcase,				     struct torture_test *test){	bool (*check_fn) (struct torture_context *ctx, void *data) = test->fn;	const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;	void *ds = talloc_zero_size(tctx, data->struct_size);	struct ndr_pull *ndr;	uint32_t highest_ofs;	/* handle NDR_IN context */	ndr = ndr_pull_init_blob(&(data->data_context), tctx);	torture_assert(tctx, ndr, "ndr init failed");	ndr->flags |= LIBNDR_FLAG_REF_ALLOC;	torture_assert_ndr_success(tctx,		data->pull_fn(ndr, NDR_IN, ds),		"ndr pull of context failed");	if (ndr->offset > ndr->relative_highest_offset) {		highest_ofs = ndr->offset;	} else {		highest_ofs = ndr->relative_highest_offset;	}	torture_assert(tctx, highest_ofs == ndr->data_size,		talloc_asprintf(tctx, "%d unread bytes", ndr->data_size - highest_ofs));	talloc_free(ndr);	/* handle NDR_OUT */	ndr = ndr_pull_init_blob(&(data->data), tctx);	torture_assert(tctx, ndr, "ndr init failed");	ndr->flags |= LIBNDR_FLAG_REF_ALLOC;	torture_assert_ndr_success(tctx,		data->pull_fn(ndr, NDR_OUT, ds),		"ndr pull failed");	if (ndr->offset > ndr->relative_highest_offset) {		highest_ofs = ndr->offset;	} else {		highest_ofs = ndr->relative_highest_offset;	}	torture_assert(tctx, highest_ofs == ndr->data_size,		talloc_asprintf(tctx, "%d unread bytes", ndr->data_size - highest_ofs));	talloc_free(ndr);	if (check_fn) {		return check_fn(tctx, ds);	} else {		return true;	}}

// return 1 on success, 0 if disabled, -1 on errorint stream_file_cache_init(stream_t *cache, stream_t *stream,                           struct mp_cache_opts *opts){    if (!opts->file || !opts->file[0] || opts->file_max < 1)        return 0;    FILE *file = fopen(opts->file, "wb+");    if (!file) {        MP_ERR(cache, "can't open cache file '%s'/n", opts->file);        return -1;    }    struct priv *p = talloc_zero(NULL, struct priv);    cache->priv = p;    p->original = stream;    p->cache_file = file;    p->max_size = opts->file_max * 1024LL;    // file_max can be INT_MAX, so this is at most about 256MB    p->block_bits = talloc_zero_size(p, (p->max_size / BLOCK_SIZE + 1) / 8 + 1);    cache->seek = seek;    cache->fill_buffer = fill_buffer;    cache->control = control;    cache->close = s_close;    return 1;}

static AudioChannelLayout* ca_query_stereo_layout(struct ao *ao,                                                  AudioDeviceID device,                                                  void *talloc_ctx){    OSStatus err;    const int nch = 2;    uint32_t channels[nch];    AudioChannelLayout *r = NULL;    AudioObjectPropertyAddress p_addr = (AudioObjectPropertyAddress) {        .mSelector = kAudioDevicePropertyPreferredChannelsForStereo,        .mScope    = kAudioDevicePropertyScopeOutput,        .mElement  = kAudioObjectPropertyElementWildcard,    };    uint32_t psize = sizeof(channels);    err = AudioObjectGetPropertyData(device, &p_addr, 0, NULL, &psize, channels);    CHECK_CA_ERROR("could not get device preferred stereo layout");    psize = sizeof(AudioChannelLayout) + nch * sizeof(AudioChannelDescription);    r = talloc_zero_size(talloc_ctx, psize);    r->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions;    r->mNumberChannelDescriptions = nch;    AudioChannelDescription desc = {0};    desc.mChannelFlags = kAudioChannelFlags_AllOff;    for(int i = 0; i < nch; i++) {        desc.mChannelLabel = channels[i];        r->mChannelDescriptions[i] = desc;    }coreaudio_error:    return r;}

int tr_dh_pub_hash(TID_REQ *request,		   unsigned char **out_digest,		   size_t *out_len){  const BIGNUM *pub = request->tidc_dh->pub_key;  unsigned char *bn_bytes = talloc_zero_size(request, BN_num_bytes(pub));  unsigned char *digest = talloc_zero_size(request, SHA_DIGEST_LENGTH+1);  assert(bn_bytes && digest);  BN_bn2bin(pub, bn_bytes);  SHA1(bn_bytes, BN_num_bytes(pub), digest);  *out_digest = digest;  *out_len = SHA_DIGEST_LENGTH;  talloc_free(bn_bytes);  return 0;}

int drm_object_create_properties(struct mp_log *log, int fd,                                 struct drm_object *object){    object->props = drmModeObjectGetProperties(fd, object->id, object->type);    if (object->props) {        object->props_info = talloc_zero_size(NULL, object->props->count_props                                              * sizeof(object->props_info));        if (object->props_info) {            for (int i = 0; i < object->props->count_props; i++)                object->props_info[i] = drmModeGetProperty(fd, object->props->props[i]);        } else {            mp_err(log, "Out of memory/n");            goto fail;        }    } else {        mp_err(log, "Failed to retrieve properties for object id %d/n", object->id);        goto fail;    }    return 0;  fail:    drm_object_free_properties(object);    return -1;}

bool prs_init(prs_struct *ps, uint32_t size, TALLOC_CTX *ctx, bool io){	ZERO_STRUCTP(ps);	ps->io = io;	ps->bigendian_data = RPC_LITTLE_ENDIAN;	ps->align = RPC_PARSE_ALIGN;	ps->is_dynamic = False;	ps->data_offset = 0;	ps->buffer_size = 0;	ps->data_p = NULL;	ps->mem_ctx = ctx;	if (size != 0) {		ps->buffer_size = size;		ps->data_p = (char *)talloc_zero_size(ps->mem_ctx, size);		if(ps->data_p == NULL) {			DEBUG(0,("prs_init: talloc fail for %u bytes./n", (unsigned int)size));			return False;		}		ps->is_dynamic = True; /* We own this memory. */	} else if (MARSHALLING(ps)) {		/* If size is zero and we're marshalling we should allocate memory on demand. */		ps->is_dynamic = True;	}	return True;}

struct gsm341_ms_message *gsm0341_build_msg(void *ctx, uint8_t geo_scope, uint8_t msg_code,		  uint8_t update, uint16_t msg_id, uint8_t dcs,		  uint8_t page_total, uint8_t page_cur,		  uint8_t *data, uint8_t len){	struct gsm341_ms_message *cbmsg;	msg_id = htons(msg_id);	if (len > 88)		return NULL;	cbmsg = talloc_zero_size(ctx, sizeof(*cbmsg)+len);	if (!cbmsg)		return NULL;	cbmsg->serial.code_hi = (msg_code >> 4) & 0xF;	cbmsg->serial.gs = geo_scope;	cbmsg->serial.update = update;	cbmsg->serial.code_lo = msg_code & 0xF;	cbmsg->msg_id = msg_id;	cbmsg->dcs.group = dcs >> 4;	cbmsg->dcs.language = dcs & 0xF;	cbmsg->page.total = page_total;	cbmsg->page.current = page_cur;	memcpy(cbmsg->data, data, len);	return cbmsg;}

/*  Constructs a PR_ENTRYID value for recipients. */_PUBLIC_ struct Binary_r *generate_recipient_entryid(TALLOC_CTX *mem_ctx, const char *recipient_id){	struct Binary_r	*entryid;	uint32_t	off;	char		*guid = (char *) NULL;	entryid = talloc(mem_ctx, struct Binary_r);	entryid->cb = sizeof (uint32_t) + sizeof (MAPI_LOCAL_UID) + sizeof (MAPI_LOCAL_UID_END) + 1;	if (recipient_id) {		guid = guid_delete_dash(mem_ctx, recipient_id);		entryid->cb += strlen(guid);	}	entryid->lpb = (uint8_t *)talloc_zero_size(mem_ctx, entryid->cb);	off = 4;	memcpy(entryid->lpb + off, MAPI_LOCAL_UID, sizeof (MAPI_LOCAL_UID));	off += sizeof (MAPI_LOCAL_UID);		memcpy(entryid->lpb + off, MAPI_LOCAL_UID_END, sizeof (MAPI_LOCAL_UID_END));	off += sizeof (MAPI_LOCAL_UID_END);	if (recipient_id) {		strcpy((char *)entryid->lpb + off, guid);		off += strlen(recipient_id);	}		return entryid;}

struct tlv_parsed *tlvp_copy(const struct tlv_parsed *tp_orig, void *ctx){	struct tlv_parsed *tp_out;	unsigned int i;	tp_out = talloc_zero(ctx, struct tlv_parsed);	if (!tp_out)		return NULL;	/* if the original is NULL, return empty tlvp */	if (!tp_orig)		return tp_out;	for (i = 0; i < ARRAY_SIZE(tp_orig->lv); i++) {		unsigned int len = tp_orig->lv[i].len;		tp_out->lv[i].len = len;		if (len && tp_out->lv[i].val) {			tp_out->lv[i].val = talloc_zero_size(tp_out, len);			if (!tp_out->lv[i].val) {				talloc_free(tp_out);				return NULL;			}			memcpy((uint8_t *)tp_out->lv[i].val, tp_orig->lv[i].val, len);		}	}	return tp_out;}

char *cfstr_get_cstr(CFStringRef cfstr){    CFIndex size =        CFStringGetMaximumSizeForEncoding(            CFStringGetLength(cfstr), CA_CFSTR_ENCODING) + 1;    char *buffer = talloc_zero_size(NULL, size);    CFStringGetCString(cfstr, buffer, size, CA_CFSTR_ENCODING);    return buffer;}

const char *notmuch_time_relative_date (const void *ctx, time_t then){    struct tm tm_now, tm_then;    time_t now = time(NULL);    time_t delta;    char *result;    localtime_r (&now, &tm_now);    localtime_r (&then, &tm_then);    result = talloc_zero_size (ctx, RELATIVE_DATE_MAX);    if (result == NULL)	return "when?";    if (then > now)	return "the future";    delta = now - then;    if (delta > 180 * DAY) {	strftime (result, RELATIVE_DATE_MAX,		  "%F", &tm_then); /* 2008-06-30 */	return result;    }    if (delta < 3600) {	snprintf (result, RELATIVE_DATE_MAX,		  "%d mins. ago", (int) (delta / 60));	return result;    }    if (delta <= 7 * DAY) {	if (tm_then.tm_wday == tm_now.tm_wday &&	    delta < DAY)	{	    strftime (result, RELATIVE_DATE_MAX,		      "Today %R", &tm_then); /* Today 12:30 */	    return result;	} else if ((tm_now.tm_wday + 7 - tm_then.tm_wday) % 7 == 1) {	    strftime (result, RELATIVE_DATE_MAX,		      "Yest. %R", &tm_then); /* Yest. 12:30 */	    return result;	} else {	    if (tm_then.tm_wday != tm_now.tm_wday) {		strftime (result, RELATIVE_DATE_MAX,			  "%a. %R", &tm_then); /* Mon. 12:30 */		return result;	    }	}    }    strftime (result, RELATIVE_DATE_MAX,	      "%B %d", &tm_then); /* October 12 */    return result;}

/*! /brief Generate a VTY command string from value_string */char *vty_cmd_string_from_valstr(void *ctx, const struct value_string *vals,				 const char *prefix, const char *sep,				 const char *end, int do_lower){	int len = 0, offset = 0, ret, rem;	int size = strlen(prefix) + strlen(end);	int sep_len = strlen(sep);	const struct value_string *vs;	char *str;	for (vs = vals; vs->value || vs->str; vs++)		size += strlen(vs->str) + sep_len;	rem = size;	str = talloc_zero_size(ctx, size);	if (!str)		return NULL;	ret = snprintf(str + offset, rem, "%s", prefix);	if (ret < 0)		goto err;	OSMO_SNPRINTF_RET(ret, rem, offset, len);	for (vs = vals; vs->value || vs->str; vs++) {		if (vs->str) {			int j, name_len = strlen(vs->str)+1;			char name[name_len];			for (j = 0; j < name_len; j++)				name[j] = do_lower ?					tolower(vs->str[j]) : vs->str[j];			name[name_len-1] = '/0';			ret = snprintf(str + offset, rem, "%s%s", name, sep);			if (ret < 0)				goto err;			OSMO_SNPRINTF_RET(ret, rem, offset, len);		}	}	offset -= sep_len;	/* to remove the trailing sep */	rem += sep_len;	ret = snprintf(str + offset, rem, "%s", end);	if (ret < 0)		goto err;	OSMO_SNPRINTF_RET(ret, rem, offset, len);err:	str[size-1] = '/0';	return str;}

static PyObject *py_generate_random_bytes(PyObject *self, PyObject *args){	int len;	PyObject *ret;	uint8_t *bytes = NULL;	if (!PyArg_ParseTuple(args, "i", &len))		return NULL;	bytes = talloc_zero_size(NULL, len);	generate_random_buffer(bytes, len);	ret = PyBytes_FromStringAndSize((const char *)bytes, len);	talloc_free(bytes);	return ret;}

static int vo_preinit(struct vo *vo, char *arg){    if (vo->driver->privsize)        vo->priv = talloc_zero_size(vo, vo->driver->privsize);    if (vo->driver->options) {        struct m_config *cfg = m_config_simple(vo->driver->options);        m_config_initialize(cfg, vo->priv);        char n[50];        int l = snprintf(n, sizeof(n), "vo/%s", vo->driver->info->short_name);        assert(l < sizeof(n));        int r = m_config_parse_suboptions(cfg, vo->priv, n, arg);        talloc_free(cfg);        if (r < 0)            return r;    }    return vo->driver->preinit(vo, arg);}

/** Create a fifo queue * * The first element enqueued will be the first to be dequeued. * * @note The created fifo does not provide any thread synchronisation functionality *	such as mutexes.  If multiple threads are enqueueing and dequeueing data *	the callers must synchronise their access. * * @param[in] ctx	to allocate fifo array in. * @param[in] type	Talloc type of elements (may be NULL). * @param[in] max	The maximum number of elements allowed. * @param[in] free_node	Function to use to free node data if the fifo is freed. * @return *	- A new fifo queue. *	- NULL on error. */fr_fifo_t *_fr_fifo_create(TALLOC_CTX *ctx, char const *type, int max, fr_fifo_free_t free_node){	fr_fifo_t *fi;	if ((max < 2) || (max > (1024 * 1024))) return NULL;	fi = talloc_zero_size(ctx, (sizeof(*fi) + (sizeof(fi->data[0])*max)));	if (!fi) return NULL;	talloc_set_type(fi, fr_fifo_t);	talloc_set_destructor(fi, _fifo_free);	fi->max = max;	fi->type = type;	fi->free_node = free_node;	return fi;}

/* * @brief Create an new EncryptedSecret owned by the supplied talloc context. * * Create a new encrypted secret and initialise the header. * * @param ldb ldb context, to allow logging. * @param ctx The talloc memory context that will own the new EncryptedSecret * * @return pointer to the new encrypted secret, or NULL if there was an error */static struct EncryptedSecret *makeEncryptedSecret(struct ldb_context *ldb,						   TALLOC_CTX *ctx){	struct EncryptedSecret *es = NULL;	es = talloc_zero_size(ctx, sizeof(struct EncryptedSecret));	if (es == NULL) {		ldb_set_errstring(ldb,				  "Out of memory, allocating "				   "struct EncryptedSecret/n");		return NULL;	}	es->header.magic     = ENCRYPTED_SECRET_MAGIC_VALUE;	es->header.version   = SECRET_ATTRIBUTE_VERSION;	es->header.algorithm = SECRET_ENCRYPTION_ALGORITHM;	es->header.flags     = 0;	return es;}

/* helper function for marshalling multiple records */struct ctdb_marshall_buffer *ctdb_marshall_add(TALLOC_CTX *mem_ctx,					       struct ctdb_marshall_buffer *m,					       uint64_t db_id,					       uint32_t reqid,					       TDB_DATA key,					       struct ctdb_ltdb_header *header,					       TDB_DATA data){	struct ctdb_rec_data *r;	struct ctdb_marshall_buffer *m2;	uint32_t length, offset;	length = ctdb_marshall_record_size(key, header, data);	if (m == NULL) {		offset = offsetof(struct ctdb_marshall_buffer, data);		m2 = talloc_zero_size(mem_ctx, offset + length);	} else {

/* * Convert an Imap string to a filesystem string * ex INBOX/Test/Test2 -> .Test.Test2 */char *ImapToMaildir(TALLOC_CTX *MemCtx, char *sImap){char *returnString;int i;returnString = (char *)talloc_zero_size(MemCtx, strlen(sImap));i=0;while(sImap[i] != 0)  {  if( sImap[i+5] == '/' )    returnString[i] = '.';  else    returnString[i] = sImap[i+5];  i++;  }returnString[i] = 0;return( returnString ); }

static bool wrap_ndr_pullpush_test(struct torture_context *tctx,				   struct torture_tcase *tcase,				   struct torture_test *test){	bool (*check_fn) (struct torture_context *ctx, void *data) = test->fn;	const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;	struct ndr_pull *ndr = ndr_pull_init_blob(&(data->data), tctx);	void *ds = talloc_zero_size(ndr, data->struct_size);	bool ret;	uint32_t highest_ofs;	ndr->flags |= data->flags;	ndr->flags |= LIBNDR_FLAG_REF_ALLOC;	torture_assert_ndr_success(tctx, data->pull_fn(ndr, data->ndr_flags, ds),				   "pulling");	if (ndr->offset > ndr->relative_highest_offset) {		highest_ofs = ndr->offset;	} else {		highest_ofs = ndr->relative_highest_offset;	}	torture_assert(tctx, highest_ofs == ndr->data_size,				   talloc_asprintf(tctx,					   "%d unread bytes", ndr->data_size - highest_ofs));	if (check_fn != NULL) {		ret = check_fn(tctx, ds);	} else {		ret = true;	}	if (data->push_fn != NULL) {		DATA_BLOB outblob;		torture_assert_ndr_success(tctx, ndr_push_struct_blob(&outblob, ndr, ds, data->push_fn), "pushing");		torture_assert_data_blob_equal(tctx, outblob, data->data, "ndr push compare");	}	talloc_free(ndr);	return ret;}

static int vo_preinit(struct vo *vo, char *arg){    if (vo->driver->priv_size) {        vo->priv = talloc_zero_size(vo, vo->driver->priv_size);        if (vo->driver->priv_defaults)            memcpy(vo->priv, vo->driver->priv_defaults, vo->driver->priv_size);    }    if (vo->driver->options) {        struct m_config *cfg = m_config_simple(vo->priv);        talloc_steal(vo->priv, cfg);        m_config_register_options(cfg, vo->driver->options);        char n[50];        int l = snprintf(n, sizeof(n), "vo/%s", vo->driver->info->short_name);        assert(l < sizeof(n));        int r = m_config_parse_suboptions(cfg, n, arg);        if (r < 0)            return r;    }    return vo->driver->preinit(vo, arg);}

/* enqueue some data into the tx_queue of a given subchannel */int subchan_mux_enqueue(struct subch_mux *mx, int s_nr, const u_int8_t *data,			int len){	struct mux_subch *sch = &mx->subch[s_nr];	int list_len = llist_len(&sch->tx_queue);	struct subch_txq_entry *tqe = talloc_zero_size(tall_tqe_ctx,							sizeof(*tqe) + len);	if (!tqe)		return -ENOMEM;	tqe->bit_len = len;	memcpy(tqe->bits, data, len);	if (list_len > 2)		tx_queue_evict(sch, list_len-2);	llist_add_tail(&tqe->list, &sch->tx_queue);	return 0;}

_PUBLIC_ char *guid_delete_dash(TALLOC_CTX *mem_ctx, const char *recipient_id){	char		*guid;	uint32_t	count,i;	if (!recipient_id) {		return NULL;	}	for (count=0,i=0;i!=strlen(recipient_id);i++) {		if (recipient_id[i] != '-') count++;	}	guid = (char *)talloc_zero_size(mem_ctx, count+1);	for (count=0,i = 0;i!=strlen(recipient_id);i++) {		if (recipient_id[i] != '-') {			guid[count] = recipient_id[i];			count++;		}	}	return guid;}

static bool wrap_ndr_pull_test(struct torture_context *tctx,							   struct torture_tcase *tcase,							   struct torture_test *test){	bool (*check_fn) (struct torture_context *ctx, void *data) = test->fn;	const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;	void *ds = talloc_zero_size(tctx, data->struct_size);	struct ndr_pull *ndr = ndr_pull_init_blob(&(data->data), tctx, lp_iconv_convenience(tctx->lp_ctx));	ndr->flags |= LIBNDR_FLAG_REF_ALLOC;	torture_assert_ndr_success(tctx, data->pull_fn(ndr, data->ndr_flags, ds),				   "pulling");	torture_assert(tctx, ndr->offset == ndr->data_size, 				   talloc_asprintf(tctx, 					   "%d unread bytes", ndr->data_size - ndr->offset));	if (check_fn != NULL) 		return check_fn(tctx, ds);	else		return true;}

struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,				    void *pdata,				    size_t data_size,				    const char *type,				    const char *location){	struct tevent_req *req;	void **ppdata = (void **)pdata;	void *data;	req = talloc_zero(mem_ctx, struct tevent_req);	if (req == NULL) {		return NULL;	}	req->internal.private_type	= type;	req->internal.create_location	= location;	req->internal.finish_location	= NULL;	req->internal.state		= TEVENT_REQ_IN_PROGRESS;	req->internal.trigger		= tevent_create_immediate(req);	if (!req->internal.trigger) {		talloc_free(req);		return NULL;	}	req->internal.defer_callback_ev	= NULL;	data = talloc_zero_size(req, data_size);	if (data == NULL) {		talloc_free(req);		return NULL;	}	talloc_set_name_const(data, type);	req->data = data;	*ppdata = data;	return req;}

struct rate_ctr_group *rate_ctr_group_alloc(void *ctx,					    const struct rate_ctr_group_desc *desc,					    unsigned int idx){	unsigned int size;	struct rate_ctr_group *group;	size = sizeof(struct rate_ctr_group) +			desc->num_ctr * sizeof(struct rate_ctr);	if (!ctx)		ctx = tall_rate_ctr_ctx;	group = talloc_zero_size(ctx, size);	if (!group)		return NULL;	group->desc = desc;	group->idx = idx;	llist_add(&group->list, &rate_ctr_groups);	return group;}

/** * Initializes a new primitive by allocating memory * and filling some meta-information (e.g. lchan type). * * @param  trx     TRX instance to be used as initial talloc context * @param  prim    external prim pointer (will point to the allocated prim) * @param  pl_len  prim payload length * @param  chan_nr RSL channel description (used to set a proper chan) * @param  link_id RSL link description (used to set a proper chan) * @return         zero in case of success, otherwise a error number */int sched_prim_init(struct trx_instance *trx,	struct trx_ts_prim **prim, size_t pl_len,	uint8_t chan_nr, uint8_t link_id){	enum trx_lchan_type lchan_type;	struct trx_ts_prim *new_prim;	uint8_t len;	/* Determine lchan type */	lchan_type = sched_trx_chan_nr2lchan_type(chan_nr, link_id);	if (!lchan_type) {		LOGP(DSCH, LOGL_ERROR, "Couldn't determine lchan type "			"for chan_nr=%02x and link_id=%02x/n", chan_nr, link_id);		return -EINVAL;	}	/* How much memory do we need? */	len  = sizeof(struct trx_ts_prim); /* Primitive header */	len += pl_len; /* Requested payload size */	/* Allocate a new primitive */	new_prim = talloc_zero_size(trx, len);	if (new_prim == NULL) {		LOGP(DSCH, LOGL_ERROR, "Failed to allocate memory/n");		return -ENOMEM;	}	/* Init primitive header */	new_prim->payload_len = pl_len;	new_prim->chan = lchan_type;	/* Set external pointer */	*prim = new_prim;	return 0;}

struct dcerpc_binding_handle *_dcerpc_binding_handle_create(TALLOC_CTX *mem_ctx,					const struct dcerpc_binding_handle_ops *ops,					const struct GUID *object,					const struct ndr_interface_table *table,					void *pstate,					size_t psize,					const char *type,					const char *location){	struct dcerpc_binding_handle *h;	void **ppstate = (void **)pstate;	void *state;	h = talloc_zero(mem_ctx, struct dcerpc_binding_handle);	if (h == NULL) {		return NULL;	}	h->ops		= ops;	h->location	= location;	h->object	= object;	h->table	= table;	state = talloc_zero_size(h, psize);	if (state == NULL) {		talloc_free(h);		return NULL;	}	talloc_set_name_const(state, type);	h->private_data = state;	talloc_set_destructor(h, dcerpc_binding_handle_destructor);	*ppstate = state;	return h;}

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