upstream/extra-patches/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-03-10
  11   - File: http://www.spinnaker.de/mutt/compressed/patch-1.5.8.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   - 2005-03-10: fix configure.in to match latest CVS.
  18
  19 == END PATCH
  20 diff -urN mutt-1.5.8/compress.c mutt-1.5.8-ro/compress.c
  21 --- mutt-1.5.8/compress.c       1970-01-01 01:00:00.000000000 +0100
  22 +++ mutt-1.5.8-ro/compress.c    2005-02-13 18:54:39.000000000 +0100
  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 diff -urN mutt-1.5.8/compress.h mutt-1.5.8-ro/compress.h
 512 --- mutt-1.5.8/compress.h       1970-01-01 01:00:00.000000000 +0100
 513 +++ mutt-1.5.8-ro/compress.h    2005-02-13 18:54:39.000000000 +0100
 514 @@ -0,0 +1,27 @@
 515 +/*
 516 + * Copyright (C) 1997 Alain Penders <Alain@Finale-Dev.com>
 517 + *
 518 + *     This program is free software; you can redistribute it and/or modify
 519 + *     it under the terms of the GNU General Public License as published by
 520 + *     the Free Software Foundation; either version 2 of the License, or
 521 + *     (at your option) any later version.
 522 + *
 523 + *     This program is distributed in the hope that it will be useful,
 524 + *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 525 + *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 526 + *     GNU General Public License for more details.
 527 + *
 528 + *     You should have received a copy of the GNU General Public License
 529 + *     along with this program; if not, write to the Free Software
 530 + *     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 531 + */
 532 +
 533 +int mutt_can_read_compressed (const char *);
 534 +int mutt_can_append_compressed (const char *);
 535 +int mutt_open_read_compressed (CONTEXT *);
 536 +int mutt_open_append_compressed (CONTEXT *);
 537 +int mutt_slow_close_compressed (CONTEXT *);
 538 +int mutt_sync_compressed (CONTEXT *);
 539 +int mutt_test_compress_command (const char *);
 540 +int mutt_check_mailbox_compressed (CONTEXT *);
 541 +void mutt_fast_close_compressed (CONTEXT *);
 542 diff -urN mutt-1.5.8/config.h.in mutt-1.5.8-ro/config.h.in
 543 diff -urN mutt-1.5.8/configure mutt-1.5.8-ro/configure
 544 diff -urN mutt-1.5.8/configure.in mutt-1.5.8-ro/configure.in
 545 --- mutt-1.5.8/configure.in     2005-02-12 21:57:16.000000000 +0100
 546 +++ mutt-1.5.8-ro/configure.in  2005-02-13 18:54:39.000000000 +0100
 547 @@ -776,6 +776,11 @@
 548                  AC_DEFINE(LOCALES_HACK,1,[ Define if the result of isprint() is unreliable. ])
 549          fi])
 550
 551 +AC_ARG_ENABLE(compressed, AC_HELP_STRING([--enable-compressed], [Enable compressed folders support]),
 552 +       [if test x$enableval = xyes; then
 553 +                AC_DEFINE(USE_COMPRESSED,1, [ Define to support compressed folders. ])
 554 +        fi])
 555 +
 556  AC_ARG_WITH(exec-shell, AC_HELP_STRING([--with-exec-shell=SHELL], [Specify alternate shell (ONLY if /bin/sh is broken)]),
 557          [if test $withval != yes; then
 558                  AC_DEFINE_UNQUOTED(EXECSHELL, "$withval",
 559 diff -urN mutt-1.5.8/curs_main.c mutt-1.5.8-ro/curs_main.c
 560 --- mutt-1.5.8/curs_main.c      2005-02-12 20:22:15.000000000 +0100
 561 +++ mutt-1.5.8-ro/curs_main.c   2005-02-13 18:54:39.000000000 +0100
 562 @@ -1076,6 +1076,11 @@
 563          {
 564           int check;
 565
 566 +#ifdef USE_COMPRESSED
 567 +         if (Context->compressinfo && Context->realpath)
 568 +           mutt_str_replace (&LastFolder, Context->realpath);
 569 +         else
 570 +#endif
 571           mutt_str_replace (&LastFolder, Context->path);
 572           oldcount = Context ? Context->msgcount : 0;
 573
 574 diff -urN mutt-1.5.8/doc/manual-4.html mutt-1.5.8-ro/doc/manual-4.html
 575 diff -urN mutt-1.5.8/doc/manual-6.html mutt-1.5.8-ro/doc/manual-6.html
 576 diff -urN mutt-1.5.8/doc/manual.html mutt-1.5.8-ro/doc/manual.html
 577 diff -urN mutt-1.5.8/doc/manual.sgml mutt-1.5.8-ro/doc/manual.sgml
 578 diff -urN mutt-1.5.8/doc/manual.sgml.head mutt-1.5.8-ro/doc/manual.sgml.head
 579 --- mutt-1.5.8/doc/manual.sgml.head     2005-02-12 20:41:36.000000000 +0100
 580 +++ mutt-1.5.8-ro/doc/manual.sgml.head  2005-02-13 18:54:39.000000000 +0100
 581 @@ -2537,6 +2537,176 @@
 582  macro pager \cb |urlview\n
 583  </verb></tscreen>
 584
 585 +<sect1>Compressed folders Support (OPTIONAL)
 586 +<p>
 587 +
 588 +If Mutt was compiled with compressed folders support (by running the
 589 +<em/configure/ script with the <em/--enable-compressed/ flag), Mutt
 590 +can open folders stored in an arbitrary format, provided that the user
 591 +has a script to convert from/to this format to one of the accepted.
 592 +
 593 +The most common use is to open compressed archived folders e.g. with
 594 +gzip.
 595 +
 596 +In addition, the user can provide a script that gets a folder in an
 597 +accepted format and appends its context to the folder in the
 598 +user-defined format, which may be faster than converting the entire
 599 +folder to the accepted format, appending to it and converting back to
 600 +the user-defined format.
 601 +
 602 +There are three hooks defined (<ref id="open-hook" name="open-hook">,
 603 +<ref id="close-hook" name="close-hook"> and <ref id="append-hook"
 604 +name="append-hook">) which define commands to uncompress and compress
 605 +a folder and to append messages to an existing compressed folder
 606 +respectively.
 607 +
 608 +For example:
 609 +
 610 +<tscreen><verb>
 611 +open-hook \\.gz$ "gzip -cd %f &gt; %t"
 612 +close-hook \\.gz$ "gzip -c %t &gt; %f"
 613 +append-hook \\.gz$ "gzip -c %t &gt;&gt; %f"
 614 +</verb></tscreen>
 615 +
 616 +You do not have to specify all of the commands. If you omit <ref
 617 +id="append-hook" name="append-hook">, the folder will be open and
 618 +closed again each time you will add to it. If you omit <ref
 619 +id="close-hook" name="close-hook"> (or give empty command) , the
 620 +folder will be open in the  mode. If you specify <ref
 621 +id="append-hook" name="append-hook"> though you'll be able to append
 622 +to the folder.
 623 +
 624 +Note that Mutt will only try to use hooks if the file is not in one of
 625 +the accepted formats. In particular, if the file is empty, mutt
 626 +supposes it is not compressed. This is important because it allows the
 627 +use of programs that do not have well defined extensions. Just use
 628 +&dquot;.&dquot; as a regexp. But this may be surprising if your
 629 +compressing script produces empty files. In this situation, unset <ref
 630 +id="save_empty" name="&dollar;save&lowbar;empty">, so that the compressed file
 631 +will be removed if you delete all of the messages.
 632 +
 633 +<sect2>Open a compressed mailbox for reading<label id="open-hook">
 634 +<p>
 635 +Usage: <tt/open-hook/ <em/regexp/ &dquot;<em/command/&dquot;
 636 +
 637 +The <em/command/ is the command that can be used for opening the
 638 +folders whose names match <em/regexp/.
 639 +
 640 +The <em/command/ string is the printf-like format string, and it
 641 +should accept two parameters: &percnt;f, which is replaced with the
 642 +(compressed) folder name, and &percnt;t which is replaced with the
 643 +name of the temporary folder to which to write.
 644 +
 645 +&percnt;f and &percnt;t can be repeated any number of times in the
 646 +command string, and all of the entries are replaced with the
 647 +appropriate folder name. In addition, &percnt;&percnt; is replaced by
 648 +&percnt;, as in printf, and any other &percnt;anything is left as is.
 649 +
 650 +The <em/command/ should <bf/not/ remove the original compressed file.
 651 +The <em/command/ should return non-zero exit status if it fails, so
 652 +mutt knows something's wrong.
 653 +
 654 +Example:
 655 +
 656 +<tscreen><verb>
 657 +open-hook \\.gz$ "gzip -cd %f &gt; %t"
 658 +</verb></tscreen>
 659 +
 660 +If the <em/command/ is empty, this operation is disabled for this file
 661 +type.
 662 +
 663 +<sect2>Write a compressed mailbox<label id="close-hook">
 664 +<p>
 665 +Usage: <tt/close-hook/ <em/regexp/ &dquot;<em/command/&dquot;
 666 +
 667 +This is used to close the folder that was open with the <ref id="open-hook"
 668 +name="open-hook"> command after some changes were made to it.
 669 +
 670 +The <em/command/ string is the command that can be used for closing the
 671 +folders whose names match <em/regexp/. It has the same format as in
 672 +the <ref id="open-hook" name="open-hook"> command. Temporary folder
 673 +in this case is the folder previously produced by the <ref id="open-hook"
 674 +name="open-hook"> command.
 675 +
 676 +The <em/command/ should <bf/not/ remove the decompressed file. The
 677 +<em/command/ should return non-zero exit status if it fails, so mutt
 678 +knows something's wrong.
 679 +
 680 +Example:
 681 +
 682 +<tscreen><verb>
 683 +close-hook \\.gz$ "gzip -c %t &gt; %f"
 684 +</verb></tscreen>
 685 +
 686 +If the <em/command/ is empty, this operation is disabled for this file
 687 +type, and the file can only be open in the read-only mode.
 688 +
 689 +<ref id="close-hook" name ="close-hook"> is not called when you exit
 690 +from the folder if the folder was not changed.
 691 +
 692 +<sect2>Append a message to a compressed mailbox<label id="append-hook">
 693 +<p>
 694 +Usage: <tt/append-hook/ <em/regexp/ &dquot;<em/command/&dquot;
 695 +
 696 +This command is used for saving to an existing compressed folder.
 697 +The <em/command/ is the command that can be used for appending to the
 698 +folders whose names match <em/regexp/. It has the same format as in
 699 + the <ref id="open-hook" name="open-hook"> command.
 700 +The temporary folder in this case contains the messages that are being
 701 +appended.
 702 +
 703 +The <em/command/ should <bf/not/ remove the decompressed file. The
 704 +<em/command/ should return non-zero exit status if it fails, so mutt
 705 +knows something's wrong.
 706 +
 707 +Example:
 708 +
 709 +<tscreen><verb>
 710 +append-hook \\.gz$ "gzip -c %t &gt;&gt; %f"
 711 +</verb></tscreen>
 712 +
 713 +When <ref id="append-hook" name="append-hook"> is used, the folder is
 714 +not opened, which saves time, but this means that we can not find out
 715 +what the folder type is. Thus the default (<ref id="mbox_type"
 716 +name="&dollar;mbox&lowbar;type">) type is always supposed (i.e.
 717 +this is the format used for the temporary folder).
 718 +
 719 +If the file does not exist when you save to it, <ref id="close-hook"
 720 +name="close-hook"> is called, and not <ref id="append-hook"
 721 +name="append-hook">. <ref id="append-hook" name="append-hook"> is only
 722 +for appending to existing folders.
 723 +
 724 +If the <em/command/ is empty, this operation is disabled for this file
 725 +type. In this case, the folder will be open and closed again (using
 726 +<ref id="open-hook" name="open-hook"> and <ref id="close-hook"
 727 +name="close-hook">respectively) each time you will add to it.
 728 +
 729 +<sect2>Encrypted folders
 730 +<p>
 731 +The compressed folders support can also be used to handle encrypted
 732 +folders. If you want to encrypt a folder with PGP, you may want to use
 733 +the following hooks:
 734 +
 735 +<tscreen><verb>
 736 +open-hook  \\.pgp$ "pgp -f &lt; %f &gt; %t"
 737 +close-hook \\.pgp$ "pgp -fe YourPgpUserIdOrKeyId &lt; %t &gt; %f"
 738 +</verb></tscreen>
 739 +
 740 +Please note, that PGP does not support appending to an encrypted
 741 +folder, so there is no append-hook defined.
 742 +
 743 +If you are using GnuPG instead of PGP, you may use the following hooks
 744 +instead:
 745 +
 746 +<tscreen><verb>
 747 +open-hook  \\.gpg$ "gpg --decrypt &lt; %f &gt; %t"
 748 +close-hook \\.gpg$ "gpg --encrypt --recipient YourGpgUserIdOrKeyId &lt; %t &gt; %f"
 749 +</verb></tscreen>
 750 +
 751 +<bf/Note:/ the folder is temporary stored decrypted in the /tmp
 752 +directory, where it can be read by your system administrator. So think
 753 +about the security aspects of this.
 754 +
 755  <sect>Mutt's MIME Support
 756  <p>
 757  Quite a bit of effort has been made to make Mutt the premier text-mode
 758 @@ -3116,6 +3286,8 @@
 759  <item>
 760  <tt><ref id="alternative_order" name="unalternative&lowbar;order"></tt> <em/mimetype/ &lsqb; <em/mimetype/ ... &rsqb;
 761  <item>
 762 +<tt><ref id="append-hook" name="append-hook"></tt> <em/regexp/ &dquot;<em/command/&dquot;
 763 +<item>
 764  <tt><ref id="auto_view" name="auto&lowbar;view"></tt> <em/mimetype/ &lsqb; <em/mimetype/ ... &rsqb;
 765  <item>
 766  <tt><ref id="auto_view" name="unauto&lowbar;view"></tt> <em/mimetype/ &lsqb; <em/mimetype/ ... &rsqb;
 767 @@ -3124,6 +3296,8 @@
 768  <item>
 769  <tt><ref id="charset-hook" name="charset-hook"></tt> <em/alias/ <em/charset/
 770  <item>
 771 +<tt><ref id="close-hook" name="close-hook"></tt> <em/regexp/ &dquot;<em/command/&dquot;
 772 +<item>
 773  <tt><ref id="color" name="color"></tt> <em/object/ <em/foreground/ <em/background/ &lsqb; <em/regexp/ &rsqb;
 774  <item>
 775  <tt><ref id="color" name="uncolor"></tt> <em/index/ <em/pattern/ &lsqb; <em/pattern/ ... &rsqb;
 776 @@ -3170,6 +3344,8 @@
 777  <item>
 778  <tt><ref id="my_hdr" name="unmy&lowbar;hdr"></tt> <em/field/ &lsqb; <em/field/ ... &rsqb;
 779  <item>
 780 +<tt><ref id="open-hook" name="open-hook"></tt> <em/regexp/ &dquot;<em/command/&dquot;
 781 +<item>
 782  <tt><ref id="crypt-hook" name="crypt-hook"></tt> <em/pattern/ <em/key-id/
 783  <item>
 784  <tt><ref id="push" name="push"></tt> <em/string/
 785 diff -urN mutt-1.5.8/doc/manual.txt mutt-1.5.8-ro/doc/manual.txt
 786 diff -urN mutt-1.5.8/doc/muttrc.man mutt-1.5.8-ro/doc/muttrc.man
 787 diff -urN mutt-1.5.8/doc/muttrc.man.head mutt-1.5.8-ro/doc/muttrc.man.head
 788 --- mutt-1.5.8/doc/muttrc.man.head      2005-01-15 10:42:45.000000000 +0100
 789 +++ mutt-1.5.8-ro/doc/muttrc.man.head   2005-02-13 18:54:39.000000000 +0100
 790 @@ -316,6 +316,24 @@
 791  to a certain recipient.  The meaning of "key ID" is to be taken
 792  broadly: This can be a different e-mail address, a numerical key ID,
 793  or even just an arbitrary search string.
 794 +.PP
 795 +.nf
 796 +\fBopen-hook\fP \fIregexp\fP "\fIcommand\fP"
 797 +\fBclose-hook\fP \fIregexp\fP "\fIcommand\fP"
 798 +\fBappend-hook\fP \fIregexp\fP "\fIcommand\fP"
 799 +.fi
 800 +.IP
 801 +These commands provide a way to handle compressed folders. The given
 802 +\fBregexp\fP specifies which folders are taken as compressed (e.g.
 803 +"\fI\\\\.gz$\fP"). The commands tell Mutt how to uncompress a folder
 804 +(\fBopen-hook\fP), compress a folder (\fBclose-hook\fP) or append a
 805 +compressed mail to a compressed folder (\fBappend-hook\fP). The
 806 +\fIcommand\fP string is the
 807 +.BR printf (3)
 808 +like format string, and it should accept two parameters: \fB%f\fP,
 809 +which is replaced with the (compressed) folder name, and \fB%t\fP
 810 +which is replaced with the name of the temporary folder to which to
 811 +write.
 812  .TP
 813  \fBpush\fP \fIstring\fP
 814  This command adds the named \fIstring\fP to the keyboard buffer.
 815 diff -urN mutt-1.5.8/hook.c mutt-1.5.8-ro/hook.c
 816 --- mutt-1.5.8/hook.c   2005-02-03 19:47:52.000000000 +0100
 817 +++ mutt-1.5.8-ro/hook.c        2005-02-13 18:54:39.000000000 +0100
 818 @@ -24,6 +24,10 @@
 819  #include "mailbox.h"
 820  #include "mutt_crypt.h"
 821
 822 +#ifdef USE_COMPRESSED
 823 +#include "compress.h"
 824 +#endif
 825 +
 826  #include <limits.h>
 827  #include <string.h>
 828  #include <stdlib.h>
 829 @@ -92,6 +96,16 @@
 830      memset (&pattern, 0, sizeof (pattern));
 831      pattern.data = safe_strdup (path);
 832    }
 833 +#ifdef USE_COMPRESSED
 834 +  else if (data & (M_APPENDHOOK | M_OPENHOOK | M_CLOSEHOOK))
 835 +  {
 836 +    if (mutt_test_compress_command (command.data))
 837 +    {
 838 +      strfcpy (err->data, _("bad formatted command string"), err->dsize);
 839 +      return (-1);
 840 +    }
 841 +  }
 842 +#endif
 843    else if (DefaultHook && !(data & (M_CHARSETHOOK | M_ACCOUNTHOOK))
 844             && (!WithCrypto || !(data & M_CRYPTHOOK))
 845        )
 846 diff -urN mutt-1.5.8/init.h mutt-1.5.8-ro/init.h
 847 --- mutt-1.5.8/init.h   2005-02-12 21:01:10.000000000 +0100
 848 +++ mutt-1.5.8-ro/init.h        2005-02-13 18:54:39.000000000 +0100
 849 @@ -2926,6 +2926,11 @@
 850    { "fcc-hook",                mutt_parse_hook,        M_FCCHOOK },
 851    { "fcc-save-hook",   mutt_parse_hook,        M_FCCHOOK | M_SAVEHOOK },
 852    { "folder-hook",     mutt_parse_hook,        M_FOLDERHOOK },
 853 +#ifdef USE_COMPRESSED
 854 +  { "open-hook",       mutt_parse_hook,        M_OPENHOOK },
 855 +  { "close-hook",      mutt_parse_hook,        M_CLOSEHOOK },
 856 +  { "append-hook",     mutt_parse_hook,        M_APPENDHOOK },
 857 +#endif
 858    { "hdr_order",       parse_list,             UL &HeaderOrderList },
 859  #ifdef HAVE_ICONV
 860    { "iconv-hook",      mutt_parse_hook,        M_ICONVHOOK },
 861 diff -urN mutt-1.5.8/main.c mutt-1.5.8-ro/main.c
 862 --- mutt-1.5.8/main.c   2005-02-12 20:41:32.000000000 +0100
 863 +++ mutt-1.5.8-ro/main.c        2005-02-13 18:54:40.000000000 +0100
 864 @@ -376,6 +376,12 @@
 865  #else
 866         "-LOCALES_HACK  "
 867  #endif
 868 +
 869 +#ifdef USE_COMPRESSED
 870 +       "+COMPRESSED  "
 871 +#else
 872 +       "-COMPRESSED  "
 873 +#endif
 874
 875  #ifdef HAVE_WC_FUNCS
 876         "+HAVE_WC_FUNCS  "
 877 diff -urN mutt-1.5.8/Makefile.am mutt-1.5.8-ro/Makefile.am
 878 --- mutt-1.5.8/Makefile.am      2005-02-12 21:54:39.000000000 +0100
 879 +++ mutt-1.5.8-ro/Makefile.am   2005-02-13 18:54:40.000000000 +0100
 880 @@ -18,7 +18,7 @@
 881  bin_PROGRAMS = mutt @DOTLOCK_TARGET@ @PGPAUX_TARGET@
 882  mutt_SOURCES = $(BUILT_SOURCES) \
 883         addrbook.c alias.c attach.c base64.c browser.c buffy.c color.c \
 884 -        crypt.c cryptglue.c \
 885 +        crypt.c cryptglue.c compress.c \
 886         commands.c complete.c compose.c copy.c curs_lib.c curs_main.c date.c \
 887         edit.c enter.c flags.c init.c filter.c from.c getdomain.c \
 888         handler.c hash.c hdrline.c headers.c help.c hook.c keymap.c \
 889 @@ -67,7 +67,7 @@
 890         crypt-gpgme.c crypt-mod-pgp-gpgme.c crypt-mod-smime-gpgme.c
 891
 892  EXTRA_DIST = COPYRIGHT GPL OPS OPS.PGP OPS.CRYPT OPS.SMIME TODO \
 893 -       configure account.h \
 894 +       configure account.h compress.h \
 895         attach.h buffy.h charset.h copy.h crypthash.h dotlock.h functions.h gen_defs \
 896         globals.h hash.h history.h init.h keymap.h mutt_crypt.h \
 897         mailbox.h mapping.h md5.h mime.h mutt.h mutt_curses.h mutt_menu.h \
 898 diff -urN mutt-1.5.8/Makefile.in mutt-1.5.8-ro/Makefile.in
 899 diff -urN mutt-1.5.8/mbox.c mutt-1.5.8-ro/mbox.c
 900 --- mutt-1.5.8/mbox.c   2005-02-03 19:47:53.000000000 +0100
 901 +++ mutt-1.5.8-ro/mbox.c        2005-02-13 18:54:40.000000000 +0100
 902 @@ -28,6 +28,10 @@
 903  #include "sort.h"
 904  #include "copy.h"
 905
 906 +#ifdef USE_COMPRESSED
 907 +#include "compress.h"
 908 +#endif
 909 +
 910  #include <sys/stat.h>
 911  #include <dirent.h>
 912  #include <string.h>
 913 @@ -1020,6 +1024,12 @@
 914  int mbox_close_mailbox (CONTEXT *ctx)
 915  {
 916    mx_unlock_file (ctx->path, fileno (ctx->fp), 1);
 917 +
 918 +#ifdef USE_COMPRESSED
 919 +  if (ctx->compressinfo)
 920 +    mutt_slow_close_compressed (ctx);
 921 +#endif
 922 +
 923    mutt_unblock_signals ();
 924    mx_fastclose_mailbox (ctx);
 925    return 0;
 926 diff -urN mutt-1.5.8/mutt.h mutt-1.5.8-ro/mutt.h
 927 --- mutt-1.5.8/mutt.h   2005-02-12 21:01:20.000000000 +0100
 928 +++ mutt-1.5.8-ro/mutt.h        2005-02-13 18:54:40.000000000 +0100
 929 @@ -159,6 +159,11 @@
 930  #define M_ACCOUNTHOOK  (1<<9)
 931  #define M_REPLYHOOK    (1<<10)
 932  #define M_SEND2HOOK     (1<<11)
 933 +#ifdef USE_COMPRESSED
 934 +#define M_OPENHOOK     (1<<12)
 935 +#define M_APPENDHOOK   (1<<13)
 936 +#define M_CLOSEHOOK    (1<<14)
 937 +#endif
 938
 939  /* tree characters for linearize_tree and print_enriched_string */
 940  #define M_TREE_LLCORNER                1
 941 @@ -823,6 +828,11 @@
 942    void *data;                  /* driver specific data */
 943  #endif /* USE_IMAP */
 944
 945 +#ifdef USE_COMPRESSED
 946 +  void *compressinfo;          /* compressed mbox module private data */
 947 +  char *realpath;              /* path to compressed mailbox */
 948 +#endif /* USE_COMPRESSED */
 949 +
 950    short magic;                 /* mailbox type */
 951
 952    unsigned int locked : 1;     /* is the mailbox locked? */
 953 diff -urN mutt-1.5.8/Muttrc mutt-1.5.8-ro/Muttrc
 954 diff -urN mutt-1.5.8/Muttrc.head mutt-1.5.8-ro/Muttrc.head
 955 --- mutt-1.5.8/Muttrc.head      2005-02-12 21:57:45.000000000 +0100
 956 +++ mutt-1.5.8-ro/Muttrc.head   2005-02-13 18:54:40.000000000 +0100
 957 @@ -19,6 +19,11 @@
 958  macro index   <f1> "!less /usr/local/doc/mutt/manual.txt\n" "Show Mutt documentation"
 959  macro pager   <f1> "!less /usr/local/doc/mutt/manual.txt\n" "Show Mutt documentation"
 960
 961 +# Use folders which match on \\.gz$ as gzipped folders:
 962 +# open-hook \\.gz$ "gzip -cd %f > %t"
 963 +# close-hook \\.gz$ "gzip -c %t > %f"
 964 +# append-hook \\.gz$ "gzip -c %t >> %f"
 965 +
 966  # If Mutt is unable to determine your site's domain name correctly, you can
 967  # set the default here.
 968  #
 969 diff -urN mutt-1.5.8/Muttrc.head.in mutt-1.5.8-ro/Muttrc.head.in
 970 --- mutt-1.5.8/Muttrc.head.in   2002-01-24 13:10:47.000000000 +0100
 971 +++ mutt-1.5.8-ro/Muttrc.head.in        2005-02-13 18:54:40.000000000 +0100
 972 @@ -19,6 +19,11 @@
 973  macro index   <f1> "!less @docdir@/manual.txt\n" "Show Mutt documentation"
 974  macro pager   <f1> "!less @docdir@/manual.txt\n" "Show Mutt documentation"
 975
 976 +# Use folders which match on \\.gz$ as gzipped folders:
 977 +# open-hook \\.gz$ "gzip -cd %f > %t"
 978 +# close-hook \\.gz$ "gzip -c %t > %f"
 979 +# append-hook \\.gz$ "gzip -c %t >> %f"
 980 +
 981  # If Mutt is unable to determine your site's domain name correctly, you can
 982  # set the default here.
 983  #
 984 diff -urN mutt-1.5.8/mx.c mutt-1.5.8-ro/mx.c
 985 --- mutt-1.5.8/mx.c     2005-02-03 19:47:53.000000000 +0100
 986 +++ mutt-1.5.8-ro/mx.c  2005-02-13 18:54:40.000000000 +0100
 987 @@ -30,6 +30,10 @@
 988  #include "keymap.h"
 989  #include "url.h"
 990
 991 +#ifdef USE_COMPRESSED
 992 +#include "compress.h"
 993 +#endif
 994 +
 995  #ifdef USE_IMAP
 996  #include "imap.h"
 997  #endif
 998 @@ -454,6 +458,10 @@
 999      return (-1);
1000    }
1001
1002 +#ifdef USE_COMPRESSED
1003 +  if (magic == 0 && mutt_can_read_compressed (path))
1004 +    return M_COMPRESSED;
1005 +#endif
1006    return (magic);
1007  }
1008
1009 @@ -493,6 +501,13 @@
1010  {
1011    struct stat sb;
1012
1013 +#ifdef USE_COMPRESSED
1014 +  /* special case for appending to compressed folders -
1015 +   * even if we can not open them for reading */
1016 +  if (mutt_can_append_compressed (ctx->path))
1017 +    mutt_open_append_compressed (ctx);
1018 +#endif
1019 +
1020    ctx->append = 1;
1021
1022  #ifdef USE_IMAP
1023 @@ -653,7 +668,12 @@
1024    }
1025
1026    ctx->magic = mx_get_magic (path);
1027 -
1028 +
1029 +#ifdef USE_COMPRESSED
1030 +  if (ctx->magic == M_COMPRESSED)
1031 +    mutt_open_read_compressed (ctx);
1032 +#endif
1033 +
1034    if(ctx->magic == 0)
1035      mutt_error (_("%s is not a mailbox."), path);
1036
1037 @@ -759,6 +779,10 @@
1038      mutt_free_header (&ctx->hdrs[i]);
1039    FREE (&ctx->hdrs);
1040    FREE (&ctx->v2r);
1041 +#ifdef USE_COMPRESSED
1042 +  if (ctx->compressinfo)
1043 +    mutt_fast_close_compressed (ctx);
1044 +#endif
1045    FREE (&ctx->path);
1046    FREE (&ctx->pattern);
1047    if (ctx->limit_pattern)
1048 @@ -816,6 +840,12 @@
1049    if (tmp && tmp->new == 0)
1050      mutt_update_mailbox (tmp);
1051  #endif
1052 +
1053 +#ifdef USE_COMPRESSED
1054 +  if (rc == 0 && ctx->compressinfo)
1055 +    return mutt_sync_compressed (ctx);
1056 +#endif
1057 +
1058    return rc;
1059  }
1060
1061 @@ -1021,6 +1051,11 @@
1062        !mutt_is_spool(ctx->path) && !option (OPTSAVEEMPTY))
1063      mx_unlink_empty (ctx->path);
1064
1065 +#ifdef USE_COMPRESSED
1066 +  if (ctx->compressinfo && mutt_slow_close_compressed (ctx))
1067 +    return (-1);
1068 +#endif
1069 +
1070    mx_fastclose_mailbox (ctx);
1071
1072    return 0;
1073 @@ -1325,6 +1360,11 @@
1074  {
1075    int rc;
1076
1077 +#ifdef USE_COMPRESSED
1078 +  if (ctx->compressinfo)
1079 +    return mutt_check_mailbox_compressed (ctx);
1080 +#endif
1081 +
1082    if (ctx)
1083    {
1084      if (ctx->locked) lock = 0;
1085 diff -urN mutt-1.5.8/mx.h mutt-1.5.8-ro/mx.h
1086 --- mutt-1.5.8/mx.h     2003-08-05 15:58:16.000000000 +0200
1087 +++ mutt-1.5.8-ro/mx.h  2005-02-13 18:54:40.000000000 +0100
1088 @@ -40,6 +40,9 @@
1089  #ifdef USE_POP
1090    , M_POP
1091  #endif
1092 +#ifdef USE_COMPRESSED
1093 +  , M_COMPRESSED
1094 +#endif
1095  };
1096
1097  WHERE short DefaultMagic INITVAL (M_MBOX);
1098 diff -urN mutt-1.5.8/PATCHES mutt-1.5.8-ro/PATCHES
1099 --- mutt-1.5.8/PATCHES  2005-02-12 21:55:51.000000000 +0100
1100 +++ mutt-1.5.8-ro/PATCHES       2005-02-13 18:54:40.000000000 +0100
1101 @@ -0,0 +1 @@
1102 +patch-1.5.8.rr.compressed.1
1103 diff -urN mutt-1.5.8/po/de.po mutt-1.5.8-ro/po/de.po
1104 --- mutt-1.5.8/po/de.po 2005-02-12 21:58:50.000000000 +0100
1105 +++ mutt-1.5.8-ro/po/de.po      2005-02-13 18:56:06.000000000 +0100
1106 @@ -710,6 +710,48 @@
1107  msgid "PGP already selected. Clear & continue ? "
1108  msgstr "PGP bereits ausgewählt. Löschen und weiter?"
1109
1110 +#: compress.c:203 mbox.c:661
1111 +msgid "Mailbox was corrupted!"
1112 +msgstr "Mailbox wurde zerstört!"
1113 +
1114 +#: compress.c:228 compress.c:253
1115 +#, c-format
1116 +msgid "Decompressing %s...\n"
1117 +msgstr "Entpacke %s...\n"
1118 +
1119 +#: compress.c:246 compress.c:367 compress.c:443 mbox.c:706
1120 +msgid "Unable to lock mailbox!"
1121 +msgstr "Kann Mailbox nicht für exklusiven Zugriff sperren!"
1122 +
1123 +#: compress.c:264
1124 +#, c-format
1125 +msgid "Error executing: %s : unable to open the mailbox!\n"
1126 +msgstr "Fehler beim Ausführen von %s : Kann die Mailbox nicht öffnen!\n"
1127 +
1128 +#: compress.c:350 compress.c:377 compress.c:423 compress.c:454
1129 +#, c-format
1130 +msgid "Compressing %s...\n"
1131 +msgstr "Komprimiere %s...\n"
1132 +
1133 +#: compress.c:381
1134 +#, c-format
1135 +msgid ""
1136 +"%s: Error compressing mailbox! Original mailbox deleted, uncompressed one "
1137 +"kept!\n"
1138 +msgstr ""
1139 +"%s: Fehler beim Komprimieren der Mailbox! Ursprüngliche Mailbox gelöscht, "
1140 +"entpackte gespeichert!\n"
1141 +
1142 +#: compress.c:425 compress.c:456
1143 +#, c-format
1144 +msgid "Compressed-appending to %s...\n"
1145 +msgstr "Hänge komprimiert an %s... an\n"
1146 +
1147 +#: compress.c:461
1148 +#, c-format
1149 +msgid " %s: Error compressing mailbox!  Uncompressed one kept!\n"
1150 +msgstr " %s: Fehler beim packen der Mailbox! Entpackte Mailbox gespeichert!\n"
1151 +
1152  #: crypt.c:69
1153  #, c-format
1154  msgid " (current time: %c)"
1155 @@ -1300,6 +1342,10 @@
1156  msgid "Help for %s"
1157  msgstr "Hilfe für %s"
1158
1159 +#: hook.c:96
1160 +msgid "bad formatted command string"
1161 +msgstr "Hook enthält nicht die Muster %f und %t"
1162 +
1163  #: hook.c:246
1164  #, c-format
1165  msgid "unhook: Can't do unhook * from within a hook."
1166 @@ -2713,18 +2759,10 @@
1167  msgid "Mailbox is corrupt!"
1168  msgstr "Mailbox fehlerhaft!"
1169
1170 -#: mbox.c:662
1171 -msgid "Mailbox was corrupted!"
1172 -msgstr "Mailbox wurde zerstört!"
1173 -
1174  #: mbox.c:699 mbox.c:953
1175  msgid "Fatal error!  Could not reopen mailbox!"
1176  msgstr "Fataler Fehler, konnte Mailbox nicht erneut öffnen!"
1177
1178 -#: mbox.c:708
1179 -msgid "Unable to lock mailbox!"
1180 -msgstr "Kann Mailbox nicht für exklusiven Zugriff sperren!"
1181 -
1182  #. this means ctx->changed or ctx->deleted was set, but no
1183  #. * messages were found to be changed or deleted.  This should
1184  #. * never happen, is we presume it is a bug in mutt.
1185 diff -urN mutt-1.5.8/po/POTFILES.in mutt-1.5.8-ro/po/POTFILES.in
1186 --- mutt-1.5.8/po/POTFILES.in   2002-03-27 09:44:17.000000000 +0100
1187 +++ mutt-1.5.8-ro/po/POTFILES.in        2005-02-13 18:54:40.000000000 +0100
1188 @@ -8,6 +8,7 @@
1189  color.c
1190  commands.c
1191  compose.c
1192 +compress.c
1193  crypt.c
1194  curs_lib.c
1195  curs_main.c
1196 diff -urN mutt-1.5.8/status.c mutt-1.5.8-ro/status.c
1197 --- mutt-1.5.8/status.c 2005-02-03 19:47:53.000000000 +0100
1198 +++ mutt-1.5.8-ro/status.c      2005-02-13 18:54:40.000000000 +0100
1199 @@ -97,6 +97,14 @@
1200
1201      case 'f':
1202        snprintf (fmt, sizeof(fmt), "%%%ss", prefix);
1203 +#ifdef USE_COMPRESSED
1204 +      if (Context && Context->compressinfo && Context->realpath)
1205 +      {
1206 +        strfcpy (tmp, Context->realpath, sizeof (tmp));
1207 +        mutt_pretty_mailbox (tmp);
1208 +      }
1209 +      else
1210 +#endif
1211        if (Context && Context->path)
1212        {
1213         strfcpy (tmp, Context->path, sizeof (tmp));