array_append_array(&fields->snapshot_fields, &fields->fields);
}
array_foreach_modifiable(&fields->fields, field)
- field->flags &= ~AUTH_FIELD_FLAG_CHANGED;
+ field->flags &= ENUM_NEGATE(AUTH_FIELD_FLAG_CHANGED);
}
void auth_fields_rollback(struct auth_fields *fields)
{
const char *str;
- switch (type & ~MAIL_CACHE_DECISION_FORCED) {
+ switch (type & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED)) {
case MAIL_CACHE_DECISION_NO:
str = "no";
break;
cmd_mailbox_cache_decision_to_str(enum mail_cache_decision_type decision)
{
string_t *ret = t_str_new(10);
- switch((decision & ~MAIL_CACHE_DECISION_FORCED)) {
+ switch((decision & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED))) {
case MAIL_CACHE_DECISION_NO:
str_append(ret, "no");
break;
}
if (ctx->total_sum &&
- ((ctx->status_items & ~TOTAL_STATUS_ITEMS) != 0 ||
- (ctx->metadata_items & ~TOTAL_METADATA_ITEMS) != 0)) {
+ ((ctx->status_items & ENUM_NEGATE(TOTAL_STATUS_ITEMS)) != 0 ||
+ (ctx->metadata_items & ENUM_NEGATE(TOTAL_METADATA_ITEMS)) != 0)) {
i_fatal_status(EX_USAGE,
"Status field %s can't be used with -t", field);
}
ibc_set.import_commit_msgs_interval = set->import_commit_msgs_interval;
ibc_set.hashed_headers = set->hashed_headers;
/* reverse the backup direction for the slave */
- ibc_set.brain_flags = flags & ~(DSYNC_BRAIN_FLAG_BACKUP_SEND |
- DSYNC_BRAIN_FLAG_BACKUP_RECV);
+ ibc_set.brain_flags = flags & ENUM_NEGATE(DSYNC_BRAIN_FLAG_BACKUP_SEND |
+ DSYNC_BRAIN_FLAG_BACKUP_RECV);
if ((flags & DSYNC_BRAIN_FLAG_BACKUP_SEND) != 0)
ibc_set.brain_flags |= DSYNC_BRAIN_FLAG_BACKUP_RECV;
else if ((flags & DSYNC_BRAIN_FLAG_BACKUP_RECV) != 0)
dsync_serializer_encode_add(encoder, "name", field->name);
memset(decision, 0, sizeof(decision));
- switch (field->decision & ~MAIL_CACHE_DECISION_FORCED) {
+ switch (field->decision & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED)) {
case MAIL_CACHE_DECISION_NO:
decision[0] = 'n';
break;
DSYNC_MAIL_CHANGE_TYPE_FLAG_CHANGE,
&change)) {
change->add_flags |= rec->add_flags;
- change->remove_flags &= ~rec->add_flags;
+ change->remove_flags &= ENUM_NEGATE(rec->add_flags);
change->remove_flags |= rec->remove_flags;
- change->add_flags &= ~rec->remove_flags;
+ change->add_flags &= ENUM_NEGATE(rec->remove_flags);
}
}
}
/* used literals with LOGIN command, just ignore. */
return 0;
}
- imap_client->proxy_sent_state &= ~IMAP_PROXY_SENT_STATE_AUTHENTICATE;
+ imap_client->proxy_sent_state &= ENUM_NEGATE(IMAP_PROXY_SENT_STATE_AUTHENTICATE);
imap_client->proxy_rcvd_state = IMAP_PROXY_RCVD_STATE_AUTH_CONTINUE;
str = t_str_new(128);
o_stream_nsend(output, str_data(str), str_len(str));
return 0;
} else if (str_begins(line, "S ")) {
- imap_client->proxy_sent_state &= ~IMAP_PROXY_SENT_STATE_STARTTLS;
+ imap_client->proxy_sent_state &= ENUM_NEGATE(IMAP_PROXY_SENT_STATE_STARTTLS);
imap_client->proxy_rcvd_state = IMAP_PROXY_RCVD_STATE_STARTTLS;
if (!str_begins(line, "S OK ")) {
return 1;
} else if (str_begins(line, "L OK ")) {
/* Login successful. Send this line to client. */
- imap_client->proxy_sent_state &= ~IMAP_PROXY_SENT_STATE_LOGIN;
+ imap_client->proxy_sent_state &= ENUM_NEGATE(IMAP_PROXY_SENT_STATE_LOGIN);
imap_client->proxy_rcvd_state = IMAP_PROXY_RCVD_STATE_LOGIN;
str = t_str_new(128);
client_send_login_reply(imap_client, str, line + 5);
client_proxy_finish_destroy_client(client);
return 1;
} else if (str_begins(line, "L ")) {
- imap_client->proxy_sent_state &= ~IMAP_PROXY_SENT_STATE_LOGIN;
+ imap_client->proxy_sent_state &= ENUM_NEGATE(IMAP_PROXY_SENT_STATE_LOGIN);
imap_client->proxy_rcvd_state = IMAP_PROXY_RCVD_STATE_LOGIN;
line += 2;
return 0;
} else if (str_begins(line, "C ")) {
/* Reply to CAPABILITY command we sent */
- imap_client->proxy_sent_state &= ~IMAP_PROXY_SENT_STATE_CAPABILITY;
+ imap_client->proxy_sent_state &= ENUM_NEGATE(IMAP_PROXY_SENT_STATE_CAPABILITY);
imap_client->proxy_rcvd_state = IMAP_PROXY_RCVD_STATE_CAPABILITY;
if (str_begins(line, "C OK ") &&
HAS_NO_BITS(imap_client->proxy_sent_state,
/* Reply to ID command we sent, ignore it unless
pipelining is disabled, in which case send
either STARTTLS or login */
- imap_client->proxy_sent_state &= ~IMAP_PROXY_SENT_STATE_ID;
+ imap_client->proxy_sent_state &= ENUM_NEGATE(IMAP_PROXY_SENT_STATE_ID);
imap_client->proxy_rcvd_state = IMAP_PROXY_RCVD_STATE_ID;
if (client->proxy_nopipelining) {
if ((flags & MAILBOX_NONEXISTENT) != 0 && !ctx->used_listext) {
flags |= MAILBOX_NOSELECT;
- flags &= ~MAILBOX_NONEXISTENT;
+ flags &= ENUM_NEGATE(MAILBOX_NONEXISTENT);
}
if ((ctx->list_flags & MAILBOX_LIST_ITER_RETURN_CHILDREN) == 0)
- flags &= ~(MAILBOX_CHILDREN|MAILBOX_NOCHILDREN);
+ flags &= ENUM_NEGATE(MAILBOX_CHILDREN | MAILBOX_NOCHILDREN);
if ((flags & MAILBOX_CHILD_SUBSCRIBED) != 0 &&
(flags & MAILBOX_SUBSCRIBED) == 0 && !ctx->used_listext) {
/* LSUB uses \Noselect for this */
flags |= MAILBOX_NOSELECT;
} else if ((ctx->list_flags & MAILBOX_LIST_ITER_RETURN_SUBSCRIBED) == 0)
- flags &= ~MAILBOX_SUBSCRIBED;
+ flags &= ENUM_NEGATE(MAILBOX_SUBSCRIBED);
imap_mailbox_flags2str(str, flags);
if ((ctx->list_flags & MAILBOX_LIST_ITER_RETURN_SPECIALUSE) != 0 &&
imap_append_quoted(str, ctx->cmd->tag);
str_append_c(str, ']');
client_send_line(client, str_c(str));
- ctx->return_options &= ~SEARCH_RETURN_UPDATE;
+ ctx->return_options &= ENUM_NEGATE(SEARCH_RETURN_UPDATE);
imap_search_context_free(ctx);
return;
}
if (client->notify_immediate_expunges) {
/* NOTIFY enabled without SELECTED-DELAYED */
- flags &= ~MAILBOX_SYNC_FLAG_NO_EXPUNGES;
+ flags &= ENUM_NEGATE(MAILBOX_SYNC_FLAG_NO_EXPUNGES);
}
ctx = i_new(struct imap_sync_context, 1);
}
i_assert(noexpunges_count == 0 || noexpunges_count == count);
if (fast_count != count)
- *flags_r &= ~MAILBOX_SYNC_FLAG_FAST;
+ *flags_r &= ENUM_NEGATE(MAILBOX_SYNC_FLAG_FAST);
i_assert((*flags_r & MAILBOX_SYNC_FLAG_FIX_INCONSISTENT) == 0);
}
if ((dict->flag & CDB_WITH_NULL) != 0) {
ret = cdb_find(&dict->cdb, key, (unsigned)strlen(key)+1);
if (ret > 0)
- dict->flag &= ~CDB_WITHOUT_NULL;
+ dict->flag &= ENUM_NEGATE(CDB_WITHOUT_NULL);
}
/* ...or not */
if (ret == 0 && (dict->flag & CDB_WITHOUT_NULL) != 0) {
ret = cdb_find(&dict->cdb, key, (unsigned)strlen(key));
if (ret > 0)
- dict->flag &= ~CDB_WITH_NULL;
+ dict->flag &= ENUM_NEGATE(CDB_WITH_NULL);
}
if (ret <= 0) {
T_BEGIN {
file = fs->v.file_alloc();
file->fs = fs;
- file->flags = mode_flags & ~FS_OPEN_MODE_MASK;
+ file->flags = mode_flags & ENUM_NEGATE(FS_OPEN_MODE_MASK);
file->event = fs_create_event(fs, event);
event_set_ptr(file->event, FS_EVENT_FIELD_FS, fs);
event_set_ptr(file->event, FS_EVENT_FIELD_FILE, file);
fs->v.file_init(file, path, mode_flags & FS_OPEN_MODE_MASK,
- mode_flags & ~FS_OPEN_MODE_MASK);
+ mode_flags & ENUM_NEGATE(FS_OPEN_MODE_MASK));
} T_END;
fs->files_open_count++;
enum fs_open_flags remove_flags)
{
file->flags |= add_flags;
- file->flags &= ~remove_flags;
+ file->flags &= ENUM_NEGATE(remove_flags);
if (file->parent != NULL)
fs_file_set_flags(file->parent, add_flags, remove_flags);
if (fs->wrap_metadata) {
/* we don't have a quick stat() to see the file's size,
because of the metadata header */
- props &= ~FS_PROPERTY_STAT;
+ props &= ENUM_NEGATE(FS_PROPERTY_STAT);
/* Copying can copy the whole metadata. */
props |= FS_PROPERTY_COPY_METADATA;
}
file->open_mode = mode;
/* avoid unnecessarily creating two seekable streams */
- flags &= ~FS_OPEN_FLAG_SEEKABLE;
+ flags &= ENUM_NEGATE(FS_OPEN_FLAG_SEEKABLE);
file->file.parent = fs_file_init_parent(_file, path, mode | flags);
if (file->fs->wrap_metadata && mode == FS_OPEN_MODE_READONLY &&
const char *mail_cache_decision_to_string(enum mail_cache_decision_type dec)
{
- switch (dec & ~MAIL_CACHE_DECISION_FORCED) {
+ switch (dec & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED)) {
case MAIL_CACHE_DECISION_NO:
return "no";
case MAIL_CACHE_DECISION_TEMP:
static bool field_decision_is_valid(enum mail_cache_decision_type type)
{
- switch (type & ~MAIL_CACHE_DECISION_FORCED) {
+ switch (type & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED)) {
case MAIL_CACHE_DECISION_NO:
case MAIL_CACHE_DECISION_TEMP:
case MAIL_CACHE_DECISION_YES:
/* ignore any forced-flags in the file */
enum mail_cache_decision_type file_dec =
- decisions[i] & ~MAIL_CACHE_DECISION_FORCED;
+ decisions[i] & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED);
if (hash_table_lookup_full(cache->field_name_hash, names,
&orig_key, &orig_value)) {
if ((cur_dec & MAIL_CACHE_DECISION_FORCED) != 0) {
/* Forced decision. If the decision has
changed, update the fields in the file. */
- if ((cur_dec & ~MAIL_CACHE_DECISION_FORCED) != file_dec)
+ if ((cur_dec & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED)) != file_dec)
cache->field_header_write_pending = TRUE;
} else if (cache->fields[fidx].decision_dirty) {
/* Decisions have recently been updated
}
*field_seen = ctx->field_seen_value;
- dec = cache_field->decision & ~MAIL_CACHE_DECISION_FORCED;
+ dec = cache_field->decision & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED);
if (ctx->new_msg) {
if (dec == MAIL_CACHE_DECISION_NO)
return;
priv->field.decision = dec;
/* drop all fields we don't want */
- if ((dec & ~MAIL_CACHE_DECISION_FORCED) == MAIL_CACHE_DECISION_NO) {
+ if ((dec & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED)) == MAIL_CACHE_DECISION_NO) {
priv->used = FALSE;
priv->field.last_used = 0;
}
mail_cache_transaction_refresh_decisions(ctx);
decision = mail_cache_field_get_decision(ctx->view->cache, field_idx);
- decision &= ~MAIL_CACHE_DECISION_FORCED;
+ decision &= ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED);
switch (decision) {
case MAIL_CACHE_DECISION_NO:
return FALSE;
for (seq = 1; seq <= map->hdr.messages_count; seq++) {
rec = MAIL_INDEX_REC_AT_SEQ(map, seq);
- rec->flags &= ~MAIL_RECENT;
+ rec->flags &= ENUM_NEGATE(MAIL_RECENT);
}
}
had_dirty = (map->hdr.flags & MAIL_INDEX_HDR_FLAG_HAVE_DIRTY) != 0;
if (had_dirty)
- map->hdr.flags &= ~MAIL_INDEX_HDR_FLAG_HAVE_DIRTY;
+ map->hdr.flags &= ENUM_NEGATE(MAIL_INDEX_HDR_FLAG_HAVE_DIRTY);
if (map->hdr_base != map->hdr_copy_buf->data) {
/* if syncing updates the header, it updates hdr_copy_buf
if (!locked) {
/* it looks like we have something to sync. lock the file and
check again. */
- flags &= ~MAIL_INDEX_SYNC_FLAG_REQUIRE_CHANGES;
+ flags &= ENUM_NEGATE(MAIL_INDEX_SYNC_FLAG_REQUIRE_CHANGES);
return mail_index_sync_begin_init(index, flags, log_file_seq,
log_file_offset);
}
{
i_assert(sync_rec->type == MAIL_INDEX_SYNC_TYPE_FLAGS);
- *flags = (*flags & ~sync_rec->remove_flags) | sync_rec->add_flags;
+ *flags = (*flags & ENUM_NEGATE(sync_rec->remove_flags)) | sync_rec->add_flags;
}
bool mail_index_sync_keywords_apply(const struct mail_index_sync_rec *sync_rec,
updates[idx].add_flags =
(updates[idx].add_flags | u.add_flags) &
- ~u.remove_flags;
+ ENUM_NEGATE(u.remove_flags);
updates[idx].remove_flags =
(updates[idx].remove_flags | u.remove_flags) &
- ~u.add_flags;
+ ENUM_NEGATE(u.add_flags);
u.uid1 = updates[idx].uid2 + 1;
if (updates[idx].add_flags == 0 &&
rec->flags |= flags;
break;
case MODIFY_REMOVE:
- rec->flags &= ~flags;
+ rec->flags &= ENUM_NEGATE(flags);
break;
}
}
switch (modify_type) {
case MODIFY_REPLACE:
u.add_flags = flags;
- u.remove_flags = ~flags & MAIL_INDEX_FLAGS_MASK;
+ u.remove_flags = ENUM_NEGATE(flags) & MAIL_INDEX_FLAGS_MASK;
break;
case MODIFY_ADD:
if (flags == 0)
/* remove fsck'd-flag if it exists. */
if ((new_hdr.flags & MAIL_INDEX_HDR_FLAG_FSCKD) != 0) {
- new_hdr.flags &= ~MAIL_INDEX_HDR_FLAG_FSCKD;
+ new_hdr.flags &= ENUM_NEGATE(MAIL_INDEX_HDR_FLAG_FSCKD);
mail_index_update_header(t,
offsetof(struct mail_index_header, flags),
&new_hdr.flags, sizeof(new_hdr.flags), FALSE);
trec = PTR_OFFSET(tview->recs, (seq-1) * tview->record_size);
memcpy(trec, rec, map->hdr.record_size);
trec->flags |= updates[idx].add_flags;
- trec->flags &= ~updates[idx].remove_flags;
+ trec->flags &= ENUM_NEGATE(updates[idx].remove_flags);
return trec;
}
i_zero(&flag_update);
flag_update.uid1 = flag_update.uid2 = new_rec->uid;
flag_update.add_flags = new_rec->flags;
- flag_update.remove_flags = ~new_rec->flags & 0xff;
+ flag_update.remove_flags = ENUM_NEGATE(new_rec->flags) & 0xff;
if (mail_index_sync_record(&ctx->sync_map_ctx, &thdr,
&flag_update) < 0)
return -1;
file->filepath, "fcntl(F_GETFL)");
return;
}
- if (fcntl(file->fd, F_SETFL, flags & ~O_APPEND) < 0) {
+ if (fcntl(file->fd, F_SETFL, flags & ENUM_NEGATE(O_APPEND)) < 0) {
mail_index_file_set_syscall_error(file->log->index,
file->filepath, "fcntl(F_SETFL)");
return;
"expunge record missing protection mask");
return FALSE;
}
- rec_type &= ~MAIL_TRANSACTION_EXPUNGE_PROT;
+ rec_type &= ENUM_NEGATE(MAIL_TRANSACTION_EXPUNGE_PROT);
}
if ((hdr->type & MAIL_TRANSACTION_EXPUNGE_GUID) != 0) {
if (rec_type != (MAIL_TRANSACTION_EXPUNGE_GUID |
"expunge guid record missing protection mask");
return FALSE;
}
- rec_type &= ~MAIL_TRANSACTION_EXPUNGE_PROT;
+ rec_type &= ENUM_NEGATE(MAIL_TRANSACTION_EXPUNGE_PROT);
}
if (rec_size == 0) {
(MAIL_TRANSACTION_EXPUNGE | MAIL_TRANSACTION_EXPUNGE_PROT) ||
(hdr->type & MAIL_TRANSACTION_TYPE_MASK) ==
(MAIL_TRANSACTION_EXPUNGE_GUID | MAIL_TRANSACTION_EXPUNGE_PROT))
- view->tmp_hdr.type = hdr->type & ~MAIL_TRANSACTION_EXPUNGE_PROT;
+ view->tmp_hdr.type = hdr->type & ENUM_NEGATE(MAIL_TRANSACTION_EXPUNGE_PROT);
else
view->tmp_hdr.type = hdr->type;
for (i = 0; i < N_ELEMENTS(cache_fields); i++) {
const char *value = t_strdup_printf("%s-value",
cache_fields[i].name);
- if ((cache_fields[i].decision & ~MAIL_CACHE_DECISION_FORCED) !=
+ if ((cache_fields[i].decision & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED)) !=
MAIL_CACHE_DECISION_NO) {
mail_cache_add(cache_trans, 1, cache_fields[i].idx,
value, strlen(value));
case 1:
modify_type = MODIFY_REMOVE;
for (seq = seq1; seq <= seq2; seq++)
- flags[seq] &= ~change;
+ flags[seq] &= ENUM_NEGATE(change);
break;
case 2:
modify_type = MODIFY_REPLACE;
if (set)
ctx->flags |= MESSAGE_DECODER_FLAG_RETURN_BINARY;
else
- ctx->flags &= ~MESSAGE_DECODER_FLAG_RETURN_BINARY;
+ ctx->flags &= ENUM_NEGATE(MESSAGE_DECODER_FLAG_RETURN_BINARY);
message_decode_body_init_charset(ctx, ctx->prev_part);
}
parse_next_body_multipart_init(ctx);
ctx->multipart = TRUE;
} else {
- part->flags &= ~MESSAGE_PART_FLAG_MULTIPART;
+ part->flags &= ENUM_NEGATE(MESSAGE_PART_FLAG_MULTIPART);
}
}
!parse_too_many_nested_mime_parts(ctx)) {
ctx->parse_next_block = parse_next_body_message_rfc822_init;
} else {
- part->flags &= ~MESSAGE_PART_FLAG_MESSAGE_RFC822;
+ part->flags &= ENUM_NEGATE(MESSAGE_PART_FLAG_MESSAGE_RFC822);
if (ctx->boundaries != NULL)
ctx->parse_next_block = parse_next_body_to_boundary;
else
struct ostream *output)
{
conn->ssl_secured = TRUE;
- conn->set.capabilities &= ~SMTP_CAPABILITY_STARTTLS;
+ conn->set.capabilities &= ENUM_NEGATE(SMTP_CAPABILITY_STARTTLS);
smtp_server_connection_set_streams(conn, input, output);
}
}
conn->ssl_secured = TRUE;
- conn->set.capabilities &= ~SMTP_CAPABILITY_STARTTLS;
+ conn->set.capabilities &= ENUM_NEGATE(SMTP_CAPABILITY_STARTTLS);
if (conn->ssl_start)
smtp_server_connection_ready(conn);
conn->ssl_start = ssl_start;
if (ssl_start)
- conn->set.capabilities &= ~SMTP_CAPABILITY_STARTTLS;
+ conn->set.capabilities &= ENUM_NEGATE(SMTP_CAPABILITY_STARTTLS);
/* Halt input until started */
smtp_server_connection_halt(conn);
i_assert(conn->username == NULL);
i_assert(conn->helo_domain == NULL);
- conn->set.capabilities &= ~SMTP_CAPABILITY_STARTTLS;
+ conn->set.capabilities &= ENUM_NEGATE(SMTP_CAPABILITY_STARTTLS);
conn->username = i_strdup(username);
if (helo != NULL && *helo != '\0') {
conn->helo_domain = i_strdup(helo);
const char **error_r)
{
unsigned long ssl_ops = SSL_OP_NO_SSLv2 |
- (SSL_OP_ALL & ~SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
+ (SSL_OP_ALL & ENUM_NEGATE(SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS));
ctx->pool = pool_alloconly_create("ssl iostream context", 4096);
return -1;
/* add to index */
- save_flags = _ctx->data.flags & ~MAIL_RECENT;
+ save_flags = _ctx->data.flags & ENUM_NEGATE(MAIL_RECENT);
mail_index_append(ctx->trans, 0, &ctx->seq);
mail_index_update_flags(ctx->trans, ctx->seq, MODIFY_REPLACE,
save_flags);
pool_t pool;
/* cydir can't work without index files */
- flags &= ~MAILBOX_FLAG_NO_INDEX_FILES;
+ flags &= ENUM_NEGATE(MAILBOX_FLAG_NO_INDEX_FILES);
pool = pool_alloconly_create("cydir mailbox", 1024*3);
mbox = p_new(pool, struct cydir_mailbox, 1);
struct mail_save_data *mdata = &ctx->ctx.data;
enum mail_flags save_flags;
- save_flags = mdata->flags & ~MAIL_RECENT;
+ save_flags = mdata->flags & ENUM_NEGATE(MAIL_RECENT);
mail_index_append(ctx->trans, mdata->uid, &ctx->seq);
mail_index_update_flags(ctx->trans, ctx->seq, MODIFY_REPLACE,
save_flags);
{
if ((flags & DBOX_INDEX_FLAG_ALT) != 0) {
mdbox_purge_alt_flag_change(mail, modify_type != MODIFY_REMOVE);
- flags &= ~DBOX_INDEX_FLAG_ALT;
+ flags &= ENUM_NEGATE(DBOX_INDEX_FLAG_ALT);
if (flags == 0 && modify_type != MODIFY_REPLACE)
return;
}
pool_t pool;
/* dbox can't work without index files */
- flags &= ~MAILBOX_FLAG_NO_INDEX_FILES;
+ flags &= ENUM_NEGATE(MAILBOX_FLAG_NO_INDEX_FILES);
pool = pool_alloconly_create("mdbox mailbox", 1024*3);
mbox = p_new(pool, struct mdbox_mailbox, 1);
src_file = sdbox_file_init(src_mbox, mail->uid);
dest_file = sdbox_file_init(dest_mbox, 0);
- ctx->ctx.data.flags &= ~DBOX_INDEX_FLAG_ALT;
+ ctx->ctx.data.flags &= ENUM_NEGATE(DBOX_INDEX_FLAG_ALT);
src_path = src_file->primary_path;
dest_path = dest_file->primary_path;
pool_t pool;
/* dbox can't work without index files */
- flags &= ~MAILBOX_FLAG_NO_INDEX_FILES;
+ flags &= ENUM_NEGATE(MAILBOX_FLAG_NO_INDEX_FILES);
pool = pool_alloconly_create("sdbox mailbox", 1024*3);
mbox = p_new(pool, struct sdbox_mailbox, 1);
else {
/* LSUB \Noselect means that the mailbox isn't
subscribed, but it has children that are */
- node->flags &= ~MAILBOX_NOSELECT;
+ node->flags &= ENUM_NEGATE(MAILBOX_NOSELECT);
}
}
}
_mail->mail_stream_opened = TRUE;
/* drop any fields that we may already be fetching currently */
- fields &= ~mail->fetching_fields;
+ fields &= ENUM_NEGATE(mail->fetching_fields);
if (headers_have_subset(mail->fetching_headers, headers))
headers = NULL;
if (fields == 0 && headers == NULL)
if ((fields & MAIL_FETCH_RECEIVED_DATE) != 0) {
if (imail->imail.data.received_date == (time_t)-1)
return FALSE;
- fields &= ~MAIL_FETCH_RECEIVED_DATE;
+ fields &= ENUM_NEGATE(MAIL_FETCH_RECEIVED_DATE);
}
if ((fields & MAIL_FETCH_SAVE_DATE) != 0) {
i_assert(HAS_ALL_BITS(mbox->capabilities,
IMAPC_CAPABILITY_SAVEDATE));
if (imail->imail.data.save_date == (time_t)-1)
return FALSE;
- fields &= ~MAIL_FETCH_SAVE_DATE;
+ fields &= ENUM_NEGATE(MAIL_FETCH_SAVE_DATE);
}
if ((fields & (MAIL_FETCH_PHYSICAL_SIZE | MAIL_FETCH_VIRTUAL_SIZE)) != 0) {
if (imail->imail.data.physical_size == UOFF_T_MAX)
return FALSE;
- fields &= ~(MAIL_FETCH_PHYSICAL_SIZE | MAIL_FETCH_VIRTUAL_SIZE);
+ fields &= ENUM_NEGATE(MAIL_FETCH_PHYSICAL_SIZE | MAIL_FETCH_VIRTUAL_SIZE);
}
if ((fields & MAIL_FETCH_GUID) != 0) {
if (imail->imail.data.guid == NULL)
return FALSE;
- fields &= ~MAIL_FETCH_GUID;
+ fields &= ENUM_NEGATE(MAIL_FETCH_GUID);
}
if ((fields & MAIL_FETCH_IMAP_BODY) != 0) {
if (imail->imail.data.body == NULL)
return FALSE;
- fields &= ~MAIL_FETCH_IMAP_BODY;
+ fields &= ENUM_NEGATE(MAIL_FETCH_IMAP_BODY);
}
if ((fields & MAIL_FETCH_IMAP_BODYSTRUCTURE) != 0) {
if (imail->imail.data.bodystructure == NULL)
return FALSE;
- fields &= ~MAIL_FETCH_IMAP_BODYSTRUCTURE;
+ fields &= ENUM_NEGATE(MAIL_FETCH_IMAP_BODYSTRUCTURE);
}
if ((fields & (MAIL_FETCH_STREAM_HEADER |
MAIL_FETCH_STREAM_BODY)) != 0) {
if (imail->imail.data.stream == NULL)
return FALSE;
- fields &= ~(MAIL_FETCH_STREAM_HEADER | MAIL_FETCH_STREAM_BODY);
+ fields &= ENUM_NEGATE(MAIL_FETCH_STREAM_HEADER | MAIL_FETCH_STREAM_BODY);
}
i_assert(fields == 0);
return TRUE;
}
/* FIXME: we should ideally also pass these through so they show up
to clients. */
- flags &= ~MAIL_RECENT;
+ flags &= ENUM_NEGATE(MAIL_RECENT);
/* if this is a reply to some FETCH request, update the mail's fields */
array_foreach(&mbox->fetch_requests, fetch_requestp) {
string_t *str = t_str_new(64);
str_append(str, " (");
- imap_write_flags(str, mdata->flags & ~MAIL_RECENT, NULL);
+ imap_write_flags(str, mdata->flags & ENUM_NEGATE(MAIL_RECENT),
+ NULL);
if (mdata->keywords != NULL)
imapc_append_keywords(str, mdata->keywords);
str_append_c(str, ')');
/* a bit ugly way to do this, but better than nothing for now.
FIXME: if indexes are enabled, keep this there. */
mail_generate_guid_128_hash(box->name, metadata_r->guid);
- items &= ~MAILBOX_METADATA_GUID;
+ items &= ENUM_NEGATE(MAILBOX_METADATA_GUID);
}
if ((items & MAILBOX_METADATA_BACKEND_NAMESPACE) != 0) {
if (imapc_mailbox_get_namespaces(mbox) < 0)
metadata_r->backend_ns_prefix = ns->prefix;
metadata_r->backend_ns_type = ns->type;
}
- items &= ~MAILBOX_METADATA_BACKEND_NAMESPACE;
+ items &= ENUM_NEGATE(MAILBOX_METADATA_BACKEND_NAMESPACE);
}
if (items != 0) {
if (index_mailbox_get_metadata(box, items, metadata_r) < 0)
if (index_mail_stream_check_failure(mail) < 0)
return -1;
data->hdr_size_set = TRUE;
- data->access_part &= ~PARSE_HDR;
+ data->access_part &= ENUM_NEGATE(PARSE_HDR);
return 0;
}
if (index_mail_get_pvt(_mail)) {
/* mailbox has private flags */
pvt_flags_mask = mailbox_get_private_flags_mask(_mail->box);
- flags &= ~pvt_flags_mask;
+ flags &= ENUM_NEGATE(pvt_flags_mask);
rec = mail_index_lookup(_mail->transaction->view_pvt,
mail->seq_pvt);
flags |= rec->flags & pvt_flags_mask;
/* cache flags should never get unset as long as the message doesn't
change, but try to handle it anyway */
- cache_flags &= ~(MAIL_CACHE_FLAG_BINARY_HEADER |
- MAIL_CACHE_FLAG_BINARY_BODY |
- MAIL_CACHE_FLAG_HAS_NULS |
- MAIL_CACHE_FLAG_HAS_NO_NULS);
+ cache_flags &= ENUM_NEGATE(MAIL_CACHE_FLAG_BINARY_HEADER |
+ MAIL_CACHE_FLAG_BINARY_BODY |
+ MAIL_CACHE_FLAG_HAS_NULS |
+ MAIL_CACHE_FLAG_HAS_NO_NULS);
if (message_parts_have_nuls(data->parts)) {
_mail->has_nuls = TRUE;
_mail->has_no_nuls = FALSE;
/* mailbox has private flags */
pvt_flags_mask = mailbox_get_private_flags_mask(_mail->box);
pvt_flags = flags & pvt_flags_mask;
- flags &= ~pvt_flags_mask;
+ flags &= ENUM_NEGATE(pvt_flags_mask);
if (index_mail_update_pvt_flags(_mail, modify_type, pvt_flags)) {
mail_index_update_flags(_mail->transaction->itrans_pvt,
mail->seq_pvt,
case SEARCH_FLAGS:
/* recent flag shouldn't be set, but indexes from v1.0.x
may contain it. */
- flags = rec->flags & ~MAIL_RECENT;
+ flags = rec->flags & ENUM_NEGATE(MAIL_RECENT);
if ((arg->value.flags & MAIL_RECENT) != 0 &&
mailbox_recent_flags_have_uid(ctx->box, rec->uid))
flags |= MAIL_RECENT;
no private flags */
} else {
pvt_flags_mask = mailbox_get_private_flags_mask(ctx->box);
- flags &= ~pvt_flags_mask;
+ flags &= ENUM_NEGATE(pvt_flags_mask);
if (index_search_get_pvt(ctx, rec->uid)) {
rec = mail_index_lookup(ctx->mail_ctx.transaction->view_pvt,
ctx->pvt_seq);
cache_fields = t_new(ARRAY_TYPE(mailbox_cache_field), 1);
t_array_init(cache_fields, count);
for (i = 0; i < count; i++) {
- dec = fields[i].decision & ~MAIL_CACHE_DECISION_FORCED;
+ dec = fields[i].decision & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED);
if (dec != MAIL_CACHE_DECISION_NO) {
cf = array_append_space(cache_fields);
cf->name = fields[i].name;
metadata_r->backend_ns_prefix = "";
metadata_r->backend_ns_type =
mailbox_list_get_namespace(box->list)->type;
- items &= ~MAILBOX_METADATA_BACKEND_NAMESPACE;
+ items &= ENUM_NEGATE(MAILBOX_METADATA_BACKEND_NAMESPACE);
}
if (items == 0)
return 0;
index_flags = ibox->index_flags;
if (move_to_memory)
- index_flags &= ~MAIL_INDEX_OPEN_FLAG_CREATE;
+ index_flags &= ENUM_NEGATE(MAIL_INDEX_OPEN_FLAG_CREATE);
if (index_storage_mailbox_alloc_index(box) < 0)
return -1;
dest_field = mail_cache_register_get_field(dest_trans->box->cache,
dest_field_idx);
if ((dest_field->decision &
- ~MAIL_CACHE_DECISION_FORCED) == MAIL_CACHE_DECISION_NO) {
+ ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED)) == MAIL_CACHE_DECISION_NO) {
/* field not wanted in destination mailbox */
return;
}
if ((flags_left & MAIL_DRAFT) != 0 && nextflag > 'D') {
str_append_c(flags_str, 'D');
- flags_left &= ~MAIL_DRAFT;
+ flags_left &= ENUM_NEGATE(MAIL_DRAFT);
}
if ((flags_left & MAIL_FLAGGED) != 0 && nextflag > 'F') {
str_append_c(flags_str, 'F');
- flags_left &= ~MAIL_FLAGGED;
+ flags_left &= ENUM_NEGATE(MAIL_FLAGGED);
}
if ((flags_left & MAIL_ANSWERED) != 0 && nextflag > 'R') {
str_append_c(flags_str, 'R');
- flags_left &= ~MAIL_ANSWERED;
+ flags_left &= ENUM_NEGATE(MAIL_ANSWERED);
}
if ((flags_left & MAIL_SEEN) != 0 && nextflag > 'S') {
str_append_c(flags_str, 'S');
- flags_left &= ~MAIL_SEEN;
+ flags_left &= ENUM_NEGATE(MAIL_SEEN);
}
if ((flags_left & MAIL_DELETED) != 0 && nextflag > 'T') {
str_append_c(flags_str, 'T');
- flags_left &= ~MAIL_DELETED;
+ flags_left &= ENUM_NEGATE(MAIL_DELETED);
}
if (keywords != NULL && array_is_created(keywords) &&
MAIL_FETCH_VIRTUAL_SIZE;
if (mail->data.wanted_headers != NULL ||
- (mail->data.wanted_fields & ~allowed_pop3_fields) != 0)
+ (mail->data.wanted_fields & ENUM_NEGATE(allowed_pop3_fields)) != 0)
not_pop3_only = TRUE;
/* get vsize decisions */
if (not_pop3_only) {
vsize_dec = mail_cache_field_get_decision(box->cache,
vsize_idx);
- vsize_dec &= ~MAIL_CACHE_DECISION_FORCED;
+ vsize_dec &= ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED);
} else {
/* also check if there are any non-[pv]size cached fields */
vsize_dec = MAIL_CACHE_DECISION_NO;
pool_datastack_create(),
&count);
for (i = 0; i < count; i++) {
- dec = fields[i].decision & ~MAIL_CACHE_DECISION_FORCED;
+ dec = fields[i].decision & ENUM_NEGATE(MAIL_CACHE_DECISION_FORCED);
if (fields[i].idx == vsize_idx)
vsize_dec = dec;
else if (dec != MAIL_CACHE_DECISION_NO &&
/* insert into index */
mail_index_append(ctx->trans, mdata->uid, &ctx->seq);
mail_index_update_flags(ctx->trans, ctx->seq,
- MODIFY_REPLACE, mdata->flags & ~MAIL_RECENT);
+ MODIFY_REPLACE,
+ mdata->flags & ENUM_NEGATE(MAIL_RECENT));
if (mdata->keywords != NULL) {
mail_index_update_keywords(ctx->trans, ctx->seq,
MODIFY_REPLACE, mdata->keywords);
sync_flags = index_storage_get_sync_flags(&mbox->box);
/* don't drop recent messages if we're saving messages */
if (maildir_sync_ctx == NULL)
- sync_flags &= ~MAIL_INDEX_SYNC_FLAG_DROP_RECENT;
+ sync_flags &= ENUM_NEGATE(MAIL_INDEX_SYNC_FLAG_DROP_RECENT);
if (index_storage_expunged_sync_begin(_box, &sync_ctx, &view,
&trans, sync_flags) < 0)
/* the private flags are kept only in indexes. don't use them
at all even for newly seen mails */
- ctx->flags &= ~private_flags_mask;
+ ctx->flags &= ENUM_NEGATE(private_flags_mask);
again:
seq++;
recs[i]->flags |= MAILDIR_UIDLIST_REC_FLAG_NONSYNCED;
} else {
for (i = 0; i < count; i++)
- recs[i]->flags &= ~MAILDIR_UIDLIST_REC_FLAG_NONSYNCED;
+ recs[i]->flags &= ENUM_NEGATE(MAILDIR_UIDLIST_REC_FLAG_NONSYNCED);
}
}
}
}
- rec->flags &= ~MAILDIR_UIDLIST_REC_FLAG_NEW_DIR;
+ rec->flags &= ENUM_NEGATE(MAILDIR_UIDLIST_REC_FLAG_NEW_DIR);
rec->flags = (rec->flags | flags) &
- ~MAILDIR_UIDLIST_REC_FLAG_NONSYNCED;
+ ENUM_NEGATE(MAILDIR_UIDLIST_REC_FLAG_NONSYNCED);
ctx->finished = FALSE;
*rec_r = rec;
/* probably was in new/ and now we're seeing it in cur/.
remove new/moved flags so if this happens again we'll know
to check for duplicates. */
- rec->flags &= ~(MAILDIR_UIDLIST_REC_FLAG_NEW_DIR |
- MAILDIR_UIDLIST_REC_FLAG_MOVED);
+ rec->flags &= ENUM_NEGATE(MAILDIR_UIDLIST_REC_FLAG_NEW_DIR |
+ MAILDIR_UIDLIST_REC_FLAG_MOVED);
if (strcmp(rec->filename, filename) != 0)
rec->filename = p_strdup(ctx->record_pool, filename);
} else {
uidlist->next_uid = uid + 1;
}
- rec->flags = (rec->flags | flags) & ~MAILDIR_UIDLIST_REC_FLAG_NONSYNCED;
+ rec->flags = (rec->flags | flags) & ENUM_NEGATE(MAILDIR_UIDLIST_REC_FLAG_NONSYNCED);
*rec_r = rec;
return 1;
}
if (rec == NULL)
return;
- rec->flags &= ~MAILDIR_UIDLIST_REC_FLAG_NONSYNCED;
+ rec->flags &= ENUM_NEGATE(MAILDIR_UIDLIST_REC_FLAG_NONSYNCED);
if (strcmp(rec->filename, filename) != 0)
rec->filename = p_strdup(uidlist->record_pool, filename);
}
i_assert(recs[dest]->uid == (uint32_t)-1);
i_assert(ctx->uidlist->next_uid < (uint32_t)-1);
recs[dest]->uid = ctx->uidlist->next_uid++;
- recs[dest]->flags &= ~MAILDIR_UIDLIST_REC_FLAG_MOVED;
+ recs[dest]->flags &= ENUM_NEGATE(MAILDIR_UIDLIST_REC_FLAG_MOVED);
}
if (ctx->uidlist->locked_refresh && ctx->uidlist->initial_read)
mail_index_append(ctx->trans, ctx->next_uid, &ctx->seq);
mail_index_update_flags(ctx->trans, ctx->seq, MODIFY_REPLACE,
- save_flags & ~MAIL_RECENT);
+ save_flags & ENUM_NEGATE(MAIL_RECENT));
if (mdata->keywords != NULL) {
mail_index_update_keywords(ctx->trans, ctx->seq,
MODIFY_REPLACE,
i_assert(ctx->mail.uid != 0 || ctx->mail.pseudo);
if (!ctx->sync_ctx->keep_recent)
- ctx->mail.flags &= ~MAIL_RECENT;
+ ctx->mail.flags &= ENUM_NEGATE(MAIL_RECENT);
mbox_sync_update_status(ctx);
mbox_sync_update_xstatus(ctx);
(ctx->mail.flags & STATUS_FLAGS_MASK) !=
(mail->flags & STATUS_FLAGS_MASK) ||
(ctx->mail.flags & MAIL_RECENT) != 0) {
- ctx->mail.flags = (ctx->mail.flags & ~STATUS_FLAGS_MASK) |
+ ctx->mail.flags = (ctx->mail.flags & ENUM_NEGATE(STATUS_FLAGS_MASK)) |
(mail->flags & STATUS_FLAGS_MASK);
if (!ctx->sync_ctx->keep_recent)
- ctx->mail.flags &= ~MAIL_RECENT;
+ ctx->mail.flags &= ENUM_NEGATE(MAIL_RECENT);
mbox_sync_update_status(ctx);
}
if (mail->xstatus_broken ||
(ctx->mail.flags & XSTATUS_FLAGS_MASK) !=
(mail->flags & XSTATUS_FLAGS_MASK)) {
- ctx->mail.flags = (ctx->mail.flags & ~XSTATUS_FLAGS_MASK) |
+ ctx->mail.flags = (ctx->mail.flags & ENUM_NEGATE(XSTATUS_FLAGS_MASK)) |
(mail->flags & XSTATUS_FLAGS_MASK);
mbox_sync_update_xstatus(ctx);
}
/* default to undirtying the message. it gets added back if
flags/keywords don't match what is in the index. */
- mail_ctx->mail.flags &= ~MAIL_INDEX_MAIL_FLAG_DIRTY;
+ mail_ctx->mail.flags &= ENUM_NEGATE(MAIL_INDEX_MAIL_FLAG_DIRTY);
/* replace flags */
idx_flags = rec->flags & MAIL_FLAGS_NONRECENT;
ARRAY_TYPE(keyword_indexes) idx_keywords;
uint8_t mbox_flags;
- mbox_flags = mail->flags & ~MAIL_RECENT;
+ mbox_flags = mail->flags & ENUM_NEGATE(MAIL_RECENT);
if (!sync_ctx->delay_writes) {
/* changes are written to the mbox file */
- mbox_flags &= ~MAIL_INDEX_MAIL_FLAG_DIRTY;
+ mbox_flags &= ENUM_NEGATE(MAIL_INDEX_MAIL_FLAG_DIRTY);
} else if (mail_ctx->need_rewrite) {
/* make sure this message gets written later */
mbox_flags |= MAIL_INDEX_MAIL_FLAG_DIRTY;
/* a bit ugly way to do this, but better than nothing for now.
FIXME: if indexes are enabled, keep this there. */
mail_generate_guid_128_hash(box->name, metadata_r->guid);
- items &= ~MAILBOX_METADATA_GUID;
+ items &= ENUM_NEGATE(MAILBOX_METADATA_GUID);
}
if (items != 0) {
if (index_mailbox_get_metadata(box, items, metadata_r) < 0)
ns = mail_namespaces_init_empty(user);
/* raw storage doesn't have INBOX. We especially don't want LIST to
return INBOX. */
- ns->flags &= ~NAMESPACE_FLAG_INBOX_USER;
+ ns->flags &= ENUM_NEGATE(NAMESPACE_FLAG_INBOX_USER);
ns->flags |= NAMESPACE_FLAG_NOQUOTA | NAMESPACE_FLAG_NOACL;
ns->set = ns_set;
/* absolute paths are ok with raw storage */
if (strcmp(d->d_name, ctx->ctx.list->set.maildir_name) == 0) {
/* mail storage's internal directory (e.g. dbox-Mails).
this also means that the parent is selectable */
- dir->info_flags &= ~MAILBOX_NOSELECT;
+ dir->info_flags &= ENUM_NEGATE(MAILBOX_NOSELECT);
dir->info_flags |= MAILBOX_SELECT;
return 0;
}
return 0;
/* mailbox exists - make sure parent knows it has children */
- dir->info_flags &= ~(MAILBOX_NOCHILDREN | MAILBOX_NOINFERIORS);
+ dir->info_flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN | MAILBOX_NOINFERIORS);
dir->info_flags |= MAILBOX_CHILDREN;
if (match != IMAP_MATCH_YES && (match & IMAP_MATCH_CHILDREN) == 0) {
static void inbox_flags_set(struct fs_list_iterate_context *ctx)
{
/* INBOX is always selectable */
- ctx->info.flags &= ~(MAILBOX_NOSELECT | MAILBOX_NONEXISTENT);
+ ctx->info.flags &= ENUM_NEGATE(MAILBOX_NOSELECT | MAILBOX_NONEXISTENT);
if (mail_namespace_is_inbox_noinferiors(ctx->info.ns)) {
- ctx->info.flags &= ~(MAILBOX_CHILDREN|MAILBOX_NOCHILDREN);
+ ctx->info.flags &= ENUM_NEGATE(MAILBOX_CHILDREN | MAILBOX_NOCHILDREN);
ctx->info.flags |= MAILBOX_NOINFERIORS;
}
}
/* although it could be selected with this name,
it would be confusing for clients to see the same
mails in both INBOX and <ns prefix>/INBOX. */
- ctx->info.flags &= ~MAILBOX_SELECT;
+ ctx->info.flags &= ENUM_NEGATE(MAILBOX_SELECT);
ctx->info.flags |= MAILBOX_NOSELECT;
} else if ((ns->flags & NAMESPACE_FLAG_INBOX_ANY) != 0 &&
list_file_is_any_inbox(ctx, storage_name)) {
return 0;
}
/* shared/user/INBOX */
- ctx->info.flags &= ~(MAILBOX_NOSELECT | MAILBOX_NONEXISTENT);
+ ctx->info.flags &= ENUM_NEGATE(MAILBOX_NOSELECT | MAILBOX_NONEXISTENT);
ctx->info.flags |= MAILBOX_SELECT;
ctx->inbox_found = TRUE;
}
i_assert(guid_128_is_empty(rec.guid));
/* make it selectable */
- node->flags &= ~(MAILBOX_LIST_INDEX_FLAG_NONEXISTENT |
- MAILBOX_LIST_INDEX_FLAG_NOSELECT |
- MAILBOX_LIST_INDEX_FLAG_NOINFERIORS);
+ node->flags &= ENUM_NEGATE(MAILBOX_LIST_INDEX_FLAG_NONEXISTENT |
+ MAILBOX_LIST_INDEX_FLAG_NOSELECT |
+ MAILBOX_LIST_INDEX_FLAG_NOINFERIORS);
mail_index_update_flags(sync_ctx->trans, seq, MODIFY_REPLACE,
(enum mail_flags)node->flags);
if ((newnode->flags & MAILBOX_LIST_INDEX_FLAG_CORRUPTED_NAME) != 0) {
/* mailbox is renamed - clear away the corruption flag so the
new name will be written to the mailbox index header. */
- newnode->flags &= ~MAILBOX_LIST_INDEX_FLAG_CORRUPTED_NAME;
+ newnode->flags &= ENUM_NEGATE(MAILBOX_LIST_INDEX_FLAG_CORRUPTED_NAME);
mail_index_update_flags(sync_ctx->trans, oldseq, MODIFY_REMOVE,
(enum mail_flags)MAILBOX_LIST_INDEX_FLAG_CORRUPTED_NAME);
}
/* listing INBOX itself */
ctx->info.vname = "INBOX";
if (mail_namespace_is_inbox_noinferiors(ctx->info.ns)) {
- ctx->info.flags &= ~(MAILBOX_CHILDREN|MAILBOX_NOCHILDREN);
+ ctx->info.flags &= ENUM_NEGATE(MAILBOX_CHILDREN |
+ MAILBOX_NOCHILDREN);
ctx->info.flags |= MAILBOX_NOINFERIORS;
}
} else {
{
struct index_list_mailbox *ibox = INDEX_LIST_STORAGE_CONTEXT(box);
- if ((items & ~CACHED_STATUS_ITEMS) == 0 && !box->opened) {
+ if ((items & ENUM_NEGATE(CACHED_STATUS_ITEMS)) == 0 && !box->opened) {
if (index_list_get_cached_status(box, items, status_r) > 0)
return 0;
/* nonsynced / error, fallback to doing it the slow way */
}
/* see if we have a chance of fulfilling this without opening
the mailbox. */
- noncached_items = items & ~(MAILBOX_METADATA_GUID |
- MAILBOX_METADATA_VIRTUAL_SIZE |
- MAILBOX_METADATA_FIRST_SAVE_DATE);
+ noncached_items = items & ENUM_NEGATE(MAILBOX_METADATA_GUID |
+ MAILBOX_METADATA_VIRTUAL_SIZE |
+ MAILBOX_METADATA_FIRST_SAVE_DATE);
if ((noncached_items & MAILBOX_METADATA_PHYSICAL_SIZE) != 0 &&
box->mail_vfuncs->get_physical_size ==
box->mail_vfuncs->get_virtual_size)
- noncached_items = items & ~MAILBOX_METADATA_PHYSICAL_SIZE;
+ noncached_items = items & ENUM_NEGATE(MAILBOX_METADATA_PHYSICAL_SIZE);
if (noncached_items != 0)
return 0;
if (node->children != NULL)
mailbox_list_index_node_clear_exists(node->children);
- node->flags &= ~MAILBOX_LIST_INDEX_FLAG_SYNC_EXISTS;
+ node->flags &= ENUM_NEGATE(MAILBOX_LIST_INDEX_FLAG_SYNC_EXISTS);
node = node->next;
}
}
if (!ilist->has_backing_store && !guid_128_is_empty(irec->guid) &&
(rec->flags & (MAILBOX_LIST_INDEX_FLAG_NONEXISTENT |
MAILBOX_LIST_INDEX_FLAG_NOSELECT)) != 0) {
- node->flags &= ~(MAILBOX_LIST_INDEX_FLAG_NONEXISTENT |
- MAILBOX_LIST_INDEX_FLAG_NOSELECT);
+ node->flags &= ENUM_NEGATE(MAILBOX_LIST_INDEX_FLAG_NONEXISTENT | MAILBOX_LIST_INDEX_FLAG_NOSELECT);
*error_r = t_strdup_printf(
"non-selectable mailbox '%s' (uid=%u) already has GUID - "
"marking it selectable", node->name, node->uid);
ns->prefix[5] == mail_namespace_get_sep(ns)) {
/* prefix=INBOX/ (or prefix=INBOX/something/) namespace exists.
so we can create children to INBOX. */
- ctx->inbox_info.flags &= ~MAILBOX_NOINFERIORS;
+ ctx->inbox_info.flags &= ENUM_NEGATE(MAILBOX_NOINFERIORS);
}
if (ns->prefix_len == 0 || !mailbox_list_ns_prefix_match(ctx, ns))
info->vname[5] == mail_namespace_get_sep(info->ns)) {
/* we know now that INBOX has children */
ctx->inbox_info.flags |= MAILBOX_CHILDREN;
- ctx->inbox_info.flags &= ~MAILBOX_NOINFERIORS;
+ ctx->inbox_info.flags &= ENUM_NEGATE(MAILBOX_NOINFERIORS);
}
if (info->ns->prefix_len > 0 &&
strncmp(info->vname, info->ns->prefix,
if ((ctx->flags & MAILBOX_LIST_ITER_SELECT_SUBSCRIBED) != 0)
info->flags |= MAILBOX_CHILD_SUBSCRIBED;
else {
- info->flags &= ~MAILBOX_NOCHILDREN;
+ info->flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
info->flags |= MAILBOX_CHILDREN;
}
}
FALSE, &idx);
}
if ((match2 & AUTOCREATE_MATCH_RESULT_YES) != 0)
- info->flags &= ~MAILBOX_NONEXISTENT;
+ info->flags &= ENUM_NEGATE(MAILBOX_NONEXISTENT);
if ((match2 & AUTOCREATE_MATCH_RESULT_CHILDREN) != 0) {
- info->flags &= ~MAILBOX_NOCHILDREN;
+ info->flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
info->flags |= MAILBOX_CHILDREN;
}
MAILBOX_CHILD_SUBSCRIBED));
if ((old_flags & MAILBOX_NONEXISTENT) == 0) {
actx->new_info.flags |= MAILBOX_CHILDREN;
- actx->new_info.flags &= ~MAILBOX_NOCHILDREN;
+ actx->new_info.flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
}
if ((old_flags & MAILBOX_SUBSCRIBED) != 0)
actx->new_info.flags |= MAILBOX_CHILD_SUBSCRIBED;
if (!ctx->update_only && add_matched)
node->flags |= MAILBOX_MATCHED;
if ((always_flags & MAILBOX_CHILDREN) != 0)
- node->flags &= ~MAILBOX_NOCHILDREN;
+ node->flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
node->flags |= always_flags;
}
/* We don't want to show the parent mailboxes unless
name = t_strdup_until(name, p);
create_flags |= MAILBOX_NONEXISTENT;
- create_flags &= ~MAILBOX_NOCHILDREN;
+ create_flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
always_flags = MAILBOX_CHILDREN | ctx->parent_flags;
}
}
node->flags |= MAILBOX_NONEXISTENT;
node->flags |= MAILBOX_CHILDREN;
- node->flags &= ~MAILBOX_NOCHILDREN;
+ node->flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
}
}
if (!update_only)
node->flags |= MAILBOX_MATCHED;
node->flags |= MAILBOX_CHILDREN;
- node->flags &= ~MAILBOX_NOCHILDREN;
+ node->flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
node_fix_parents(node);
}
}
node = mailbox_tree_lookup(ctx->tree_ctx, vname);
if (node != NULL) {
- node->flags &= ~MAILBOX_NOCHILDREN;
+ node->flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
node->flags |= MAILBOX_CHILDREN;
break;
}
if (update_only) {
node = mailbox_tree_lookup(ctx->tree_ctx, inbox_name);
if (node != NULL)
- node->flags &= ~MAILBOX_NONEXISTENT;
+ node->flags &= ENUM_NEGATE(MAILBOX_NONEXISTENT);
return 0;
}
if (created)
node->flags = MAILBOX_NOCHILDREN;
else
- node->flags &= ~MAILBOX_NONEXISTENT;
+ node->flags &= ENUM_NEGATE(MAILBOX_NONEXISTENT);
node->flags |= MAILBOX_MATCHED;
}
return 0;
/* we know the children flags ourself, so ignore if any of
them were set. */
- flags &= ~(MAILBOX_NOINFERIORS | MAILBOX_CHILDREN | MAILBOX_NOCHILDREN);
+ flags &= ENUM_NEGATE(MAILBOX_NOINFERIORS | MAILBOX_CHILDREN | MAILBOX_NOCHILDREN);
if ((match & IMAP_MATCH_PARENT) != 0)
maildir_fill_parents(ctx, glob, update_only, vname);
if (created)
node->flags = MAILBOX_NOCHILDREN;
else
- node->flags &= ~MAILBOX_NONEXISTENT;
+ node->flags &= ENUM_NEGATE(MAILBOX_NONEXISTENT);
if (!update_only)
node->flags |= MAILBOX_MATCHED;
node->flags |= flags;
if (strcmp(ctx->info.vname, "INBOX") == 0 &&
mail_namespace_is_inbox_noinferiors(ctx->info.ns)) {
i_assert((ctx->info.flags & MAILBOX_NOCHILDREN) != 0);
- ctx->info.flags &= ~MAILBOX_NOCHILDREN;
+ ctx->info.flags &= ENUM_NEGATE(MAILBOX_NOCHILDREN);
ctx->info.flags |= MAILBOX_NOINFERIORS;
}
if ((_ctx->flags & MAILBOX_LIST_ITER_RETURN_SUBSCRIBED) != 0 &&
{
struct mailbox_node *node;
- *flags &= ~(MAILBOX_SUBSCRIBED | MAILBOX_CHILD_SUBSCRIBED);
+ *flags &= ENUM_NEGATE(MAILBOX_SUBSCRIBED | MAILBOX_CHILD_SUBSCRIBED);
node = mailbox_tree_lookup(list->subscriptions, vname);
if (node != NULL) {
}
- ctx->info.flags &= ~(MAILBOX_SUBSCRIBED | MAILBOX_CHILD_SUBSCRIBED);
+ ctx->info.flags &= ENUM_NEGATE(MAILBOX_SUBSCRIBED | MAILBOX_CHILD_SUBSCRIBED);
ctx->info.flags |=
node->flags & (MAILBOX_SUBSCRIBED | MAILBOX_CHILD_SUBSCRIBED);
return &ctx->info;
getuid() != 0) {
/* service { user } isn't root. the permission drop can't be
temporary. */
- flags &= ~MAIL_STORAGE_SERVICE_FLAG_TEMP_PRIV_DROP;
+ flags &= ENUM_NEGATE(MAIL_STORAGE_SERVICE_FLAG_TEMP_PRIV_DROP);
}
(void)umask(0077);
{
enum mail_storage_service_flags flags;
- flags = (ctx->flags & ~input->flags_override_remove) |
+ flags = (ctx->flags & ENUM_NEGATE(input->flags_override_remove)) |
input->flags_override_add;
if (input->no_userdb_lookup) {
/* FIXME: for API backwards compatibility only */
- flags &= ~MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP;
+ flags &= ENUM_NEGATE(MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP);
}
return flags;
}
old_flag = box->flags & MAILBOX_FLAG_OPEN_DELETED;
box->flags |= MAILBOX_FLAG_OPEN_DELETED;
ret = mailbox_open(box);
- box->flags = (box->flags & ~MAILBOX_FLAG_OPEN_DELETED) | old_flag;
+ box->flags = (box->flags & ENUM_NEGATE(MAILBOX_FLAG_OPEN_DELETED)) | old_flag;
if (ret < 0)
return -1;
if (ctx->data.keywords != NULL)
mailbox_keywords_unref(&ctx->data.keywords);
- ctx->data.flags = flags & ~mailbox_get_private_flags_mask(box);
+ ctx->data.flags = flags & ENUM_NEGATE(mailbox_get_private_flags_mask(box));
ctx->data.pvt_flags = flags & mailbox_get_private_flags_mask(box);
ctx->data.keywords = keywords;
if (keywords != NULL)
i_unreached();
}
/* the value was validated. */
- type_flags &= ~MAIL_ATTRIBUTE_TYPE_FLAG_VALIDATED;
+ type_flags &= ENUM_NEGATE(MAIL_ATTRIBUTE_TYPE_FLAG_VALIDATED);
}
ret = t->box->v.attribute_set(t, type_flags, key, value);
case MAIL_ATTRIBUTE_INTERNAL_RANK_OVERRIDE:
/* we already checked that this attribute has
validated-flag */
- type_flags &= ~MAIL_ATTRIBUTE_TYPE_FLAG_VALIDATED;
+ type_flags &= ENUM_NEGATE(MAIL_ATTRIBUTE_TYPE_FLAG_VALIDATED);
if (iattr->get == NULL)
break;
if (tcgetattr(fd, &old_tio) == 0) {
restore_tio = TRUE;
tio = old_tio;
- tio.c_lflag &= ~(ECHO | ECHONL);
+ tio.c_lflag &= ENUM_NEGATE(ECHO | ECHONL);
(void)tcsetattr(fd, TCSAFLUSH, &tio);
}
} else {
if (nonblock)
flags |= O_NONBLOCK;
else
- flags &= ~O_NONBLOCK;
+ flags &= ENUM_NEGATE(O_NONBLOCK);
if (fcntl(fd, F_SETFL, flags) < 0)
i_fatal("fcntl(%d, F_SETFL) failed: %m", fd);
i_free(io);
if ((condition & IO_READ) != 0) {
- ctx->fds[index].events &= ~(POLLIN|POLLPRI);
- ctx->fds[index].revents &= ~(POLLIN|POLLPRI);
+ ctx->fds[index].events &= ENUM_NEGATE(POLLIN | POLLPRI);
+ ctx->fds[index].revents &= ENUM_NEGATE(POLLIN | POLLPRI);
}
if ((condition & IO_WRITE) != 0) {
- ctx->fds[index].events &= ~POLLOUT;
- ctx->fds[index].revents &= ~POLLOUT;
+ ctx->fds[index].events &= ENUM_NEGATE(POLLOUT);
+ ctx->fds[index].revents &= ENUM_NEGATE(POLLOUT);
}
if ((ctx->fds[index].events & (POLLIN|POLLOUT)) == 0) {
pollfd->revents = 0;
} else if ((io->io.condition & IO_READ) != 0) {
call = (pollfd->revents & IO_POLL_INPUT) != 0;
- pollfd->revents &= ~IO_POLL_INPUT;
+ pollfd->revents &= ENUM_NEGATE(IO_POLL_INPUT);
} else if ((io->io.condition & IO_WRITE) != 0) {
call = (pollfd->revents & IO_POLL_OUTPUT) != 0;
- pollfd->revents &= ~IO_POLL_OUTPUT;
+ pollfd->revents &= ENUM_NEGATE(IO_POLL_OUTPUT);
} else if ((io->io.condition & IO_ERROR) != 0) {
call = (pollfd->revents & IO_POLL_ERROR) != 0;
- pollfd->revents &= ~IO_POLL_ERROR;
+ pollfd->revents &= ENUM_NEGATE(IO_POLL_ERROR);
} else {
call = FALSE;
}
enum ostream_send_istream_result res;
- tstream->flags &= ~IOSTREAM_TEMP_FLAG_TRY_FD_DUP;
+ tstream->flags &= ENUM_NEGATE(IOSTREAM_TEMP_FLAG_TRY_FD_DUP);
if (tstream->dupstream != NULL) {
if (o_stream_temp_dup_cancel(tstream, &res))
return -1;
if ((outstream->flags & IOSTREAM_TEMP_FLAG_TRY_FD_DUP) != 0) {
if (o_stream_temp_dup_istream(outstream, instream, &res))
return res;
- outstream->flags &= ~IOSTREAM_TEMP_FLAG_TRY_FD_DUP;
+ outstream->flags &= ENUM_NEGATE(IOSTREAM_TEMP_FLAG_TRY_FD_DUP);
}
return io_stream_copy(&outstream->ostream.ostream, instream);
}
if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT,
&opt, sizeof(opt)) < 0)
#endif
- *flags &= ~NET_LISTEN_FLAG_REUSEPORT;
+ *flags &= ENUM_NEGATE(NET_LISTEN_FLAG_REUSEPORT);
}
/* If using IPv6, bind only to IPv6 if possible. This avoids
/* remove changed bits from old mask */
size = I_MIN(old_mask->size, change_mask->size);
for (i = 0; i < size; i++)
- old_mask->mask[i] &= ~change_mask->mask[i];
+ old_mask->mask[i] &= ENUM_NEGATE(change_mask->mask[i]);
break;
case ACL_MODIFY_MODE_REPLACE:
if (old_mask == NULL && change_mask == NULL)
/* apply the negative rights. they override positive rights. */
size = I_MIN(mask->size, obj_cache->my_neg_rights->size);
for (i = 0; i < size; i++)
- mask->mask[i] &= ~obj_cache->my_neg_rights->mask[i];
+ mask->mask[i] &= ENUM_NEGATE(obj_cache->my_neg_rights->mask[i]);
}
obj_cache->my_current_rights = mask;
if ((_ctx->flags & MAILBOX_LIST_ITER_RETURN_NO_FLAGS) != 0) {
/* don't waste time checking if there are visible
children, but also don't return incorrect flags */
- info->flags &= ~MAILBOX_CHILDREN;
+ info->flags &= ENUM_NEGATE(MAILBOX_CHILDREN);
} else if ((info->flags & MAILBOX_CHILDREN) != 0 &&
!iter_mailbox_has_visible_children(_ctx, FALSE, FALSE)) {
- info->flags &= ~MAILBOX_CHILDREN;
+ info->flags &= ENUM_NEGATE(MAILBOX_CHILDREN);
info->flags |= MAILBOX_NOCHILDREN;
}
return ret;
if (!acl_flags)
flags &= MAIL_SEEN | MAIL_DELETED;
if (!acl_flag_seen)
- flags &= ~MAIL_SEEN;
+ flags &= ENUM_NEGATE(MAIL_SEEN);
if (!acl_flag_del)
- flags &= ~MAIL_DELETED;
+ flags &= ENUM_NEGATE(MAIL_DELETED);
} else if (!acl_flags || !acl_flag_seen || !acl_flag_del) {
/* we don't have permission to replace all the flags. */
if (!acl_flags && !acl_flag_seen && !acl_flag_del) {
/* handle this by first removing the allowed flags and
then adding the allowed flags */
- acl_mail_update_flags(_mail, MODIFY_REMOVE, ~flags);
+ acl_mail_update_flags(_mail, MODIFY_REMOVE,
+ ENUM_NEGATE(flags));
if (flags != 0)
acl_mail_update_flags(_mail, MODIFY_ADD, flags);
return;
return -1;
if (!acl_flag_seen) {
- *flags &= ~MAIL_SEEN;
- *pvt_flags &= ~MAIL_SEEN;
+ *flags &= ENUM_NEGATE(MAIL_SEEN);
+ *pvt_flags &= ENUM_NEGATE(MAIL_SEEN);
}
if (!acl_flag_del) {
- *flags &= ~MAIL_DELETED;
- *pvt_flags &= ~MAIL_DELETED;
+ *flags &= ENUM_NEGATE(MAIL_DELETED);
+ *pvt_flags &= ENUM_NEGATE(MAIL_DELETED);
}
if (!acl_flags) {
*flags &= MAIL_SEEN | MAIL_DELETED;
status_r->allow_new_keywords = FALSE;
}
if (acl_mailbox_right_lookup(box, ACL_STORAGE_RIGHT_WRITE_DELETED) <= 0)
- status_r->permanent_flags &= ~MAIL_DELETED;
+ status_r->permanent_flags &= ENUM_NEGATE(MAIL_DELETED);
if (acl_mailbox_right_lookup(box, ACL_STORAGE_RIGHT_WRITE_SEEN) <= 0)
- status_r->permanent_flags &= ~MAIL_SEEN;
+ status_r->permanent_flags &= ENUM_NEGATE(MAIL_SEEN);
}
return 0;
}
file->open_mode = mode;
/* avoid unnecessarily creating two seekable streams */
- flags &= ~FS_OPEN_FLAG_SEEKABLE;
+ flags &= ENUM_NEGATE(FS_OPEN_FLAG_SEEKABLE);
file->file.parent = fs_file_init_parent(_file, path, mode | flags);
if (mode == FS_OPEN_MODE_READONLY &&
if (fuser->set.use_libfts) {
/* change our flags so we get proper input */
- _backend->flags &= ~FTS_BACKEND_FLAG_FUZZY_SEARCH;
+ _backend->flags &= ENUM_NEGATE(FTS_BACKEND_FLAG_FUZZY_SEARCH);
_backend->flags |= FTS_BACKEND_FLAG_TOKENIZED_INPUT;
}
path = mailbox_list_get_root_forced(_backend->ns->list,
}
if (fuser->set.use_libfts) {
/* change our flags so we get proper input */
- _backend->flags &= ~FTS_BACKEND_FLAG_FUZZY_SEARCH;
+ _backend->flags &= ENUM_NEGATE(FTS_BACKEND_FLAG_FUZZY_SEARCH);
_backend->flags |= FTS_BACKEND_FLAG_TOKENIZED_INPUT;
}
save_ctx = mailbox_save_alloc(lt->dest_trans);
mailbox_save_copy_flags(save_ctx, _mail);
- save_ctx->data.flags &= ~MAIL_DELETED;
+ save_ctx->data.flags &= ENUM_NEGATE(MAIL_DELETED);
mmail->recursing = TRUE;
if (mailbox_move(&save_ctx, _mail) < 0 && !_mail->expunged)
file->open_mode = mode;
/* avoid unnecessarily creating two seekable streams */
- flags &= ~FS_OPEN_FLAG_SEEKABLE;
+ flags &= ENUM_NEGATE(FS_OPEN_FLAG_SEEKABLE);
file->file.parent = fs_file_init_parent(_file, path, mode | flags);
if (mode == FS_OPEN_MODE_READONLY &&
}
quota_transaction_rollback(&qt);
- if ((items & ~STATUS_CHECK_OVER_QUOTA) == 0) {
+ if ((items & ENUM_NEGATE(STATUS_CHECK_OVER_QUOTA)) == 0) {
/* don't bother calling parent, it may unnecessarily
try to open the mailbox */
return ret < 0 ? -1 : 0;
/* Replication needs to be triggered on all the user-visible changes,
but not e.g. due to writes to cache file. */
return (changes->changes_mask &
- ~MAIL_INDEX_TRANSACTION_CHANGE_OTHERS) != 0;
+ ENUM_NEGATE(MAIL_INDEX_TRANSACTION_CHANGE_OTHERS)) != 0;
}
static void
i_assert(bbox->box == NULL);
if (!bbox->clear_recent)
- flags &= ~MAILBOX_FLAG_DROP_RECENT;
+ flags &= ENUM_NEGATE(MAILBOX_FLAG_DROP_RECENT);
mailbox = bbox->name;
ns = mail_namespace_find(user->namespaces, mailbox);
flags = mail_get_flags(bbox->sync_mail);
/* we don't need to keep recent flags here */
- mail_index_update_flags(ctx->trans, vseq, MODIFY_REPLACE, flags & ~(MAIL_RECENT));
+ mail_index_update_flags(ctx->trans, vseq, MODIFY_REPLACE,
+ flags & ENUM_NEGATE(MAIL_RECENT));
/* copy keywords */
kw_names = mail_get_keywords(bbox->sync_mail);
switch (c) {
case 'f':
if (strcmp(optarg, "in") == 0)
- flags &= ~RAWLOG_FLAG_LOG_OUTPUT;
+ flags &= ENUM_NEGATE(RAWLOG_FLAG_LOG_OUTPUT);
else if (strcmp(optarg, "out") == 0)
- flags &= ~RAWLOG_FLAG_LOG_INPUT;
+ flags &= ENUM_NEGATE(RAWLOG_FLAG_LOG_INPUT);
else
i_fatal("Invalid filter: %s", optarg);
break;
projects / thirdparty / dovecot / core.git / commitdiff
