bool dsync_brain_recv_mailbox_tree(struct dsync_brain *brain) { const struct dsync_mailbox_node *remote_node; struct dsync_mailbox_node *node, *dup_node1, *dup_node2; const char *const *parts, *name; struct mail_namespace *ns; enum dsync_ibc_recv_ret ret; char sep[2]; bool changed = FALSE; sep[0] = brain->hierarchy_sep; sep[1] = '\0'; while ((ret = dsync_ibc_recv_mailbox_tree_node(brain->ibc, &parts, &remote_node)) > 0) { if (dsync_get_mailbox_name(brain, parts, &name, &ns) < 0) { i_error("Couldn't find namespace for mailbox %s", t_strarray_join(parts, sep)); brain->failed = TRUE; return TRUE; } if (brain->debug) { i_debug("brain %c: Remote mailbox tree: %s %s", brain->master_brain ? 'M' : 'S', t_strarray_join(parts, sep), dsync_mailbox_node_to_string(remote_node)); } node = dsync_mailbox_tree_get(brain->remote_mailbox_tree, name); node->ns = ns; dsync_mailbox_node_copy_data(node, remote_node); } if (ret != DSYNC_IBC_RECV_RET_FINISHED) return changed; if (dsync_mailbox_tree_build_guid_hash(brain->remote_mailbox_tree, &dup_node1, &dup_node2) < 0) { i_error("Remote sent duplicate mailbox GUID %s for mailboxes %s and %s", guid_128_to_string(dup_node1->mailbox_guid), dsync_mailbox_node_get_full_name(brain->remote_mailbox_tree, dup_node1), dsync_mailbox_node_get_full_name(brain->remote_mailbox_tree, dup_node2)); brain->failed = TRUE; } brain->state = DSYNC_STATE_RECV_MAILBOX_TREE_DELETES; return TRUE; }
static int dsync_mailbox_tree_fix_guid_duplicate(struct dsync_mailbox_tree *tree, struct dsync_mailbox_node *node1, struct dsync_mailbox_node *node2) { struct mailbox *box; struct mailbox_update update; struct dsync_mailbox_node *change_node; const char *change_vname; int ret = 0; i_zero(&update); guid_128_generate(update.mailbox_guid); /* just in case the duplication exists in both sides, make them choose the same node */ if (strcmp(dsync_mailbox_node_get_full_name(tree, node1), dsync_mailbox_node_get_full_name(tree, node2)) <= 0) change_node = node1; else change_node = node2; change_vname = dsync_mailbox_node_get_full_name(tree, change_node); i_error("Duplicate mailbox GUID %s for mailboxes %s and %s - " "giving a new GUID %s to %s", guid_128_to_string(node1->mailbox_guid), dsync_mailbox_node_get_full_name(tree, node1), dsync_mailbox_node_get_full_name(tree, node2), guid_128_to_string(update.mailbox_guid), change_vname); i_assert(node1->ns != NULL && node2->ns != NULL); box = mailbox_alloc(change_node->ns->list, change_vname, 0); if (mailbox_update(box, &update) < 0) { i_error("Couldn't update mailbox %s GUID: %s", change_vname, mailbox_get_last_internal_error(box, NULL)); ret = -1; } else { memcpy(change_node->mailbox_guid, update.mailbox_guid, sizeof(change_node->mailbox_guid)); } mailbox_free(&box); return ret; }
bool dsync_brain_recv_mailbox_tree_deletes(struct dsync_brain *brain) { const struct dsync_mailbox_node *node; const char *status; const struct dsync_mailbox_delete *deletes; unsigned int i, count; char sep; if (dsync_ibc_recv_mailbox_deletes(brain->ibc, &deletes, &count, &sep) == 0) return FALSE; /* apply remote's mailbox deletions based on our local tree */ dsync_mailbox_tree_set_remote_sep(brain->local_mailbox_tree, sep); for (i = 0; i < count; i++) { dsync_brain_mailbox_tree_add_delete(brain->local_mailbox_tree, brain->remote_mailbox_tree, &deletes[i], &node, &status); if (brain->debug) { const char *node_name = node == NULL ? "" : dsync_mailbox_node_get_full_name(brain->local_mailbox_tree, node); i_debug("brain %c: Remote mailbox tree deletion: guid=%s type=%s timestamp=%ld name=%s local update=%s", brain->master_brain ? 'M' : 'S', guid_128_to_string(deletes[i].guid), dsync_mailbox_delete_type_to_string(deletes[i].type), deletes[i].timestamp, node_name, status); } } /* apply local mailbox deletions based on remote tree */ deletes = dsync_mailbox_tree_get_deletes(brain->local_mailbox_tree, &count); dsync_mailbox_tree_set_remote_sep(brain->remote_mailbox_tree, brain->hierarchy_sep); for (i = 0; i < count; i++) { dsync_brain_mailbox_tree_add_delete(brain->remote_mailbox_tree, brain->local_mailbox_tree, &deletes[i], &node, &status); } dsync_brain_mailbox_trees_sync(brain); brain->state = brain->master_brain ? DSYNC_STATE_MASTER_SEND_MAILBOX : DSYNC_STATE_SLAVE_RECV_MAILBOX; i_assert(brain->local_tree_iter == NULL); brain->local_tree_iter = dsync_mailbox_tree_iter_init(brain->local_mailbox_tree); return TRUE; }
static void sync_add_dir_change(struct dsync_mailbox_tree_sync_ctx *ctx, const struct dsync_mailbox_node *node, enum dsync_mailbox_tree_sync_type type) { struct dsync_mailbox_tree_sync_change *change; const char *name; i_assert(ctx->sync_type != DSYNC_MAILBOX_TREES_SYNC_TYPE_PRESERVE_LOCAL); name = dsync_mailbox_node_get_full_name(ctx->local_tree, node); change = array_append_space(&ctx->changes); change->type = type; change->ns = node->ns; change->full_name = p_strdup(ctx->pool, name); }
static void dsync_brain_mailbox_tree_add_delete(struct dsync_mailbox_tree *tree, struct dsync_mailbox_tree *other_tree, const struct dsync_mailbox_delete *other_del, const struct dsync_mailbox_node **node_r, const char **status_r) { const struct dsync_mailbox_node *node; struct dsync_mailbox_node *other_node, *old_node; const char *name; /* see if we can find the deletion based on mailbox tree that should still have the mailbox */ node = *node_r = dsync_mailbox_tree_find_delete(tree, other_del); if (node == NULL) { *status_r = "not found"; return; } switch (other_del->type) { case DSYNC_MAILBOX_DELETE_TYPE_MAILBOX: /* mailbox is always deleted */ break; case DSYNC_MAILBOX_DELETE_TYPE_DIR: if (other_del->timestamp <= node->last_renamed_or_created) { /* we don't want to delete this directory, we already have a newer timestamp for it */ *status_r = "keep directory, we have a newer timestamp"; return; } break; case DSYNC_MAILBOX_DELETE_TYPE_UNSUBSCRIBE: if (other_del->timestamp <= node->last_subscription_change) { /* we don't want to unsubscribe, since we already have a newer subscription timestamp */ *status_r = "keep subscription, we have a newer timestamp"; return; } break; } /* make a node for it in the other mailbox tree */ name = dsync_mailbox_node_get_full_name(tree, node); other_node = dsync_mailbox_tree_get(other_tree, name); if (other_node->existence == DSYNC_MAILBOX_NODE_EXISTS && (!guid_128_is_empty(other_node->mailbox_guid) || other_del->type != DSYNC_MAILBOX_DELETE_TYPE_MAILBOX)) { /* other side has already created a new mailbox or directory with this name, we can't delete it */ *status_r = "name has already been recreated"; return; } /* ok, mark the other node deleted */ if (other_del->type == DSYNC_MAILBOX_DELETE_TYPE_MAILBOX) { memcpy(other_node->mailbox_guid, node->mailbox_guid, sizeof(other_node->mailbox_guid)); } if (other_node->ns != node->ns && other_node->ns != NULL) { /* namespace mismatch for this node. this shouldn't happen normally, but especially during some misconfigurations it's possible that one side has created mailboxes that conflict with another namespace's prefix. since we're here because one of the mailboxes was deleted, we'll just ignore this. */ *status_r = "namespace mismatch"; return; } other_node->ns = node->ns; if (other_del->type != DSYNC_MAILBOX_DELETE_TYPE_UNSUBSCRIBE) { other_node->existence = DSYNC_MAILBOX_NODE_DELETED; *status_r = "marked as deleted"; } else { other_node->last_subscription_change = other_del->timestamp; other_node->subscribed = FALSE; *status_r = "marked as unsubscribed"; } if (dsync_mailbox_tree_guid_hash_add(other_tree, other_node, &old_node) < 0) i_unreached(); }
static void dsync_brain_mailbox_tree_add_delete(struct dsync_mailbox_tree *tree, struct dsync_mailbox_tree *other_tree, const struct dsync_mailbox_delete *other_del) { const struct dsync_mailbox_node *node; struct dsync_mailbox_node *other_node, *old_node; const char *name; /* see if we can find the deletion based on mailbox tree that should still have the mailbox */ node = dsync_mailbox_tree_find_delete(tree, other_del); if (node == NULL) return; switch (other_del->type) { case DSYNC_MAILBOX_DELETE_TYPE_MAILBOX: /* mailbox is always deleted */ break; case DSYNC_MAILBOX_DELETE_TYPE_DIR: if (other_del->timestamp <= node->last_renamed_or_created) { /* we don't want to delete this directory, we already have a newer timestamp for it */ return; } break; case DSYNC_MAILBOX_DELETE_TYPE_UNSUBSCRIBE: if (other_del->timestamp <= node->last_subscription_change) { /* we don't want to unsubscribe, since we already have a newer subscription timestamp */ return; } break; } /* make a node for it in the other mailbox tree */ name = dsync_mailbox_node_get_full_name(tree, node); other_node = dsync_mailbox_tree_get(other_tree, name); if (other_node->existence == DSYNC_MAILBOX_NODE_EXISTS && (!guid_128_is_empty(other_node->mailbox_guid) || other_del->type != DSYNC_MAILBOX_DELETE_TYPE_MAILBOX)) { /* other side has already created a new mailbox or directory with this name, we can't delete it */ return; } /* ok, mark the other node deleted */ if (other_del->type == DSYNC_MAILBOX_DELETE_TYPE_MAILBOX) { memcpy(other_node->mailbox_guid, node->mailbox_guid, sizeof(other_node->mailbox_guid)); } i_assert(other_node->ns == NULL || other_node->ns == node->ns); other_node->ns = node->ns; if (other_del->type != DSYNC_MAILBOX_DELETE_TYPE_UNSUBSCRIBE) other_node->existence = DSYNC_MAILBOX_NODE_DELETED; else { other_node->last_subscription_change = other_del->timestamp; other_node->subscribed = FALSE; } if (dsync_mailbox_tree_guid_hash_add(other_tree, other_node, &old_node) < 0) i_unreached(); }