bool cmd_create(struct client_command_context *cmd)
{
enum mailbox_name_status status;
struct mail_namespace *ns;
const char *mailbox, *storage_name;
struct mailbox *box;
bool directory;
size_t len;
/* <mailbox> */
if (!client_read_string_args(cmd, 1, &mailbox))
return FALSE;
ns = client_find_namespace(cmd, mailbox, &storage_name, NULL);
if (ns == NULL)
return TRUE;
len = strlen(mailbox);
if (len == 0 || mailbox[len-1] != ns->sep)
directory = FALSE;
else if (*storage_name == '\0') {
client_send_tagline(cmd, "NO ["IMAP_RESP_CODE_ALREADYEXISTS
"] Namespace already exists.");
return TRUE;
} else {
/* name ends with hierarchy separator - client is just
informing us that it wants to create children under this
mailbox. */
directory = TRUE;
storage_name = t_strndup(storage_name, strlen(storage_name)-1);
mailbox = t_strndup(mailbox, len-1);
}
ns = client_find_namespace(cmd, mailbox, &storage_name, &status);
if (ns == NULL)
return TRUE;
switch (status) {
case MAILBOX_NAME_VALID:
break;
case MAILBOX_NAME_EXISTS_DIR:
if (!directory)
break;
/* fall through */
case MAILBOX_NAME_EXISTS_MAILBOX:
case MAILBOX_NAME_INVALID:
case MAILBOX_NAME_NOINFERIORS:
client_fail_mailbox_name_status(cmd, mailbox, NULL, status);
return TRUE;
}
box = mailbox_alloc(ns->list, storage_name, 0);
if (mailbox_create(box, NULL, directory) < 0)
client_send_storage_error(cmd, mailbox_get_storage(box));
else
client_send_tagline(cmd, "OK Create completed.");
mailbox_free(&box);
return TRUE;
}
static int
dest_mailbox_open_or_create(struct import_cmd_context *ctx,
struct mail_user *user,
const struct mailbox_info *info,
struct mailbox **box_r)
{
struct mail_namespace *ns;
struct mailbox *box;
enum mail_error error;
const char *name, *errstr;
if (*ctx->dest_parent != '\0') {
/* prefix destination mailbox name with given parent mailbox */
ns = mail_namespace_find(user->namespaces, ctx->dest_parent);
} else {
ns = mail_namespace_find(user->namespaces, info->vname);
}
name = convert_vname_separators(info->vname,
mail_namespace_get_sep(info->ns),
mail_namespace_get_sep(ns));
if (*ctx->dest_parent != '\0') {
name = t_strdup_printf("%s%c%s", ctx->dest_parent,
mail_namespace_get_sep(ns), name);
}
box = mailbox_alloc(ns->list, name, MAILBOX_FLAG_SAVEONLY);
if (mailbox_create(box, NULL, FALSE) < 0) {
errstr = mailbox_get_last_error(box, &error);
if (error != MAIL_ERROR_EXISTS) {
i_error("Couldn't create mailbox %s: %s", name, errstr);
doveadm_mail_failed_mailbox(&ctx->ctx, box);
mailbox_free(&box);
return -1;
}
}
if (ctx->subscribe) {
if (mailbox_set_subscribed(box, TRUE) < 0) {
i_error("Couldn't subscribe to mailbox %s: %s",
name, mailbox_get_last_error(box, NULL));
}
}
if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
i_error("Syncing mailbox %s failed: %s", name,
mailbox_get_last_error(box, NULL));
doveadm_mail_failed_mailbox(&ctx->ctx, box);
mailbox_free(&box);
return -1;
}
*box_r = box;
return 0;
}
static int
dest_mailbox_open_or_create(struct import_cmd_context *ctx,
struct mail_user *user, const char *name,
struct mailbox **box_r)
{
struct mail_namespace *ns;
struct mailbox *box;
enum mail_error error;
const char *errstr, *storage_name;
if (*ctx->dest_parent != '\0') {
/* prefix destination mailbox name with given parent mailbox */
storage_name = ctx->dest_parent;
ns = mail_namespace_find(user->namespaces, &storage_name);
if (ns == NULL) {
i_error("Can't find namespace for parent mailbox %s",
ctx->dest_parent);
return -1;
}
name = t_strdup_printf("%s%c%s", ctx->dest_parent,
ns->sep, name);
}
storage_name = name;
ns = mail_namespace_find(user->namespaces, &storage_name);
if (ns == NULL) {
i_error("Can't find namespace for mailbox %s", name);
return -1;
}
box = mailbox_alloc(ns->list, storage_name, MAILBOX_FLAG_SAVEONLY |
MAILBOX_FLAG_KEEP_RECENT);
if (mailbox_create(box, NULL, FALSE) < 0) {
errstr = mail_storage_get_last_error(mailbox_get_storage(box),
&error);
if (error != MAIL_ERROR_EXISTS) {
i_error("Couldn't create mailbox %s: %s", name, errstr);
mailbox_free(&box);
return -1;
}
}
if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
i_error("Syncing mailbox %s failed: %s", name,
mail_storage_get_last_error(mailbox_get_storage(box),
NULL));
mailbox_free(&box);
return -1;
}
*box_r = box;
return 0;
}
int mailbox_init(connection_t *con, tims_msg_head* tcpMsg, tims_msg_head *replyMsg)
{
int ret;
tims_router_mbx_msg* mbxMsg = NULL;
if (tcpMsg->msglen < sizeof(tims_router_mbx_msg))
{
tims_print("con[%02d]: %s: init mailbox -> message "
"length invalid, is: %u bytes, must be %u bytes\n",
con->index, inet_ntoa(con->addr.sin_addr),
tcpMsg->msglen, sizeof(tims_router_mbx_msg));
return -EFAULT;
}
mbxMsg = tims_router_parse_mbx_msg(tcpMsg);
ret = mailbox_create(mbxMsg->mbx, con->index);
if (ret)
{
tims_print("con[%02d] %s error: Can't init MBX %x, "
"code = %d\n", con->index, inet_ntoa(con->addr.sin_addr),
mbxMsg->mbx, ret);
if (replyMsg)
{
tims_fillhead(replyMsg, TIMS_MSG_ERROR, tcpMsg->src, tcpMsg->dest,
tcpMsg->priority, tcpMsg->seq_nr, 0, TIMS_HEADLEN);
}
}
else
{
tims_print("con[%02d]: %s: init MBX %x\n", con->index,
inet_ntoa(con->addr.sin_addr), mbxMsg->mbx);
if (replyMsg)
{
tims_fillhead(replyMsg, TIMS_MSG_OK, tcpMsg->src, tcpMsg->dest,
tcpMsg->priority, tcpMsg->seq_nr, 0, TIMS_HEADLEN);
}
//TODO: Register mailbox @ next level TCP Router
}
if (replyMsg)
sndTcpTimsMsg(con, replyMsg);
return 0;
}
bool cmd_create(struct client_command_context *cmd)
{
struct mail_namespace *ns;
const char *mailbox, *orig_mailbox;
struct mailbox *box;
bool directory;
size_t len;
/* <mailbox> */
if (!client_read_string_args(cmd, 1, &mailbox))
return FALSE;
orig_mailbox = mailbox;
ns = client_find_namespace(cmd, &mailbox);
if (ns == NULL)
return TRUE;
len = strlen(orig_mailbox);
if (len == 0 || orig_mailbox[len-1] != mail_namespace_get_sep(ns))
directory = FALSE;
else {
/* name ends with hierarchy separator - client is just
informing us that it wants to create children under this
mailbox. */
directory = TRUE;
/* drop separator from mailbox. it's already dropped when
WORKAROUND_TB_EXTRA_MAILBOX_SEP is enabled */
if (len == strlen(mailbox))
mailbox = t_strndup(mailbox, len-1);
}
box = mailbox_alloc(ns->list, mailbox, 0);
mailbox_set_reason(box, "CREATE");
if (mailbox_create(box, NULL, directory) < 0)
client_send_box_error(cmd, box);
else
client_send_tagline(cmd, "OK Create completed.");
mailbox_free(&box);
return TRUE;
}
static struct replay_thread *
thread_get(int fd, void *(*thread_main)(void *))
{
assert(fd != 0);
if (fd >= nthreads) {
struct replay_thread **newthreads = threads;
size_t newnthreads = nthreads;
while (fd >= newnthreads)
newnthreads += newnthreads + 1;
newthreads = realloc(newthreads,
newnthreads * sizeof *newthreads);
XXXAN(newthreads != NULL);
memset(newthreads + nthreads, 0,
(newnthreads - nthreads) * sizeof *newthreads);
threads = newthreads;
nthreads = newnthreads;
}
if (threads[fd] == NULL) {
threads[fd] = malloc(sizeof *threads[fd]);
assert(threads[fd] != NULL);
threads[fd]->sock = -1;
thread_clear(threads[fd]);
mailbox_create(&threads[fd]->mbox);
if (pthread_create(&threads[fd]->thread_id, &thread_attr,
thread_main, threads[fd]) != 0) {
thread_log(0, errno, "pthread_create()");
mailbox_destroy(&threads[fd]->mbox);
freez(threads[fd]);
threads[fd] = THREAD_FAIL;
} else {
threads[fd]->fd = fd;
thread_log(0, 0, "thread %p:%d started",
(void *)threads[fd]->thread_id, fd);
}
}
if (threads[fd] == THREAD_FAIL)
return (NULL);
return (threads[fd]);
}
static int
sync_create_box(struct dsync_brain *brain, struct mailbox *box,
const guid_128_t mailbox_guid, uint32_t uid_validity,
enum mail_error *error_r)
{
struct mailbox_metadata metadata;
struct mailbox_update update;
enum mail_error error;
const char *errstr;
int ret;
memset(&update, 0, sizeof(update));
memcpy(update.mailbox_guid, mailbox_guid, sizeof(update.mailbox_guid));
update.uid_validity = uid_validity;
if (mailbox_create(box, &update, FALSE) < 0) {
errstr = mailbox_get_last_error(box, &error);
if (error != MAIL_ERROR_EXISTS) {
i_error("Can't create mailbox %s: %s",
mailbox_get_vname(box), errstr);
*error_r = error;
return -1;
}
}
if (brain->no_mail_sync) {
/* trust that create worked, we can't actually open it
and verify. */
return 0;
}
/* sync the mailbox so we can look up its latest status */
if (mailbox_sync(box, MAILBOX_SYNC_FLAG_FULL_READ) < 0) {
i_error("Can't sync mailbox %s: %s",
mailbox_get_vname(box),
mailbox_get_last_error(box, error_r));
return -1;
}
/* verify that the GUID is what we wanted. if it's not, it probably
means that the mailbox had already been created. then we'll use the
GUID that is higher.
mismatching UIDVALIDITY is handled later, because we choose it by
checking which mailbox has more messages */
if (mailbox_get_metadata(box, MAILBOX_METADATA_GUID, &metadata) < 0) {
i_error("Can't get mailbox GUID %s: %s",
mailbox_get_vname(box),
mailbox_get_last_error(box, error_r));
return -1;
}
ret = memcmp(mailbox_guid, metadata.guid, sizeof(metadata.guid));
if (ret > 0) {
if (brain->debug) {
i_debug("brain %c: Changing mailbox %s GUID %s -> %s",
brain->master_brain ? 'M' : 'S',
mailbox_get_vname(box),
guid_128_to_string(metadata.guid),
guid_128_to_string(mailbox_guid));
}
memset(&update, 0, sizeof(update));
memcpy(update.mailbox_guid, mailbox_guid,
sizeof(update.mailbox_guid));
if (mailbox_update(box, &update) < 0) {
i_error("Can't update mailbox GUID %s: %s",
mailbox_get_vname(box),
mailbox_get_last_error(box, error_r));
return -1;
}
/* verify that the update worked */
if (mailbox_get_metadata(box, MAILBOX_METADATA_GUID,
&metadata) < 0) {
i_error("Can't get mailbox GUID %s: %s",
mailbox_get_vname(box),
mailbox_get_last_error(box, error_r));
return -1;
}
if (memcmp(mailbox_guid, metadata.guid,
sizeof(metadata.guid)) != 0) {
i_error("Backend didn't update mailbox %s GUID",
mailbox_get_vname(box));
*error_r = MAIL_ERROR_TEMP;
return -1;
}
} else if (ret < 0) {
if (brain->debug) {
i_debug("brain %c: Other brain should change mailbox "
"%s GUID %s -> %s",
brain->master_brain ? 'M' : 'S',
mailbox_get_vname(box),
guid_128_to_string(mailbox_guid),
guid_128_to_string(metadata.guid));
}
}
return 0;
}
int dsync_brain_mailbox_tree_sync_change(struct dsync_brain *brain,
const struct dsync_mailbox_tree_sync_change *change,
enum mail_error *error_r)
{
struct mailbox *box = NULL, *destbox;
const char *errstr, *func_name = NULL, *storage_name;
enum mail_error error;
int ret = -1;
if (brain->backup_send) {
i_assert(brain->no_backup_overwrite);
return 0;
}
switch (change->type) {
case DSYNC_MAILBOX_TREE_SYNC_TYPE_DELETE_BOX:
/* make sure we're deleting the correct mailbox */
ret = dsync_brain_mailbox_alloc(brain, change->mailbox_guid,
&box, &errstr, error_r);
if (ret < 0) {
i_error("Mailbox sync: Couldn't allocate mailbox GUID %s: %s",
guid_128_to_string(change->mailbox_guid), errstr);
return -1;
}
if (ret == 0) {
if (brain->debug) {
i_debug("brain %c: Change during sync: "
"Mailbox GUID %s deletion conflict: %s",
brain->master_brain ? 'M' : 'S',
guid_128_to_string(change->mailbox_guid), errstr);
}
brain->changes_during_sync = TRUE;
return 0;
}
break;
case DSYNC_MAILBOX_TREE_SYNC_TYPE_DELETE_DIR:
storage_name = mailbox_list_get_storage_name(change->ns->list,
change->full_name);
if (mailbox_list_delete_dir(change->ns->list, storage_name) == 0)
return 0;
errstr = mailbox_list_get_last_error(change->ns->list, &error);
if (error == MAIL_ERROR_NOTFOUND ||
error == MAIL_ERROR_EXISTS) {
if (brain->debug) {
i_debug("brain %c: Change during sync: "
"Mailbox %s mailbox_list_delete_dir conflict: %s",
brain->master_brain ? 'M' : 'S',
change->full_name, errstr);
}
brain->changes_during_sync = TRUE;
return 0;
} else {
i_error("Mailbox sync: mailbox_list_delete_dir failed: %s",
errstr);
*error_r = error;
return -1;
}
default:
box = mailbox_alloc(change->ns->list, change->full_name, 0);
break;
}
switch (change->type) {
case DSYNC_MAILBOX_TREE_SYNC_TYPE_CREATE_BOX:
ret = sync_create_box(brain, box, change->mailbox_guid,
change->uid_validity, error_r);
mailbox_free(&box);
return ret;
case DSYNC_MAILBOX_TREE_SYNC_TYPE_CREATE_DIR:
ret = mailbox_create(box, NULL, TRUE);
if (ret < 0 &&
mailbox_get_last_mail_error(box) == MAIL_ERROR_EXISTS) {
/* it doesn't matter if somebody else created this
directory or we automatically did while creating its
child mailbox. it's there now anyway and we don't
gain anything by treating this failure any
differently from success. */
ret = 0;
}
func_name = "mailbox_create";
break;
case DSYNC_MAILBOX_TREE_SYNC_TYPE_DELETE_BOX:
ret = mailbox_delete(box);
func_name = "mailbox_delete";
break;
case DSYNC_MAILBOX_TREE_SYNC_TYPE_DELETE_DIR:
i_unreached();
case DSYNC_MAILBOX_TREE_SYNC_TYPE_RENAME:
destbox = mailbox_alloc(change->ns->list,
change->rename_dest_name, 0);
ret = mailbox_rename(box, destbox);
func_name = "mailbox_rename";
mailbox_free(&destbox);
break;
case DSYNC_MAILBOX_TREE_SYNC_TYPE_SUBSCRIBE:
ret = mailbox_set_subscribed(box, TRUE);
func_name = "mailbox_set_subscribed";
break;
case DSYNC_MAILBOX_TREE_SYNC_TYPE_UNSUBSCRIBE:
ret = mailbox_set_subscribed(box, FALSE);
func_name = "mailbox_set_subscribed";
break;
}
if (ret < 0) {
errstr = mailbox_get_last_error(box, &error);
if (error == MAIL_ERROR_EXISTS ||
error == MAIL_ERROR_NOTFOUND) {
/* mailbox was already created or was already deleted.
let the next sync figure out what to do */
if (brain->debug) {
i_debug("brain %c: Change during sync: "
"Mailbox %s %s conflict: %s",
brain->master_brain ? 'M' : 'S',
mailbox_get_vname(box),
func_name, errstr);
}
brain->changes_during_sync = TRUE;
ret = 0;
} else {
i_error("Mailbox %s sync: %s failed: %s",
mailbox_get_vname(box), func_name, errstr);
*error_r = error;
}
}
mailbox_free(&box);
return ret;
}
