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

static int filter_connect(struct mail_filter_ostream *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;	}	net_set_nonblock(fd, FALSE);	mstream->fd = fd;	mstream->ext_in = i_stream_create_fd(fd, IO_BLOCK_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;}

void render(struct page *p){    int depth;    FILE *out;    struct lacy_env env;    struct page_stack p_stack;    struct ut_str outfile;    str_init(&curtok);    if (NULL == p)        return;    str_init(&outfile);    str_append_str(&outfile, conf.output_dir.s);    str_append(&outfile, '/');    str_append_str(&outfile, p->file_path);    /* depth - 1 since we added output dir to path */    depth = build_depth(outfile.s) - 1;    if (NULL == (out = fopen(outfile.s, "w")))         fatal("Unable to open: %: ", outfile.s);    p_stack.size = 0;    p_stack.pos = 0;    /* Build Environment */    env.depth = depth;    env.p_stack = &p_stack;    env.sym_tbl = NULL;    env_build(p, &env);    /* set stack back to top */    p_stack.pos = 0;    /* do it already */    build_tree(&env);    write_tree(out, &env);    env_free(&env);    fclose(out);    str_free(&curtok);    if (verbosity > 0) {        printf("Rendered %s/n", outfile.s);    }    str_free(&outfile);}

static int proxy_write_starttls(struct imap_client *client, string_t *str){	enum login_proxy_ssl_flags ssl_flags = login_proxy_get_ssl_flags(client->common.login_proxy);	if ((ssl_flags & PROXY_SSL_FLAG_STARTTLS) != 0) {		if (client->proxy_backend_capability != NULL &&		    !str_array_icase_find(t_strsplit(client->proxy_backend_capability, " "), "STARTTLS")) {			client_log_err(&client->common,			"proxy: Remote doesn't support STARTTLS");			return -1;		}		str_append(str, "S STARTTLS/r/n");		return 1;	}	return 0;}

/// This differs from the non-unique version in that we expect the filename/// to be something like a pattern for mkstemp(), so the resulting path can/// reside in a system-wide directory with no risk of a conflict.static char *resolve_relative_runtime_unique_filename (const char *filename){	struct str path;	str_init (&path);	const char *runtime_dir = getenv ("XDG_RUNTIME_DIR");	if (runtime_dir && *runtime_dir == '/')		str_append (&path, runtime_dir);	else		str_append (&path, "/tmp");	str_append_printf (&path, "/%s/%s", PROGRAM_NAME, filename);	// Try to create the file's ancestors;	// typically the user will want to immediately create a file in there	const char *last_slash = strrchr (path.str, '/');	if (last_slash && last_slash != path.str)	{		char *copy = xstrndup (path.str, last_slash - path.str);		(void) mkdir_with_parents (copy, NULL);		free (copy);	}	return str_steal (&path);}

char* CSaveTeam::GetString(){	str_format(m_String, sizeof(m_String), "%d/t%d/t%d/t%d", m_TeamState, m_MembersCount, m_NumSwitchers, m_TeamLocked);	for (int i = 0; i<m_MembersCount; i++)	{		char aBuf[1024];		str_format(aBuf, sizeof(aBuf), "/n%s", SavedTees[i].GetString());		str_append(m_String, aBuf, sizeof(m_String));	}	if(m_NumSwitchers)		for(int i=1; i < m_NumSwitchers+1; i++)		{			char aBuf[64];			if (m_Switchers)			{				str_format(aBuf, sizeof(aBuf), "/n%d/t%d/t%d", m_Switchers[i].m_Status, m_Switchers[i].m_EndTime, m_Switchers[i].m_Type);				str_append(m_String, aBuf, sizeof(m_String));			}		}	return m_String;}

static const char *get_body_human_name(pool_t pool, struct imap_fetch_body_data *body){	string_t *str;	uoff_t partial_offset, partial_size;	str = t_str_new(64);	if (body->binary)		str_append(str, "BINARY[");	else		str_append(str, "BODY[");	str_append(str, body->section);	str_append_c(str, ']');	partial_offset = imap_msgpart_get_partial_offset(body->msgpart);	partial_size = imap_msgpart_get_partial_size(body->msgpart);	if (partial_offset != 0 || partial_size != (uoff_t)-1) {		str_printfa(str, "<%"PRIuUOFF_T, partial_offset);		if (partial_size != (uoff_t)-1)			str_printfa(str, ".%"PRIuUOFF_T, partial_size);		str_append_c(str, '>');	}	return p_strdup(pool, str_c(str));}

static bool show_backtrace_function(void *addr, struct string *str){	void * buf[] = { addr };	char **symbols;	symbols = backtrace_symbols(buf, 1);	if (symbols == NULL) {		return false;	}	str_append(str, "%s/n", symbols[0]);	free(symbols);	return true;}

static intserver_connection_authenticate(struct server_connection *conn){	string_t *plain = t_str_new(128);	string_t *cmd = t_str_new(128);	if (*conn->set->doveadm_password == '/0') {		i_error("doveadm_password not set, "			"can't authenticate to remote server");		return -1;	}	str_append_c(plain, '/0');	str_append(plain, "doveadm");	str_append_c(plain, '/0');	str_append(plain, conn->set->doveadm_password);	str_append(cmd, "PLAIN/t");	base64_encode(plain->data, plain->used, cmd);	str_append_c(cmd, '/n');	o_stream_nsend(conn->output, cmd->data, cmd->used);	return 0;}

char *err_msg(void){    char *result = NULL;    struct ErrFrame *frame = err_stack;    int i = 0;    str_append(result, "Error:/n");    while (frame) {        char *message_line = NULL;        str_append(message_line, "%d: [%s] ", i++, frame->module);        if (frame->src_loc) {            str_append(        message_line,        "(%d,%d) ",        frame->src_loc->line,        frame->src_loc->column);        }        str_append(message_line, ": %s/n", frame->message);        str_append(result, "/t%s", message_line);        mem_free(message_line);        frame = frame->next;    }    return result;}

bool CConsole::ConModCommandStatus(IResult *pResult, void *pUser){	CConsole* pConsole = static_cast<CConsole *>(pUser);	char aBuf[240];	mem_zero(aBuf, sizeof(aBuf));	int Used = 0;	for(CCommand *pCommand = pConsole->m_pFirstCommand; pCommand; pCommand = pCommand->m_pNext)	{		if(pCommand->m_Flags&pConsole->m_FlagMask && pCommand->GetAccessLevel() == ACCESS_LEVEL_MOD)		{			int Length = str_length(pCommand->m_pName);			if(Used + Length + 2 < (int)(sizeof(aBuf)))			{				if(Used > 0)				{					Used += 2;					str_append(aBuf, ", ", sizeof(aBuf));				}				str_append(aBuf, pCommand->m_pName, sizeof(aBuf));				Used += Length;			}			else			{				pConsole->Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);				mem_zero(aBuf, sizeof(aBuf));				str_copy(aBuf, pCommand->m_pName, sizeof(aBuf));				Used = Length;			}		}	}	if(Used > 0)		pConsole->Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);		return true;}

static intdbox_get_cached_metadata(struct dbox_mail *mail, enum dbox_metadata_key key,			 enum index_cache_field cache_field,			 const char **value_r){	struct index_mail *imail = &mail->imail;	struct index_mailbox_context *ibox =		INDEX_STORAGE_CONTEXT(imail->mail.mail.box);	const char *value;	string_t *str;	uint32_t order;	str = str_new(imail->mail.data_pool, 64);	if (mail_cache_lookup_field(imail->mail.mail.transaction->cache_view,				    str, imail->mail.mail.seq,				    ibox->cache_fields[cache_field].idx) > 0) {		if (cache_field == MAIL_CACHE_POP3_ORDER) {			i_assert(str_len(str) == sizeof(order));			memcpy(&order, str_data(str), sizeof(order));			str_truncate(str, 0);			str_printfa(str, "%u", order);		}		*value_r = str_c(str);		return 0;	}	if (dbox_mail_metadata_get(mail, key, &value) < 0)		return -1;	if (value == NULL)		value = "";	if (cache_field != MAIL_CACHE_POP3_ORDER) {		index_mail_cache_add_idx(imail, ibox->cache_fields[cache_field].idx,					 value, strlen(value)+1);	} else {		if (str_to_uint(value, &order) < 0)			order = 0;		index_mail_cache_add_idx(imail, ibox->cache_fields[cache_field].idx,					 &order, sizeof(order));	}	/* don't return pointer to dbox metadata directly, since it may	   change unexpectedly */	str_truncate(str, 0);	str_append(str, value);	*value_r = str_c(str);	return 0;}

struct page *parse_page(FILE *f, char *file_path){    char c;    int parsed_header = 0;    struct ut_str buffer;    /* markdown vars */    struct page *p = malloc(sizeof(struct page));    parse_filepath(file_path, p);    p->inherits = NULL;    p->attr_top = NULL;    str_init(&buffer);    while ((c = fgetc(f)) != EOF) {        if (!parsed_header && '-' == c && flook_ahead(f, "--", 2)) {            parse_header(f, p);            parsed_header = 1;        }        else {            str_append(&buffer, c);        }    }     while (c != EOF);    p->code = malloc(sizeof(char) * buffer.size + 1);    memset(p->code, '/0', buffer.size + 1);    if (MARKDOWN == p->page_type) {        Document *doc = mkd_string(buffer.s, buffer.size + 1, 0);        if (NULL != doc && mkd_compile(doc, 0) ) {            char *html = NULL;            int szdoc = mkd_document(doc, &html);            strncpy(p->code, html, szdoc);            mkd_cleanup(doc);        }    } else {        strncpy(p->code, buffer.s, buffer.size);    }    str_free(&buffer);    return p;}

static void show_option( enum OptType type, Bool *pflag,                         char *short_opt, char *long_opt, char *help_text, char *help_arg ){	STR_DEFINE(msg, STR_SIZE);    int count_opts = 0;    if ( type == OptDeprecated )        return;							/* skip deprecated options */    /* show default option */    if ( ( type == OptSet   &&   *pflag ) ||            ( type == OptClear && ! *pflag ) )        str_set( msg, "* " );    else        str_set( msg, "  " );    if ( *short_opt )    {        /* dont show short_opt if short_opt is same as long_opt, except for extra '-',           e.g. -sdcc and --sdcc */        if ( !( *long_opt && strcmp( short_opt, long_opt + 1 ) == 0 ) )        {            str_append_sprintf( msg, "%s", short_opt );            count_opts++;        }    }    if ( *long_opt )    {        if ( count_opts )            str_append( msg, ", " );        str_append_sprintf( msg, "%s", long_opt );        count_opts++;    }    if ( *help_arg )    {        str_append_sprintf( msg, "=%s", help_arg );    }    if ( str_len(msg) > ALIGN_HELP )        printf( "%s/n%-*s %s/n", str_data(msg), ALIGN_HELP, "",       help_text );    else        printf( "%-*s %s/n",                    ALIGN_HELP, str_data(msg), help_text );	STR_DELETE(msg);}

/* Ensure a path capable of writing the passed in file */intensurepath(char *path){	char **a;	int i, rv, dotdot;	char *ptmp;	struct growstring grow;	assert(path);	ptmp=strdup(path);	a=split('/', ptmp);	/* Get rid of the last element */	for(i=0; a[i]!=NULL; i++);	free(a[i-1]);	a[i-1]=NULL;	grow.size=1024*sizeof(char);	grow.string=calloc(sizeof(char), grow.size);	assert(grow.string);	dotdot=0;	/* Get the first two pieces */	str_append(&grow, "/");	str_append(&grow, a[0]);	if(strcmp(a[0], "..")==0) {		dotdot+=2;	}	str_append(&grow, "/");	str_append(&grow, a[1]);	if(strcmp(a[1], "..")==0) {		dotdot+=2;	}	rv=mkdir(grow.string, 0755);	if(rv<0 && errno!=EEXIST) {		return(-1);	}	for(i=2; a[i]!=NULL; i++) {		str_append(&grow, "/");		str_append(&grow, a[i]);		if(strcmp(a[i], "..")==0) {			dotdot+=2;		}		/* We want to make sure someone doesn't try to .. out of the		 * controlled work area */		assert(dotdot<i);		rv=mkdir(grow.string, 0755);		if(rv<0 && errno!=EEXIST) {			return(-1);		}	}	return(0);}

const char *http_url_create(const struct http_url *url){	string_t *urlstr = t_str_new(512);	http_url_add_scheme(urlstr, url);	http_url_add_authority(urlstr, url);	http_url_add_target(urlstr, url);	/* fragment */	if (url->enc_fragment != NULL) {		str_append_c(urlstr, '#');		str_append(urlstr, url->enc_fragment);	}	return str_c(urlstr);}

void CServerBrowser::AddRecent(const NETADDR &Addr){    for (int i = MAX_RECENT - 1; i > 0; i--)        swap(m_aRecentServers[i], m_aRecentServers[i - 1]);    m_aRecentServers[0] = Addr;    if (m_NumRecentServers < MAX_RECENT)        m_NumRecentServers++;    //save recent to file    char aFilePath[1024];    fs_storage_path("Teeworlds", aFilePath, sizeof(aFilePath));    str_append(aFilePath, "/recent.cfg", sizeof(aFilePath));    IOHANDLE RecentFile = io_open(aFilePath, IOFLAG_WRITE);    io_write(RecentFile, m_aRecentServers, sizeof(NETADDR) * m_NumRecentServers);    io_close(RecentFile);}

void testsuite_message_init(void){	message_pool = pool_alloconly_create("testsuite_message", 6096);	string_t *default_message = str_new(message_pool, 1024);	str_append(default_message, _default_message_data);	testsuite_mail = sieve_tool_open_data_as_mail(sieve_tool, default_message);	envelope_to = str_new(message_pool, 256);	envelope_orig_to = str_new(message_pool, 256);	envelope_from = str_new(message_pool, 256);	envelope_auth = str_new(message_pool, 256);	testsuite_message_set_data(testsuite_mail);}

static void auth_cache_key_add_tab_idx(string_t *str, unsigned int i){	const struct var_expand_table *tab =		&auth_request_var_expand_static_tab[i];	if (str_len(str) > 0)		str_append_c(str, '/t');	str_append_c(str, '%');	if (tab->key != '/0')		str_append_c(str, tab->key);	else {		str_append_c(str, '{');		str_append(str, tab->long_key);		str_append_c(str, '}');	}}

static int client_export_iter_command(struct client *client){	struct client_export_cmd *cmd = client->cmd_export;	struct mail_command *command = client->mail_cmd_iter;	i_assert(cmd->level == MAIL_EXPORT_LEVEL_COMMAND);	mail_command_unref(&client->mail_cmd_iter);	if (!cmd->header_sent) {		o_stream_nsend_str(client->output,			"cmd/targs/tsession/tuser/tlast_update"MAIL_STATS_HEADER);		cmd->header_sent = TRUE;	}	for (; command != NULL; command = command->stable_next) {		if (client_is_busy(client))			break;		if (!mail_export_filter_match_session(&cmd->filter,						      command->session))			continue;		str_truncate(cmd->str, 0);		str_append_tabescaped(cmd->str, command->name);		str_append_c(cmd->str, '/t');		str_append_tabescaped(cmd->str, command->args);		str_append_c(cmd->str, '/t');		T_BEGIN {			str_append(cmd->str,				   guid_128_to_string(command->session->guid));			str_append_c(cmd->str, '/t');			str_append_tabescaped(cmd->str,					      command->session->user->name);		} T_END;		client_export_timeval(cmd->str, &command->last_update);		client_export_mail_stats(cmd->str, &command->stats);		str_append_c(cmd->str, '/n');		o_stream_nsend(client->output, str_data(cmd->str),			       str_len(cmd->str));	}	if (command != NULL) {		client->mail_cmd_iter = command;		mail_command_ref(command);		return 0;	}	return 1;}

static int update_statusbar(void){	status_str.len = 0;	if (str_append(&status_str, " "))		return -1;	append_sections(&status_str, wordy);		if (str_null_terminate(&status_str))		return -1;		XStoreName(dpy, root, status_str.buf);	XFlush(dpy);	return 0;}

static voidhttp_url_add_authority(string_t *urlstr, const struct http_url *url){	/* host:port */	if (url->host_name != NULL) {		/* assume IPv6 literal if starts with '['; avoid encoding */		if (*url->host_name == '[')			str_append(urlstr, url->host_name);		else			uri_append_host_name(urlstr, url->host_name);	} else if (url->have_host_ip) {		uri_append_host_ip(urlstr, &url->host_ip);	} else		i_unreached();	if (url->have_port)		uri_append_port(urlstr, url->port);}

int cmd_lhlo(struct client *client, const char *args){	struct rfc822_parser_context parser;	string_t *domain = t_str_new(128);	const char *p;	int ret = 0;	if (*args == '/0') {		client_send_line(client, "501 Missing hostname");		return 0;	}	/* domain / address-literal */	rfc822_parser_init(&parser, (const unsigned char *)args, strlen(args),			   NULL);	if (*args != '[')		ret = rfc822_parse_dot_atom(&parser, domain);	else {		for (p = args+1; *p != ']'; p++) {			if (*p == '//' || *p == '[')				break;		}		if (strcmp(p, "]") != 0)			ret = -1;	}	if (ret < 0) {		str_truncate(domain, 0);		str_append(domain, "invalid");	}	client_state_reset(client, "LHLO");	client_send_line(client, "250-%s", client->my_domain);	if (master_service_ssl_is_enabled(master_service) &&	    client->ssl_iostream == NULL)		client_send_line(client, "250-STARTTLS");	if (client_is_trusted(client))		client_send_line(client, "250-XCLIENT ADDR PORT TTL TIMEOUT");	client_send_line(client, "250-8BITMIME");	client_send_line(client, "250-ENHANCEDSTATUSCODES");	client_send_line(client, "250 PIPELINING");	i_free(client->lhlo);	client->lhlo = i_strdup(str_c(domain));	client_state_set(client, "LHLO", "");	return 0;}

static void test_str_truncate(void){	string_t *str = t_str_new(8);	int i;	test_begin("str_truncate()");	str_append(str, "123456");	for (i = 100; i >= 6; i--) {		str_truncate(str, i);		test_assert_idx(str_len(str) == 6, i);	}	for (; i >= 0; i--) {		str_truncate(str, i);		test_assert_idx(str_len(str) == (unsigned int)i, i);	}	test_end();}

CServerBrowser::CServerBrowser(){	m_pMasterServer = 0;	m_ppServerlist = 0;	m_pSortedServerlist = 0;	m_NumFavoriteServers = 0;	mem_zero(m_aServerlistIp, sizeof(m_aServerlistIp));	m_pFirstReqServer = 0; // request list	m_pLastReqServer = 0;	m_NumRequests = 0;	m_NeedRefresh = 0;	m_NumSortedServers = 0;	m_NumSortedServersCapacity = 0;	m_NumServers = 0;	m_NumServerCapacity = 0;	m_Sorthash = 0;	m_aFilterString[0] = 0;	m_aFilterGametypeString[0] = 0;	// the token is to keep server refresh separated from each other	m_CurrentToken = 1;	m_ServerlistType = 0;	m_BroadcastTime = 0;	m_LastSort = 0;    //Load recent servers    char aFilePath[1024];    fs_storage_path("Teeworlds", aFilePath, sizeof(aFilePath));    str_append(aFilePath, "/recent.cfg", sizeof(aFilePath));    IOHANDLE RecentFile = io_open(aFilePath, IOFLAG_READ);    if (RecentFile)    {        io_read(RecentFile, m_aRecentServers, io_length(RecentFile));        m_NumRecentServers = io_length(RecentFile) / sizeof(NETADDR);        io_close(RecentFile);    }}

void CServerBrowser::DDNetTypeFilterClean(){	char aNewList[128];	for(int i = 0; i < m_NumDDNetTypes; i++)	{		const char *pName = m_aDDNetTypes[i];		if(DDNetFiltered(g_Config.m_BrFilterExcludeTypes, pName))		{			char aBuf[128];			str_format(aBuf, sizeof(aBuf), ",%s", pName);			str_append(aNewList, aBuf, sizeof(aNewList));		}	}	str_copy(g_Config.m_BrFilterExcludeTypes, aNewList, sizeof(g_Config.m_BrFilterExcludeTypes));}

static bool auth_worker_verify_db_hash(const char *line){	string_t *str;	unsigned char passdb_md5[MD5_RESULTLEN];	unsigned char userdb_md5[MD5_RESULTLEN];	passdbs_generate_md5(passdb_md5);	userdbs_generate_md5(userdb_md5);	str = t_str_new(128);	str_append(str, "DBHASH/t");	binary_to_hex_append(str, passdb_md5, sizeof(passdb_md5));	str_append_c(str, '/t');	binary_to_hex_append(str, userdb_md5, sizeof(userdb_md5));	return strcmp(line, str_c(str)) == 0;}

bool cmd_genurlauth(struct client_command_context *cmd){	const struct imap_arg *args;	string_t *response;	int ret;	if (cmd->client->urlauth_ctx == NULL) {		client_send_command_error(cmd, "URLAUTH disabled.");		return TRUE;	}	if (!client_read_args(cmd, 0, 0, &args))		return FALSE;	response = t_str_new(1024);	str_append(response, "* GENURLAUTH");	for (;;) {		const char *url_rump, *mechanism, *url, *error;		if (IMAP_ARG_IS_EOL(args))			break;		if (!imap_arg_get_astring(args++, &url_rump) ||		    !imap_arg_get_atom(args++, &mechanism)) {			client_send_command_error(cmd, "Invalid arguments.");			return FALSE;		}		ret = imap_urlauth_generate(cmd->client->urlauth_ctx,					    mechanism, url_rump, &url, &error);		if (ret <= 0) {			if (ret < 0)				client_send_internal_error(cmd);			else				client_send_command_error(cmd, error);			return TRUE;		}		str_append_c(response, ' ');		imap_append_astring(response, url);	}	client_send_line(cmd->client, str_c(response));	client_send_tagline(cmd, "OK GENURLAUTH completed.");	return TRUE;}

static int proxy_input_banner(struct imap_client *client,			      struct ostream *output, const char *line){	enum login_proxy_ssl_flags ssl_flags;	const char *const *capabilities = NULL;	string_t *str;	if (strncmp(line, "* OK ", 5) != 0) {		client_log_err(&client->common, t_strdup_printf(			"proxy: Remote returned invalid banner: %s",			str_sanitize(line, 160)));		return -1;	}	str = t_str_new(128);	if (strncmp(line + 5, "[CAPABILITY ", 12) == 0) {		capabilities = t_strsplit(t_strcut(line + 5 + 12, ']'), " ");		if (str_array_icase_find(capabilities, "ID"))			proxy_write_id(client, str);		if (str_array_icase_find(capabilities, "SASL-IR"))			client->proxy_sasl_ir = TRUE;		if (str_array_icase_find(capabilities, "LOGINDISABLED"))			client->proxy_logindisabled = TRUE;		i_free(client->proxy_backend_capability);		client->proxy_backend_capability =			i_strdup(t_strcut(line + 5 + 12, ']'));	}	ssl_flags = login_proxy_get_ssl_flags(client->common.login_proxy);	if ((ssl_flags & PROXY_SSL_FLAG_STARTTLS) != 0) {		if (capabilities != NULL &&		    !str_array_icase_find(capabilities, "STARTTLS")) {			client_log_err(&client->common,				"proxy: Remote doesn't support STARTTLS");			return -1;		}		str_append(str, "S STARTTLS/r/n");	} else {		if (proxy_write_login(client, str) < 0)			return -1;	}	o_stream_nsend(output, str_data(str), str_len(str));	return 0;}

static const char *sieve_attribute_iter_next_script(struct sieve_mailbox_attribute_iter *siter){	struct mail_user *user = siter->iter.box->storage->user;	struct sieve_mail_user *suser = SIEVE_USER_CONTEXT(user);	struct sieve_storage *svstorage = suser->sieve_storage;	const char *scriptname;	bool active;	int ret;	if (siter->sieve_list == NULL)		return NULL;	/* Iterate through all scripts in sieve_dir */	while ((scriptname = sieve_storage_list_next(siter->sieve_list, &active))		!= NULL) {		if (active)			siter->have_active = TRUE;		str_truncate(siter->name, strlen(MAILBOX_ATTRIBUTE_PREFIX_SIEVE_FILES));		str_append(siter->name, scriptname);		return str_c(siter->name);	}	if (sieve_storage_list_deinit(&siter->sieve_list) < 0) {		mail_storage_set_critical(siter->iter.box->storage,			"Failed to iterate sieve scripts: %s",			sieve_storage_get_last_error(svstorage, NULL));		siter->failed = TRUE;		return NULL;	}	/* Check whether active script is a proper symlink or a regular file */	if ((ret=sieve_storage_is_singular(svstorage)) < 0) {		mail_storage_set_critical(siter->iter.box->storage,			"Failed to iterate sieve scripts: %s",			sieve_storage_get_last_error(svstorage, NULL));		return NULL;	}	/* Regular file */	if (ret > 0)		return MAILBOX_ATTRIBUTE_SIEVE_DEFAULT;	/* Symlink or none active */	return siter->have_active ? MAILBOX_ATTRIBUTE_SIEVE_DEFAULT : NULL;}