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

struct lavc_conv *lavc_conv_create(struct mp_log *log, const char *codec_name,                                   char *extradata, int extradata_len){    struct lavc_conv *priv = talloc_zero(NULL, struct lavc_conv);    priv->log = log;    priv->cur_list = talloc_array(priv, char*, 0);    priv->codec = talloc_strdup(priv, codec_name);    AVCodecContext *avctx = NULL;    const char *fmt = get_lavc_format(priv->codec);    AVCodec *codec = avcodec_find_decoder(mp_codec_to_av_codec_id(fmt));    if (!codec)        goto error;    avctx = avcodec_alloc_context3(codec);    if (!avctx)        goto error;    avctx->extradata_size = extradata_len;    avctx->extradata = talloc_memdup(priv, extradata, extradata_len);    if (avcodec_open2(avctx, codec, NULL) < 0)        goto error;    // Documented as "set by libavcodec", but there is no other way    avctx->time_base = (AVRational) {1, 1000};    priv->avctx = avctx;    priv->extradata = talloc_strndup(priv, avctx->subtitle_header,                                     avctx->subtitle_header_size);    disable_styles(bstr0(priv->extradata));    return priv; error:    MP_FATAL(priv, "Could not open libavcodec subtitle converter/n");    av_free(avctx);    talloc_free(priv);    return NULL;}

/** Open a key by name (including the predefined key name!) */WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,			const char *name, struct registry_key **result){	struct registry_key *predef;	WERROR error;	int predeflength;	char *predefname;	if (strchr(name, '//') != NULL)		predeflength = strchr(name, '//')-name;	else		predeflength = strlen(name);	predefname = talloc_strndup(mem_ctx, name, predeflength);	error = reg_get_predefined_key_by_name(handle, predefname, &predef);	talloc_free(predefname);	if (!W_ERROR_IS_OK(error)) {		return error;	}	if (strchr(name, '//')) {		return reg_open_key(mem_ctx, predef, strchr(name, '//')+1,				    result);	} else {		*result = predef;		return WERR_OK;	}}

/** * XXX: This is temporary and there should be no callers of this once * smb_filename is plumbed through all path based operations. */struct smb_filename *synthetic_smb_fname_split(TALLOC_CTX *ctx,					       const char *fname,					       const SMB_STRUCT_STAT *psbuf){	const char *stream_name = NULL;	char *base_name = NULL;	struct smb_filename *ret;	if (!lp_posix_pathnames()) {		stream_name = strchr_m(fname, ':');	}	/* Setup the base_name/stream_name. */	if (stream_name) {		base_name = talloc_strndup(ctx, fname,					   PTR_DIFF(stream_name, fname));	} else {		base_name = talloc_strdup(ctx, fname);	}	if (!base_name) {		return NULL;	}	ret = synthetic_smb_fname(ctx, base_name, stream_name, psbuf);	TALLOC_FREE(base_name);	return ret;}

double ldb_msg_find_attr_as_double(const struct ldb_message *msg,				   const char *attr_name,				   double default_value){	const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);	char *buf;	char *end = NULL;	double ret;	if (!v || !v->data) {		return default_value;	}	buf = talloc_strndup(msg, (const char *)v->data, v->length);	if (buf == NULL) {		return default_value;	}	errno = 0;	ret = strtod(buf, &end);	talloc_free(buf);	if (errno != 0) {		return default_value;	}	if (end && end[0] != '/0') {		return default_value;	}	return ret;}

static char *get_netbios_name(TALLOC_CTX *mem_ctx, HostAddresses *addrs){	char *nb_name = NULL;	size_t len;	unsigned int i;	for (i = 0; addrs && i < addrs->len; i++) {		if (addrs->val[i].addr_type != KRB5_ADDRESS_NETBIOS) {			continue;		}		len = MIN(addrs->val[i].address.length, 15);		nb_name = talloc_strndup(mem_ctx,					 addrs->val[i].address.data, len);		if (nb_name) {			break;		}	}	if ((nb_name == NULL) || (nb_name[0] == '/0')) {		return NULL;	}	/* Strip space padding */	for (len = strlen(nb_name) - 1;	     (len > 0) && (nb_name[len] == ' ');	     --len) {		nb_name[len] = '/0';	}	return nb_name;}

void mp_tags_set_bstr(struct mp_tags *tags, bstr key, bstr value){    for (int n = 0; n < tags->num_keys; n++) {        if (bstrcasecmp0(key, tags->keys[n]) == 0) {            talloc_free(tags->values[n]);            tags->values[n] = talloc_strndup(tags, value.start, value.len);            return;        }    }    MP_RESIZE_ARRAY(tags, tags->keys,   tags->num_keys + 1);    MP_RESIZE_ARRAY(tags, tags->values, tags->num_keys + 1);    tags->keys[tags->num_keys]   = talloc_strndup(tags, key.start,   key.len);    tags->values[tags->num_keys] = talloc_strndup(tags, value.start, value.len);    tags->num_keys++;}

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

/*  called when a CTDB_REPLY_CONTROL packet comes in*/void ctdb_reply_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr){	struct ctdb_reply_control_old *c = (struct ctdb_reply_control_old *)hdr;	TDB_DATA data;	struct ctdb_control_state *state;	const char *errormsg = NULL;	state = reqid_find(ctdb->idr, hdr->reqid, struct ctdb_control_state);	if (state == NULL) {		DEBUG(DEBUG_ERR,("pnn %u Invalid reqid %u in ctdb_reply_control/n",			 ctdb->pnn, hdr->reqid));		return;	}	if (hdr->reqid != state->reqid) {		/* we found a record  but it was the wrong one */		DEBUG(DEBUG_ERR, ("Dropped orphaned control reply with reqid:%u/n", hdr->reqid));		return;	}	data.dptr = &c->data[0];	data.dsize = c->datalen;	if (c->errorlen) {		errormsg = talloc_strndup(state, 					  (char *)&c->data[c->datalen], c->errorlen);	}	/* make state a child of the packet, so it goes away when the packet	   is freed. */	talloc_steal(hdr, state);	state->callback(ctdb, c->status, data, errormsg, state->private_data);}

/*  given a filename, find the parent directory */static char *parent_dir(TALLOC_CTX *mem_ctx, const char *name){	const char *p = strrchr(name, '/');	if (p == NULL) {		return talloc_strdup(mem_ctx, ".");	}	return talloc_strndup(mem_ctx, name, (p+1) - name);}

char *talloc_dirname(const void *ctx, const char *dir){	char *p = strrchr(dir, '/');	if (!p)		return talloc_strdup(ctx, ".");	return talloc_strndup(ctx, dir, p - dir);}

static bool test_rpc_netservergetinfo(struct torture_context *tctx,				      struct smbcli_state *cli){	struct rap_WserverGetInfo r;	struct dcerpc_pipe *p;	struct dcerpc_binding_handle *b;	struct srvsvc_NetSrvGetInfo s;	union srvsvc_NetSrvInfo info;	const char *server_name;	torture_assert_ntstatus_ok(tctx,		torture_rpc_connection(tctx, &p, &ndr_table_srvsvc),		"failed to open srvsvc");	b = p->binding_handle;	s.in.server_unc = NULL;	s.in.level = 101;	s.out.info = &info;	torture_assert_ntstatus_ok(tctx,		dcerpc_srvsvc_NetSrvGetInfo_r(b, tctx, &s),		"srvsvc_NetSrvGetInfo level 101 failed");	torture_assert_werr_ok(tctx, s.out.result,		"srvsvc_NetSrvGetInfo level 101 failed");	r.in.bufsize = 0xffff;	r.in.level = 0;	torture_assert_ntstatus_ok(tctx,		smbcli_rap_netservergetinfo(cli->tree, tctx, &r),		"rap_netservergetinfo level 0 failed");	torture_assert_int_equal(tctx, r.out.status, 0,		"rap_netservergetinfo level 0 failed");	server_name = talloc_strndup(tctx, info.info101->server_name, 16);	torture_assert_str_equal(tctx, (const char *)r.out.info.info0.name, server_name, "server name");	r.in.level = 1;	torture_assert_ntstatus_ok(tctx,		smbcli_rap_netservergetinfo(cli->tree, tctx, &r),		"rap_netservergetinfo level 1 failed");	torture_assert_int_equal(tctx, r.out.status, 0,		"rap_netservergetinfo level 1 failed");	torture_assert_str_equal(tctx, (const char *)r.out.info.info1.name, server_name, "server name");	torture_assert_int_equal(tctx, r.out.info.info1.version_major, info.info101->version_major, "version major");	torture_assert_int_equal(tctx, r.out.info.info1.version_minor, info.info101->version_minor, "version minor");	torture_assert_int_equal(tctx, r.out.info.info1.servertype, info.info101->server_type, "server_type");	torture_assert_str_equal(tctx, r.out.info.info1.comment, info.info101->comment, "comment");	talloc_free(p);	return true;}

char *_notmuch_message_id_parse (void *ctx, const char *message_id, const char **next){    const char *s, *end;    char *result;    if (message_id == NULL || *message_id == '/0')	return NULL;    s = message_id;    skip_space_and_comments (&s);    /* Skip any unstructured text as well. */    while (*s && *s != '<')	s++;    if (*s == '<') {	s++;    } else {	if (next)	    *next = s;	return NULL;    }    skip_space_and_comments (&s);    end = s;    while (*end && *end != '>')	end++;    if (next) {	if (*end)	    *next = end + 1;	else	    *next = end;    }    if (end > s && *end == '>')	end--;    if (end <= s)	return NULL;    result = talloc_strndup (ctx, s, end - s + 1);    /* Finally, collapse any whitespace that is within the message-id     * itself. */    {	char *r;	int len;	for (r = result, len = strlen (r); *r; r++, len--)	    if (*r == ' ' || *r == '/t')		memmove (r, r+1, len);    }    return result;}

errno_t sysdb_get_rdn(struct sysdb_ctx *sysdb, TALLOC_CTX *mem_ctx,                      const char *dn, char **_name, char **_val){    errno_t ret;    struct ldb_dn *ldb_dn;    const char *attr_name = NULL;    const struct ldb_val *val;    TALLOC_CTX *tmp_ctx;    /* We have to create a tmp_ctx here because     * ldb_dn_new_fmt() fails if mem_ctx is NULL     */    tmp_ctx = talloc_new(NULL);    if (!tmp_ctx) {        return ENOMEM;    }    ldb_dn = ldb_dn_new_fmt(tmp_ctx, sysdb->ldb, "%s", dn);    if (ldb_dn == NULL) {        ret = ENOMEM;        goto done;    }    if (_name) {        attr_name = ldb_dn_get_rdn_name(ldb_dn);        if (attr_name == NULL) {            ret = EINVAL;            goto done;        }        *_name = talloc_strdup(mem_ctx, attr_name);        if (!*_name) {            ret = ENOMEM;            goto done;        }    }    val = ldb_dn_get_rdn_val(ldb_dn);    if (val == NULL) {        ret = EINVAL;        if (_name) talloc_free(*_name);        goto done;    }    *_val = talloc_strndup(mem_ctx, (char *) val->data, val->length);    if (!*_val) {        ret = ENOMEM;        if (_name) talloc_free(*_name);        goto done;    }    ret = EOK;done:    talloc_zfree(tmp_ctx);    return ret;}

int demuxer_add_attachment(demuxer_t *demuxer, struct bstr name,                           struct bstr type, struct bstr data){    if (!(demuxer->num_attachments % 32))        demuxer->attachments = talloc_realloc(demuxer, demuxer->attachments,                                              struct demux_attachment,                                              demuxer->num_attachments + 32);    struct demux_attachment *att =        demuxer->attachments + demuxer->num_attachments;    att->name = talloc_strndup(demuxer->attachments, name.start, name.len);    att->type = talloc_strndup(demuxer->attachments, type.start, type.len);    att->data = talloc_size(demuxer->attachments, data.len);    memcpy(att->data, data.start, data.len);    att->data_size = data.len;    return demuxer->num_attachments++;}

static int ldif_canonicalise_objectCategory(struct ldb_context *ldb, void *mem_ctx,					    const struct ldb_val *in, struct ldb_val *out){	struct ldb_dn *dn1 = NULL;	const struct dsdb_schema *schema = dsdb_get_schema(ldb, NULL);	const struct dsdb_class *sclass;	TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);	if (!tmp_ctx) {		return LDB_ERR_OPERATIONS_ERROR;	}	if (!schema) {		talloc_free(tmp_ctx);		*out = data_blob_talloc(mem_ctx, in->data, in->length);		if (in->data && !out->data) {			return LDB_ERR_OPERATIONS_ERROR;		}		return LDB_SUCCESS;	}	dn1 = ldb_dn_from_ldb_val(tmp_ctx, ldb, in);	if ( ! ldb_dn_validate(dn1)) {		const char *lDAPDisplayName = talloc_strndup(tmp_ctx, (char *)in->data, in->length);		sclass = dsdb_class_by_lDAPDisplayName(schema, lDAPDisplayName);		if (sclass) {			struct ldb_dn *dn = ldb_dn_new(tmp_ctx, ldb,						       sclass->defaultObjectCategory);			if (dn == NULL) {				talloc_free(tmp_ctx);				return LDB_ERR_OPERATIONS_ERROR;			}			*out = data_blob_string_const(ldb_dn_alloc_casefold(mem_ctx, dn));			talloc_free(tmp_ctx);			if (!out->data) {				return LDB_ERR_OPERATIONS_ERROR;			}			return LDB_SUCCESS;		} else {			*out = data_blob_talloc(mem_ctx, in->data, in->length);			talloc_free(tmp_ctx);			if (in->data && !out->data) {				return LDB_ERR_OPERATIONS_ERROR;			}			return LDB_SUCCESS;		}	}	*out = data_blob_string_const(ldb_dn_alloc_casefold(mem_ctx, dn1));	talloc_free(tmp_ctx);	if (!out->data) {		return LDB_ERR_OPERATIONS_ERROR;	}	return LDB_SUCCESS;}

void tid_srvr_get_address(const TID_SRVR_BLK *blk,			  const struct sockaddr **out_addr,			  size_t *out_len){    char *colon = NULL;    assert(blk);    char *hostname = NULL, *port = NULL;    int s, len;    struct addrinfo *result;    // make sure we don't return garbage    *out_len = 0;    *out_addr = NULL;    /* get a copy of the address */    hostname = talloc_strdup(blk, blk->aaa_server_addr);    /* address might contain AAA port number. If so, process it */    colon = strrchr(hostname, ':');    /* If there are more than one colon, and the last one is not preceeded by ],       this is not a port separator, but an IPv6 address (likely) */    if (strchr(hostname, ':') != colon && *(colon - 1) != ']')      colon = NULL;    /* we get two strings, the hostname without the colon, and the port number */    if (colon != NULL) {      *colon = '/0';      port = talloc_strdup(blk, colon + 1);    }    /* IPv6 addresses might be surrounded by square brackets */    len = strlen(hostname);    if (hostname[0] == '[' && hostname[len - 1] == ']') {        char *copy = talloc_strndup(NULL, hostname + 1, len - 2);        talloc_free(hostname);        hostname = copy;    }    s = getaddrinfo(hostname,             // address                    port ? port : "2083", // port as a string                    NULL,                 // hints                    &result);    if (s != 0 || result == NULL) {      tr_crit("tid_srvr_get_address: Could not resolve an address from %s", hostname);      return;    }    *out_addr = result->ai_addr;    *out_len = result->ai_addrlen;    result->ai_addr = NULL; // to avoid deleting it    freeaddrinfo(result);    talloc_free(hostname);    talloc_free(port);}

static void do_pam_chauthtok(struct LOCAL_request *lreq){    int ret;    char *newauthtok;    char *salt;    char *new_hash;    struct pam_data *pd;    pd = lreq->preq->pd;    newauthtok = talloc_strndup(lreq, (char *) pd->newauthtok,                                pd->newauthtok_size);    NULL_CHECK_OR_JUMP(newauthtok, ("talloc_strndup failed./n"), lreq->error,                       ENOMEM, done);    memset(pd->newauthtok, 0, pd->newauthtok_size);    if (strlen(newauthtok) == 0) {        /* TODO: should we allow null passwords via a config option ? */        DEBUG(1, ("Empty passwords are not allowed!/n"));        lreq->error = EINVAL;        goto done;    }    ret = s3crypt_gen_salt(lreq, &salt);    NEQ_CHECK_OR_JUMP(ret, EOK, ("Salt generation failed./n"),                      lreq->error, ret, done);    DEBUG(4, ("Using salt [%s]/n", salt));    ret = s3crypt_sha512(lreq, newauthtok, salt, &new_hash);    NEQ_CHECK_OR_JUMP(ret, EOK, ("Hash generation failed./n"),                      lreq->error, ret, done);    DEBUG(4, ("New hash [%s]/n", new_hash));    memset(newauthtok, 0, pd->newauthtok_size);    lreq->mod_attrs = sysdb_new_attrs(lreq);    NULL_CHECK_OR_JUMP(lreq->mod_attrs, ("sysdb_new_attrs failed./n"),                       lreq->error, ENOMEM, done);    ret = sysdb_attrs_add_string(lreq->mod_attrs, SYSDB_PWD, new_hash);    NEQ_CHECK_OR_JUMP(ret, EOK, ("sysdb_attrs_add_string failed./n"),                      lreq->error, ret, done);    ret = sysdb_attrs_add_long(lreq->mod_attrs,                               "lastPasswordChange", (long)time(NULL));    NEQ_CHECK_OR_JUMP(ret, EOK, ("sysdb_attrs_add_long failed./n"),                      lreq->error, ret, done);    ret = sysdb_set_user_attr(lreq->dbctx, lreq->preq->pd->user,                              lreq->mod_attrs, SYSDB_MOD_REP);    NEQ_CHECK_OR_JUMP(ret, EOK, ("sysdb_set_user_attr failed./n"),                      lreq->error, ret, done);done:    return;}

/* Accepts fqname in the format [email
C++ talloc_tos函数代码示例
C++ talloc_strdup函数代码示例