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
6 * This file is part of GnuPG.
8 * This file is free software; you can redistribute it and/or modify
9 * it under the terms of either
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.
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.
21 * or both in parallel, as here.
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.
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/>.
39 #include <sys/types.h>
43 #ifdef HAVE_W32_SYSTEM
44 # ifdef HAVE_WINSOCK2_H
45 # include <winsock2.h>
52 #endif /* __riscos__ */
60 /*-- Begin configurable part. --*/
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
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
71 /*-- End configurable part. --*/
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))
79 # define FD_FOR_STDIN (GetStdHandle (STD_INPUT_HANDLE))
80 # define FD_FOR_STDOUT (GetStdHandle (STD_OUTPUT_HANDLE))
82 #else /*!HAVE_W32_SYSTEM*/
83 # define FD_FOR_STDIN (0)
84 # define FD_FOR_STDOUT (1)
85 #endif /*!HAVE_W32_SYSTEM*/
88 /* The context used by the file filter. */
91 gnupg_fd_t fp; /* Open file pointer or handle. */
95 int print_only_name; /* Flags indicating that fname is not a real file. */
96 char fname[1]; /* Name of the file. */
99 /* The context used by the estream filter. */
102 estream_t fp; /* Open estream handle. */
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;
111 /* Object to control the "close cache". */
114 struct close_cache_s *next;
118 typedef struct close_cache_s *close_cache_t;
119 static close_cache_t close_cache;
123 #ifdef HAVE_W32_SYSTEM
130 int print_only_name; /* Flag indicating that fname is not a real file. */
131 char fname[1]; /* Name of the file */
134 #endif /*HAVE_W32_SYSTEM*/
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
142 /* The context we use for the block filter (used to handle OpenPGP
143 length information header). */
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). */
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;
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);
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.
173 If A is a IOBUF_OUTPUT_TEMP filter, then this also enlarges the
174 buffer by IOBUF_BUFFER_SIZE.
176 May only be called on an IOBUF_OUTPUT or IOBUF_OUTPUT_TEMP filters. */
177 static int filter_flush (iobuf_t a);
181 /* This is a replacement for strcmp. Under W32 it does not
182 distinguish between backslash and slash. */
184 fd_cache_strcmp (const char *a, const char *b)
186 #ifdef HAVE_DOSISH_SYSTEM
187 for (; *a && *b; a++, b++)
189 if (*a != *b && !((*a == '/' && *b == '\\')
190 || (*a == '\\' && *b == '/')) )
193 return *(const unsigned char *)a - *(const unsigned char *)b;
195 return strcmp (a, b);
200 * Invalidate (i.e. close) a cached iobuf
203 fd_cache_invalidate (const char *fname)
210 log_debug ("fd_cache_invalidate (%s)\n", fname);
212 for (cc = close_cache; cc; cc = cc->next)
214 if (cc->fp != GNUPG_INVALID_FD && !fd_cache_strcmp (cc->fname, fname))
217 log_debug (" did (%s)\n", cc->fname);
218 #ifdef HAVE_W32_SYSTEM
219 if (!CloseHandle (cc->fp))
224 cc->fp = GNUPG_INVALID_FD;
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
235 fd_cache_synchronize (const char *fname)
243 log_debug ("fd_cache_synchronize (%s)\n", fname);
245 for (cc=close_cache; cc; cc = cc->next )
247 if (cc->fp != GNUPG_INVALID_FD && !fd_cache_strcmp (cc->fname, fname))
250 log_debug (" did (%s)\n", cc->fname);
252 err = fsync (cc->fp);
257 #endif /*HAVE_FSYNC*/
264 direct_open (const char *fname, const char *mode, int mode700)
266 #ifdef HAVE_W32_SYSTEM
267 unsigned long da, cd, sm;
270 /* Note, that we do not handle all mode combinations */
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 ;-)
276 if (strchr (mode, '+'))
278 if (fd_cache_invalidate (fname))
279 return GNUPG_INVALID_FD;
280 da = GENERIC_READ | GENERIC_WRITE;
282 sm = FILE_SHARE_READ | FILE_SHARE_WRITE;
284 else if (strchr (mode, 'w'))
286 if (fd_cache_invalidate (fname))
287 return GNUPG_INVALID_FD;
290 sm = FILE_SHARE_WRITE;
296 sm = FILE_SHARE_READ;
299 #ifdef HAVE_W32CE_SYSTEM
301 wchar_t *wfname = utf8_to_wchar (fname);
304 hfile = CreateFile (wfname, da, sm, NULL, cd,
305 FILE_ATTRIBUTE_NORMAL, NULL);
309 hfile = INVALID_HANDLE_VALUE;
312 hfile = CreateFile (fname, da, sm, NULL, cd, FILE_ATTRIBUTE_NORMAL, NULL);
316 #else /*!HAVE_W32_SYSTEM*/
319 int cflag = S_IRUSR | S_IWUSR;
322 cflag |= S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
324 /* Note, that we do not handle all mode combinations */
325 if (strchr (mode, '+'))
327 if (fd_cache_invalidate (fname))
328 return GNUPG_INVALID_FD;
331 else if (strchr (mode, 'w'))
333 if (fd_cache_invalidate (fname))
334 return GNUPG_INVALID_FD;
335 oflag = O_WRONLY | O_CREAT | O_TRUNC;
342 if (strchr (mode, 'b'))
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);
355 return open (fname, oflag, cflag);
357 #endif /*!HAVE_W32_SYSTEM*/
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.
366 fd_cache_close (const char *fname, gnupg_fd_t fp)
371 if (!fname || !*fname)
373 #ifdef HAVE_W32_SYSTEM
379 log_debug ("fd_cache_close (%d) real\n", (int)fp);
382 /* try to reuse a slot */
383 for (cc = close_cache; cc; cc = cc->next)
385 if (cc->fp == GNUPG_INVALID_FD && !fd_cache_strcmp (cc->fname, fname))
389 log_debug ("fd_cache_close (%s) used existing slot\n", fname);
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);
399 cc->next = close_cache;
404 * Do a direct_open on FNAME but first try to reuse one from the fd_cache
407 fd_cache_open (const char *fname, const char *mode)
412 for (cc = close_cache; cc; cc = cc->next)
414 if (cc->fp != GNUPG_INVALID_FD && !fd_cache_strcmp (cc->fname, fname))
416 gnupg_fd_t fp = cc->fp;
417 cc->fp = GNUPG_INVALID_FD;
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)
423 log_error ("rewind file failed on handle %p: ec=%d\n",
424 fp, (int) GetLastError ());
425 fp = GNUPG_INVALID_FD;
428 if (lseek (fp, 0, SEEK_SET) == (off_t) - 1)
430 log_error ("can't rewind fd %d: %s\n", fp, strerror (errno));
431 fp = GNUPG_INVALID_FD;
438 log_debug ("fd_cache_open (%s) not cached\n", fname);
439 return direct_open (fname, mode, 0);
444 file_filter (void *opaque, int control, iobuf_t chain, byte * buf,
447 file_filter_ctx_t *a = opaque;
448 gnupg_fd_t f = a->fp;
449 size_t size = *ret_len;
453 (void)chain; /* Not used. */
455 if (control == IOBUFCTRL_UNDERFLOW)
457 assert (size); /* We need a buffer. */
465 #ifdef HAVE_W32_SYSTEM
469 if (!ReadFile (f, buf, size, &nread, NULL))
471 int ec = (int) GetLastError ();
472 if (ec != ERROR_BROKEN_PIPE)
474 rc = gpg_error_from_errno (ec);
475 log_error ("%s: read error: ec=%d\n", a->fname, ec);
495 n = read (f, buf, size);
497 while (n == -1 && errno == EINTR);
502 rc = gpg_error_from_syserror ();
503 log_error ("%s: read error: %s\n",
504 a->fname, strerror (errno));
520 else if (control == IOBUFCTRL_FLUSH)
524 #ifdef HAVE_W32_SYSTEM
531 if (size && !WriteFile (f, p, nbytes, &n, NULL))
533 int ec = (int) GetLastError ();
534 rc = gpg_error_from_errno (ec);
535 log_error ("%s: write error: ec=%d\n", a->fname, ec);
552 n = write (f, p, nbytes);
554 while (n == -1 && errno == EINTR);
561 while (n != -1 && nbytes);
564 rc = gpg_error_from_syserror ();
565 log_error ("%s: write error: %s\n", a->fname, strerror (errno));
572 else if (control == IOBUFCTRL_INIT)
578 else if (control == IOBUFCTRL_DESC)
580 *(char **) buf = "file_filter(fd)";
582 else if (control == IOBUFCTRL_FREE)
584 if (f != FD_FOR_STDIN && f != FD_FOR_STDOUT)
587 log_debug ("%s: close fd/handle %d\n", a->fname, FD2INT (f));
589 fd_cache_close (a->no_cache ? NULL : a->fname, f);
591 f = GNUPG_INVALID_FD;
592 xfree (a); /* We can free our context now. */
599 /* Similar to file_filter but using the estream system. */
601 file_es_filter (void *opaque, int control, iobuf_t chain, byte * buf,
604 file_es_filter_ctx_t *a = opaque;
606 size_t size = *ret_len;
610 (void)chain; /* Not used. */
612 if (control == IOBUFCTRL_UNDERFLOW)
614 assert (size); /* We need a buffer. */
623 rc = es_read (f, buf, size, &nbytes);
626 rc = gpg_error_from_syserror ();
627 log_error ("%s: read error: %s\n", a->fname, strerror (errno));
637 else if (control == IOBUFCTRL_FLUSH)
648 if (es_write (f, p, nbytes, &nwritten))
650 rc = gpg_error_from_syserror ();
651 log_error ("%s: write error: %s\n",
652 a->fname, strerror (errno));
663 else if (control == IOBUFCTRL_INIT)
668 else if (control == IOBUFCTRL_DESC)
670 *(char **) buf = "estream_filter";
672 else if (control == IOBUFCTRL_FREE)
674 if (f != es_stdin && f != es_stdout)
677 log_debug ("%s: es_fclose %p\n", a->fname, f);
682 xfree (a); /* We can free our context now. */
689 #ifdef HAVE_W32_SYSTEM
690 /* Because network sockets are special objects under Lose32 we have to
691 use a dedicated filter for them. */
693 sock_filter (void *opaque, int control, iobuf_t chain, byte * buf,
696 sock_filter_ctx_t *a = opaque;
697 size_t size = *ret_len;
703 if (control == IOBUFCTRL_UNDERFLOW)
705 assert (size); /* need a buffer */
715 nread = recv (a->sock, buf, size, 0);
716 if (nread == SOCKET_ERROR)
718 int ec = (int) WSAGetLastError ();
719 rc = gpg_error_from_errno (ec);
720 log_error ("socket read error: ec=%d\n", ec);
734 else if (control == IOBUFCTRL_FLUSH)
744 n = send (a->sock, p, nbytes, 0);
745 if (n == SOCKET_ERROR)
747 int ec = (int) WSAGetLastError ();
748 rc = gpg_error_from_errno (ec);
749 log_error ("socket write error: ec=%d\n", ec);
760 else if (control == IOBUFCTRL_INIT)
766 else if (control == IOBUFCTRL_DESC)
768 *(char **) buf = "sock_filter";
770 else if (control == IOBUFCTRL_FREE)
773 closesocket (a->sock);
774 xfree (a); /* we can free our context now */
778 #endif /*HAVE_W32_SYSTEM*/
781 * This is used to implement the block write mode.
782 * Block reading is done on a byte by byte basis in readbyte(),
786 block_filter (void *opaque, int control, iobuf_t chain, byte * buffer,
789 block_filter_ctx_t *a = opaque;
790 char *buf = (char *)buffer;
791 size_t size = *ret_len;
792 int c, needed, rc = 0;
795 if (control == IOBUFCTRL_UNDERFLOW)
800 assert (size); /* need a buffer */
801 if (a->eof) /* don't read any further */
806 { /* get the length bytes */
816 /* These OpenPGP introduced huffman like encoded length
817 * bytes are really a mess :-( */
823 else if ((c = iobuf_get (chain)) == -1)
825 log_error ("block_filter: 1st length byte missing\n");
826 rc = GPG_ERR_BAD_DATA;
843 a->size = (c - 192) * 256;
844 if ((c = iobuf_get (chain)) == -1)
847 ("block_filter: 2nd length byte missing\n");
848 rc = GPG_ERR_BAD_DATA;
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)
868 log_error ("block_filter: invalid 4 byte length\n");
869 rc = GPG_ERR_BAD_DATA;
883 { /* Next partial body length. */
884 a->size = 1 << (c & 0x1f);
886 /* log_debug("partial: ctx=%p c=%02x size=%u\n", a, c, a->size); */
892 while (!rc && size && a->size)
894 needed = size < a->size ? size : a->size;
895 c = iobuf_read (chain, p, needed);
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;
916 else if (control == IOBUFCTRL_FLUSH)
919 { /* the complicated openpgp scheme */
920 size_t blen, n, nbytes = size + a->buflen;
922 assert (a->buflen <= OP_MIN_PARTIAL_CHUNK);
923 if (nbytes < OP_MIN_PARTIAL_CHUNK)
925 /* not enough to write a partial block out; so we store it */
927 a->buffer = xmalloc (OP_MIN_PARTIAL_CHUNK);
928 memcpy (a->buffer + a->buflen, buf, size);
932 { /* okay, we can write out something */
933 /* do this in a loop to use the most efficient block lengths */
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;
945 /* write the partial length header */
946 assert (c <= 0x1f); /*;-) */
948 iobuf_put (chain, c);
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 ();
957 if ((n = nbytes) > blen)
959 if (n && iobuf_write (chain, p, n))
960 rc = gpg_error_from_syserror ();
964 while (!rc && nbytes >= OP_MIN_PARTIAL_CHUNK);
965 /* store the rest in the buffer */
969 assert (nbytes < OP_MIN_PARTIAL_CHUNK);
971 a->buffer = xmalloc (OP_MIN_PARTIAL_CHUNK);
972 memcpy (a->buffer, p, nbytes);
980 else if (control == IOBUFCTRL_INIT)
983 log_debug ("init block_filter %p\n", a);
986 else if (a->use == IOBUF_INPUT)
987 a->count = a->size = 0;
989 a->count = a->size; /* force first length bytes */
994 else if (control == IOBUFCTRL_DESC)
996 *(char **) buf = "block_filter";
998 else if (control == IOBUFCTRL_FREE)
1000 if (a->use == IOBUF_OUTPUT)
1001 { /* write the end markers */
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.
1015 /* construct header */
1017 /*log_debug("partial: remaining length=%u\n", len ); */
1019 rc = iobuf_put (chain, len);
1020 else if (len < 8384)
1022 if (!(rc = iobuf_put (chain, ((len - 192) / 256) + 192)))
1023 rc = iobuf_put (chain, ((len - 192) % 256));
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);
1034 rc = iobuf_write (chain, a->buffer, len);
1037 log_error ("block_filter: write error: %s\n",
1039 rc = gpg_error_from_syserror ();
1050 log_error ("block_filter: pending bytes!\n");
1053 log_debug ("free block_filter %p\n", a);
1054 xfree (a); /* we can free our context now */
1061 iobuf_desc (iobuf_t a)
1063 size_t dummy_len = 0;
1064 const char *desc = "?";
1066 if (! a || ! a->filter)
1069 a->filter (a->filter_ov, IOBUFCTRL_DESC, NULL,
1070 (byte *) & desc, &dummy_len);
1076 print_chain (iobuf_t a)
1080 for (; a; a = a->chain)
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);
1090 iobuf_print_chain (iobuf_t a)
1097 iobuf_alloc (int use, size_t bufsize)
1100 static int number = 0;
1102 assert (use == IOBUF_INPUT || use == IOBUF_INPUT_TEMP
1103 || use == IOBUF_OUTPUT || use == IOBUF_OUTPUT_TEMP);
1106 log_bug ("iobuf_alloc() passed a bufsize of 0!\n");
1107 bufsize = IOBUF_BUFFER_SIZE;
1110 a = xcalloc (1, sizeof *a);
1112 a->d.buf = xmalloc (bufsize);
1113 a->d.size = bufsize;
1116 a->real_fname = NULL;
1121 iobuf_close (iobuf_t a)
1124 size_t dummy_len = 0;
1127 for (; a; a = a_chain)
1133 if (a->use == IOBUF_OUTPUT && (rc = filter_flush (a)))
1134 log_error ("filter_flush failed on close: %s\n", gpg_strerror (rc));
1137 log_debug ("iobuf-%d.%d: close '%s'\n",
1138 a->no, a->subno, iobuf_desc (a));
1140 if (a->filter && (rc2 = a->filter (a->filter_ov, IOBUFCTRL_FREE,
1141 a->chain, NULL, &dummy_len)))
1142 log_error ("IOBUFCTRL_FREE failed on close: %s\n", gpg_strerror (rc));
1144 /* Whoops! An error occured. Save it in RC if we haven't
1145 already recorded an error. */
1148 xfree (a->real_fname);
1151 memset (a->d.buf, 0, a->d.size); /* erase the buffer */
1160 iobuf_cancel (iobuf_t a)
1165 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1166 char *remove_name = NULL;
1169 if (a && a->use == IOBUF_OUTPUT)
1171 s = iobuf_get_real_fname (a);
1174 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1175 remove_name = xstrdup (s);
1182 /* send a cancel message to all filters */
1183 for (a2 = a; a2; a2 = a2->chain)
1187 a2->filter (a2->filter_ov, IOBUFCTRL_CANCEL, a2->chain, NULL, &dummy);
1190 rc = iobuf_close (a);
1191 #if defined(HAVE_W32_SYSTEM) || defined(__riscos__)
1194 /* Argg, MSDOS does not allow to remove open files. So
1195 * we have to do it here */
1196 #ifdef HAVE_W32CE_SYSTEM
1197 wchar_t *wtmp = utf8_to_wchar (remove_name);
1202 remove (remove_name);
1204 xfree (remove_name);
1214 return iobuf_alloc (IOBUF_OUTPUT_TEMP, IOBUF_BUFFER_SIZE);
1218 iobuf_temp_with_content (const char *buffer, size_t length)
1223 a = iobuf_alloc (IOBUF_INPUT_TEMP, length);
1224 assert (length == a->d.size);
1225 /* memcpy (a->d.buf, buffer, length); */
1226 for (i=0; i < length; i++)
1227 a->d.buf[i] = buffer[i];
1234 iobuf_enable_special_filenames (int yes)
1236 special_names_enabled = yes;
1240 /* See whether the filename has the form "-&nnnn", where n is a
1241 non-zero number. Returns this number or -1 if it is not the
1244 check_special_filename (const char *fname)
1246 if (special_names_enabled && fname && *fname == '-' && fname[1] == '&')
1251 for (i = 0; digitp (fname+i); i++)
1254 return atoi (fname);
1261 iobuf_is_pipe_filename (const char *fname)
1263 if (!fname || (*fname=='-' && !fname[1]) )
1265 return check_special_filename (fname) != -1;
1269 do_open (const char *fname, int special_filenames,
1270 int use, const char *opentype, int mode700)
1274 file_filter_ctx_t *fcx;
1279 assert (use == IOBUF_INPUT || use == IOBUF_OUTPUT);
1281 if (special_filenames
1283 && (!fname || (*fname == '-' && !fname[1])))
1285 if (use == IOBUF_INPUT)
1299 else if (special_filenames && (fd = check_special_filename (fname)) != -1)
1300 return iobuf_fdopen (translate_file_handle (fd, use == IOBUF_INPUT ? 0 : 1),
1304 if (use == IOBUF_INPUT)
1305 fp = fd_cache_open (fname, opentype);
1307 fp = direct_open (fname, opentype, mode700);
1308 if (fp == GNUPG_INVALID_FD)
1312 a = iobuf_alloc (use, IOBUF_BUFFER_SIZE);
1313 fcx = xmalloc (sizeof *fcx + strlen (fname));
1315 fcx->print_only_name = print_only;
1316 strcpy (fcx->fname, fname);
1318 a->real_fname = xstrdup (fname);
1319 a->filter = file_filter;
1321 file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1323 log_debug ("iobuf-%d.%d: open '%s' desc=%s fd=%d\n",
1324 a->no, a->subno, fname, iobuf_desc (a), FD2INT (fcx->fp));
1330 iobuf_open (const char *fname)
1332 return do_open (fname, 1, IOBUF_INPUT, "rb", 0);
1336 iobuf_create (const char *fname, int mode700)
1338 return do_open (fname, 1, IOBUF_OUTPUT, "wb", mode700);
1342 iobuf_openrw (const char *fname)
1344 return do_open (fname, 0, IOBUF_OUTPUT, "r+b", 0);
1349 do_iobuf_fdopen (int fd, const char *mode, int keep_open)
1353 file_filter_ctx_t *fcx;
1358 a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1360 fcx = xmalloc (sizeof *fcx + 20);
1362 fcx->print_only_name = 1;
1363 fcx->keep_open = keep_open;
1364 sprintf (fcx->fname, "[fd %d]", fd);
1365 a->filter = file_filter;
1367 file_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1369 log_debug ("iobuf-%d.%d: fdopen%s '%s'\n",
1370 a->no, a->subno, keep_open? "_nc":"", fcx->fname);
1371 iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
1377 iobuf_fdopen (int fd, const char *mode)
1379 return do_iobuf_fdopen (fd, mode, 0);
1383 iobuf_fdopen_nc (int fd, const char *mode)
1385 return do_iobuf_fdopen (fd, mode, 1);
1390 iobuf_esopen (estream_t estream, const char *mode, int keep_open)
1393 file_es_filter_ctx_t *fcx;
1396 a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1398 fcx = xtrymalloc (sizeof *fcx + 30);
1400 fcx->print_only_name = 1;
1401 fcx->keep_open = keep_open;
1402 sprintf (fcx->fname, "[fd %p]", estream);
1403 a->filter = file_es_filter;
1405 file_es_filter (fcx, IOBUFCTRL_INIT, NULL, NULL, &len);
1407 log_debug ("iobuf-%d.%d: esopen%s '%s'\n",
1408 a->no, a->subno, keep_open? "_nc":"", fcx->fname);
1414 iobuf_sockopen (int fd, const char *mode)
1417 #ifdef HAVE_W32_SYSTEM
1418 sock_filter_ctx_t *scx;
1421 a = iobuf_alloc (strchr (mode, 'w') ? IOBUF_OUTPUT : IOBUF_INPUT,
1423 scx = xmalloc (sizeof *scx + 25);
1425 scx->print_only_name = 1;
1426 sprintf (scx->fname, "[sock %d]", fd);
1427 a->filter = sock_filter;
1429 sock_filter (scx, IOBUFCTRL_INIT, NULL, NULL, &len);
1431 log_debug ("iobuf-%d.%d: sockopen '%s'\n", a->no, a->subno, scx->fname);
1432 iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
1434 a = iobuf_fdopen (fd, mode);
1440 iobuf_ioctl (iobuf_t a, iobuf_ioctl_t cmd, int intval, void *ptrval)
1442 if (cmd == IOBUF_IOCTL_KEEP_OPEN)
1444 /* Keep system filepointer/descriptor open. This was used in
1445 the past by http.c; this ioctl is not directly used
1448 log_debug ("iobuf-%d.%d: ioctl '%s' keep_open=%d\n",
1449 a ? a->no : -1, a ? a->subno : -1, iobuf_desc (a),
1451 for (; a; a = a->chain)
1452 if (!a->chain && a->filter == file_filter)
1454 file_filter_ctx_t *b = a->filter_ov;
1455 b->keep_open = intval;
1458 #ifdef HAVE_W32_SYSTEM
1459 else if (!a->chain && a->filter == sock_filter)
1461 sock_filter_ctx_t *b = a->filter_ov;
1462 b->keep_open = intval;
1467 else if (cmd == IOBUF_IOCTL_INVALIDATE_CACHE)
1470 log_debug ("iobuf-*.*: ioctl '%s' invalidate\n",
1471 ptrval ? (char *) ptrval : "?");
1472 if (!a && !intval && ptrval)
1474 if (fd_cache_invalidate (ptrval))
1479 else if (cmd == IOBUF_IOCTL_NO_CACHE)
1482 log_debug ("iobuf-%d.%d: ioctl '%s' no_cache=%d\n",
1483 a ? a->no : -1, a ? a->subno : -1, iobuf_desc (a),
1485 for (; a; a = a->chain)
1486 if (!a->chain && a->filter == file_filter)
1488 file_filter_ctx_t *b = a->filter_ov;
1489 b->no_cache = intval;
1492 #ifdef HAVE_W32_SYSTEM
1493 else if (!a->chain && a->filter == sock_filter)
1495 sock_filter_ctx_t *b = a->filter_ov;
1496 b->no_cache = intval;
1501 else if (cmd == IOBUF_IOCTL_FSYNC)
1503 /* Do a fsync on the open fd and return any errors to the caller
1504 of iobuf_ioctl. Note that we work on a file name here. */
1506 log_debug ("iobuf-*.*: ioctl '%s' fsync\n",
1507 ptrval? (const char*)ptrval:"<null>");
1509 if (!a && !intval && ptrval)
1511 return fd_cache_synchronize (ptrval);
1521 * Register an i/o filter.
1524 iobuf_push_filter (iobuf_t a,
1525 int (*f) (void *opaque, int control,
1526 iobuf_t chain, byte * buf, size_t * len),
1529 return iobuf_push_filter2 (a, f, ov, 0);
1533 iobuf_push_filter2 (iobuf_t a,
1534 int (*f) (void *opaque, int control,
1535 iobuf_t chain, byte * buf, size_t * len),
1536 void *ov, int rel_ov)
1539 size_t dummy_len = 0;
1542 if (a->use == IOBUF_OUTPUT && (rc = filter_flush (a)))
1545 if (a->subno >= MAX_NESTING_FILTER)
1547 log_error ("i/o filter too deeply nested - corrupted data?\n");
1548 return GPG_ERR_BAD_DATA;
1551 /* We want to create a new filter and put it in front of A. A
1552 simple implementation would do:
1554 b = iobuf_alloc (...);
1558 This is a bit problematic: A is the head of the pipeline and
1559 there are potentially many pointers to it. Requiring the caller
1560 to update all of these pointers is a burden.
1562 An alternative implementation would add a level of indirection.
1563 For instance, we could use a pipeline object, which contains a
1564 pointer to the first filter in the pipeline. This is not what we
1567 Instead, we allocate a new buffer (B) and copy the first filter's
1568 state into that and use the initial buffer (A) for the new
1569 filter. One limitation of this approach is that it is not
1570 practical to maintain a pointer to a specific filter's state.
1577 +----------+ +----------+
1578 | filter x |--------->| filter y |---->....
1579 +----------+ +----------+
1588 +----------+ +----------+
1589 | filter w | | filter y |---->....
1590 +----------+ +----------+
1592 Note: filter x's address changed from 0x100 to 0x300, but A still
1593 points to the head of the pipeline.
1596 b = xmalloc (sizeof *b);
1597 memcpy (b, a, sizeof *b);
1598 /* fixme: it is stupid to keep a copy of the name at every level
1599 * but we need the name somewhere because the name known by file_filter
1600 * may have been released when we need the name of the file */
1601 b->real_fname = a->real_fname ? xstrdup (a->real_fname) : NULL;
1602 /* remove the filter stuff from the new stream */
1604 a->filter_ov = NULL;
1605 a->filter_ov_owner = 0;
1607 if (a->use == IOBUF_OUTPUT_TEMP)
1608 /* A TEMP filter buffers any data sent to it; it does not forward
1609 any data down the pipeline. If we add a new filter to the
1610 pipeline, it shouldn't also buffer data. It should send it
1611 downstream to be buffered. Thus, the correct type for a filter
1612 added in front of an IOBUF_OUTPUT_TEMP filter is IOBUF_OUPUT, not
1613 IOBUF_OUTPUT_TEMP. */
1615 a->use = IOBUF_OUTPUT;
1617 /* When pipeline is written to, the temp buffer's size is
1618 increased accordingly. We don't need to allocate a 10 MB
1619 buffer for a non-terminal filter. Just use the default
1621 a->d.size = IOBUF_BUFFER_SIZE;
1623 else if (a->use == IOBUF_INPUT_TEMP)
1624 /* Same idea as above. */
1626 a->use = IOBUF_INPUT;
1627 a->d.size = IOBUF_BUFFER_SIZE;
1630 /* The new filter (A) gets a new buffer.
1632 If the pipeline is an output or temp pipeline, then giving the
1633 buffer to the new filter means that data that was written before
1634 the filter was pushed gets sent to the filter. That's clearly
1637 If the pipeline is an input pipeline, then giving the buffer to
1638 the new filter (A) means that data that has read from (B), but
1639 not yet read from the pipeline won't be processed by the new
1640 filter (A)! That's certainly not what we want. */
1641 a->d.buf = xmalloc (a->d.size);
1645 /* disable nlimit for the new stream */
1646 a->ntotal = b->ntotal + b->nbytes;
1647 a->nlimit = a->nbytes = 0;
1649 /* make a link from the new stream to the original stream */
1652 /* setup the function on the new stream */
1655 a->filter_ov_owner = rel_ov;
1657 a->subno = b->subno + 1;
1661 log_debug ("iobuf-%d.%d: push '%s'\n",
1662 a->no, a->subno, iobuf_desc (a));
1666 /* now we can initialize the new function if we have one */
1667 if (a->filter && (rc = a->filter (a->filter_ov, IOBUFCTRL_INIT, a->chain,
1669 log_error ("IOBUFCTRL_INIT failed: %s\n", gpg_strerror (rc));
1674 * Remove an i/o filter.
1677 pop_filter (iobuf_t a, int (*f) (void *opaque, int control,
1678 iobuf_t chain, byte * buf, size_t * len),
1682 size_t dummy_len = 0;
1686 log_debug ("iobuf-%d.%d: pop '%s'\n",
1687 a->no, a->subno, iobuf_desc (a));
1688 if (a->use == IOBUF_INPUT_TEMP || a->use == IOBUF_OUTPUT_TEMP)
1690 /* This should be the last filter in the pipeline. */
1691 assert (! a->chain);
1695 { /* this is simple */
1699 xfree (a->real_fname);
1700 memcpy (a, b, sizeof *a);
1704 for (b = a; b; b = b->chain)
1705 if (b->filter == f && (!ov || b->filter_ov == ov))
1708 log_bug ("pop_filter(): filter function not found\n");
1710 /* flush this stream if it is an output stream */
1711 if (a->use == IOBUF_OUTPUT && (rc = filter_flush (b)))
1713 log_error ("filter_flush failed in pop_filter: %s\n", gpg_strerror (rc));
1716 /* and tell the filter to free it self */
1717 if (b->filter && (rc = b->filter (b->filter_ov, IOBUFCTRL_FREE, b->chain,
1720 log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
1723 if (b->filter_ov && b->filter_ov_owner)
1725 xfree (b->filter_ov);
1726 b->filter_ov = NULL;
1730 /* and see how to remove it */
1731 if (a == b && !b->chain)
1732 log_bug ("can't remove the last filter from the chain\n");
1734 { /* remove the first iobuf from the chain */
1735 /* everything from b is copied to a. This is save because
1736 * a flush has been done on the to be removed entry
1740 xfree (a->real_fname);
1741 memcpy (a, b, sizeof *a);
1744 log_debug ("iobuf-%d.%d: popped filter\n", a->no, a->subno);
1747 { /* remove the last iobuf from the chain */
1748 log_bug ("Ohh jeee, trying to remove a head filter\n");
1751 { /* remove an intermediate iobuf from the chain */
1752 log_bug ("Ohh jeee, trying to remove an intermediate filter\n");
1760 * read underflow: read more bytes into the buffer and return
1761 * the first byte or -1 on EOF.
1764 underflow (iobuf_t a, int clear_pending_eof)
1770 log_debug ("iobuf-%d.%d: underflow: buffer size: %d; still buffered: %d => space for %d bytes\n",
1772 (int) a->d.size, (int) (a->d.len - a->d.start),
1773 (int) (a->d.size - (a->d.len - a->d.start)));
1775 if (a->use == IOBUF_INPUT_TEMP)
1776 /* By definition, there isn't more data to read into the
1780 assert (a->use == IOBUF_INPUT);
1782 /* If there is still some buffered data, then move it to the start
1783 of the buffer and try to fill the end of the buffer. (This is
1784 useful if we are called from iobuf_peek().) */
1785 assert (a->d.start <= a->d.len);
1786 a->d.len -= a->d.start;
1787 memmove (a->d.buf, &a->d.buf[a->d.start], a->d.len);
1790 if (a->d.len == 0 && a->filter_eof)
1791 /* The last time we tried to read from this filter, we got an EOF.
1792 We couldn't return the EOF, because there was buffered data.
1793 Since there is no longer any buffered data, return the
1797 log_debug ("iobuf-%d.%d: underflow: eof (pending eof)\n",
1799 if (! clear_pending_eof)
1803 /* A filter follows this one. Free this filter. */
1805 iobuf_t b = a->chain;
1807 log_debug ("iobuf-%d.%d: filter popped (pending EOF returned)\n",
1810 xfree (a->real_fname);
1811 memcpy (a, b, sizeof *a);
1816 a->filter_eof = 0; /* for the top level filter */
1817 return -1; /* return one(!) EOF */
1820 if (a->d.len == 0 && a->error)
1821 /* The last time we tried to read from this filter, we got an
1822 error. We couldn't return the error, because there was
1823 buffered data. Since there is no longer any buffered data,
1824 return the error. */
1827 log_debug ("iobuf-%d.%d: pending error (%s) returned\n",
1828 a->no, a->subno, gpg_strerror (a->error));
1832 if (a->filter && ! a->filter_eof && ! a->error)
1833 /* We have a filter function and the last time we tried to read we
1834 didn't get an EOF or an error. Try to fill the buffer. */
1836 /* Be careful to account for any buffered data. */
1837 len = a->d.size - a->d.len;
1839 log_debug ("iobuf-%d.%d: underflow: A->FILTER (%lu bytes)\n",
1840 a->no, a->subno, (ulong) len);
1842 /* There is no space for more data. Don't bother calling
1846 rc = a->filter (a->filter_ov, IOBUFCTRL_UNDERFLOW, a->chain,
1847 &a->d.buf[a->d.len], &len);
1851 log_debug ("iobuf-%d.%d: A->FILTER() returned rc=%d (%s), read %lu bytes\n",
1853 rc, rc == 0 ? "ok" : rc == -1 ? "EOF" : gpg_strerror (rc),
1855 /* if( a->no == 1 ) */
1856 /* log_hexdump (" data:", a->d.buf, len); */
1861 size_t dummy_len = 0;
1863 /* Tell the filter to free itself */
1864 if ((rc = a->filter (a->filter_ov, IOBUFCTRL_FREE, a->chain,
1866 log_error ("IOBUFCTRL_FREE failed: %s\n", gpg_strerror (rc));
1868 /* Free everything except for the internal buffer. */
1869 if (a->filter_ov && a->filter_ov_owner)
1870 xfree (a->filter_ov);
1871 a->filter_ov = NULL;
1875 if (clear_pending_eof && a->d.len == 0 && a->chain)
1876 /* We don't need to keep this filter around at all:
1879 - we have no buffered data
1880 - a filter follows this one.
1882 Unlink this filter. */
1884 iobuf_t b = a->chain;
1886 log_debug ("iobuf-%d.%d: pop in underflow (nothing buffered, got EOF)\n",
1889 xfree (a->real_fname);
1890 memcpy (a, b, sizeof *a);
1897 else if (a->d.len == 0)
1898 /* We can't unlink this filter (it is the only one in the
1899 pipeline), but we can immediately return EOF. */
1903 /* Record the error. */
1908 /* There is no buffered data. Immediately return EOF. */
1913 assert (a->d.start <= a->d.len);
1914 if (a->d.start < a->d.len)
1915 return a->d.buf[a->d.start++];
1923 filter_flush (iobuf_t a)
1928 if (a->use == IOBUF_OUTPUT_TEMP)
1929 { /* increase the temp buffer */
1930 size_t newsize = a->d.size + IOBUF_BUFFER_SIZE;
1933 log_debug ("increasing temp iobuf from %lu to %lu\n",
1934 (ulong) a->d.size, (ulong) newsize);
1936 a->d.buf = xrealloc (a->d.buf, newsize);
1937 a->d.size = newsize;
1940 else if (a->use != IOBUF_OUTPUT)
1941 log_bug ("flush on non-output iobuf\n");
1942 else if (!a->filter)
1943 log_bug ("filter_flush: no filter\n");
1945 rc = a->filter (a->filter_ov, IOBUFCTRL_FLUSH, a->chain, a->d.buf, &len);
1946 if (!rc && len != a->d.len)
1948 log_info ("filter_flush did not write all!\n");
1949 rc = GPG_ERR_INTERNAL;
1960 iobuf_readbyte (iobuf_t a)
1964 if (a->use == IOBUF_OUTPUT || a->use == IOBUF_OUTPUT_TEMP)
1966 log_bug ("iobuf_readbyte called on a non-INPUT pipeline!\n");
1970 assert (a->d.start <= a->d.len);
1972 if (a->nlimit && a->nbytes >= a->nlimit)
1973 return -1; /* forced EOF */
1975 if (a->d.start < a->d.len)
1977 c = a->d.buf[a->d.start++];
1979 else if ((c = underflow (a, 1)) == -1)
1980 return -1; /* EOF */
1982 assert (a->d.start <= a->d.len);
1984 /* Note: if underflow doesn't return EOF, then it returns the first
1985 byte that was read and advances a->d.start appropriately. */
1993 iobuf_read (iobuf_t a, void *buffer, unsigned int buflen)
1995 unsigned char *buf = (unsigned char *)buffer;
1998 if (a->use == IOBUF_OUTPUT || a->use == IOBUF_OUTPUT_TEMP)
2000 log_bug ("iobuf_read called on a non-INPUT pipeline!\n");
2006 /* Handle special cases. */
2007 for (n = 0; n < buflen; n++)
2009 if ((c = iobuf_readbyte (a)) == -1)
2012 return -1; /* eof */
2028 if (n < buflen && a->d.start < a->d.len)
2029 /* Drain the buffer. */
2031 unsigned size = a->d.len - a->d.start;
2032 if (size > buflen - n)
2035 memcpy (buf, a->d.buf + a->d.start, size);
2042 /* Draining the internal buffer didn't fill BUFFER. Call
2043 underflow to read more data into the filter's internal
2046 if ((c = underflow (a, 1)) == -1)
2047 /* EOF. If we managed to read something, don't return EOF
2051 return n ? n : -1 /*EOF*/;
2066 iobuf_peek (iobuf_t a, byte * buf, unsigned buflen)
2070 assert (buflen > 0);
2071 assert (a->use == IOBUF_INPUT || a->use == IOBUF_INPUT_TEMP);
2073 if (buflen > a->d.size)
2074 /* We can't peek more than we can buffer. */
2077 /* Try to fill the internal buffer with enough data to satisfy the
2079 while (buflen > a->d.len - a->d.start)
2081 if (underflow (a, 0) == -1)
2082 /* EOF. We can't read any more. */
2085 /* Underflow consumes the first character (it's the return
2086 value). unget() it by resetting the "file position". */
2087 assert (a->d.start == 1);
2091 n = a->d.len - a->d.start;
2099 memcpy (buf, &a->d.buf[a->d.start], n);
2108 iobuf_writebyte (iobuf_t a, unsigned int c)
2112 if (a->use == IOBUF_INPUT || a->use == IOBUF_INPUT_TEMP)
2114 log_bug ("iobuf_writebyte called on an input pipeline!\n");
2118 if (a->d.len == a->d.size)
2119 if ((rc=filter_flush (a)))
2122 assert (a->d.len < a->d.size);
2123 a->d.buf[a->d.len++] = c;
2129 iobuf_write (iobuf_t a, const void *buffer, unsigned int buflen)
2131 const unsigned char *buf = (const unsigned char *)buffer;
2134 if (a->use == IOBUF_INPUT || a->use == IOBUF_INPUT_TEMP)
2136 log_bug ("iobuf_write called on an input pipeline!\n");
2142 if (buflen && a->d.len < a->d.size)
2144 unsigned size = a->d.size - a->d.len;
2147 memcpy (a->d.buf + a->d.len, buf, size);
2154 rc = filter_flush (a);
2165 iobuf_writestr (iobuf_t a, const char *buf)
2167 if (a->use == IOBUF_INPUT || a->use == IOBUF_INPUT_TEMP)
2169 log_bug ("iobuf_writestr called on an input pipeline!\n");
2173 return iobuf_write (a, buf, strlen (buf));
2179 iobuf_write_temp (iobuf_t dest, iobuf_t source)
2181 assert (source->use == IOBUF_OUTPUT || source->use == IOBUF_OUTPUT_TEMP);
2182 assert (dest->use == IOBUF_OUTPUT || dest->use == IOBUF_OUTPUT_TEMP);
2184 iobuf_flush_temp (source);
2185 return iobuf_write (dest, source->d.buf, source->d.len);
2189 iobuf_temp_to_buffer (iobuf_t a, byte * buffer, size_t buflen)
2195 int rc = filter_flush (a);
2197 log_bug ("Flushing iobuf %d.%d (%s) from iobuf_temp_to_buffer failed. Ignoring.\n",
2198 a->no, a->subno, iobuf_desc (a));
2207 memcpy (buffer, a->d.buf, n);
2213 iobuf_flush_temp (iobuf_t temp)
2215 if (temp->use == IOBUF_INPUT || temp->use == IOBUF_INPUT_TEMP)
2216 log_bug ("iobuf_writestr called on an input pipeline!\n");
2218 pop_filter (temp, temp->filter, NULL);
2223 iobuf_set_limit (iobuf_t a, off_t nlimit)
2230 a->ntotal += a->nbytes;
2237 iobuf_get_filelength (iobuf_t a, int *overflow)
2244 /* Hmmm: file_filter may have already been removed */
2245 for ( ; a->chain; a = a->chain )
2248 if (a->filter != file_filter)
2252 file_filter_ctx_t *b = a->filter_ov;
2253 gnupg_fd_t fp = b->fp;
2255 #if defined(HAVE_W32_SYSTEM)
2257 static int (* __stdcall get_file_size_ex) (void *handle,
2258 LARGE_INTEGER *r_size);
2259 static int get_file_size_ex_initialized;
2261 if (!get_file_size_ex_initialized)
2265 handle = dlopen ("kernel32.dll", RTLD_LAZY);
2268 get_file_size_ex = dlsym (handle, "GetFileSizeEx");
2269 if (!get_file_size_ex)
2272 get_file_size_ex_initialized = 1;
2275 if (get_file_size_ex)
2277 /* This is a newer system with GetFileSizeEx; we use this
2278 then because it seem that GetFileSize won't return a
2279 proper error in case a file is larger than 4GB. */
2280 LARGE_INTEGER exsize;
2282 if (get_file_size_ex (fp, &exsize))
2284 if (!exsize.u.HighPart)
2285 return exsize.u.LowPart;
2293 if ((size=GetFileSize (fp, NULL)) != 0xffffffff)
2296 log_error ("GetFileSize for handle %p failed: %s\n",
2297 fp, w32_strerror (0));
2299 if ( !fstat (FD2INT (fp), &st) )
2301 log_error("fstat() failed: %s\n", strerror(errno) );
2310 iobuf_get_fd (iobuf_t a)
2312 for (; a->chain; a = a->chain)
2315 if (a->filter != file_filter)
2319 file_filter_ctx_t *b = a->filter_ov;
2320 gnupg_fd_t fp = b->fp;
2328 iobuf_tell (iobuf_t a)
2330 return a->ntotal + a->nbytes;
2334 #if !defined(HAVE_FSEEKO) && !defined(fseeko)
2336 #ifdef HAVE_LIMITS_H
2337 # include <limits.h>
2340 # define LONG_MAX ((long) ((unsigned long) -1 >> 1))
2343 # define LONG_MIN (-1 - LONG_MAX)
2347 * A substitute for fseeko, for hosts that don't have it.
2350 fseeko (FILE * stream, off_t newpos, int whence)
2352 while (newpos != (long) newpos)
2354 long pos = newpos < 0 ? LONG_MIN : LONG_MAX;
2355 if (fseek (stream, pos, whence) != 0)
2360 return fseek (stream, (long) newpos, whence);
2365 iobuf_seek (iobuf_t a, off_t newpos)
2367 file_filter_ctx_t *b = NULL;
2369 if (a->use == IOBUF_OUTPUT || a->use == IOBUF_INPUT)
2371 /* Find the last filter in the pipeline. */
2372 for (; a->chain; a = a->chain)
2375 if (a->filter != file_filter)
2380 #ifdef HAVE_W32_SYSTEM
2381 if (SetFilePointer (b->fp, newpos, NULL, FILE_BEGIN) == 0xffffffff)
2383 log_error ("SetFilePointer failed on handle %p: ec=%d\n",
2384 b->fp, (int) GetLastError ());
2388 if (lseek (b->fp, newpos, SEEK_SET) == (off_t) - 1)
2390 log_error ("can't lseek: %s\n", strerror (errno));
2394 /* Discard the buffer it is not a temp stream. */
2404 /* It is impossible for A->CHAIN to be non-NULL. If A is an INPUT
2405 or OUTPUT buffer, then we find the last filter, which is defined
2406 as A->CHAIN being NULL. If A is a TEMP filter, then A must be
2407 the only filter in the pipe: when iobuf_push_filter adds a filter
2408 to the front of a pipeline, it sets the new filter to be an
2409 OUTPUT filter if the pipeline is an OUTPUT or TEMP pipeline and
2410 to be an INPUT filter if the pipeline is an INPUT pipeline.
2411 Thus, only the last filter in a TEMP pipeline can be a */
2413 /* remove filters, but the last */
2415 log_debug ("pop_filter called in iobuf_seek - please report\n");
2417 pop_filter (a, a->filter, NULL);
2424 iobuf_get_real_fname (iobuf_t a)
2427 return a->real_fname;
2429 /* the old solution */
2430 for (; a; a = a->chain)
2431 if (!a->chain && a->filter == file_filter)
2433 file_filter_ctx_t *b = a->filter_ov;
2434 return b->print_only_name ? NULL : b->fname;
2441 iobuf_get_fname (iobuf_t a)
2443 for (; a; a = a->chain)
2444 if (!a->chain && a->filter == file_filter)
2446 file_filter_ctx_t *b = a->filter_ov;
2453 iobuf_get_fname_nonnull (iobuf_t a)
2457 fname = iobuf_get_fname (a);
2458 return fname? fname : "[?]";
2463 * enable partial block mode as described in the OpenPGP draft.
2464 * LEN is the first length byte on read, but ignored on writes.
2467 iobuf_set_partial_block_mode (iobuf_t a, size_t len)
2469 block_filter_ctx_t *ctx = xcalloc (1, sizeof *ctx);
2474 if (a->use == IOBUF_INPUT)
2475 log_debug ("pop_filter called in set_partial_block_mode"
2476 " - please report\n");
2477 /* XXX: This pop_filter doesn't make sense. Since we haven't
2478 actually added the filter to the pipeline yet, why are we
2479 popping anything? Moreover, since we don't report an error,
2480 the caller won't directly see an error. I think that it
2481 would be better to push the filter and set a->error to
2482 GPG_ERR_BAD_DATA, but Werner thinks it's impossible for len
2483 to be 0 (but he doesn't want to remove the check just in
2485 pop_filter (a, block_filter, NULL);
2492 iobuf_push_filter (a, block_filter, ctx);
2499 iobuf_read_line (iobuf_t a, byte ** addr_of_buffer,
2500 unsigned *length_of_buffer, unsigned *max_length)
2503 char *buffer = (char *)*addr_of_buffer;
2504 unsigned length = *length_of_buffer;
2505 unsigned nbytes = 0;
2506 unsigned maxlen = *max_length;
2509 /* The code assumes that we have space for at least a newline and a
2510 NUL character in the buffer. This requires at least 2 bytes. We
2511 don't complicate the code by handling the stupid corner case, but
2512 simply assert that it can't happen. */
2513 assert (length >= 2 || maxlen >= 2);
2515 if (!buffer || length <= 1)
2516 /* must allocate a new buffer */
2518 length = 256 <= maxlen ? 256 : maxlen;
2519 buffer = xrealloc (buffer, length);
2520 *addr_of_buffer = (unsigned char *)buffer;
2521 *length_of_buffer = length;
2525 while ((c = iobuf_get (a)) != -1)
2532 if (nbytes == length - 1)
2533 /* We don't have enough space to add a \n and a \0. Increase
2536 if (length == maxlen)
2537 /* We reached the buffer's size limit! */
2539 /* Skip the rest of the line. */
2540 while (c != '\n' && (c = iobuf_get (a)) != -1)
2543 /* p is pointing at the last byte in the buffer. We
2544 always terminate the line with "\n\0" so overwrite
2545 the previous byte with a \n. */
2546 assert (p > buffer);
2549 /* Indicate truncation. */
2554 length += length < 1024 ? 256 : 1024;
2555 if (length > maxlen)
2558 buffer = xrealloc (buffer, length);
2559 *addr_of_buffer = (unsigned char *)buffer;
2560 *length_of_buffer = length;
2561 p = buffer + nbytes;
2564 /* Add the terminating NUL. */
2567 /* Return the number of characters written to the buffer including
2568 the newline, but not including the terminating NUL. */
2573 translate_file_handle (int fd, int for_write)
2575 #if defined(HAVE_W32CE_SYSTEM)
2576 /* This is called only with one of the special filenames. Under
2577 W32CE the FD here is not a file descriptor but a rendezvous id,
2578 thus we need to finish the pipe first. */
2579 fd = _assuan_w32ce_finish_pipe (fd, for_write);
2580 #elif defined(HAVE_W32_SYSTEM)
2587 x = (int) GetStdHandle (STD_INPUT_HANDLE);
2589 x = (int) GetStdHandle (STD_OUTPUT_HANDLE);
2591 x = (int) GetStdHandle (STD_ERROR_HANDLE);
2596 log_debug ("GetStdHandle(%d) failed: ec=%d\n",
2597 fd, (int) GetLastError ());
2609 iobuf_skip_rest (iobuf_t a, unsigned long n, int partial)
2615 if (a->nofast || a->d.start >= a->d.len)
2617 if (iobuf_readbyte (a) == -1)
2624 unsigned long count = a->d.len - a->d.start;
2626 a->d.start = a->d.len;
2632 unsigned long remaining = n;
2633 while (remaining > 0)
2635 if (a->nofast || a->d.start >= a->d.len)
2637 if (iobuf_readbyte (a) == -1)
2645 unsigned long count = a->d.len - a->d.start;
2646 if (count > remaining)
2651 a->d.start += count;