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