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

static void pam_handle_cached_login(struct pam_auth_req *preq, int ret,                                    time_t expire_date, time_t delayed_until){    uint32_t resp_type;    size_t resp_len;    uint8_t *resp;    int64_t dummy;    preq->pd->pam_status = cached_login_pam_status(ret);    switch (preq->pd->pam_status) {        case PAM_SUCCESS:            resp_type = SSS_PAM_USER_INFO_OFFLINE_AUTH;            resp_len = sizeof(uint32_t) + sizeof(int64_t);            resp = talloc_size(preq->pd, resp_len);            if (resp == NULL) {                DEBUG(SSSDBG_CRIT_FAILURE,                      "talloc_size failed, cannot prepare user info./n");            } else {                memcpy(resp, &resp_type, sizeof(uint32_t));                dummy = (int64_t) expire_date;                memcpy(resp+sizeof(uint32_t), &dummy, sizeof(int64_t));                ret = pam_add_response(preq->pd, SSS_PAM_USER_INFO, resp_len,                                       (const uint8_t *) resp);                if (ret != EOK) {                    DEBUG(SSSDBG_CRIT_FAILURE, "pam_add_response failed./n");                }            }            break;        case PAM_PERM_DENIED:            if (delayed_until >= 0) {                resp_type = SSS_PAM_USER_INFO_OFFLINE_AUTH_DELAYED;                resp_len = sizeof(uint32_t) + sizeof(int64_t);                resp = talloc_size(preq->pd, resp_len);                if (resp == NULL) {                    DEBUG(SSSDBG_CRIT_FAILURE,                          "talloc_size failed, cannot prepare user info./n");                } else {                    memcpy(resp, &resp_type, sizeof(uint32_t));                    dummy = (int64_t) delayed_until;                    memcpy(resp+sizeof(uint32_t), &dummy, sizeof(int64_t));                    ret = pam_add_response(preq->pd, SSS_PAM_USER_INFO, resp_len,                                           (const uint8_t *) resp);                    if (ret != EOK) {                        DEBUG(SSSDBG_CRIT_FAILURE,                              "pam_add_response failed./n");                    }                }            }            break;        default:            DEBUG(SSSDBG_TRACE_LIBS,                  "cached login returned: %d/n", preq->pd->pam_status);    }    pam_reply(preq);    return;}

/**   /details Return the list of pending mapistore notifications   available on the queue name specified in argument.   /param mstore_ctx pointer to the mapistore context   /param mqueue_name the name of the queue to open   /param nl pointer on pointer to the list of mapistore notifications to return   /return MAPISTORE_SUCCESS on success, otherwise MAPISTORE error. */_PUBLIC_ enum MAPISTATUS mapistore_get_queued_notifications_named(struct mapistore_context *mstore_ctx,								  const char *mqueue_name,								  struct mapistore_notification_list **nl){	int					ret;	mqd_t					mqueue;	struct mapistore_notification_list	*nlist = NULL;	struct mapistore_notification_list	*el = NULL;	unsigned int				prio;	struct mq_attr				attr;	DATA_BLOB				data;	bool					found = false;	printf("[%s:%d]: queue name = %s/n", __FUNCTION__, __LINE__, ((mqueue_name) ? mqueue_name : NULL));	/* Sanity checks */	MAPISTORE_RETVAL_IF(!mstore_ctx, MAPISTORE_ERR_NOT_INITIALIZED, NULL);	MAPISTORE_RETVAL_IF(!nl, MAPISTORE_ERR_INVALID_PARAMETER, NULL);	mqueue = mq_open(mqueue_name, O_RDONLY|O_NONBLOCK|O_CREAT, 0777, NULL);	if (mqueue == -1) {		perror("mq_open");		return MAPISTORE_ERR_NOT_INITIALIZED;	}	/* Retrieve queue attributes */	ret = mq_getattr(mqueue, &attr);	if (ret == -1) {		perror("mq_getattr");		/* set proper error message here and remove above */		if (mq_close(mqueue) == -1) {			perror("mq_close");		}		MAPISTORE_RETVAL_IF(ret == -1, MAPISTORE_ERR_NOT_FOUND, NULL);	}	data.data = talloc_size((TALLOC_CTX *)mstore_ctx, attr.mq_msgsize);	while ((data.length = mq_receive(mqueue, (char *)data.data, attr.mq_msgsize, &prio)) != -1) {		printf("* we received a notification on queue %s/n", mqueue_name);		if (!nlist) {			nlist = talloc_zero((TALLOC_CTX *)mstore_ctx, struct mapistore_notification_list);		}		el = mapistore_notification_process_mqueue_notif((TALLOC_CTX *)nlist, data);		printf("* processing notification returned %p/n", el);		if (el) {			DLIST_ADD_END(nlist, el, struct mapistore_notification_list);		}		talloc_free(data.data);		found = true;		data.data = talloc_size((TALLOC_CTX *)mstore_ctx, attr.mq_msgsize);	}

struct tsocket_address *_tsocket_address_create(TALLOC_CTX *mem_ctx,						const struct tsocket_address_ops *ops,						void *pstate,						size_t psize,						const char *type,						const char *location){	void **ppstate = (void **)pstate;	struct tsocket_address *addr;	addr = talloc_zero(mem_ctx, struct tsocket_address);	if (!addr) {		return NULL;	}	addr->ops = ops;	addr->location = location;	addr->private_data = talloc_size(addr, psize);	if (!addr->private_data) {		talloc_free(addr);		return NULL;	}	talloc_set_name_const(addr->private_data, type);	*ppstate = addr->private_data;	return addr;}

static NTSTATUS spoolss__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r){	enum ndr_err_code ndr_err;	uint16_t opnum = dce_call->pkt.u.request.opnum;	dce_call->fault_code = 0;	if (opnum >= ndr_table_spoolss.num_calls) {		dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;		return NT_STATUS_NET_WRITE_FAULT;	}	*r = talloc_size(mem_ctx, ndr_table_spoolss.calls[opnum].struct_size);	NT_STATUS_HAVE_NO_MEMORY(*r);        /* unravel the NDR for the packet */	ndr_err = ndr_table_spoolss.calls[opnum].ndr_pull(pull, NDR_IN, *r);	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {		dcerpc_log_packet(dce_call->conn->packet_log_dir,						  &ndr_table_spoolss, opnum, NDR_IN,				  &dce_call->pkt.u.request.stub_and_verifier);		dce_call->fault_code = DCERPC_FAULT_NDR;		return NT_STATUS_NET_WRITE_FAULT;	}	return NT_STATUS_OK;}

/*  test the SinkData interface*/static bool test_sinkdata(struct torture_context *tctx, 						  struct dcerpc_pipe *p){	int i;	NTSTATUS status;	uint8_t *data_in;	int len;	struct echo_SinkData r;	if (torture_setting_bool(tctx, "quick", false) &&	    (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {		len = 100 + (random() % 5000);	} else {		len = 200000 + (random() % 5000);	}	data_in = talloc_size(tctx, len);	for (i=0;i<len;i++) {		data_in[i] = i+1;	}	r.in.len = len;	r.in.data = data_in;	status = dcerpc_echo_SinkData(p, tctx, &r);	torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, 										"SinkData(%d) failed", 							   len));	torture_comment(tctx, "sunk %d bytes/n", len);	return true;}

static char *get_name_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_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) {	char *comma = strchr (passwd.pw_gecos, ',');	if (comma)	    name = talloc_strndup (ctx, passwd.pw_gecos,				   comma - passwd.pw_gecos);	else	    name = talloc_strdup (ctx, passwd.pw_gecos);    } else {	name = talloc_strdup (ctx, "");    }    talloc_free (pw_buf);    return name;}

/* * Store a record together with the ctdb record header * in the local copy of the database. */static NTSTATUS db_ctdb_ltdb_store(struct db_ctdb_ctx *db,				   TDB_DATA key,				   struct ctdb_ltdb_header *header,				   TDB_DATA data){	TDB_DATA rec;	int ret;	rec.dsize = data.dsize + sizeof(struct ctdb_ltdb_header);	rec.dptr = (uint8_t *)talloc_size(talloc_tos(), rec.dsize);	if (rec.dptr == NULL) {		return NT_STATUS_NO_MEMORY;	}	memcpy(rec.dptr, header, sizeof(struct ctdb_ltdb_header));	memcpy(sizeof(struct ctdb_ltdb_header) + (uint8_t *)rec.dptr, data.dptr, data.dsize);	ret = tdb_store(db->wtdb->tdb, key, rec, TDB_REPLACE);	talloc_free(rec.dptr);	return (ret == 0) ? NT_STATUS_OK			  : tdb_error_to_ntstatus(db->wtdb->tdb);}

/*  dump talloc memory hierarchy, returning it as a blob to the client */int32_t ctdb_dump_memory(struct ctdb_context *ctdb, TDB_DATA *outdata){    /* dump to a file, then send the file as a blob */    FILE *f;    long fsize;    f = tmpfile();    if (f == NULL) {        DEBUG(DEBUG_ERR,(__location__ " Unable to open tmpfile - %s/n", strerror(errno)));        return -1;    }    talloc_report_full(NULL, f);    fsize = ftell(f);    if (fsize == -1) {        DEBUG(DEBUG_ERR, (__location__ " Unable to get file size - %s/n",                          strerror(errno)));        fclose(f);        return -1;    }    rewind(f);    outdata->dptr = talloc_size(outdata, fsize);    if (outdata->dptr == NULL) {        fclose(f);        CTDB_NO_MEMORY(ctdb, outdata->dptr);    }    outdata->dsize = fread(outdata->dptr, 1, fsize, f);    fclose(f);    if (outdata->dsize != fsize) {        DEBUG(DEBUG_ERR,(__location__ " Unable to read tmpfile/n"));        return -1;    }    return 0;}

void *_policy_handle_create(struct pipes_struct *p, struct policy_handle *hnd,                            uint32_t access_granted, size_t data_size,                            const char *type, NTSTATUS *pstatus){    struct policy *pol;    void *data;    if (p->pipe_handles->count > MAX_OPEN_POLS) {        DEBUG(0, ("policy_handle_create: ERROR: too many handles (%d) "                  "on pipe %s./n", (int)p->pipe_handles->count,                  get_pipe_name_from_syntax(talloc_tos(), &p->syntax)));        *pstatus = NT_STATUS_INSUFFICIENT_RESOURCES;        return NULL;    }    data = talloc_size(talloc_tos(), data_size);    if (data == NULL) {        *pstatus = NT_STATUS_NO_MEMORY;        return NULL;    }    talloc_set_name_const(data, type);    pol = create_policy_hnd_internal(p, hnd, data);    if (pol == NULL) {        TALLOC_FREE(data);        *pstatus = NT_STATUS_NO_MEMORY;        return NULL;    }    pol->access_granted = access_granted;    *pstatus = NT_STATUS_OK;    return data;}

glsl_type::glsl_type(const glsl_type *array, unsigned length) :   base_type(GLSL_TYPE_ARRAY),   sampler_dimensionality(0), sampler_shadow(0), sampler_array(0),   sampler_type(0),   vector_elements(0), matrix_columns(0),   name(NULL), length(length){   this->fields.array = array;   /* Inherit the gl type of the base. The GL type is used for    * uniform/statevar handling in Mesa and the arrayness of the type    * is represented by the size rather than the type.    */   this->gl_type = array->gl_type;   /* Allow a maximum of 10 characters for the array size.  This is enough    * for 32-bits of ~0.  The extra 3 are for the '[', ']', and terminating    * NUL.    */   const unsigned name_length = strlen(array->name) + 10 + 3;   char *const n = (char *) talloc_size(this->mem_ctx, name_length);   if (length == 0)      snprintf(n, name_length, "%s[]", array->name);   else      snprintf(n, name_length, "%s[%u]", array->name, length);   this->name = n;}

/*  add an integer into a record in sorted order*/static int sort_func(struct ctdb_call_info *call){	if (call->call_data == NULL ||	    call->call_data->dsize != sizeof(int)) {		return CTDB_ERR_INVALID;	}	call->new_data = talloc(call, TDB_DATA);	if (call->new_data == NULL) {		return CTDB_ERR_NOMEM;	}	call->new_data->dptr = talloc_size(call, 					   call->record_data.dsize + 					   call->call_data->dsize);	if (call->new_data->dptr == NULL) {		return CTDB_ERR_NOMEM;	}	call->new_data->dsize = call->record_data.dsize + call->call_data->dsize;	memcpy(call->new_data->dptr,	       call->record_data.dptr, call->record_data.dsize);	memcpy(call->new_data->dptr+call->record_data.dsize,	       call->call_data->dptr, call->call_data->dsize);	qsort(call->new_data->dptr, call->new_data->dsize / sizeof(int),	      sizeof(int), (comparison_fn_t)int_compare);	return 0;}

static void append_route(struct radius_ctx_st *pctx, const char *route, unsigned len){	unsigned i;	char *p;	/* accept route/mask */	if ((p=strchr(route, '/')) == 0)		return;	p = strchr(p, ' ');	if (p != NULL) {		len = p - route;	}	if (pctx->routes_size == 0) {		pctx->routes = talloc_size(pctx, sizeof(char*));	} else {		pctx->routes = talloc_realloc_size(pctx, pctx->routes,						   (pctx->routes_size+1)*sizeof(char*));	}	if (pctx->routes != NULL) {		i = pctx->routes_size;		pctx->routes[i] = talloc_strndup(pctx, route, len);		if (pctx->routes[i] != NULL)			pctx->routes_size++;	}}

/*  convert a dom_sid to a string*/char *dom_sid_string(TALLOC_CTX *mem_ctx, const struct dom_sid *sid){	int i, ofs, maxlen;	uint32_t ia;	char *ret;		if (!sid) {		return talloc_strdup(mem_ctx, "(NULL SID)");	}	maxlen = sid->num_auths * 11 + 25;	ret = (char *)talloc_size(mem_ctx, maxlen);	if (!ret) return talloc_strdup(mem_ctx, "(SID ERR)");	ia = (sid->id_auth[5]) +		(sid->id_auth[4] << 8 ) +		(sid->id_auth[3] << 16) +		(sid->id_auth[2] << 24);	ofs = snprintf(ret, maxlen, "S-%u-%lu", 		       (unsigned int)sid->sid_rev_num, (unsigned long)ia);	for (i = 0; i < sid->num_auths; i++) {		ofs += snprintf(ret + ofs, maxlen - ofs, "-%lu", (unsigned long)sid->sub_auths[i]);	}		return ret;}

int s3crypt_gen_salt(TALLOC_CTX *memctx, char **_salt){    uint8_t rb[SALT_RAND_LEN];    char *salt, *cp;    size_t slen;    int ret;    ret = nspr_nss_init();    if (ret != EOK) {        return EIO;    }    salt = talloc_size(memctx, SALT_LEN_MAX + 1);    if (!salt) {        return ENOMEM;    }    ret = PK11_GenerateRandom(rb, SALT_RAND_LEN);    if (ret != SECSuccess) {        return EIO;    }    slen = SALT_LEN_MAX;    cp = salt;    b64_from_24bit(&cp, &slen, 4, rb[0], rb[1], rb[2]);    b64_from_24bit(&cp, &slen, 4, rb[3], rb[4], rb[5]);    b64_from_24bit(&cp, &slen, 4, rb[6], rb[7], rb[8]);    b64_from_24bit(&cp, &slen, 4, rb[9], rb[10], rb[11]);    *cp = '/0';    *_salt = salt;    return EOK;}

/*  form a ctdb_rec_data record from a key/data pair  note that header may be NULL. If not NULL then it is included in the data portion  of the record */static struct ctdb_rec_data *db_ctdb_marshall_record(TALLOC_CTX *mem_ctx, uint32_t reqid,							  TDB_DATA key, 						  struct ctdb_ltdb_header *header,						  TDB_DATA data){	size_t length;	struct ctdb_rec_data *d;	length = offsetof(struct ctdb_rec_data, data) + key.dsize + 		data.dsize + (header?sizeof(*header):0);	d = (struct ctdb_rec_data *)talloc_size(mem_ctx, length);	if (d == NULL) {		return NULL;	}	d->length = length;	d->reqid = reqid;	d->keylen = key.dsize;	memcpy(&d->data[0], key.dptr, key.dsize);	if (header) {		d->datalen = data.dsize + sizeof(*header);		memcpy(&d->data[key.dsize], header, sizeof(*header));		memcpy(&d->data[key.dsize+sizeof(*header)], data.dptr, data.dsize);	} else {		d->datalen = data.dsize;		memcpy(&d->data[key.dsize], data.dptr, data.dsize);	}	return d;}

static enum NTDB_ERROR db_ntdb_fetchlock_parse(NTDB_DATA key, NTDB_DATA data,					       struct ntdb_fetch_locked_state *state){	struct db_record *result;	result = (struct db_record *)talloc_size(		state->mem_ctx,		sizeof(struct db_record) + key.dsize + data.dsize);	if (result == NULL) {		return NTDB_ERR_OOM;	}	state->result = result;	result->key.dsize = key.dsize;	result->key.dptr = ((uint8_t *)result) + sizeof(struct db_record);	memcpy(result->key.dptr, key.dptr, key.dsize);	result->value.dsize = data.dsize;	if (data.dsize > 0) {		result->value.dptr = result->key.dptr+key.dsize;		memcpy(result->value.dptr, data.dptr, data.dsize);	}	else {		result->value.dptr = NULL;	}	return NTDB_SUCCESS;}

static int db_tdb_fetchlock_parse(TDB_DATA key, TDB_DATA data,				  void *private_data){	struct tdb_fetch_locked_state *state =		(struct tdb_fetch_locked_state *)private_data;	struct db_record *result;	result = (struct db_record *)talloc_size(		state->mem_ctx,		sizeof(struct db_record) + key.dsize + data.dsize);	if (result == NULL) {		return 0;	}	state->result = result;	result->key.dsize = key.dsize;	result->key.dptr = ((uint8 *)result) + sizeof(struct db_record);	memcpy(result->key.dptr, key.dptr, key.dsize);	result->value.dsize = data.dsize;	if (data.dsize > 0) {		result->value.dptr = result->key.dptr+key.dsize;		memcpy(result->value.dptr, data.dptr, data.dsize);	}	else {		result->value.dptr = NULL;	}	return 0;}

static struct doc_section *new_section(struct list_head *list,				       const char *function,				       const char *type,				       unsigned int srcline){	struct doc_section *d;	char *lowertype;	unsigned int i;	/* If previous section was empty, delete it. */	d = list_tail(list, struct doc_section, list);	if (d && empty_section(d)) {		list_del(&d->list);		talloc_free(d);	}	d = talloc(list, struct doc_section);	d->function = function;	lowertype = talloc_size(d, strlen(type) + 1);	/* Canonicalize type to lower case. */	for (i = 0; i < strlen(type)+1; i++)		lowertype[i] = tolower(type[i]);	d->type = lowertype;	d->lines = NULL;	d->num_lines = 0;	d->srcline = srcline;	list_add_tail(list, &d->list);	return d;}

/*  use ndr_print_* to convert a NDR formatted blob to a ldif formatted blob  If mask_errors is true, then function succeeds but out data  is set to "<Unable to decode binary data>" message  /return 0 on success; -1 on error*/static int ldif_write_NDR(struct ldb_context *ldb, void *mem_ctx,			  const struct ldb_val *in, struct ldb_val *out,			  size_t struct_size,			  ndr_pull_flags_fn_t pull_fn,			  ndr_print_fn_t print_fn,			  bool mask_errors){	uint8_t *p;	enum ndr_err_code err;	if (!(ldb_get_flags(ldb) & LDB_FLG_SHOW_BINARY)) {		return ldb_handler_copy(ldb, mem_ctx, in, out);	}	p = talloc_size(mem_ctx, struct_size);	err = ndr_pull_struct_blob(in, mem_ctx, 				   p, pull_fn);	if (err != NDR_ERR_SUCCESS) {		/* fail in not in mask_error mode */		if (!mask_errors) {			return -1;		}		talloc_free(p);		out->data = (uint8_t *)talloc_strdup(mem_ctx, "<Unable to decode binary data>");		out->length = strlen((const char *)out->data);		return 0;	}	out->data = (uint8_t *)ndr_print_struct_string(mem_ctx, print_fn, "NDR", p);	talloc_free(p);	if (out->data == NULL) {		return ldb_handler_copy(ldb, mem_ctx, in, out);			}	out->length = strlen((char *)out->data);	return 0;}

void *_policy_handle_create(struct pipes_struct *p, struct policy_handle *hnd,			    uint32_t access_granted, size_t data_size,			    const char *type, NTSTATUS *pstatus){	struct dcesrv_handle *rpc_hnd;	void *data;	if (p->pipe_handles->count > MAX_OPEN_POLS) {		DEBUG(0, ("ERROR: Too many handles (%d) for RPC connection %s/n",			  (int) p->pipe_handles->count,			  get_pipe_name_from_syntax(talloc_tos(),						    &p->contexts->syntax)));		*pstatus = NT_STATUS_INSUFFICIENT_RESOURCES;		return NULL;	}	data = talloc_size(talloc_tos(), data_size);	if (data == NULL) {		*pstatus = NT_STATUS_NO_MEMORY;		return NULL;	}	talloc_set_name_const(data, type);	rpc_hnd = create_rpc_handle_internal(p, hnd, data);	if (rpc_hnd == NULL) {		TALLOC_FREE(data);		*pstatus = NT_STATUS_NO_MEMORY;		return NULL;	}	rpc_hnd->access_granted = access_granted;	*pstatus = NT_STATUS_OK;	return data;}

static AudioChannelLayout* ca_query_layout(struct ao *ao,                                           AudioDeviceID device,                                           void *talloc_ctx){    OSStatus err;    uint32_t psize;    AudioChannelLayout *r = NULL;    AudioObjectPropertyAddress p_addr = (AudioObjectPropertyAddress) {        .mSelector = kAudioDevicePropertyPreferredChannelLayout,        .mScope    = kAudioDevicePropertyScopeOutput,        .mElement  = kAudioObjectPropertyElementWildcard,    };    err = AudioObjectGetPropertyDataSize(device, &p_addr, 0, NULL, &psize);    CHECK_CA_ERROR("could not get device preferred layout (size)");    r = talloc_size(talloc_ctx, psize);    err = AudioObjectGetPropertyData(device, &p_addr, 0, NULL, &psize, r);    CHECK_CA_ERROR("could not get device preferred layout (get)");coreaudio_error:    return r;}

/*  measure the speed of talloc versus malloc*/static bool test_speed(void){	void *ctx = talloc_new(NULL);	unsigned count;	const int loop = 1000;	int i;	struct timeval tv;	printf("test: speed [/nTALLOC VS MALLOC SPEED/n]/n");	tv = timeval_current();	count = 0;	do {		void *p1, *p2, *p3;		for (i=0;i<loop;i++) {			p1 = talloc_size(ctx, loop % 100);			p2 = talloc_strdup(p1, "foo bar");			p3 = talloc_size(p1, 300);			talloc_free(p1);		}		count += 3 * loop;	} while (timeval_elapsed(&tv) < 5.0);	fprintf(stderr, "talloc: %.0f ops/sec/n", count/timeval_elapsed(&tv));	talloc_free(ctx);	tv = timeval_current();	count = 0;	do {		void *p1, *p2, *p3;		for (i=0;i<loop;i++) {			p1 = malloc(loop % 100);			p2 = strdup("foo bar");			p3 = malloc(300);			free(p1);			free(p2);			free(p3);		}		count += 3 * loop;	} while (timeval_elapsed(&tv) < 5.0);	fprintf(stderr, "malloc: %.0f ops/sec/n", count/timeval_elapsed(&tv));	printf("success: speed/n");	return true;}

static int get_pw_uid(TALLOC_CTX *mem_ctx,                      struct proxy_id_ctx *ctx,                      struct sysdb_ctx *sysdb,                      struct sss_domain_info *dom,                      uid_t uid){    TALLOC_CTX *tmpctx;    struct passwd *pwd;    enum nss_status status;    char *buffer;    size_t buflen;    bool del_user = false;    int ret;    DEBUG(SSSDBG_TRACE_FUNC, ("Searching user by uid (%d)/n", uid));    tmpctx = talloc_new(NULL);    if (!tmpctx) {        return ENOMEM;    }    pwd = talloc_zero(tmpctx, struct passwd);    if (!pwd) {        ret = ENOMEM;        goto done;    }    buflen = DEFAULT_BUFSIZE;    buffer = talloc_size(tmpctx, buflen);    if (!buffer) {        ret = ENOMEM;        goto done;    }    status = ctx->ops.getpwuid_r(uid, pwd, buffer, buflen, &ret);    ret = handle_getpw_result(status, pwd, dom, &del_user);    if (ret) {        DEBUG(SSSDBG_OP_FAILURE,              ("getpwuid failed [%d]: %s/n", ret, strerror(ret)));        goto done;    }    if (del_user) {        ret = delete_user(sysdb, dom, NULL, uid);        goto done;    }    ret = save_user(sysdb, dom, !dom->case_sensitive, pwd,                    pwd->pw_name, NULL, dom->user_timeout);done:    talloc_zfree(tmpctx);    if (ret) {        DEBUG(SSSDBG_CRIT_FAILURE,              ("proxy -> getpwuid_r failed for '%d' <%d>: %s/n",               uid, ret, strerror(ret)));    }    return ret;}

/*  transport packet allocator - allows transport to control memory for packets*/static void *ctdb_tcp_allocate_pkt(TALLOC_CTX *mem_ctx, size_t size){    /* tcp transport needs to round to 8 byte alignment to ensure       that we can use a length header and 64 bit elements in       structures */    size = (size+(CTDB_TCP_ALIGNMENT-1)) & ~(CTDB_TCP_ALIGNMENT-1);    return talloc_size(mem_ctx, size);}

static void initialise_output_state(TALLOC_CTX *mem_ctx, output_state *state, uint32_t rawSize, DATA_BLOB *output_blob){	state->out_pos = 0;	state->out_size = rawSize + LZFU_HEADERLENGTH + 4;	output_blob->data = (uint8_t *) talloc_size(mem_ctx, state->out_size);	output_blob->length = 0;	state->output_blob = output_blob;}

/* * This function is used to process data in queue buffer. * * Queue callback function can end up freeing the queue, there should not be a * loop processing packets from queue buffer.  Instead set up a timed event for * immediate run to process remaining packets from buffer. */static void queue_process(struct ctdb_queue *queue){	uint32_t pkt_size;	uint8_t *data;	if (queue->buffer.length < sizeof(pkt_size)) {		return;	}	pkt_size = *(uint32_t *)queue->buffer.data;	if (pkt_size == 0) {		DEBUG(DEBUG_CRIT, ("Invalid packet of length 0/n"));		goto failed;	}	if (queue->buffer.length < pkt_size) {		if (pkt_size > QUEUE_BUFFER_SIZE) {			queue->buffer.extend = pkt_size;		}		return;	}	/* Extract complete packet */	data = talloc_size(queue, pkt_size);	if (data == NULL) {		DEBUG(DEBUG_ERR, ("read error alloc failed for %u/n", pkt_size));		return;	}	memcpy(data, queue->buffer.data, pkt_size);	/* Shift packet out from buffer */	if (queue->buffer.length > pkt_size) {		memmove(queue->buffer.data,			queue->buffer.data + pkt_size,			queue->buffer.length - pkt_size);	}	queue->buffer.length -= pkt_size;	if (queue->buffer.length > 0) {		/* There is more data to be processed, schedule an event */		tevent_schedule_immediate(queue->im, queue->ctdb->ev,					  queue_process_event, queue);	} else {		if (queue->buffer.size > QUEUE_BUFFER_SIZE) {			TALLOC_FREE(queue->buffer.data);			queue->buffer.size = 0;		}	}	/* It is the responsibility of the callback to free 'data' */	queue->callback(data, pkt_size, queue->private_data);	return;failed:	queue->callback(NULL, 0, queue->private_data);}

/*  write a record to a normal database*/int ctdb_ltdb_store(struct ctdb_db_context *ctdb_db, TDB_DATA key, 		    struct ctdb_ltdb_header *header, TDB_DATA data){	struct ctdb_context *ctdb = ctdb_db->ctdb;	TDB_DATA rec;	int ret;	bool seqnum_suppressed = false;	if (ctdb_db->ctdb_ltdb_store_fn) {		return ctdb_db->ctdb_ltdb_store_fn(ctdb_db, key, header, data);	}	if (ctdb->flags & CTDB_FLAG_TORTURE) {		struct ctdb_ltdb_header *h2;		rec = tdb_fetch(ctdb_db->ltdb->tdb, key);		h2 = (struct ctdb_ltdb_header *)rec.dptr;		if (rec.dptr && rec.dsize >= sizeof(h2) && h2->rsn > header->rsn) {			DEBUG(DEBUG_CRIT,("RSN regression! %llu %llu/n",				 (unsigned long long)h2->rsn, (unsigned long long)header->rsn));		}		if (rec.dptr) free(rec.dptr);	}	rec.dsize = sizeof(*header) + data.dsize;	rec.dptr = talloc_size(ctdb, rec.dsize);	CTDB_NO_MEMORY(ctdb, rec.dptr);	memcpy(rec.dptr, header, sizeof(*header));	memcpy(rec.dptr + sizeof(*header), data.dptr, data.dsize);	/* Databases with seqnum updates enabled only get their seqnum	   changes when/if we modify the data */	if (ctdb_db->seqnum_update != NULL) {		TDB_DATA old;		old = tdb_fetch(ctdb_db->ltdb->tdb, key);		if ( (old.dsize == rec.dsize)		&& !memcmp(old.dptr+sizeof(struct ctdb_ltdb_header),			  rec.dptr+sizeof(struct ctdb_ltdb_header),			  rec.dsize-sizeof(struct ctdb_ltdb_header)) ) {			tdb_remove_flags(ctdb_db->ltdb->tdb, TDB_SEQNUM);			seqnum_suppressed = true;		}		if (old.dptr) free(old.dptr);	}	ret = tdb_store(ctdb_db->ltdb->tdb, key, rec, TDB_REPLACE);	if (ret != 0) {		DEBUG(DEBUG_ERR, (__location__ " Failed to store dynamic data/n"));	}	if (seqnum_suppressed) {		tdb_add_flags(ctdb_db->ltdb->tdb, TDB_SEQNUM);	}	talloc_free(rec.dptr);	return ret;}

/*  test the EchoData interface*/static bool test_echodata(struct torture_context *tctx,						  struct dcerpc_pipe *p){	int i;	NTSTATUS status;	uint8_t *data_in, *data_out;	int len;	struct echo_EchoData r;	if (torture_setting_bool(tctx, "quick", false) &&	    (p->conn->flags & DCERPC_DEBUG_VALIDATE_BOTH)) {		len = 1 + (random() % 500);	} else {		len = 1 + (random() % 5000);	}	data_in = talloc_size(tctx, len);	data_out = talloc_size(tctx, len);	for (i=0;i<len;i++) {		data_in[i] = i;	}		r.in.len = len;	r.in.in_data = data_in;	status = dcerpc_echo_EchoData(p, tctx, &r);	torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, 											"EchoData(%d) failed/n", len));	data_out = r.out.out_data;	for (i=0;i<len;i++) {		if (data_in[i] != data_out[i]) {			torture_comment(tctx, "Bad data returned for len %d at offset %d/n", 			       len, i);			torture_comment(tctx, "in:/n");			dump_data(0, data_in+i, MIN(len-i, 16));			torture_comment(tctx, "out:/n");			dump_data(0, data_out+i, MIN(len-1, 16));			return false;		}	}	return true;}