mbox_open_append()

Open a Mailbox for appending. More...

Collaboration diagram for mbox_open_append():

Functions
static bool	comp_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
static bool	imap_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
bool	maildir_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
static bool	mbox_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
static bool	mh_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.

Detailed Description

Open a Mailbox for appending.

Parameters

m	Mailbox to open
flags	Flags, see OpenMailboxFlags

Return values

true	Success
false	Failure

Precondition

m is not NULL

Function Documentation

comp_mbox_open_append()

static bool comp_mbox_open_append ( struct Mailbox * m, OpenMailboxFlags flags )

static

Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.

To append to a compressed mailbox we need an append-hook (or both open- and close-hooks).

Definition at line 474 of file compress.c.

{
  /* If this succeeds, we know there's an open-hook */
  struct CompressInfo *ci = set_compress_info(m);
  if (!ci)
    return false;
 
  /* To append we need an append-hook or a close-hook */
  if (!ci->cmd_append && !ci->cmd_close)
  {
    mutt_error(_("Can't append without an append-hook or close-hook : %s"),
               mailbox_path(m));
    goto cmoa_fail1;
  }
 
  if (setup_paths(m) != 0)
    goto cmoa_fail2;
 
  /* Lock the realpath for the duration of the append.
   * It will be unlocked in the close */
  if (!lock_realpath(m, true))
  {
    mutt_error(_("Unable to lock mailbox"));
    goto cmoa_fail2;
  }
 
  /* Open the existing mailbox, unless we are appending */
  if (!ci->cmd_append && (mutt_file_get_size(m->realpath) > 0))
  {
    if (!execute_command(m, ci->cmd_open, _("Decompressing %s")))
    {
      mutt_error(_("Compress command failed: %s"), ci->cmd_open->string);
      goto cmoa_fail2;
    }
    m->type = mx_path_probe(mailbox_path(m));
  }
  else
  {
    m->type = cs_subset_enum(NeoMutt->sub, "mbox_type");
  }
 
  /* We can only deal with mbox and mmdf mailboxes */
  if ((m->type != MUTT_MBOX) && (m->type != MUTT_MMDF))
  {
    mutt_error(_("Unsupported mailbox type for appending"));
    goto cmoa_fail2;
  }
 
  ci->child_ops = mx_get_ops(m->type);
  if (!ci->child_ops)
  {
    mutt_error(_("Can't find mailbox ops for mailbox type %d"), m->type);
    goto cmoa_fail2;
  }
 
  if (!ci->child_ops->mbox_open_append(m, flags))
    goto cmoa_fail2;
 
  return true;
 
cmoa_fail2:
  /* remove the partial uncompressed file */
  (void) remove(mailbox_path(m));
cmoa_fail1:
  /* Free the compress_info to prevent close from trying to recompress */
  compress_info_free(m);
 
  return false;
}

Here is the call graph for this function:

imap_mbox_open_append()

static bool imap_mbox_open_append ( struct Mailbox * m, OpenMailboxFlags flags )

static

Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.

Definition at line 2270 of file imap.c.

{
  if (!m->account)
    return false;
 
  /* in APPEND mode, we appear to hijack an existing IMAP connection -
   * mailbox is brand new and mostly empty */
  struct ImapAccountData *adata = imap_adata_get(m);
  struct ImapMboxData *mdata = imap_mdata_get(m);
  if (!adata || !mdata)
    return false;
 
  int rc = imap_mailbox_status(m, false);
  if (rc >= 0)
    return true;
  if (rc == -1)
    return false;
 
  char buf[PATH_MAX + 64];
  snprintf(buf, sizeof(buf), _("Create %s?"), mdata->name);
  const bool c_confirm_create = cs_subset_bool(NeoMutt->sub, "confirm_create");
  if (c_confirm_create &&
      (query_yesorno_help(buf, MUTT_YES, NeoMutt->sub, "confirm_create") != MUTT_YES))
    return false;
 
  if (imap_create_mailbox(adata, mdata->name) < 0)
    return false;
 
  return true;
}

Here is the call graph for this function:

maildir_mbox_open_append()

bool maildir_mbox_open_append	(	struct Mailbox *	m,
		OpenMailboxFlags	flags )

Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.

Definition at line 757 of file mailbox.c.

{
  if (!(flags & (MUTT_APPEND | MUTT_APPENDNEW)))
  {
    return true;
  }
 
  errno = 0;
  if ((mutt_file_mkdir(mailbox_path(m), S_IRWXU) != 0) && (errno != EEXIST))
  {
    mutt_perror("%s", mailbox_path(m));
    return false;
  }
 
  char tmp[PATH_MAX] = { 0 };
  snprintf(tmp, sizeof(tmp), "%s/cur", mailbox_path(m));
  errno = 0;
  if ((mkdir(tmp, S_IRWXU) != 0) && (errno != EEXIST))
  {
    mutt_perror("%s", tmp);
    rmdir(mailbox_path(m));
    return false;
  }
 
  snprintf(tmp, sizeof(tmp), "%s/new", mailbox_path(m));
  errno = 0;
  if ((mkdir(tmp, S_IRWXU) != 0) && (errno != EEXIST))
  {
    mutt_perror("%s", tmp);
    snprintf(tmp, sizeof(tmp), "%s/cur", mailbox_path(m));
    rmdir(tmp);
    rmdir(mailbox_path(m));
    return false;
  }
 
  snprintf(tmp, sizeof(tmp), "%s/tmp", mailbox_path(m));
  errno = 0;
  if ((mkdir(tmp, S_IRWXU) != 0) && (errno != EEXIST))
  {
    mutt_perror("%s", tmp);
    snprintf(tmp, sizeof(tmp), "%s/cur", mailbox_path(m));
    rmdir(tmp);
    snprintf(tmp, sizeof(tmp), "%s/new", mailbox_path(m));
    rmdir(tmp);
    rmdir(mailbox_path(m));
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

mbox_mbox_open_append()

static bool mbox_mbox_open_append ( struct Mailbox * m, OpenMailboxFlags flags )

static

Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.

Definition at line 881 of file mbox.c.

{
  if (init_mailbox(m) != 0)
    return false;
 
  struct MboxAccountData *adata = mbox_adata_get(m);
  if (!adata)
    return false;
 
  if (!adata->fp)
  {
    // create dir recursively
    char *tmp_path = mutt_path_dirname(mailbox_path(m));
    if (mutt_file_mkdir(tmp_path, S_IRWXU) == -1)
    {
      mutt_perror("%s", mailbox_path(m));
      FREE(&tmp_path);
      return false;
    }
    FREE(&tmp_path);
 
    adata->fp = mutt_file_fopen(mailbox_path(m), "a+");
    if (!adata->fp)
    {
      mutt_perror("%s", mailbox_path(m));
      return false;
    }
 
    if (mbox_lock_mailbox(m, true, true) != 0)
    {
      mutt_error(_("Couldn't lock %s"), mailbox_path(m));
      mutt_file_fclose(&adata->fp);
      return false;
    }
  }
 
  if (!mutt_file_seek(adata->fp, 0, SEEK_END))
  {
    mutt_file_fclose(&adata->fp);
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

mh_mbox_open_append()

static bool mh_mbox_open_append ( struct Mailbox * m, OpenMailboxFlags flags )

static

Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.

Definition at line 827 of file mh.c.

{
  if (!(flags & MUTT_APPENDNEW))
    return true;
 
  if (mutt_file_mkdir(mailbox_path(m), S_IRWXU))
  {
    mutt_perror("%s", mailbox_path(m));
    return false;
  }
 
  char tmp[PATH_MAX] = { 0 };
  snprintf(tmp, sizeof(tmp), "%s/.mh_sequences", mailbox_path(m));
  const int i = creat(tmp, S_IRUSR | S_IWUSR);
  if (i == -1)
  {
    mutt_perror("%s", tmp);
    rmdir(mailbox_path(m));
    return false;
  }
  close(i);
 
  return true;
}

Here is the call graph for this function: