If search fails, it'll be noticed anyway by mailbox_search_deinit().
--HG--
branch : HEAD
return -1;
prev_uid = iter->mail->uid;
- switch (mailbox_search_next(iter->search_ctx, iter->mail)) {
- case 0:
+ if (!mailbox_search_next(iter->search_ctx, iter->mail)) {
if (iter_local_mailbox_next_expunge(iter, prev_uid, msg_r)) {
*mailbox_idx_r = iter->mailbox_idx;
return 1;
if (iter_local_mailbox_open(iter) < 0)
return -1;
return local_worker_msg_iter_next(_iter, mailbox_idx_r, msg_r);
- case -1:
- return -1;
- default:
- break;
}
*mailbox_idx_r = iter->mailbox_idx;
mail = mail_alloc(src_trans, MAIL_FETCH_STREAM_HEADER |
MAIL_FETCH_STREAM_BODY, NULL);
ret = 1;
- while (mailbox_search_next(search_ctx, mail) > 0 && ret > 0) {
+ while (mailbox_search_next(search_ctx, mail) && ret > 0) {
if (mail->expunged) {
ret = 0;
break;
}
mail = mail_alloc(t, MAIL_FETCH_FLAGS, NULL);
- while (mailbox_search_next(search_ctx, mail) > 0) {
+ while (mailbox_search_next(search_ctx, mail)) {
if (ctx.max_modseq < (uint64_t)-1) {
/* check early so there's less work for transaction
commit if something has to be cancelled */
mail_search_args_unref(&search_args);
mail = mail_alloc(t, 0, NULL);
- while (mailbox_search_next(ctx, mail) > 0) {
+ while (mailbox_search_next(ctx, mail)) {
mail_expunge(mail);
expunges = TRUE;
}
search_ctx = mailbox_search_init(trans, search_args, NULL);
mail_search_args_unref(&search_args);
- while (mailbox_search_next(search_ctx, mail) > 0) {
+ while (mailbox_search_next(search_ctx, mail)) {
if (mail->uid == next_uid) {
if (next_uid < uid_filter[i].seq2)
next_uid++;
if (ctx->cmd->cancel)
return 1;
- if (mailbox_search_next(ctx->search_ctx,
- ctx->mail) <= 0)
+ if (!mailbox_search_next(ctx->search_ctx, ctx->mail))
break;
ctx->cur_mail = ctx->mail;
(opts & ~(SEARCH_RETURN_NORESULTS |
SEARCH_RETURN_MIN | SEARCH_RETURN_MAX)) == 0;
while (mailbox_search_next_nonblock(ctx->search_ctx, ctx->mail,
- &tryagain) > 0) {
+ &tryagain)) {
id = cmd->uid ? ctx->mail->uid : ctx->mail->seq;
ctx->result_count++;
search_ctx->update_result = result;
mail = mail_alloc(t, 0, NULL);
- while (mailbox_search_next(search_ctx, mail) > 0) {
+ while (mailbox_search_next(search_ctx, mail)) {
i_assert(next_uid != 0);
if (next_uid != mail->uid) {
search_ctx = mailbox_search_init(t, result->search_args, NULL);
mail = mail_alloc(t, 0, NULL);
- while (mailbox_search_next(search_ctx, mail) > 0)
+ while (mailbox_search_next(search_ctx, mail))
mailbox_search_result_add(result, mail->uid);
mail_free(&mail);
return ret;
}
-int index_storage_search_next_nonblock(struct mail_search_context *_ctx,
- struct mail *mail, bool *tryagain_r)
+bool index_storage_search_next_nonblock(struct mail_search_context *_ctx,
+ struct mail *mail, bool *tryagain_r)
{
struct index_search_context *ctx = (struct index_search_context *)_ctx;
struct mailbox *box = _ctx->transaction->box;
/* everything searched at this point already. just returning
matches from sort list */
if (!index_sort_list_next(ctx->mail_ctx.sort_program, mail))
- return 0;
- return 1;
+ return FALSE;
+ return TRUE;
}
if (search_would_block(ctx)) {
/* this lookup is useful when a large number of
messages match */
*tryagain_r = TRUE;
- return 0;
+ return FALSE;
}
ctx->mail = mail;
return index_storage_search_next_nonblock(_ctx, mail,
tryagain_r);
}
-
- return ctx->failed ? -1 : (match ? 1 : 0);
+ return !ctx->failed && match;
}
bool index_storage_search_next_update_seq(struct mail_search_context *_ctx)
struct mail_search_args *args,
const enum mail_sort_type *sort_program);
int index_storage_search_deinit(struct mail_search_context *ctx);
-int index_storage_search_next(struct mail_search_context *ctx,
- struct mail *mail);
-int index_storage_search_next_nonblock(struct mail_search_context *ctx,
- struct mail *mail, bool *tryagain_r);
+bool index_storage_search_next_nonblock(struct mail_search_context *ctx,
+ struct mail *mail, bool *tryagain_r);
bool index_storage_search_next_update_seq(struct mail_search_context *ctx);
void index_transaction_set_max_modseq(struct mailbox_transaction_context *_t,
mail = mail_alloc(ctx->t, 0, headers_ctx);
mailbox_header_lookup_unref(&headers_ctx);
- while (mailbox_search_next(search_ctx, mail) > 0) {
+ while (mailbox_search_next(search_ctx, mail)) {
if (mail_thread_map_add_mail(ctx, mail) < 0) {
ret = -1;
break;
count - kind of kludgy) */
i_assert(msgid_map[count].uid == 0);
i = 0;
- while (i < count && mailbox_search_next(search_ctx, mail) > 0) {
+ while (i < count && mailbox_search_next(search_ctx, mail)) {
while (msgid_map[i].uid < mail->uid)
i++;
i_assert(i < count);
struct mail_search_args *args,
const enum mail_sort_type *sort_program);
int (*search_deinit)(struct mail_search_context *ctx);
- int (*search_next_nonblock)(struct mail_search_context *ctx,
- struct mail *mail, bool *tryagain_r);
+ bool (*search_next_nonblock)(struct mail_search_context *ctx,
+ struct mail *mail, bool *tryagain_r);
/* Internal search function which updates ctx->seq */
bool (*search_next_update_seq)(struct mail_search_context *ctx);
return ret;
}
-int mailbox_search_next(struct mail_search_context *ctx, struct mail *mail)
+bool mailbox_search_next(struct mail_search_context *ctx, struct mail *mail)
{
bool tryagain;
- int ret;
- while ((ret = mailbox_search_next_nonblock(ctx, mail,
- &tryagain)) == 0) {
+ while (!mailbox_search_next_nonblock(ctx, mail, &tryagain)) {
if (!tryagain)
- break;
+ return FALSE;
}
-
- return ret;
+ return TRUE;
}
-int mailbox_search_next_nonblock(struct mail_search_context *ctx,
- struct mail *mail, bool *tryagain_r)
+bool mailbox_search_next_nonblock(struct mail_search_context *ctx,
+ struct mail *mail, bool *tryagain_r)
{
- int ret;
+ struct mailbox *box = ctx->transaction->box;
- ret = ctx->transaction->box->v.
- search_next_nonblock(ctx, mail, tryagain_r);
- if (ret > 0)
+ if (!box->v.search_next_nonblock(ctx, mail, tryagain_r))
+ return FALSE;
+ else {
mailbox_search_results_add(ctx, mail->uid);
- return ret;
+ return TRUE;
+ }
}
bool mailbox_search_seen_lost_data(struct mail_search_context *ctx)
ctx = mailbox_search_init(t, args, NULL);
*result_r = mailbox_search_result_save(ctx, flags);
mail = mail_alloc(t, 0, NULL);
- while (mailbox_search_next(ctx, mail) > 0) ;
+ while (mailbox_search_next(ctx, mail)) ;
mail_free(&mail);
ret = mailbox_search_deinit(&ctx);
const enum mail_sort_type *sort_program);
/* Deinitialize search request. */
int mailbox_search_deinit(struct mail_search_context **ctx);
-/* Search the next message. Returns 1 if found, 0 if not, -1 if failure. */
-int mailbox_search_next(struct mail_search_context *ctx, struct mail *mail);
+/* Search the next message. Returns TRUE if found, FALSE if not. */
+bool mailbox_search_next(struct mail_search_context *ctx, struct mail *mail);
/* Like mailbox_search_next(), but don't spend too much time searching.
- Returns 1 if found, -1 if failure or 0 with tryagain_r=FALSE if
- finished, and TRUE if more results will by calling the function again. */
-int mailbox_search_next_nonblock(struct mail_search_context *ctx,
+ Returns FALSE with tryagain_r=FALSE if finished, and tryagain_r=TRUE if
+ more results will be returned by calling the function again. */
+bool mailbox_search_next_nonblock(struct mail_search_context *ctx,
struct mail *mail, bool *tryagain_r);
/* Returns TRUE if some messages were already expunged and we couldn't
determine correctly if those messages should have been returned in this
return 0;
}
-static int
+static bool
test_mailbox_search_next_nonblock(struct mail_search_context *ctx ATTR_UNUSED,
struct mail *mail ATTR_UNUSED,
bool *tryagain_r)
{
*tryagain_r = FALSE;
- return 0;
+ return FALSE;
}
static bool
MAIL_FETCH_FLAGS | MAIL_FETCH_RECEIVED_DATE |
MAIL_FETCH_STREAM_HEADER | MAIL_FETCH_STREAM_BODY |
MAIL_FETCH_FROM_ENVELOPE, NULL);
- while (mailbox_search_next(ctx, mail) > 0) {
+ while (mailbox_search_next(ctx, mail)) {
if ((mail->seq % 100) == 0) {
/* touch the lock file so that if there are tons of
mails another process won't override our lock. */
mail = mail_alloc(t, 0, NULL);
- now = time(NULL);
- while ((ret = mailbox_search_next(search_ctx, mail)) > 0) {
+ now = time(NULL); ret = 0;
+ while (mailbox_search_next(search_ctx, mail)) {
if (mail_get_save_date(mail, &save_time) < 0) {
/* maybe just got expunged. anyway try again later. */
if (ctx->testrun) {
ret = -1;
mailbox_close(&box);
- return ret < 0 ? -1 : 0;
+ return ret;
}
static void expire_run(struct master_service *service, bool testrun)
struct mail_search_context *search_ctx;
struct mail_search_args *search_args;
struct mail *mail;
- int ret = 0;
+ int ret;
t = mailbox_transaction_begin(box, 0);
mail = mail_alloc(t, 0, NULL);
search_ctx = mailbox_search_init(t, search_args, NULL);
mail_search_args_unref(&search_args);
- while ((ret = mailbox_search_next(search_ctx, mail)) > 0) {
+ while (mailbox_search_next(search_ctx, mail)) {
/* *2 because even/odd is for body/header */
seq_range_array_add_range(uids, mail->uid * 2,
mail->uid * 2 + 1);
}
- if (mailbox_search_deinit(&search_ctx) < 0)
- ret = -1;
+ ret = mailbox_search_deinit(&search_ctx);
mail_free(&mail);
(void)mailbox_transaction_commit(&t);
return ret;
FTS_BUILD_NOTIFY_INTERVAL_SECS)
fts_build_notify(ctx);
- while (mailbox_search_next(ctx->search_ctx, ctx->mail) > 0) {
+ while (mailbox_search_next(ctx->search_ctx, ctx->mail)) {
T_BEGIN {
ret = fts_build_mail(ctx, ctx->mail->uid);
} T_END;
return ctx;
}
-static int fts_mailbox_search_next_nonblock(struct mail_search_context *ctx,
- struct mail *mail, bool *tryagain_r)
+static bool
+fts_mailbox_search_next_nonblock(struct mail_search_context *ctx,
+ struct mail *mail, bool *tryagain_r)
{
struct fts_mailbox *fbox = FTS_CONTEXT(ctx->transaction->box);
struct fts_search_context *fctx = FTS_CONTEXT(ctx);
to finish building the indexes */
if (!fts_try_build_init(ctx, fctx)) {
*tryagain_r = TRUE;
- return 0;
+ return FALSE;
}
}
ret = fts_build_more(fctx->build_ctx);
if (ret == 0) {
*tryagain_r = TRUE;
- return 0;
+ return FALSE;
}
/* finished / error */
search_ctx = mailbox_search_init(src_trans, search_args, NULL);
mail_search_args_unref(&search_args);
+ ret = 0;
mail = mail_alloc(src_trans, MAIL_FETCH_STREAM_HEADER |
MAIL_FETCH_STREAM_BODY, NULL);
- while ((ret = mailbox_search_next(search_ctx, mail)) > 0) {
+ while (mailbox_search_next(search_ctx, mail)) {
if (mail->expunged)
continue;
ctx = mailbox_search_init(trans, search_args, NULL);
mail_search_args_unref(&search_args);
- while (mailbox_search_next(ctx, mail) > 0) {
+ while (mailbox_search_next(ctx, mail)) {
if (mail_get_physical_size(mail, &size) == 0)
*bytes_r += size;
*count_r += 1;
mail_search_args_unref(&search_args);
mail = mail_alloc(t, 0, NULL);
- while (mailbox_search_next(ctx, mail) > 0)
+ while (mailbox_search_next(ctx, mail))
quota_free(qt, mail);
mail_free(&mail);
ret = trash_clean_mailbox_open(trash);
else
ret = mailbox_search_next(trash->search_ctx,
- trash->mail);
+ trash->mail) ? 1 : 0;
if (ret <= 0) {
*received_time_r = 0;
return ret;
#include <stdlib.h>
enum virtual_search_state {
- VIRTUAL_SEARCH_STATE_FAILED = -1,
VIRTUAL_SEARCH_STATE_BUILD,
VIRTUAL_SEARCH_STATE_RETURN,
VIRTUAL_SEARCH_STATE_SORT,
return ret;
}
-static int virtual_search_get_records(struct mail_search_context *ctx,
- struct virtual_search_context *vctx)
+static void virtual_search_get_records(struct mail_search_context *ctx,
+ struct virtual_search_context *vctx)
{
struct virtual_mailbox *mbox =
(struct virtual_mailbox *)ctx->transaction->box;
struct virtual_search_record srec;
const void *data;
bool expunged;
- int ret, result;
+ int result;
memset(&srec, 0, sizeof(srec));
- while ((ret = index_storage_search_next_update_seq(ctx)) > 0) {
+ while (index_storage_search_next_update_seq(ctx)) {
result = mail_search_get_result(ctx);
i_assert(result != 0);
if (result > 0) {
array_sort(&vctx->records, virtual_search_record_cmp);
ctx->progress_max = array_count(&vctx->records);
- return ret;
}
struct mail_search_context *
i_array_init(&vctx->records, 64);
MODULE_CONTEXT_SET(ctx, virtual_storage_module, vctx);
- if (virtual_search_get_records(ctx, vctx) < 0)
- vctx->search_state = VIRTUAL_SEARCH_STATE_FAILED;
-
+ virtual_search_get_records(ctx, vctx);
seq_range_array_iter_init(&vctx->result_iter, &vctx->result);
return ctx;
}
return index_storage_search_deinit(ctx);
}
-int virtual_search_next_nonblock(struct mail_search_context *ctx,
- struct mail *mail, bool *tryagain_r)
+bool virtual_search_next_nonblock(struct mail_search_context *ctx,
+ struct mail *mail, bool *tryagain_r)
{
struct virtual_search_context *vctx = VIRTUAL_CONTEXT(ctx);
uint32_t seq;
- int ret;
switch (vctx->search_state) {
- case VIRTUAL_SEARCH_STATE_FAILED:
- return -1;
case VIRTUAL_SEARCH_STATE_BUILD:
if (ctx->sort_program == NULL)
vctx->search_state = VIRTUAL_SEARCH_STATE_SORT;
case VIRTUAL_SEARCH_STATE_SORT:
/* the messages won't be returned sorted, so we'll have to
do it ourself */
- while ((ret = index_storage_search_next_nonblock(ctx, mail,
- tryagain_r)) > 0)
+ while (index_storage_search_next_nonblock(ctx, mail, tryagain_r))
seq_range_array_add(&vctx->result, 0, mail->seq);
- if (ret < 0 || *tryagain_r)
- return ret;
+ if (*tryagain_r)
+ return FALSE;
vctx->next_result_n = 0;
vctx->search_state = VIRTUAL_SEARCH_STATE_SORT_DONE;
*tryagain_r = FALSE;
if (!seq_range_array_iter_nth(&vctx->result_iter,
vctx->next_result_n, &seq))
- return 0;
+ return FALSE;
vctx->next_result_n++;
mail_set_seq(mail, seq);
- return 1;
+ return TRUE;
}
i_unreached();
}
struct mail_search_args *args,
const enum mail_sort_type *sort_program);
int virtual_search_deinit(struct mail_search_context *ctx);
-int virtual_search_next_nonblock(struct mail_search_context *ctx,
- struct mail *mail, bool *tryagain_r);
+bool virtual_search_next_nonblock(struct mail_search_context *ctx,
+ struct mail *mail, bool *tryagain_r);
bool virtual_search_next_update_seq(struct mail_search_context *ctx);
struct mail *
/* add the found UIDs to uidmap. virtual_uid gets assigned later. */
memset(&uidmap, 0, sizeof(uidmap));
array_clear(&bbox->uids);
- while (mailbox_search_next(search_ctx, mail) > 0) {
+ while (mailbox_search_next(search_ctx, mail)) {
uidmap.real_uid = mail->uid;
array_append(&bbox->uids, &uidmap, 1);
}
failed = FALSE;
mail = mail_alloc(t, MAIL_FETCH_VIRTUAL_SIZE, NULL);
- while (mailbox_search_next(ctx, mail) > 0) {
+ while (mailbox_search_next(ctx, mail)) {
if (mail_get_virtual_size(mail, &size) < 0) {
expunged = mail->expunged;
failed = TRUE;
mail_search_args_unref(&search_args);
mail = mail_alloc(client->trans, 0, NULL);
- while (mailbox_search_next(ctx, mail) > 0) {
+ while (mailbox_search_next(ctx, mail)) {
idx = mail->seq - 1;
bit = 1 << (idx % CHAR_BIT);
if (client->deleted_bitmask != NULL &&
ctx->mail = mail_alloc(client->trans, MAIL_FETCH_STREAM_HEADER |
MAIL_FETCH_STREAM_BODY, NULL);
- if (mailbox_search_next(ctx->search_ctx, ctx->mail) <= 0 ||
+ if (!mailbox_search_next(ctx->search_ctx, ctx->mail) ||
mail_get_stream(ctx->mail, NULL, NULL, &ctx->stream) < 0) {
ret = client_reply_msg_expunged(client, msgnum);
fetch_deinit(ctx);
mail_search_args_unref(&search_args);
mail = mail_alloc(client->trans, 0, NULL);
- while (mailbox_search_next(search_ctx, mail) > 0)
+ while (mailbox_search_next(search_ctx, mail))
mail_update_flags(mail, MODIFY_REMOVE, MAIL_SEEN);
mail_free(&mail);
(void)mailbox_search_deinit(&search_ctx);
tab[0].value = t_strdup_printf("%u", client->uid_validity);
str = t_str_new(128);
- while (mailbox_search_next(ctx->search_ctx, ctx->mail) > 0) {
+ while (mailbox_search_next(ctx->search_ctx, ctx->mail)) {
if (client->deleted) {
uint32_t idx = ctx->mail->seq - 1;
if (client->deleted_bitmask[idx / CHAR_BIT] &