NeoMutt  2020-06-26-89-g172cd3
Teaching an old dog new tricks
DOXYGEN
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_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

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 CompressInfoset_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 Accountcomp_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, 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

struct MxOps MxCompOps
 Compressed Mailbox - Implements MxOps. More...
 

Detailed Description

Compressed mbox local mailbox type.

Authors
  • Alain Penders
  • Richard Russon

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

◆ lock_realpath()

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

Try to lock the ctx->realpath.

Parameters
mMailbox to lock
exclLock exclusively?
Return values
trueSuccess (locked or readonly)
falseError (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 65 of file compress.c.

66 {
67  if (!m || !m->compress_info)
68  return false;
69 
70  struct CompressInfo *ci = m->compress_info;
71 
72  if (ci->locked)
73  return true;
74 
75  if (excl)
76  ci->fp_lock = fopen(m->realpath, "a");
77  else
78  ci->fp_lock = fopen(m->realpath, "r");
79  if (!ci->fp_lock)
80  {
82  return false;
83  }
84 
85  int r = mutt_file_lock(fileno(ci->fp_lock), excl, true);
86  if (r == 0)
87  ci->locked = true;
88  else if (excl)
89  {
91  m->readonly = true;
92  return true;
93  }
94 
95  return r == 0;
96 }
#define mutt_perror(...)
Definition: logging.h:85
FILE * fp_lock
fp used for locking
Definition: lib.h:56
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:84
bool locked
if realpath is locked
Definition: lib.h:55
int mutt_file_lock(int fd, bool excl, bool timeout)
(try to) lock a file using fcntl()
Definition: file.c:1168
bool readonly
Don&#39;t allow changes to the mailbox.
Definition: mailbox.h:119
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
+ 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
mMailbox to unlock

Unlock a mailbox previously locked by lock_mailbox().

Definition at line 104 of file compress.c.

105 {
106  if (!m || !m->compress_info)
107  return;
108 
109  struct CompressInfo *ci = m->compress_info;
110 
111  if (!ci->locked)
112  return;
113 
114  mutt_file_unlock(fileno(ci->fp_lock));
115 
116  ci->locked = false;
118 }
FILE * fp_lock
fp used for locking
Definition: lib.h:56
bool locked
if realpath is locked
Definition: lib.h:55
int mutt_file_unlock(int fd)
Unlock a file previously locked by mutt_file_lock()
Definition: file.c:1216
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
+ 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
mMailbox to modify
Return values
0Success
-1Error

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 130 of file compress.c.

131 {
132  if (!m)
133  return -1;
134 
135  /* Setup the right paths */
137 
138  /* We will uncompress to /tmp */
139  struct Buffer *buf = mutt_buffer_pool_get();
140  mutt_buffer_mktemp(buf);
141  mutt_buffer_copy(&m->pathbuf, buf);
143 
144  FILE *fp = mutt_file_fopen(mailbox_path(m), "w");
145  if (!fp)
146  return -1;
147 
148  mutt_file_fclose(&fp);
149  return 0;
150 }
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox&#39;s path string.
Definition: mailbox.h:196
#define mutt_buffer_mktemp(buf)
Definition: muttlib.h:77
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
size_t mutt_buffer_copy(struct Buffer *dst, const struct Buffer *src)
Copy a Buffer&#39;s contents to another Buffer.
Definition: buffer.c:445
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:84
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
int mutt_file_fclose(FILE **fp)
Close a FILE handle (and NULL the pointer)
Definition: file.c:153
char * mutt_str_replace(char **p, const char *s)
Replace one string with another.
Definition: string.c:451
struct Buffer pathbuf
Definition: mailbox.h:83
FILE * mutt_file_fopen(const char *path, const char *mode)
Call fopen() safely.
Definition: file.c:588
+ 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
mMailbox

Save the compressed file size in the compress_info struct.

Definition at line 158 of file compress.c.

159 {
160  if (!m || !m->compress_info)
161  return;
162 
163  struct CompressInfo *ci = m->compress_info;
164 
165  ci->size = mutt_file_get_size(m->realpath);
166 }
long mutt_file_get_size(const char *path)
Get the size of a file.
Definition: file.c:1488
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:84
long size
size of the compressed file
Definition: lib.h:53
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
+ 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
mMailbox to examine
Return values
ptrCompressInfo Hook info for the mailbox's path
NULLError

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

Definition at line 176 of file compress.c.

177 {
178  if (!m)
179  return NULL;
180 
181  if (m->compress_info)
182  return m->compress_info;
183 
184  /* Open is compulsory */
185  const char *o = mutt_find_hook(MUTT_OPEN_HOOK, mailbox_path(m));
186  if (!o)
187  return NULL;
188 
189  const char *c = mutt_find_hook(MUTT_CLOSE_HOOK, mailbox_path(m));
190  const char *a = mutt_find_hook(MUTT_APPEND_HOOK, mailbox_path(m));
191 
192  struct CompressInfo *ci = mutt_mem_calloc(1, sizeof(struct CompressInfo));
193  m->compress_info = ci;
194 
195  ci->cmd_open = mutt_str_dup(o);
196  ci->cmd_close = mutt_str_dup(c);
197  ci->cmd_append = mutt_str_dup(a);
198 
199  return ci;
200 }
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox&#39;s path string.
Definition: mailbox.h:196
void * mutt_mem_calloc(size_t nmemb, size_t size)
Allocate zeroed memory on the heap.
Definition: memory.c:50
const char * cmd_append
append-hook command
Definition: lib.h:50
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:375
const char * cmd_close
close-hook command
Definition: lib.h:51
#define MUTT_APPEND_HOOK
append-hook: append to a compressed mailbox
Definition: hook.h:59
char * mutt_find_hook(HookFlags type, const char *pat)
Find a matching hook.
Definition: hook.c:552
#define MUTT_CLOSE_HOOK
close-hook: write to a compressed mailbox
Definition: hook.h:60
#define MUTT_OPEN_HOOK
open-hook: to read a compressed mailbox
Definition: hook.h:58
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const char * cmd_open
open-hook command
Definition: lib.h:52
+ 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
mMailbox to free compress_info for

Definition at line 206 of file compress.c.

207 {
208  if (!m || !m->compress_info)
209  return;
210 
211  struct CompressInfo *ci = m->compress_info;
212  FREE(&ci->cmd_open);
213  FREE(&ci->cmd_close);
214  FREE(&ci->cmd_append);
215 
216  unlock_realpath(m);
217 
218  FREE(&m->compress_info);
219 }
const char * cmd_append
append-hook command
Definition: lib.h:50
const char * cmd_close
close-hook command
Definition: lib.h:51
static void unlock_realpath(struct Mailbox *m)
Unlock the mailbox->realpath.
Definition: compress.c:104
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
#define FREE(x)
Definition: memory.h:40
const char * cmd_open
open-hook command
Definition: lib.h:52
+ 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 229 of file compress.c.

233 {
234  if (!buf || (data == 0))
235  return src;
236 
237  struct Mailbox *m = (struct Mailbox *) data;
238 
239  /* NOTE the compressed file config vars expect %f and %t to be
240  * surrounded by '' (unlike other NeoMutt config vars, which add the
241  * outer quotes for the user). This is why we use the
242  * mutt_buffer_quote_filename() form with add_outer of false. */
243  struct Buffer *quoted = mutt_buffer_pool_get();
244  switch (op)
245  {
246  case 'f':
247  /* Compressed file */
248  mutt_buffer_quote_filename(quoted, m->realpath, false);
249  snprintf(buf, buflen, "%s", mutt_b2s(quoted));
250  break;
251  case 't':
252  /* Plaintext, temporary file */
253  mutt_buffer_quote_filename(quoted, mailbox_path(m), false);
254  snprintf(buf, buflen, "%s", mutt_b2s(quoted));
255  break;
256  }
257 
258  mutt_buffer_pool_release(&quoted);
259  return src;
260 }
void mutt_buffer_quote_filename(struct Buffer *buf, const char *filename, bool add_outer)
Quote a filename to survive the shell&#39;s quoting rules.
Definition: file.c:836
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox&#39;s path string.
Definition: mailbox.h:196
struct Buffer * mutt_buffer_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:101
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:84
void mutt_buffer_pool_release(struct Buffer **pbuf)
Free a Buffer from the pool.
Definition: pool.c:112
String manipulation buffer.
Definition: buffer.h:33
#define mutt_b2s(buf)
Definition: buffer.h:41
A mailbox.
Definition: mailbox.h:81
+ 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
mMailbox for paths
cmdTemplate command to be expanded
bufBuffer to store the command
buflenSize 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 279 of file compress.c.

280 {
281  if (!m || !cmd || !buf)
282  return;
283 
284  mutt_expando_format(buf, buflen, 0, buflen, cmd, compress_format_str,
285  (intptr_t) m, MUTT_FORMAT_NO_FLAGS);
286 }
#define MUTT_FORMAT_NO_FLAGS
No flags are set.
Definition: format_flags.h:30
void mutt_expando_format(char *buf, size_t buflen, size_t col, int cols, const char *src, format_t *callback, intptr_t data, MuttFormatFlags flags)
Expand expandos (x) in a string.
Definition: muttlib.c:772
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.
Definition: compress.c:229
+ 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
mMailbox to work with
commandCommand string to execute
progressMessage to show the user
Return values
1Success
0Failure

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.

300 {
301  if (!m || !command || !progress)
302  return 0;
303 
304  if (m->verbose)
305  mutt_message(progress, m->realpath);
306 
307  int rc = 1;
308  char sys_cmd[STR_COMMAND];
309 
310  mutt_sig_block();
311  endwin();
312  fflush(stdout);
313 
314  expand_command_str(m, command, sys_cmd, sizeof(sys_cmd));
315 
316  if (mutt_system(sys_cmd) != 0)
317  {
318  rc = 0;
320  mutt_error(_("Error running \"%s\""), sys_cmd);
321  }
322 
324 
325  return rc;
326 }
void mutt_sig_unblock(void)
Restore previously blocked signals.
Definition: signal.c:168
#define mutt_message(...)
Definition: logging.h:83
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:84
#define _(a)
Definition: message.h:28
bool verbose
Display status messages?
Definition: mailbox.h:118
#define STR_COMMAND
Enough space for a long command line.
Definition: string2.h:35
int mutt_any_key_to_continue(const char *s)
Prompt the user to &#39;press any key&#39; and wait.
Definition: curs_lib.c:602
#define mutt_error(...)
Definition: logging.h:84
void mutt_sig_block(void)
Block signals during critical operations.
Definition: signal.c:150
static void expand_command_str(const struct Mailbox *m, const char *cmd, char *buf, int buflen)
Expand placeholders in command string.
Definition: compress.c:279
int mutt_system(const char *cmd)
Run an external command.
Definition: system.c:51
+ 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
mMailbox
Return values
trueYes, we can append to the file
falseNo, 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 339 of file compress.c.

340 {
341  if (!m)
342  return false;
343 
344  /* If this succeeds, we know there's an open-hook */
345  struct CompressInfo *ci = set_compress_info(m);
346  if (!ci)
347  return false;
348 
349  /* We have an open-hook, so to append we need an append-hook,
350  * or a close-hook. */
351  if (ci->cmd_append || ci->cmd_close)
352  return true;
353 
354  mutt_error(_("Can't append without an append-hook or close-hook : %s"), mailbox_path(m));
355  return false;
356 }
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox&#39;s path string.
Definition: mailbox.h:196
const char * cmd_append
append-hook command
Definition: lib.h:50
#define _(a)
Definition: message.h:28
const char * cmd_close
close-hook command
Definition: lib.h:51
static struct CompressInfo * set_compress_info(struct Mailbox *m)
Find the compress hooks for a mailbox.
Definition: compress.c:176
Private data for compress.
Definition: lib.h:48
#define mutt_error(...)
Definition: logging.h:84
+ 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
pathPathname of file to be tested
Return values
trueYes, we can read the file
falseNo, 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 368 of file compress.c.

369 {
370  if (!path)
371  return false;
372 
373  if (mutt_find_hook(MUTT_OPEN_HOOK, path))
374  return true;
375 
376  return false;
377 }
char * mutt_find_hook(HookFlags type, const char *pat)
Find a matching hook.
Definition: hook.c:552
#define MUTT_OPEN_HOOK
open-hook: to read a compressed mailbox
Definition: hook.h:58
+ 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
cmdCommand string
Return values
1Valid 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 388 of file compress.c.

389 {
390  if (!cmd)
391  return 0;
392 
393  return strstr(cmd, "%f") && strstr(cmd, "%t");
394 }
+ 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 399 of file compress.c.

400 {
401  return NULL;
402 }

◆ 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 407 of file compress.c.

408 {
409  if (!a || !m || (m->type != MUTT_COMPRESSED))
410  return -1;
411  return 0;
412 }
enum MailboxType type
Mailbox type.
Definition: mailbox.h:105
Compressed file Mailbox type.
Definition: mailbox.h:56

◆ 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 422 of file compress.c.

423 {
424  if (!m || (m->type != MUTT_COMPRESSED))
425  return -1;
426 
427  struct CompressInfo *ci = set_compress_info(m);
428  if (!ci)
429  return -1;
430 
431  int rc;
432 
433  /* If there's no close-hook, or the file isn't writable */
434  if (!ci->cmd_close || (access(mailbox_path(m), W_OK) != 0))
435  m->readonly = true;
436 
437  if (setup_paths(m) != 0)
438  goto cmo_fail;
439  store_size(m);
440 
441  if (!lock_realpath(m, false))
442  {
443  mutt_error(_("Unable to lock mailbox"));
444  goto cmo_fail;
445  }
446 
447  rc = execute_command(m, ci->cmd_open, _("Decompressing %s"));
448  if (rc == 0)
449  goto cmo_fail;
450 
451  unlock_realpath(m);
452 
454  if (m->type == MUTT_UNKNOWN)
455  {
456  mutt_error(_("Can't identify the contents of the compressed file"));
457  goto cmo_fail;
458  }
459 
460  ci->child_ops = mx_get_ops(m->type);
461  if (!ci->child_ops)
462  {
463  mutt_error(_("Can't find mailbox ops for mailbox type %d"), m->type);
464  goto cmo_fail;
465  }
466 
467  m->account->type = m->type;
468  return ci->child_ops->mbox_open(m);
469 
470 cmo_fail:
471  /* remove the partial uncompressed file */
472  remove(mailbox_path(m));
474  return -1;
475 }
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox&#39;s path string.
Definition: mailbox.h:196
const struct MxOps * mx_get_ops(enum MailboxType type)
Get mailbox operations.
Definition: mx.c:141
enum MailboxType type
Mailbox type.
Definition: mailbox.h:105
static void compress_info_free(struct Mailbox *m)
Frees the compress info members and structure.
Definition: compress.c:206
#define _(a)
Definition: message.h:28
Mailbox wasn&#39;t recognised.
Definition: mailbox.h:47
enum MailboxType type
Type of Mailboxes this Account contains.
Definition: account.h:38
int(* mbox_open)(struct Mailbox *m)
Open a Mailbox.
Definition: mx.h:136
const char * cmd_close
close-hook command
Definition: lib.h:51
static void store_size(const struct Mailbox *m)
Save the size of the compressed file.
Definition: compress.c:158
bool readonly
Don&#39;t allow changes to the mailbox.
Definition: mailbox.h:119
static struct CompressInfo * set_compress_info(struct Mailbox *m)
Find the compress hooks for a mailbox.
Definition: compress.c:176
Compressed file Mailbox type.
Definition: mailbox.h:56
static void unlock_realpath(struct Mailbox *m)
Unlock the mailbox->realpath.
Definition: compress.c:104
Private data for compress.
Definition: lib.h:48
static int execute_command(struct Mailbox *m, const char *command, const char *progress)
Run a system command.
Definition: compress.c:299
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1327
struct Account * account
Account that owns this Mailbox.
Definition: mailbox.h:131
#define mutt_error(...)
Definition: logging.h:84
static bool lock_realpath(struct Mailbox *m, bool excl)
Try to lock the ctx->realpath.
Definition: compress.c:65
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
const char * cmd_open
open-hook command
Definition: lib.h:52
static int setup_paths(struct Mailbox *m)
Set the mailbox paths.
Definition: compress.c:130
+ 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 485 of file compress.c.

486 {
487  if (!m)
488  return -1;
489 
490  /* If this succeeds, we know there's an open-hook */
491  struct CompressInfo *ci = set_compress_info(m);
492  if (!ci)
493  return -1;
494 
495  /* To append we need an append-hook or a close-hook */
496  if (!ci->cmd_append && !ci->cmd_close)
497  {
498  mutt_error(_("Can't append without an append-hook or close-hook : %s"),
499  mailbox_path(m));
500  goto cmoa_fail1;
501  }
502 
503  if (setup_paths(m) != 0)
504  goto cmoa_fail2;
505 
506  /* Lock the realpath for the duration of the append.
507  * It will be unlocked in the close */
508  if (!lock_realpath(m, true))
509  {
510  mutt_error(_("Unable to lock mailbox"));
511  goto cmoa_fail2;
512  }
513 
514  /* Open the existing mailbox, unless we are appending */
515  if (!ci->cmd_append && (mutt_file_get_size(m->realpath) > 0))
516  {
517  int rc = execute_command(m, ci->cmd_open, _("Decompressing %s"));
518  if (rc == 0)
519  {
520  mutt_error(_("Compress command failed: %s"), ci->cmd_open);
521  goto cmoa_fail2;
522  }
524  }
525  else
526  m->type = C_MboxType;
527 
528  /* We can only deal with mbox and mmdf mailboxes */
529  if ((m->type != MUTT_MBOX) && (m->type != MUTT_MMDF))
530  {
531  mutt_error(_("Unsupported mailbox type for appending"));
532  goto cmoa_fail2;
533  }
534 
535  ci->child_ops = mx_get_ops(m->type);
536  if (!ci->child_ops)
537  {
538  mutt_error(_("Can't find mailbox ops for mailbox type %d"), m->type);
539  goto cmoa_fail2;
540  }
541 
542  if (ci->child_ops->mbox_open_append(m, flags) != 0)
543  goto cmoa_fail2;
544 
545  return 0;
546 
547 cmoa_fail2:
548  /* remove the partial uncompressed file */
549  remove(mailbox_path(m));
550 cmoa_fail1:
551  /* Free the compress_info to prevent close from trying to recompress */
553 
554  return -1;
555 }
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox&#39;s path string.
Definition: mailbox.h:196
const struct MxOps * mx_get_ops(enum MailboxType type)
Get mailbox operations.
Definition: mx.c:141
enum MailboxType type
Mailbox type.
Definition: mailbox.h:105
const char * cmd_append
append-hook command
Definition: lib.h:50
static void compress_info_free(struct Mailbox *m)
Frees the compress info members and structure.
Definition: compress.c:206
long mutt_file_get_size(const char *path)
Get the size of a file.
Definition: file.c:1488
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:84
#define _(a)
Definition: message.h:28
int(* mbox_open_append)(struct Mailbox *m, OpenMailboxFlags flags)
Open a Mailbox for appending.
Definition: mx.h:145
const char * cmd_close
close-hook command
Definition: lib.h:51
static struct CompressInfo * set_compress_info(struct Mailbox *m)
Find the compress hooks for a mailbox.
Definition: compress.c:176
&#39;mmdf&#39; Mailbox type
Definition: mailbox.h:49
unsigned char C_MboxType
Config: Default type for creating new mailboxes.
Definition: mx.c:84
Private data for compress.
Definition: lib.h:48
static int execute_command(struct Mailbox *m, const char *command, const char *progress)
Run a system command.
Definition: compress.c:299
&#39;mbox&#39; Mailbox type
Definition: mailbox.h:48
enum MailboxType mx_path_probe(const char *path)
Find a mailbox that understands a path.
Definition: mx.c:1327
#define mutt_error(...)
Definition: logging.h:84
static bool lock_realpath(struct Mailbox *m, bool excl)
Try to lock the ctx->realpath.
Definition: compress.c:65
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
const char * cmd_open
open-hook command
Definition: lib.h:52
static int setup_paths(struct Mailbox *m)
Set the mailbox paths.
Definition: compress.c:130
+ 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
mMailbox
Return values
0Mailbox OK
MUTT_REOPENEDThe mailbox was closed and reopened
-1Mailbox 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 571 of file compress.c.

572 {
573  if (!m || !m->compress_info)
574  return -1;
575 
576  struct CompressInfo *ci = m->compress_info;
577 
578  const struct MxOps *ops = ci->child_ops;
579  if (!ops)
580  return -1;
581 
582  int size = mutt_file_get_size(m->realpath);
583  if (size == ci->size)
584  return 0;
585 
586  if (!lock_realpath(m, false))
587  {
588  mutt_error(_("Unable to lock mailbox"));
589  return -1;
590  }
591 
592  int rc = execute_command(m, ci->cmd_open, _("Decompressing %s"));
593  store_size(m);
594  unlock_realpath(m);
595  if (rc == 0)
596  return -1;
597 
598  return ops->mbox_check(m);
599 }
long mutt_file_get_size(const char *path)
Get the size of a file.
Definition: file.c:1488
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:84
#define _(a)
Definition: message.h:28
long size
size of the compressed file
Definition: lib.h:53
static void store_size(const struct Mailbox *m)
Save the size of the compressed file.
Definition: compress.c:158
int(* mbox_check)(struct Mailbox *m)
Check for new mail.
Definition: mx.h:153
static void unlock_realpath(struct Mailbox *m)
Unlock the mailbox->realpath.
Definition: compress.c:104
Private data for compress.
Definition: lib.h:48
static int execute_command(struct Mailbox *m, const char *command, const char *progress)
Run a system command.
Definition: compress.c:299
#define mutt_error(...)
Definition: logging.h:84
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
static bool lock_realpath(struct Mailbox *m, bool excl)
Try to lock the ctx->realpath.
Definition: compress.c:65
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
const char * cmd_open
open-hook command
Definition: lib.h:52
The Mailbox API.
Definition: mx.h:105
+ 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 607 of file compress.c.

608 {
609  if (!m || !m->compress_info)
610  return -1;
611 
612  struct CompressInfo *ci = m->compress_info;
613 
614  if (!ci->cmd_close)
615  {
616  mutt_error(_("Can't sync a compressed file without a close-hook"));
617  return -1;
618  }
619 
620  const struct MxOps *ops = ci->child_ops;
621  if (!ops)
622  return -1;
623 
624  if (!lock_realpath(m, true))
625  {
626  mutt_error(_("Unable to lock mailbox"));
627  return -1;
628  }
629 
630  int rc = comp_mbox_check(m);
631  if (rc != 0)
632  goto sync_cleanup;
633 
634  rc = ops->mbox_sync(m);
635  if (rc != 0)
636  goto sync_cleanup;
637 
638  rc = execute_command(m, ci->cmd_close, _("Compressing %s"));
639  if (rc == 0)
640  {
641  rc = -1;
642  goto sync_cleanup;
643  }
644 
645  rc = 0;
646 
647 sync_cleanup:
648  store_size(m);
649  unlock_realpath(m);
650  return rc;
651 }
#define _(a)
Definition: message.h:28
const char * cmd_close
close-hook command
Definition: lib.h:51
static void store_size(const struct Mailbox *m)
Save the size of the compressed file.
Definition: compress.c:158
int(* mbox_sync)(struct Mailbox *m)
Save changes to the Mailbox.
Definition: mx.h:171
static void unlock_realpath(struct Mailbox *m)
Unlock the mailbox->realpath.
Definition: compress.c:104
Private data for compress.
Definition: lib.h:48
static int execute_command(struct Mailbox *m, const char *command, const char *progress)
Run a system command.
Definition: compress.c:299
static int comp_mbox_check(struct Mailbox *m)
Check for new mail - Implements MxOps::mbox_check()
Definition: compress.c:571
#define mutt_error(...)
Definition: logging.h:84
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
static bool lock_realpath(struct Mailbox *m, bool excl)
Try to lock the ctx->realpath.
Definition: compress.c:65
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105
+ 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 659 of file compress.c.

660 {
661  if (!m || !m->compress_info)
662  return -1;
663 
664  struct CompressInfo *ci = m->compress_info;
665 
666  const struct MxOps *ops = ci->child_ops;
667  if (!ops)
668  {
670  return -1;
671  }
672 
673  ops->mbox_close(m);
674 
675  /* sync has already been called, so we only need to delete some files */
676  if (m->append)
677  {
678  const char *append = NULL;
679  const char *msg = NULL;
680 
681  /* The file exists and we can append */
682  if ((access(m->realpath, F_OK) == 0) && ci->cmd_append)
683  {
684  append = ci->cmd_append;
685  msg = _("Compressed-appending to %s...");
686  }
687  else
688  {
689  append = ci->cmd_close;
690  msg = _("Compressing %s");
691  }
692 
693  int rc = execute_command(m, append, msg);
694  if (rc == 0)
695  {
697  mutt_error(_("Error. Preserving temporary file: %s"), mailbox_path(m));
698  }
699  else
700  remove(mailbox_path(m));
701 
702  unlock_realpath(m);
703  }
704  else
705  {
706  /* If the file was removed, remove the compressed folder too */
707  if ((access(mailbox_path(m), F_OK) != 0) && !C_SaveEmpty)
708  {
709  remove(m->realpath);
710  }
711  else
712  {
713  remove(mailbox_path(m));
714  }
715  }
716 
718 
719  return 0;
720 }
static const char * mailbox_path(const struct Mailbox *m)
Get the Mailbox&#39;s path string.
Definition: mailbox.h:196
const char * cmd_append
append-hook command
Definition: lib.h:50
static void compress_info_free(struct Mailbox *m)
Frees the compress info members and structure.
Definition: compress.c:206
WHERE bool C_SaveEmpty
Config: (mbox,mmdf) Preserve empty mailboxes.
Definition: mutt_globals.h:160
char * realpath
Used for duplicate detection, context comparison, and the sidebar.
Definition: mailbox.h:84
#define _(a)
Definition: message.h:28
const char * cmd_close
close-hook command
Definition: lib.h:51
bool append
Mailbox is opened in append mode.
Definition: mailbox.h:113
static void unlock_realpath(struct Mailbox *m)
Unlock the mailbox->realpath.
Definition: compress.c:104
Private data for compress.
Definition: lib.h:48
static int execute_command(struct Mailbox *m, const char *command, const char *progress)
Run a system command.
Definition: compress.c:299
int mutt_any_key_to_continue(const char *s)
Prompt the user to &#39;press any key&#39; and wait.
Definition: curs_lib.c:602
int(* mbox_close)(struct Mailbox *m)
Close a Mailbox.
Definition: mx.h:179
#define mutt_error(...)
Definition: logging.h:84
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105
+ 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 725 of file compress.c.

726 {
727  if (!m || !m->compress_info)
728  return -1;
729 
730  struct CompressInfo *ci = m->compress_info;
731 
732  const struct MxOps *ops = ci->child_ops;
733  if (!ops)
734  return -1;
735 
736  /* Delegate */
737  return ops->msg_open(m, msg, msgno);
738 }
int(* msg_open)(struct Mailbox *m, struct Message *msg, int msgno)
Open an email message in a Mailbox.
Definition: mx.h:189
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105

◆ comp_msg_open_new()

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

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

Definition at line 743 of file compress.c.

744 {
745  if (!m || !m->compress_info)
746  return -1;
747 
748  struct CompressInfo *ci = m->compress_info;
749 
750  const struct MxOps *ops = ci->child_ops;
751  if (!ops)
752  return -1;
753 
754  /* Delegate */
755  return ops->msg_open_new(m, msg, e);
756 }
int(* msg_open_new)(struct Mailbox *m, struct Message *msg, struct Email *e)
Open a new message in a Mailbox.
Definition: mx.h:199
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105

◆ 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 761 of file compress.c.

762 {
763  if (!m || !m->compress_info)
764  return -1;
765 
766  struct CompressInfo *ci = m->compress_info;
767 
768  const struct MxOps *ops = ci->child_ops;
769  if (!ops)
770  return -1;
771 
772  /* Delegate */
773  return ops->msg_commit(m, msg);
774 }
int(* msg_commit)(struct Mailbox *m, struct Message *msg)
Save changes to an email.
Definition: mx.h:208
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105

◆ 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 779 of file compress.c.

780 {
781  if (!m || !m->compress_info)
782  return -1;
783 
784  struct CompressInfo *ci = m->compress_info;
785 
786  const struct MxOps *ops = ci->child_ops;
787  if (!ops)
788  return -1;
789 
790  /* Delegate */
791  return ops->msg_close(m, msg);
792 }
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
int(* msg_close)(struct Mailbox *m, struct Message *msg)
Close an email.
Definition: mx.h:217
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105

◆ 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 797 of file compress.c.

798 {
799  if (!m || !m->compress_info)
800  return 0;
801 
802  struct CompressInfo *ci = m->compress_info;
803 
804  const struct MxOps *ops = ci->child_ops;
805  if (!ops || !ops->msg_padding_size)
806  return 0;
807 
808  return ops->msg_padding_size(m);
809 }
int(* msg_padding_size)(struct Mailbox *m)
Bytes of padding between messages.
Definition: mx.h:224
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105

◆ 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 814 of file compress.c.

815 {
816  if (!m || !m->compress_info)
817  return 0;
818 
819  struct CompressInfo *ci = m->compress_info;
820 
821  const struct MxOps *ops = ci->child_ops;
822  if (!ops || !ops->msg_save_hcache)
823  return 0;
824 
825  return ops->msg_save_hcache(m, e);
826 }
int(* msg_save_hcache)(struct Mailbox *m, struct Email *e)
Save message to the header cache.
Definition: mx.h:233
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105

◆ 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 831 of file compress.c.

832 {
833  if (!m || !m->compress_info)
834  return 0;
835 
836  struct CompressInfo *ci = m->compress_info;
837 
838  const struct MxOps *ops = ci->child_ops;
839  if (!ops || !ops->tags_edit)
840  return 0;
841 
842  return ops->tags_edit(m, tags, buf, buflen);
843 }
int(* tags_edit)(struct Mailbox *m, const char *tags, char *buf, size_t buflen)
Prompt and validate new messages tags.
Definition: mx.h:245
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105

◆ 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 848 of file compress.c.

849 {
850  if (!m || !m->compress_info)
851  return 0;
852 
853  struct CompressInfo *ci = m->compress_info;
854 
855  const struct MxOps *ops = ci->child_ops;
856  if (!ops || !ops->tags_commit)
857  return 0;
858 
859  return ops->tags_commit(m, e, buf);
860 }
Private data for compress.
Definition: lib.h:48
void * compress_info
Compressed mbox module private data.
Definition: mailbox.h:124
const struct MxOps * child_ops
callbacks of de-compressed file
Definition: lib.h:54
The Mailbox API.
Definition: mx.h:105
int(* tags_commit)(struct Mailbox *m, struct Email *e, char *buf)
Save the tags to a message.
Definition: mx.h:255

◆ 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 865 of file compress.c.

866 {
867  if (!path)
868  return MUTT_UNKNOWN;
869 
870  if (!st || !S_ISREG(st->st_mode))
871  return MUTT_UNKNOWN;
872 
873  if (mutt_comp_can_read(path))
874  return MUTT_COMPRESSED;
875 
876  return MUTT_UNKNOWN;
877 }
Mailbox wasn&#39;t recognised.
Definition: mailbox.h:47
Compressed file Mailbox type.
Definition: mailbox.h:56
bool mutt_comp_can_read(const char *path)
Can we read from this file?
Definition: compress.c:368
+ 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 882 of file compress.c.

883 {
884  if (!buf)
885  return -1;
886 
887  mutt_path_canon(buf, buflen, HomeDir, false);
888  return 0;
889 }
char * HomeDir
User&#39;s home directory.
Definition: mutt_globals.h:50
bool mutt_path_canon(char *buf, size_t buflen, const char *homedir, bool is_dir)
Create the canonical version of a path.
Definition: path.c:285
+ 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 894 of file compress.c.

895 {
896  if (!buf)
897  return -1;
898 
899  if (mutt_path_abbr_folder(buf, buflen, folder))
900  return 0;
901 
902  if (mutt_path_pretty(buf, buflen, HomeDir, false))
903  return 0;
904 
905  return -1;
906 }
bool mutt_path_pretty(char *buf, size_t buflen, const char *homedir, bool is_dir)
Tidy a filesystem path.
Definition: path.c:186
char * HomeDir
User&#39;s home directory.
Definition: mutt_globals.h:50
bool mutt_path_abbr_folder(char *buf, size_t buflen, const char *folder)
Create a folder abbreviation.
Definition: path.c:492
+ 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.

912 {
913  if (!buf)
914  return -1;
915 
916  if (mutt_path_parent(buf, buflen))
917  return 0;
918 
919  if (buf[0] == '~')
920  mutt_path_canon(buf, buflen, HomeDir, false);
921 
922  if (mutt_path_parent(buf, buflen))
923  return 0;
924 
925  return -1;
926 }
bool mutt_path_parent(char *buf, size_t buflen)
Find the parent of a path.
Definition: path.c:459
char * HomeDir
User&#39;s home directory.
Definition: mutt_globals.h:50
bool mutt_path_canon(char *buf, size_t buflen, const char *homedir, bool is_dir)
Create the canonical version of a path.
Definition: path.c:285
+ Here is the call graph for this function:

Variable Documentation

◆ 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,
}
static int comp_mbox_open(struct Mailbox *m)
Open a Mailbox - Implements MxOps::mbox_open()
Definition: compress.c:422
static int comp_ac_add(struct Account *a, struct Mailbox *m)
Add a Mailbox to an Account - Implements MxOps::ac_add()
Definition: compress.c:407
static int comp_mbox_sync(struct Mailbox *m)
Save changes to the Mailbox - Implements MxOps::mbox_sync()
Definition: compress.c:607
static int comp_msg_save_hcache(struct Mailbox *m, struct Email *e)
Save message to the header cache - Implements MxOps::msg_save_hcache()
Definition: compress.c:814
static int comp_path_parent(char *buf, size_t buflen)
Find the parent of a Mailbox path - Implements MxOps::path_parent()
Definition: compress.c:911
static int comp_path_pretty(char *buf, size_t buflen, const char *folder)
Abbreviate a Mailbox path - Implements MxOps::path_pretty()
Definition: compress.c:894
static struct Account * comp_ac_find(struct Account *a, const char *path)
Find an Account that matches a Mailbox path - Implements MxOps::ac_find()
Definition: compress.c:399
static int comp_mbox_open_append(struct Mailbox *m, OpenMailboxFlags flags)
Open a Mailbox for appending - Implements MxOps::mbox_open_append()
Definition: compress.c:485
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()
Definition: compress.c:831
static enum MailboxType comp_path_probe(const char *path, const struct stat *st)
Is this a compressed Mailbox? - Implements MxOps::path_probe()
Definition: compress.c:865
static int comp_msg_padding_size(struct Mailbox *m)
Bytes of padding between messages - Implements MxOps::msg_padding_size()
Definition: compress.c:797
static int comp_path_canon(char *buf, size_t buflen)
Canonicalise a Mailbox path - Implements MxOps::path_canon()
Definition: compress.c:882
static int comp_tags_commit(struct Mailbox *m, struct Email *e, char *buf)
Save the tags to a message - Implements MxOps::tags_commit()
Definition: compress.c:848
Compressed file Mailbox type.
Definition: mailbox.h:56
static int comp_mbox_check(struct Mailbox *m)
Check for new mail - Implements MxOps::mbox_check()
Definition: compress.c:571
static int comp_msg_open(struct Mailbox *m, struct Message *msg, int msgno)
Open an email message in a Mailbox - Implements MxOps::msg_open()
Definition: compress.c:725
static int comp_msg_commit(struct Mailbox *m, struct Message *msg)
Save changes to an email - Implements MxOps::msg_commit()
Definition: compress.c:761
static int comp_msg_close(struct Mailbox *m, struct Message *msg)
Close an email - Implements MxOps::msg_close()
Definition: compress.c:779
static int comp_mbox_close(struct Mailbox *m)
Close a Mailbox - Implements MxOps::mbox_close()
Definition: compress.c:659
static int comp_msg_open_new(struct Mailbox *m, struct Message *msg, struct Email *e)
Open a new message in a Mailbox - Implements MxOps::msg_open_new()
Definition: compress.c:743

Compressed Mailbox - Implements MxOps.

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

Definition at line 935 of file compress.c.