common/iobuf.h: Remove iobuf_open_fd_or_name.
[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 /****************
1305  * Create a head iobuf for reading from a file
1306  * returns: NULL if an error occures and sets errno
1307  */
1308 iobuf_t
1309 iobuf_open (const char *fname)
1310 {
1311   iobuf_t a;
1312   gnupg_fd_t fp;
1313   file_filter_ctx_t *fcx;
1314   size_t len = 0;
1315   int print_only = 0;
1316   int fd;
1317
1318   if (!fname || (*fname == '-' && !fname[1]))
1319     {
1320       fp = FD_FOR_STDIN;
1321       fname = "[stdin]";
1322       print_only = 1;
1323     }
1324   else if ((fd = check_special_filename (fname)) != -1)
1325     return iobuf_fdopen (translate_file_handle (fd, 0), "rb");
1326   else if ((fp = fd_cache_open (fname, "rb")) == GNUPG_INVALID_FD)
1327     return NULL;
1328   a = iobuf_alloc (IOBUF_INPUT, IOBUF_BUFFER_SIZE);
1329   fcx = xmalloc (sizeof *fcx + strlen (fname));
1330   fcx->fp = fp;
1331   fcx->print_only_name = print_only;
1332   strcpy (fcx->fname, fname);
1333   if (!print_only)
1334     a->real_fname = xstrdup (fname);
1335   a->filter = file_filter;
1336   a->filter_ov = fcx;
1337   file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1338   if (DBG_IOBUF)
1339     log_debug ("iobuf-%d.%d: open '%s' fd=%d\n",
1340                a->no, a->subno, fname, FD2INT (fcx->fp));
1341
1342   return a;
1343 }
1344
1345
1346 static iobuf_t
1347 do_iobuf_fdopen (int fd, const char *mode, int keep_open)
1348 {
1349   iobuf_t a;
1350   gnupg_fd_t fp;
1351   file_filter_ctx_t *fcx;
1352   size_t len;
1353
1354   fp = INT2FD (fd);
1355
1356   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1357                    IOBUF_BUFFER_SIZE);
1358   fcx = xmalloc (sizeof *fcx + 20);
1359   fcx->fp = fp;
1360   fcx->print_only_name = 1;
1361   fcx->keep_open = keep_open;
1362   sprintf (fcx->fname, "[fd %d]", fd);
1363   a->filter = file_filter;
1364   a->filter_ov = fcx;
1365   file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1366   if (DBG_IOBUF)
1367     log_debug ("iobuf-%d.%d: fdopen%s '%s'\n",
1368                a->no, a->subno, keep_open? "_nc":"", fcx->fname);
1369   iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
1370   return a;
1371 }
1372
1373
1374 /* Create a head iobuf for reading or writing from/to a file Returns:
1375  * NULL and sets ERRNO if an error occured.  */
1376 iobuf_t
1377 iobuf_fdopen (int fd, const char *mode)
1378 {
1379   return do_iobuf_fdopen (fd, mode, 0);
1380 }
1381
1382 iobuf_t
1383 iobuf_fdopen_nc (int fd, const char *mode)
1384 {
1385   return do_iobuf_fdopen (fd, mode, 1);
1386 }
1387
1388
1389 iobuf_t
1390 iobuf_esopen (estream_t estream, const char *mode, int keep_open)
1391 {
1392   iobuf_t a;
1393   file_es_filter_ctx_t *fcx;
1394   size_t len;
1395
1396   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1397                    IOBUF_BUFFER_SIZE);
1398   fcx = xtrymalloc (sizeof *fcx + 30);
1399   fcx->fp = estream;
1400   fcx->print_only_name = 1;
1401   fcx->keep_open = keep_open;
1402   sprintf (fcx->fname, "[fd %p]", estream);
1403   a->filter = file_es_filter;
1404   a->filter_ov = fcx;
1405   file_es_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1406   if (DBG_IOBUF)
1407     log_debug ("iobuf-%d.%d: esopen%s '%s'\n",
1408                a->no, a->subno, keep_open? "_nc":"", fcx->fname);
1409   return a;
1410 }
1411
1412
1413 iobuf_t
1414 iobuf_sockopen (int fd, const char *mode)
1415 {
1416   iobuf_t a;
1417 #ifdef HAVE_W32_SYSTEM
1418   sock_filter_ctx_t *scx;
1419   size_t len;
1420
1421   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1422                    IOBUF_BUFFER_SIZE);
1423   scx = xmalloc (sizeof *scx + 25);
1424   scx->sock = fd;
1425   scx->print_only_name = 1;
1426   sprintf (scx->fname, "[sock %d]", fd);
1427   a->filter = sock_filter;
1428   a->filter_ov = scx;
1429   sock_filter (scx, IOBUFCTRL_INIT, NULL, NULL, &len);
1430   if (DBG_IOBUF)
1431     log_debug ("iobuf-%d.%d: sockopen '%s'\n", a->no, a->subno, scx->fname);
1432   iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
1433 #else
1434   a = iobuf_fdopen (fd, mode);
1435 #endif
1436   return a;
1437 }
1438
1439 /****************
1440  * Create an iobuf for writing to a file; the file will be created.
1441  * With MODE700 set the file is created with that mode (Unix only).
1442  */
1443 iobuf_t
1444 iobuf_create (const char *fname, int mode700)
1445 {
1446   iobuf_t a;
1447   gnupg_fd_t fp;
1448   file_filter_ctx_t *fcx;
1449   size_t len;
1450   int print_only = 0;
1451   int fd;
1452
1453   if (!fname || (*fname == '-' && !fname[1]))
1454     {
1455       fp = FD_FOR_STDOUT;
1456       fname = "[stdout]";
1457       print_only = 1;
1458     }
1459   else if ((fd = check_special_filename (fname)) != -1)
1460     return iobuf_fdopen (translate_file_handle (fd, 1), "wb");
1461   else if ((fp = direct_open (fname, "wb", mode700)) == GNUPG_INVALID_FD)
1462     return NULL;
1463   a = iobuf_alloc (IOBUF_OUTPUT, IOBUF_BUFFER_SIZE);
1464   fcx = xmalloc (sizeof *fcx + strlen (fname));
1465   fcx->fp = fp;
1466   fcx->print_only_name = print_only;
1467   strcpy (fcx->fname, fname);
1468   if (!print_only)
1469     a->real_fname = xstrdup (fname);
1470   a->filter = file_filter;
1471   a->filter_ov = fcx;
1472   file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1473   if (DBG_IOBUF)
1474     log_debug ("iobuf-%d.%d: create '%s'\n",
1475                a->no, a->subno, iobuf_desc (a));
1476
1477   return a;
1478 }
1479
1480
1481 iobuf_t
1482 iobuf_openrw (const char *fname)
1483 {
1484   iobuf_t a;
1485   gnupg_fd_t fp;
1486   file_filter_ctx_t *fcx;
1487   size_t len;
1488
1489   if (!fname)
1490     return NULL;
1491   else if ((fp = direct_open (fname, "r+b", 0)) == GNUPG_INVALID_FD)
1492     return NULL;
1493   a = iobuf_alloc (IOBUF_OUTPUT, IOBUF_BUFFER_SIZE);
1494   fcx = xmalloc (sizeof *fcx + strlen (fname));
1495   fcx->fp = fp;
1496   strcpy (fcx->fname, fname);
1497   a->real_fname = xstrdup (fname);
1498   a->filter = file_filter;
1499   a->filter_ov = fcx;
1500   file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1501   if (DBG_IOBUF)
1502     log_debug ("iobuf-%d.%d: openrw '%s'\n",
1503                a->no, a->subno, iobuf_desc (a));
1504
1505   return a;
1506 }
1507
1508
1509 int
1510 iobuf_ioctl (iobuf_t a, iobuf_ioctl_t cmd, int intval, void *ptrval)
1511 {
1512   if (cmd == IOBUF_IOCTL_KEEP_OPEN)
1513     {
1514       /* Keep system filepointer/descriptor open.  This was used in
1515          the past by http.c; this ioctl is not directly used
1516          anymore.  */
1517       if (DBG_IOBUF)
1518         log_debug ("iobuf-%d.%d: ioctl '%s' keep_open=%d\n",
1519                    a ? a->no : -1, a ? a->subno : -1, iobuf_desc (a),
1520                    intval);
1521       for (; a; a = a->chain)
1522         if (!a->chain && a->filter == file_filter)
1523           {
1524             file_filter_ctx_t *b = a->filter_ov;
1525             b->keep_open = intval;
1526             return 0;
1527           }
1528 #ifdef HAVE_W32_SYSTEM
1529         else if (!a->chain && a->filter == sock_filter)
1530           {
1531             sock_filter_ctx_t *b = a->filter_ov;
1532             b->keep_open = intval;
1533             return 0;
1534           }
1535 #endif
1536     }
1537   else if (cmd == IOBUF_IOCTL_INVALIDATE_CACHE)
1538     {
1539       if (DBG_IOBUF)
1540         log_debug ("iobuf-*.*: ioctl '%s' invalidate\n",
1541                    ptrval ? (char *) ptrval : "?");
1542       if (!a && !intval && ptrval)
1543         {
1544           if (fd_cache_invalidate (ptrval))
1545             return -1;
1546           return 0;
1547         }
1548     }
1549   else if (cmd == IOBUF_IOCTL_NO_CACHE)
1550     {
1551       if (DBG_IOBUF)
1552         log_debug ("iobuf-%d.%d: ioctl '%s' no_cache=%d\n",
1553                    a ? a->no : -1, a ? a->subno : -1, iobuf_desc (a),
1554                    intval);
1555       for (; a; a = a->chain)
1556         if (!a->chain && a->filter == file_filter)
1557           {
1558             file_filter_ctx_t *b = a->filter_ov;
1559             b->no_cache = intval;
1560             return 0;
1561           }
1562 #ifdef HAVE_W32_SYSTEM
1563         else if (!a->chain && a->filter == sock_filter)
1564           {
1565             sock_filter_ctx_t *b = a->filter_ov;
1566             b->no_cache = intval;
1567             return 0;
1568           }
1569 #endif
1570     }
1571   else if (cmd == IOBUF_IOCTL_FSYNC)
1572     {
1573       /* Do a fsync on the open fd and return any errors to the caller
1574          of iobuf_ioctl.  Note that we work on a file name here. */
1575       if (DBG_IOBUF)
1576         log_debug ("iobuf-*.*: ioctl '%s' fsync\n",
1577                    ptrval? (const char*)ptrval:"<null>");
1578
1579         if (!a && !intval && ptrval)
1580           {
1581             return fd_cache_synchronize (ptrval);
1582           }
1583       }
1584
1585
1586   return -1;
1587 }
1588
1589
1590 /****************
1591  * Register an i/o filter.
1592  */
1593 int
1594 iobuf_push_filter (iobuf_t a,
1595                    int (*f) (void *opaque, int control,
1596                              iobuf_t chain, byte * buf, size_t * len),
1597                    void *ov)
1598 {
1599   return iobuf_push_filter2 (a, f, ov, 0);
1600 }
1601
1602 int
1603 iobuf_push_filter2 (iobuf_t a,
1604                     int (*f) (void *opaque, int control,
1605                               iobuf_t chain, byte * buf, size_t * len),
1606                     void *ov, int rel_ov)
1607 {
1608   iobuf_t b;
1609   size_t dummy_len = 0;
1610   int rc = 0;
1611
1612   if (a->use == IOBUF_OUTPUT && (rc = filter_flush (a)))
1613     return rc;
1614
1615   if (a->subno >= MAX_NESTING_FILTER)
1616     {
1617       log_error ("i/o filter too deeply nested - corrupted data?\n");
1618       return GPG_ERR_BAD_DATA;
1619     }
1620
1621   /* make a copy of the current stream, so that
1622    * A is the new stream and B the original one.
1623    * The contents of the buffers are transferred to the
1624    * new stream.
1625    */
1626   b = xmalloc (sizeof *b);
1627   memcpy (b, a, sizeof *b);
1628   /* fixme: it is stupid to keep a copy of the name at every level
1629    * but we need the name somewhere because the name known by file_filter
1630    * may have been released when we need the name of the file */
1631   b->real_fname = a->real_fname ? xstrdup (a->real_fname) : NULL;
1632   /* remove the filter stuff from the new stream */
1633   a->filter = NULL;
1634   a->filter_ov = NULL;
1635   a->filter_ov_owner = 0;
1636   a->filter_eof = 0;
1637   if (a->use == IOBUF_TEMP)
1638     /* make a write stream from a temp stream */
1639     a->use = IOBUF_OUTPUT;
1640
1641   if (a->use == IOBUF_OUTPUT)
1642     {                           /* allocate a fresh buffer for the
1643                                    original stream */
1644       b->d.buf = xmalloc (a->d.size);
1645       b->d.len = 0;
1646       b->d.start = 0;
1647     }
1648   else
1649     {                           /* allocate a fresh buffer for the new
1650                                    stream */
1651       a->d.buf = xmalloc (a->d.size);
1652       a->d.len = 0;
1653       a->d.start = 0;
1654     }
1655   /* disable nlimit for the new stream */
1656   a->ntotal = b->ntotal + b->nbytes;
1657   a->nlimit = a->nbytes = 0;
1658   a->nofast = 0;
1659   /* make a link from the new stream to the original stream */
1660   a->chain = b;
1661
1662   /* setup the function on the new stream */
1663   a->filter = f;
1664   a->filter_ov = ov;
1665   a->filter_ov_owner = rel_ov;
1666
1667   a->subno = b->subno + 1;
1668
1669   if (DBG_IOBUF)
1670     {
1671       log_debug ("iobuf-%d.%d: push '%s'\n",
1672                  a->no, a->subno, iobuf_desc (a));
1673       print_chain (a);
1674     }
1675
1676   /* now we can initialize the new function if we have one */
1677   if (a->filter && (rc = a->filter (a->filter_ov, IOBUFCTRL_INIT, a->chain,
1678                                     NULL, &dummy_len)))
1679     log_error ("IOBUFCTRL_INIT failed: %s\n", gpg_strerror (rc));
1680   return rc;
1681 }
1682
1683 /****************
1684  * Remove an i/o filter.
1685  */
1686 static int
1687 pop_filter (iobuf_t a, int (*f) (void *opaque, int control,
1688                                iobuf_t chain, byte * buf, size_t * len),
1689             void *ov)
1690 {
1691   iobuf_t b;
1692   size_t dummy_len = 0;
1693   int rc = 0;
1694
1695   if (DBG_IOBUF)
1696     log_debug ("iobuf-%d.%d: pop '%s'\n",
1697                a->no, a->subno, iobuf_desc (a));
1698   if (!a->filter)
1699     {                           /* this is simple */
1700       b = a->chain;
1701       assert (b);
1702       xfree (a->d.buf);
1703       xfree (a->real_fname);
1704       memcpy (a, b, sizeof *a);
1705       xfree (b);
1706       return 0;
1707     }
1708   for (b = a; b; b = b->chain)
1709     if (b->filter == f && (!ov || b->filter_ov == ov))
1710       break;
1711   if (!b)
1712     log_bug ("pop_filter(): filter function not found\n");
1713
1714   /* flush this stream if it is an output stream */
1715   if (a->use == IOBUF_OUTPUT && (rc = filter_flush (b)))
1716     {
1717       log_error ("filter_flush failed in pop_filter: %s\n", gpg_strerror (rc));
1718       return rc;
1719     }
1720   /* and tell the filter to free it self */
1721   if (b->filter && (rc = b->filter (b->filter_ov, IOBUFCTRL_FREE, b->chain,
1722                                     NULL, &dummy_len)))
1723     {
1724       log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
1725       return rc;
1726     }
1727   if (b->filter_ov && b->filter_ov_owner)
1728     {
1729       xfree (b->filter_ov);
1730       b->filter_ov = NULL;
1731     }
1732
1733
1734   /* and see how to remove it */
1735   if (a == b && !b->chain)
1736     log_bug ("can't remove the last filter from the chain\n");
1737   else if (a == b)
1738     {                           /* remove the first iobuf from the chain */
1739       /* everything from b is copied to a. This is save because
1740        * a flush has been done on the to be removed entry
1741        */
1742       b = a->chain;
1743       xfree (a->d.buf);
1744       xfree (a->real_fname);
1745       memcpy (a, b, sizeof *a);
1746       xfree (b);
1747       if (DBG_IOBUF)
1748         log_debug ("iobuf-%d.%d: popped filter\n", a->no, a->subno);
1749     }
1750   else if (!b->chain)
1751     {                           /* remove the last iobuf from the chain */
1752       log_bug ("Ohh jeee, trying to remove a head filter\n");
1753     }
1754   else
1755     {                           /* remove an intermediate iobuf from the chain */
1756       log_bug ("Ohh jeee, trying to remove an intermediate filter\n");
1757     }
1758
1759   return rc;
1760 }
1761
1762
1763 /****************
1764  * read underflow: read more bytes into the buffer and return
1765  * the first byte or -1 on EOF.
1766  */
1767 static int
1768 underflow (iobuf_t a, int clear_pending_eof)
1769 {
1770   size_t len;
1771   int rc;
1772
1773   if (DBG_IOBUF)
1774     log_debug ("iobuf-%d.%d: underflow: buffer size: %d; still buffered: %d => space for %d bytes\n",
1775                a->no, a->subno,
1776                (int) a->d.size, (int) (a->d.len - a->d.start),
1777                (int) (a->d.size - (a->d.len - a->d.start)));
1778
1779   assert (a->use == IOBUF_INPUT);
1780
1781   /* If there is still some buffered data, then move it to the start
1782      of the buffer and try to fill the end of the buffer.  (This is
1783      useful if we are called from iobuf_peek().)  */
1784   assert (a->d.start <= a->d.len);
1785   a->d.len -= a->d.start;
1786   memmove (a->d.buf, &a->d.buf[a->d.start], a->d.len);
1787   a->d.start = 0;
1788
1789   if (a->d.len == 0 && a->filter_eof)
1790     /* The last time we tried to read from this filter, we got an EOF.
1791        We couldn't return the EOF, because there was buffered data.
1792        Since there is no longer any buffered data, return the
1793        error.  */
1794     {
1795       if (DBG_IOBUF)
1796         log_debug ("iobuf-%d.%d: underflow: eof (pending eof)\n",
1797                    a->no, a->subno);
1798       if (! clear_pending_eof)
1799         return -1;
1800
1801       if (a->chain)
1802         /* A filter follows this one.  Free this filter.  */
1803         {
1804           iobuf_t b = a->chain;
1805           if (DBG_IOBUF)
1806             log_debug ("iobuf-%d.%d: filter popped (pending EOF returned)\n",
1807                        a->no, a->subno);
1808           xfree (a->d.buf);
1809           xfree (a->real_fname);
1810           memcpy (a, b, sizeof *a);
1811           xfree (b);
1812           print_chain (a);
1813         }
1814       else
1815         a->filter_eof = 0;      /* for the top level filter */
1816       return -1;                /* return one(!) EOF */
1817     }
1818
1819   if (a->d.len == 0 && a->error)
1820     /* The last time we tried to read from this filter, we got an
1821        error.  We couldn't return the error, because there was
1822        buffered data.  Since there is no longer any buffered data,
1823        return the error.  */
1824     {
1825       if (DBG_IOBUF)
1826         log_debug ("iobuf-%d.%d: pending error (%s) returned\n",
1827                    a->no, a->subno, gpg_strerror (a->error));
1828       return -1;
1829     }
1830
1831   if (a->filter && ! a->filter_eof && ! a->error)
1832     /* We have a filter function and the last time we tried to read we
1833        didn't get an EOF or an error.  Try to fill the buffer.  */
1834     {
1835       /* Be careful to account for any buffered data.  */
1836       len = a->d.size - a->d.len;
1837       if (DBG_IOBUF)
1838         log_debug ("iobuf-%d.%d: underflow: A->FILTER (%lu bytes)\n",
1839                    a->no, a->subno, (ulong) len);
1840       if (len == 0)
1841         /* There is no space for more data.  Don't bother calling
1842            A->FILTER.  */
1843         rc = 0;
1844       else
1845         rc = a->filter (a->filter_ov, IOBUFCTRL_UNDERFLOW, a->chain,
1846                         &a->d.buf[a->d.len], &len);
1847       a->d.len += len;
1848
1849       if (DBG_IOBUF)
1850         log_debug ("iobuf-%d.%d: A->FILTER() returned rc=%d (%s), read %lu bytes\n",
1851                    a->no, a->subno,
1852                    rc, rc == 0 ? "ok" : rc == -1 ? "EOF" : gpg_strerror (rc),
1853                    (ulong) len);
1854 /*          if( a->no == 1 ) */
1855 /*                   log_hexdump ("     data:", a->d.buf, len); */
1856
1857       if (rc == -1)
1858         /* EOF.  */
1859         {
1860           size_t dummy_len = 0;
1861
1862           /* Tell the filter to free itself */
1863           if ((rc = a->filter (a->filter_ov, IOBUFCTRL_FREE, a->chain,
1864                                NULL, &dummy_len)))
1865             log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
1866
1867           /* Free everything except for the internal buffer.  */
1868           if (a->filter_ov && a->filter_ov_owner)
1869             xfree (a->filter_ov);
1870           a->filter_ov = NULL;
1871           a->filter = NULL;
1872           a->filter_eof = 1;
1873
1874           if (clear_pending_eof && a->d.len == 0 && a->chain)
1875             /* We don't need to keep this filter around at all:
1876
1877                  - we got an EOF
1878                  - we have no buffered data
1879                  - a filter follows this one.
1880
1881               Unlink this filter.  */
1882             {
1883               iobuf_t b = a->chain;
1884               if (DBG_IOBUF)
1885                 log_debug ("iobuf-%d.%d: pop in underflow (nothing buffered, got EOF)\n",
1886                            a->no, a->subno);
1887               xfree (a->d.buf);
1888               xfree (a->real_fname);
1889               memcpy (a, b, sizeof *a);
1890               xfree (b);
1891
1892               print_chain (a);
1893
1894               return -1;
1895             }
1896           else if (a->d.len == 0)
1897             /* We can't unlink this filter (it is the only one in the
1898                pipeline), but we can immediately return EOF.  */
1899             return -1;
1900         }
1901       else if (rc)
1902         /* Record the error.  */
1903         {
1904           a->error = rc;
1905
1906           if (a->d.len == 0)
1907             /* There is no buffered data.  Immediately return EOF.  */
1908             return -1;
1909         }
1910     }
1911
1912   assert (a->d.start <= a->d.len);
1913   if (a->d.start < a->d.len)
1914     return a->d.buf[a->d.start++];
1915
1916   /* EOF.  */
1917   return -1;
1918 }
1919
1920
1921 static int
1922 filter_flush (iobuf_t a)
1923 {
1924   size_t len;
1925   int rc;
1926
1927   if (a->use == IOBUF_TEMP)
1928     {                           /* increase the temp buffer */
1929       size_t newsize = a->d.size + IOBUF_BUFFER_SIZE;
1930
1931       if (DBG_IOBUF)
1932         log_debug ("increasing temp iobuf from %lu to %lu\n",
1933                    (ulong) a->d.size, (ulong) newsize);
1934
1935       a->d.buf = xrealloc (a->d.buf, newsize);
1936       a->d.size = newsize;
1937       return 0;
1938     }
1939   else if (a->use != IOBUF_OUTPUT)
1940     log_bug ("flush on non-output iobuf\n");
1941   else if (!a->filter)
1942     log_bug ("filter_flush: no filter\n");
1943   len = a->d.len;
1944   rc = a->filter (a->filter_ov, IOBUFCTRL_FLUSH, a->chain, a->d.buf, &len);
1945   if (!rc && len != a->d.len)
1946     {
1947       log_info ("filter_flush did not write all!\n");
1948       rc = GPG_ERR_INTERNAL;
1949     }
1950   else if (rc)
1951     a->error = rc;
1952   a->d.len = 0;
1953
1954   return rc;
1955 }
1956
1957
1958 /****************
1959  * Read a byte from the iobuf; returns -1 on EOF
1960  */
1961 int
1962 iobuf_readbyte (iobuf_t a)
1963 {
1964   int c;
1965
1966   if (a->nlimit && a->nbytes >= a->nlimit)
1967     return -1;                  /* forced EOF */
1968
1969   if (a->d.start < a->d.len)
1970     {
1971       c = a->d.buf[a->d.start++];
1972     }
1973   else if ((c = underflow (a, 1)) == -1)
1974     return -1;                  /* EOF */
1975
1976   a->nbytes++;
1977   return c;
1978 }
1979
1980
1981 int
1982 iobuf_read (iobuf_t a, void *buffer, unsigned int buflen)
1983 {
1984   unsigned char *buf = (unsigned char *)buffer;
1985   int c, n;
1986
1987   if (a->nlimit)
1988     {
1989       /* Handle special cases. */
1990       for (n = 0; n < buflen; n++)
1991         {
1992           if ((c = iobuf_readbyte (a)) == -1)
1993             {
1994               if (!n)
1995                 return -1;      /* eof */
1996               break;
1997             }
1998           else if (buf)
1999             *buf = c;
2000           if (buf)
2001             buf++;
2002         }
2003       return n;
2004     }
2005
2006   n = 0;
2007   do
2008     {
2009       if (n < buflen && a->d.start < a->d.len)
2010         {
2011           unsigned size = a->d.len - a->d.start;
2012           if (size > buflen - n)
2013             size = buflen - n;
2014           if (buf)
2015             memcpy (buf, a->d.buf + a->d.start, size);
2016           n += size;
2017           a->d.start += size;
2018           if (buf)
2019             buf += size;
2020         }
2021       if (n < buflen)
2022         {
2023           if ((c = underflow (a, 1)) == -1)
2024             {
2025               a->nbytes += n;
2026               return n ? n : -1 /*EOF*/;
2027             }
2028           if (buf)
2029             *buf++ = c;
2030           n++;
2031         }
2032     }
2033   while (n < buflen);
2034   a->nbytes += n;
2035   return n;
2036 }
2037
2038
2039
2040 int
2041 iobuf_peek (iobuf_t a, byte * buf, unsigned buflen)
2042 {
2043   int n = 0;
2044
2045   assert (buflen > 0);
2046   assert (a->use == IOBUF_INPUT);
2047
2048   if (buflen > a->d.size)
2049     /* We can't peek more than we can buffer.  */
2050     buflen = a->d.size;
2051
2052   /* Try to fill the internal buffer with enough data to satisfy the
2053      request.  */
2054   while (buflen > a->d.len - a->d.start)
2055     {
2056       if (underflow (a, 0) == -1)
2057         /* EOF.  We can't read any more.  */
2058         break;
2059
2060       /* Underflow consumes the first character (it's the return
2061          value).  unget() it by resetting the "file position".  */
2062       assert (a->d.start == 1);
2063       a->d.start = 0;
2064     }
2065
2066   n = a->d.len - a->d.start;
2067   if (n > buflen)
2068     n = buflen;
2069
2070   if (n == 0)
2071     /* EOF.  */
2072     return -1;
2073
2074   memcpy (buf, &a->d.buf[a->d.start], n);
2075
2076   return n;
2077 }
2078
2079
2080
2081
2082 int
2083 iobuf_writebyte (iobuf_t a, unsigned int c)
2084 {
2085   int rc;
2086
2087   if (a->d.len == a->d.size)
2088     if ((rc=filter_flush (a)))
2089       return rc;
2090
2091   assert (a->d.len < a->d.size);
2092   a->d.buf[a->d.len++] = c;
2093   return 0;
2094 }
2095
2096
2097 int
2098 iobuf_write (iobuf_t a, const void *buffer, unsigned int buflen)
2099 {
2100   const unsigned char *buf = (const unsigned char *)buffer;
2101   int rc;
2102
2103   do
2104     {
2105       if (buflen && a->d.len < a->d.size)
2106         {
2107           unsigned size = a->d.size - a->d.len;
2108           if (size > buflen)
2109             size = buflen;
2110           memcpy (a->d.buf + a->d.len, buf, size);
2111           buflen -= size;
2112           buf += size;
2113           a->d.len += size;
2114         }
2115       if (buflen)
2116         {
2117           rc = filter_flush (a);
2118           if (rc)
2119             return rc;
2120         }
2121     }
2122   while (buflen);
2123   return 0;
2124 }
2125
2126
2127 int
2128 iobuf_writestr (iobuf_t a, const char *buf)
2129 {
2130   int rc;
2131
2132   for (; *buf; buf++)
2133     if ((rc=iobuf_writebyte (a, *buf)))
2134       return rc;
2135   return 0;
2136 }
2137
2138
2139
2140 /****************
2141  * copy the contents of TEMP to A.
2142  */
2143 int
2144 iobuf_write_temp (iobuf_t a, iobuf_t temp)
2145 {
2146   while (temp->chain)
2147     pop_filter (temp, temp->filter, NULL);
2148   return iobuf_write (a, temp->d.buf, temp->d.len);
2149 }
2150
2151 /****************
2152  * copy the contents of the temp io stream to BUFFER.
2153  */
2154 size_t
2155 iobuf_temp_to_buffer (iobuf_t a, byte * buffer, size_t buflen)
2156 {
2157   size_t n = a->d.len;
2158
2159   if (n > buflen)
2160     n = buflen;
2161   memcpy (buffer, a->d.buf, n);
2162   return n;
2163 }
2164
2165
2166 /****************
2167  * Call this function to terminate processing of the temp stream
2168  * without closing it.  This removes all filters from the stream
2169  * makes sure that iobuf_get_temp_{buffer,length}() returns correct
2170  * values.
2171  */
2172 void
2173 iobuf_flush_temp (iobuf_t temp)
2174 {
2175   while (temp->chain)
2176     pop_filter (temp, temp->filter, NULL);
2177 }
2178
2179
2180 /****************
2181  * Set a limit on how many bytes may be read from the input stream A.
2182  * Setting the limit to 0 disables this feature.
2183  */
2184 void
2185 iobuf_set_limit (iobuf_t a, off_t nlimit)
2186 {
2187   if (nlimit)
2188     a->nofast = 1;
2189   else
2190     a->nofast = 0;
2191   a->nlimit = nlimit;
2192   a->ntotal += a->nbytes;
2193   a->nbytes = 0;
2194 }
2195
2196
2197
2198 /* Return the length of an open file A.  IF OVERFLOW is not NULL it
2199    will be set to true if the file is larger than what off_t can cope
2200    with.  The function return 0 on error or on overflow condition.  */
2201 off_t
2202 iobuf_get_filelength (iobuf_t a, int *overflow)
2203 {
2204   struct stat st;
2205
2206   if (overflow)
2207     *overflow = 0;
2208
2209   /* Hmmm: file_filter may have already been removed */
2210   for ( ; a; a = a->chain )
2211     if ( !a->chain && a->filter == file_filter )
2212       {
2213         file_filter_ctx_t *b = a->filter_ov;
2214         gnupg_fd_t fp = b->fp;
2215
2216 #if defined(HAVE_W32_SYSTEM)
2217         ulong size;
2218         static int (* __stdcall get_file_size_ex) (void *handle,
2219                                                    LARGE_INTEGER *r_size);
2220         static int get_file_size_ex_initialized;
2221
2222         if (!get_file_size_ex_initialized)
2223           {
2224             void *handle;
2225
2226             handle = dlopen ("kernel32.dll", RTLD_LAZY);
2227             if (handle)
2228               {
2229                 get_file_size_ex = dlsym (handle, "GetFileSizeEx");
2230                 if (!get_file_size_ex)
2231                   dlclose (handle);
2232               }
2233             get_file_size_ex_initialized = 1;
2234           }
2235
2236         if (get_file_size_ex)
2237           {
2238             /* This is a newer system with GetFileSizeEx; we use this
2239                then because it seem that GetFileSize won't return a
2240                proper error in case a file is larger than 4GB. */
2241             LARGE_INTEGER exsize;
2242
2243             if (get_file_size_ex (fp, &exsize))
2244               {
2245                 if (!exsize.u.HighPart)
2246                   return exsize.u.LowPart;
2247                 if (overflow)
2248                   *overflow = 1;
2249                 return 0;
2250               }
2251           }
2252         else
2253           {
2254             if ((size=GetFileSize (fp, NULL)) != 0xffffffff)
2255               return size;
2256           }
2257         log_error ("GetFileSize for handle %p failed: %s\n",
2258                    fp, w32_strerror (0));
2259 #else
2260         if ( !fstat (FD2INT (fp), &st) )
2261           return st.st_size;
2262         log_error("fstat() failed: %s\n", strerror(errno) );
2263 #endif
2264         break/*the for loop*/;
2265       }
2266
2267     return 0;
2268 }
2269
2270
2271 /* Return the file descriptor of the underlying file or -1 if it is
2272    not available.  */
2273 int
2274 iobuf_get_fd (iobuf_t a)
2275 {
2276   for ( ; a; a = a->chain )
2277     if (!a->chain && a->filter == file_filter)
2278       {
2279         file_filter_ctx_t *b = a->filter_ov;
2280         gnupg_fd_t fp = b->fp;
2281
2282         return FD2INT (fp);
2283       }
2284
2285   return -1;
2286 }
2287
2288
2289
2290 /****************
2291  * Tell the file position, where the next read will take place
2292  */
2293 off_t
2294 iobuf_tell (iobuf_t a)
2295 {
2296   return a->ntotal + a->nbytes;
2297 }
2298
2299
2300 #if !defined(HAVE_FSEEKO) && !defined(fseeko)
2301
2302 #ifdef HAVE_LIMITS_H
2303 # include <limits.h>
2304 #endif
2305 #ifndef LONG_MAX
2306 # define LONG_MAX ((long) ((unsigned long) -1 >> 1))
2307 #endif
2308 #ifndef LONG_MIN
2309 # define LONG_MIN (-1 - LONG_MAX)
2310 #endif
2311
2312 /****************
2313  * A substitute for fseeko, for hosts that don't have it.
2314  */
2315 static int
2316 fseeko (FILE * stream, off_t newpos, int whence)
2317 {
2318   while (newpos != (long) newpos)
2319     {
2320       long pos = newpos < 0 ? LONG_MIN : LONG_MAX;
2321       if (fseek (stream, pos, whence) != 0)
2322         return -1;
2323       newpos -= pos;
2324       whence = SEEK_CUR;
2325     }
2326   return fseek (stream, (long) newpos, whence);
2327 }
2328 #endif
2329
2330 /****************
2331  * This is a very limited implementation. It simply discards all internal
2332  * buffering and removes all filters but the first one.
2333  */
2334 int
2335 iobuf_seek (iobuf_t a, off_t newpos)
2336 {
2337   file_filter_ctx_t *b = NULL;
2338
2339   if (a->use != IOBUF_TEMP)
2340     {
2341       for (; a; a = a->chain)
2342         {
2343           if (!a->chain && a->filter == file_filter)
2344             {
2345               b = a->filter_ov;
2346               break;
2347             }
2348         }
2349       if (!a)
2350         return -1;
2351 #ifdef HAVE_W32_SYSTEM
2352       if (SetFilePointer (b->fp, newpos, NULL, FILE_BEGIN) == 0xffffffff)
2353         {
2354           log_error ("SetFilePointer failed on handle %p: ec=%d\n",
2355                      b->fp, (int) GetLastError ());
2356           return -1;
2357         }
2358 #else
2359       if (lseek (b->fp, newpos, SEEK_SET) == (off_t) - 1)
2360         {
2361           log_error ("can't lseek: %s\n", strerror (errno));
2362           return -1;
2363         }
2364 #endif
2365     }
2366   /* Discard the buffer unless it is a temp stream.  */
2367   if (a->use != IOBUF_TEMP)
2368     a->d.len = 0;
2369   a->d.start = 0;
2370   a->nbytes = 0;
2371   a->nlimit = 0;
2372   a->nofast = 0;
2373   a->ntotal = newpos;
2374   a->error = 0;
2375   /* remove filters, but the last */
2376   if (a->chain)
2377     log_debug ("pop_filter called in iobuf_seek - please report\n");
2378   while (a->chain)
2379     pop_filter (a, a->filter, NULL);
2380
2381   return 0;
2382 }
2383
2384
2385
2386
2387
2388
2389 /****************
2390  * Retrieve the real filename.  This is the filename actually used on
2391  * disk and not a made up one.  Returns NULL if no real filename is
2392  * available.
2393  */
2394 const char *
2395 iobuf_get_real_fname (iobuf_t a)
2396 {
2397   if (a->real_fname)
2398     return a->real_fname;
2399
2400   /* the old solution */
2401   for (; a; a = a->chain)
2402     if (!a->chain && a->filter == file_filter)
2403       {
2404         file_filter_ctx_t *b = a->filter_ov;
2405         return b->print_only_name ? NULL : b->fname;
2406       }
2407
2408   return NULL;
2409 }
2410
2411
2412 /****************
2413  * Retrieve the filename.  This name should only be used in diagnostics.
2414  */
2415 const char *
2416 iobuf_get_fname (iobuf_t a)
2417 {
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->fname;
2423       }
2424   return NULL;
2425 }
2426
2427 /* Same as iobuf_get_fname but never returns NULL.  */
2428 const char *
2429 iobuf_get_fname_nonnull (iobuf_t a)
2430 {
2431   const char *fname;
2432
2433   fname = iobuf_get_fname (a);
2434   return fname? fname : "[?]";
2435 }
2436
2437
2438 /****************
2439  * enable partial block mode as described in the OpenPGP draft.
2440  * LEN is the first length byte on read, but ignored on writes.
2441  */
2442 void
2443 iobuf_set_partial_block_mode (iobuf_t a, size_t len)
2444 {
2445   block_filter_ctx_t *ctx = xcalloc (1, sizeof *ctx);
2446
2447   assert (a->use == IOBUF_INPUT || a->use == IOBUF_OUTPUT);
2448   ctx->use = a->use;
2449   if (!len)
2450     {
2451       if (a->use == IOBUF_INPUT)
2452         log_debug ("pop_filter called in set_partial_block_mode"
2453                    " - please report\n");
2454       pop_filter (a, block_filter, NULL);
2455     }
2456   else
2457     {
2458       ctx->partial = 1;
2459       ctx->size = 0;
2460       ctx->first_c = len;
2461       iobuf_push_filter (a, block_filter, ctx);
2462     }
2463 }
2464
2465
2466
2467 /****************
2468  * Same as fgets() but if the buffer is too short a larger one will
2469  * be allocated up to some limit *max_length.
2470  * A line is considered a byte stream ending in a LF.
2471  * Returns the length of the line. EOF is indicated by a line of
2472  * length zero. The last LF may be missing due to an EOF.
2473  * is max_length is zero on return, the line has been truncated.
2474  *
2475  * Note: The buffer is allocated with enough space to append a CR,LF,EOL
2476  */
2477 unsigned int
2478 iobuf_read_line (iobuf_t a, byte ** addr_of_buffer,
2479                  unsigned *length_of_buffer, unsigned *max_length)
2480 {
2481   int c;
2482   char *buffer = (char *)*addr_of_buffer;
2483   unsigned length = *length_of_buffer;
2484   unsigned nbytes = 0;
2485   unsigned maxlen = *max_length;
2486   char *p;
2487
2488   /* The code assumes that we have space for at least a newline and a
2489      NUL character in the buffer.  This requires at least 2 bytes.  We
2490      don't complicate the code by handling the stupid corner case, but
2491      simply assert that it can't happen.  */
2492   assert (length >= 2 || maxlen >= 2);
2493
2494   if (!buffer || length <= 1)
2495     /* must allocate a new buffer */
2496     {
2497       length = 256 <= maxlen ? 256 : maxlen;
2498       buffer = xrealloc (buffer, length);
2499       *addr_of_buffer = (unsigned char *)buffer;
2500       *length_of_buffer = length;
2501     }
2502
2503   p = buffer;
2504   while ((c = iobuf_get (a)) != -1)
2505     {
2506       *p++ = c;
2507       nbytes++;
2508       if (c == '\n')
2509         break;
2510
2511       if (nbytes == length - 1)
2512         /* We don't have enough space to add a \n and a \0.  Increase
2513            the buffer size.  */
2514         {
2515           if (length == maxlen)
2516             /* We reached the buffer's size limit!  */
2517             {
2518               /* Skip the rest of the line.  */
2519               while (c != '\n' && (c = iobuf_get (a)) != -1)
2520                 ;
2521
2522               /* p is pointing at the last byte in the buffer.  We
2523                  always terminate the line with "\n\0" so overwrite
2524                  the previous byte with a \n.  */
2525               assert (p > buffer);
2526               p[-1] = '\n';
2527
2528               /* Indicate truncation.  */
2529               *max_length = 0;
2530               break;
2531             }
2532
2533           length += length < 1024 ? 256 : 1024;
2534           if (length > maxlen)
2535             length = maxlen;
2536
2537           buffer = xrealloc (buffer, length);
2538           *addr_of_buffer = (unsigned char *)buffer;
2539           *length_of_buffer = length;
2540           p = buffer + nbytes;
2541         }
2542     }
2543   /* Add the terminating NUL.  */
2544   *p = 0;
2545
2546   /* Return the number of characters written to the buffer including
2547      the newline, but not including the terminating NUL.  */
2548   return nbytes;
2549 }
2550
2551 static int
2552 translate_file_handle (int fd, int for_write)
2553 {
2554 #if defined(HAVE_W32CE_SYSTEM)
2555   /* This is called only with one of the special filenames.  Under
2556      W32CE the FD here is not a file descriptor but a rendezvous id,
2557      thus we need to finish the pipe first.  */
2558   fd = _assuan_w32ce_finish_pipe (fd, for_write);
2559 #elif defined(HAVE_W32_SYSTEM)
2560   {
2561     int x;
2562
2563     (void)for_write;
2564
2565     if (fd == 0)
2566       x = (int) GetStdHandle (STD_INPUT_HANDLE);
2567     else if (fd == 1)
2568       x = (int) GetStdHandle (STD_OUTPUT_HANDLE);
2569     else if (fd == 2)
2570       x = (int) GetStdHandle (STD_ERROR_HANDLE);
2571     else
2572       x = fd;
2573
2574     if (x == -1)
2575       log_debug ("GetStdHandle(%d) failed: ec=%d\n",
2576                  fd, (int) GetLastError ());
2577
2578     fd = x;
2579   }
2580 #else
2581   (void)for_write;
2582 #endif
2583   return fd;
2584 }
2585
2586
2587 void
2588 iobuf_skip_rest (iobuf_t a, unsigned long n, int partial)
2589 {
2590   if ( partial )
2591     {
2592       for (;;)
2593         {
2594           if (a->nofast || a->d.start >= a->d.len)
2595             {
2596               if (iobuf_readbyte (a) == -1)
2597                 {
2598                   break;
2599                 }
2600             }
2601           else
2602             {
2603               unsigned long count = a->d.len - a->d.start;
2604               a->nbytes += count;
2605               a->d.start = a->d.len;
2606             }
2607         }
2608     }
2609   else
2610     {
2611       unsigned long remaining = n;
2612       while (remaining > 0)
2613         {
2614           if (a->nofast || a->d.start >= a->d.len)
2615             {
2616               if (iobuf_readbyte (a) == -1)
2617                 {
2618                   break;
2619                 }
2620               --remaining;
2621             }
2622           else
2623             {
2624               unsigned long count = a->d.len - a->d.start;
2625               if (count > remaining)
2626                 {
2627                   count = remaining;
2628                 }
2629               a->nbytes += count;
2630               a->d.start += count;
2631               remaining -= count;
2632             }
2633         }
2634     }
2635 }