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

static voidsolr_add_ns_query_http(string_t *str, struct solr_fts_backend *backend,                       struct mail_namespace *ns){    string_t *tmp;    tmp = t_str_new(64);    solr_add_ns_query(tmp, backend, ns, FALSE);    http_url_escape_param(str, str_c(tmp));}

static void test_str_append(void){	string_t *str = t_str_new(32);	string_t *str2 = t_str_new(32);	test_begin("str_append_*()");	str_append(str, "foo");	str_append_c(str, '|');	str_append_c(str, '/0');	test_assert(str->used == 5 && memcmp(str_data(str), "foo|/0", 5) == 0);	str_append(str2, "sec");	str_append_c(str2, '/0');	str_append(str2, "ond");	str_append_str(str, str2);	test_assert(str->used == 5+7 && memcmp(str_data(str), "foo|/0sec/0ond", 5+7) == 0);	test_end();}

int rfc822_parse_content_param(struct rfc822_parser_context *ctx,			       const char **key_r, const char **value_r){	string_t *tmp;	size_t value_pos;	int ret;	/* .. := *(";" parameter)	   parameter := attribute "=" value	   attribute := token	   value := token / quoted-string	*/	*key_r = NULL;	*value_r = NULL;	if (ctx->data == ctx->end)		return 0;	if (*ctx->data != ';')		return -1;	ctx->data++;	if (rfc822_skip_lwsp(ctx) <= 0)		return -1;	tmp = t_str_new(64);	if (rfc822_parse_mime_token(ctx, tmp) <= 0)		return -1;	str_append_c(tmp, '/0');	value_pos = str_len(tmp);	if (*ctx->data != '=')		return -1;	ctx->data++;	if ((ret = rfc822_skip_lwsp(ctx)) <= 0) {		/* broken / no value */	} else if (*ctx->data == '"') {		ret = rfc822_parse_quoted_string(ctx, tmp);	} else if (ctx->data != ctx->end && *ctx->data == '=') {		/* workaround for broken input:		   name==?utf-8?b?...?= */		while (ctx->data != ctx->end && *ctx->data != ';' &&		       *ctx->data != ' ' && *ctx->data != '/t' &&		       *ctx->data != '/r' && *ctx->data != '/n') {			str_append_c(tmp, *ctx->data);			ctx->data++;		}	} else {		ret = rfc822_parse_mime_token(ctx, tmp);	}	*key_r = str_c(tmp);	*value_r = *key_r + value_pos;	return ret < 0 ? -1 : 1;}

static void test_json_append_escaped_data(void){	static const unsigned char test_input[] =		"/b/f/r/n/t/"///000/001/002-/xC3/xA4";	string_t *str = t_str_new(32);	test_begin("json_append_escaped()");	json_append_escaped_data(str, test_input, sizeof(test_input)-1);	test_assert(strcmp(str_c(str), "//b//f//r//n//t///"//////u0000//u0001//u0002-/xC3/xA4") == 0);	test_end();}

void test_str_sanitize(void){	static struct str_sanitize_test tests[] = {		{ NULL,    2, NULL },		{ "",      2, NULL },		{ "a",     2, NULL },		{ "ab",    2, NULL },		{ "abc",   2, "..." },		{ "abcd",  3, "..." },		{ "abcde", 4, "a..." },		{ "/xD1/x81",     1, "..." },		{ "/xD1/x81",     2, "/xD1/x81" },		{ "/xD1/x81",     3, NULL },		{ "/xC3/xA4/xC3/xA4zyxa", 1, "..." },		{ "/xC3/xA4/xC3/xA4zyxa", 2, "..." },		{ "/xC3/xA4/xC3/xA4zyxa", 3, "..." },		{ "/xC3/xA4/xC3/xA4zyxa", 4, "..." },		{ "/xC3/xA4/xC3/xA4zyxa", 5, "/xC3/xA4..." },		{ "/xC3/xA4/xC3/xA4zyxa", 6, "/xC3/xA4..." },		{ "/xC3/xA4/xC3/xA4zyxa", 7, "/xC3/xA4/xC3/xA4..." },		{ "/xC3/xA4/xC3/xA4zyxa", 8, "/xC3/xA4/xC3/xA4zyxa" },		{ "/001x/x1fy/x81", 10, "?x?y?" }	};	const char *str;	string_t *str2;	unsigned int i;	test_begin("str_sanitize");	for (i = 0; i < N_ELEMENTS(tests); i++) {		str = str_sanitize(tests[i].str, tests[i].max_len);		if (tests[i].sanitized != NULL)			test_assert_idx(null_strcmp(str, tests[i].sanitized) == 0, i);		else			test_assert_idx(str == tests[i].str, i);	}	test_end();	test_begin("str_sanitize_append");	str2 = t_str_new(128);	for (i = 0; i < N_ELEMENTS(tests); i++) {		if (tests[i].str == NULL)			continue;		str_truncate(str2, 0);		str_append(str2, "1234567890");		str_sanitize_append(str2, tests[i].str, tests[i].max_len);		test_assert_idx(strncmp(str_c(str2), "1234567890", 10) == 0, i);		if (tests[i].sanitized != NULL)			test_assert_idx(strcmp(str_c(str2)+10, tests[i].sanitized) == 0, i);		else			test_assert_idx(strcmp(str_c(str2)+10, tests[i].str) == 0, i);	}	test_end();}

const char *checkpassword_get_cmd(struct auth_request *request, const char *args,		      const char *checkpassword_reply_path){	string_t *str;	str = t_str_new(256);	var_expand(str, args,		   auth_request_get_var_expand_table(request, NULL));	return t_strconcat(str_c(str), " ", checkpassword_reply_path, NULL);}

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

int http_parse_quoted_string(struct http_parser *parser, const char **str_r){	string_t *str;	/* quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE	   qdtext        = HTAB / SP / "!" / %x23-5B ; '#'-'['	                   / %x5D-7E ; ']'-'~'	                   / obs-text	   quoted-pair   = "/" ( HTAB / SP / VCHAR / obs-text )	   obs-text      = %x80-FF	 */	/* DQUOTE */	if (parser->cur >= parser->end || parser->cur[0] != '"')		return 0;	parser->cur++;	/* *( qdtext / quoted-pair ) */	str = t_str_new(256);	for (;;) {		const unsigned char *first;		/* *qdtext */		first = parser->cur;		while (parser->cur < parser->end && http_char_is_qdtext(*parser->cur))			parser->cur++;		if (parser->cur >= parser->end)			return -1;		str_append_data(str, first, parser->cur - first);		/* DQUOTE */		if (*parser->cur == '"') {			parser->cur++;			break;		/* "/" */		} else if (*parser->cur == '//') {			parser->cur++;						if (parser->cur >= parser->end || !http_char_is_text(*parser->cur))				return -1;			str_append_c(str, *parser->cur);			parser->cur++;		/* ERROR */		} else {			return -1;		}	}	*str_r = str_c(str);	return 1;}

static void passwd_file_lookup(struct auth_request *auth_request,                               userdb_callback_t *callback){    struct userdb_module *_module = auth_request->userdb->userdb;    struct passwd_file_userdb_module *module =        (struct passwd_file_userdb_module *)_module;    struct passwd_user *pu;    const struct var_expand_table *table;    string_t *str;    const char *key, *value;    char **p;    pu = db_passwd_file_lookup(module->pwf, auth_request,                               module->username_format);    if (pu == NULL || pu->uid == 0) {        callback(USERDB_RESULT_USER_UNKNOWN, auth_request);        return;    }    auth_request_init_userdb_reply(auth_request);    if (pu->uid != (uid_t)-1) {        auth_request_set_userdb_field(auth_request, "uid",                                      dec2str(pu->uid));    }    if (pu->gid != (gid_t)-1) {        auth_request_set_userdb_field(auth_request, "gid",                                      dec2str(pu->gid));    }    if (pu->home != NULL)        auth_request_set_userdb_field(auth_request, "home", pu->home);    if (pu->extra_fields != NULL) {        str = t_str_new(512);        table = auth_request_get_var_expand_table(auth_request, NULL);        for (p = pu->extra_fields; *p != NULL; p++) {            if (strncmp(*p, "userdb_", 7) != 0)                continue;            key = *p + 7;            value = strchr(key, '=');            if (value != NULL) {                key = t_strdup_until(key, value);                str_truncate(str, 0);                var_expand(str, value + 1, table);                value = str_c(str);            }            auth_request_set_userdb_field(auth_request, key, value);        }    }    callback(USERDB_RESULT_OK, auth_request);}

static intreplication_fifo_notify(struct mail_user *user,			enum replication_priority priority){	string_t *str;	ssize_t ret;	if (fifo_failed)		return -1;	if (fifo_fd == -1) {		fifo_fd = open(fifo_path, O_WRONLY | O_NONBLOCK);		if (fifo_fd == -1) {			i_error("open(%s) failed: %m", fifo_path);			fifo_failed = TRUE;			return -1;		}	}	/* <username> /t <priority> */	str = t_str_new(256);	str_append_tabescaped(str, user->username);	str_append_c(str, '/t');	switch (priority) {	case REPLICATION_PRIORITY_NONE:	case REPLICATION_PRIORITY_SYNC:		i_unreached();	case REPLICATION_PRIORITY_LOW:		str_append(str, "low");		break;	case REPLICATION_PRIORITY_HIGH:		str_append(str, "high");		break;	}	str_append_c(str, '/n');	ret = write(fifo_fd, str_data(str), str_len(str));	i_assert(ret != 0);	if (ret != (ssize_t)str_len(str)) {		if (ret > 0)			i_error("write(%s) wrote partial data", fifo_path);		else if (errno == EAGAIN) {			/* busy, try again later */			return 0;		} else if (errno != EPIPE) {			i_error("write(%s) failed: %m", fifo_path);		} else {			/* server was probably restarted, don't bother logging			   this. */		}		if (close(fifo_fd) < 0)			i_error("close(%s) failed: %m", fifo_path);		fifo_fd = -1;		return -1;	}	return 1;}

static void test_str_c(void){	string_t *str;	unsigned int i, j;	test_begin("str_c()");	str = t_str_new(0);	T_BEGIN {		(void)str_c(str);	} T_END;	for (i = 0; i < 32; i++) T_BEGIN {		str = t_str_new(15);		for (j = 0; j < i; j++)			str_append_c(str, 'x');		T_BEGIN {			(void)str_c(str);		} T_END;	} T_END;	test_end();}

void userdb_blocking_lookup(struct auth_request *request){	string_t *str;	str = t_str_new(128);	str_printfa(str, "USER/t%u/t", request->userdb->userdb->id);	auth_request_export(request, str);	auth_request_ref(request);	auth_worker_call(request->pool, request->user,			 str_c(str), user_callback, request);}

static int fetch_and_copy(struct client *client,			  struct mailbox_transaction_context *t,			  struct mail_search_args *search_args,			  const char **src_uidset_r,			  unsigned int *copy_count_r){	struct mail_search_context *search_ctx;        struct mailbox_transaction_context *src_trans;	struct mail_save_context *save_ctx;	struct mail *mail;	unsigned int copy_count = 0;	struct msgset_generator_context srcset_ctx;	string_t *src_uidset;	int ret;	src_uidset = t_str_new(256);	msgset_generator_init(&srcset_ctx, src_uidset);	src_trans = mailbox_transaction_begin(client->mailbox, 0);	search_ctx = mailbox_search_init(src_trans, search_args, NULL);	mail = mail_alloc(src_trans, 0, NULL);	ret = 1;	while (mailbox_search_next(search_ctx, mail) && ret > 0) {		if (mail->expunged) {			ret = 0;			break;		}		if ((++copy_count % COPY_CHECK_INTERVAL) == 0)			client_send_sendalive_if_needed(client);		save_ctx = mailbox_save_alloc(t);		mailbox_save_copy_flags(save_ctx, mail);		if (mailbox_copy(&save_ctx, mail) < 0)			ret = mail->expunged ? 0 : -1;		msgset_generator_next(&srcset_ctx, mail->uid);	}	mail_free(&mail);	msgset_generator_finish(&srcset_ctx);	if (mailbox_search_deinit(&search_ctx) < 0)		ret = -1;	if (mailbox_transaction_commit(&src_trans) < 0)		ret = -1;	*src_uidset_r = str_c(src_uidset);	*copy_count_r = copy_count;	return ret;}

struct db_passwd_file *db_passwd_file_init(const char *path, bool userdb, bool debug){	struct db_passwd_file *db;	const char *p;	bool percents = FALSE;	db = db_passwd_file_find(path);	if (db != NULL) {		db->refcount++;		if (userdb)			db_passwd_file_set_userdb(db);		return db;	}	db = i_new(struct db_passwd_file, 1);	db->refcount = 1;	if (userdb)		db_passwd_file_set_userdb(db);	db->debug = debug;	for (p = path; *p != '/0'; p++) {		if (*p == '%' && p[1] != '/0') {			if (var_get_key(++p) == '%')				percents = TRUE;			else				db->vars = TRUE;		}	}	if (percents && !db->vars) {		/* just extra escaped % chars. remove them. */		struct var_expand_table empty_table[1];		string_t *dest;		empty_table[0].key = '/0';		dest = t_str_new(256);		var_expand(dest, path, empty_table);		path = str_c(dest);	}	db->path = i_strdup(path);	if (db->vars) {		hash_table_create(&db->files, default_pool, 0,				  str_hash, strcmp);	} else {		db->default_file = passwd_file_new(db, path);	}	db->next = passwd_files;	passwd_files = db;	return db;}

bool mod_lower_modify(string_t *in, string_t **result){	char *content;	*result = t_str_new(str_len(in));	str_append_str(*result, in);	content = str_c_modifiable(*result);	(void)str_lcase(content);	return TRUE;}

static void get_plain_auth(struct client *client, string_t *dest){	string_t *str;	str = t_str_new(128);	str_append(str, client->proxy_user);	str_append_c(str, '/0');	str_append(str, client->proxy_master_user);	str_append_c(str, '/0');	str_append(str, client->proxy_password);	base64_encode(str_data(str), str_len(str), dest);}

void rfc2822_header_utf8_printf(string_t *header, const char *name, const char *fmt, ...){	string_t *body = t_str_new(256);	va_list args;	va_start(args, fmt);	message_header_encode(t_strdup_vprintf(fmt, args), body);	va_end(args);	rfc2822_header_write(header, name, str_c(body));}

const char *mbox_from_create(const char *sender, time_t timestamp){	string_t *str;	struct tm *tm;	int year;	str = t_str_new(256);	str_append(str, "From ");	str_append(str, sender);	str_append(str, "  ");	/* we could use simply asctime(), but i18n etc. may break it.	   Example: "Thu Nov 29 22:33:52 2001" */	tm = localtime(&timestamp);	/* week day */	str_append(str, weekdays[tm->tm_wday]);	str_append_c(str, ' ');	/* month */	str_append(str, months[tm->tm_mon]);	str_append_c(str, ' ');	/* day */	str_append_c(str, (tm->tm_mday / 10) + '0');	str_append_c(str, (tm->tm_mday % 10) + '0');	str_append_c(str, ' ');	/* hour */	str_append_c(str, (tm->tm_hour / 10) + '0');	str_append_c(str, (tm->tm_hour % 10) + '0');	str_append_c(str, ':');	/* minute */	str_append_c(str, (tm->tm_min / 10) + '0');	str_append_c(str, (tm->tm_min % 10) + '0');	str_append_c(str, ':');	/* second */	str_append_c(str, (tm->tm_sec / 10) + '0');	str_append_c(str, (tm->tm_sec % 10) + '0');	str_append_c(str, ' ');	/* year */	year = tm->tm_year + 1900;	str_append_c(str, (year / 1000) + '0');	str_append_c(str, ((year / 100) % 10) + '0');	str_append_c(str, ((year / 10) % 10) + '0');	str_append_c(str, (year % 10) + '0');	str_append_c(str, '/n');	return str_c(str);}

bool mod_lowerfirst_modify(string_t *in, string_t **result){	char *content;	*result = t_str_new(str_len(in));	str_append_str(*result, in);	content = str_c_modifiable(*result);	content[0] = i_tolower(content[0]);	return TRUE;}

static void imap_hibernate_write_cmd(struct client *client, string_t *cmd,				     const buffer_t *state, int fd_notify){	struct stat peer_st;	str_append_tabescaped(cmd, client->user->username);	str_append_c(cmd, '/t');	str_append_tabescaped(cmd, client->user->set->mail_log_prefix);	str_printfa(cmd, "/tidle_notify_interval=%u",		    client->set->imap_idle_notify_interval);	if (fstat(client->fd_in, &peer_st) == 0) {		str_printfa(cmd, "/tpeer_dev_major=%lu/tpeer_dev_minor=%lu/tpeer_ino=%llu",			    (unsigned long)major(peer_st.st_dev),			    (unsigned long)minor(peer_st.st_dev),			    (unsigned long long)peer_st.st_ino);	}	if (client->session_id != NULL) {		str_append(cmd, "/tsession=");		str_append_tabescaped(cmd, client->session_id);	}	if (client->user->local_ip != NULL)		str_printfa(cmd, "/tlip=%s", net_ip2addr(client->user->local_ip));	if (client->user->remote_ip != NULL)		str_printfa(cmd, "/trip=%s", net_ip2addr(client->user->remote_ip));	if (client->userdb_fields != NULL) {		string_t *userdb_fields = t_str_new(256);		unsigned int i;		for (i = 0; client->userdb_fields[i] != NULL; i++) {			if (i > 0)				str_append_c(userdb_fields, '/t');			str_append_tabescaped(userdb_fields, client->userdb_fields[i]);		}		str_append(cmd, "/tuserdb_fields=");		str_append_tabescaped(cmd, str_c(userdb_fields));	}	if (client->user->uid != (uid_t)-1)		str_printfa(cmd, "/tuid=%s", dec2str(client->user->uid));	if (client->user->gid != (gid_t)-1)		str_printfa(cmd, "/tgid=%s", dec2str(client->user->gid));	str_append(cmd, "/tstats=");	str_append_tabescaped(cmd, client_stats(client));	if (client->command_queue != NULL &&	    strcasecmp(client->command_queue->name, "IDLE") == 0)		str_append(cmd, "/tidle-cmd");	if (fd_notify != -1)		str_append(cmd, "/tnotify_fd");	str_append(cmd, "/tstate=");	base64_encode(state->data, state->used, cmd);	str_append_c(cmd, '/n');}

static void test_fts_icu_utf16_to_utf8(void){	string_t *dest = t_str_new(64);	const UChar src[] = { 0xbd, 'b', 'c' };	unsigned int i;	test_begin("fts_icu_utf16_to_utf8");	for (i = N_ELEMENTS(src); i > 0; i--) {		fts_icu_utf16_to_utf8(dest, src, i);		test_assert(dest->used == i+1);	}	test_end();}

struct config_export_context *config_export_init(const char *const *modules, enum config_dump_scope scope,		   enum config_dump_flags flags,		   config_request_callback_t *callback, void *context){	struct config_export_context *ctx;	pool_t pool;	pool = pool_alloconly_create(MEMPOOL_GROWING"config export", 1024*64);	ctx = p_new(pool, struct config_export_context, 1);	ctx->pool = pool;	ctx->modules = modules == NULL ? NULL : p_strarray_dup(pool, modules);	ctx->flags = flags;	ctx->callback = callback;	ctx->context = context;	ctx->scope = scope;	ctx->value = t_str_new(256);	ctx->prefix = t_str_new(64);	hash_table_create(&ctx->keys, ctx->pool, 0, str_hash, strcmp);	return ctx;}

static void test_base32_random(void){	string_t *str, *dest;	char buf[10];	unsigned int i, j, max;	str = t_str_new(256);	dest = t_str_new(256);	test_begin("padded base32 encode/decode with random input");	for (i = 0; i < 1000; i++) {		max = rand() % sizeof(buf);		for (j = 0; j < max; j++)			buf[j] = rand();		str_truncate(str, 0);		str_truncate(dest, 0);		base32_encode(TRUE, buf, max, str);		test_assert(base32_decode(str_data(str), str_len(str), NULL, dest) >= 0);		test_assert(str_len(dest) == max &&			    memcmp(buf, str_data(dest), max) == 0);	}	test_end();	test_begin("padded base32hex encode/decode with random input");	for (i = 0; i < 1000; i++) {		max = rand() % sizeof(buf);		for (j = 0; j < max; j++)			buf[j] = rand();		str_truncate(str, 0);		str_truncate(dest, 0);		base32hex_encode(TRUE, buf, max, str);		test_assert(base32hex_decode(str_data(str), str_len(str), NULL, dest) >= 0);		test_assert(str_len(dest) == max &&			    memcmp(buf, str_data(dest), max) == 0);	}	test_end();}

static const char *mech_get_plugin_name(const char *name){	string_t *str = t_str_new(32);	str_append(str, "mech_");	for (; *name != '/0'; name++) {		if (*name == '-')			str_append_c(str, '_');		else			str_append_c(str, i_tolower(*name));	}	return str_c(str);}

static void passdb_dict_lookup_pass(struct passdb_dict_request *dict_request){	struct auth_request *auth_request = dict_request->auth_request;	struct passdb_module *_module = auth_request->passdb->passdb;	struct dict_passdb_module *module =		(struct dict_passdb_module *)_module;	string_t *key;	const char *password = NULL, *scheme = NULL;	enum passdb_result passdb_result;	int ret;	key = t_str_new(512);	str_append(key, DICT_PATH_SHARED);	var_expand(key, module->conn->set.password_key,		   auth_request_get_var_expand_table(auth_request, NULL));	if (*module->conn->set.password_key == '/0') {		auth_request_log_error(auth_request, "dict",				       "password_key not specified");		passdb_result = PASSDB_RESULT_INTERNAL_FAILURE;	} else {		passdb_result = passdb_dict_lookup_key(auth_request, module,						       str_c(key));	}	if (passdb_result == PASSDB_RESULT_OK) {		/* passdb_password may change on the way,		   so we'll need to strdup. */		password = t_strdup(auth_request->passdb_password);		scheme = password_get_scheme(&password);		/* auth_request_set_field() sets scheme */		i_assert(password == NULL || scheme != NULL);	}	if (auth_request->credentials_scheme != NULL) {		passdb_handle_credentials(passdb_result, password, scheme,			dict_request->callback.lookup_credentials,			auth_request);	} else {		if (password != NULL) {			ret = auth_request_password_verify(auth_request,					auth_request->mech_password,					password, scheme, "dict");			passdb_result = ret > 0 ? PASSDB_RESULT_OK :				PASSDB_RESULT_PASSWORD_MISMATCH;		}		dict_request->callback.verify_plain(passdb_result,						    auth_request);	}}

static intunlink_old_files_real(const char *dir, const char *prefix, time_t min_time){	DIR *dirp;	struct dirent *d;	struct stat st;	string_t *path;	unsigned int prefix_len, dir_len;	dirp = opendir(dir);	if (dirp == NULL) {		if (errno != ENOENT)			i_error("opendir(%s) failed: %m", dir);		return -1;	}	/* update atime immediately, so if this scanning is done based on	   atime it won't be done by multiple processes if the scan is slow */	if (utime(dir, NULL) < 0 && errno != ENOENT)		i_error("utime(%s) failed: %m", dir);	path = t_str_new(256);	str_printfa(path, "%s/", dir);	dir_len = str_len(path);	prefix_len = strlen(prefix);	while ((d = readdir(dirp)) != NULL) {		if (d->d_name[0] == '.' &&		    (d->d_name[1] == '/0' ||		     (d->d_name[1] == '.' && d->d_name[2] == '/0'))) {			/* skip . and .. */			continue;		}		if (strncmp(d->d_name, prefix, prefix_len) != 0)			continue;		str_truncate(path, dir_len);		str_append(path, d->d_name);		if (stat(str_c(path), &st) < 0) {			if (errno != ENOENT)				i_error("stat(%s) failed: %m", str_c(path));		} else if (!S_ISDIR(st.st_mode) && st.st_ctime < min_time) {			if (unlink(str_c(path)) < 0 && errno != ENOENT)				i_error("unlink(%s) failed: %m", str_c(path));		}	}	if (closedir(dirp) < 0)		i_error("closedir(%s) failed: %m", dir);	return 0;}

static int mcht_count_match(struct sieve_match_context *mctx, struct sieve_stringlist *value_list,	struct sieve_stringlist *key_list){	const struct sieve_runtime_env *renv = mctx->runenv;	bool trace = sieve_runtime_trace_active(renv, SIEVE_TRLVL_MATCHING);	int count;	string_t *key_item;	int match, ret;	if ( (count=sieve_stringlist_get_length(value_list)) < 0 ) {		mctx->exec_status = value_list->exec_status;		return -1;	}	sieve_stringlist_reset(key_list);	string_t *value = t_str_new(20);	str_printfa(value, "%d", count);	if ( trace ) {		sieve_runtime_trace(renv, 0,			"matching count value `%s'", str_sanitize(str_c(value), 80));	}	sieve_runtime_trace_descend(renv);  /* Match to all key values */  key_item = NULL;	match = 0;  while ( match == 0 &&		(ret=sieve_stringlist_next_item(key_list, &key_item)) > 0 )  {		match = mcht_value_match_key			(mctx, str_c(value), str_len(value), str_c(key_item), str_len(key_item));		if ( trace ) {			sieve_runtime_trace(renv, 0,				"with key `%s' => %d", str_sanitize(str_c(key_item), 80), ret);		}	}	sieve_runtime_trace_ascend(renv);	if ( ret < 0 ) {		mctx->exec_status = key_list->exec_status;		match = -1;	}	return match;}

const char *acl_rights_export(const struct acl_rights *rights){	string_t *str = t_str_new(128);	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, " -"));	}	return str_c(str);}

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