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