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 int server_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 int dbox_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 */ int ensurepath(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); }
/* * Create start of pidf document */ int start_pidf_doc(str* _b, int _l) { if ((XML_VERSION_L + CRLF_L + DOCTYPE_L + CRLF_L ) > _l) { paerrno = PA_SMALL_BUFFER; LOG(L_ERR, "start_pidf_doc(): Buffer too small\n"); return -1; } str_append(_b, XML_VERSION CRLF DOCTYPE CRLF, XML_VERSION_L + CRLF_L + DOCTYPE_L + CRLF_L); return 0; }
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 void http_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; }