compress.c File Reference

Compressed mbox local mailbox type. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "lib.h"
#include "format_flags.h"
#include "hook.h"
#include "mutt_commands.h"
#include "mutt_globals.h"
#include "muttlib.h"
#include "mx.h"
#include "protos.h"

Include dependency graph for compress.c:

Go to the source code of this file.

Functions
void	mutt_comp_init (void)
	Setup feature commands. More...
static bool	lock_realpath (struct Mailbox *m, bool excl)
	Try to lock the ctx->realpath. More...
static void	unlock_realpath (struct Mailbox *m)
	Unlock the mailbox->realpath. More...
static int	setup_paths (struct Mailbox *m)
	Set the mailbox paths. More...
static void	store_size (const struct Mailbox *m)
	Save the size of the compressed file. More...
static struct CompressInfo *	set_compress_info (struct Mailbox *m)
	Find the compress hooks for a mailbox. More...
static void	compress_info_free (struct Mailbox *m)
	Frees the compress info members and structure. More...
static const char *	compress_format_str (char *buf, size_t buflen, size_t col, int cols, char op, const char *src, const char *prec, const char *if_str, const char *else_str, intptr_t data, MuttFormatFlags flags)
	Expand the filenames in a command string - Implements format_t. More...
static void	expand_command_str (const struct Mailbox *m, const char *cmd, char *buf, int buflen)
	Expand placeholders in command string. More...
static int	execute_command (struct Mailbox *m, const char *command, const char *progress)
	Run a system command. More...
bool	mutt_comp_can_append (struct Mailbox *m)
	Can we append to this path? More...
bool	mutt_comp_can_read (const char *path)
	Can we read from this file? More...
int	mutt_comp_valid_command (const char *cmd)
	Is this command string allowed? More...
static struct Account *	comp_ac_find (struct Account *a, const char *path)
	Find an Account that matches a Mailbox path - Implements MxOps::ac_find() More...
static int	comp_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Implements MxOps::ac_add() More...
static int	comp_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() More...
static int	comp_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() More...
static int	comp_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() More...
static int	comp_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() More...
static int	comp_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() More...
static int	comp_msg_open (struct Mailbox *m, struct Message *msg, int msgno)
	Open an email message in a Mailbox - Implements MxOps::msg_open() More...
static int	comp_msg_open_new (struct Mailbox *m, struct Message *msg, const struct Email *e)
	Open a new message in a Mailbox - Implements MxOps::msg_open_new() More...
static int	comp_msg_commit (struct Mailbox *m, struct Message *msg)
	Save changes to an email - Implements MxOps::msg_commit() More...
static int	comp_msg_close (struct Mailbox *m, struct Message *msg)
	Close an email - Implements MxOps::msg_close() More...
static int	comp_msg_padding_size (struct Mailbox *m)
	Bytes of padding between messages - Implements MxOps::msg_padding_size() More...
static int	comp_msg_save_hcache (struct Mailbox *m, struct Email *e)
	Save message to the header cache - Implements MxOps::msg_save_hcache() More...
static int	comp_tags_edit (struct Mailbox *m, const char *tags, char *buf, size_t buflen)
	Prompt and validate new messages tags - Implements MxOps::tags_edit() More...
static int	comp_tags_commit (struct Mailbox *m, struct Email *e, char *buf)
	Save the tags to a message - Implements MxOps::tags_commit() More...
static enum MailboxType	comp_path_probe (const char *path, const struct stat *st)
	Is this a compressed Mailbox? - Implements MxOps::path_probe() More...
static int	comp_path_canon (char *buf, size_t buflen)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() More...
static int	comp_path_pretty (char *buf, size_t buflen, const char *folder)
	Abbreviate a Mailbox path - Implements MxOps::path_pretty() More...
static int	comp_path_parent (char *buf, size_t buflen)
	Find the parent of a Mailbox path - Implements MxOps::path_parent() More...

Variables
static const struct Command	comp_commands []
struct MxOps	MxCompOps
	Compressed Mailbox - Implements MxOps. More...

Detailed Description

Compressed mbox local mailbox type.

Authors

• Alain Penders
• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file compress.c.

Function Documentation

mutt_comp_init()

void mutt_comp_init

(

void

)

Setup feature commands.

Definition at line 66 of file compress.c.

{
  COMMANDS_REGISTER(comp_commands);
}

Here is the caller graph for this function:

lock_realpath()

static bool lock_realpath ( struct Mailbox *  m, bool  excl  )

static

Try to lock the ctx->realpath.

Parameters

m	Mailbox to lock
excl	Lock exclusively?

Return values

true	Success (locked or readonly)
false	Error (can't lock the file)

Try to (exclusively) lock the mailbox. If we succeed, then we mark the mailbox as locked. If we fail, but we didn't want exclusive rights, then the mailbox will be marked readonly.

Definition at line 82 of file compress.c.

{
  if (!m || !m->compress_info)
    return false;

  struct CompressInfo *ci = m->compress_info;

  if (ci->locked)
    return true;

  if (excl)
    ci->fp_lock = fopen(m->realpath, "a");
  else
    ci->fp_lock = fopen(m->realpath, "r");
  if (!ci->fp_lock)
  {
    mutt_perror(m->realpath);
    return false;
  }

  int r = mutt_file_lock(fileno(ci->fp_lock), excl, true);
  if (r == 0)
    ci->locked = true;
  else if (excl)
  {
    mutt_file_fclose(&ci->fp_lock);
    m->readonly = true;
    return true;
  }

  return r == 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unlock_realpath()

static void unlock_realpath ( struct Mailbox *  m )

static

Unlock the mailbox->realpath.

Parameters

m	Mailbox to unlock

Unlock a mailbox previously locked by lock_mailbox().

Definition at line 121 of file compress.c.

{
  if (!m || !m->compress_info)
    return;

  struct CompressInfo *ci = m->compress_info;

  if (!ci->locked)
    return;

  mutt_file_unlock(fileno(ci->fp_lock));

  ci->locked = false;
  mutt_file_fclose(&ci->fp_lock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_paths()

static int setup_paths ( struct Mailbox *  m )

static

Set the mailbox paths.

Parameters

m	Mailbox to modify

Return values

0	Success
-1	Error

Save the compressed filename in mailbox->realpath. Create a temporary filename and put its name in mailbox->path. The temporary file is created to prevent symlink attacks.

Definition at line 147 of file compress.c.

{
  if (!m)
    return -1;

  /* Setup the right paths */
  mutt_str_replace(&m->realpath, mailbox_path(m));

  /* We will uncompress to /tmp */
  struct Buffer *buf = mutt_buffer_pool_get();
  mutt_buffer_mktemp(buf);
  mutt_buffer_copy(&m->pathbuf, buf);
  mutt_buffer_pool_release(&buf);

  FILE *fp = mutt_file_fopen(mailbox_path(m), "w");
  if (!fp)
    return -1;

  mutt_file_fclose(&fp);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

store_size()

static void store_size ( const struct Mailbox *  m )

static

Save the size of the compressed file.

Parameters

m

Mailbox

Save the compressed file size in the compress_info struct.

Definition at line 175 of file compress.c.

{
  if (!m || !m->compress_info)
    return;

  struct CompressInfo *ci = m->compress_info;

  ci->size = mutt_file_get_size(m->realpath);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_compress_info()

static struct CompressInfo* set_compress_info ( struct Mailbox *  m )

static

Find the compress hooks for a mailbox.

Parameters

m	Mailbox to examine

Return values

ptr	CompressInfo Hook info for the mailbox's path
NULL	Error

When a mailbox is opened, we check if there are any matching hooks.

Definition at line 193 of file compress.c.

{
  if (!m)
    return NULL;

  if (m->compress_info)
    return m->compress_info;

  /* Open is compulsory */
  const char *o = mutt_find_hook(MUTT_OPEN_HOOK, mailbox_path(m));
  if (!o)
    return NULL;

  const char *c = mutt_find_hook(MUTT_CLOSE_HOOK, mailbox_path(m));
  const char *a = mutt_find_hook(MUTT_APPEND_HOOK, mailbox_path(m));

  struct CompressInfo *ci = mutt_mem_calloc(1, sizeof(struct CompressInfo));
  m->compress_info = ci;

  ci->cmd_open = mutt_str_dup(o);
  ci->cmd_close = mutt_str_dup(c);
  ci->cmd_append = mutt_str_dup(a);

  return ci;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compress_info_free()

static void compress_info_free ( struct Mailbox *  m )

static

Frees the compress info members and structure.

Parameters

m	Mailbox to free compress_info for

Definition at line 223 of file compress.c.

{
  if (!m || !m->compress_info)
    return;

  struct CompressInfo *ci = m->compress_info;
  FREE(&ci->cmd_open);
  FREE(&ci->cmd_close);
  FREE(&ci->cmd_append);

  unlock_realpath(m);

  FREE(&m->compress_info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

compress_format_str()

static const char* compress_format_str ( char *  buf, size_t  buflen, size_t  col, int  cols, char  op, const char *  src, const char *  prec, const char *  if_str, const char *  else_str, intptr_t  data, MuttFormatFlags  flags  )

static

Expand the filenames in a command string - Implements format_t.

Expando	Description
%f	Compressed file
%t	Plaintext, temporary file

Definition at line 246 of file compress.c.

{
  if (!buf || (data == 0))
    return src;

  struct Mailbox *m = (struct Mailbox *) data;

  /* NOTE the compressed file config vars expect %f and %t to be
   * surrounded by '' (unlike other NeoMutt config vars, which add the
   * outer quotes for the user).  This is why we use the
   * mutt_buffer_quote_filename() form with add_outer of false. */
  struct Buffer *quoted = mutt_buffer_pool_get();
  switch (op)
  {
    case 'f':
      /* Compressed file */
      mutt_buffer_quote_filename(quoted, m->realpath, false);
      snprintf(buf, buflen, "%s", mutt_b2s(quoted));
      break;
    case 't':
      /* Plaintext, temporary file */
      mutt_buffer_quote_filename(quoted, mailbox_path(m), false);
      snprintf(buf, buflen, "%s", mutt_b2s(quoted));
      break;
  }

  mutt_buffer_pool_release(&quoted);
  return src;
}

Here is the call graph for this function:

Here is the caller graph for this function:

expand_command_str()

static void expand_command_str ( const struct Mailbox *  m, const char *  cmd, char *  buf, int  buflen  )

static

Expand placeholders in command string.

Parameters

m	Mailbox for paths
cmd	Template command to be expanded
buf	Buffer to store the command
buflen	Size of the buffer

This function takes a hook command and expands the filename placeholders within it. The function calls mutt_expando_format() to do the replacement which calls our callback function compress_format_str(). e.g.

Template command: gzip -cd 'f' > 't'

Result: gzip -dc '~/mail/abc.gz' > '/tmp/xyz'

Definition at line 296 of file compress.c.

{
  if (!m || !cmd || !buf)
    return;

  mutt_expando_format(buf, buflen, 0, buflen, cmd, compress_format_str,
                      (intptr_t) m, MUTT_FORMAT_NO_FLAGS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

execute_command()

static int execute_command ( struct Mailbox *  m, const char *  command, const char *  progress  )

static

Run a system command.

Parameters

m	Mailbox to work with
command	Command string to execute
progress	Message to show the user

Return values

1	Success
0	Failure

Run the supplied command, taking care of all the NeoMutt requirements, such as locking files and blocking signals.

Definition at line 316 of file compress.c.

{
  if (!m || !command || !progress)
    return 0;

  if (m->verbose)
    mutt_message(progress, m->realpath);

  int rc = 1;
  char sys_cmd[STR_COMMAND];

  mutt_sig_block();
  endwin();
  fflush(stdout);

  expand_command_str(m, command, sys_cmd, sizeof(sys_cmd));

  if (mutt_system(sys_cmd) != 0)
  {
    rc = 0;
    mutt_any_key_to_continue(NULL);
    mutt_error(_("Error running \"%s\""), sys_cmd);
  }

  mutt_sig_unblock();

  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_comp_can_append()

bool mutt_comp_can_append

(

struct Mailbox *

m

)

Can we append to this path?

Parameters

m

Mailbox

Return values

true	Yes, we can append to the file
false	No, appending isn't possible

To append to a file we can either use an 'append-hook' or a combination of 'open-hook' and 'close-hook'.

A match means it's our responsibility to append to the file.

Definition at line 356 of file compress.c.

{
  if (!m)
    return false;

  /* If this succeeds, we know there's an open-hook */
  struct CompressInfo *ci = set_compress_info(m);
  if (!ci)
    return false;

  /* We have an open-hook, so to append we need an append-hook,
   * or a close-hook. */
  if (ci->cmd_append || ci->cmd_close)
    return true;

  mutt_error(_("Can't append without an append-hook or close-hook : %s"), mailbox_path(m));
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_comp_can_read()

bool mutt_comp_can_read

(

const char *

path

)

Can we read from this file?

Parameters

path	Pathname of file to be tested

Return values

true	Yes, we can read the file
false	No, we can't read the file

Search for an 'open-hook' with a regex that matches the path.

A match means it's our responsibility to open the file.

Definition at line 385 of file compress.c.

{
  if (!path)
    return false;

  if (mutt_find_hook(MUTT_OPEN_HOOK, path))
    return true;

  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_comp_valid_command()

int mutt_comp_valid_command

(

const char *

cmd

)

Is this command string allowed?

Parameters

cmd	Command string

Return values

1	Valid command
0	"%f" and/or "%t" is missing

A valid command string must have both "%f" (from file) and "%t" (to file). We don't check if we can actually run the command.

Definition at line 405 of file compress.c.

{
  if (!cmd)
    return 0;

  return strstr(cmd, "%f") && strstr(cmd, "%t");
}

Here is the caller graph for this function:

comp_ac_find()

static struct Account* comp_ac_find ( struct Account *  a, const char *  path  )

static

Find an Account that matches a Mailbox path - Implements MxOps::ac_find()

Definition at line 416 of file compress.c.

{
  return NULL;
}

comp_ac_add()

static int comp_ac_add ( struct Account *  a, struct Mailbox *  m  )

static

Add a Mailbox to an Account - Implements MxOps::ac_add()

Definition at line 424 of file compress.c.

{
  return 0;
}

comp_mbox_open()

static int comp_mbox_open ( struct Mailbox *  m )

static

Open a Mailbox - Implements MxOps::mbox_open()

Set up a compressed mailbox to be read. Decompress the mailbox and set up the paths and hooks needed. Then determine the type of the mailbox so we can delegate the handling of messages.

Definition at line 437 of file compress.c.

{
  struct CompressInfo *ci = set_compress_info(m);
  if (!ci)
    return -1;

  int rc;

  /* If there's no close-hook, or the file isn't writable */
  if (!ci->cmd_close || (access(mailbox_path(m), W_OK) != 0))
    m->readonly = true;

  if (setup_paths(m) != 0)
    goto cmo_fail;
  store_size(m);

  if (!lock_realpath(m, false))
  {
    mutt_error(_("Unable to lock mailbox"));
    goto cmo_fail;
  }

  rc = execute_command(m, ci->cmd_open, _("Decompressing %s"));
  if (rc == 0)
    goto cmo_fail;

  unlock_realpath(m);

  m->type = mx_path_probe(mailbox_path(m));
  if (m->type == MUTT_UNKNOWN)
  {
    mutt_error(_("Can't identify the contents of the compressed file"));
    goto cmo_fail;
  }

  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 cmo_fail;
  }

  m->account->type = m->type;
  return ci->child_ops->mbox_open(m);

cmo_fail:
  /* remove the partial uncompressed file */
  remove(mailbox_path(m));
  compress_info_free(m);
  return -1;
}

Here is the call graph for this function:

comp_mbox_open_append()

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

static

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

flags may also contain MUTT_NEWFOLDER

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

Definition at line 497 of file compress.c.

{
  /* If this succeeds, we know there's an open-hook */
  struct CompressInfo *ci = set_compress_info(m);
  if (!ci)
    return -1;

  /* 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))
  {
    int rc = execute_command(m, ci->cmd_open, _("Decompressing %s"));
    if (rc == 0)
    {
      mutt_error(_("Compress command failed: %s"), ci->cmd_open);
      goto cmoa_fail2;
    }
    m->type = mx_path_probe(mailbox_path(m));
  }
  else
    m->type = C_MboxType;

  /* 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) != 0)
    goto cmoa_fail2;

  return 0;

cmoa_fail2:
  /* remove the partial uncompressed file */
  remove(mailbox_path(m));
cmoa_fail1:
  /* Free the compress_info to prevent close from trying to recompress */
  compress_info_free(m);

  return -1;
}

Here is the call graph for this function:

comp_mbox_check()

static int comp_mbox_check ( struct Mailbox *  m )

static

Check for new mail - Implements MxOps::mbox_check()

Parameters

m

Mailbox

Return values

0	Mailbox OK
MUTT_REOPENED	The mailbox was closed and reopened
-1	Mailbox bad

If the compressed file changes in size but the mailbox hasn't been changed in NeoMutt, then we can close and reopen the mailbox.

If the mailbox has been changed in NeoMutt, warn the user.

The return codes are picked to match mx_mbox_check().

Definition at line 580 of file compress.c.

{
  if (!m->compress_info)
    return -1;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return -1;

  int size = mutt_file_get_size(m->realpath);
  if (size == ci->size)
    return 0;

  if (!lock_realpath(m, false))
  {
    mutt_error(_("Unable to lock mailbox"));
    return -1;
  }

  int rc = execute_command(m, ci->cmd_open, _("Decompressing %s"));
  store_size(m);
  unlock_realpath(m);
  if (rc == 0)
    return -1;

  return ops->mbox_check(m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

comp_mbox_sync()

static int comp_mbox_sync ( struct Mailbox *  m )

static

Save changes to the Mailbox - Implements MxOps::mbox_sync()

Changes in NeoMutt only affect the tmp file. Calling comp_mbox_sync() will commit them to the compressed file.

Definition at line 616 of file compress.c.

{
  if (!m->compress_info)
    return -1;

  struct CompressInfo *ci = m->compress_info;

  if (!ci->cmd_close)
  {
    mutt_error(_("Can't sync a compressed file without a close-hook"));
    return -1;
  }

  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return -1;

  if (!lock_realpath(m, true))
  {
    mutt_error(_("Unable to lock mailbox"));
    return -1;
  }

  int rc = comp_mbox_check(m);
  if (rc != 0)
    goto sync_cleanup;

  rc = ops->mbox_sync(m);
  if (rc != 0)
    goto sync_cleanup;

  rc = execute_command(m, ci->cmd_close, _("Compressing %s"));
  if (rc == 0)
  {
    rc = -1;
    goto sync_cleanup;
  }

  rc = 0;

sync_cleanup:
  store_size(m);
  unlock_realpath(m);
  return rc;
}

Here is the call graph for this function:

comp_mbox_close()

static int comp_mbox_close ( struct Mailbox *  m )

static

Close a Mailbox - Implements MxOps::mbox_close()

If the mailbox has been changed then re-compress the tmp file. Then delete the tmp file.

Definition at line 668 of file compress.c.

{
  if (!m->compress_info)
    return -1;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops)
  {
    compress_info_free(m);
    return -1;
  }

  ops->mbox_close(m);

  /* sync has already been called, so we only need to delete some files */
  if (m->append)
  {
    const char *append = NULL;
    const char *msg = NULL;

    /* The file exists and we can append */
    if ((access(m->realpath, F_OK) == 0) && ci->cmd_append)
    {
      append = ci->cmd_append;
      msg = _("Compressed-appending to %s...");
    }
    else
    {
      append = ci->cmd_close;
      msg = _("Compressing %s");
    }

    int rc = execute_command(m, append, msg);
    if (rc == 0)
    {
      mutt_any_key_to_continue(NULL);
      mutt_error(_("Error. Preserving temporary file: %s"), mailbox_path(m));
    }
    else
      remove(mailbox_path(m));

    unlock_realpath(m);
  }
  else
  {
    /* If the file was removed, remove the compressed folder too */
    if ((access(mailbox_path(m), F_OK) != 0) && !C_SaveEmpty)
    {
      remove(m->realpath);
    }
    else
    {
      remove(mailbox_path(m));
    }
  }

  compress_info_free(m);

  return 0;
}

Here is the call graph for this function:

comp_msg_open()

static int comp_msg_open ( struct Mailbox *  m, struct Message *  msg, int  msgno  )

static

Open an email message in a Mailbox - Implements MxOps::msg_open()

Definition at line 734 of file compress.c.

{
  if (!m->compress_info)
    return -1;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return -1;

  /* Delegate */
  return ops->msg_open(m, msg, msgno);
}

comp_msg_open_new()

static int comp_msg_open_new ( struct Mailbox *  m, struct Message *  msg, const struct Email *  e  )

static

Open a new message in a Mailbox - Implements MxOps::msg_open_new()

Definition at line 752 of file compress.c.

{
  if (!m->compress_info)
    return -1;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return -1;

  /* Delegate */
  return ops->msg_open_new(m, msg, e);
}

comp_msg_commit()

static int comp_msg_commit ( struct Mailbox *  m, struct Message *  msg  )

static

Save changes to an email - Implements MxOps::msg_commit()

Definition at line 770 of file compress.c.

{
  if (!m->compress_info)
    return -1;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return -1;

  /* Delegate */
  return ops->msg_commit(m, msg);
}

comp_msg_close()

static int comp_msg_close ( struct Mailbox *  m, struct Message *  msg  )

static

Close an email - Implements MxOps::msg_close()

Definition at line 788 of file compress.c.

{
  if (!m->compress_info)
    return -1;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops)
    return -1;

  /* Delegate */
  return ops->msg_close(m, msg);
}

comp_msg_padding_size()

static int comp_msg_padding_size ( struct Mailbox *  m )

static

Bytes of padding between messages - Implements MxOps::msg_padding_size()

Definition at line 806 of file compress.c.

{
  if (!m->compress_info)
    return 0;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops || !ops->msg_padding_size)
    return 0;

  return ops->msg_padding_size(m);
}

comp_msg_save_hcache()

static int comp_msg_save_hcache ( struct Mailbox *  m, struct Email *  e  )

static

Save message to the header cache - Implements MxOps::msg_save_hcache()

Definition at line 823 of file compress.c.

{
  if (!m->compress_info)
    return 0;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops || !ops->msg_save_hcache)
    return 0;

  return ops->msg_save_hcache(m, e);
}

comp_tags_edit()

static int comp_tags_edit ( struct Mailbox *  m, const char *  tags, char *  buf, size_t  buflen  )

static

Prompt and validate new messages tags - Implements MxOps::tags_edit()

Definition at line 840 of file compress.c.

{
  if (!m->compress_info)
    return 0;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops || !ops->tags_edit)
    return 0;

  return ops->tags_edit(m, tags, buf, buflen);
}

comp_tags_commit()

static int comp_tags_commit ( struct Mailbox *  m, struct Email *  e, char *  buf  )

static

Save the tags to a message - Implements MxOps::tags_commit()

Definition at line 857 of file compress.c.

{
  if (!m->compress_info)
    return 0;

  struct CompressInfo *ci = m->compress_info;

  const struct MxOps *ops = ci->child_ops;
  if (!ops || !ops->tags_commit)
    return 0;

  return ops->tags_commit(m, e, buf);
}

comp_path_probe()

static enum MailboxType comp_path_probe ( const char *  path, const struct stat *  st  )

static

Is this a compressed Mailbox? - Implements MxOps::path_probe()

Definition at line 874 of file compress.c.

{
  if (!st || !S_ISREG(st->st_mode))
    return MUTT_UNKNOWN;

  if (mutt_comp_can_read(path))
    return MUTT_COMPRESSED;

  return MUTT_UNKNOWN;
}

Here is the call graph for this function:

comp_path_canon()

static int comp_path_canon ( char *  buf, size_t  buflen  )

static

Canonicalise a Mailbox path - Implements MxOps::path_canon()

Definition at line 888 of file compress.c.

{
  mutt_path_canon(buf, buflen, HomeDir, false);
  return 0;
}

Here is the call graph for this function:

comp_path_pretty()

static int comp_path_pretty ( char *  buf, size_t  buflen, const char *  folder  )

static

Abbreviate a Mailbox path - Implements MxOps::path_pretty()

Definition at line 897 of file compress.c.

{
  if (mutt_path_abbr_folder(buf, buflen, folder))
    return 0;

  if (mutt_path_pretty(buf, buflen, HomeDir, false))
    return 0;

  return -1;
}

Here is the call graph for this function:

comp_path_parent()

static int comp_path_parent ( char *  buf, size_t  buflen  )

static

Find the parent of a Mailbox path - Implements MxOps::path_parent()

Definition at line 911 of file compress.c.

{
  if (mutt_path_parent(buf, buflen))
    return 0;

  if (buf[0] == '~')
    mutt_path_canon(buf, buflen, HomeDir, false);

  if (mutt_path_parent(buf, buflen))
    return 0;

  return -1;
}

Here is the call graph for this function:

Variable Documentation

comp_commands

const struct Command comp_commands[]

static

Initial value:

= {
  
  { "append-hook", mutt_parse_hook, MUTT_APPEND_HOOK },
  { "close-hook",  mutt_parse_hook, MUTT_CLOSE_HOOK },
  { "open-hook",   mutt_parse_hook, MUTT_OPEN_HOOK },
  
}

Definition at line 55 of file compress.c.

MxCompOps

struct MxOps MxCompOps

Initial value:

= {
  .type            = MUTT_COMPRESSED,
  .name             = "compressed",
  .is_local         = true,
  .ac_find          = comp_ac_find,
  .ac_add           = comp_ac_add,
  .mbox_open        = comp_mbox_open,
  .mbox_open_append = comp_mbox_open_append,
  .mbox_check       = comp_mbox_check,
  .mbox_check_stats = NULL,
  .mbox_sync        = comp_mbox_sync,
  .mbox_close       = comp_mbox_close,
  .msg_open         = comp_msg_open,
  .msg_open_new     = comp_msg_open_new,
  .msg_commit       = comp_msg_commit,
  .msg_close        = comp_msg_close,
  .msg_padding_size = comp_msg_padding_size,
  .msg_save_hcache  = comp_msg_save_hcache,
  .tags_edit        = comp_tags_edit,
  .tags_commit      = comp_tags_commit,
  .path_probe       = comp_path_probe,
  .path_canon       = comp_path_canon,
  .path_pretty      = comp_path_pretty,
  .path_parent      = comp_path_parent,
  .path_is_empty    = NULL,
}

Compressed Mailbox - Implements MxOps.

Compress only uses open, close and check. The message functions are delegated to mbox.

Definition at line 932 of file compress.c.