gpg: Allow to cache the mbox in a user id struct.
[gnupg.git] / g10 / progress.c
1 /* progress.c - emit progress status lines
2  * Copyright (C) 2003, 2006 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22
23 #include "gpg.h"
24 #include "iobuf.h"
25 #include "filter.h"
26 #include "status.h"
27 #include "util.h"
28 #include "options.h"
29
30 /* Create a new context for use with the progress filter.  We need to
31    allocate such contexts on the heap because there is no guarantee
32    that at the end of a function the filter has already been popped
33    off.  In general this will happen but with malformed packets it is
34    possible that a filter has not yet reached the end-of-stream when
35    the function has done all processing.  Checking in each function
36    that end-of-stream has been reached would be to cumbersome.
37
38    What we also do is to shortcut the progress handler by having this
39    function return NULL if progress information has not been
40    requested.
41 */
42 progress_filter_context_t *
43 new_progress_context (void)
44 {
45   progress_filter_context_t *pfx;
46
47   if (!opt.enable_progress_filter)
48     return NULL;
49
50   if (!is_status_enabled ())
51     return NULL;
52
53   pfx = xcalloc (1, sizeof *pfx);
54   pfx->refcount = 1;
55
56   return pfx;
57 }
58
59 /* Release a progress filter context.  Passing NULL is explicitly
60    allowed and a no-op.  */
61 void
62 release_progress_context (progress_filter_context_t *pfx)
63 {
64   if (!pfx)
65     return;
66   log_assert (pfx->refcount);
67   if ( --pfx->refcount )
68     return;
69   xfree (pfx->what);
70   xfree (pfx);
71 }
72
73
74 static void
75 write_status_progress (const char *what,
76                        unsigned long current, unsigned long total)
77 {
78   char buffer[50];
79
80   /* Although we use an unsigned long for the values, 32 bit
81    * applications using GPGME will use an "int" and thus are limited
82    * in the total size which can be represented.  On Windows, where
83    * sizeof(int)==sizeof(long), this is even worse and will lead to an
84    * integer overflow for all files larger than 2 GiB.  Although, the
85    * allowed value range of TOTAL and CURRENT is nowhere specified, we
86    * better protect applications from the need to handle negative
87    * values.  The common usage pattern of the progress information is
88    * to display how many percent of the operation has been done and
89    * thus scaling CURRENT and TOTAL down before they get to large,
90    * should not have a noticeable effect except for rounding
91    * imprecision. */
92   if (total)
93     {
94       if (current > total)
95         current = total;
96
97       while (total > 1024*1024)
98         {
99           total /= 1024;
100           current /= 1024;
101         }
102     }
103   else
104     {
105       while (current > 1024*1024)
106         {
107           current /= 1024;
108         }
109     }
110
111   snprintf (buffer, sizeof buffer, "%.20s ? %lu %lu",
112             what? what : "?", current, total);
113   write_status_text (STATUS_PROGRESS, buffer);
114 }
115
116
117 /****************
118  * The filter is used to report progress to the user.
119  */
120 static int
121 progress_filter (void *opaque, int control,
122                  IOBUF a, byte *buf, size_t *ret_len)
123 {
124   int rc = 0;
125   progress_filter_context_t *pfx = opaque;
126
127   if (control == IOBUFCTRL_INIT)
128     {
129       pfx->last = 0;
130       pfx->offset = 0;
131       pfx->last_time = make_timestamp ();
132
133       write_status_progress (pfx->what, pfx->offset, pfx->total);
134     }
135   else if (control == IOBUFCTRL_UNDERFLOW)
136     {
137       u32 timestamp = make_timestamp ();
138       int len = iobuf_read (a, buf, *ret_len);
139
140       if (len >= 0)
141         {
142           pfx->offset += len;
143           *ret_len = len;
144         }
145       else
146         {
147           *ret_len = 0;
148           rc = -1;
149         }
150       if ((len == -1 && pfx->offset != pfx->last)
151           || timestamp - pfx->last_time > 0)
152         {
153           write_status_progress (pfx->what, pfx->offset, pfx->total);
154           pfx->last = pfx->offset;
155           pfx->last_time = timestamp;
156         }
157     }
158   else if (control == IOBUFCTRL_FREE)
159     {
160       release_progress_context (pfx);
161     }
162   else if (control == IOBUFCTRL_DESC)
163     mem2str (buf, "progress_filter", *ret_len);
164   return rc;
165 }
166
167 void
168 handle_progress (progress_filter_context_t *pfx, IOBUF inp, const char *name)
169 {
170   off_t filesize = 0;
171
172   if (!pfx)
173     return;
174
175   log_assert (opt.enable_progress_filter);
176   log_assert (is_status_enabled ());
177
178   if ( !iobuf_is_pipe_filename (name) && *name )
179     filesize = iobuf_get_filelength (inp, NULL);
180   else if (opt.set_filesize)
181     filesize = opt.set_filesize;
182
183   /* register the progress filter */
184   pfx->what = xstrdup (name ? name : "stdin");
185   pfx->total = filesize;
186   pfx->refcount++;
187   iobuf_push_filter (inp, progress_filter, pfx);
188 }