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