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