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

void test_str_append_c(void) {    str dst;    str_create_from_cstr(&dst, "base_string");    str_append_c(&dst, "appended_string");    CU_ASSERT(str_size(&dst) == 26);    CU_ASSERT_PTR_NOT_NULL(dst.data);    CU_ASSERT_NSTRING_EQUAL(dst.data, "base_string", 11);    CU_ASSERT_NSTRING_EQUAL(dst.data+11, "appended_string", 15);    CU_ASSERT(dst.data[dst.len] == 0);    str_free(&dst);}

static void xml_encode_id(struct solr_fts_backend_update_context *ctx,                          string_t *str, uint32_t uid){    struct solr_fts_backend *backend =        (struct solr_fts_backend *)ctx->ctx.backend;    if (uid != 0)        str_printfa(str, "%u/", uid);    else        str_append(str, "L/");    if (backend->id_namespace != NULL) {        xml_encode(str, backend->id_namespace);        str_append_c(str, '/');    }    str_printfa(str, "%u/", ctx->uid_validity);    xml_encode(str, backend->id_username);    str_append_c(str, '/');    xml_encode(str, ctx->id_box_name);}

void stats_connection_disconnect(struct stats_connection *conn,				 struct mail_user *user){	struct stats_user *suser = STATS_USER_CONTEXT(user);	string_t *str = t_str_new(128);	str_append(str, "DISCONNECT/t");	str_append(str, guid_128_to_string(suser->session_guid));	str_append_c(str, '/n');	stats_connection_send(conn, str);}

static void status_flags_append(string_t *str, enum mail_flags flags,				const struct mbox_flag_type *flags_list){	int i;	flags ^= MBOX_NONRECENT_KLUDGE;	for (i = 0; flags_list[i].chr != 0; i++) {		if ((flags & flags_list[i].flag) != 0)			str_append_c(str, flags_list[i].chr);	}}

void mail_search_args_to_cmdline(string_t *dest,				 const struct mail_search_arg *args){	const struct mail_search_arg *arg;	for (arg = args; arg != NULL; arg = arg->next) {		mail_search_arg_to_cmdline(dest, arg);		if (arg->next != NULL)			str_append_c(dest, ' ');	}}

bool cmd_namespace(struct client_command_context *cmd){	struct client *client = cmd->client;	string_t *str;	str = t_str_new(256);	str_append(str, "* NAMESPACE ");	list_namespaces(client->user->namespaces,			MAIL_NAMESPACE_TYPE_PRIVATE, str);	str_append_c(str, ' ');	list_namespaces(client->user->namespaces,			MAIL_NAMESPACE_TYPE_SHARED, str);	str_append_c(str, ' ');	list_namespaces(client->user->namespaces,			MAIL_NAMESPACE_TYPE_PUBLIC, str);	client_send_line(client, str_c(str));	client_send_tagline(cmd, "OK Namespace completed.");	return TRUE;}

void client_authenticate_get_capabilities(struct client *client, string_t *str){	const struct auth_mech_desc *mech;	unsigned int i, count;	mech = sasl_server_get_advertised_mechs(client, &count);	for (i = 0; i < count; i++) {		str_append_c(str, ' ');		str_append(str, "AUTH=");		str_append(str, mech[i].name);	}}

static void lmtp_append_xtext(string_t *dest, const char *str){	unsigned int i;	for (i = 0; str[i] != '/0'; i++) {		if (str[i] >= 33 && str[i] <= 126 &&		    str[i] != '+' && str[i] != '=')			str_append_c(dest, str[i]);		else			str_printfa(dest, "+%02X", str[i]);	}}

static void script_execute_finish(void){	const char *keys_str, *username, *const *keys, *value;	string_t *reply = t_str_new(512);	ssize_t ret;	keys_str = getenv(ENV_USERDB_KEYS);	if (keys_str == NULL)		i_fatal(ENV_USERDB_KEYS" environment missing");	username = getenv("USER");	if (username == NULL)		i_fatal("USER environment missing");	str_append(reply, username);	for (keys = t_strsplit_spaces(keys_str, " "); *keys != NULL; keys++) {		value = getenv(t_str_ucase(*keys));		if (value != NULL) {			str_append_c(reply, '/t');			str_append_tabescaped(reply,					    t_strconcat(t_str_lcase(*keys), "=",							value, NULL));		}	}	str_append_c(reply, '/n');	/* finish by sending the fd to the mail process */	ret = fd_send(SCRIPT_COMM_FD, STDOUT_FILENO,		      str_data(reply), str_len(reply));	if (ret == (ssize_t)str_len(reply)) {		/* success */	} else {		if (ret < 0)			i_error("fd_send() failed: %m");		else			i_error("fd_send() sent partial output");		/* exit with 0 even though we failed. non-0 exit just makes		   master log an unnecessary error. */	}}

static void list_namespaces(struct mail_namespace *ns,			    enum mail_namespace_type type, string_t *str){	string_t *mutf7_prefix = t_str_new(64);	char ns_sep;	bool found = FALSE;	while (ns != NULL) {		if (ns->type == type &&		    (ns->flags & NAMESPACE_FLAG_HIDDEN) == 0) {			if (!found) {				str_append_c(str, '(');				found = TRUE;			}			ns_sep = mail_namespace_get_sep(ns);			str_append_c(str, '(');			str_truncate(mutf7_prefix, 0);			if (imap_utf8_to_utf7(ns->prefix, mutf7_prefix) < 0) {				i_panic("LIST: Namespace prefix not UTF-8: %s",					ns->prefix);			}			imap_append_string(str, str_c(mutf7_prefix));			str_append(str, " /"");			if (ns_sep == '//')				str_append_c(str, '//');			str_append_c(str, ns_sep);			str_append(str, "/")");		}		ns = ns->next;	}	if (found)		str_append_c(str, ')');	else		str_append(str, "NIL");}

static int filter_connect(struct mail_filter_istream *mstream,			  const char *socket_path, const char *args){	const char **argv;	string_t *str;	int fd;	argv = t_strsplit(args, " ");	if ((fd = net_connect_unix_with_retries(socket_path, 1000)) < 0) {		if (errno == EACCES) {			i_error("ext-filter: %s",				eacces_error_get("net_connect_unix",						 socket_path));		} else {			i_error("ext-filter: net_connect_unix(%s) failed: %m",				socket_path);		}		return -1;	}	if (mstream->istream.istream.blocking)		net_set_nonblock(fd, FALSE);	mstream->fd = fd;	mstream->ext_in =		i_stream_create_fd(fd, mstream->istream.max_buffer_size, FALSE);	mstream->ext_out = o_stream_create_fd(fd, 0, FALSE);	str = t_str_new(256);	str_append(str, "VERSION/tscript/t3/t0/nnoreply/n");	for (; *argv != NULL; argv++) {		str_append(str, *argv);		str_append_c(str, '/n');	}	str_append_c(str, '/n');	o_stream_send(mstream->ext_out, str_data(str), str_len(str));	return 0;}

static void proxy_write_id(struct imap_client *client, string_t *str){	i_assert(client->common.proxy_ttl > 1);	str_append(str, "I ID (");	if (client->common.client_id != NULL &&	    str_len(client->common.client_id) > 0) {		str_append_str(str, client->common.client_id);		str_append_c(str, ' ');	}	str_printfa(str, "/"x-session-id/" /"%s/" "		    "/"x-originating-ip/" /"%s/" "		    "/"x-originating-port/" /"%u/" "		    "/"x-connected-ip/" /"%s/" "		    "/"x-connected-port/" /"%u/" "		    "/"x-proxy-ttl/" /"%u/"",		    client_get_session_id(&client->common),		    net_ip2addr(&client->common.ip),		    client->common.remote_port,		    net_ip2addr(&client->common.local_ip),		    client->common.local_port,		    client->common.proxy_ttl - 1);	/* append any forward_ variables to request */	for(const char *const *ptr = client->common.auth_passdb_args; *ptr != NULL; ptr++) {		if (strncasecmp(*ptr, "forward_", 8) == 0) {			const char *key = t_strconcat("x-forward-",						      t_strcut((*ptr)+8, '='),						      NULL);			const char *val = i_strchr_to_next(*ptr, '=');			str_append_c(str, ' ');			imap_append_string(str, key);			str_append_c(str, ' ');			imap_append_nstring(str, val);		}	}	str_append(str, ")/r/n");}

static intjson_parse_digits(struct json_parser *parser){	if (parser->data == parser->end)		return 0;	if (*parser->data < '0' || *parser->data > '9')		return -1;	while (parser->data != parser->end &&	       *parser->data >= '0' && *parser->data <= '9')		str_append_c(parser->value, *parser->data++);	return 1;}

bool mail_search_args_to_imap(string_t *dest, const struct mail_search_arg *args,			      const char **error_r){	const struct mail_search_arg *arg;	for (arg = args; arg != NULL; arg = arg->next) {		if (!mail_search_arg_to_imap(dest, arg, error_r))			return FALSE;		if (arg->next != NULL)			str_append_c(dest, ' ');	}	return TRUE;}

void str_append_tabunescaped(string_t *dest, const void *src, size_t src_size){	const unsigned char *src_c = src;	size_t start = 0, i = 0;	while (i < src_size) {		for (; i < src_size; i++) {			if (src_c[i] == '/001')				break;		}		str_append_n(dest, src_c + start, i-start);		if (i < src_size) {			i++;			if (i < src_size) {				switch (src_c[i]) {				case '1':					str_append_c(dest, '/001');					break;				case 't':					str_append_c(dest, '/t');					break;				case 'r':					str_append_c(dest, '/r');					break;				case 'n':					str_append_c(dest, '/n');					break;				default:					str_append_c(dest, src_c[i]);					break;				}				i++;			}		}		start = i;	}}

static void cmd_acl_get_right(const struct acl_rights *rights){	string_t *str;	doveadm_print(acl_rights_get_id(rights));	if (rights->global)		doveadm_print("global");	else		doveadm_print("");	str = t_str_new(256);	if (rights->rights != NULL)		str_append(str, t_strarray_join(rights->rights, " "));	if (rights->neg_rights != NULL) {		if (str_len(str) > 0)			str_append_c(str, ' ');		str_append_c(str, '-');		str_append(str, t_strarray_join(rights->neg_rights, " -"));	}	doveadm_print(str_c(str));}

void imap_refresh_proctitle(void){#define IMAP_PROCTITLE_PREFERRED_LEN 80	struct client *client;	struct client_command_context *cmd;	string_t *title = t_str_new(128);	if (!verbose_proctitle)		return;	str_append_c(title, '[');	switch (imap_client_count) {	case 0:		str_append(title, "idling");		break;	case 1:		client = imap_clients;		str_append(title, client->user->username);		if (client->user->remote_ip != NULL) {			str_append_c(title, ' ');			str_append(title, net_ip2addr(client->user->remote_ip));		}		for (cmd = client->command_queue; cmd != NULL; cmd = cmd->next) {			if (cmd->name == NULL)				continue;			if (str_len(title) > IMAP_PROCTITLE_PREFERRED_LEN)				break;			str_append_c(title, ' ');			str_append(title, cmd->name);		}		break;	default:		str_printfa(title, "%u connections", imap_client_count);		break;	}	str_append_c(title, ']');	process_title_set(str_c(title));}

void str_sanitize_append(string_t *dest, const char *src, size_t max_bytes){    unsigned int len, initial_pos = str_len(dest);    unichar_t chr;    size_t i;    int ret;    for (i = 0; src[i] != '/0'; ) {        len = uni_utf8_char_bytes(src[i]);        if (i + len > max_bytes)            break;        ret = uni_utf8_get_char(src+i, &chr);        if (ret <= 0) {            /* invalid UTF-8 */            str_append_c(dest, '?');            if (ret == 0) {                /* input ended too early */                return;            }            i++;            continue;        }        if ((unsigned char)src[i] < 32)            str_append_c(dest, '?');        else            str_append_n(dest, src+i, len);        i += len;    }    if (src[i] != '/0') {        if (max_bytes < 3)            str_truncate(dest, initial_pos);        else {            while (str_len(dest) - initial_pos > max_bytes-3)                str_sanitize_truncate_char(dest, initial_pos);        }        str_append(dest, "...");    }}

bool uri_data_decode(struct uri_parser *parser, const char *data,		     const char *until, const char **decoded_r){	const unsigned char *p = (const unsigned char *)data;	const unsigned char *pend = (const unsigned char *)until;	string_t *decoded;	if (pend == NULL) {		/* NULL means unlimited; solely rely on '/0' */		pend = (const unsigned char *)(size_t)-1;	}		if (p >= pend || *p == '/0') {		if (decoded_r != NULL)			*decoded_r = "";		return TRUE;	}		decoded = uri_parser_get_tmpbuf(parser, 256);	while (p < pend && *p != '/0') {		unsigned char ch;		if (*p == '%') {			p++;			if (uri_parse_pct_encoded(parser, &p, NULL, &ch) <= 0)				return FALSE;			str_append_c(decoded, ch);		} else {			str_append_c(decoded, *p);			p++;		}	}	if (decoded_r != NULL)		*decoded_r = t_strdup(str_c(decoded));	return TRUE;}

static voidlookup_credentials_callback(enum passdb_result result,			    const unsigned char *credentials, size_t size,			    struct auth_request *request){	struct auth_worker_client *client = request->context;	string_t *str;	if (request->failed && result == PASSDB_RESULT_OK)		result = PASSDB_RESULT_PASSWORD_MISMATCH;	str = t_str_new(128);	str_printfa(str, "%u/t", request->id);	if (result != PASSDB_RESULT_OK && result != PASSDB_RESULT_NEXT)		str_printfa(str, "FAIL/t%d", result);	else {		if (result == PASSDB_RESULT_NEXT)			str_append(str, "NEXT/t");		else			str_append(str, "OK/t");		str_append_tabescaped(str, request->user);		str_append_c(str, '/t');		if (request->credentials_scheme[0] != '/0') {			str_printfa(str, "{%s.b64}", request->credentials_scheme);			base64_encode(credentials, size, str);		} else {			i_assert(size == 0);		}		reply_append_extra_fields(str, request);	}	str_append_c(str, '/n');	auth_worker_send_reply(client, request, str);	auth_request_unref(&request);	auth_worker_client_check_throttle(client);	auth_worker_client_unref(&client);}

voidstr_vprintf (str_t d, const char *fmt, int append, va_list ap){#define STR_BUFSIZE 64  char buffer[STR_BUFSIZE];  char *xbuf;  int xbuf_size;  int ns;  va_list aq;  va_copy (aq, ap);  ns = vsnprintf (buffer, STR_BUFSIZE, fmt, ap);  if (ns >= STR_BUFSIZE)    {      xbuf_size = ns+1;      xbuf = malloc (xbuf_size);      vsnprintf (xbuf, xbuf_size, fmt, aq);    }  else    {      xbuf = buffer;      xbuf_size = 0;    }  va_end (aq);  if (append)    {      str_append_c (d, xbuf, 0);      if (xbuf_size > 0)	free (xbuf);    }  else    {      if (xbuf_size > 0)	{	  free (d->heap);	  d->heap = xbuf;	  d->size = xbuf_size;	  d->length = ns;	}      else	{	  str_copy_c_substr (d, xbuf, ns);	}    }#undef STR_BUFSIZE}

static const char *subsfile_list_unescaped(struct subsfile_list_context *ctx, const char *line){	const char *p;	str_truncate(ctx->name, 0);	while ((p = strchr(line, '/t')) != NULL) {		str_append_tabunescaped(ctx->name, line, p-line);		str_append_c(ctx->name, mailbox_list_get_hierarchy_sep(ctx->list));		line = p+1;	}	str_append_tabunescaped(ctx->name, line, strlen(line));	return str_c(ctx->name);}

void test_istream_tee(void){	string_t *str;	unsigned int i;	str = str_new(default_pool, TEST_STR_LEN);	for (i = 0; i < TEST_STR_LEN; i++)		str_append_c(str, 'a' + i%26);	test_istream_tee_tailing(str_c(str));	test_istream_tee_blocks(str_c(str));	str_free(&str);}

static void test_binary_to_hex(void){	static unsigned char input[] = { 0xff, 0x00, 0x01, 0xb3 };	static char *output_lcase = "ff0001b3";	static char *output_ucase = "FF0001B3";	string_t *str;	test_begin("binary to hex");	test_assert(strcmp(binary_to_hex(input, sizeof(input)), output_lcase) == 0);	test_end();	test_begin("binary to hex ucase");	test_assert(strcmp(binary_to_hex_ucase(input, sizeof(input)), output_ucase) == 0);	test_end();	test_begin("binary to hex ucase");	str = t_str_new(32);	str_append_c(str, '<');	binary_to_hex_append(str, input, sizeof(input));	str_append_c(str, '>');	test_assert(strcmp(str_c(str), t_strconcat("<", output_lcase, ">", NULL)) == 0);	test_end();}

static int client_input_status_overview(struct doveadm_connection *client){	struct replicator_queue *queue =		replicator_brain_get_queue(client->brain);	struct replicator_queue_iter *iter;	struct replicator_user *user;	enum replication_priority priority;	unsigned int pending_counts[REPLICATION_PRIORITY_SYNC+1];	unsigned int user_count, next_secs, pending_failed_count;	unsigned int pending_full_resync_count, waiting_failed_count;	string_t *str = t_str_new(256);	memset(pending_counts, 0, sizeof(pending_counts));	pending_failed_count = 0; waiting_failed_count = 0;	pending_full_resync_count = 0;	user_count = 0;	iter = replicator_queue_iter_init(queue);	while ((user = replicator_queue_iter_next(iter)) != NULL) {		if (user->priority != REPLICATION_PRIORITY_NONE)			pending_counts[user->priority]++;		else if (replicator_queue_want_sync_now(queue, user, &next_secs)) {			if (user->last_sync_failed)				pending_failed_count++;			else				pending_full_resync_count++;		} else {			if (user->last_sync_failed)				waiting_failed_count++;		}		user_count++;	}	replicator_queue_iter_deinit(&iter);	for (priority = REPLICATION_PRIORITY_SYNC; priority > 0; priority--) {		str_printfa(str, "Queued '%s' requests/t%u/n",			    replicator_priority_to_str(priority),			    pending_counts[priority]);	}	str_printfa(str, "Queued 'failed' requests/t%u/n",		    pending_failed_count);	str_printfa(str, "Queued 'full resync' requests/t%u/n",		    pending_full_resync_count);	str_printfa(str, "Waiting 'failed' requests/t%u/n",		    waiting_failed_count);	str_printfa(str, "Total number of known users/t%u/n", user_count);	str_append_c(str, '/n');	o_stream_send(client->conn.output, str_data(str), str_len(str));	return 0;}

static voidreply_append_extra_fields(string_t *str, struct auth_request *request){	if (!auth_fields_is_empty(request->extra_fields)) {		str_append_c(str, '/t');		auth_fields_append(request->extra_fields, str, 0, 0);	}	if (request->userdb_reply != NULL &&	    auth_fields_is_empty(request->userdb_reply)) {		/* all userdb_* fields had NULL values. we'll still		   need to tell this to the master */		str_append(str, "/tuserdb_"AUTH_REQUEST_USER_KEY_IGNORE);	}}

void passdb_blocking_verify_plain(struct auth_request *request){	string_t *str;	str = t_str_new(128);	str_printfa(str, "PASSV/t%u/t", request->passdb->passdb->id);	str_append_tabescaped(str, request->mech_password);	str_append_c(str, '/t');	auth_request_export(request, str);	auth_request_ref(request);	auth_worker_call(request->pool, request->user, str_c(str),			 verify_plain_callback, request);}

void passdb_blocking_lookup_credentials(struct auth_request *request){	string_t *str;	str = t_str_new(128);	str_printfa(str, "PASSL/t%u/t", request->passdb->passdb->id);	str_append_tabescaped(str, request->credentials_scheme);	str_append_c(str, '/t');	auth_request_export(request, str);	auth_request_ref(request);	auth_worker_call(request->pool, request->user, str_c(str),			 lookup_credentials_callback, request);}

static const char *pop3c_client_get_sasl_plain_request(struct pop3c_client *client){	const struct pop3c_client_settings *set = &client->set;	string_t *in, *out;	in = t_str_new(128);	if (set->master_user != NULL) {		str_append(in, set->username);		str_append_c(in, '/0');		str_append(in, set->master_user);	} else {		str_append_c(in, '/0');		str_append(in, set->username);	}	str_append_c(in, '/0');	str_append(in, set->password);	out = t_str_new(128);	base64_encode(str_data(in), str_len(in), out);	str_append(out, "/r/n");	return str_c(out);}

void qp_encoder_more(struct qp_encoder *qp, const void *_src, size_t src_size){	const unsigned char *src = _src;	i_assert(_src != NULL || src_size == 0);	if (src_size == 0)		return;	if (qp->add_header_preamble) {		size_t used = qp->dest->used;		qp->add_header_preamble = FALSE;		str_append(qp->dest, "=?utf-8?Q?");		qp->line_len = qp->dest->used - used;	}	for(unsigned int i = 0; i < src_size; i++) {		unsigned char c = src[i];		/* if input is not binary data and we encounter newline		   convert it as crlf, or if the last byte was CR, preserve		   CRLF */		if (c == '/n' &&		    ((qp->flags & (QP_ENCODER_FLAG_BINARY_DATA|QP_ENCODER_FLAG_HEADER_FORMAT)) == 0 ||		      qp->cr_last)) {			str_append_c(qp->dest, '/r');			str_append_c(qp->dest, '/n');			/* reset line length here */			qp->line_len = 0;			qp->cr_last = FALSE;			continue;		} else if (qp->cr_last) {			qp_encode_or_break(qp, '/r');			qp->cr_last = FALSE;		}		if (c == '/r') {			qp->cr_last = TRUE;		} else {			qp_encode_or_break(qp, c);		}	}}