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