Move score_* to mod_score
[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/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)
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) || ctx->magic != M_MBOX)
300       unlink(tmppath);
301
302   /* No error checking - the parent function will catch it */
303   return 0;
304 }
305
306 /* close a compressed mailbox */
307 void mutt_fast_close_compressed (CONTEXT * ctx)
308 {
309   if (ctx->cinfo) {
310     m_fclose(&ctx->fp);
311
312     /* if the folder was removed, remove the gzipped folder too */
313     remove_file (ctx);
314     restore_path (ctx);
315     p_delete(&ctx->cinfo);
316   }
317 }
318
319 /* return 0 on success, -1 on failure */
320 int mutt_sync_compressed (CONTEXT * ctx)
321 {
322   char *cmd;
323   int rc = 0;
324   FILE *fp;
325
326   if (!ctx->quiet)
327     mutt_message (_("Compressing %s..."), ctx->realpath);
328
329   cmd = get_compression_cmd (ctx->cinfo->close, ctx);
330   if (cmd == NULL)
331     return -1;
332
333   if ((fp = fopen (ctx->realpath, "a")) == NULL) {
334     mutt_perror (ctx->realpath);
335     p_delete(&cmd);
336     return -1;
337   }
338   mutt_block_signals ();
339   if (mbox_lock_compressed (ctx, fp, 1, 1) == -1) {
340     m_fclose(&fp);
341     mutt_unblock_signals ();
342     mutt_error _("Unable to lock mailbox!");
343
344     ctx->cinfo->size = get_size(ctx->realpath);
345
346     p_delete(&cmd);
347     return -1;
348   }
349
350   endwin ();
351   fflush (stdout);
352   sprintf (echo_cmd, _("echo Compressing %s..."), ctx->realpath);
353   mutt_system (echo_cmd);
354   if (mutt_system (cmd)) {
355     mutt_any_key_to_continue (NULL);
356     mutt_error (_
357                 ("%s: Error compressing mailbox! Original mailbox deleted, uncompressed one kept!\n"),
358                 ctx->path);
359     rc = -1;
360   }
361
362   mbox_unlock_compressed (ctx, fp);
363   mutt_unblock_signals ();
364   m_fclose(&fp);
365
366   p_delete(&cmd);
367
368   ctx->cinfo->size = get_size(ctx->realpath);
369
370   return rc;
371 }
372
373 int mutt_slow_close_compressed (CONTEXT * ctx)
374 {
375   FILE *fp;
376   const char *append;
377   char *cmd;
378   compress_info *ci = ctx->cinfo;
379
380   if (!(ctx->append && ((append = get_append_command (ctx->realpath, ctx))
381                         || (append = ci->close)))) {
382       /* if we can not or should not append, we only have to remove the
383          compressed info, because sync was already called */
384     mutt_fast_close_compressed (ctx);
385     return 0;
386   }
387
388   m_fclose(&ctx->fp);
389
390   if (!ctx->quiet) {
391     if (append == ci->close)
392       mutt_message (_("Compressing %s..."), ctx->realpath);
393     else
394       mutt_message (_("Compressed-appending to %s..."), ctx->realpath);
395   }
396
397   cmd = get_compression_cmd (append, ctx);
398   if (cmd == NULL)
399     return -1;
400
401   if ((fp = fopen (ctx->realpath, "a")) == NULL) {
402     mutt_perror (ctx->realpath);
403     p_delete(&cmd);
404     return -1;
405   }
406   mutt_block_signals ();
407   if (mbox_lock_compressed (ctx, fp, 1, 1) == -1) {
408     m_fclose(&fp);
409     mutt_unblock_signals ();
410     mutt_error _("Unable to lock mailbox!");
411
412     p_delete(&cmd);
413     return -1;
414   }
415
416   endwin ();
417   fflush (stdout);
418
419   if (append == ci->close)
420     sprintf (echo_cmd, _("echo Compressing %s..."), ctx->realpath);
421   else
422     sprintf (echo_cmd, _("echo Compressed-appending to %s..."),
423              ctx->realpath);
424   mutt_system (echo_cmd);
425
426   if (mutt_system (cmd)) {
427     mutt_any_key_to_continue (NULL);
428     mutt_error (_(" %s: Error compressing mailbox!  Uncompressed one kept!\n"),
429                 ctx->path);
430     p_delete(&cmd);
431     mbox_unlock_compressed (ctx, fp);
432     mutt_unblock_signals ();
433     m_fclose(&fp);
434     return -1;
435   }
436
437   mbox_unlock_compressed (ctx, fp);
438   mutt_unblock_signals ();
439   m_fclose(&fp);
440   remove_file (ctx);
441   restore_path (ctx);
442   p_delete(&cmd);
443   p_delete(&ctx->cinfo);
444
445   return 0;
446 }
447
448 mx_t const compress_mx = {
449     M_COMPRESSED,
450     1,
451     mbox_is_magic,
452     mbox_check_empty,
453     access,
454     mutt_open_read_compressed,
455     NULL,
456     NULL,
457     NULL,
458     NULL,
459     NULL,
460     NULL,
461 };