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