compress.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 1997 Alain Penders <Alain@Finale-Dev.com>
   4  *
   5  * This file is part of mutt-ng, see http://www.muttng.org/.
   6  * It's licensed under the GNU General Public License,
   7  * please see the file GPL in the top level source directory.
   8  */
   9
  10 #include "mutt.h"
  11
  12 #ifdef USE_COMPRESSED
  13
  14 #include "mx.h"
  15 #include "mailbox.h"
  16 #include "mutt_curses.h"
  17
  18 #include "lib/mem.h"
  19 #include "lib/intl.h"
  20 #include "lib/str.h"
  21
  22 #include <errno.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <sys/stat.h>
  26
  27 typedef struct {
  28   const char *close;            /* close-hook  command */
  29   const char *open;             /* open-hook   command */
  30   const char *append;           /* append-hook command */
  31   off_t size;                   /* size of real folder */
  32 } COMPRESS_INFO;
  33
  34 char echo_cmd[HUGE_STRING];
  35
  36 /* parameters:
  37  * ctx - context to lock
  38  * excl - exclusive lock?
  39  * retry - should retry if unable to lock?
  40  */
  41 int mbox_lock_compressed (CONTEXT * ctx, FILE * fp, int excl, int retry)
  42 {
  43   int r;
  44
  45   if ((r = mx_lock_file (ctx->realpath, fileno (fp), excl, 1, retry)) == 0)
  46     ctx->locked = 1;
  47   else if (retry && !excl) {
  48     ctx->readonly = 1;
  49     return 0;
  50   }
  51
  52   return (r);
  53 }
  54
  55 void mbox_unlock_compressed (CONTEXT * ctx, FILE * fp)
  56 {
  57   if (ctx->locked) {
  58     fflush (fp);
  59
  60     mx_unlock_file (ctx->realpath, fileno (fp), 1);
  61     ctx->locked = 0;
  62   }
  63 }
  64
  65 static int is_new (const char *path)
  66 {
  67   return (access (path, W_OK) != 0 && errno == ENOENT) ? 1 : 0;
  68 }
  69
  70 static const char *find_compress_hook (int type, const char *path)
  71 {
  72   const char *c = mutt_find_hook (type, path);
  73
  74   return (!c || !*c) ? NULL : c;
  75 }
  76
  77 int mutt_can_read_compressed (const char *path)
  78 {
  79   return find_compress_hook (M_OPENHOOK, path) ? 1 : 0;
  80 }
  81
  82 /* if the file is new, we really do not append, but create, and so use
  83  * close-hook, and not append-hook
  84  */
  85 static const char *get_append_command (const char *path, const CONTEXT * ctx)
  86 {
  87   COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
  88
  89   return (is_new (path)) ? ci->close : ci->append;
  90 }
  91
  92 int mutt_can_append_compressed (const char *path)
  93 {
  94   int magic;
  95
  96   if (is_new (path))
  97     return (find_compress_hook (M_CLOSEHOOK, path) ? 1 : 0);
  98
  99   magic = mx_get_magic (path);
 100
 101   if (magic != 0 && magic != M_COMPRESSED)
 102     return 0;
 103
 104   return (find_compress_hook (M_APPENDHOOK, path)
 105           || (find_compress_hook (M_OPENHOOK, path)
 106               && find_compress_hook (M_CLOSEHOOK, path))) ? 1 : 0;
 107 }
 108
 109 /* open a compressed mailbox */
 110 static COMPRESS_INFO *set_compress_info (CONTEXT * ctx)
 111 {
 112   COMPRESS_INFO *ci;
 113
 114   /* Now lets uncompress this thing */
 115   ci = safe_malloc (sizeof (COMPRESS_INFO));
 116   ctx->compressinfo = (void *) ci;
 117   ci->append = find_compress_hook (M_APPENDHOOK, ctx->path);
 118   ci->open = find_compress_hook (M_OPENHOOK, ctx->path);
 119   ci->close = find_compress_hook (M_CLOSEHOOK, ctx->path);
 120   return ci;
 121 }
 122
 123 static void set_path (CONTEXT * ctx)
 124 {
 125   char tmppath[_POSIX_PATH_MAX];
 126
 127   /* Setup the right paths */
 128   ctx->realpath = ctx->path;
 129
 130   /* Uncompress to /tmp */
 131   mutt_mktemp (tmppath);
 132   ctx->path = safe_malloc (mutt_strlen (tmppath) + 1);
 133   strcpy (ctx->path, tmppath);
 134 }
 135
 136 static int get_size (const char *path)
 137 {
 138   struct stat sb;
 139
 140   if (stat (path, &sb) != 0)
 141     return 0;
 142   return (sb.st_size);
 143 }
 144
 145 static void store_size (CONTEXT * ctx)
 146 {
 147   COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 148
 149   ci->size = get_size (ctx->realpath);
 150 }
 151
 152 static const char *compresshook_format_str (char *dest, size_t destlen,
 153                                             char op, const char *src,
 154                                             const char *fmt,
 155                                             const char *ifstring,
 156                                             const char *elsestring,
 157                                             unsigned long data,
 158                                             format_flag flags)
 159 {
 160   char tmp[SHORT_STRING];
 161
 162   CONTEXT *ctx = (CONTEXT *) data;
 163
 164   switch (op) {
 165   case 'f':
 166     snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
 167     snprintf (dest, destlen, tmp, ctx->realpath);
 168     break;
 169   case 't':
 170     snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
 171     snprintf (dest, destlen, tmp, ctx->path);
 172     break;
 173   }
 174   return (src);
 175 }
 176
 177 /* check that the command has both %f and %t
 178  * 0 means OK, -1 means error
 179  */
 180 int mutt_test_compress_command (const char *cmd)
 181 {
 182   return (strstr (cmd, "%f") && strstr (cmd, "%t")) ? 0 : -1;
 183 }
 184
 185 static char *get_compression_cmd (const char *cmd, const CONTEXT * ctx)
 186 {
 187   char expanded[_POSIX_PATH_MAX];
 188
 189   mutt_FormatString (expanded, sizeof (expanded), cmd,
 190                      compresshook_format_str, (unsigned long) ctx, 0);
 191   return safe_strdup (expanded);
 192 }
 193
 194 int mutt_check_mailbox_compressed (CONTEXT * ctx)
 195 {
 196   COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 197
 198   if (ci->size != get_size (ctx->realpath)) {
 199     FREE (&ctx->compressinfo);
 200     FREE (&ctx->realpath);
 201     mutt_error _("Mailbox was corrupted!");
 202
 203     return (-1);
 204   }
 205   return (0);
 206 }
 207
 208 int mutt_open_read_compressed (CONTEXT * ctx)
 209 {
 210   char *cmd;
 211   FILE *fp;
 212   int rc;
 213
 214   COMPRESS_INFO *ci = set_compress_info (ctx);
 215
 216   if (!ci->open) {
 217     ctx->magic = 0;
 218     FREE (ctx->compressinfo);
 219     return (-1);
 220   }
 221   if (!ci->close || access (ctx->path, W_OK) != 0)
 222     ctx->readonly = 1;
 223
 224   set_path (ctx);
 225   store_size (ctx);
 226
 227   if (!ctx->quiet)
 228     mutt_message (_("Decompressing %s..."), ctx->realpath);
 229
 230   cmd = get_compression_cmd (ci->open, ctx);
 231   if (cmd == NULL)
 232     return (-1);
 233   dprint (2, (debugfile, "DecompressCmd: '%s'\n", cmd));
 234
 235   if ((fp = fopen (ctx->realpath, "r")) == NULL) {
 236     mutt_perror (ctx->realpath);
 237     FREE (&cmd);
 238     return (-1);
 239   }
 240   mutt_block_signals ();
 241   if (mbox_lock_compressed (ctx, fp, 0, 1) == -1) {
 242     fclose (fp);
 243     mutt_unblock_signals ();
 244     mutt_error _("Unable to lock mailbox!");
 245
 246     FREE (&cmd);
 247     return (-1);
 248   }
 249
 250   endwin ();
 251   fflush (stdout);
 252   sprintf (echo_cmd, _("echo Decompressing %s..."), ctx->realpath);
 253   mutt_system (echo_cmd);
 254   rc = mutt_system (cmd);
 255   mbox_unlock_compressed (ctx, fp);
 256   mutt_unblock_signals ();
 257   fclose (fp);
 258
 259   if (rc) {
 260     mutt_any_key_to_continue (NULL);
 261     ctx->magic = 0;
 262     FREE (ctx->compressinfo);
 263     mutt_error (_("Error executing: %s : unable to open the mailbox!\n"),
 264                 cmd);
 265   }
 266   FREE (&cmd);
 267   if (rc)
 268     return (-1);
 269
 270   if (mutt_check_mailbox_compressed (ctx))
 271     return (-1);
 272
 273   ctx->magic = mx_get_magic (ctx->path);
 274
 275   return (0);
 276 }
 277
 278 void restore_path (CONTEXT * ctx)
 279 {
 280   FREE (&ctx->path);
 281   ctx->path = ctx->realpath;
 282 }
 283
 284 /* remove the temporary mailbox */
 285 void remove_file (CONTEXT * ctx)
 286 {
 287   if (ctx->magic == M_MBOX || ctx->magic == M_MMDF)
 288     remove (ctx->path);
 289 }
 290
 291 int mutt_open_append_compressed (CONTEXT * ctx)
 292 {
 293   FILE *fh;
 294   COMPRESS_INFO *ci = set_compress_info (ctx);
 295
 296   if (!get_append_command (ctx->path, ctx)) {
 297     if (ci->open && ci->close)
 298       return (mutt_open_read_compressed (ctx));
 299
 300     ctx->magic = 0;
 301     FREE (&ctx->compressinfo);
 302     return (-1);
 303   }
 304
 305   set_path (ctx);
 306
 307   ctx->magic = DefaultMagic;
 308
 309   if (!is_new (ctx->realpath))
 310     if (ctx->magic == M_MBOX || ctx->magic == M_MMDF)
 311       if ((fh = safe_fopen (ctx->path, "w")))
 312         fclose (fh);
 313   /* No error checking - the parent function will catch it */
 314
 315   return (0);
 316 }
 317
 318 /* close a compressed mailbox */
 319 void mutt_fast_close_compressed (CONTEXT * ctx)
 320 {
 321   dprint (2, (debugfile, "mutt_fast_close_compressed called on '%s'\n",
 322               ctx->path));
 323
 324   if (ctx->compressinfo) {
 325     if (ctx->fp)
 326       fclose (ctx->fp);
 327     ctx->fp = NULL;
 328     /* if the folder was removed, remove the gzipped folder too */
 329     if (access (ctx->path, F_OK) != 0 && !option (OPTSAVEEMPTY))
 330       remove (ctx->realpath);
 331     else
 332       remove_file (ctx);
 333
 334     restore_path (ctx);
 335     FREE (&ctx->compressinfo);
 336   }
 337 }
 338
 339 /* return 0 on success, -1 on failure */
 340 int mutt_sync_compressed (CONTEXT * ctx)
 341 {
 342   char *cmd;
 343   int rc = 0;
 344   FILE *fp;
 345   COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 346
 347   if (!ctx->quiet)
 348     mutt_message (_("Compressing %s..."), ctx->realpath);
 349
 350   cmd = get_compression_cmd (ci->close, ctx);
 351   if (cmd == NULL)
 352     return (-1);
 353
 354   if ((fp = fopen (ctx->realpath, "a")) == NULL) {
 355     mutt_perror (ctx->realpath);
 356     FREE (&cmd);
 357     return (-1);
 358   }
 359   mutt_block_signals ();
 360   if (mbox_lock_compressed (ctx, fp, 1, 1) == -1) {
 361     fclose (fp);
 362     mutt_unblock_signals ();
 363     mutt_error _("Unable to lock mailbox!");
 364
 365     store_size (ctx);
 366
 367     FREE (&cmd);
 368     return (-1);
 369   }
 370
 371   dprint (2, (debugfile, "CompressCommand: '%s'\n", cmd));
 372
 373   endwin ();
 374   fflush (stdout);
 375   sprintf (echo_cmd, _("echo Compressing %s..."), ctx->realpath);
 376   mutt_system (echo_cmd);
 377   if (mutt_system (cmd)) {
 378     mutt_any_key_to_continue (NULL);
 379     mutt_error (_
 380                 ("%s: Error compressing mailbox! Original mailbox deleted, uncompressed one kept!\n"),
 381                 ctx->path);
 382     rc = -1;
 383   }
 384
 385   mbox_unlock_compressed (ctx, fp);
 386   mutt_unblock_signals ();
 387   fclose (fp);
 388
 389   FREE (&cmd);
 390
 391   store_size (ctx);
 392
 393   return (rc);
 394 }
 395
 396 int mutt_slow_close_compressed (CONTEXT * ctx)
 397 {
 398   FILE *fp;
 399   const char *append;
 400   char *cmd;
 401   COMPRESS_INFO *ci = (COMPRESS_INFO *) ctx->compressinfo;
 402
 403   dprint (2, (debugfile, "mutt_slow_close_compressed called on '%s'\n",
 404               ctx->path));
 405
 406   if (!(ctx->append && ((append = get_append_command (ctx->realpath, ctx))
 407                         || (append = ci->close)))) {    /* if we can not or should not append,
 408                                                          * we only have to remove the compressed info, because sync was already
 409                                                          * called
 410                                                          */
 411     mutt_fast_close_compressed (ctx);
 412     return (0);
 413   }
 414
 415   if (ctx->fp)
 416     fclose (ctx->fp);
 417   ctx->fp = NULL;
 418
 419   if (!ctx->quiet) {
 420     if (append == ci->close)
 421       mutt_message (_("Compressing %s..."), ctx->realpath);
 422     else
 423       mutt_message (_("Compressed-appending to %s..."), ctx->realpath);
 424   }
 425
 426   cmd = get_compression_cmd (append, ctx);
 427   if (cmd == NULL)
 428     return (-1);
 429
 430   if ((fp = fopen (ctx->realpath, "a")) == NULL) {
 431     mutt_perror (ctx->realpath);
 432     FREE (&cmd);
 433     return (-1);
 434   }
 435   mutt_block_signals ();
 436   if (mbox_lock_compressed (ctx, fp, 1, 1) == -1) {
 437     fclose (fp);
 438     mutt_unblock_signals ();
 439     mutt_error _("Unable to lock mailbox!");
 440
 441     FREE (&cmd);
 442     return (-1);
 443   }
 444
 445   dprint (2, (debugfile, "CompressCmd: '%s'\n", cmd));
 446
 447   endwin ();
 448   fflush (stdout);
 449
 450   if (append == ci->close)
 451     sprintf (echo_cmd, _("echo Compressing %s..."), ctx->realpath);
 452   else
 453     sprintf (echo_cmd, _("echo Compressed-appending to %s..."),
 454              ctx->realpath);
 455   mutt_system (echo_cmd);
 456
 457   if (mutt_system (cmd)) {
 458     mutt_any_key_to_continue (NULL);
 459     mutt_error (_
 460                 (" %s: Error compressing mailbox!  Uncompressed one kept!\n"),
 461                 ctx->path);
 462     FREE (&cmd);
 463     mbox_unlock_compressed (ctx, fp);
 464     mutt_unblock_signals ();
 465     fclose (fp);
 466     return (-1);
 467   }
 468
 469   mbox_unlock_compressed (ctx, fp);
 470   mutt_unblock_signals ();
 471   fclose (fp);
 472   remove_file (ctx);
 473   restore_path (ctx);
 474   FREE (&cmd);
 475   FREE (&ctx->compressinfo);
 476
 477   return (0);
 478 }
 479
 480 #endif /* USE_COMPRESSED */