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