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