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