common/iobuf: Improve documentation and code comments.
[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
1104   a = xcalloc (1, sizeof *a);
1105   a->use = use;
1106   a->d.buf = xmalloc (bufsize);
1107   a->d.size = bufsize;
1108   a->no = ++number;
1109   a->subno = 0;
1110   a->real_fname = NULL;
1111   return a;
1112 }
1113
1114 int
1115 iobuf_close (iobuf_t a)
1116 {
1117   iobuf_t a_chain;
1118   size_t dummy_len = 0;
1119   int rc = 0;
1120
1121   for (; a; a = a_chain)
1122     {
1123       int rc2 = 0;
1124
1125       a_chain = a->chain;
1126
1127       if (a->use == IOBUF_OUTPUT && (rc = filter_flush (a)))
1128         log_error ("filter_flush failed on close: %s\n", gpg_strerror (rc));
1129
1130       if (DBG_IOBUF)
1131         log_debug ("iobuf-%d.%d: close '%s'\n",
1132                    a->no, a->subno, iobuf_desc (a));
1133
1134       if (a->filter && (rc2 = a->filter (a->filter_ov, IOBUFCTRL_FREE,
1135                                          a->chain, NULL, &dummy_len)))
1136         log_error ("IOBUFCTRL_FREE failed on close: %s\n", gpg_strerror (rc));
1137       if (! rc && rc2)
1138         /* Whoops!  An error occured.  Save it in RC if we haven't
1139            already recorded an error.  */
1140         rc = rc2;
1141
1142       xfree (a->real_fname);
1143       if (a->d.buf)
1144         {
1145           memset (a->d.buf, 0, a->d.size);      /* erase the buffer */
1146           xfree (a->d.buf);
1147         }
1148       xfree (a);
1149     }
1150   return rc;
1151 }
1152
1153 int
1154 iobuf_cancel (iobuf_t a)
1155 {
1156   const char *s;
1157   iobuf_t a2;
1158   int rc;
1159 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1160   char *remove_name = NULL;
1161 #endif
1162
1163   if (a && a->use == IOBUF_OUTPUT)
1164     {
1165       s = iobuf_get_real_fname (a);
1166       if (s && *s)
1167         {
1168 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1169           remove_name = xstrdup (s);
1170 #else
1171           remove (s);
1172 #endif
1173         }
1174     }
1175
1176   /* send a cancel message to all filters */
1177   for (a2 = a; a2; a2 = a2->chain)
1178     {
1179       size_t dummy;
1180       if (a2->filter)
1181         a2->filter (a2->filter_ov, IOBUFCTRL_CANCEL, a2->chain, NULL, &dummy);
1182     }
1183
1184   rc = iobuf_close (a);
1185 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1186   if (remove_name)
1187     {
1188       /* Argg, MSDOS does not allow to remove open files.  So
1189        * we have to do it here */
1190 #ifdef HAVE_W32CE_SYSTEM
1191       wchar_t *wtmp = utf8_to_wchar (remove_name);
1192       if (wtmp)
1193         DeleteFile (wtmp);
1194       xfree (wtmp);
1195 #else
1196       remove (remove_name);
1197 #endif
1198       xfree (remove_name);
1199     }
1200 #endif
1201   return rc;
1202 }
1203
1204
1205 iobuf_t
1206 iobuf_temp (void)
1207 {
1208   return iobuf_alloc (IOBUF_TEMP, IOBUF_BUFFER_SIZE);
1209 }
1210
1211 iobuf_t
1212 iobuf_temp_with_content (const char *buffer, size_t length)
1213 {
1214   iobuf_t a;
1215   int i;
1216
1217   a = iobuf_alloc (IOBUF_INPUT, length);
1218   /* memcpy (a->d.buf, buffer, length); */
1219   for (i=0; i < length; i++)
1220     a->d.buf[i] = buffer[i];
1221   a->d.len = length;
1222
1223   return a;
1224 }
1225
1226 void
1227 iobuf_enable_special_filenames (int yes)
1228 {
1229   special_names_enabled = yes;
1230 }
1231
1232
1233 /* See whether the filename has the form "-&nnnn", where n is a
1234    non-zero number.  Returns this number or -1 if it is not the
1235    case.  */
1236 static int
1237 check_special_filename (const char *fname)
1238 {
1239   if (special_names_enabled && fname && *fname == '-' && fname[1] == '&')
1240     {
1241       int i;
1242
1243       fname += 2;
1244       for (i = 0; digitp (fname+i); i++)
1245         ;
1246       if (!fname[i])
1247         return atoi (fname);
1248     }
1249   return -1;
1250 }
1251
1252
1253 int
1254 iobuf_is_pipe_filename (const char *fname)
1255 {
1256   if (!fname || (*fname=='-' && !fname[1]) )
1257     return 1;
1258   return check_special_filename (fname) != -1;
1259 }
1260
1261 static iobuf_t
1262 do_open (const char *fname, int special_filenames,
1263          int use, const char *opentype, int mode700)
1264 {
1265   iobuf_t a;
1266   gnupg_fd_t fp;
1267   file_filter_ctx_t *fcx;
1268   size_t len = 0;
1269   int print_only = 0;
1270   int fd;
1271
1272   if (special_filenames
1273       /* NULL or '-'.  */
1274       && (!fname || (*fname == '-' && !fname[1])))
1275     {
1276       if (use == IOBUF_INPUT)
1277         {
1278           fp = FD_FOR_STDIN;
1279           fname = "[stdin]";
1280         }
1281       else
1282         {
1283           fp = FD_FOR_STDOUT;
1284           fname = "[stdout]";
1285         }
1286       print_only = 1;
1287     }
1288   else if (!fname)
1289     return NULL;
1290   else if (special_filenames && (fd = check_special_filename (fname)) != -1)
1291     return iobuf_fdopen (translate_file_handle (fd, use == IOBUF_INPUT ? 0 : 1),
1292                          opentype);
1293   else
1294     {
1295       if (use == IOBUF_INPUT)
1296         fp = fd_cache_open (fname, opentype);
1297       else
1298         fp = direct_open (fname, opentype, mode700);
1299       if (fp == GNUPG_INVALID_FD)
1300         return NULL;
1301     }
1302
1303   a = iobuf_alloc (use, IOBUF_BUFFER_SIZE);
1304   fcx = xmalloc (sizeof *fcx + strlen (fname));
1305   fcx->fp = fp;
1306   fcx->print_only_name = print_only;
1307   strcpy (fcx->fname, fname);
1308   if (!print_only)
1309     a->real_fname = xstrdup (fname);
1310   a->filter = file_filter;
1311   a->filter_ov = fcx;
1312   file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1313   if (DBG_IOBUF)
1314     log_debug ("iobuf-%d.%d: open '%s' desc=%s fd=%d\n",
1315                a->no, a->subno, fname, iobuf_desc (a), FD2INT (fcx->fp));
1316
1317   return a;
1318 }
1319
1320 iobuf_t
1321 iobuf_open (const char *fname)
1322 {
1323   return do_open (fname, 1, IOBUF_INPUT, "rb", 0);
1324 }
1325
1326 iobuf_t
1327 iobuf_create (const char *fname, int mode700)
1328 {
1329   return do_open (fname, 1, IOBUF_OUTPUT, "wb", mode700);
1330 }
1331
1332 iobuf_t
1333 iobuf_openrw (const char *fname)
1334 {
1335   return do_open (fname, 0, IOBUF_OUTPUT, "r+b", 0);
1336 }
1337
1338
1339 static iobuf_t
1340 do_iobuf_fdopen (int fd, const char *mode, int keep_open)
1341 {
1342   iobuf_t a;
1343   gnupg_fd_t fp;
1344   file_filter_ctx_t *fcx;
1345   size_t len;
1346
1347   fp = INT2FD (fd);
1348
1349   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1350                    IOBUF_BUFFER_SIZE);
1351   fcx = xmalloc (sizeof *fcx + 20);
1352   fcx->fp = fp;
1353   fcx->print_only_name = 1;
1354   fcx->keep_open = keep_open;
1355   sprintf (fcx->fname, "[fd %d]", fd);
1356   a->filter = file_filter;
1357   a->filter_ov = fcx;
1358   file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1359   if (DBG_IOBUF)
1360     log_debug ("iobuf-%d.%d: fdopen%s '%s'\n",
1361                a->no, a->subno, keep_open? "_nc":"", fcx->fname);
1362   iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
1363   return a;
1364 }
1365
1366
1367 iobuf_t
1368 iobuf_fdopen (int fd, const char *mode)
1369 {
1370   return do_iobuf_fdopen (fd, mode, 0);
1371 }
1372
1373 iobuf_t
1374 iobuf_fdopen_nc (int fd, const char *mode)
1375 {
1376   return do_iobuf_fdopen (fd, mode, 1);
1377 }
1378
1379
1380 iobuf_t
1381 iobuf_esopen (estream_t estream, const char *mode, int keep_open)
1382 {
1383   iobuf_t a;
1384   file_es_filter_ctx_t *fcx;
1385   size_t len;
1386
1387   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1388                    IOBUF_BUFFER_SIZE);
1389   fcx = xtrymalloc (sizeof *fcx + 30);
1390   fcx->fp = estream;
1391   fcx->print_only_name = 1;
1392   fcx->keep_open = keep_open;
1393   sprintf (fcx->fname, "[fd %p]", estream);
1394   a->filter = file_es_filter;
1395   a->filter_ov = fcx;
1396   file_es_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1397   if (DBG_IOBUF)
1398     log_debug ("iobuf-%d.%d: esopen%s '%s'\n",
1399                a->no, a->subno, keep_open? "_nc":"", fcx->fname);
1400   return a;
1401 }
1402
1403
1404 iobuf_t
1405 iobuf_sockopen (int fd, const char *mode)
1406 {
1407   iobuf_t a;
1408 #ifdef HAVE_W32_SYSTEM
1409   sock_filter_ctx_t *scx;
1410   size_t len;
1411
1412   a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1413                    IOBUF_BUFFER_SIZE);
1414   scx = xmalloc (sizeof *scx + 25);
1415   scx->sock = fd;
1416   scx->print_only_name = 1;
1417   sprintf (scx->fname, "[sock %d]", fd);
1418   a->filter = sock_filter;
1419   a->filter_ov = scx;
1420   sock_filter (scx, IOBUFCTRL_INIT, NULL, NULL, &len);
1421   if (DBG_IOBUF)
1422     log_debug ("iobuf-%d.%d: sockopen '%s'\n", a->no, a->subno, scx->fname);
1423   iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
1424 #else
1425   a = iobuf_fdopen (fd, mode);
1426 #endif
1427   return a;
1428 }
1429
1430 int
1431 iobuf_ioctl (iobuf_t a, iobuf_ioctl_t cmd, int intval, void *ptrval)
1432 {
1433   if (cmd == IOBUF_IOCTL_KEEP_OPEN)
1434     {
1435       /* Keep system filepointer/descriptor open.  This was used in
1436          the past by http.c; this ioctl is not directly used
1437          anymore.  */
1438       if (DBG_IOBUF)
1439         log_debug ("iobuf-%d.%d: ioctl '%s' keep_open=%d\n",
1440                    a ? a->no : -1, a ? a->subno : -1, iobuf_desc (a),
1441                    intval);
1442       for (; a; a = a->chain)
1443         if (!a->chain && a->filter == file_filter)
1444           {
1445             file_filter_ctx_t *b = a->filter_ov;
1446             b->keep_open = intval;
1447             return 0;
1448           }
1449 #ifdef HAVE_W32_SYSTEM
1450         else if (!a->chain && a->filter == sock_filter)
1451           {
1452             sock_filter_ctx_t *b = a->filter_ov;
1453             b->keep_open = intval;
1454             return 0;
1455           }
1456 #endif
1457     }
1458   else if (cmd == IOBUF_IOCTL_INVALIDATE_CACHE)
1459     {
1460       if (DBG_IOBUF)
1461         log_debug ("iobuf-*.*: ioctl '%s' invalidate\n",
1462                    ptrval ? (char *) ptrval : "?");
1463       if (!a && !intval && ptrval)
1464         {
1465           if (fd_cache_invalidate (ptrval))
1466             return -1;
1467           return 0;
1468         }
1469     }
1470   else if (cmd == IOBUF_IOCTL_NO_CACHE)
1471     {
1472       if (DBG_IOBUF)
1473         log_debug ("iobuf-%d.%d: ioctl '%s' no_cache=%d\n",
1474                    a ? a->no : -1, a ? a->subno : -1, iobuf_desc (a),
1475                    intval);
1476       for (; a; a = a->chain)
1477         if (!a->chain && a->filter == file_filter)
1478           {
1479             file_filter_ctx_t *b = a->filter_ov;
1480             b->no_cache = intval;
1481             return 0;
1482           }
1483 #ifdef HAVE_W32_SYSTEM
1484         else if (!a->chain && a->filter == sock_filter)
1485           {
1486             sock_filter_ctx_t *b = a->filter_ov;
1487             b->no_cache = intval;
1488             return 0;
1489           }
1490 #endif
1491     }
1492   else if (cmd == IOBUF_IOCTL_FSYNC)
1493     {
1494       /* Do a fsync on the open fd and return any errors to the caller
1495          of iobuf_ioctl.  Note that we work on a file name here. */
1496       if (DBG_IOBUF)
1497         log_debug ("iobuf-*.*: ioctl '%s' fsync\n",
1498                    ptrval? (const char*)ptrval:"<null>");
1499
1500         if (!a && !intval && ptrval)
1501           {
1502             return fd_cache_synchronize (ptrval);
1503           }
1504       }
1505
1506
1507   return -1;
1508 }
1509
1510
1511 /****************
1512  * Register an i/o filter.
1513  */
1514 int
1515 iobuf_push_filter (iobuf_t a,
1516                    int (*f) (void *opaque, int control,
1517                              iobuf_t chain, byte * buf, size_t * len),
1518                    void *ov)
1519 {
1520   return iobuf_push_filter2 (a, f, ov, 0);
1521 }
1522
1523 int
1524 iobuf_push_filter2 (iobuf_t a,
1525                     int (*f) (void *opaque, int control,
1526                               iobuf_t chain, byte * buf, size_t * len),
1527                     void *ov, int rel_ov)
1528 {
1529   iobuf_t b;
1530   size_t dummy_len = 0;
1531   int rc = 0;
1532
1533   if (a->use == IOBUF_OUTPUT && (rc = filter_flush (a)))
1534     return rc;
1535
1536   if (a->subno >= MAX_NESTING_FILTER)
1537     {
1538       log_error ("i/o filter too deeply nested - corrupted data?\n");
1539       return GPG_ERR_BAD_DATA;
1540     }
1541
1542   /* We want to create a new filter and put it in front of A.  A
1543      simple implementation would do:
1544
1545        b = iobuf_alloc (...);
1546        b->chain = a;
1547        return a;
1548
1549      This is a bit problematic: A is the head of the pipeline and
1550      there are potentially many pointers to it.  Requiring the caller
1551      to update all of these pointers is a burden.
1552
1553      An alternative implementation would add a level of indirection.
1554      For instance, we could use a pipeline object, which contains a
1555      pointer to the first filter in the pipeline.  This is not what we
1556      do either.
1557
1558      Instead, we allocate a new buffer (B) and copy the first filter's
1559      state into that and use the initial buffer (A) for the new
1560      filter.  One limitation of this approach is that it is not
1561      practical to maintain a pointer to a specific filter's state.
1562
1563      Before:
1564
1565            A
1566            |
1567            v 0x100               0x200
1568            +----------+          +----------+
1569            | filter x |--------->| filter y |---->....
1570            +----------+          +----------+
1571
1572      After:           B
1573                       |
1574                       v 0x300
1575                       +----------+
1576            A          | filter x |
1577            |          +----------+
1578            v 0x100    ^          v 0x200
1579            +----------+          +----------+
1580            | filter w |          | filter y |---->....
1581            +----------+          +----------+
1582
1583      Note: filter x's address changed from 0x100 to 0x300, but A still
1584      points to the head of the pipeline.
1585   */
1586
1587   b = xmalloc (sizeof *b);
1588   memcpy (b, a, sizeof *b);
1589   /* fixme: it is stupid to keep a copy of the name at every level
1590    * but we need the name somewhere because the name known by file_filter
1591    * may have been released when we need the name of the file */
1592   b->real_fname = a->real_fname ? xstrdup (a->real_fname) : NULL;
1593   /* remove the filter stuff from the new stream */
1594   a->filter = NULL;
1595   a->filter_ov = NULL;
1596   a->filter_ov_owner = 0;
1597   a->filter_eof = 0;
1598   if (a->use == IOBUF_TEMP)
1599     /* A TEMP filter buffers any data sent to it; it does not forward
1600        any data down the pipeline.  If we add a new filter to the
1601        pipeline, it shouldn't also buffer data.  It should send it
1602        downstream to be buffered.  Thus, the correct type for a filter
1603        added in front of an IOBUF_TEMP filter is IOBUF_OUPUT, not
1604        IOBUF_TEMP.  */
1605     {
1606       a->use = IOBUF_OUTPUT;
1607
1608       /* When pipeline is written to, the temp buffer's size is
1609          increased accordingly.  We don't need to allocate a 10 MB
1610          buffer for a non-terminal filter.  Just use the default
1611          size.  */
1612       a->d.size = IOBUF_BUFFER_SIZE;
1613     }
1614
1615   /* The new filter (A) gets a new buffer.
1616
1617      If the pipeline is an output or temp pipeline, then giving the
1618      buffer to the new filter means that data that was written before
1619      the filter was pushed gets sent to the filter.  That's clearly
1620      wrong.
1621
1622      If the pipeline is an input pipeline, then giving the buffer to
1623      the new filter (A) means that data that has read from (B), but
1624      not yet read from the pipeline won't be processed by the new
1625      filter (A)!  That's certainly not what we want.  */
1626   a->d.buf = xmalloc (a->d.size);
1627   a->d.len = 0;
1628   a->d.start = 0;
1629
1630   /* disable nlimit for the new stream */
1631   a->ntotal = b->ntotal + b->nbytes;
1632   a->nlimit = a->nbytes = 0;
1633   a->nofast = 0;
1634   /* make a link from the new stream to the original stream */
1635   a->chain = b;
1636
1637   /* setup the function on the new stream */
1638   a->filter = f;
1639   a->filter_ov = ov;
1640   a->filter_ov_owner = rel_ov;
1641
1642   a->subno = b->subno + 1;
1643
1644   if (DBG_IOBUF)
1645     {
1646       log_debug ("iobuf-%d.%d: push '%s'\n",
1647                  a->no, a->subno, iobuf_desc (a));
1648       print_chain (a);
1649     }
1650
1651   /* now we can initialize the new function if we have one */
1652   if (a->filter && (rc = a->filter (a->filter_ov, IOBUFCTRL_INIT, a->chain,
1653                                     NULL, &dummy_len)))
1654     log_error ("IOBUFCTRL_INIT failed: %s\n", gpg_strerror (rc));
1655   return rc;
1656 }
1657
1658 /****************
1659  * Remove an i/o filter.
1660  */
1661 static int
1662 pop_filter (iobuf_t a, int (*f) (void *opaque, int control,
1663                                iobuf_t chain, byte * buf, size_t * len),
1664             void *ov)
1665 {
1666   iobuf_t b;
1667   size_t dummy_len = 0;
1668   int rc = 0;
1669
1670   if (DBG_IOBUF)
1671     log_debug ("iobuf-%d.%d: pop '%s'\n",
1672                a->no, a->subno, iobuf_desc (a));
1673   if (!a->filter)
1674     {                           /* this is simple */
1675       b = a->chain;
1676       assert (b);
1677       xfree (a->d.buf);
1678       xfree (a->real_fname);
1679       memcpy (a, b, sizeof *a);
1680       xfree (b);
1681       return 0;
1682     }
1683   for (b = a; b; b = b->chain)
1684     if (b->filter == f && (!ov || b->filter_ov == ov))
1685       break;
1686   if (!b)
1687     log_bug ("pop_filter(): filter function not found\n");
1688
1689   /* flush this stream if it is an output stream */
1690   if (a->use == IOBUF_OUTPUT && (rc = filter_flush (b)))
1691     {
1692       log_error ("filter_flush failed in pop_filter: %s\n", gpg_strerror (rc));
1693       return rc;
1694     }
1695   /* and tell the filter to free it self */
1696   if (b->filter && (rc = b->filter (b->filter_ov, IOBUFCTRL_FREE, b->chain,
1697                                     NULL, &dummy_len)))
1698     {
1699       log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
1700       return rc;
1701     }
1702   if (b->filter_ov && b->filter_ov_owner)
1703     {
1704       xfree (b->filter_ov);
1705       b->filter_ov = NULL;
1706     }
1707
1708
1709   /* and see how to remove it */
1710   if (a == b && !b->chain)
1711     log_bug ("can't remove the last filter from the chain\n");
1712   else if (a == b)
1713     {                           /* remove the first iobuf from the chain */
1714       /* everything from b is copied to a. This is save because
1715        * a flush has been done on the to be removed entry
1716        */
1717       b = a->chain;
1718       xfree (a->d.buf);
1719       xfree (a->real_fname);
1720       memcpy (a, b, sizeof *a);
1721       xfree (b);
1722       if (DBG_IOBUF)
1723         log_debug ("iobuf-%d.%d: popped filter\n", a->no, a->subno);
1724     }
1725   else if (!b->chain)
1726     {                           /* remove the last iobuf from the chain */
1727       log_bug ("Ohh jeee, trying to remove a head filter\n");
1728     }
1729   else
1730     {                           /* remove an intermediate iobuf from the chain */
1731       log_bug ("Ohh jeee, trying to remove an intermediate filter\n");
1732     }
1733
1734   return rc;
1735 }
1736
1737
1738 /****************
1739  * read underflow: read more bytes into the buffer and return
1740  * the first byte or -1 on EOF.
1741  */
1742 static int
1743 underflow (iobuf_t a, int clear_pending_eof)
1744 {
1745   size_t len;
1746   int rc;
1747
1748   if (DBG_IOBUF)
1749     log_debug ("iobuf-%d.%d: underflow: buffer size: %d; still buffered: %d => space for %d bytes\n",
1750                a->no, a->subno,
1751                (int) a->d.size, (int) (a->d.len - a->d.start),
1752                (int) (a->d.size - (a->d.len - a->d.start)));
1753
1754   assert (a->use == IOBUF_INPUT);
1755
1756   /* If there is still some buffered data, then move it to the start
1757      of the buffer and try to fill the end of the buffer.  (This is
1758      useful if we are called from iobuf_peek().)  */
1759   assert (a->d.start <= a->d.len);
1760   a->d.len -= a->d.start;
1761   memmove (a->d.buf, &a->d.buf[a->d.start], a->d.len);
1762   a->d.start = 0;
1763
1764   if (a->d.len == 0 && a->filter_eof)
1765     /* The last time we tried to read from this filter, we got an EOF.
1766        We couldn't return the EOF, because there was buffered data.
1767        Since there is no longer any buffered data, return the
1768        error.  */
1769     {
1770       if (DBG_IOBUF)
1771         log_debug ("iobuf-%d.%d: underflow: eof (pending eof)\n",
1772                    a->no, a->subno);
1773       if (! clear_pending_eof)
1774         return -1;
1775
1776       if (a->chain)
1777         /* A filter follows this one.  Free this filter.  */
1778         {
1779           iobuf_t b = a->chain;
1780           if (DBG_IOBUF)
1781             log_debug ("iobuf-%d.%d: filter popped (pending EOF returned)\n",
1782                        a->no, a->subno);
1783           xfree (a->d.buf);
1784           xfree (a->real_fname);
1785           memcpy (a, b, sizeof *a);
1786           xfree (b);
1787           print_chain (a);
1788         }
1789       else
1790         a->filter_eof = 0;      /* for the top level filter */
1791       return -1;                /* return one(!) EOF */
1792     }
1793
1794   if (a->d.len == 0 && a->error)
1795     /* The last time we tried to read from this filter, we got an
1796        error.  We couldn't return the error, because there was
1797        buffered data.  Since there is no longer any buffered data,
1798        return the error.  */
1799     {
1800       if (DBG_IOBUF)
1801         log_debug ("iobuf-%d.%d: pending error (%s) returned\n",
1802                    a->no, a->subno, gpg_strerror (a->error));
1803       return -1;
1804     }
1805
1806   if (a->filter && ! a->filter_eof && ! a->error)
1807     /* We have a filter function and the last time we tried to read we
1808        didn't get an EOF or an error.  Try to fill the buffer.  */
1809     {
1810       /* Be careful to account for any buffered data.  */
1811       len = a->d.size - a->d.len;
1812       if (DBG_IOBUF)
1813         log_debug ("iobuf-%d.%d: underflow: A->FILTER (%lu bytes)\n",
1814                    a->no, a->subno, (ulong) len);
1815       if (len == 0)
1816         /* There is no space for more data.  Don't bother calling
1817            A->FILTER.  */
1818         rc = 0;
1819       else
1820         rc = a->filter (a->filter_ov, IOBUFCTRL_UNDERFLOW, a->chain,
1821                         &a->d.buf[a->d.len], &len);
1822       a->d.len += len;
1823
1824       if (DBG_IOBUF)
1825         log_debug ("iobuf-%d.%d: A->FILTER() returned rc=%d (%s), read %lu bytes\n",
1826                    a->no, a->subno,
1827                    rc, rc == 0 ? "ok" : rc == -1 ? "EOF" : gpg_strerror (rc),
1828                    (ulong) len);
1829 /*          if( a->no == 1 ) */
1830 /*                   log_hexdump ("     data:", a->d.buf, len); */
1831
1832       if (rc == -1)
1833         /* EOF.  */
1834         {
1835           size_t dummy_len = 0;
1836
1837           /* Tell the filter to free itself */
1838           if ((rc = a->filter (a->filter_ov, IOBUFCTRL_FREE, a->chain,
1839                                NULL, &dummy_len)))
1840             log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
1841
1842           /* Free everything except for the internal buffer.  */
1843           if (a->filter_ov && a->filter_ov_owner)
1844             xfree (a->filter_ov);
1845           a->filter_ov = NULL;
1846           a->filter = NULL;
1847           a->filter_eof = 1;
1848
1849           if (clear_pending_eof && a->d.len == 0 && a->chain)
1850             /* We don't need to keep this filter around at all:
1851
1852                  - we got an EOF
1853                  - we have no buffered data
1854                  - a filter follows this one.
1855
1856               Unlink this filter.  */
1857             {
1858               iobuf_t b = a->chain;
1859               if (DBG_IOBUF)
1860                 log_debug ("iobuf-%d.%d: pop in underflow (nothing buffered, got EOF)\n",
1861                            a->no, a->subno);
1862               xfree (a->d.buf);
1863               xfree (a->real_fname);
1864               memcpy (a, b, sizeof *a);
1865               xfree (b);
1866
1867               print_chain (a);
1868
1869               return -1;
1870             }
1871           else if (a->d.len == 0)
1872             /* We can't unlink this filter (it is the only one in the
1873                pipeline), but we can immediately return EOF.  */
1874             return -1;
1875         }
1876       else if (rc)
1877         /* Record the error.  */
1878         {
1879           a->error = rc;
1880
1881           if (a->d.len == 0)
1882             /* There is no buffered data.  Immediately return EOF.  */
1883             return -1;
1884         }
1885     }
1886
1887   assert (a->d.start <= a->d.len);
1888   if (a->d.start < a->d.len)
1889     return a->d.buf[a->d.start++];
1890
1891   /* EOF.  */
1892   return -1;
1893 }
1894
1895
1896 static int
1897 filter_flush (iobuf_t a)
1898 {
1899   size_t len;
1900   int rc;
1901
1902   if (a->use == IOBUF_TEMP)
1903     {                           /* increase the temp buffer */
1904       size_t newsize = a->d.size + IOBUF_BUFFER_SIZE;
1905
1906       if (DBG_IOBUF)
1907         log_debug ("increasing temp iobuf from %lu to %lu\n",
1908                    (ulong) a->d.size, (ulong) newsize);
1909
1910       a->d.buf = xrealloc (a->d.buf, newsize);
1911       a->d.size = newsize;
1912       return 0;
1913     }
1914   else if (a->use != IOBUF_OUTPUT)
1915     log_bug ("flush on non-output iobuf\n");
1916   else if (!a->filter)
1917     log_bug ("filter_flush: no filter\n");
1918   len = a->d.len;
1919   rc = a->filter (a->filter_ov, IOBUFCTRL_FLUSH, a->chain, a->d.buf, &len);
1920   if (!rc && len != a->d.len)
1921     {
1922       log_info ("filter_flush did not write all!\n");
1923       rc = GPG_ERR_INTERNAL;
1924     }
1925   else if (rc)
1926     a->error = rc;
1927   a->d.len = 0;
1928
1929   return rc;
1930 }
1931
1932
1933 int
1934 iobuf_readbyte (iobuf_t a)
1935 {
1936   int c;
1937
1938   if (a->nlimit && a->nbytes >= a->nlimit)
1939     return -1;                  /* forced EOF */
1940
1941   if (a->d.start < a->d.len)
1942     {
1943       c = a->d.buf[a->d.start++];
1944     }
1945   else if ((c = underflow (a, 1)) == -1)
1946     return -1;                  /* EOF */
1947
1948   /* Note: if underflow doesn't return EOF, then it returns the first
1949      byte that was read and advances a->d.start appropriately.  */
1950
1951   a->nbytes++;
1952   return c;
1953 }
1954
1955
1956 int
1957 iobuf_read (iobuf_t a, void *buffer, unsigned int buflen)
1958 {
1959   unsigned char *buf = (unsigned char *)buffer;
1960   int c, n;
1961
1962   if (a->nlimit)
1963     {
1964       /* Handle special cases. */
1965       for (n = 0; n < buflen; n++)
1966         {
1967           if ((c = iobuf_readbyte (a)) == -1)
1968             {
1969               if (!n)
1970                 return -1;      /* eof */
1971               break;
1972             }
1973           else if (buf)
1974             *buf = c;
1975           if (buf)
1976             buf++;
1977         }
1978       return n;
1979     }
1980
1981   n = 0;
1982   do
1983     {
1984       if (n < buflen && a->d.start < a->d.len)
1985         /* Drain the buffer.  */
1986         {
1987           unsigned size = a->d.len - a->d.start;
1988           if (size > buflen - n)
1989             size = buflen - n;
1990           if (buf)
1991             memcpy (buf, a->d.buf + a->d.start, size);
1992           n += size;
1993           a->d.start += size;
1994           if (buf)
1995             buf += size;
1996         }
1997       if (n < buflen)
1998         /* Draining the internal buffer didn't fill BUFFER.  Call
1999            underflow to read more data into the filter's internal
2000            buffer.  */
2001         {
2002           if ((c = underflow (a, 1)) == -1)
2003             /* EOF.  If we managed to read something, don't return EOF
2004                now.  */
2005             {
2006               a->nbytes += n;
2007               return n ? n : -1 /*EOF*/;
2008             }
2009           if (buf)
2010             *buf++ = c;
2011           n++;
2012         }
2013     }
2014   while (n < buflen);
2015   a->nbytes += n;
2016   return n;
2017 }
2018
2019
2020
2021 int
2022 iobuf_peek (iobuf_t a, byte * buf, unsigned buflen)
2023 {
2024   int n = 0;
2025
2026   assert (buflen > 0);
2027   assert (a->use == IOBUF_INPUT);
2028
2029   if (buflen > a->d.size)
2030     /* We can't peek more than we can buffer.  */
2031     buflen = a->d.size;
2032
2033   /* Try to fill the internal buffer with enough data to satisfy the
2034      request.  */
2035   while (buflen > a->d.len - a->d.start)
2036     {
2037       if (underflow (a, 0) == -1)
2038         /* EOF.  We can't read any more.  */
2039         break;
2040
2041       /* Underflow consumes the first character (it's the return
2042          value).  unget() it by resetting the "file position".  */
2043       assert (a->d.start == 1);
2044       a->d.start = 0;
2045     }
2046
2047   n = a->d.len - a->d.start;
2048   if (n > buflen)
2049     n = buflen;
2050
2051   if (n == 0)
2052     /* EOF.  */
2053     return -1;
2054
2055   memcpy (buf, &a->d.buf[a->d.start], n);
2056
2057   return n;
2058 }
2059
2060
2061
2062
2063 int
2064 iobuf_writebyte (iobuf_t a, unsigned int c)
2065 {
2066   int rc;
2067
2068   if (a->d.len == a->d.size)
2069     if ((rc=filter_flush (a)))
2070       return rc;
2071
2072   assert (a->d.len < a->d.size);
2073   a->d.buf[a->d.len++] = c;
2074   return 0;
2075 }
2076
2077
2078 int
2079 iobuf_write (iobuf_t a, const void *buffer, unsigned int buflen)
2080 {
2081   const unsigned char *buf = (const unsigned char *)buffer;
2082   int rc;
2083
2084   do
2085     {
2086       if (buflen && a->d.len < a->d.size)
2087         {
2088           unsigned size = a->d.size - a->d.len;
2089           if (size > buflen)
2090             size = buflen;
2091           memcpy (a->d.buf + a->d.len, buf, size);
2092           buflen -= size;
2093           buf += size;
2094           a->d.len += size;
2095         }
2096       if (buflen)
2097         {
2098           rc = filter_flush (a);
2099           if (rc)
2100             return rc;
2101         }
2102     }
2103   while (buflen);
2104   return 0;
2105 }
2106
2107
2108 int
2109 iobuf_writestr (iobuf_t a, const char *buf)
2110 {
2111   int rc;
2112
2113   for (; *buf; buf++)
2114     if ((rc=iobuf_writebyte (a, *buf)))
2115       return rc;
2116   return 0;
2117 }
2118
2119
2120
2121 int
2122 iobuf_write_temp (iobuf_t a, iobuf_t temp)
2123 {
2124   while (temp->chain)
2125     pop_filter (temp, temp->filter, NULL);
2126   return iobuf_write (a, temp->d.buf, temp->d.len);
2127 }
2128
2129 size_t
2130 iobuf_temp_to_buffer (iobuf_t a, byte * buffer, size_t buflen)
2131 {
2132   size_t n;
2133
2134   while (1)
2135     {
2136       int rc = filter_flush (a);
2137       if (rc)
2138         log_bug ("Flushing iobuf %d.%d (%s) from iobuf_temp_to_buffer failed.  Ignoring.\n",
2139                  a->no, a->subno, iobuf_desc (a));
2140       if (! a->chain)
2141         break;
2142       a = a->chain;
2143     }
2144
2145   n = a->d.len;
2146   if (n > buflen)
2147     n = buflen;
2148   memcpy (buffer, a->d.buf, n);
2149   return n;
2150 }
2151
2152
2153 void
2154 iobuf_flush_temp (iobuf_t temp)
2155 {
2156   while (temp->chain)
2157     pop_filter (temp, temp->filter, NULL);
2158 }
2159
2160
2161 void
2162 iobuf_set_limit (iobuf_t a, off_t nlimit)
2163 {
2164   if (nlimit)
2165     a->nofast = 1;
2166   else
2167     a->nofast = 0;
2168   a->nlimit = nlimit;
2169   a->ntotal += a->nbytes;
2170   a->nbytes = 0;
2171 }
2172
2173
2174
2175 off_t
2176 iobuf_get_filelength (iobuf_t a, int *overflow)
2177 {
2178   struct stat st;
2179
2180   if (overflow)
2181     *overflow = 0;
2182
2183   /* Hmmm: file_filter may have already been removed */
2184   for ( ; a; a = a->chain )
2185     if ( !a->chain && a->filter == file_filter )
2186       {
2187         file_filter_ctx_t *b = a->filter_ov;
2188         gnupg_fd_t fp = b->fp;
2189
2190 #if defined(HAVE_W32_SYSTEM)
2191         ulong size;
2192         static int (* __stdcall get_file_size_ex) (void *handle,
2193                                                    LARGE_INTEGER *r_size);
2194         static int get_file_size_ex_initialized;
2195
2196         if (!get_file_size_ex_initialized)
2197           {
2198             void *handle;
2199
2200             handle = dlopen ("kernel32.dll", RTLD_LAZY);
2201             if (handle)
2202               {
2203                 get_file_size_ex = dlsym (handle, "GetFileSizeEx");
2204                 if (!get_file_size_ex)
2205                   dlclose (handle);
2206               }
2207             get_file_size_ex_initialized = 1;
2208           }
2209
2210         if (get_file_size_ex)
2211           {
2212             /* This is a newer system with GetFileSizeEx; we use this
2213                then because it seem that GetFileSize won't return a
2214                proper error in case a file is larger than 4GB. */
2215             LARGE_INTEGER exsize;
2216
2217             if (get_file_size_ex (fp, &exsize))
2218               {
2219                 if (!exsize.u.HighPart)
2220                   return exsize.u.LowPart;
2221                 if (overflow)
2222                   *overflow = 1;
2223                 return 0;
2224               }
2225           }
2226         else
2227           {
2228             if ((size=GetFileSize (fp, NULL)) != 0xffffffff)
2229               return size;
2230           }
2231         log_error ("GetFileSize for handle %p failed: %s\n",
2232                    fp, w32_strerror (0));
2233 #else
2234         if ( !fstat (FD2INT (fp), &st) )
2235           return st.st_size;
2236         log_error("fstat() failed: %s\n", strerror(errno) );
2237 #endif
2238         break/*the for loop*/;
2239       }
2240
2241     return 0;
2242 }
2243
2244
2245 int
2246 iobuf_get_fd (iobuf_t a)
2247 {
2248   for ( ; a; a = a->chain )
2249     if (!a->chain && a->filter == file_filter)
2250       {
2251         file_filter_ctx_t *b = a->filter_ov;
2252         gnupg_fd_t fp = b->fp;
2253
2254         return FD2INT (fp);
2255       }
2256
2257   return -1;
2258 }
2259
2260
2261 off_t
2262 iobuf_tell (iobuf_t a)
2263 {
2264   return a->ntotal + a->nbytes;
2265 }
2266
2267
2268 #if !defined(HAVE_FSEEKO) && !defined(fseeko)
2269
2270 #ifdef HAVE_LIMITS_H
2271 # include <limits.h>
2272 #endif
2273 #ifndef LONG_MAX
2274 # define LONG_MAX ((long) ((unsigned long) -1 >> 1))
2275 #endif
2276 #ifndef LONG_MIN
2277 # define LONG_MIN (-1 - LONG_MAX)
2278 #endif
2279
2280 /****************
2281  * A substitute for fseeko, for hosts that don't have it.
2282  */
2283 static int
2284 fseeko (FILE * stream, off_t newpos, int whence)
2285 {
2286   while (newpos != (long) newpos)
2287     {
2288       long pos = newpos < 0 ? LONG_MIN : LONG_MAX;
2289       if (fseek (stream, pos, whence) != 0)
2290         return -1;
2291       newpos -= pos;
2292       whence = SEEK_CUR;
2293     }
2294   return fseek (stream, (long) newpos, whence);
2295 }
2296 #endif
2297
2298 int
2299 iobuf_seek (iobuf_t a, off_t newpos)
2300 {
2301   file_filter_ctx_t *b = NULL;
2302
2303   if (a->use != IOBUF_TEMP)
2304     {
2305       for (; a; a = a->chain)
2306         {
2307           if (!a->chain && a->filter == file_filter)
2308             {
2309               b = a->filter_ov;
2310               break;
2311             }
2312         }
2313       if (!a)
2314         return -1;
2315 #ifdef HAVE_W32_SYSTEM
2316       if (SetFilePointer (b->fp, newpos, NULL, FILE_BEGIN) == 0xffffffff)
2317         {
2318           log_error ("SetFilePointer failed on handle %p: ec=%d\n",
2319                      b->fp, (int) GetLastError ());
2320           return -1;
2321         }
2322 #else
2323       if (lseek (b->fp, newpos, SEEK_SET) == (off_t) - 1)
2324         {
2325           log_error ("can't lseek: %s\n", strerror (errno));
2326           return -1;
2327         }
2328 #endif
2329     }
2330   /* Discard the buffer unless it is a temp stream.  */
2331   if (a->use != IOBUF_TEMP)
2332     a->d.len = 0;
2333   a->d.start = 0;
2334   a->nbytes = 0;
2335   a->nlimit = 0;
2336   a->nofast = 0;
2337   a->ntotal = newpos;
2338   a->error = 0;
2339
2340   /* It is impossible for A->CHAIN to be non-NULL.  If A is an INPUT
2341      or OUTPUT buffer, then we find the last filter, which is defined
2342      as A->CHAIN being NULL.  If A is a TEMP filter, then A must be
2343      the only filter in the pipe: when iobuf_push_filter adds a filter
2344      to the front of a pipeline, it sets the new filter to be an
2345      OUTPUT filter if the pipeline is an OUTPUT or TEMP pipeline and
2346      to be an INPUT filter if the pipeline is an INPUT pipeline.
2347      Thus, only the last filter in a TEMP pipeline can be a */
2348
2349   /* remove filters, but the last */
2350   if (a->chain)
2351     log_debug ("pop_filter called in iobuf_seek - please report\n");
2352   while (a->chain)
2353     pop_filter (a, a->filter, NULL);
2354
2355   return 0;
2356 }
2357
2358
2359
2360
2361
2362
2363 const char *
2364 iobuf_get_real_fname (iobuf_t a)
2365 {
2366   if (a->real_fname)
2367     return a->real_fname;
2368
2369   /* the old solution */
2370   for (; a; a = a->chain)
2371     if (!a->chain && a->filter == file_filter)
2372       {
2373         file_filter_ctx_t *b = a->filter_ov;
2374         return b->print_only_name ? NULL : b->fname;
2375       }
2376
2377   return NULL;
2378 }
2379
2380
2381 const char *
2382 iobuf_get_fname (iobuf_t a)
2383 {
2384   for (; a; a = a->chain)
2385     if (!a->chain && a->filter == file_filter)
2386       {
2387         file_filter_ctx_t *b = a->filter_ov;
2388         return b->fname;
2389       }
2390   return NULL;
2391 }
2392
2393 const char *
2394 iobuf_get_fname_nonnull (iobuf_t a)
2395 {
2396   const char *fname;
2397
2398   fname = iobuf_get_fname (a);
2399   return fname? fname : "[?]";
2400 }
2401
2402
2403 /****************
2404  * enable partial block mode as described in the OpenPGP draft.
2405  * LEN is the first length byte on read, but ignored on writes.
2406  */
2407 void
2408 iobuf_set_partial_block_mode (iobuf_t a, size_t len)
2409 {
2410   block_filter_ctx_t *ctx = xcalloc (1, sizeof *ctx);
2411
2412   assert (a->use == IOBUF_INPUT || a->use == IOBUF_OUTPUT);
2413   ctx->use = a->use;
2414   if (!len)
2415     {
2416       if (a->use == IOBUF_INPUT)
2417         log_debug ("pop_filter called in set_partial_block_mode"
2418                    " - please report\n");
2419       /* XXX: This pop_filter doesn't make sense.  Since we haven't
2420          actually added the filter to the pipeline yet, why are we
2421          popping anything?  Moreover, since we don't report an error,
2422          the caller won't directly see an error.  I think that it
2423          would be better to push the filter and set a->error to
2424          GPG_ERR_BAD_DATA, but Werner thinks it's impossible for len
2425          to be 0 (but he doesn't want to remove the check just in
2426          case).  */
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 unsigned int
2441 iobuf_read_line (iobuf_t a, byte ** addr_of_buffer,
2442                  unsigned *length_of_buffer, unsigned *max_length)
2443 {
2444   int c;
2445   char *buffer = (char *)*addr_of_buffer;
2446   unsigned length = *length_of_buffer;
2447   unsigned nbytes = 0;
2448   unsigned maxlen = *max_length;
2449   char *p;
2450
2451   /* The code assumes that we have space for at least a newline and a
2452      NUL character in the buffer.  This requires at least 2 bytes.  We
2453      don't complicate the code by handling the stupid corner case, but
2454      simply assert that it can't happen.  */
2455   assert (length >= 2 || maxlen >= 2);
2456
2457   if (!buffer || length <= 1)
2458     /* must allocate a new buffer */
2459     {
2460       length = 256 <= maxlen ? 256 : maxlen;
2461       buffer = xrealloc (buffer, length);
2462       *addr_of_buffer = (unsigned char *)buffer;
2463       *length_of_buffer = length;
2464     }
2465
2466   p = buffer;
2467   while ((c = iobuf_get (a)) != -1)
2468     {
2469       *p++ = c;
2470       nbytes++;
2471       if (c == '\n')
2472         break;
2473
2474       if (nbytes == length - 1)
2475         /* We don't have enough space to add a \n and a \0.  Increase
2476            the buffer size.  */
2477         {
2478           if (length == maxlen)
2479             /* We reached the buffer's size limit!  */
2480             {
2481               /* Skip the rest of the line.  */
2482               while (c != '\n' && (c = iobuf_get (a)) != -1)
2483                 ;
2484
2485               /* p is pointing at the last byte in the buffer.  We
2486                  always terminate the line with "\n\0" so overwrite
2487                  the previous byte with a \n.  */
2488               assert (p > buffer);
2489               p[-1] = '\n';
2490
2491               /* Indicate truncation.  */
2492               *max_length = 0;
2493               break;
2494             }
2495
2496           length += length < 1024 ? 256 : 1024;
2497           if (length > maxlen)
2498             length = maxlen;
2499
2500           buffer = xrealloc (buffer, length);
2501           *addr_of_buffer = (unsigned char *)buffer;
2502           *length_of_buffer = length;
2503           p = buffer + nbytes;
2504         }
2505     }
2506   /* Add the terminating NUL.  */
2507   *p = 0;
2508
2509   /* Return the number of characters written to the buffer including
2510      the newline, but not including the terminating NUL.  */
2511   return nbytes;
2512 }
2513
2514 static int
2515 translate_file_handle (int fd, int for_write)
2516 {
2517 #if defined(HAVE_W32CE_SYSTEM)
2518   /* This is called only with one of the special filenames.  Under
2519      W32CE the FD here is not a file descriptor but a rendezvous id,
2520      thus we need to finish the pipe first.  */
2521   fd = _assuan_w32ce_finish_pipe (fd, for_write);
2522 #elif defined(HAVE_W32_SYSTEM)
2523   {
2524     int x;
2525
2526     (void)for_write;
2527
2528     if (fd == 0)
2529       x = (int) GetStdHandle (STD_INPUT_HANDLE);
2530     else if (fd == 1)
2531       x = (int) GetStdHandle (STD_OUTPUT_HANDLE);
2532     else if (fd == 2)
2533       x = (int) GetStdHandle (STD_ERROR_HANDLE);
2534     else
2535       x = fd;
2536
2537     if (x == -1)
2538       log_debug ("GetStdHandle(%d) failed: ec=%d\n",
2539                  fd, (int) GetLastError ());
2540
2541     fd = x;
2542   }
2543 #else
2544   (void)for_write;
2545 #endif
2546   return fd;
2547 }
2548
2549
2550 void
2551 iobuf_skip_rest (iobuf_t a, unsigned long n, int partial)
2552 {
2553   if ( partial )
2554     {
2555       for (;;)
2556         {
2557           if (a->nofast || a->d.start >= a->d.len)
2558             {
2559               if (iobuf_readbyte (a) == -1)
2560                 {
2561                   break;
2562                 }
2563             }
2564           else
2565             {
2566               unsigned long count = a->d.len - a->d.start;
2567               a->nbytes += count;
2568               a->d.start = a->d.len;
2569             }
2570         }
2571     }
2572   else
2573     {
2574       unsigned long remaining = n;
2575       while (remaining > 0)
2576         {
2577           if (a->nofast || a->d.start >= a->d.len)
2578             {
2579               if (iobuf_readbyte (a) == -1)
2580                 {
2581                   break;
2582                 }
2583               --remaining;
2584             }
2585           else
2586             {
2587               unsigned long count = a->d.len - a->d.start;
2588               if (count > remaining)
2589                 {
2590                   count = remaining;
2591                 }
2592               a->nbytes += count;
2593               a->d.start += count;
2594               remaining -= count;
2595             }
2596         }
2597     }
2598 }