compress.c File Reference

Compressed mbox local mailbox type. More...

#include "config.h"
#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "lib.h"
#include "expando/lib.h"
#include "expando.h"
#include "hook.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 Compressed Mailbox commands.
static bool	lock_realpath (struct Mailbox *m, bool excl)
	Try to lock the Mailbox.realpath.
static void	unlock_realpath (struct Mailbox *m)
	Unlock the mailbox->realpath.
static int	setup_paths (struct Mailbox *m)
	Set the mailbox paths.
static void	store_size (const struct Mailbox *m)
	Save the size of the compressed file.
static struct Expando *	validate_compress_expando (const char *s)
	Validate the Compress hooks.
static struct CompressInfo *	set_compress_info (struct Mailbox *m)
	Find the compress hooks for a mailbox.
static void	compress_info_free (struct Mailbox *m)
	Frees the compress info members and structure.
static bool	execute_command (struct Mailbox *m, const struct Expando *exp, const char *progress)
	Run a system command.
bool	mutt_comp_can_append (struct Mailbox *m)
	Can we append to this path?
bool	mutt_comp_can_read (const char *path)
	Can we read from this file?
int	mutt_comp_valid_command (const char *cmd)
	Is this command string allowed?
static bool	comp_ac_owns_path (struct Account *a, const char *path)
	Check whether an Account owns a Mailbox path - Implements MxOps::ac_owns_path() -.
static bool	comp_ac_add (struct Account *a, struct Mailbox *m)
	Add a Mailbox to an Account - Implements MxOps::ac_add() -.
static enum MxOpenReturns	comp_mbox_open (struct Mailbox *m)
	Open a Mailbox - Implements MxOps::mbox_open() -.
static bool	comp_mbox_open_append (struct Mailbox *m, OpenMailboxFlags flags)
	Open a Mailbox for appending - Implements MxOps::mbox_open_append() -.
static enum MxStatus	comp_mbox_check (struct Mailbox *m)
	Check for new mail - Implements MxOps::mbox_check() -.
static enum MxStatus	comp_mbox_sync (struct Mailbox *m)
	Save changes to the Mailbox - Implements MxOps::mbox_sync() -.
static enum MxStatus	comp_mbox_close (struct Mailbox *m)
	Close a Mailbox - Implements MxOps::mbox_close() -.
static bool	comp_msg_open (struct Mailbox *m, struct Message *msg, struct Email *e)
	Open an email message in a Mailbox - Implements MxOps::msg_open() -.
static bool	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() -.
static int	comp_msg_commit (struct Mailbox *m, struct Message *msg)
	Save changes to an email - Implements MxOps::msg_commit() -.
static int	comp_msg_close (struct Mailbox *m, struct Message *msg)
	Close an email - Implements MxOps::msg_close() -.
static int	comp_msg_padding_size (struct Mailbox *m)
	Bytes of padding between messages - Implements MxOps::msg_padding_size() -.
static int	comp_msg_save_hcache (struct Mailbox *m, struct Email *e)
	Save message to the header cache - Implements MxOps::msg_save_hcache() -.
static int	comp_tags_edit (struct Mailbox *m, const char *tags, struct Buffer *buf)
	Prompt and validate new messages tags - Implements MxOps::tags_edit() -.
static int	comp_tags_commit (struct Mailbox *m, struct Email *e, const char *buf)
	Save the tags to a message - Implements MxOps::tags_commit() -.
static enum MailboxType	comp_path_probe (const char *path, const struct stat *st)
	Is this a compressed Mailbox?
static int	comp_path_canon (struct Buffer *path)
	Canonicalise a Mailbox path - Implements MxOps::path_canon() -.

Variables
static const struct Command	CompCommands []
	Compression Commands.
const struct ExpandoDefinition	CompressFormatDef []
	Expando definitions.
const struct MxOps	MxCompOps
	Compressed Mailbox - Implements MxOps -.

Detailed Description

Compressed mbox local mailbox type.

Authors

• Richard Russon
• Pietro Cerutti
• Reto Brunner
• Tóth János

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 Compressed Mailbox commands.

Definition at line 100 of file compress.c.

{
  commands_register(&NeoMutt->commands, CompCommands);
}

Here is the call graph for this function:

Here is the caller graph for this function:

lock_realpath()

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

static

Try to lock the Mailbox.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 116 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 = mutt_file_fopen(m->realpath, "a");
  else
    ci->fp_lock = mutt_file_fopen(m->realpath, "r");
  if (!ci->fp_lock)
  {
    mutt_perror("%s", 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 157 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 183 of file compress.c.

{
  if (!m)
    return -1;
 
  /* Setup the right paths */
  mutt_str_replace(&m->realpath, mailbox_path(m));
 
  /* We will uncompress to TMPDIR */
  struct Buffer *buf = buf_pool_get();
  buf_mktemp(buf);
  buf_copy(&m->pathbuf, buf);
  buf_pool_release(&buf);
 
  return mutt_file_touch(mailbox_path(m)) ? 0 : -1;
}

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 206 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:

validate_compress_expando()

static struct Expando * validate_compress_expando ( const char * s )

static

Validate the Compress hooks.

Parameters

s	Command string

Return values

ptr

Expando

Definition at line 221 of file compress.c.

{
  struct Buffer *err = buf_pool_get();
 
  struct Expando *exp = expando_parse(s, CompressFormatDef, err);
  if (!exp)
  {
    mutt_error(_("Expando parse error: %s"), buf_string(err));
  }
 
  buf_pool_release(&err);
  return exp;
}

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 243 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, struct CompressInfo);
  m->compress_info = ci;
 
  ci->cmd_open = validate_compress_expando(o);
  ci->cmd_close = validate_compress_expando(c);
  ci->cmd_append = validate_compress_expando(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 273 of file compress.c.

{
  if (!m || !m->compress_info)
    return;
 
  struct CompressInfo *ci = m->compress_info;
  expando_free(&ci->cmd_open);
  expando_free(&ci->cmd_close);
  expando_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:

execute_command()

static bool execute_command ( struct Mailbox * m, const struct Expando * exp, const char * progress )

static

Run a system command.

Parameters

m	Mailbox to work with
exp	Command expando to execute
progress	Message to show the user

Return values

true	Success
false	Failure

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

Definition at line 299 of file compress.c.

{
  if (!m || !exp || !progress)
    return false;
 
  if (m->verbose)
    mutt_message(progress, m->realpath);
 
  bool rc = true;
  struct Buffer *sys_cmd = buf_pool_get();
  buf_alloc(sys_cmd, STR_COMMAND);
 
  mutt_sig_block();
  mutt_endwin();
  fflush(stdout);
 
  expando_render(exp, CompressRenderCallbacks, m, MUTT_FORMAT_NO_FLAGS,
                 sys_cmd->dsize, sys_cmd);
 
  if (mutt_system(buf_string(sys_cmd)) != 0)
  {
    rc = false;
    mutt_any_key_to_continue(NULL);
    mutt_error(_("Error running \"%s\""), buf_string(sys_cmd));
  }
 
  mutt_sig_unblock();
 
  buf_pool_release(&sys_cmd);
  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 342 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 371 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 391 of file compress.c.

{
  if (!cmd)
    return 0;
 
  return strstr(cmd, "%f") && strstr(cmd, "%t");
}

Here is the caller graph for this function:

Variable Documentation

CompCommands

const struct Command CompCommands[]

static

Initial value:

= {
  
  { "append-hook", parse_hook_compress, MUTT_APPEND_HOOK,
        N_("Define command to append to a compressed mailbox"),
        N_("append-hook <regex> <shell-command>"),
        "optionalfeatures.html#append-hook" },
  { "close-hook", parse_hook_compress, MUTT_CLOSE_HOOK,
        N_("Define command to close a compressed mailbox"),
        N_("close-hook <regex> <shell-command>"),
        "optionalfeatures.html#close-hook" },
  { "open-hook", parse_hook_compress, MUTT_OPEN_HOOK,
        N_("Define command to open a compressed mailbox"),
        N_("open-hook <regex> <shell-command>"),
        "optionalfeatures.html#open-hook" },
 
  { NULL, NULL, 0, NULL, NULL, NULL, CF_NO_FLAGS },
  
}

Compression Commands.

Definition at line 62 of file compress.c.

                                             {
  // clang-format off
  { "append-hook", parse_hook_compress, MUTT_APPEND_HOOK,
        N_("Define command to append to a compressed mailbox"),
        N_("append-hook <regex> <shell-command>"),
        "optionalfeatures.html#append-hook" },
  { "close-hook", parse_hook_compress, MUTT_CLOSE_HOOK,
        N_("Define command to close a compressed mailbox"),
        N_("close-hook <regex> <shell-command>"),
        "optionalfeatures.html#close-hook" },
  { "open-hook", parse_hook_compress, MUTT_OPEN_HOOK,
        N_("Define command to open a compressed mailbox"),
        N_("open-hook <regex> <shell-command>"),
        "optionalfeatures.html#open-hook" },
 
  { NULL, NULL, 0, NULL, NULL, NULL, CF_NO_FLAGS },
  // clang-format on
};

CompressFormatDef

const struct ExpandoDefinition CompressFormatDef[]

Initial value:

= {
  
  { "f", "from", ED_COMPRESS, ED_CMP_FROM, NULL },
  { "t", "to",   ED_COMPRESS, ED_CMP_TO,   NULL },
  { NULL, NULL, 0, -1, NULL }
  
}

Expando definitions.

Config:

• append-hook
• close-hook
• open-hook

Definition at line 89 of file compress.c.

                                                     {
  // clang-format off
  { "f", "from", ED_COMPRESS, ED_CMP_FROM, NULL },
  { "t", "to",   ED_COMPRESS, ED_CMP_TO,   NULL },
  { NULL, NULL, 0, -1, NULL }
  // clang-format on
};