debian/patches/features/compressed-folders

   1 # vi: ft=diff
   2 This is the compressed folders patch by Roland Rosenfeld
   3 <roland@spinnaker.de>.
   4
   5 The home page for this patch is:
   6
   7   http://www.spinnaker.de/mutt/compressed/
   8
   9 * Patch last synced with upstream:
  10   - Date: 2008-05-20
  11   - File: http://www.spinnaker.de/mutt/compressed/patch-1.5.18.rr.compressed.1.gz
  12
  13 * Changes made:
  14   - 2008-05-20 myon: refreshed to remove hunks in auto* files
  15   - 2009-09-15 myon: refreshed for mutt-1.5.19
  16                      status.c:103: add sizeof (tmp) to mutt_pretty_mailbox
  17   - 2009-09-15 scotton: removed doc/Muttrc for mutt-1.5.19 (only patch doc/Muttrc.head)
  18   - 2009-09-11 antonio: removed DefaultMagic, see 541360
  19
  20 == END PATCH
  21 --- /dev/null
  22 +++ b/compress.c
  23 @@ -0,0 +1,496 @@
  24 +/*
  25 + * Copyright (C) 1997 Alain Penders <Alain@Finale-Dev.com>
  26 + *
  27 + *     This program is free software; you can redistribute it and/or modify
  28 + *     it under the terms of the GNU General Public License as published by
  29 + *     the Free Software Foundation; either version 2 of the License, or
  30 + *     (at your option) any later version.
  31 + *
  32 + *     This program is distributed in the hope that it will be useful,
  33 + *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  34 + *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35 + *     GNU General Public License for more details.
  36 + *
  37 + *     You should have received a copy of the GNU General Public License
  38 + *     along with this program; if not, write to the Free Software
  39 + *     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  40 + */
  41 +
  42 +#if HAVE_CONFIG_H
  43 +# include "config.h"
  44 +#endif
  45 +
  46 +#include "mutt.h"
  47 +
  48 +#ifdef USE_COMPRESSED
  49 +
  50 +#include "mx.h"
  51 +#include "mailbox.h"
  52 +#include "mutt_curses.h"
  53 +
  54 +#include <errno.h>
  55 +#include <string.h>
  56 +#include <unistd.h>
  57 +#include <sys/stat.h>
  58 +
  59 +typedef struct
  60 +{
  61 +  const char *close;   /* close-hook  command */
  62 +  const char *open;    /* open-hook   command */
  63 +  const char *append;  /* append-hook command */
  64 +  off_t size;          /* size of real folder */
  65 +} COMPRESS_INFO;
  66 +
  67 +
  68 +/*
  69 + * ctx - context to lock
  70 + * excl - exclusive lock?
  71 + * retry - should retry if unable to lock?
  72 + */
  73 +int mbox_lock_compressed (CONTEXT *ctx, FILE *fp, int excl, int retry)
  74 +{
  75 +  int r;
  76 +
  77 +  if ((r = mx_lock_file (ctx->realpath, fileno (fp), excl, 1, retry)) == 0)
  78 +    ctx->locked = 1;
  79 +  else if (retry && !excl)
  80 +  {
  81 +    ctx->readonly = 1;
  82 +    return 0;
  83 +  }
  84 +
  85 +  return (r);
  86 +}
  87 +
  88 +void mbox_unlock_compressed (CONTEXT *ctx, FILE *fp)
  89 +{
  90 +  if (ctx->locked)
  91 +  {
  92 +    fflush (fp);
  93 +
  94 +    mx_unlock_file (ctx->realpath, fileno (fp), 1);
  95 +    ctx->locked = 0;
  96 +  }
  97 +}
  98 +
  99 +static int is_new (const char *path)
 100 +{
 101 +  return (access (path, W_OK) != 0 && errno == ENOENT) ? 1 : 0;
 102 +}
 103 +
 104 +static const char* find_compress_hook (int type, const char *path)
 105 +{
 106 +  const char* c = mutt_find_hook (type, path);
 107 +  return (!c || !*c) ? NULL : c;
 108 +}
 109 +
 110 +int mutt_can_read_compressed (const char *path)
 111 +{
 112 +  return find_compress_hook (M_OPENHOOK, path) ? 1 : 0;
 113 +}
 114 +
 115 +/*
 116 + * if the file is new, we really do not append, but create, and so use
 117 + * close-hook, and not append-hook
 118 + */
 119 +static const char* get_append_command (const char *path, const CONTEXT* ctx)
 120 +{
 121 +  COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 122 +  return (is_new (path)) ? ci->close : ci->append;
 123 +}
 124 +
 125 +int mutt_can_append_compressed (const char *path)
 126 +{
 127 +  int magic;
 128 +
 129 +  if (is_new (path))
 130 +  {
 131 +    char *dir_path = safe_strdup(path);
 132 +    char *aux = strrchr(dir_path, '/');
 133 +    int dir_valid = 1;
 134 +    if (aux)
 135 +    {
 136 +      *aux='\0';
 137 +      if (access(dir_path, W_OK|X_OK))
 138 +        dir_valid = 0;
 139 +    }
 140 +    safe_free((void**)&dir_path);
 141 +    return dir_valid && (find_compress_hook (M_CLOSEHOOK, path) ? 1 : 0);
 142 +  }
 143 +
 144 +  magic = mx_get_magic (path);
 145 +
 146 +  if (magic != 0 && magic != M_COMPRESSED)
 147 +    return 0;
 148 +
 149 +  return (find_compress_hook (M_APPENDHOOK, path)
 150 +         || (find_compress_hook (M_OPENHOOK, path)
 151 +             && find_compress_hook (M_CLOSEHOOK, path))) ? 1 : 0;
 152 +}
 153 +
 154 +/* open a compressed mailbox */
 155 +static COMPRESS_INFO *set_compress_info (CONTEXT *ctx)
 156 +{
 157 +  COMPRESS_INFO *ci;
 158 +
 159 +  /* Now lets uncompress this thing */
 160 +  ci = safe_malloc (sizeof (COMPRESS_INFO));
 161 +  ctx->compressinfo = (void*) ci;
 162 +  ci->append = find_compress_hook (M_APPENDHOOK, ctx->path);
 163 +  ci->open = find_compress_hook (M_OPENHOOK, ctx->path);
 164 +  ci->close = find_compress_hook (M_CLOSEHOOK, ctx->path);
 165 +  return ci;
 166 +}
 167 +
 168 +static void set_path (CONTEXT* ctx)
 169 +{
 170 +  char tmppath[_POSIX_PATH_MAX];
 171 +
 172 +  /* Setup the right paths */
 173 +  ctx->realpath = ctx->path;
 174 +
 175 +  /* Uncompress to /tmp */
 176 +  mutt_mktemp (tmppath);
 177 +  ctx->path = safe_malloc (strlen (tmppath) + 1);
 178 +  strcpy (ctx->path, tmppath);
 179 +}
 180 +
 181 +static int get_size (const char* path)
 182 +{
 183 +  struct stat sb;
 184 +  if (stat (path, &sb) != 0)
 185 +    return 0;
 186 +  return (sb.st_size);
 187 +}
 188 +
 189 +static void store_size (CONTEXT* ctx)
 190 +{
 191 +  COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 192 +  ci->size = get_size (ctx->realpath);
 193 +}
 194 +
 195 +static const char *
 196 +compresshook_format_str (char *dest, size_t destlen, size_t col, char op,
 197 +                        const char *src, const char *fmt,
 198 +                        const char *ifstring, const char *elsestring,
 199 +                        unsigned long data, format_flag flags)
 200 +{
 201 +  char tmp[SHORT_STRING];
 202 +
 203 +  CONTEXT *ctx = (CONTEXT *) data;
 204 +  switch (op)
 205 +  {
 206 +  case 'f':
 207 +    snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
 208 +    snprintf (dest, destlen, tmp, ctx->realpath);
 209 +    break;
 210 +  case 't':
 211 +    snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
 212 +    snprintf (dest, destlen, tmp, ctx->path);
 213 +    break;
 214 +  }
 215 +  return (src);
 216 +}
 217 +
 218 +/*
 219 + * check that the command has both %f and %t
 220 + * 0 means OK, -1 means error
 221 + */
 222 +int mutt_test_compress_command (const char* cmd)
 223 +{
 224 +  return (strstr (cmd, "%f") && strstr (cmd, "%t")) ? 0 : -1;
 225 +}
 226 +
 227 +static char *get_compression_cmd (const char* cmd, const CONTEXT* ctx)
 228 +{
 229 +  char expanded[_POSIX_PATH_MAX];
 230 +  mutt_FormatString (expanded, sizeof (expanded), 0, cmd,
 231 +                    compresshook_format_str, (unsigned long) ctx, 0);
 232 +  return safe_strdup (expanded);
 233 +}
 234 +
 235 +int mutt_check_mailbox_compressed (CONTEXT* ctx)
 236 +{
 237 +  COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 238 +  if (ci->size != get_size (ctx->realpath))
 239 +  {
 240 +    FREE (&ctx->compressinfo);
 241 +    FREE (&ctx->realpath);
 242 +    mutt_error _("Mailbox was corrupted!");
 243 +    return (-1);
 244 +  }
 245 +  return (0);
 246 +}
 247 +
 248 +int mutt_open_read_compressed (CONTEXT *ctx)
 249 +{
 250 +  char *cmd;
 251 +  FILE *fp;
 252 +  int rc;
 253 +
 254 +  COMPRESS_INFO *ci = set_compress_info (ctx);
 255 +  if (!ci->open) {
 256 +    ctx->magic = 0;
 257 +    FREE (&ctx->compressinfo);
 258 +    return (-1);
 259 +  }
 260 +  if (!ci->close || access (ctx->path, W_OK) != 0)
 261 +    ctx->readonly = 1;
 262 +
 263 +  set_path (ctx);
 264 +  store_size (ctx);
 265 +
 266 +  if (!ctx->quiet)
 267 +    mutt_message (_("Decompressing %s..."), ctx->realpath);
 268 +
 269 +  cmd = get_compression_cmd (ci->open, ctx);
 270 +  if (cmd == NULL)
 271 +    return (-1);
 272 +  dprint (2, (debugfile, "DecompressCmd: '%s'\n", cmd));
 273 +
 274 +  if ((fp = fopen (ctx->realpath, "r")) == NULL)
 275 +  {
 276 +    mutt_perror (ctx->realpath);
 277 +    FREE (&cmd);
 278 +    return (-1);
 279 +  }
 280 +  mutt_block_signals ();
 281 +  if (mbox_lock_compressed (ctx, fp, 0, 1) == -1)
 282 +  {
 283 +    fclose (fp);
 284 +    mutt_unblock_signals ();
 285 +    mutt_error _("Unable to lock mailbox!");
 286 +    FREE (&cmd);
 287 +    return (-1);
 288 +  }
 289 +
 290 +  endwin ();
 291 +  fflush (stdout);
 292 +  fprintf (stderr, _("Decompressing %s...\n"),ctx->realpath);
 293 +  rc = mutt_system (cmd);
 294 +  mbox_unlock_compressed (ctx, fp);
 295 +  mutt_unblock_signals ();
 296 +  fclose (fp);
 297 +
 298 +  if (rc)
 299 +  {
 300 +    mutt_any_key_to_continue (NULL);
 301 +    ctx->magic = 0;
 302 +    FREE (&ctx->compressinfo);
 303 +    mutt_error (_("Error executing: %s : unable to open the mailbox!\n"), cmd);
 304 +  }
 305 +  FREE (&cmd);
 306 +  if (rc)
 307 +    return (-1);
 308 +
 309 +  if (mutt_check_mailbox_compressed (ctx))
 310 +    return (-1);
 311 +
 312 +  ctx->magic = mx_get_magic (ctx->path);
 313 +
 314 +  return (0);
 315 +}
 316 +
 317 +void restore_path (CONTEXT* ctx)
 318 +{
 319 +  FREE (&ctx->path);
 320 +  ctx->path = ctx->realpath;
 321 +}
 322 +
 323 +/* remove the temporary mailbox */
 324 +void remove_file (CONTEXT* ctx)
 325 +{
 326 +  if (ctx->magic == M_MBOX || ctx->magic == M_MMDF)
 327 +    remove (ctx->path);
 328 +}
 329 +
 330 +int mutt_open_append_compressed (CONTEXT *ctx)
 331 +{
 332 +  FILE *fh;
 333 +  COMPRESS_INFO *ci = set_compress_info (ctx);
 334 +
 335 +  if (!get_append_command (ctx->path, ctx))
 336 +  {
 337 +    if (ci->open && ci->close)
 338 +      return (mutt_open_read_compressed (ctx));
 339 +
 340 +    ctx->magic = 0;
 341 +    FREE (&ctx->compressinfo);
 342 +    return (-1);
 343 +  }
 344 +
 345 +  set_path (ctx);
 346 +
 347 +  if (!is_new (ctx->realpath))
 348 +      if ((fh = fopen (ctx->path, "w")))
 349 +       fclose (fh);
 350 +  /* No error checking - the parent function will catch it */
 351 +
 352 +  return (0);
 353 +}
 354 +
 355 +/* close a compressed mailbox */
 356 +void mutt_fast_close_compressed (CONTEXT *ctx)
 357 +{
 358 +  dprint (2, (debugfile, "mutt_fast_close_compressed called on '%s'\n",
 359 +             ctx->path));
 360 +
 361 +  if (ctx->compressinfo)
 362 +  {
 363 +    if (ctx->fp)
 364 +      fclose (ctx->fp);
 365 +    ctx->fp = NULL;
 366 +    /* if the folder was removed, remove the gzipped folder too */
 367 +    if ((ctx->magic > 0)
 368 +       && (access (ctx->path, F_OK) != 0)
 369 +       && ! option (OPTSAVEEMPTY))
 370 +      remove (ctx->realpath);
 371 +    else
 372 +      remove_file (ctx);
 373 +
 374 +    restore_path (ctx);
 375 +    FREE (&ctx->compressinfo);
 376 +  }
 377 +}
 378 +
 379 +/* return 0 on success, -1 on failure */
 380 +int mutt_sync_compressed (CONTEXT* ctx)
 381 +{
 382 +  char *cmd;
 383 +  int rc = 0;
 384 +  FILE *fp;
 385 +  COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 386 +
 387 +  if (!ctx->quiet)
 388 +    mutt_message (_("Compressing %s..."), ctx->realpath);
 389 +
 390 +  cmd = get_compression_cmd (ci->close, ctx);
 391 +  if (cmd == NULL)
 392 +    return (-1);
 393 +
 394 +  if ((fp = fopen (ctx->realpath, "a")) == NULL)
 395 +  {
 396 +    mutt_perror (ctx->realpath);
 397 +    FREE (&cmd);
 398 +    return (-1);
 399 +  }
 400 +  mutt_block_signals ();
 401 +  if (mbox_lock_compressed (ctx, fp, 1, 1) == -1)
 402 +  {
 403 +    fclose (fp);
 404 +    mutt_unblock_signals ();
 405 +    mutt_error _("Unable to lock mailbox!");
 406 +    store_size (ctx);
 407 +    FREE (&cmd);
 408 +    return (-1);
 409 +  }
 410 +
 411 +  dprint (2, (debugfile, "CompressCommand: '%s'\n", cmd));
 412 +
 413 +  endwin ();
 414 +  fflush (stdout);
 415 +  fprintf (stderr, _("Compressing %s...\n"), ctx->realpath);
 416 +  if (mutt_system (cmd))
 417 +  {
 418 +    mutt_any_key_to_continue (NULL);
 419 +    mutt_error (_("%s: Error compressing mailbox! Original mailbox deleted, uncompressed one kept!\n"), ctx->path);
 420 +    rc = -1;
 421 +  }
 422 +
 423 +  mbox_unlock_compressed (ctx, fp);
 424 +  mutt_unblock_signals ();
 425 +  fclose (fp);
 426 +
 427 +  FREE (&cmd);
 428 +
 429 +  store_size (ctx);
 430 +
 431 +  return (rc);
 432 +}
 433 +
 434 +int mutt_slow_close_compressed (CONTEXT *ctx)
 435 +{
 436 +  FILE *fp;
 437 +  const char *append;
 438 +  char *cmd;
 439 +  COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 440 +
 441 +  dprint (2, (debugfile, "mutt_slow_close_compressed called on '%s'\n",
 442 +             ctx->path));
 443 +
 444 +  if (! (ctx->append
 445 +        && ((append = get_append_command (ctx->realpath, ctx))
 446 +            || (append = ci->close))))
 447 +  {
 448 +    /* if we can not or should not append, we only have to remove the */
 449 +    /* compressed info, because sync was already called               */
 450 +    mutt_fast_close_compressed (ctx);
 451 +    return (0);
 452 +  }
 453 +
 454 +  if (ctx->fp)
 455 +    fclose (ctx->fp);
 456 +  ctx->fp = NULL;
 457 +
 458 +  if (!ctx->quiet)
 459 +  {
 460 +    if (append == ci->close)
 461 +      mutt_message (_("Compressing %s..."), ctx->realpath);
 462 +    else
 463 +      mutt_message (_("Compressed-appending to %s..."), ctx->realpath);
 464 +  }
 465 +
 466 +  cmd = get_compression_cmd (append, ctx);
 467 +  if (cmd == NULL)
 468 +    return (-1);
 469 +
 470 +  if ((fp = fopen (ctx->realpath, "a")) == NULL)
 471 +  {
 472 +    mutt_perror (ctx->realpath);
 473 +    FREE (&cmd);
 474 +    return (-1);
 475 +  }
 476 +  mutt_block_signals ();
 477 +  if (mbox_lock_compressed (ctx, fp, 1, 1) == -1)
 478 +  {
 479 +    fclose (fp);
 480 +    mutt_unblock_signals ();
 481 +    mutt_error _("Unable to lock mailbox!");
 482 +    FREE (&cmd);
 483 +    return (-1);
 484 +  }
 485 +
 486 +  dprint (2, (debugfile, "CompressCmd: '%s'\n", cmd));
 487 +
 488 +  endwin ();
 489 +  fflush (stdout);
 490 +
 491 +  if (append == ci->close)
 492 +    fprintf (stderr, _("Compressing %s...\n"), ctx->realpath);
 493 +  else
 494 +    fprintf (stderr, _("Compressed-appending to %s...\n"), ctx->realpath);
 495 +
 496 +  if (mutt_system (cmd))
 497 +  {
 498 +    mutt_any_key_to_continue (NULL);
 499 +    mutt_error (_(" %s: Error compressing mailbox!  Uncompressed one kept!\n"),
 500 +               ctx->path);
 501 +    FREE (&cmd);
 502 +    mbox_unlock_compressed (ctx, fp);
 503 +    mutt_unblock_signals ();
 504 +    fclose (fp);
 505 +    return (-1);
 506 +  }
 507 +
 508 +  mbox_unlock_compressed (ctx, fp);
 509 +  mutt_unblock_signals ();
 510 +  fclose (fp);
 511 +  remove_file (ctx);
 512 +  restore_path (ctx);
 513 +  FREE (&cmd);
 514 +  FREE (&ctx->compressinfo);
 515 +
 516 +  return (0);
 517 +}
 518 +
 519 +#endif /* USE_COMPRESSED */
 520 --- /dev/null
 521 +++ b/compress.h
 522 @@ -0,0 +1,27 @@
 523 +/*
 524 + * Copyright (C) 1997 Alain Penders <Alain@Finale-Dev.com>
 525 + *
 526 + *     This program is free software; you can redistribute it and/or modify
 527 + *     it under the terms of the GNU General Public License as published by
 528 + *     the Free Software Foundation; either version 2 of the License, or
 529 + *     (at your option) any later version.
 530 + *
 531 + *     This program is distributed in the hope that it will be useful,
 532 + *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 533 + *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 534 + *     GNU General Public License for more details.
 535 + *
 536 + *     You should have received a copy of the GNU General Public License
 537 + *     along with this program; if not, write to the Free Software
 538 + *     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 539 + */
 540 +
 541 +int mutt_can_read_compressed (const char *);
 542 +int mutt_can_append_compressed (const char *);
 543 +int mutt_open_read_compressed (CONTEXT *);
 544 +int mutt_open_append_compressed (CONTEXT *);
 545 +int mutt_slow_close_compressed (CONTEXT *);
 546 +int mutt_sync_compressed (CONTEXT *);
 547 +int mutt_test_compress_command (const char *);
 548 +int mutt_check_mailbox_compressed (CONTEXT *);
 549 +void mutt_fast_close_compressed (CONTEXT *);
 550 --- a/configure.ac
 551 +++ b/configure.ac
 552 @@ -805,6 +805,11 @@
 553                  AC_DEFINE(LOCALES_HACK,1,[ Define if the result of isprint() is unreliable. ])
 554          fi])
 555
 556 +AC_ARG_ENABLE(compressed, AC_HELP_STRING([--enable-compressed], [Enable compressed folders support]),
 557 +       [if test x$enableval = xyes; then
 558 +                AC_DEFINE(USE_COMPRESSED,1, [ Define to support compressed folders. ])
 559 +        fi])
 560 +
 561  AC_ARG_WITH(exec-shell, AC_HELP_STRING([--with-exec-shell=SHELL], [Specify alternate shell (ONLY if /bin/sh is broken)]),
 562          [if test $withval != yes; then
 563                  AC_DEFINE_UNQUOTED(EXECSHELL, "$withval",
 564 --- a/curs_main.c
 565 +++ b/curs_main.c
 566 @@ -1135,6 +1135,11 @@
 567          {
 568           int check;
 569
 570 +#ifdef USE_COMPRESSED
 571 +         if (Context->compressinfo && Context->realpath)
 572 +           mutt_str_replace (&LastFolder, Context->realpath);
 573 +         else
 574 +#endif
 575           mutt_str_replace (&LastFolder, Context->path);
 576           oldcount = Context ? Context->msgcount : 0;
 577
 578 --- a/doc/manual.xml.head
 579 +++ b/doc/manual.xml.head
 580 @@ -5678,6 +5678,205 @@
 581
 582  </chapter>
 583
 584 +<sect1 id="compressedfolders">
 585 +<title>Compressed folders Support (OPTIONAL)</title>
 586 +
 587 +<para>
 588 +If Mutt was compiled with compressed folders support (by running the
 589 +<emphasis>configure</emphasis> script with the
 590 +<emphasis>--enable-compressed</emphasis> flag), Mutt can open folders
 591 +stored in an arbitrary format, provided that the user has a script to
 592 +convert from/to this format to one of the accepted.
 593 +
 594 +The most common use is to open compressed archived folders e.g. with
 595 +gzip.
 596 +
 597 +In addition, the user can provide a script that gets a folder in an
 598 +accepted format and appends its context to the folder in the
 599 +user-defined format, which may be faster than converting the entire
 600 +folder to the accepted format, appending to it and converting back to
 601 +the user-defined format.
 602 +
 603 +There are three hooks defined (<link
 604 +linkend="open-hook">open-hook</link>, <link
 605 +linkend="close-hook">close-hook</link> and <link
 606 +linkend="append-hook">append-hook</link>) which define commands to
 607 +uncompress and compress a folder and to append messages to an existing
 608 +compressed folder respectively.
 609 +
 610 +For example:
 611 +
 612 +<screen>
 613 +open-hook \\.gz$ "gzip -cd %f &gt; %t"
 614 +close-hook \\.gz$ "gzip -c %t &gt; %f"
 615 +append-hook \\.gz$ "gzip -c %t &gt;&gt; %f"
 616 +</screen>
 617 +
 618 +You do not have to specify all of the commands. If you omit <link
 619 +linkend="append-hook">append-hook</link>, the folder will be open and
 620 +closed again each time you will add to it. If you omit <link
 621 +linkend="close-hook">close-hook</link> (or give empty command) , the
 622 +folder will be open in the mode. If you specify <link
 623 +linkend="append-hook">append-hook</link> though you'll be able to
 624 +append to the folder.
 625 +
 626 +Note that Mutt will only try to use hooks if the file is not in one of
 627 +the accepted formats. In particular, if the file is empty, mutt
 628 +supposes it is not compressed. This is important because it allows the
 629 +use of programs that do not have well defined extensions. Just use
 630 +&quot;.&quot; as a regexp. But this may be surprising if your
 631 +compressing script produces empty files. In this situation, unset
 632 +<link linkend="save-empty">&dollar;save&lowbar;empty</link>, so that
 633 +the compressed file will be removed if you delete all of the messages.
 634 +</para>
 635 +
 636 +<sect2 id="open-hook">
 637 +<title>Open a compressed mailbox for reading</title>
 638 +
 639 +<para>
 640 +Usage: <literal>open-hook</literal> <emphasis>regexp</emphasis> &quot;<emphasis>command</emphasis>&quot;
 641 +
 642 +The <emphasis>command</emphasis> is the command that can be used for
 643 +opening the folders whose names match <emphasis>regexp</emphasis>.
 644 +
 645 +The <emphasis>command</emphasis> string is the printf-like format
 646 +string, and it should accept two parameters: &percnt;f, which is
 647 +replaced with the (compressed) folder name, and &percnt;t which is
 648 +replaced with the name of the temporary folder to which to write.
 649 +
 650 +&percnt;f and &percnt;t can be repeated any number of times in the
 651 +command string, and all of the entries are replaced with the
 652 +appropriate folder name. In addition, &percnt;&percnt; is replaced by
 653 +&percnt;, as in printf, and any other &percnt;anything is left as is.
 654 +
 655 +The <emphasis>command</emphasis> should <emphasis
 656 +role="bold">not</emphasis> remove the original compressed file.  The
 657 +<emphasis>command</emphasis> should return non-zero exit status if it
 658 +fails, so mutt knows something's wrong.
 659 +
 660 +Example:
 661 +
 662 +<screen>
 663 +open-hook \\.gz$ "gzip -cd %f &gt; %t"
 664 +</screen>
 665 +
 666 +If the <emphasis>command</emphasis> is empty, this operation is
 667 +disabled for this file type.
 668 +</para>
 669 +</sect2>
 670 +
 671 +<sect2 id="close-hook">
 672 +<title>Write a compressed mailbox</title>
 673 +
 674 +<para>
 675 +Usage: <literal>close-hook</literal> <emphasis>regexp</emphasis> &quot;<emphasis>command</emphasis>&quot;
 676 +
 677 +This is used to close the folder that was open with the <link
 678 +linkend="open-hook">open-hook</link> command after some changes were
 679 +made to it.
 680 +
 681 +The <emphasis>command</emphasis> string is the command that can be
 682 +used for closing the folders whose names match
 683 +<emphasis>regexp</emphasis>. It has the same format as in the <link
 684 +linkend="open-hook">open-hook</link> command. Temporary folder in this
 685 +case is the folder previously produced by the <link
 686 +linkend="open-hook">open-hook</link> command.
 687 +
 688 +The <emphasis>command</emphasis> should <emphasis
 689 +role="bold">not</emphasis> remove the decompressed file. The
 690 +<emphasis>command</emphasis> should return non-zero exit status if it
 691 +fails, so mutt knows something's wrong.
 692 +
 693 +Example:
 694 +
 695 +<screen>
 696 +close-hook \\.gz$ "gzip -c %t &gt; %f"
 697 +</screen>
 698 +
 699 +If the <emphasis>command</emphasis> is empty, this operation is
 700 +disabled for this file type, and the file can only be open in the
 701 +read-only mode.
 702 +
 703 +<link linkend="close-hook">close-hook</link> is not called when you
 704 +exit from the folder if the folder was not changed.
 705 +</para>
 706 +</sect2>
 707 +
 708 +<sect2 id="append-hook">
 709 +<title>Append a message to a compressed mailbox</title>
 710 +
 711 +<para>
 712 +Usage: <literal>append-hook</literal> <emphasis>regexp</emphasis> &quot;<emphasis>command</emphasis>&quot;
 713 +
 714 +This command is used for saving to an existing compressed folder.  The
 715 +<emphasis>command</emphasis> is the command that can be used for
 716 +appending to the folders whose names match
 717 +<emphasis>regexp</emphasis>. It has the same format as in the <link
 718 +linkend="open-hook">open-hook</link> command.  The temporary folder in
 719 +this case contains the messages that are being appended.
 720 +
 721 +The <emphasis>command</emphasis> should <emphasis
 722 +role="bold">not</emphasis> remove the decompressed file. The
 723 +<emphasis>command</emphasis> should return non-zero exit status if it
 724 +fails, so mutt knows something's wrong.
 725 +
 726 +Example:
 727 +
 728 +<screen>
 729 +append-hook \\.gz$ "gzip -c %t &gt;&gt; %f"
 730 +</screen>
 731 +
 732 +When <link linkend="append-hook">append-hook</link> is used, the folder
 733 +is not opened, which saves time, but this means that we can not find
 734 +out what the folder type is. Thus the default (<link
 735 +linkend="mbox-type">&dollar;mbox&lowbar;type</link>) type is always
 736 +supposed (i.e.  this is the format used for the temporary folder).
 737 +
 738 +If the file does not exist when you save to it, <link
 739 +linkend="close-hook">close-hook</link> is called, and not <link
 740 +linkend="append-hook">append-hook</link>. <link
 741 +linkend="append-hook">append-hook</link> is only for appending to
 742 +existing folders.
 743 +
 744 +If the <emphasis>command</emphasis> is empty, this operation is
 745 +disabled for this file type. In this case, the folder will be open and
 746 +closed again (using <link linkend="open-hook">open-hook</link> and
 747 +<link linkend="close-hook">close-hook</link>respectively) each time you
 748 +will add to it.
 749 +</para>
 750 +</sect2>
 751 +
 752 +<sect2>
 753 +<title>Encrypted folders</title>
 754 +
 755 +<para>
 756 +The compressed folders support can also be used to handle encrypted
 757 +folders. If you want to encrypt a folder with PGP, you may want to use
 758 +the following hooks:
 759 +
 760 +<screen>
 761 +open-hook  \\.pgp$ "pgp -f &lt; %f &gt; %t"
 762 +close-hook \\.pgp$ "pgp -fe YourPgpUserIdOrKeyId &lt; %t &gt; %f"
 763 +</screen>
 764 +
 765 +Please note, that PGP does not support appending to an encrypted
 766 +folder, so there is no append-hook defined.
 767 +
 768 +If you are using GnuPG instead of PGP, you may use the following hooks
 769 +instead:
 770 +
 771 +<screen>
 772 +open-hook  \\.gpg$ "gpg --decrypt &lt; %f &gt; %t"
 773 +close-hook \\.gpg$ "gpg --encrypt --recipient YourGpgUserIdOrKeyId &lt; %t &gt; %f"
 774 +</screen>
 775 +
 776 +<emphasis role="bold">Note:</emphasis> the folder is temporary stored
 777 +decrypted in the /tmp directory, where it can be read by your system
 778 +administrator. So think about the security aspects of this.
 779 +</para>
 780 +</sect2>
 781 +</sect1>
 782 +
 783  <chapter id="mimesupport">
 784  <title>Mutt's MIME Support</title>
 785
 786 --- a/doc/Muttrc.head
 787 +++ b/doc/Muttrc.head
 788 @@ -29,6 +29,11 @@
 789  macro index,pager y "<change-folder>?<toggle-mailboxes>" "show incoming mailboxes list"
 790  bind browser y exit
 791
 792 +# Use folders which match on \\.gz$ as gzipped folders:
 793 +# open-hook \\.gz$ "gzip -cd %f > %t"
 794 +# close-hook \\.gz$ "gzip -c %t > %f"
 795 +# append-hook \\.gz$ "gzip -c %t >> %f"
 796 +
 797  # If Mutt is unable to determine your site's domain name correctly, you can
 798  # set the default here.
 799  #
 800 --- a/doc/muttrc.man.head
 801 +++ b/doc/muttrc.man.head
 802 @@ -345,6 +345,24 @@
 803  to a certain recipient.  The meaning of "key ID" is to be taken
 804  broadly: This can be a different e-mail address, a numerical key ID,
 805  or even just an arbitrary search string.
 806 +.PP
 807 +.nf
 808 +\fBopen-hook\fP \fIregexp\fP "\fIcommand\fP"
 809 +\fBclose-hook\fP \fIregexp\fP "\fIcommand\fP"
 810 +\fBappend-hook\fP \fIregexp\fP "\fIcommand\fP"
 811 +.fi
 812 +.IP
 813 +These commands provide a way to handle compressed folders. The given
 814 +\fBregexp\fP specifies which folders are taken as compressed (e.g.
 815 +"\fI\\\\.gz$\fP"). The commands tell Mutt how to uncompress a folder
 816 +(\fBopen-hook\fP), compress a folder (\fBclose-hook\fP) or append a
 817 +compressed mail to a compressed folder (\fBappend-hook\fP). The
 818 +\fIcommand\fP string is the
 819 +.BR printf (3)
 820 +like format string, and it should accept two parameters: \fB%f\fP,
 821 +which is replaced with the (compressed) folder name, and \fB%t\fP
 822 +which is replaced with the name of the temporary folder to which to
 823 +write.
 824  .TP
 825  \fBpush\fP \fIstring\fP
 826  This command adds the named \fIstring\fP to the keyboard buffer.
 827 --- a/hook.c
 828 +++ b/hook.c
 829 @@ -24,6 +24,10 @@
 830  #include "mailbox.h"
 831  #include "mutt_crypt.h"
 832
 833 +#ifdef USE_COMPRESSED
 834 +#include "compress.h"
 835 +#endif
 836 +
 837  #include <limits.h>
 838  #include <string.h>
 839  #include <stdlib.h>
 840 @@ -92,6 +96,16 @@
 841      memset (&pattern, 0, sizeof (pattern));
 842      pattern.data = safe_strdup (path);
 843    }
 844 +#ifdef USE_COMPRESSED
 845 +  else if (data & (M_APPENDHOOK | M_OPENHOOK | M_CLOSEHOOK))
 846 +  {
 847 +    if (mutt_test_compress_command (command.data))
 848 +    {
 849 +      strfcpy (err->data, _("badly formatted command string"), err->dsize);
 850 +      return (-1);
 851 +    }
 852 +  }
 853 +#endif
 854    else if (DefaultHook && !(data & (M_CHARSETHOOK | M_ICONVHOOK | M_ACCOUNTHOOK))
 855             && (!WithCrypto || !(data & M_CRYPTHOOK))
 856        )
 857 --- a/init.h
 858 +++ b/init.h
 859 @@ -3504,6 +3504,11 @@
 860    { "fcc-hook",                mutt_parse_hook,        M_FCCHOOK },
 861    { "fcc-save-hook",   mutt_parse_hook,        M_FCCHOOK | M_SAVEHOOK },
 862    { "folder-hook",     mutt_parse_hook,        M_FOLDERHOOK },
 863 +#ifdef USE_COMPRESSED
 864 +  { "open-hook",       mutt_parse_hook,        M_OPENHOOK },
 865 +  { "close-hook",      mutt_parse_hook,        M_CLOSEHOOK },
 866 +  { "append-hook",     mutt_parse_hook,        M_APPENDHOOK },
 867 +#endif
 868    { "group",           parse_group,            0 },
 869    { "ungroup",         parse_ungroup,          0 },
 870    { "hdr_order",       parse_list,             UL &HeaderOrderList },
 871 --- a/main.c
 872 +++ b/main.c
 873 @@ -402,6 +402,12 @@
 874  #else
 875         "-LOCALES_HACK  "
 876  #endif
 877 +
 878 +#ifdef USE_COMPRESSED
 879 +       "+COMPRESSED  "
 880 +#else
 881 +       "-COMPRESSED  "
 882 +#endif
 883
 884  #ifdef HAVE_WC_FUNCS
 885         "+HAVE_WC_FUNCS  "
 886 --- a/Makefile.am
 887 +++ b/Makefile.am
 888 @@ -18,7 +18,7 @@
 889  bin_PROGRAMS = mutt @DOTLOCK_TARGET@ @PGPAUX_TARGET@
 890  mutt_SOURCES = \
 891         addrbook.c alias.c attach.c base64.c browser.c buffy.c color.c \
 892 -       crypt.c cryptglue.c \
 893 +       crypt.c cryptglue.c compress.c \
 894         commands.c complete.c compose.c copy.c curs_lib.c curs_main.c date.c \
 895         edit.c enter.c flags.c init.c filter.c from.c \
 896         getdomain.c group.c \
 897 @@ -57,7 +57,7 @@
 898         bcache.h browser.h hcache.h mbyte.h mutt_idna.h remailer.h url.h
 899
 900  EXTRA_DIST = COPYRIGHT GPL OPS OPS.PGP OPS.CRYPT OPS.SMIME TODO UPDATING \
 901 -       configure account.h \
 902 +       configure account.h compress.h \
 903         attach.h buffy.h charset.h copy.h crypthash.h dotlock.h functions.h gen_defs \
 904         globals.h hash.h history.h init.h keymap.h mutt_crypt.h \
 905         mailbox.h mapping.h md5.h mime.h mutt.h mutt_curses.h mutt_menu.h \
 906 --- a/mbox.c
 907 +++ b/mbox.c
 908 @@ -29,6 +29,10 @@
 909  #include "copy.h"
 910  #include "mutt_curses.h"
 911
 912 +#ifdef USE_COMPRESSED
 913 +#include "compress.h"
 914 +#endif
 915 +
 916  #include <sys/stat.h>
 917  #include <dirent.h>
 918  #include <string.h>
 919 @@ -1048,6 +1052,12 @@
 920  int mbox_close_mailbox (CONTEXT *ctx)
 921  {
 922    mx_unlock_file (ctx->path, fileno (ctx->fp), 1);
 923 +
 924 +#ifdef USE_COMPRESSED
 925 +  if (ctx->compressinfo)
 926 +    mutt_slow_close_compressed (ctx);
 927 +#endif
 928 +
 929    mutt_unblock_signals ();
 930    mx_fastclose_mailbox (ctx);
 931    return 0;
 932 --- a/mutt.h
 933 +++ b/mutt.h
 934 @@ -146,6 +146,11 @@
 935  #define M_ACCOUNTHOOK  (1<<9)
 936  #define M_REPLYHOOK    (1<<10)
 937  #define M_SEND2HOOK     (1<<11)
 938 +#ifdef USE_COMPRESSED
 939 +#define M_OPENHOOK     (1<<12)
 940 +#define M_APPENDHOOK   (1<<13)
 941 +#define M_CLOSEHOOK    (1<<14)
 942 +#endif
 943
 944  /* tree characters for linearize_tree and print_enriched_string */
 945  #define M_TREE_LLCORNER                1
 946 @@ -882,6 +887,11 @@
 947    int flagged;                 /* how many flagged messages */
 948    int msgnotreadyet;           /* which msg "new" in pager, -1 if none */
 949
 950 +#ifdef USE_COMPRESSED
 951 +  void *compressinfo;          /* compressed mbox module private data */
 952 +  char *realpath;              /* path to compressed mailbox */
 953 +#endif /* USE_COMPRESSED */
 954 +
 955    short magic;                 /* mailbox type */
 956
 957    unsigned char rights[(RIGHTSMAX + 7)/8];     /* ACL bits */
 958 --- a/mx.c
 959 +++ b/mx.c
 960 @@ -30,6 +30,10 @@
 961  #include "keymap.h"
 962  #include "url.h"
 963
 964 +#ifdef USE_COMPRESSED
 965 +#include "compress.h"
 966 +#endif
 967 +
 968  #ifdef USE_IMAP
 969  #include "imap.h"
 970  #endif
 971 @@ -415,6 +419,10 @@
 972      return (-1);
 973    }
 974
 975 +#ifdef USE_COMPRESSED
 976 +  if (magic == 0 && mutt_can_read_compressed (path))
 977 +    return M_COMPRESSED;
 978 +#endif
 979    return (magic);
 980  }
 981
 982 @@ -454,6 +462,13 @@
 983  {
 984    struct stat sb;
 985
 986 +#ifdef USE_COMPRESSED
 987 +  /* special case for appending to compressed folders -
 988 +   * even if we can not open them for reading */
 989 +  if (mutt_can_append_compressed (ctx->path))
 990 +    mutt_open_append_compressed (ctx);
 991 +#endif
 992 +
 993    ctx->append = 1;
 994
 995  #ifdef USE_IMAP
 996 @@ -617,7 +632,12 @@
 997    }
 998
 999    ctx->magic = mx_get_magic (path);
1000 -
1001 +
1002 +#ifdef USE_COMPRESSED
1003 +  if (ctx->magic == M_COMPRESSED)
1004 +    mutt_open_read_compressed (ctx);
1005 +#endif
1006 +
1007    if(ctx->magic == 0)
1008      mutt_error (_("%s is not a mailbox."), path);
1009
1010 @@ -718,6 +738,10 @@
1011      mutt_free_header (&ctx->hdrs[i]);
1012    FREE (&ctx->hdrs);
1013    FREE (&ctx->v2r);
1014 +#ifdef USE_COMPRESSED
1015 +  if (ctx->compressinfo)
1016 +    mutt_fast_close_compressed (ctx);
1017 +#endif
1018    FREE (&ctx->path);
1019    FREE (&ctx->pattern);
1020    if (ctx->limit_pattern)
1021 @@ -770,6 +794,12 @@
1022
1023    if (tmp && tmp->new == 0)
1024      mutt_update_mailbox (tmp);
1025 +
1026 +#ifdef USE_COMPRESSED
1027 +  if (rc == 0 && ctx->compressinfo)
1028 +    return mutt_sync_compressed (ctx);
1029 +#endif
1030 +
1031    return rc;
1032  }
1033
1034 @@ -1033,6 +1063,11 @@
1035        !mutt_is_spool(ctx->path) && !option (OPTSAVEEMPTY))
1036      mx_unlink_empty (ctx->path);
1037
1038 +#ifdef USE_COMPRESSED
1039 +  if (ctx->compressinfo && mutt_slow_close_compressed (ctx))
1040 +    return (-1);
1041 +#endif
1042 +
1043    mx_fastclose_mailbox (ctx);
1044
1045    return 0;
1046 @@ -1355,6 +1390,11 @@
1047  {
1048    int rc;
1049
1050 +#ifdef USE_COMPRESSED
1051 +  if (ctx->compressinfo)
1052 +    return mutt_check_mailbox_compressed (ctx);
1053 +#endif
1054 +
1055    if (ctx)
1056    {
1057      if (ctx->locked) lock = 0;
1058 --- a/mx.h
1059 +++ b/mx.h
1060 @@ -40,6 +40,9 @@
1061  #ifdef USE_POP
1062    , M_POP
1063  #endif
1064 +#ifdef USE_COMPRESSED
1065 +  , M_COMPRESSED
1066 +#endif
1067  };
1068
1069  WHERE short DefaultMagic INITVAL (M_MBOX);
1070 --- a/po/de.po
1071 +++ b/po/de.po
1072 @@ -2005,6 +2005,10 @@
1073  msgid "Bad history file format (line %d)"
1074  msgstr "Falsches Format der Datei früherer Eingaben (Zeile %d)"
1075
1076 +#: hook.c:96
1077 +msgid "badly formatted command string"
1078 +msgstr "Hook enthält nicht die Muster %f und %t"
1079 +
1080  #: hook.c:251
1081  #, c-format
1082  msgid "unhook: Can't do unhook * from within a hook."
1083 @@ -2766,7 +2770,7 @@
1084  msgid "Mailbox is corrupt!"
1085  msgstr "Mailbox fehlerhaft!"
1086
1087 -#: mbox.c:678
1088 +#: mbox.c:678 compress.c:203 mbox.c:661
1089  msgid "Mailbox was corrupted!"
1090  msgstr "Mailbox wurde zerstört!"
1091
1092 @@ -2774,10 +2778,11 @@
1093  msgid "Fatal error!  Could not reopen mailbox!"
1094  msgstr "Fataler Fehler, konnte Mailbox nicht erneut öffnen!"
1095
1096 -#: mbox.c:746
1097 +#: mbox.c:746 compress.c:264 compress.c:246 compress.c:367 compress.c:443 mbox.c:706
1098  msgid "Unable to lock mailbox!"
1099  msgstr "Kann Mailbox nicht für exklusiven Zugriff sperren!"
1100
1101 +
1102  #. this means ctx->changed or ctx->deleted was set, but no
1103  #. * messages were found to be changed or deleted.  This should
1104  #. * never happen, is we presume it is a bug in mutt.
1105 @@ -5378,3 +5383,32 @@
1106
1107  #~ msgid "Authentication method is unknown."
1108  #~ msgstr "Authentifizierungsmethode unbekannt."
1109 +
1110 +#: compress.c:228 compress.c:253
1111 +#, c-format
1112 +msgid "Decompressing %s...\n"
1113 +msgstr "Entpacke %s...\n"
1114 +
1115 +#: compress.c:350 compress.c:377 compress.c:423 compress.c:454
1116 +#, c-format
1117 +msgid "Compressing %s...\n"
1118 +msgstr "Komprimiere %s...\n"
1119 +
1120 +#: compress.c:381
1121 +#, c-format
1122 +msgid ""
1123 +"%s: Error compressing mailbox! Original mailbox deleted, uncompressed one "
1124 +"kept!\n"
1125 +msgstr ""
1126 +"%s: Fehler beim Komprimieren der Mailbox! Ursprüngliche Mailbox gelöscht, "
1127 +"entpackte gespeichert!\n"
1128 +
1129 +#: compress.c:425 compress.c:456
1130 +#, c-format
1131 +msgid "Compressed-appending to %s...\n"
1132 +msgstr "Hänge komprimiert an %s... an\n"
1133 +
1134 +#: compress.c:461
1135 +#, c-format
1136 +msgid " %s: Error compressing mailbox!  Uncompressed one kept!\n"
1137 +msgstr " %s: Fehler beim packen der Mailbox! Entpackte Mailbox gespeichert!\n"
1138 --- a/po/POTFILES.in
1139 +++ b/po/POTFILES.in
1140 @@ -8,6 +8,7 @@
1141  color.c
1142  commands.c
1143  compose.c
1144 +compress.c
1145  crypt-gpgme.c
1146  crypt.c
1147  cryptglue.c
1148 --- a/status.c
1149 +++ b/status.c
1150 @@ -96,6 +96,14 @@
1151
1152      case 'f':
1153        snprintf (fmt, sizeof(fmt), "%%%ss", prefix);
1154 +#ifdef USE_COMPRESSED
1155 +      if (Context && Context->compressinfo && Context->realpath)
1156 +      {
1157 +        strfcpy (tmp, Context->realpath, sizeof (tmp));
1158 +        mutt_pretty_mailbox (tmp, sizeof (tmp));
1159 +      }
1160 +      else
1161 +#endif
1162        if (Context && Context->path)
1163        {
1164         strfcpy (tmp, Context->path, sizeof (tmp));