static void
get_metadata_cache_fields(struct mailbox *box,
struct mailbox_metadata *metadata_r)
{
const struct mail_cache_field *fields;
enum mail_cache_decision_type dec;
ARRAY_TYPE(mailbox_cache_field) *cache_fields;
struct mailbox_cache_field *cf;
unsigned int i, count;
if (box->metadata_pool == NULL) {
box->metadata_pool =
pool_alloconly_create("mailbox metadata", 1024*3);
}
fields = mail_cache_register_get_list(box->cache,
box->metadata_pool, &count);
cache_fields = p_new(box->metadata_pool,
ARRAY_TYPE(mailbox_cache_field), 1);
p_array_init(cache_fields, box->metadata_pool, count);
for (i = 0; i < count; i++) {
dec = fields[i].decision & ~MAIL_CACHE_DECISION_FORCED;
if (dec != MAIL_CACHE_DECISION_NO) {
cf = array_append_space(cache_fields);
cf->name = fields[i].name;
cf->decision = fields[i].decision;
cf->last_used = fields[i].last_used;
}
}
metadata_r->cache_fields = cache_fields;
}
void OCamlFGotoCodeGen::writeData()
{
if ( redFsm->anyToStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
TO_STATE_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyFromStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
FROM_STATE_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
if ( redFsm->anyEofActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), EA() );
EOF_ACTIONS();
CLOSE_ARRAY() <<
"\n";
}
STATE_IDS();
out << "exception Goto_again" << TOP_SEP();
}
void FGotoCodeGen::writeData()
{
if ( redFsm->anyToStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), TSA() );
TO_STATE_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyFromStateActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), FSA() );
FROM_STATE_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
if ( redFsm->anyEofActions() ) {
OPEN_ARRAY( ARRAY_TYPE(redFsm->maxActionLoc), EA() );
EOF_ACTIONS();
CLOSE_ARRAY() <<
L"\n";
}
STATE_IDS();
}
void CSharpTabCodeGen::initVarTypes()
{
int klenMax = MAX(MAX(redFsm->maxCondLen, redFsm->maxRangeLen),
redFsm->maxSingleLen);
int keysMax = MAX(MAX(redFsm->maxKeyOffset, klenMax),
redFsm->maxCondOffset);
int transMax = MAX(MAX(redFsm->maxIndex+1, redFsm->maxIndexOffset), keysMax);
transMax = MAX(transMax, klenMax);
transType = ARRAY_TYPE(transMax);
klenType = ARRAY_TYPE(klenMax);
keysType = ARRAY_TYPE(keysMax);
signedKeysType = ARRAY_TYPE(keysMax, true);
}
static uint32_t
maildir_save_set_recent_flags(struct maildir_save_context *ctx)
{
struct maildir_mailbox *mbox = ctx->mbox;
ARRAY_TYPE(seq_range) saved_sorted_uids;
const struct seq_range *uids;
unsigned int i, count;
uint32_t uid;
count = array_count(&ctx->ctx.transaction->changes->saved_uids);
if (count == 0)
return 0;
t_array_init(&saved_sorted_uids, count);
array_append_array(&saved_sorted_uids,
&ctx->ctx.transaction->changes->saved_uids);
array_sort(&saved_sorted_uids, seq_range_cmp);
uids = array_get(&saved_sorted_uids, &count);
for (i = 0; i < count; i++) {
for (uid = uids[i].seq1; uid <= uids[i].seq2; uid++)
mailbox_recent_flags_set_uid(&mbox->box, uid);
}
return uids[count-1].seq2 + 1;
}
static void
virtual_mailbox_get_list_patterns(struct virtual_parse_context *ctx)
{
struct virtual_mailbox *mbox = ctx->mbox;
ARRAY_TYPE(mailbox_virtual_patterns) *dest;
struct mailbox_virtual_pattern pattern;
struct virtual_backend_box *const *bboxes;
unsigned int i, count;
memset(&pattern, 0, sizeof(pattern));
bboxes = array_get_modifiable(&mbox->backend_boxes, &count);
p_array_init(&mbox->list_include_patterns, ctx->pool, count);
p_array_init(&mbox->list_exclude_patterns, ctx->pool, count);
for (i = 0; i < count; i++) {
if (bboxes[i]->metadata_entry == NULL)
continue;
pattern.ns = bboxes[i]->ns;
pattern.pattern = bboxes[i]->name;
if (bboxes[i]->negative_match)
dest = &mbox->list_include_patterns;
else {
dest = &mbox->list_exclude_patterns;
pattern.pattern++;
}
array_append(dest, &pattern, 1);
}
}
ARRAY_TYPE(imap_arg_list) *
test_parse_imap_args(pool_t pool, const char *line, unsigned int linelen,
const char **error_r)
{
struct imap_parser *imap_parser;
struct istream *input;
const struct imap_arg *args;
ARRAY_TYPE(imap_arg_list) *dup_args;
enum imap_parser_error fatal;
int ret;
input = i_stream_create_from_data(line, linelen);
imap_parser = imap_parser_create(input, NULL, (size_t)-1);
ret = imap_parser_finish_line(imap_parser, 0,
IMAP_PARSE_FLAG_LITERAL8 |
IMAP_PARSE_FLAG_LITERAL_TYPE |
IMAP_PARSE_FLAG_ATOM_ALLCHARS |
IMAP_PARSE_FLAG_MULTILINE_STR, &args);
if (ret < 0) {
dup_args = NULL;
if (ret == -2)
*error_r = "Missing data";
else {
*error_r = t_strdup(imap_parser_get_error(imap_parser,
&fatal));
}
} else {
dup_args = test_parse_imap_args_dup(pool, args);
}
imap_parser_unref(&imap_parser);
i_stream_unref(&input);
return dup_args;
}
static void env_clean_except_real(const char *const preserve_envs[])
{
ARRAY_TYPE(const_string) copy;
const char *value, *const *envp;
unsigned int i;
t_array_init(©, 16);
for (i = 0; preserve_envs[i] != NULL; i++) {
const char *key = preserve_envs[i];
value = getenv(key);
if (value != NULL) {
value = t_strconcat(key, "=", value, NULL);
array_append(©, &value, 1);
}
}
/* Note that if the original environment was set with env_put(), the
environment strings will be invalid after env_clean(). That's why
we t_strconcat() them above. */
env_clean();
array_foreach(©, envp)
env_put(*envp);
}
static void test_seq_range_array_remove_nth(void)
{
ARRAY_TYPE(seq_range) range;
const struct seq_range *r;
test_begin("seq_range_array_remove_nth()");
t_array_init(&range, 8);
seq_range_array_add_range(&range, 1, 5);
seq_range_array_add(&range, 7);
seq_range_array_add_range(&range, 10,20);
test_assert(array_count(&range) == 3);
seq_range_array_remove_nth(&range, 0, 2);
r = array_idx(&range, 0); test_assert(r->seq1 == 3 && r->seq2 == 5);
seq_range_array_remove_nth(&range, 1, 4);
r = array_idx(&range, 0); test_assert(r->seq1 == 3 && r->seq2 == 3);
r = array_idx(&range, 1); test_assert(r->seq1 == 11 && r->seq2 == 20);
seq_range_array_remove_nth(&range, 5, (uint32_t)-1);
r = array_idx(&range, 1); test_assert(r->seq1 == 11 && r->seq2 == 14);
test_assert(array_count(&range) == 2);
test_end();
}
static int cmd_deduplicate_uidlist(struct mailbox *box, struct uidlist *uidlist)
{
struct mailbox_transaction_context *trans;
struct mail_search_context *search_ctx;
struct mail_search_args *search_args;
struct mail_search_arg *arg;
struct mail *mail;
ARRAY_TYPE(seq_range) uids;
int ret = 0;
/* the uidlist is reversed with oldest mails at the end.
we'll delete everything but the oldest mail. */
if (uidlist->next == NULL)
return 0;
t_array_init(&uids, 8);
for (; uidlist->next != NULL; uidlist = uidlist->next)
seq_range_array_add(&uids, uidlist->uid);
search_args = mail_search_build_init();
arg = mail_search_build_add(search_args, SEARCH_UIDSET);
arg->value.seqset = uids;
trans = mailbox_transaction_begin(box, 0);
search_ctx = mailbox_search_init(trans, search_args, NULL, 0, NULL);
mail_search_args_unref(&search_args);
while (mailbox_search_next(search_ctx, &mail))
mail_expunge(mail);
if (mailbox_search_deinit(&search_ctx) < 0)
ret = -1;
if (mailbox_transaction_commit(&trans) < 0)
ret = -1;
return ret;
}
static void
dbox_sync_index_copy_from_old(struct dbox_sync_rebuild_context *ctx,
struct mail_index_view *view,
uint32_t old_seq, uint32_t new_seq)
{
struct mail_index *index = mail_index_view_get_index(view);
const struct mail_index_record *rec;
ARRAY_TYPE(keyword_indexes) old_keywords;
struct mail_keywords *kw;
uint64_t modseq;
/* copy flags */
rec = mail_index_lookup(view, old_seq);
mail_index_update_flags(ctx->trans, new_seq,
MODIFY_REPLACE, rec->flags);
/* copy keywords */
t_array_init(&old_keywords, 32);
mail_index_lookup_keywords(view, old_seq, &old_keywords);
kw = mail_index_keywords_create_from_indexes(index, &old_keywords);
mail_index_update_keywords(ctx->trans, new_seq, MODIFY_REPLACE, kw);
mail_index_keywords_unref(&kw);
/* copy modseq */
modseq = mail_index_modseq_lookup(view, old_seq);
mail_index_update_modseq(ctx->trans, new_seq, modseq);
dbox_sync_index_copy_cache(ctx, view, old_seq, new_seq);
}
static void
mirror_get_remote_cmd_line(const char *const *argv,
const char *const **cmd_args_r)
{
ARRAY_TYPE(const_string) cmd_args;
unsigned int i;
const char *p;
i_assert(argv[0] != NULL);
t_array_init(&cmd_args, 16);
for (i = 0; argv[i] != NULL; i++) {
p = argv[i];
array_append(&cmd_args, &p, 1);
}
if (legacy_dsync) {
/* we're executing dsync */
p = "server";
} else {
/* we're executing doveadm */
p = "dsync-server";
}
array_append(&cmd_args, &p, 1);
array_append_zero(&cmd_args);
*cmd_args_r = array_idx(&cmd_args, 0);
}
static void
boundaries_permute(uint32_t *input, unsigned int i, unsigned int count)
{
ARRAY_TYPE(seq_range) range;
const struct seq_range *seqs;
unsigned int seqs_count;
uint32_t tmp;
unsigned int j;
if (i+1 < count) {
for (j = i; j < count; j++) {
tmp = input[i]; input[i] = input[j]; input[j] = tmp;
boundaries_permute(input, i+1, count);
tmp = input[i]; input[i] = input[j]; input[j] = tmp;
}
return;
}
t_array_init(&range, 4);
for (i = 0; i < count; i++)
seq_range_array_add(&range, input[i]);
seqs = array_get(&range, &seqs_count);
test_assert(seqs_count == 2);
test_assert(seqs[0].seq1 == 0);
test_assert(seqs[0].seq2 == 1);
test_assert(seqs[1].seq1 == (uint32_t)-2);
test_assert(seqs[1].seq2 == (uint32_t)-1);
}
int acl_rights_update_import(struct acl_rights_update *update,
const char *id, const char *const *rights,
const char **error_r)
{
ARRAY_TYPE(const_string) dest_rights, dest_neg_rights, *dest;
unsigned int i, j;
if (acl_identifier_parse(id, &update->rights) < 0) {
*error_r = t_strdup_printf("Invalid ID: %s", id);
return -1;
}
if (rights == NULL) {
update->modify_mode = ACL_MODIFY_MODE_CLEAR;
update->neg_modify_mode = ACL_MODIFY_MODE_CLEAR;
return 0;
}
t_array_init(&dest_rights, 8);
t_array_init(&dest_neg_rights, 8);
for (i = 0; rights[i] != NULL; i++) {
const char *right = rights[i];
if (right[0] != '-')
dest = &dest_rights;
else {
right++;
dest = &dest_neg_rights;
}
if (strcmp(right, "all") != 0) {
if (*right == ':') {
/* non-standard right */
right++;
array_append(dest, &right, 1);
} else if (is_standard_right(right)) {
array_append(dest, &right, 1);
} else {
*error_r = t_strdup_printf("Invalid right '%s'",
right);
return -1;
}
} else {
for (j = 0; all_mailbox_rights[j] != NULL; j++)
array_append(dest, &all_mailbox_rights[j], 1);
}
}
if (array_count(&dest_rights) > 0) {
array_append_zero(&dest_rights);
update->rights.rights = array_idx(&dest_rights, 0);
} else if (update->modify_mode == ACL_MODIFY_MODE_REPLACE) {
update->modify_mode = ACL_MODIFY_MODE_CLEAR;
}
if (array_count(&dest_neg_rights) > 0) {
array_append_zero(&dest_neg_rights);
update->rights.neg_rights = array_idx(&dest_neg_rights, 0);
} else if (update->neg_modify_mode == ACL_MODIFY_MODE_REPLACE) {
update->neg_modify_mode = ACL_MODIFY_MODE_CLEAR;
}
return 0;
}
/**
* Callback for Modbus write register function
* for setting a new IP address.
*
* High-Byte of value is always the left most IP segment!
* How to set a new IP:
* 1) Write higher 2 segments at num IP_HIGH.
* 2) Write lower 2 segments at num IP_LOW.
* New IP is stored in EEPROM.
* New IP address will be activated after Modbus transmission has
* been confirmed with old IP address.
*
* Example:
* write_IP(IP_HIGH, 0xC0A8); // 192.168
* write_IP(IP_LOW, 0x00A8); // 0.111
*
* @param num Register number
* @param value Two 8-bit values for IPv4 segments
* @return True if value was written successfully
**/
uint8_t write_IP(uint8_t num, uint16_t value) {
switch (num) {
case IP_HIGH:
config.ip[0] = (ARRAY_TYPE(config.ip))(value >> 8);
config.ip[1] = (ARRAY_TYPE(config.ip))value;
break;
case IP_LOW:
config.ip[2] = (ARRAY_TYPE(config.ip))(value >> 8);
config.ip[3] = (ARRAY_TYPE(config.ip))value;
eeprom_update_block(config.ip, eeConfig.ip, sizeof(config.ip));
renewIP = 1;
break;
default:
return 0;
}
return 1;
}
static ARRAY_TYPE(imap_arg_list) *
test_parse_imap_args_dup(pool_t pool, const struct imap_arg *args)
{
ARRAY_TYPE(imap_arg_list) *list;
struct imap_arg *dub;
unsigned int i, count = 0;
while (args[count++].type != IMAP_ARG_EOL) ;
list = p_new(pool, ARRAY_TYPE(imap_arg_list), 1);
p_array_init(list, pool, count);
for (i = 0; i < count; i++) {
dub = array_append_space(list);
test_parse_imap_arg_dup(pool, &args[i], dub);
}
return list;
}
int pop3c_sync_get_uidls(struct pop3c_mailbox *mbox)
{
ARRAY_TYPE(const_string) uidls;
struct istream *input;
const char *error, *cline;
char *line, *p;
unsigned int seq, line_seq;
if (mbox->msg_uidls != NULL)
return 0;
if ((pop3c_client_get_capabilities(mbox->client) &
POP3C_CAPABILITY_UIDL) == 0) {
mail_storage_set_error(mbox->box.storage,
MAIL_ERROR_NOTPOSSIBLE,
"UIDLs not supported by server");
return -1;
}
if (pop3c_client_cmd_stream(mbox->client, "UIDL\r\n",
&input, &error) < 0) {
mail_storage_set_critical(mbox->box.storage,
"UIDL failed: %s", error);
return -1;
}
mbox->uidl_pool = pool_alloconly_create("POP3 UIDLs", 1024*32);
p_array_init(&uidls, mbox->uidl_pool, 64); seq = 0;
while ((line = i_stream_read_next_line(input)) != NULL) {
seq++;
p = strchr(line, ' ');
if (p == NULL) {
mail_storage_set_critical(mbox->box.storage,
"Invalid UIDL line: %s", line);
break;
}
*p++ = '\0';
if (str_to_uint(line, &line_seq) < 0 || line_seq != seq) {
mail_storage_set_critical(mbox->box.storage,
"Unexpected UIDL seq: %s != %u", line, seq);
break;
}
cline = p_strdup(mbox->uidl_pool, p);
array_append(&uidls, &cline, 1);
}
i_stream_destroy(&input);
if (line != NULL) {
pool_unref(&mbox->uidl_pool);
return -1;
}
if (seq == 0) {
/* make msg_uidls non-NULL */
array_append_zero(&uidls);
}
mbox->msg_uidls = array_idx(&uidls, 0);
mbox->msg_count = seq;
return 0;
}
int main(int argc, char *argv[])
{
ARRAY_TYPE(const_string) aenvs;
const char *binary;
const char *const *envs;
int c, i;
master_service = master_service_init("script", 0, &argc, &argv, "+e:");
t_array_init(&aenvs, 16);
while ((c = master_getopt(master_service)) > 0) {
switch (c) {
case 'e':
envs = t_strsplit_spaces(optarg,", \t");
while (*envs != NULL) {
array_append(&aenvs, envs, 1);
envs++;
}
break;
default:
return FATAL_DEFAULT;
}
}
argc -= optind;
argv += optind;
array_append_zero(&aenvs);
accepted_envs = p_strarray_dup(default_pool, array_idx(&aenvs, 0));
master_service_init_log(master_service, "script: ");
if (argv[0] == NULL)
i_fatal("Missing script path");
restrict_access_by_env(RESTRICT_ACCESS_FLAG_ALLOW_ROOT, NULL);
restrict_access_allow_coredumps(TRUE);
master_service_init_finish(master_service);
master_service_set_service_count(master_service, 1);
if (argv[0][0] == '/')
binary = argv[0];
else
binary = t_strconcat(PKG_LIBEXECDIR"/", argv[0], NULL);
i_array_init(&exec_args, argc + 16);
array_append(&exec_args, &binary, 1);
for (i = 1; i < argc; i++) {
const char *arg = argv[i];
array_append(&exec_args, &arg, 1);
}
master_service_run(master_service, client_connected);
array_free(&exec_args);
i_free(accepted_envs);
master_service_deinit(&master_service);
return 0;
}
static void
index_sort_list_finish_size(struct mail_search_sort_program *program)
{
ARRAY_TYPE(mail_sort_node_size) *nodes = program->context;
array_sort(nodes, sort_node_size_cmp);
memcpy(&program->seqs, nodes, sizeof(program->seqs));
i_free(nodes);
program->context = NULL;
}
static void
index_sort_list_add_pop3_order(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_size) *nodes = program->context;
struct mail_sort_node_size *node;
node = array_append_space(nodes);
node->seq = mail->seq;
node->size = index_sort_get_pop3_order(mail);
}
static void
index_sort_list_add_relevancy(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_float) *nodes = program->context;
struct mail_sort_node_float *node;
node = array_append_space(nodes);
node->seq = mail->seq;
node->num = index_sort_get_relevancy(mail);
}
static void
index_storage_get_status_cache_fields(struct mailbox *box,
struct mailbox_status *status_r)
{
const struct mail_cache_field *fields;
enum mail_cache_decision_type dec;
ARRAY_TYPE(const_string) *cache_fields;
unsigned int i, count;
fields = mail_cache_register_get_list(box->cache,
pool_datastack_create(), &count);
cache_fields = t_new(ARRAY_TYPE(const_string), 1);
t_array_init(cache_fields, count);
for (i = 0; i < count; i++) {
dec = fields[i].decision & ~MAIL_CACHE_DECISION_FORCED;
if (dec != MAIL_CACHE_DECISION_NO)
array_append(cache_fields, &fields[i].name, 1);
}
status_r->cache_fields = cache_fields;
}
static void
index_sort_list_add_size(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_size) *nodes = program->context;
struct mail_sort_node_size *node;
node = array_append_space(nodes);
node->seq = mail->seq;
if (mail_get_virtual_size(mail, &node->size) < 0)
node->size = 0;
}
static void
index_sort_list_add_arrival(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_date) *nodes = program->context;
struct mail_sort_node_date *node;
node = array_append_space(nodes);
node->seq = mail->seq;
if (mail_get_received_date(mail, &node->date) < 0)
node->date = 0;
}
static void test_seq_range_array_add_merge(void)
{
ARRAY_TYPE(seq_range) range;
test_begin("seq_range_array_add() merging");
t_array_init(&range, 8);
seq_range_array_add(&range, 4);
seq_range_array_add(&range, 1);
seq_range_array_add(&range, 2);
test_assert(array_count(&range) == 2);
test_end();
}
static int
config_read_reply_header(struct istream *istream, const char *path, pool_t pool,
const struct master_service_settings_input *input,
struct master_service_settings_output *output_r,
const char **error_r)
{
const char *line;
ssize_t ret;
while ((ret = i_stream_read(istream)) > 0) {
line = i_stream_next_line(istream);
if (line != NULL)
break;
}
if (ret <= 0) {
if (ret == 0)
return 1;
*error_r = istream->stream_errno != 0 ?
t_strdup_printf("read(%s) failed: %s", path,
i_stream_get_error(istream)) :
t_strdup_printf("read(%s) failed: EOF", path);
return -1;
}
T_BEGIN {
const char *const *arg = t_strsplit_tabescaped(line);
ARRAY_TYPE(const_string) services;
p_array_init(&services, pool, 8);
for (; *arg != NULL; arg++) {
if (strcmp(*arg, "service-uses-local") == 0)
output_r->service_uses_local = TRUE;
else if (strcmp(*arg, "service-uses-remote") == 0)
output_r->service_uses_remote = TRUE;
if (strcmp(*arg, "used-local") == 0)
output_r->used_local = TRUE;
else if (strcmp(*arg, "used-remote") == 0)
output_r->used_remote = TRUE;
else if (strncmp(*arg, "service=", 8) == 0) {
const char *name = p_strdup(pool, *arg + 8);
array_append(&services, &name, 1);
}
}
if (input->service == NULL) {
array_append_zero(&services);
output_r->specific_services = array_idx(&services, 0);
}
} T_END;
return 0;
}
void CSharpFlatCodeGen::initVarTypes()
{
slenType = ARRAY_TYPE(MAX(redFsm->maxSpan, redFsm->maxCondSpan));
transType = ARRAY_TYPE(redFsm->maxIndex+1);
actsType = ARRAY_TYPE(redFsm->maxActionLoc);
nactsType = ARRAY_TYPE(redFsm->maxActArrItem);
indsType = ARRAY_TYPE(redFsm->maxFlatIndexOffset);
condsType = ARRAY_TYPE(redFsm->maxCondIndexOffset);
}
static void
index_sort_list_finish_float(struct mail_search_sort_program *program)
{
ARRAY_TYPE(mail_sort_node_float) *nodes = program->context;
/* NOTE: higher relevancy is returned first, unlike with all
other number based sort keys, so temporarily reverse the search */
static_node_cmp_context.reverse = !static_node_cmp_context.reverse;
array_sort(nodes, sort_node_float_cmp);
static_node_cmp_context.reverse = !static_node_cmp_context.reverse;
memcpy(&program->seqs, nodes, sizeof(program->seqs));
i_free(nodes);
program->context = NULL;
}
static const char *
maildir_filename_guess(struct maildir_mailbox *mbox, uint32_t uid,
const char *fname,
enum maildir_uidlist_rec_flag *uidlist_flags,
bool *have_flags_r)
{
struct mail_index_view *view = mbox->flags_view;
struct maildir_keywords_sync_ctx *kw_ctx;
enum mail_flags flags;
ARRAY_TYPE(keyword_indexes) keywords;
const char *p;
uint32_t seq;
if (view == NULL || !mail_index_lookup_seq(view, uid, &seq)) {
*have_flags_r = FALSE;
return fname;
}
t_array_init(&keywords, 32);
mail_index_lookup_view_flags(view, seq, &flags, &keywords);
if (array_count(&keywords) == 0) {
*have_flags_r = (flags & MAIL_FLAGS_NONRECENT) != 0;
fname = maildir_filename_flags_set(fname, flags);
} else {
*have_flags_r = TRUE;
kw_ctx = maildir_keywords_sync_init_readonly(mbox->keywords,
mbox->box.index);
fname = maildir_filename_flags_kw_set(kw_ctx, fname,
flags, &keywords);
maildir_keywords_sync_deinit(&kw_ctx);
}
if (*have_flags_r) {
/* don't even bother looking into new/ dir */
*uidlist_flags &= MAILDIR_UIDLIST_REC_FLAG_NEW_DIR;
} else if ((*uidlist_flags & MAILDIR_UIDLIST_REC_FLAG_MOVED) == 0 &&
((*uidlist_flags & MAILDIR_UIDLIST_REC_FLAG_NEW_DIR) != 0 ||
mailbox_recent_flags_have_uid(&mbox->box, uid))) {
/* probably in new/ dir, drop ":2," from fname */
*uidlist_flags |= MAILDIR_UIDLIST_REC_FLAG_NEW_DIR;
p = strrchr(fname, MAILDIR_INFO_SEP);
if (p != NULL)
fname = t_strdup_until(fname, p);
}
return fname;
}
static void
index_sort_list_add_date(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_date) *nodes = program->context;
struct mail_sort_node_date *node;
int tz;
node = array_append_space(nodes);
node->seq = mail->seq;
if (mail_get_date(mail, &node->date, &tz) < 0)
node->date = index_sort_program_set_date_failed(program, mail);
else if (node->date == 0) {
if (mail_get_received_date(mail, &node->date) < 0)
node->date = index_sort_program_set_date_failed(program, mail);
}
}
