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