gpg: New maintainer option --debug-set-iobuf-size.
[gnupg.git] / common / iobuf.c
1 /* iobuf.c  -  File Handling for OpenPGP.
2  * Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2006, 2007, 2008,
3  *               2009, 2010, 2011  Free Software Foundation, Inc.
4  * Copyright (C) 2015  g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * This file is free software; you can redistribute it and/or modify
9  * it under the terms of either
10  *
11  *   - the GNU Lesser General Public License as published by the Free
12  *     Software Foundation; either version 3 of the License, or (at
13  *     your option) any later version.
14  *
15  * or
16  *
17  *   - the GNU General Public License as published by the Free
18  *     Software Foundation; either version 2 of the License, or (at
19  *     your option) any later version.
20  *
21  * or both in parallel, as here.
22  *
23  * This file is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  * GNU General Public License for more details.
27  *
28  * You should have received a copy of the GNU General Public License
29  * along with this program; if not, see <https://www.gnu.org/licenses/>.
30  */
31
32 #include <config.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <errno.h>
37 #include <ctype.h>
38 #include <assert.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <fcntl.h>
42 #include <unistd.h>
43 #ifdef HAVE_W32_SYSTEM
44 # ifdef HAVE_WINSOCK2_H
45 #  include <winsock2.h>
46 # endif
47 # include <windows.h>
48 #endif
49 #ifdef __riscos__
50 # include <kernel.h>
51 # include <swis.h>
52 #endif /* __riscos__ */
53
54 #include <assuan.h>
55
56 #include "util.h"
57 #include "sysutils.h"
58 #include "iobuf.h"
59
60 /*-- Begin configurable part.  --*/
61
62 /* The standard size of the internal buffers.  */
63 #define DEFAULT_IOBUF_BUFFER_SIZE  (64*1024)
64
65 /* To avoid a potential DoS with compression packets we better limit
66    the number of filters in a chain.  */
67 #define MAX_NESTING_FILTER 64
68
69 /*-- End configurable part.  --*/
70
71 /* The size of the iobuffers.  This can be chnages using the
72  * iobuf_set_buffer_size fucntion.  */
73 static unsigned int iobuf_buffer_size = DEFAULT_IOBUF_BUFFER_SIZE;
74
75
76 #ifdef HAVE_W32_SYSTEM
77 # ifdef HAVE_W32CE_SYSTEM
78 #  define FD_FOR_STDIN  (es_fileno (es_stdin))
79 #  define FD_FOR_STDOUT (es_fileno (es_stdout))
80 # else
81 #  define FD_FOR_STDIN  (GetStdHandle (STD_INPUT_HANDLE))
82 #  define FD_FOR_STDOUT (GetStdHandle (STD_OUTPUT_HANDLE))
83 # endif
84 #else /*!HAVE_W32_SYSTEM*/
85 # define FD_FOR_STDIN  (0)
86 # define FD_FOR_STDOUT (1)
87 #endif /*!HAVE_W32_SYSTEM*/
88
89
90 /* The context used by the file filter.  */
91 typedef struct
92 {
93   gnupg_fd_t fp;       /* Open file pointer or handle.  */
94   int keep_open;
95   int no_cache;
96   int eof_seen;
97   int delayed_rc;
98   int print_only_name; /* Flags indicating that fname is not a real file.  */
99   char fname[1];       /* Name of the file.  */
100 } file_filter_ctx_t;
101
102 /* The context used by the estream filter.  */
103 typedef struct
104 {
105   estream_t fp;        /* Open estream handle.  */
106   int keep_open;
107   int no_cache;
108   int eof_seen;
109   int print_only_name; /* Flags indicating that fname is not a real file.  */
110   char fname[1];       /* Name of the file.  */
111 } file_es_filter_ctx_t;
112
113
114 /* Object to control the "close cache".  */
115 struct close_cache_s
116 {
117   struct close_cache_s *next;
118   gnupg_fd_t fp;
119   char fname[1];
120 };
121 typedef struct close_cache_s *close_cache_t;
122 static close_cache_t close_cache;
123
124
125
126 #ifdef HAVE_W32_SYSTEM
127 typedef struct
128 {
129   int sock;
130   int keep_open;
131   int no_cache;
132   int eof_seen;
133   int print_only_name;  /* Flag indicating that fname is not a real file.  */
134   char fname[1];        /* Name of the file */
135
136 } sock_filter_ctx_t;
137 #endif /*HAVE_W32_SYSTEM*/
138
139 /* The first partial length header block must be of size 512 to make
140  * it easier (and more efficient) we use a min. block size of 512 for
141  * all chunks (but the last one) */
142 #define OP_MIN_PARTIAL_CHUNK      512
143 #define OP_MIN_PARTIAL_CHUNK_2POW 9
144
145 /* The context we use for the block filter (used to handle OpenPGP
146    length information header).  */
147 typedef struct
148 {
149   int use;
150   size_t size;
151   size_t count;
152   int partial;     /* 1 = partial header, 2 in last partial packet.  */
153   char *buffer;    /* Used for partial header.  */
154   size_t buflen;   /* Used size of buffer.  */
155   int first_c;     /* First character of a partial header (which is > 0).  */
156   int eof;
157 }
158 block_filter_ctx_t;
159
160
161 /* Local prototypes.  */
162 static int underflow (iobuf_t a, int clear_pending_eof);
163 static int underflow_target (iobuf_t a, int clear_pending_eof, size_t target);
164 static int translate_file_handle (int fd, int for_write);
165
166 /* Sends any pending data to the filter's FILTER function.  Note: this
167    works on the filter and not on the whole pipeline.  That is,
168    iobuf_flush doesn't necessarily cause data to be written to any
169    underlying file; it just causes any data buffered at the filter A
170    to be sent to A's filter function.
171
172    If A is a IOBUF_OUTPUT_TEMP filter, then this also enlarges the
173    buffer by iobuf_buffer_size.
174
175    May only be called on an IOBUF_OUTPUT or IOBUF_OUTPUT_TEMP filters.  */
176 static int filter_flush (iobuf_t a);
177
178
179 \f
180 /* This is a replacement for strcmp.  Under W32 it does not
181    distinguish between backslash and slash.  */
182 static int
183 fd_cache_strcmp (const char *a, const char *b)
184 {
185 #ifdef HAVE_DOSISH_SYSTEM
186   for (; *a && *b; a++, b++)
187     {
188       if (*a != *b && !((*a == '/' && *b == '\\')
189                         || (*a == '\\' && *b == '/')) )
190         break;
191     }
192   return *(const unsigned char *)a - *(const unsigned char *)b;
193 #else
194   return strcmp (a, b);
195 #endif
196 }
197
198 /*
199  * Invalidate (i.e. close) a cached iobuf
200  */
201 static int
202 fd_cache_invalidate (const char *fname)
203 {
204   close_cache_t cc;
205   int rc = 0;
206
207   assert (fname);
208   if (DBG_IOBUF)
209     log_debug ("fd_cache_invalidate (%s)\n", fname);
210
211   for (cc = close_cache; cc; cc = cc->next)
212     {
213       if (cc->fp != GNUPG_INVALID_FD && !fd_cache_strcmp (cc->fname, fname))
214         {
215           if (DBG_IOBUF)
216             log_debug ("                did (%s)\n", cc->fname);
217 #ifdef HAVE_W32_SYSTEM
218           if (!CloseHandle (cc->fp))
219             rc = -1;
220 #else
221           rc = close (cc->fp);
222 #endif
223           cc->fp = GNUPG_INVALID_FD;
224         }
225     }
226   return rc;
227 }
228
229
230 /* Try to sync changes to the disk.  This is to avoid data loss during
231    a system crash in write/close/rename cycle on some file
232    systems.  */
233 static int
234 fd_cache_synchronize (const char *fname)
235 {
236   int err = 0;
237
238 #ifdef HAVE_FSYNC
239   close_cache_t cc;
240
241   if (DBG_IOBUF)
242     log_debug ("fd_cache_synchronize (%s)\n", fname);
243
244   for (cc=close_cache; cc; cc = cc->next )
245     {
246       if (cc->fp != GNUPG_INVALID_FD && !fd_cache_strcmp (cc->fname, fname))
247         {
248           if (DBG_IOBUF)
249             log_debug ("                 did (%s)\n", cc->fname);
250
251           err = fsync (cc->fp);
252         }
253     }
254 #else
255   (void)fname;
256 #endif /*HAVE_FSYNC*/
257
258   return err;
259 }
260
261
262 static gnupg_fd_t
263 direct_open (const char *fname, const char *mode, int mode700)
264 {
265 #ifdef HAVE_W32_SYSTEM
266   unsigned long da, cd, sm;
267   HANDLE hfile;
268
269   (void)mode700;
270   /* Note, that we do not handle all mode combinations */
271
272   /* According to the ReactOS source it seems that open() of the
273    * standard MSW32 crt does open the file in shared mode which is
274    * something new for MS applications ;-)
275    */
276   if (strchr (mode, '+'))
277     {
278       if (fd_cache_invalidate (fname))
279         return GNUPG_INVALID_FD;
280       da = GENERIC_READ | GENERIC_WRITE;
281       cd = OPEN_EXISTING;
282       sm = FILE_SHARE_READ | FILE_SHARE_WRITE;
283     }
284   else if (strchr (mode, 'w'))
285     {
286       if (fd_cache_invalidate (fname))
287         return GNUPG_INVALID_FD;
288       da = GENERIC_WRITE;
289       cd = CREATE_ALWAYS;
290       sm = FILE_SHARE_WRITE;
291     }
292   else
293     {
294       da = GENERIC_READ;
295       cd = OPEN_EXISTING;
296       sm = FILE_SHARE_READ;
297     }
298
299 #ifdef HAVE_W32CE_SYSTEM
300   {
301     wchar_t *wfname = utf8_to_wchar (fname);
302     if (wfname)
303       {
304         hfile = CreateFile (wfname, da, sm, NULL, cd,
305                             FILE_ATTRIBUTE_NORMAL, NULL);
306         xfree (wfname);
307       }
308     else
309       hfile = INVALID_HANDLE_VALUE;
310   }
311 #else
312   hfile = CreateFile (fname, da, sm, NULL, cd, FILE_ATTRIBUTE_NORMAL, NULL);
313 #endif
314   return hfile;
315
316 #else /*!HAVE_W32_SYSTEM*/
317
318   int oflag;
319   int cflag = S_IRUSR | S_IWUSR;
320
321   if (!mode700)
322     cflag |= S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
323
324   /* Note, that we do not handle all mode combinations */
325   if (strchr (mode, '+'))
326     {
327       if (fd_cache_invalidate (fname))
328         return GNUPG_INVALID_FD;
329       oflag = O_RDWR;
330     }
331   else if (strchr (mode, 'w'))
332     {
333       if (fd_cache_invalidate (fname))
334         return GNUPG_INVALID_FD;
335       oflag = O_WRONLY | O_CREAT | O_TRUNC;
336     }
337   else
338     {
339       oflag = O_RDONLY;
340     }
341 #ifdef O_BINARY
342   if (strchr (mode, 'b'))
343     oflag |= O_BINARY;
344 #endif
345
346 #ifdef __riscos__
347   {
348     struct stat buf;
349
350     /* Don't allow iobufs on directories */
351     if (!stat (fname, &buf) && S_ISDIR (buf.st_mode) && !S_ISREG (buf.st_mode))
352       return __set_errno (EISDIR);
353   }
354 #endif
355   return open (fname, oflag, cflag);
356
357 #endif /*!HAVE_W32_SYSTEM*/
358 }
359
360
361 /*
362  * Instead of closing an FD we keep it open and cache it for later reuse
363  * Note that this caching strategy only works if the process does not chdir.
364  */
365 static void
366 fd_cache_close (const char *fname, gnupg_fd_t fp)
367 {
368   close_cache_t cc;
369
370   assert (fp);
371   if (!fname || !*fname)
372     {
373 #ifdef HAVE_W32_SYSTEM
374       CloseHandle (fp);
375 #else
376       close (fp);
377 #endif
378       if (DBG_IOBUF)
379         log_debug ("fd_cache_close (%d) real\n", (int)fp);
380       return;
381     }
382   /* try to reuse a slot */
383   for (cc = close_cache; cc; cc = cc->next)
384     {
385       if (cc->fp == GNUPG_INVALID_FD && !fd_cache_strcmp (cc->fname, fname))
386         {
387           cc->fp = fp;
388           if (DBG_IOBUF)
389             log_debug ("fd_cache_close (%s) used existing slot\n", fname);
390           return;
391         }
392     }
393   /* add a new one */
394   if (DBG_IOBUF)
395     log_debug ("fd_cache_close (%s) new slot created\n", fname);
396   cc = xcalloc (1, sizeof *cc + strlen (fname));
397   strcpy (cc->fname, fname);
398   cc->fp = fp;
399   cc->next = close_cache;
400   close_cache = cc;
401 }
402
403 /*
404  * Do a direct_open on FNAME but first try to reuse one from the fd_cache
405  */
406 static gnupg_fd_t
407 fd_cache_open (const char *fname, const char *mode)
408 {
409   close_cache_t cc;
410
411   assert (fname);
412   for (cc = close_cache; cc; cc = cc->next)
413     {
414       if (cc->fp != GNUPG_INVALID_FD && !fd_cache_strcmp (cc->fname, fname))
415         {
416           gnupg_fd_t fp = cc->fp;
417           cc->fp = GNUPG_INVALID_FD;
418           if (DBG_IOBUF)
419             log_debug ("fd_cache_open (%s) using cached fp\n", fname);
420 #ifdef HAVE_W32_SYSTEM
421           if (SetFilePointer (fp, 0, NULL, FILE_BEGIN) == 0xffffffff)
422             {
423               log_error ("rewind file failed on handle %p: ec=%d\n",
424                          fp, (int) GetLastError ());
425               fp = GNUPG_INVALID_FD;
426             }
427 #else
428           if (lseek (fp, 0, SEEK_SET) == (off_t) - 1)
429             {
430               log_error ("can't rewind fd %d: %s\n", fp, strerror (errno));
431               fp = GNUPG_INVALID_FD;
432             }
433 #endif
434           return fp;
435         }
436     }
437   if (DBG_IOBUF)
438     log_debug ("fd_cache_open (%s) not cached\n", fname);
439   return direct_open (fname, mode, 0);
440 }
441
442
443 static int
444 file_filter (void *opaque, int control, iobuf_t chain, byte * buf,
445              size_t * ret_len)
446 {
447   file_filter_ctx_t *a = opaque;
448   gnupg_fd_t f = a->fp;
449   size_t size = *ret_len;
450   size_t nbytes = 0;
451   int rc = 0;
452
453   (void)chain; /* Not used.  */
454
455   if (control == IOBUFCTRL_UNDERFLOW)
456     {
457       log_assert (size); /* We need a buffer.  */
458       if (a->eof_seen)
459         {
460           rc = -1;
461           *ret_len = 0;
462         }
463       else if (a->delayed_rc)
464         {
465           rc = a->delayed_rc;
466           a->delayed_rc = 0;
467           if (rc == -1)
468             a->eof_seen = -1;
469           *ret_len = 0;
470         }
471       else
472         {
473 #ifdef HAVE_W32_SYSTEM
474           unsigned long nread;
475
476           nbytes = 0;
477           if (!ReadFile (f, buf, size, &nread, NULL))
478             {
479               int ec = (int) GetLastError ();
480               if (ec != ERROR_BROKEN_PIPE)
481                 {
482                   rc = gpg_error_from_errno (ec);
483                   log_error ("%s: read error: ec=%d\n", a->fname, ec);
484                 }
485             }
486           else if (!nread)
487             {
488               a->eof_seen = 1;
489               rc = -1;
490             }
491           else
492             {
493               nbytes = nread;
494             }
495
496 #else
497
498           int n;
499
500           nbytes = 0;
501         read_more:
502           do
503             {
504               n = read (f, buf + nbytes, size - nbytes);
505             }
506           while (n == -1 && errno == EINTR);
507           if (n > 0)
508             {
509               nbytes += n;
510               if (nbytes < size)
511                 goto read_more;
512             }
513           else if (!n) /* eof */
514             {
515               if (nbytes)
516                 a->delayed_rc = -1;
517               else
518                 {
519                   a->eof_seen = 1;
520                   rc = -1;
521                 }
522             }
523           else /* error */
524             {
525               rc = gpg_error_from_syserror ();
526               if (gpg_err_code (rc) != GPG_ERR_EPIPE)
527                 log_error ("%s: read error: %s\n", a->fname, gpg_strerror (rc));
528               if (nbytes)
529                 {
530                   a->delayed_rc = rc;
531                   rc = 0;
532                 }
533             }
534 #endif
535           *ret_len = nbytes;
536         }
537     }
538   else if (control == IOBUFCTRL_FLUSH)
539     {
540       if (size)
541         {
542 #ifdef HAVE_W32_SYSTEM
543           byte *p = buf;
544           unsigned long n;
545
546           nbytes = size;
547           do
548             {
549               if (size && !WriteFile (f, p, nbytes, &n, NULL))
550                 {
551                   int ec = (int) GetLastError ();
552                   rc = gpg_error_from_errno (ec);
553                   log_error ("%s: write error: ec=%d\n", a->fname, ec);
554                   break;
555                 }
556               p += n;
557               nbytes -= n;
558             }
559           while (nbytes);
560           nbytes = p - buf;
561 #else
562           byte *p = buf;
563           int n;
564
565           nbytes = size;
566           do
567             {
568               do
569                 {
570                   n = write (f, p, nbytes);
571                 }
572               while (n == -1 && errno == EINTR);
573               if (n > 0)
574                 {
575                   p += n;
576                   nbytes -= n;
577                 }
578             }
579           while (n != -1 && nbytes);
580           if (n == -1)
581             {
582               rc = gpg_error_from_syserror ();
583               log_error ("%s: write error: %s\n", a->fname, strerror (errno));
584             }
585           nbytes = p - buf;
586 #endif
587         }
588       *ret_len = nbytes;
589     }
590   else if (control == IOBUFCTRL_INIT)
591     {
592       a->eof_seen = 0;
593       a->delayed_rc = 0;
594       a->keep_open = 0;
595       a->no_cache = 0;
596     }
597   else if (control == IOBUFCTRL_DESC)
598     {
599       mem2str (buf, "file_filter(fd)", *ret_len);
600     }
601   else if (control == IOBUFCTRL_FREE)
602     {
603       if (f != FD_FOR_STDIN && f != FD_FOR_STDOUT)
604         {
605           if (DBG_IOBUF)
606             log_debug ("%s: close fd/handle %d\n", a->fname, FD2INT (f));
607           if (!a->keep_open)
608             fd_cache_close (a->no_cache ? NULL : a->fname, f);
609         }
610       xfree (a); /* We can free our context now. */
611     }
612
613   return rc;
614 }
615
616
617 /* Similar to file_filter but using the estream system.  */
618 static int
619 file_es_filter (void *opaque, int control, iobuf_t chain, byte * buf,
620                 size_t * ret_len)
621 {
622   file_es_filter_ctx_t *a = opaque;
623   estream_t f = a->fp;
624   size_t size = *ret_len;
625   size_t nbytes = 0;
626   int rc = 0;
627
628   (void)chain; /* Not used.  */
629
630   if (control == IOBUFCTRL_UNDERFLOW)
631     {
632       assert (size); /* We need a buffer.  */
633       if (a->eof_seen)
634         {
635           rc = -1;
636           *ret_len = 0;
637         }
638       else
639         {
640           nbytes = 0;
641           rc = es_read (f, buf, size, &nbytes);
642           if (rc == -1)
643             {                   /* error */
644               rc = gpg_error_from_syserror ();
645               log_error ("%s: read error: %s\n", a->fname, strerror (errno));
646             }
647           else if (!nbytes)
648             {                   /* eof */
649               a->eof_seen = 1;
650               rc = -1;
651             }
652           *ret_len = nbytes;
653         }
654     }
655   else if (control == IOBUFCTRL_FLUSH)
656     {
657       if (size)
658         {
659           byte *p = buf;
660           size_t nwritten;
661
662           nbytes = size;
663           do
664             {
665               nwritten = 0;
666               if (es_write (f, p, nbytes, &nwritten))
667                 {
668                   rc = gpg_error_from_syserror ();
669                   log_error ("%s: write error: %s\n",
670                              a->fname, strerror (errno));
671                   break;
672                 }
673               p += nwritten;
674               nbytes -= nwritten;
675             }
676           while (nbytes);
677           nbytes = p - buf;
678         }
679       *ret_len = nbytes;
680     }
681   else if (control == IOBUFCTRL_INIT)
682     {
683       a->eof_seen = 0;
684       a->no_cache = 0;
685     }
686   else if (control == IOBUFCTRL_DESC)
687     {
688       mem2str (buf, "estream_filter", *ret_len);
689     }
690   else if (control == IOBUFCTRL_FREE)
691     {
692       if (f != es_stdin && f != es_stdout)
693         {
694           if (DBG_IOBUF)
695             log_debug ("%s: es_fclose %p\n", a->fname, f);
696           if (!a->keep_open)
697             es_fclose (f);
698         }
699       f = NULL;
700       xfree (a); /* We can free our context now. */
701     }
702
703   return rc;
704 }
705
706
707 #ifdef HAVE_W32_SYSTEM
708 /* Because network sockets are special objects under Lose32 we have to
709    use a dedicated filter for them. */
710 static int
711 sock_filter (void *opaque, int control, iobuf_t chain, byte * buf,
712              size_t * ret_len)
713 {
714   sock_filter_ctx_t *a = opaque;
715   size_t size = *ret_len;
716   size_t nbytes = 0;
717   int rc = 0;
718
719   (void)chain;
720
721   if (control == IOBUFCTRL_UNDERFLOW)
722     {
723       assert (size);            /* need a buffer */
724       if (a->eof_seen)
725         {
726           rc = -1;
727           *ret_len = 0;
728         }
729       else
730         {
731           int nread;
732
733           nread = recv (a->sock, buf, size, 0);
734           if (nread == SOCKET_ERROR)
735             {
736               int ec = (int) WSAGetLastError ();
737               rc = gpg_error_from_errno (ec);
738               log_error ("socket read error: ec=%d\n", ec);
739             }
740           else if (!nread)
741             {
742               a->eof_seen = 1;
743               rc = -1;
744             }
745           else
746             {
747               nbytes = nread;
748             }
749           *ret_len = nbytes;
750         }
751     }
752   else if (control == IOBUFCTRL_FLUSH)
753     {
754       if (size)
755         {
756           byte *p = buf;
757           int n;
758
759           nbytes = size;
760           do
761             {
762               n = send (a->sock, p, nbytes, 0);
763               if (n == SOCKET_ERROR)
764                 {
765                   int ec = (int) WSAGetLastError ();
766                   rc = gpg_error_from_errno (ec);
767                   log_error ("socket write error: ec=%d\n", ec);
768                   break;
769                 }
770               p += n;
771               nbytes -= n;
772             }
773           while (nbytes);
774           nbytes = p - buf;
775         }
776       *ret_len = nbytes;
777     }
778   else if (control == IOBUFCTRL_INIT)
779     {
780       a->eof_seen = 0;
781       a->keep_open = 0;
782       a->no_cache = 0;
783     }
784   else if (control == IOBUFCTRL_DESC)
785     {
786       mem2str (buf, "sock_filter", *ret_len);
787     }
788   else if (control == IOBUFCTRL_FREE)
789     {
790       if (!a->keep_open)
791         closesocket (a->sock);
792       xfree (a);                /* we can free our context now */
793     }
794   return rc;
795 }
796 #endif /*HAVE_W32_SYSTEM*/
797
798 /****************
799  * This is used to implement the block write mode.
800  * Block reading is done on a byte by byte basis in readbyte(),
801  * without a filter
802  */
803 static int
804 block_filter (void *opaque, int control, iobuf_t chain, byte * buffer,
805               size_t * ret_len)
806 {
807   block_filter_ctx_t *a = opaque;
808   char *buf = (char *)buffer;
809   size_t size = *ret_len;
810   int c, needed, rc = 0;
811   char *p;
812
813   if (control == IOBUFCTRL_UNDERFLOW)
814     {
815       size_t n = 0;
816
817       p = buf;
818       assert (size);            /* need a buffer */
819       if (a->eof)               /* don't read any further */
820         rc = -1;
821       while (!rc && size)
822         {
823           if (!a->size)
824             {                   /* get the length bytes */
825               if (a->partial == 2)
826                 {
827                   a->eof = 1;
828                   if (!n)
829                     rc = -1;
830                   break;
831                 }
832               else if (a->partial)
833                 {
834                   /* These OpenPGP introduced huffman like encoded length
835                    * bytes are really a mess :-( */
836                   if (a->first_c)
837                     {
838                       c = a->first_c;
839                       a->first_c = 0;
840                     }
841                   else if ((c = iobuf_get (chain)) == -1)
842                     {
843                       log_error ("block_filter: 1st length byte missing\n");
844                       rc = GPG_ERR_BAD_DATA;
845                       break;
846                     }
847                   if (c < 192)
848                     {
849                       a->size = c;
850                       a->partial = 2;
851                       if (!a->size)
852                         {
853                           a->eof = 1;
854                           if (!n)
855                             rc = -1;
856                           break;
857                         }
858                     }
859                   else if (c < 224)
860                     {
861                       a->size = (c - 192) * 256;
862                       if ((c = iobuf_get (chain)) == -1)
863                         {
864                           log_error
865                             ("block_filter: 2nd length byte missing\n");
866                           rc = GPG_ERR_BAD_DATA;
867                           break;
868                         }
869                       a->size += c + 192;
870                       a->partial = 2;
871                       if (!a->size)
872                         {
873                           a->eof = 1;
874                           if (!n)
875                             rc = -1;
876                           break;
877                         }
878                     }
879                   else if (c == 255)
880                     {
881                       a->size = (size_t)iobuf_get (chain) << 24;
882                       a->size |= iobuf_get (chain) << 16;
883                       a->size |= iobuf_get (chain) << 8;
884                       if ((c = iobuf_get (chain)) == -1)
885                         {
886                           log_error ("block_filter: invalid 4 byte length\n");
887                           rc = GPG_ERR_BAD_DATA;
888                           break;
889                         }
890                       a->size |= c;
891                       a->partial = 2;
892                       if (!a->size)
893                         {
894                           a->eof = 1;
895                           if (!n)
896                             rc = -1;
897                           break;
898                         }
899                     }
900                   else
901                     { /* Next partial body length. */
902                       a->size = 1 << (c & 0x1f);
903                     }
904                   /*  log_debug("partial: ctx=%p c=%02x size=%u\n", a, c, a->size); */
905                 }
906               else
907                 BUG ();
908             }
909
910           while (!rc && size && a->size)
911             {
912               needed = size < a->size ? size : a->size;
913               c = iobuf_read (chain, p, needed);
914               if (c < needed)
915                 {
916                   if (c == -1)
917                     c = 0;
918                   log_error
919                     ("block_filter %p: read error (size=%lu,a->size=%lu)\n",
920                      a, (ulong) size + c, (ulong) a->size + c);
921                   rc = GPG_ERR_BAD_DATA;
922                 }
923               else
924                 {
925                   size -= c;
926                   a->size -= c;
927                   p += c;
928                   n += c;
929                 }
930             }
931         }
932       *ret_len = n;
933     }
934   else if (control == IOBUFCTRL_FLUSH)
935     {
936       if (a->partial)
937         {                       /* the complicated openpgp scheme */
938           size_t blen, n, nbytes = size + a->buflen;
939
940           assert (a->buflen <= OP_MIN_PARTIAL_CHUNK);
941           if (nbytes < OP_MIN_PARTIAL_CHUNK)
942             {
943               /* not enough to write a partial block out; so we store it */
944               if (!a->buffer)
945                 a->buffer = xmalloc (OP_MIN_PARTIAL_CHUNK);
946               memcpy (a->buffer + a->buflen, buf, size);
947               a->buflen += size;
948             }
949           else
950             {                   /* okay, we can write out something */
951               /* do this in a loop to use the most efficient block lengths */
952               p = buf;
953               do
954                 {
955                   /* find the best matching block length - this is limited
956                    * by the size of the internal buffering */
957                   for (blen = OP_MIN_PARTIAL_CHUNK * 2,
958                        c = OP_MIN_PARTIAL_CHUNK_2POW + 1; blen <= nbytes;
959                        blen *= 2, c++)
960                     ;
961                   blen /= 2;
962                   c--;
963                   /* write the partial length header */
964                   assert (c <= 0x1f);   /*;-) */
965                   c |= 0xe0;
966                   iobuf_put (chain, c);
967                   if ((n = a->buflen))
968                     {           /* write stuff from the buffer */
969                       assert (n == OP_MIN_PARTIAL_CHUNK);
970                       if (iobuf_write (chain, a->buffer, n))
971                         rc = gpg_error_from_syserror ();
972                       a->buflen = 0;
973                       nbytes -= n;
974                     }
975                   if ((n = nbytes) > blen)
976                     n = blen;
977                   if (n && iobuf_write (chain, p, n))
978                     rc = gpg_error_from_syserror ();
979                   p += n;
980                   nbytes -= n;
981                 }
982               while (!rc && nbytes >= OP_MIN_PARTIAL_CHUNK);
983               /* store the rest in the buffer */
984               if (!rc && nbytes)
985                 {
986                   assert (!a->buflen);
987                   assert (nbytes < OP_MIN_PARTIAL_CHUNK);
988                   if (!a->buffer)
989                     a->buffer = xmalloc (OP_MIN_PARTIAL_CHUNK);
990                   memcpy (a->buffer, p, nbytes);
991                   a->buflen = nbytes;
992                 }
993             }
994         }
995       else
996         BUG ();
997     }
998   else if (control == IOBUFCTRL_INIT)
999     {
1000       if (DBG_IOBUF)
1001         log_debug ("init block_filter %p\n", a);
1002       if (a->partial)
1003         a->count = 0;
1004       else if (a->use == IOBUF_INPUT)
1005         a->count = a->size = 0;
1006       else
1007         a->count = a->size;     /* force first length bytes */
1008       a->eof = 0;
1009       a->buffer = NULL;
1010       a->buflen = 0;
1011     }
1012   else if (control == IOBUFCTRL_DESC)
1013     {
1014       mem2str (buf, "block_filter", *ret_len);
1015     }
1016   else if (control == IOBUFCTRL_FREE)
1017     {
1018       if (a->use == IOBUF_OUTPUT)
1019         {                       /* write the end markers */
1020           if (a->partial)
1021             {
1022               u32 len;
1023               /* write out the remaining bytes without a partial header
1024                * the length of this header may be 0 - but if it is
1025                * the first block we are not allowed to use a partial header
1026                * and frankly we can't do so, because this length must be
1027                * a power of 2. This is _really_ complicated because we
1028                * have to check the possible length of a packet prior
1029                * to it's creation: a chain of filters becomes complicated
1030                * and we need a lot of code to handle compressed packets etc.
1031                *   :-(((((((
1032                */
1033               /* construct header */
1034               len = a->buflen;
1035               /*log_debug("partial: remaining length=%u\n", len ); */
1036               if (len < 192)
1037                 rc = iobuf_put (chain, len);
1038               else if (len < 8384)
1039                 {
1040                   if (!(rc = iobuf_put (chain, ((len - 192) / 256) + 192)))
1041                     rc = iobuf_put (chain, ((len - 192) % 256));
1042                 }
1043               else
1044                 {               /* use a 4 byte header */
1045                   if (!(rc = iobuf_put (chain, 0xff)))
1046                     if (!(rc = iobuf_put (chain, (len >> 24) & 0xff)))
1047                       if (!(rc = iobuf_put (chain, (len >> 16) & 0xff)))
1048                         if (!(rc = iobuf_put (chain, (len >> 8) & 0xff)))
1049                           rc = iobuf_put (chain, len & 0xff);
1050                 }
1051               if (!rc && len)
1052                 rc = iobuf_write (chain, a->buffer, len);
1053               if (rc)
1054                 {
1055                   log_error ("block_filter: write error: %s\n",
1056                              strerror (errno));
1057                   rc = gpg_error_from_syserror ();
1058                 }
1059               xfree (a->buffer);
1060               a->buffer = NULL;
1061               a->buflen = 0;
1062             }
1063           else
1064             BUG ();
1065         }
1066       else if (a->size)
1067         {
1068           log_error ("block_filter: pending bytes!\n");
1069         }
1070       if (DBG_IOBUF)
1071         log_debug ("free block_filter %p\n", a);
1072       xfree (a);                /* we can free our context now */
1073     }
1074
1075   return rc;
1076 }
1077
1078
1079 /* Change the default size for all IOBUFs to KILOBYTE.  This needs to
1080  * be called before any iobufs are used and can only be used once.
1081  * Returns the current value.  Using 0 has no effect except for
1082  * returning the current value.  */
1083 unsigned int
1084 iobuf_set_buffer_size (unsigned int kilobyte)
1085 {
1086   static int used;
1087
1088   if (!used && kilobyte)
1089     {
1090       if (kilobyte < 4)
1091         kilobyte = 4;
1092       else if (kilobyte > 16*1024)
1093         kilobyte = 16*1024;
1094
1095       iobuf_buffer_size = kilobyte * 1024;
1096       used = 1;
1097     }
1098   return iobuf_buffer_size / 1024;
1099 }
1100
1101
1102 #define MAX_IOBUF_DESC 32
1103 /*
1104  * Fill the buffer by the description of iobuf A.
1105  * The buffer size should be MAX_IOBUF_DESC (or larger).
1106  * Returns BUF as (const char *).
1107  */
1108 static const char *
1109 iobuf_desc (iobuf_t a, byte *buf)
1110 {
1111   size_t len = MAX_IOBUF_DESC;
1112
1113   if (! a || ! a->filter)
1114     memcpy (buf, "?", 2);
1115   else
1116     a->filter (a->filter_ov, IOBUFCTRL_DESC, NULL, buf, &len);
1117
1118   return buf;
1119 }
1120
1121 static void
1122 print_chain (iobuf_t a)
1123 {
1124   if (!DBG_IOBUF)
1125     return;
1126   for (; a; a = a->chain)
1127     {
1128       byte desc[MAX_IOBUF_DESC];
1129
1130       log_debug ("iobuf chain: %d.%d '%s' filter_eof=%d start=%d len=%d\n",
1131                  a->no, a->subno, iobuf_desc (a, desc), a->filter_eof,
1132                  (int) a->d.start, (int) a->d.len);
1133     }
1134 }
1135
1136 int
1137 iobuf_print_chain (iobuf_t a)
1138 {
1139   print_chain (a);
1140   return 0;
1141 }
1142
1143 iobuf_t
1144 iobuf_alloc (int use, size_t bufsize)
1145 {
1146   iobuf_t a;
1147   static int number = 0;
1148
1149   assert (use == IOBUF_INPUT || use == IOBUF_INPUT_TEMP
1150           || use == IOBUF_OUTPUT || use == IOBUF_OUTPUT_TEMP);
1151   if (bufsize == 0)
1152     {
1153       log_bug ("iobuf_alloc() passed a bufsize of 0!\n");
1154       bufsize = iobuf_buffer_size;
1155     }
1156
1157   a = xcalloc (1, sizeof *a);
1158   a->use = use;
1159   a->d.buf = xmalloc (bufsize);
1160   a->d.size = bufsize;
1161   a->no = ++number;
1162   a->subno = 0;
1163   a->real_fname = NULL;
1164   return a;
1165 }
1166
1167 int
1168 iobuf_close (iobuf_t a)
1169 {
1170   iobuf_t a_chain;
1171   size_t dummy_len = 0;
1172   int rc = 0;
1173
1174   for (; a; a = a_chain)
1175     {
1176       byte desc[MAX_IOBUF_DESC];
1177       int rc2 = 0;
1178
1179       a_chain = a->chain;
1180
1181       if (a->use == IOBUF_OUTPUT && (rc = filter_flush (a)))
1182         log_error ("filter_flush failed on close: %s\n", gpg_strerror (rc));
1183
1184       if (DBG_IOBUF)
1185         log_debug ("iobuf-%d.%d: close '%s'\n",
1186                    a->no, a->subno, iobuf_desc (a, desc));
1187
1188       if (a->filter && (rc2 = a->filter (a->filter_ov, IOBUFCTRL_FREE,
1189                                          a->chain, NULL, &dummy_len)))
1190         log_error ("IOBUFCTRL_FREE failed on close: %s\n", gpg_strerror (rc));
1191       if (! rc && rc2)
1192         /* Whoops!  An error occurred.  Save it in RC if we haven't
1193            already recorded an error.  */
1194         rc = rc2;
1195
1196       xfree (a->real_fname);
1197       if (a->d.buf)
1198         {
1199           memset (a->d.buf, 0, a->d.size);      /* erase the buffer */
1200           xfree (a->d.buf);
1201         }
1202       xfree (a);
1203     }
1204   return rc;
1205 }
1206
1207 int
1208 iobuf_cancel (iobuf_t a)
1209 {
1210   const char *s;
1211   iobuf_t a2;
1212   int rc;
1213 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1214   char *remove_name = NULL;
1215 #endif
1216
1217   if (a && a->use == IOBUF_OUTPUT)
1218     {
1219       s = iobuf_get_real_fname (a);
1220       if (s && *s)
1221         {
1222 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1223           remove_name = xstrdup (s);
1224 #else
1225           remove (s);
1226 #endif
1227         }
1228     }
1229
1230   /* send a cancel message to all filters */
1231   for (a2 = a; a2; a2 = a2->chain)
1232     {
1233       size_t dummy;
1234       if (a2->filter)
1235         a2->filter (a2->filter_ov, IOBUFCTRL_CANCEL, a2->chain, NULL, &dummy);
1236     }
1237
1238   rc = iobuf_close (a);
1239 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1240   if (remove_name)
1241     {
1242       /* Argg, MSDOS does not allow removing open files.  So
1243        * we have to do it here */
1244 #ifdef HAVE_W32CE_SYSTEM
1245       wchar_t *wtmp = utf8_to_wchar (remove_name);
1246       if (wtmp)
1247         DeleteFile (wtmp);
1248       xfree (wtmp);
1249 #else
1250       remove (remove_name);
1251 #endif
1252       xfree (remove_name);
1253     }
1254 #endif
1255   return rc;
1256 }
1257
1258
1259 iobuf_t
1260 iobuf_temp (void)
1261 {
1262   return iobuf_alloc (IOBUF_OUTPUT_TEMP, iobuf_buffer_size);
1263 }
1264
1265 iobuf_t
1266 iobuf_temp_with_content (const char *buffer, size_t length)
1267 {
1268   iobuf_t a;
1269   int i;
1270
1271   a = iobuf_alloc (IOBUF_INPUT_TEMP, length);
1272   assert (length == a->d.size);
1273   /* memcpy (a->d.buf, buffer, length); */
1274   for (i=0; i < length; i++)
1275     a->d.buf[i] = buffer[i];
1276   a->d.len = length;
1277
1278   return a;
1279 }
1280
1281
1282 int
1283 iobuf_is_pipe_filename (const char *fname)
1284 {
1285   if (!fname || (*fname=='-' && !fname[1]) )
1286     return 1;
1287   return check_special_filename (fname, 0, 1) != -1;
1288 }
1289
1290
1291 static iobuf_t
1292 do_open (const char *fname, int special_filenames,
1293          int use, const char *opentype, int mode700)
1294 {
1295   iobuf_t a;
1296   gnupg_fd_t fp;
1297   file_filter_ctx_t *fcx;
1298   size_t len = 0;
1299   int print_only = 0;
1300   int fd;
1301   byte desc[MAX_IOBUF_DESC];
1302
1303   assert (use == IOBUF_INPUT || use == IOBUF_OUTPUT);
1304
1305   if (special_filenames
1306       /* NULL or '-'.  */
1307       && (!fname || (*fname == '-' && !fname[1])))
1308     {
1309       if (use == IOBUF_INPUT)
1310         {
1311           fp = FD_FOR_STDIN;
1312           fname = "[stdin]";
1313         }
1314       else
1315         {
1316           fp = FD_FOR_STDOUT;
1317           fname = "[stdout]";
1318         }
1319       print_only = 1;
1320     }
1321   else if (!fname)
1322     return NULL;
1323   else if (special_filenames
1324            && (fd = check_special_filename (fname, 0, 1)) != -1)
1325     return iobuf_fdopen (translate_file_handle (fd, use == IOBUF_INPUT ? 0 : 1),
1326                          opentype);
1327   else
1328     {
1329       if (use == IOBUF_INPUT)
1330         fp = fd_cache_open (fname, opentype);
1331       else
1332         fp = direct_open (fname, opentype, mode700);
1333       if (fp == GNUPG_INVALID_FD)
1334         return NULL;
1335     }
1336
1337   a = iobuf_alloc (use, iobuf_buffer_size);
1338   fcx = xmalloc (sizeof *fcx + strlen (fname));
1339   fcx->fp = fp;
1340   fcx->print_only_name = print_only;
1341   strcpy (fcx->fname, fname);
1342   if (!print_only)
1343     a->real_fname = xstrdup (fname);
1344   a->filter = file_filter;
1345   a->filter_ov = fcx;
1346   file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1347   if (DBG_IOBUF)
1348     log_debug ("iobuf-%d.%d: open '%s' desc=%s fd=%d\n",
1349                a->no, a->subno, fname, iobuf_desc (a, desc), FD2INT (fcx->fp));
1350
1351   return a;
1352 }
1353
1354 iobuf_t
1355 iobuf_open (const char *fname)
1356 {
1357   return do_open (fname, 1, IOBUF_INPUT, "rb", 0);
1358 }
1359
1360 iobuf_t
1361 iobuf_create (const char *fname, int mode700)
1362 {
1363   return do_open (fname, 1, IOBUF_OUTPUT, "wb", mode700);
1364 }
1365
1366 iobuf_t
1367 iobuf_openrw (const char *fname)
1368 {
1369   return do_open (fname, 0, IOBUF_OUTPUT, "r+b", 0);
1370 }
1371
1372
1373 static iobuf_t
1374 do_iobuf_fdopen (int fd, const char *mode, int keep_open)
1375 {
1376   iobuf_t a;
1377   gnupg_fd_t fp;
1378   file_filter_ctx_t *fcx;
1379   size_t len;
1380
1381   fp = INT2FD (fd);
1382
1383   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1384                    iobuf_buffer_size);
1385   fcx = xmalloc (sizeof *fcx + 20);
1386   fcx->fp = fp;
1387   fcx->print_only_name = 1;
1388   fcx->keep_open = keep_open;
1389   sprintf (fcx->fname, "[fd %d]", fd);
1390   a->filter = file_filter;
1391   a->filter_ov = fcx;
1392   file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1393   if (DBG_IOBUF)
1394     log_debug ("iobuf-%d.%d: fdopen%s '%s'\n",
1395                a->no, a->subno, keep_open? "_nc":"", fcx->fname);
1396   iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
1397   return a;
1398 }
1399
1400
1401 iobuf_t
1402 iobuf_fdopen (int fd, const char *mode)
1403 {
1404   return do_iobuf_fdopen (fd, mode, 0);
1405 }
1406
1407 iobuf_t
1408 iobuf_fdopen_nc (int fd, const char *mode)
1409 {
1410   return do_iobuf_fdopen (fd, mode, 1);
1411 }
1412
1413
1414 iobuf_t
1415 iobuf_esopen (estream_t estream, const char *mode, int keep_open)
1416 {
1417   iobuf_t a;
1418   file_es_filter_ctx_t *fcx;
1419   size_t len = 0;
1420
1421   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1422                    iobuf_buffer_size);
1423   fcx = xtrymalloc (sizeof *fcx + 30);
1424   fcx->fp = estream;
1425   fcx->print_only_name = 1;
1426   fcx->keep_open = keep_open;
1427   sprintf (fcx->fname, "[fd %p]", estream);
1428   a->filter = file_es_filter;
1429   a->filter_ov = fcx;
1430   file_es_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1431   if (DBG_IOBUF)
1432     log_debug ("iobuf-%d.%d: esopen%s '%s'\n",
1433                a->no, a->subno, keep_open? "_nc":"", fcx->fname);
1434   return a;
1435 }
1436
1437
1438 iobuf_t
1439 iobuf_sockopen (int fd, const char *mode)
1440 {
1441   iobuf_t a;
1442 #ifdef HAVE_W32_SYSTEM
1443   sock_filter_ctx_t *scx;
1444   size_t len;
1445
1446   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1447                    iobuf_buffer_size);
1448   scx = xmalloc (sizeof *scx + 25);
1449   scx->sock = fd;
1450   scx->print_only_name = 1;
1451   sprintf (scx->fname, "[sock %d]", fd);
1452   a->filter = sock_filter;
1453   a->filter_ov = scx;
1454   sock_filter (scx, IOBUFCTRL_INIT, NULL, NULL, &len);
1455   if (DBG_IOBUF)
1456     log_debug ("iobuf-%d.%d: sockopen '%s'\n", a->no, a->subno, scx->fname);
1457   iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
1458 #else
1459   a = iobuf_fdopen (fd, mode);
1460 #endif
1461   return a;
1462 }
1463
1464 int
1465 iobuf_ioctl (iobuf_t a, iobuf_ioctl_t cmd, int intval, void *ptrval)
1466 {
1467   byte desc[MAX_IOBUF_DESC];
1468
1469   if (cmd == IOBUF_IOCTL_KEEP_OPEN)
1470     {
1471       /* Keep system filepointer/descriptor open.  This was used in
1472          the past by http.c; this ioctl is not directly used
1473          anymore.  */
1474       if (DBG_IOBUF)
1475         log_debug ("iobuf-%d.%d: ioctl '%s' keep_open=%d\n",
1476                    a ? a->no : -1, a ? a->subno : -1, iobuf_desc (a, desc),
1477                    intval);
1478       for (; a; a = a->chain)
1479         if (!a->chain && a->filter == file_filter)
1480           {
1481             file_filter_ctx_t *b = a->filter_ov;
1482             b->keep_open = intval;
1483             return 0;
1484           }
1485 #ifdef HAVE_W32_SYSTEM
1486         else if (!a->chain && a->filter == sock_filter)
1487           {
1488             sock_filter_ctx_t *b = a->filter_ov;
1489             b->keep_open = intval;
1490             return 0;
1491           }
1492 #endif
1493     }
1494   else if (cmd == IOBUF_IOCTL_INVALIDATE_CACHE)
1495     {
1496       if (DBG_IOBUF)
1497         log_debug ("iobuf-*.*: ioctl '%s' invalidate\n",
1498                    ptrval ? (char *) ptrval : "?");
1499       if (!a && !intval && ptrval)
1500         {
1501           if (fd_cache_invalidate (ptrval))
1502             return -1;
1503           return 0;
1504         }
1505     }
1506   else if (cmd == IOBUF_IOCTL_NO_CACHE)
1507     {
1508       if (DBG_IOBUF)
1509         log_debug ("iobuf-%d.%d: ioctl '%s' no_cache=%d\n",
1510                    a ? a->no : -1, a ? a->subno : -1, iobuf_desc (a, desc),
1511                    intval);
1512       for (; a; a = a->chain)
1513         if (!a->chain && a->filter == file_filter)
1514           {
1515             file_filter_ctx_t *b = a->filter_ov;
1516             b->no_cache = intval;
1517             return 0;
1518           }
1519 #ifdef HAVE_W32_SYSTEM
1520         else if (!a->chain && a->filter == sock_filter)
1521           {
1522             sock_filter_ctx_t *b = a->filter_ov;
1523             b->no_cache = intval;
1524             return 0;
1525           }
1526 #endif
1527     }
1528   else if (cmd == IOBUF_IOCTL_FSYNC)
1529     {
1530       /* Do a fsync on the open fd and return any errors to the caller
1531          of iobuf_ioctl.  Note that we work on a file name here. */
1532       if (DBG_IOBUF)
1533         log_debug ("iobuf-*.*: ioctl '%s' fsync\n",
1534                    ptrval? (const char*)ptrval:"<null>");
1535
1536       if (!a && !intval && ptrval)
1537         {
1538           return fd_cache_synchronize (ptrval);
1539         }
1540     }
1541
1542
1543   return -1;
1544 }
1545
1546
1547 /****************
1548  * Register an i/o filter.
1549  */
1550 int
1551 iobuf_push_filter (iobuf_t a,
1552                    int (*f) (void *opaque, int control,
1553                              iobuf_t chain, byte * buf, size_t * len),
1554                    void *ov)
1555 {
1556   return iobuf_push_filter2 (a, f, ov, 0);
1557 }
1558
1559 int
1560 iobuf_push_filter2 (iobuf_t a,
1561                     int (*f) (void *opaque, int control,
1562                               iobuf_t chain, byte * buf, size_t * len),
1563                     void *ov, int rel_ov)
1564 {
1565   iobuf_t b;
1566   size_t dummy_len = 0;
1567   int rc = 0;
1568
1569   if (a->use == IOBUF_OUTPUT && (rc = filter_flush (a)))
1570     return rc;
1571
1572   if (a->subno >= MAX_NESTING_FILTER)
1573     {
1574       log_error ("i/o filter too deeply nested - corrupted data?\n");
1575       return GPG_ERR_BAD_DATA;
1576     }
1577
1578   /* We want to create a new filter and put it in front of A.  A
1579      simple implementation would do:
1580
1581        b = iobuf_alloc (...);
1582        b->chain = a;
1583        return a;
1584
1585      This is a bit problematic: A is the head of the pipeline and
1586      there are potentially many pointers to it.  Requiring the caller
1587      to update all of these pointers is a burden.
1588
1589      An alternative implementation would add a level of indirection.
1590      For instance, we could use a pipeline object, which contains a
1591      pointer to the first filter in the pipeline.  This is not what we
1592      do either.
1593
1594      Instead, we allocate a new buffer (B) and copy the first filter's
1595      state into that and use the initial buffer (A) for the new
1596      filter.  One limitation of this approach is that it is not
1597      practical to maintain a pointer to a specific filter's state.
1598
1599      Before:
1600
1601            A
1602            |
1603            v 0x100               0x200
1604            +----------+          +----------+
1605            | filter x |--------->| filter y |---->....
1606            +----------+          +----------+
1607
1608      After:           B
1609                       |
1610                       v 0x300
1611                       +----------+
1612            A          | filter x |
1613            |          +----------+
1614            v 0x100    ^          v 0x200
1615            +----------+          +----------+
1616            | filter w |          | filter y |---->....
1617            +----------+          +----------+
1618
1619      Note: filter x's address changed from 0x100 to 0x300, but A still
1620      points to the head of the pipeline.
1621   */
1622
1623   b = xmalloc (sizeof *b);
1624   memcpy (b, a, sizeof *b);
1625   /* fixme: it is stupid to keep a copy of the name at every level
1626    * but we need the name somewhere because the name known by file_filter
1627    * may have been released when we need the name of the file */
1628   b->real_fname = a->real_fname ? xstrdup (a->real_fname) : NULL;
1629   /* remove the filter stuff from the new stream */
1630   a->filter = NULL;
1631   a->filter_ov = NULL;
1632   a->filter_ov_owner = 0;
1633   a->filter_eof = 0;
1634   if (a->use == IOBUF_OUTPUT_TEMP)
1635     /* A TEMP filter buffers any data sent to it; it does not forward
1636        any data down the pipeline.  If we add a new filter to the
1637        pipeline, it shouldn't also buffer data.  It should send it
1638        downstream to be buffered.  Thus, the correct type for a filter
1639        added in front of an IOBUF_OUTPUT_TEMP filter is IOBUF_OUPUT, not
1640        IOBUF_OUTPUT_TEMP.  */
1641     {
1642       a->use = IOBUF_OUTPUT;
1643
1644       /* When pipeline is written to, the temp buffer's size is
1645          increased accordingly.  We don't need to allocate a 10 MB
1646          buffer for a non-terminal filter.  Just use the default
1647          size.  */
1648       a->d.size = iobuf_buffer_size;
1649     }
1650   else if (a->use == IOBUF_INPUT_TEMP)
1651     /* Same idea as above.  */
1652     {
1653       a->use = IOBUF_INPUT;
1654       a->d.size = iobuf_buffer_size;
1655     }
1656
1657   /* The new filter (A) gets a new buffer.
1658
1659      If the pipeline is an output or temp pipeline, then giving the
1660      buffer to the new filter means that data that was written before
1661      the filter was pushed gets sent to the filter.  That's clearly
1662      wrong.
1663
1664      If the pipeline is an input pipeline, then giving the buffer to
1665      the new filter (A) means that data that has read from (B), but
1666      not yet read from the pipeline won't be processed by the new
1667      filter (A)!  That's certainly not what we want.  */
1668   a->d.buf = xmalloc (a->d.size);
1669   a->d.len = 0;
1670   a->d.start = 0;
1671
1672   /* disable nlimit for the new stream */
1673   a->ntotal = b->ntotal + b->nbytes;
1674   a->nlimit = a->nbytes = 0;
1675   a->nofast = 0;
1676   /* make a link from the new stream to the original stream */
1677   a->chain = b;
1678
1679   /* setup the function on the new stream */
1680   a->filter = f;
1681   a->filter_ov = ov;
1682   a->filter_ov_owner = rel_ov;
1683
1684   a->subno = b->subno + 1;
1685
1686   if (DBG_IOBUF)
1687     {
1688       byte desc[MAX_IOBUF_DESC];
1689       log_debug ("iobuf-%d.%d: push '%s'\n",
1690                  a->no, a->subno, iobuf_desc (a, desc));
1691       print_chain (a);
1692     }
1693
1694   /* now we can initialize the new function if we have one */
1695   if (a->filter && (rc = a->filter (a->filter_ov, IOBUFCTRL_INIT, a->chain,
1696                                     NULL, &dummy_len)))
1697     log_error ("IOBUFCTRL_INIT failed: %s\n", gpg_strerror (rc));
1698   return rc;
1699 }
1700
1701 /****************
1702  * Remove an i/o filter.
1703  */
1704 int
1705 iobuf_pop_filter (iobuf_t a, int (*f) (void *opaque, int control,
1706                                        iobuf_t chain, byte * buf, size_t * len),
1707                   void *ov)
1708 {
1709   iobuf_t b;
1710   size_t dummy_len = 0;
1711   int rc = 0;
1712   byte desc[MAX_IOBUF_DESC];
1713
1714   if (DBG_IOBUF)
1715     log_debug ("iobuf-%d.%d: pop '%s'\n",
1716                a->no, a->subno, iobuf_desc (a, desc));
1717   if (a->use == IOBUF_INPUT_TEMP || a->use == IOBUF_OUTPUT_TEMP)
1718     {
1719       /* This should be the last filter in the pipeline.  */
1720       assert (! a->chain);
1721       return 0;
1722     }
1723   if (!a->filter)
1724     {                           /* this is simple */
1725       b = a->chain;
1726       assert (b);
1727       xfree (a->d.buf);
1728       xfree (a->real_fname);
1729       memcpy (a, b, sizeof *a);
1730       xfree (b);
1731       return 0;
1732     }
1733   for (b = a; b; b = b->chain)
1734     if (b->filter == f && (!ov || b->filter_ov == ov))
1735       break;
1736   if (!b)
1737     log_bug ("iobuf_pop_filter(): filter function not found\n");
1738
1739   /* flush this stream if it is an output stream */
1740   if (a->use == IOBUF_OUTPUT && (rc = filter_flush (b)))
1741     {
1742       log_error ("filter_flush failed in iobuf_pop_filter: %s\n",
1743                  gpg_strerror (rc));
1744       return rc;
1745     }
1746   /* and tell the filter to free it self */
1747   if (b->filter && (rc = b->filter (b->filter_ov, IOBUFCTRL_FREE, b->chain,
1748                                     NULL, &dummy_len)))
1749     {
1750       log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
1751       return rc;
1752     }
1753   if (b->filter_ov && b->filter_ov_owner)
1754     {
1755       xfree (b->filter_ov);
1756       b->filter_ov = NULL;
1757     }
1758
1759
1760   /* and see how to remove it */
1761   if (a == b && !b->chain)
1762     log_bug ("can't remove the last filter from the chain\n");
1763   else if (a == b)
1764     {                           /* remove the first iobuf from the chain */
1765       /* everything from b is copied to a. This is save because
1766        * a flush has been done on the to be removed entry
1767        */
1768       b = a->chain;
1769       xfree (a->d.buf);
1770       xfree (a->real_fname);
1771       memcpy (a, b, sizeof *a);
1772       xfree (b);
1773       if (DBG_IOBUF)
1774         log_debug ("iobuf-%d.%d: popped filter\n", a->no, a->subno);
1775     }
1776   else if (!b->chain)
1777     {                           /* remove the last iobuf from the chain */
1778       log_bug ("Ohh jeee, trying to remove a head filter\n");
1779     }
1780   else
1781     {                           /* remove an intermediate iobuf from the chain */
1782       log_bug ("Ohh jeee, trying to remove an intermediate filter\n");
1783     }
1784
1785   return rc;
1786 }
1787
1788
1789 /****************
1790  * read underflow: read at least one byte into the buffer and return
1791  * the first byte or -1 on EOF.
1792  */
1793 static int
1794 underflow (iobuf_t a, int clear_pending_eof)
1795 {
1796   return underflow_target (a, clear_pending_eof, 1);
1797 }
1798
1799
1800 /****************
1801  * read underflow: read TARGET bytes into the buffer and return
1802  * the first byte or -1 on EOF.
1803  */
1804 static int
1805 underflow_target (iobuf_t a, int clear_pending_eof, size_t target)
1806 {
1807   size_t len;
1808   int rc;
1809
1810   if (DBG_IOBUF)
1811     log_debug ("iobuf-%d.%d: underflow: buffer size: %d; still buffered: %d => space for %d bytes\n",
1812                a->no, a->subno,
1813                (int) a->d.size, (int) (a->d.len - a->d.start),
1814                (int) (a->d.size - (a->d.len - a->d.start)));
1815
1816   if (a->use == IOBUF_INPUT_TEMP)
1817     /* By definition, there isn't more data to read into the
1818        buffer.  */
1819     return -1;
1820
1821   assert (a->use == IOBUF_INPUT);
1822
1823   /* If there is still some buffered data, then move it to the start
1824      of the buffer and try to fill the end of the buffer.  (This is
1825      useful if we are called from iobuf_peek().)  */
1826   assert (a->d.start <= a->d.len);
1827   a->d.len -= a->d.start;
1828   memmove (a->d.buf, &a->d.buf[a->d.start], a->d.len);
1829   a->d.start = 0;
1830
1831   if (a->d.len < target && a->filter_eof)
1832     /* The last time we tried to read from this filter, we got an EOF.
1833        We couldn't return the EOF, because there was buffered data.
1834        Since there is no longer any buffered data, return the
1835        error.  */
1836     {
1837       if (DBG_IOBUF)
1838         log_debug ("iobuf-%d.%d: underflow: eof (pending eof)\n",
1839                    a->no, a->subno);
1840       if (! clear_pending_eof)
1841         return -1;
1842
1843       if (a->chain)
1844         /* A filter follows this one.  Free this filter.  */
1845         {
1846           iobuf_t b = a->chain;
1847           if (DBG_IOBUF)
1848             log_debug ("iobuf-%d.%d: filter popped (pending EOF returned)\n",
1849                        a->no, a->subno);
1850           xfree (a->d.buf);
1851           xfree (a->real_fname);
1852           memcpy (a, b, sizeof *a);
1853           xfree (b);
1854           print_chain (a);
1855         }
1856       else
1857         a->filter_eof = 0;      /* for the top level filter */
1858       return -1;                /* return one(!) EOF */
1859     }
1860
1861   if (a->d.len == 0 && a->error)
1862     /* The last time we tried to read from this filter, we got an
1863        error.  We couldn't return the error, because there was
1864        buffered data.  Since there is no longer any buffered data,
1865        return the error.  */
1866     {
1867       if (DBG_IOBUF)
1868         log_debug ("iobuf-%d.%d: pending error (%s) returned\n",
1869                    a->no, a->subno, gpg_strerror (a->error));
1870       return -1;
1871     }
1872
1873   if (a->filter && ! a->filter_eof && ! a->error)
1874     /* We have a filter function and the last time we tried to read we
1875        didn't get an EOF or an error.  Try to fill the buffer.  */
1876     {
1877       /* Be careful to account for any buffered data.  */
1878       len = a->d.size - a->d.len;
1879       if (DBG_IOBUF)
1880         log_debug ("iobuf-%d.%d: underflow: A->FILTER (%lu bytes)\n",
1881                    a->no, a->subno, (ulong) len);
1882       if (len == 0)
1883         /* There is no space for more data.  Don't bother calling
1884            A->FILTER.  */
1885         rc = 0;
1886       else
1887         rc = a->filter (a->filter_ov, IOBUFCTRL_UNDERFLOW, a->chain,
1888                         &a->d.buf[a->d.len], &len);
1889       a->d.len += len;
1890
1891       if (DBG_IOBUF)
1892         log_debug ("iobuf-%d.%d: A->FILTER() returned rc=%d (%s), read %lu bytes\n",
1893                    a->no, a->subno,
1894                    rc, rc == 0 ? "ok" : rc == -1 ? "EOF" : gpg_strerror (rc),
1895                    (ulong) len);
1896 /*          if( a->no == 1 ) */
1897 /*                   log_hexdump ("     data:", a->d.buf, len); */
1898
1899       if (rc == -1)
1900         /* EOF.  */
1901         {
1902           size_t dummy_len = 0;
1903
1904           /* Tell the filter to free itself */
1905           if ((rc = a->filter (a->filter_ov, IOBUFCTRL_FREE, a->chain,
1906                                NULL, &dummy_len)))
1907             log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
1908
1909           /* Free everything except for the internal buffer.  */
1910           if (a->filter_ov && a->filter_ov_owner)
1911             xfree (a->filter_ov);
1912           a->filter_ov = NULL;
1913           a->filter = NULL;
1914           a->filter_eof = 1;
1915
1916           if (clear_pending_eof && a->d.len == 0 && a->chain)
1917             /* We don't need to keep this filter around at all:
1918
1919                  - we got an EOF
1920                  - we have no buffered data
1921                  - a filter follows this one.
1922
1923               Unlink this filter.  */
1924             {
1925               iobuf_t b = a->chain;
1926               if (DBG_IOBUF)
1927                 log_debug ("iobuf-%d.%d: pop in underflow (nothing buffered, got EOF)\n",
1928                            a->no, a->subno);
1929               xfree (a->d.buf);
1930               xfree (a->real_fname);
1931               memcpy (a, b, sizeof *a);
1932               xfree (b);
1933
1934               print_chain (a);
1935
1936               return -1;
1937             }
1938           else if (a->d.len == 0)
1939             /* We can't unlink this filter (it is the only one in the
1940                pipeline), but we can immediately return EOF.  */
1941             return -1;
1942         }
1943       else if (rc)
1944         /* Record the error.  */
1945         {
1946           a->error = rc;
1947
1948           if (a->d.len == 0)
1949             /* There is no buffered data.  Immediately return EOF.  */
1950             return -1;
1951         }
1952     }
1953
1954   assert (a->d.start <= a->d.len);
1955   if (a->d.start < a->d.len)
1956     return a->d.buf[a->d.start++];
1957
1958   /* EOF.  */
1959   return -1;
1960 }
1961
1962
1963 static int
1964 filter_flush (iobuf_t a)
1965 {
1966   size_t len;
1967   int rc;
1968
1969   if (a->use == IOBUF_OUTPUT_TEMP)
1970     {                           /* increase the temp buffer */
1971       size_t newsize = a->d.size + iobuf_buffer_size;
1972
1973       if (DBG_IOBUF)
1974         log_debug ("increasing temp iobuf from %lu to %lu\n",
1975                    (ulong) a->d.size, (ulong) newsize);
1976
1977       a->d.buf = xrealloc (a->d.buf, newsize);
1978       a->d.size = newsize;
1979       return 0;
1980     }
1981   else if (a->use != IOBUF_OUTPUT)
1982     log_bug ("flush on non-output iobuf\n");
1983   else if (!a->filter)
1984     log_bug ("filter_flush: no filter\n");
1985   len = a->d.len;
1986   rc = a->filter (a->filter_ov, IOBUFCTRL_FLUSH, a->chain, a->d.buf, &len);
1987   if (!rc && len != a->d.len)
1988     {
1989       log_info ("filter_flush did not write all!\n");
1990       rc = GPG_ERR_INTERNAL;
1991     }
1992   else if (rc)
1993     a->error = rc;
1994   a->d.len = 0;
1995
1996   return rc;
1997 }
1998
1999
2000 int
2001 iobuf_readbyte (iobuf_t a)
2002 {
2003   int c;
2004
2005   if (a->use == IOBUF_OUTPUT || a->use == IOBUF_OUTPUT_TEMP)
2006     {
2007       log_bug ("iobuf_readbyte called on a non-INPUT pipeline!\n");
2008       return -1;
2009     }
2010
2011   assert (a->d.start <= a->d.len);
2012
2013   if (a->nlimit && a->nbytes >= a->nlimit)
2014     return -1;                  /* forced EOF */
2015
2016   if (a->d.start < a->d.len)
2017     {
2018       c = a->d.buf[a->d.start++];
2019     }
2020   else if ((c = underflow (a, 1)) == -1)
2021     return -1;                  /* EOF */
2022
2023   assert (a->d.start <= a->d.len);
2024
2025   /* Note: if underflow doesn't return EOF, then it returns the first
2026      byte that was read and advances a->d.start appropriately.  */
2027
2028   a->nbytes++;
2029   return c;
2030 }
2031
2032
2033 int
2034 iobuf_read (iobuf_t a, void *buffer, unsigned int buflen)
2035 {
2036   unsigned char *buf = (unsigned char *)buffer;
2037   int c, n;
2038
2039   if (a->use == IOBUF_OUTPUT || a->use == IOBUF_OUTPUT_TEMP)
2040     {
2041       log_bug ("iobuf_read called on a non-INPUT pipeline!\n");
2042       return -1;
2043     }
2044
2045   if (a->nlimit)
2046     {
2047       /* Handle special cases. */
2048       for (n = 0; n < buflen; n++)
2049         {
2050           if ((c = iobuf_readbyte (a)) == -1)
2051             {
2052               if (!n)
2053                 return -1;      /* eof */
2054               break;
2055             }
2056
2057           if (buf)
2058             {
2059               *buf = c;
2060               buf++;
2061             }
2062         }
2063       return n;
2064     }
2065
2066   n = 0;
2067   do
2068     {
2069       if (n < buflen && a->d.start < a->d.len)
2070         /* Drain the buffer.  */
2071         {
2072           unsigned size = a->d.len - a->d.start;
2073           if (size > buflen - n)
2074             size = buflen - n;
2075           if (buf)
2076             memcpy (buf, a->d.buf + a->d.start, size);
2077           n += size;
2078           a->d.start += size;
2079           if (buf)
2080             buf += size;
2081         }
2082       if (n < buflen)
2083         /* Draining the internal buffer didn't fill BUFFER.  Call
2084            underflow to read more data into the filter's internal
2085            buffer.  */
2086         {
2087           if ((c = underflow (a, 1)) == -1)
2088             /* EOF.  If we managed to read something, don't return EOF
2089                now.  */
2090             {
2091               a->nbytes += n;
2092               return n ? n : -1 /*EOF*/;
2093             }
2094           if (buf)
2095             *buf++ = c;
2096           n++;
2097         }
2098     }
2099   while (n < buflen);
2100   a->nbytes += n;
2101   return n;
2102 }
2103
2104
2105
2106 int
2107 iobuf_peek (iobuf_t a, byte * buf, unsigned buflen)
2108 {
2109   int n = 0;
2110
2111   assert (buflen > 0);
2112   assert (a->use == IOBUF_INPUT || a->use == IOBUF_INPUT_TEMP);
2113
2114   if (buflen > a->d.size)
2115     /* We can't peek more than we can buffer.  */
2116     buflen = a->d.size;
2117
2118   /* Try to fill the internal buffer with enough data to satisfy the
2119      request.  */
2120   while (buflen > a->d.len - a->d.start)
2121     {
2122       if (underflow_target (a, 0, buflen) == -1)
2123         /* EOF.  We can't read any more.  */
2124         break;
2125
2126       /* Underflow consumes the first character (it's the return
2127          value).  unget() it by resetting the "file position".  */
2128       assert (a->d.start == 1);
2129       a->d.start = 0;
2130     }
2131
2132   n = a->d.len - a->d.start;
2133   if (n > buflen)
2134     n = buflen;
2135
2136   if (n == 0)
2137     /* EOF.  */
2138     return -1;
2139
2140   memcpy (buf, &a->d.buf[a->d.start], n);
2141
2142   return n;
2143 }
2144
2145
2146
2147
2148 int
2149 iobuf_writebyte (iobuf_t a, unsigned int c)
2150 {
2151   int rc;
2152
2153   if (a->use == IOBUF_INPUT || a->use == IOBUF_INPUT_TEMP)
2154     {
2155       log_bug ("iobuf_writebyte called on an input pipeline!\n");
2156       return -1;
2157     }
2158
2159   if (a->d.len == a->d.size)
2160     if ((rc=filter_flush (a)))
2161       return rc;
2162
2163   assert (a->d.len < a->d.size);
2164   a->d.buf[a->d.len++] = c;
2165   return 0;
2166 }
2167
2168
2169 int
2170 iobuf_write (iobuf_t a, const void *buffer, unsigned int buflen)
2171 {
2172   const unsigned char *buf = (const unsigned char *)buffer;
2173   int rc;
2174
2175   if (a->use == IOBUF_INPUT || a->use == IOBUF_INPUT_TEMP)
2176     {
2177       log_bug ("iobuf_write called on an input pipeline!\n");
2178       return -1;
2179     }
2180
2181   do
2182     {
2183       if (buflen && a->d.len < a->d.size)
2184         {
2185           unsigned size = a->d.size - a->d.len;
2186           if (size > buflen)
2187             size = buflen;
2188           memcpy (a->d.buf + a->d.len, buf, size);
2189           buflen -= size;
2190           buf += size;
2191           a->d.len += size;
2192         }
2193       if (buflen)
2194         {
2195           rc = filter_flush (a);
2196           if (rc)
2197             return rc;
2198         }
2199     }
2200   while (buflen);
2201   return 0;
2202 }
2203
2204
2205 int
2206 iobuf_writestr (iobuf_t a, const char *buf)
2207 {
2208   if (a->use == IOBUF_INPUT || a->use == IOBUF_INPUT_TEMP)
2209     {
2210       log_bug ("iobuf_writestr called on an input pipeline!\n");
2211       return -1;
2212     }
2213
2214   return iobuf_write (a, buf, strlen (buf));
2215 }
2216
2217
2218
2219 int
2220 iobuf_write_temp (iobuf_t dest, iobuf_t source)
2221 {
2222   assert (source->use == IOBUF_OUTPUT || source->use == IOBUF_OUTPUT_TEMP);
2223   assert (dest->use == IOBUF_OUTPUT || dest->use == IOBUF_OUTPUT_TEMP);
2224
2225   iobuf_flush_temp (source);
2226   return iobuf_write (dest, source->d.buf, source->d.len);
2227 }
2228
2229 size_t
2230 iobuf_temp_to_buffer (iobuf_t a, byte * buffer, size_t buflen)
2231 {
2232   byte desc[MAX_IOBUF_DESC];
2233   size_t n;
2234
2235   while (1)
2236     {
2237       int rc = filter_flush (a);
2238       if (rc)
2239         log_bug ("Flushing iobuf %d.%d (%s) from iobuf_temp_to_buffer failed.  Ignoring.\n",
2240                  a->no, a->subno, iobuf_desc (a, desc));
2241       if (! a->chain)
2242         break;
2243       a = a->chain;
2244     }
2245
2246   n = a->d.len;
2247   if (n > buflen)
2248     n = buflen;
2249   memcpy (buffer, a->d.buf, n);
2250   return n;
2251 }
2252
2253 /* Copies the data from the input iobuf SOURCE to the output iobuf
2254    DEST until either an error is encountered or EOF is reached.
2255    Returns the number of bytes copies.  */
2256 size_t
2257 iobuf_copy (iobuf_t dest, iobuf_t source)
2258 {
2259   char *temp;
2260   /* Use a 32 KB buffer.  */
2261   const size_t temp_size = 32 * 1024;
2262
2263   size_t nread;
2264   size_t nwrote = 0;
2265   int err;
2266
2267   assert (source->use == IOBUF_INPUT || source->use == IOBUF_INPUT_TEMP);
2268   assert (dest->use == IOBUF_OUTPUT || source->use == IOBUF_OUTPUT_TEMP);
2269
2270   if (iobuf_error (dest))
2271     return -1;
2272
2273   temp = xmalloc (temp_size);
2274   while (1)
2275     {
2276       nread = iobuf_read (source, temp, temp_size);
2277       if (nread == -1)
2278         /* EOF.  */
2279         break;
2280
2281       err = iobuf_write (dest, temp, nread);
2282       if (err)
2283         break;
2284       nwrote += nread;
2285     }
2286
2287   /* Burn the buffer.  */
2288   wipememory (temp, sizeof (temp));
2289   xfree (temp);
2290
2291   return nwrote;
2292 }
2293
2294
2295 void
2296 iobuf_flush_temp (iobuf_t temp)
2297 {
2298   if (temp->use == IOBUF_INPUT || temp->use == IOBUF_INPUT_TEMP)
2299     log_bug ("iobuf_flush_temp called on an input pipeline!\n");
2300   while (temp->chain)
2301     iobuf_pop_filter (temp, temp->filter, NULL);
2302 }
2303
2304
2305 void
2306 iobuf_set_limit (iobuf_t a, off_t nlimit)
2307 {
2308   if (nlimit)
2309     a->nofast = 1;
2310   else
2311     a->nofast = 0;
2312   a->nlimit = nlimit;
2313   a->ntotal += a->nbytes;
2314   a->nbytes = 0;
2315 }
2316
2317
2318
2319 off_t
2320 iobuf_get_filelength (iobuf_t a, int *overflow)
2321 {
2322   if (overflow)
2323     *overflow = 0;
2324
2325   /* Hmmm: file_filter may have already been removed */
2326   for ( ; a->chain; a = a->chain )
2327     ;
2328
2329   if (a->filter != file_filter)
2330     return 0;
2331
2332   {
2333     file_filter_ctx_t *b = a->filter_ov;
2334     gnupg_fd_t fp = b->fp;
2335
2336 #if defined(HAVE_W32_SYSTEM)
2337     ulong size;
2338     static int (* __stdcall get_file_size_ex) (void *handle,
2339                                                LARGE_INTEGER *r_size);
2340     static int get_file_size_ex_initialized;
2341
2342     if (!get_file_size_ex_initialized)
2343       {
2344         void *handle;
2345
2346         handle = dlopen ("kernel32.dll", RTLD_LAZY);
2347         if (handle)
2348           {
2349             get_file_size_ex = dlsym (handle, "GetFileSizeEx");
2350             if (!get_file_size_ex)
2351               dlclose (handle);
2352           }
2353         get_file_size_ex_initialized = 1;
2354       }
2355
2356     if (get_file_size_ex)
2357       {
2358         /* This is a newer system with GetFileSizeEx; we use this
2359            then because it seem that GetFileSize won't return a
2360            proper error in case a file is larger than 4GB. */
2361         LARGE_INTEGER exsize;
2362
2363         if (get_file_size_ex (fp, &exsize))
2364           {
2365             if (!exsize.u.HighPart)
2366               return exsize.u.LowPart;
2367             if (overflow)
2368               *overflow = 1;
2369             return 0;
2370           }
2371       }
2372     else
2373       {
2374         if ((size=GetFileSize (fp, NULL)) != 0xffffffff)
2375           return size;
2376       }
2377     log_error ("GetFileSize for handle %p failed: %s\n",
2378                fp, w32_strerror (0));
2379 #else /*!HAVE_W32_SYSTEM*/
2380     {
2381       struct stat st;
2382
2383       if ( !fstat (FD2INT (fp), &st) )
2384         return st.st_size;
2385       log_error("fstat() failed: %s\n", strerror(errno) );
2386     }
2387 #endif /*!HAVE_W32_SYSTEM*/
2388   }
2389
2390   return 0;
2391 }
2392
2393
2394 int
2395 iobuf_get_fd (iobuf_t a)
2396 {
2397   for (; a->chain; a = a->chain)
2398     ;
2399
2400   if (a->filter != file_filter)
2401     return -1;
2402
2403   {
2404     file_filter_ctx_t *b = a->filter_ov;
2405     gnupg_fd_t fp = b->fp;
2406
2407     return FD2INT (fp);
2408   }
2409 }
2410
2411
2412 off_t
2413 iobuf_tell (iobuf_t a)
2414 {
2415   return a->ntotal + a->nbytes;
2416 }
2417
2418
2419 #if !defined(HAVE_FSEEKO) && !defined(fseeko)
2420
2421 #ifdef HAVE_LIMITS_H
2422 # include <limits.h>
2423 #endif
2424 #ifndef LONG_MAX
2425 # define LONG_MAX ((long) ((unsigned long) -1 >> 1))
2426 #endif
2427 #ifndef LONG_MIN
2428 # define LONG_MIN (-1 - LONG_MAX)
2429 #endif
2430
2431 /****************
2432  * A substitute for fseeko, for hosts that don't have it.
2433  */
2434 static int
2435 fseeko (FILE * stream, off_t newpos, int whence)
2436 {
2437   while (newpos != (long) newpos)
2438     {
2439       long pos = newpos < 0 ? LONG_MIN : LONG_MAX;
2440       if (fseek (stream, pos, whence) != 0)
2441         return -1;
2442       newpos -= pos;
2443       whence = SEEK_CUR;
2444     }
2445   return fseek (stream, (long) newpos, whence);
2446 }
2447 #endif
2448
2449 int
2450 iobuf_seek (iobuf_t a, off_t newpos)
2451 {
2452   file_filter_ctx_t *b = NULL;
2453
2454   if (a->use == IOBUF_OUTPUT || a->use == IOBUF_INPUT)
2455     {
2456       /* Find the last filter in the pipeline.  */
2457       for (; a->chain; a = a->chain)
2458         ;
2459
2460       if (a->filter != file_filter)
2461         return -1;
2462
2463       b = a->filter_ov;
2464
2465 #ifdef HAVE_W32_SYSTEM
2466       if (SetFilePointer (b->fp, newpos, NULL, FILE_BEGIN) == 0xffffffff)
2467         {
2468           log_error ("SetFilePointer failed on handle %p: ec=%d\n",
2469                      b->fp, (int) GetLastError ());
2470           return -1;
2471         }
2472 #else
2473       if (lseek (b->fp, newpos, SEEK_SET) == (off_t) - 1)
2474         {
2475           log_error ("can't lseek: %s\n", strerror (errno));
2476           return -1;
2477         }
2478 #endif
2479       /* Discard the buffer it is not a temp stream.  */
2480       a->d.len = 0;
2481     }
2482   a->d.start = 0;
2483   a->nbytes = 0;
2484   a->nlimit = 0;
2485   a->nofast = 0;
2486   a->ntotal = newpos;
2487   a->error = 0;
2488
2489   /* It is impossible for A->CHAIN to be non-NULL.  If A is an INPUT
2490      or OUTPUT buffer, then we find the last filter, which is defined
2491      as A->CHAIN being NULL.  If A is a TEMP filter, then A must be
2492      the only filter in the pipe: when iobuf_push_filter adds a filter
2493      to the front of a pipeline, it sets the new filter to be an
2494      OUTPUT filter if the pipeline is an OUTPUT or TEMP pipeline and
2495      to be an INPUT filter if the pipeline is an INPUT pipeline.
2496      Thus, only the last filter in a TEMP pipeline can be a */
2497
2498   /* remove filters, but the last */
2499   if (a->chain)
2500     log_debug ("iobuf_pop_filter called in iobuf_seek - please report\n");
2501   while (a->chain)
2502     iobuf_pop_filter (a, a->filter, NULL);
2503
2504   return 0;
2505 }
2506
2507
2508 const char *
2509 iobuf_get_real_fname (iobuf_t a)
2510 {
2511   if (a->real_fname)
2512     return a->real_fname;
2513
2514   /* the old solution */
2515   for (; a; a = a->chain)
2516     if (!a->chain && a->filter == file_filter)
2517       {
2518         file_filter_ctx_t *b = a->filter_ov;
2519         return b->print_only_name ? NULL : b->fname;
2520       }
2521
2522   return NULL;
2523 }
2524
2525 const char *
2526 iobuf_get_fname (iobuf_t a)
2527 {
2528   for (; a; a = a->chain)
2529     if (!a->chain && a->filter == file_filter)
2530       {
2531         file_filter_ctx_t *b = a->filter_ov;
2532         return b->fname;
2533       }
2534   return NULL;
2535 }
2536
2537 const char *
2538 iobuf_get_fname_nonnull (iobuf_t a)
2539 {
2540   const char *fname;
2541
2542   fname = iobuf_get_fname (a);
2543   return fname? fname : "[?]";
2544 }
2545
2546
2547 /****************
2548  * Enable or disable partial body length mode (RFC 4880 4.2.2.4).
2549  *
2550  * If LEN is 0, this disables partial block mode by popping the
2551  * partial body length filter, which must be the most recently
2552  * added filter.
2553  *
2554  * If LEN is non-zero, it pushes a partial body length filter.  If
2555  * this is a read filter, LEN must be the length byte from the first
2556  * chunk and A should be position just after this first partial body
2557  * length header.
2558  */
2559 void
2560 iobuf_set_partial_body_length_mode (iobuf_t a, size_t len)
2561 {
2562   if (!len)
2563     /* Disable partial body length mode.  */
2564     {
2565       if (a->use == IOBUF_INPUT)
2566         log_debug ("iobuf_pop_filter called in set_partial_block_mode"
2567                    " - please report\n");
2568
2569       log_assert (a->filter == block_filter);
2570       iobuf_pop_filter (a, block_filter, NULL);
2571     }
2572   else
2573     /* Enabled partial body length mode.  */
2574     {
2575       block_filter_ctx_t *ctx = xcalloc (1, sizeof *ctx);
2576       ctx->use = a->use;
2577       ctx->partial = 1;
2578       ctx->size = 0;
2579       ctx->first_c = len;
2580       iobuf_push_filter (a, block_filter, ctx);
2581     }
2582 }
2583
2584
2585
2586 unsigned int
2587 iobuf_read_line (iobuf_t a, byte ** addr_of_buffer,
2588                  unsigned *length_of_buffer, unsigned *max_length)
2589 {
2590   int c;
2591   char *buffer = (char *)*addr_of_buffer;
2592   unsigned length = *length_of_buffer;
2593   unsigned nbytes = 0;
2594   unsigned maxlen = *max_length;
2595   char *p;
2596
2597   /* The code assumes that we have space for at least a newline and a
2598      NUL character in the buffer.  This requires at least 2 bytes.  We
2599      don't complicate the code by handling the stupid corner case, but
2600      simply assert that it can't happen.  */
2601   assert (!buffer || length >= 2 || maxlen >= 2);
2602
2603   if (!buffer || length <= 1)
2604     /* must allocate a new buffer */
2605     {
2606       length = 256 <= maxlen ? 256 : maxlen;
2607       buffer = xrealloc (buffer, length);
2608       *addr_of_buffer = (unsigned char *)buffer;
2609       *length_of_buffer = length;
2610     }
2611
2612   p = buffer;
2613   while ((c = iobuf_get (a)) != -1)
2614     {
2615       *p++ = c;
2616       nbytes++;
2617       if (c == '\n')
2618         break;
2619
2620       if (nbytes == length - 1)
2621         /* We don't have enough space to add a \n and a \0.  Increase
2622            the buffer size.  */
2623         {
2624           if (length == maxlen)
2625             /* We reached the buffer's size limit!  */
2626             {
2627               /* Skip the rest of the line.  */
2628               while (c != '\n' && (c = iobuf_get (a)) != -1)
2629                 ;
2630
2631               /* p is pointing at the last byte in the buffer.  We
2632                  always terminate the line with "\n\0" so overwrite
2633                  the previous byte with a \n.  */
2634               assert (p > buffer);
2635               p[-1] = '\n';
2636
2637               /* Indicate truncation.  */
2638               *max_length = 0;
2639               break;
2640             }
2641
2642           length += length < 1024 ? 256 : 1024;
2643           if (length > maxlen)
2644             length = maxlen;
2645
2646           buffer = xrealloc (buffer, length);
2647           *addr_of_buffer = (unsigned char *)buffer;
2648           *length_of_buffer = length;
2649           p = buffer + nbytes;
2650         }
2651     }
2652   /* Add the terminating NUL.  */
2653   *p = 0;
2654
2655   /* Return the number of characters written to the buffer including
2656      the newline, but not including the terminating NUL.  */
2657   return nbytes;
2658 }
2659
2660 static int
2661 translate_file_handle (int fd, int for_write)
2662 {
2663 #if defined(HAVE_W32CE_SYSTEM)
2664   /* This is called only with one of the special filenames.  Under
2665      W32CE the FD here is not a file descriptor but a rendezvous id,
2666      thus we need to finish the pipe first.  */
2667   fd = _assuan_w32ce_finish_pipe (fd, for_write);
2668 #elif defined(HAVE_W32_SYSTEM)
2669   {
2670     int x;
2671
2672     (void)for_write;
2673
2674     if (fd == 0)
2675       x = (int) GetStdHandle (STD_INPUT_HANDLE);
2676     else if (fd == 1)
2677       x = (int) GetStdHandle (STD_OUTPUT_HANDLE);
2678     else if (fd == 2)
2679       x = (int) GetStdHandle (STD_ERROR_HANDLE);
2680     else
2681       x = fd;
2682
2683     if (x == -1)
2684       log_debug ("GetStdHandle(%d) failed: ec=%d\n",
2685                  fd, (int) GetLastError ());
2686
2687     fd = x;
2688   }
2689 #else
2690   (void)for_write;
2691 #endif
2692   return fd;
2693 }
2694
2695
2696 void
2697 iobuf_skip_rest (iobuf_t a, unsigned long n, int partial)
2698 {
2699   if ( partial )
2700     {
2701       for (;;)
2702         {
2703           if (a->nofast || a->d.start >= a->d.len)
2704             {
2705               if (iobuf_readbyte (a) == -1)
2706                 {
2707                   break;
2708                 }
2709             }
2710           else
2711             {
2712               unsigned long count = a->d.len - a->d.start;
2713               a->nbytes += count;
2714               a->d.start = a->d.len;
2715             }
2716         }
2717     }
2718   else
2719     {
2720       unsigned long remaining = n;
2721       while (remaining > 0)
2722         {
2723           if (a->nofast || a->d.start >= a->d.len)
2724             {
2725               if (iobuf_readbyte (a) == -1)
2726                 {
2727                   break;
2728                 }
2729               --remaining;
2730             }
2731           else
2732             {
2733               unsigned long count = a->d.len - a->d.start;
2734               if (count > remaining)
2735                 {
2736                   count = remaining;
2737                 }
2738               a->nbytes += count;
2739               a->d.start += count;
2740               remaining -= count;
2741             }
2742         }
2743     }
2744 }