safe_fclose -> m_fclose, and is now inlined.
[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) != 0 && errno == ENOENT) ? 1 : 0;
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 void set_path (CONTEXT * ctx)
117 {
118   char tmppath[_POSIX_PATH_MAX];
119
120   /* Setup the right paths */
121   ctx->realpath = ctx->path;
122
123   /* Uncompress to /tmp */
124   mutt_mktemp (tmppath);
125   ctx->path = p_dupstr(tmppath, m_strlen(tmppath));
126 }
127
128 static int get_size (const char *path)
129 {
130   struct stat sb;
131
132   if (stat (path, &sb) != 0)
133     return 0;
134   return (sb.st_size);
135 }
136
137 static const char *compresshook_format_str (char *dest, ssize_t destlen,
138                                             char op, const char *src,
139                                             const char *fmt,
140                                             const char *ifstring __attribute__ ((unused)),
141                                             const char *elsestring __attribute__ ((unused)),
142                                             unsigned long data,
143                                             format_flag flags __attribute__ ((unused)))
144 {
145   char tmp[SHORT_STRING];
146
147   CONTEXT *ctx = (CONTEXT *) data;
148
149   switch (op) {
150   case 'f':
151     snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
152     snprintf (dest, destlen, tmp, ctx->realpath);
153     break;
154   case 't':
155     snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
156     snprintf (dest, destlen, tmp, ctx->path);
157     break;
158   }
159   return (src);
160 }
161
162 /* check that the command has both %f and %t
163  * 0 means OK, -1 means error
164  */
165 int mutt_test_compress_command (const char *cmd)
166 {
167   return (strstr (cmd, "%f") && strstr (cmd, "%t")) ? 0 : -1;
168 }
169
170 static char *get_compression_cmd (const char *cmd, const CONTEXT * ctx)
171 {
172   char expanded[_POSIX_PATH_MAX];
173
174   mutt_FormatString (expanded, sizeof (expanded), cmd,
175                      compresshook_format_str, (unsigned long) ctx, 0);
176   return m_strdup(expanded);
177 }
178
179 int mutt_check_mailbox_compressed (CONTEXT * ctx)
180 {
181   if (ctx->cinfo->size != get_size (ctx->realpath)) {
182     p_delete(&ctx->cinfo);
183     p_delete(&ctx->realpath);
184     mutt_error _("Mailbox was corrupted!");
185
186     return (-1);
187   }
188   return (0);
189 }
190
191 int mutt_open_read_compressed (CONTEXT * ctx)
192 {
193   char *cmd;
194   FILE *fp;
195   int rc;
196
197   compress_info *ci = set_compress_info (ctx);
198
199   if (!ci->open) {
200     ctx->magic = 0;
201     p_delete(&ctx->cinfo);
202     return (-1);
203   }
204   if (!ci->close || access (ctx->path, W_OK) != 0)
205     ctx->readonly = 1;
206
207   set_path (ctx);
208   ctx->cinfo->size = get_size(ctx->realpath);
209
210   if (!ctx->quiet)
211     mutt_message (_("Decompressing %s..."), ctx->realpath);
212
213   cmd = get_compression_cmd (ci->open, ctx);
214   if (cmd == NULL)
215     return (-1);
216
217   if ((fp = fopen (ctx->realpath, "r")) == NULL) {
218     mutt_perror (ctx->realpath);
219     p_delete(&cmd);
220     return (-1);
221   }
222   mutt_block_signals ();
223   if (mbox_lock_compressed (ctx, fp, 0, 1) == -1) {
224     fclose (fp);
225     mutt_unblock_signals ();
226     mutt_error _("Unable to lock mailbox!");
227
228     p_delete(&cmd);
229     return (-1);
230   }
231
232   endwin ();
233   fflush (stdout);
234   sprintf (echo_cmd, _("echo Decompressing %s..."), ctx->realpath);
235   mutt_system (echo_cmd);
236   rc = mutt_system (cmd);
237   mbox_unlock_compressed (ctx, fp);
238   mutt_unblock_signals ();
239   fclose (fp);
240
241   if (rc) {
242     mutt_any_key_to_continue (NULL);
243     ctx->magic = 0;
244     p_delete(&ctx->cinfo);
245     mutt_error(_("Error executing: %s : unable to open the mailbox!\n"), cmd);
246   }
247   p_delete(&cmd);
248   if (rc)
249     return (-1);
250
251   if (mutt_check_mailbox_compressed (ctx))
252     return (-1);
253
254   ctx->magic = mx_get_magic (ctx->path);
255
256   return (0);
257 }
258
259 static void restore_path (CONTEXT * ctx)
260 {
261   p_delete(&ctx->path);
262   ctx->path = ctx->realpath;
263 }
264
265 /* remove the temporary mailbox */
266 static void remove_file (CONTEXT * ctx)
267 {
268   if (ctx->magic == M_MBOX || ctx->magic == M_MMDF)
269     remove (ctx->path);
270 }
271
272 int mutt_open_append_compressed (CONTEXT * ctx)
273 {
274   FILE *fh;
275   compress_info *ci = set_compress_info (ctx);
276
277   if (!get_append_command (ctx->path, ctx)) {
278     if (ci->open && ci->close)
279       return (mutt_open_read_compressed (ctx));
280
281     ctx->magic = 0;
282     p_delete(&ctx->cinfo);
283     return (-1);
284   }
285
286   set_path (ctx);
287
288   ctx->magic = DefaultMagic;
289
290   if (!is_new (ctx->realpath))
291     if (ctx->magic == M_MBOX || ctx->magic == M_MMDF)
292       if ((fh = safe_fopen (ctx->path, "w")))
293         fclose (fh);
294   /* No error checking - the parent function will catch it */
295
296   return (0);
297 }
298
299 /* close a compressed mailbox */
300 void mutt_fast_close_compressed (CONTEXT * ctx)
301 {
302   if (ctx->cinfo) {
303     if (ctx->fp)
304       fclose (ctx->fp);
305     ctx->fp = NULL;
306     /* if the folder was removed, remove the gzipped folder too */
307     if (access (ctx->path, F_OK) != 0 && !option (OPTSAVEEMPTY))
308       remove (ctx->realpath);
309     else
310       remove_file (ctx);
311
312     restore_path (ctx);
313     p_delete(&ctx->cinfo);
314   }
315 }
316
317 /* return 0 on success, -1 on failure */
318 int mutt_sync_compressed (CONTEXT * ctx)
319 {
320   char *cmd;
321   int rc = 0;
322   FILE *fp;
323
324   if (!ctx->quiet)
325     mutt_message (_("Compressing %s..."), ctx->realpath);
326
327   cmd = get_compression_cmd (ctx->cinfo->close, ctx);
328   if (cmd == NULL)
329     return (-1);
330
331   if ((fp = fopen (ctx->realpath, "a")) == NULL) {
332     mutt_perror (ctx->realpath);
333     p_delete(&cmd);
334     return (-1);
335   }
336   mutt_block_signals ();
337   if (mbox_lock_compressed (ctx, fp, 1, 1) == -1) {
338     fclose (fp);
339     mutt_unblock_signals ();
340     mutt_error _("Unable to lock mailbox!");
341
342     ctx->cinfo->size = get_size(ctx->realpath);
343
344     p_delete(&cmd);
345     return (-1);
346   }
347
348   endwin ();
349   fflush (stdout);
350   sprintf (echo_cmd, _("echo Compressing %s..."), ctx->realpath);
351   mutt_system (echo_cmd);
352   if (mutt_system (cmd)) {
353     mutt_any_key_to_continue (NULL);
354     mutt_error (_
355                 ("%s: Error compressing mailbox! Original mailbox deleted, uncompressed one kept!\n"),
356                 ctx->path);
357     rc = -1;
358   }
359
360   mbox_unlock_compressed (ctx, fp);
361   mutt_unblock_signals ();
362   fclose (fp);
363
364   p_delete(&cmd);
365
366   ctx->cinfo->size = get_size(ctx->realpath);
367
368   return (rc);
369 }
370
371 int mutt_slow_close_compressed (CONTEXT * ctx)
372 {
373   FILE *fp;
374   const char *append;
375   char *cmd;
376   compress_info *ci = ctx->cinfo;
377
378   if (!(ctx->append && ((append = get_append_command (ctx->realpath, ctx))
379                         || (append = ci->close)))) {
380       /* if we can not or should not append, we only have to remove the
381          compressed info, because sync was already called */
382     mutt_fast_close_compressed (ctx);
383     return (0);
384   }
385
386   if (ctx->fp)
387     fclose (ctx->fp);
388   ctx->fp = NULL;
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     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     fclose (fp);
434     return (-1);
435   }
436
437   mbox_unlock_compressed (ctx, fp);
438   mutt_unblock_signals ();
439   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 };