1/* fflush.c -- allow flushing input streams 2 Copyright (C) 2007-2010 Free Software Foundation, Inc. 3 4 This program is free software: you can redistribute it and/or modify 5 it under the terms of the GNU General Public License as published by 6 the Free Software Foundation; either version 3 of the License, or 7 (at your option) any later version. 8 9 This program is distributed in the hope that it will be useful, 10 but WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 GNU General Public License for more details. 13 14 You should have received a copy of the GNU General Public License 15 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 16 17/* Written by Eric Blake. */ 18 19#include <config.h> 20 21/* Specification. */ 22#include <stdio.h> 23 24#include <errno.h> 25#include <unistd.h> 26 27#include "freading.h" 28 29#include "stdio-impl.h" 30 31#undef fflush 32 33 34#if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ 35 36/* Clear the stream's ungetc buffer, preserving the value of ftello (fp). */ 37static inline void 38clear_ungetc_buffer_preserving_position (FILE *fp) 39{ 40 if (fp->_flags & _IO_IN_BACKUP) 41 /* _IO_free_backup_area is a bit complicated. Simply call fseek. */ 42 fseeko (fp, 0, SEEK_CUR); 43} 44 45#else 46 47/* Clear the stream's ungetc buffer. May modify the value of ftello (fp). */ 48static inline void 49clear_ungetc_buffer (FILE *fp) 50{ 51# if defined __sferror || defined __DragonFly__ /* FreeBSD, NetBSD, OpenBSD, DragonFly, MacOS X, Cygwin */ 52 if (HASUB (fp)) 53 { 54 fp_->_p += fp_->_r; 55 fp_->_r = 0; 56 } 57# elif defined __EMX__ /* emx+gcc */ 58 if (fp->_ungetc_count > 0) 59 { 60 fp->_ungetc_count = 0; 61 fp->_rcount = - fp->_rcount; 62 } 63# elif defined _IOERR /* AIX, HP-UX, IRIX, OSF/1, Solaris, OpenServer, mingw */ 64 /* Nothing to do. */ 65# else /* other implementations */ 66 fseeko (fp, 0, SEEK_CUR); 67# endif 68} 69 70#endif 71 72#if (defined __sferror || defined __DragonFly__) && defined __SNPT /* FreeBSD, NetBSD, OpenBSD, DragonFly, MacOS X, Cygwin */ 73 74static inline int 75disable_seek_optimization (FILE *fp) 76{ 77 int saved_flags = fp_->_flags & (__SOPT | __SNPT); 78 fp_->_flags = (fp_->_flags & ~__SOPT) | __SNPT; 79 return saved_flags; 80} 81 82static inline void 83restore_seek_optimization (FILE *fp, int saved_flags) 84{ 85 fp_->_flags = (fp_->_flags & ~(__SOPT | __SNPT)) | saved_flags; 86} 87 88#endif 89 90static inline void 91update_fpos_cache (FILE *fp, off_t pos) 92{ 93#if defined __sferror || defined __DragonFly__ /* FreeBSD, NetBSD, OpenBSD, DragonFly, MacOS X, Cygwin */ 94# if defined __CYGWIN__ 95 /* fp_->_offset is typed as an integer. */ 96 fp_->_offset = pos; 97# else 98 /* fp_->_offset is an fpos_t. */ 99 /* Use a union, since on NetBSD, the compilation flags determine 100 whether fpos_t is typedef'd to off_t or a struct containing a 101 single off_t member. */ 102 union 103 { 104 fpos_t f; 105 off_t o; 106 } u; 107 u.o = pos; 108 fp_->_offset = u.f; 109# endif 110 fp_->_flags |= __SOFF; 111#endif 112} 113 114/* Flush all pending data on STREAM according to POSIX rules. Both 115 output and seekable input streams are supported. */ 116int 117rpl_fflush (FILE *stream) 118{ 119 /* When stream is NULL, POSIX and C99 only require flushing of "output 120 streams and update streams in which the most recent operation was not 121 input", and all implementations do this. 122 123 When stream is "an output stream or an update stream in which the most 124 recent operation was not input", POSIX and C99 requires that fflush 125 writes out any buffered data, and all implementations do this. 126 127 When stream is, however, an input stream or an update stream in 128 which the most recent operation was input, C99 specifies nothing, 129 and POSIX only specifies behavior if the stream is seekable. 130 mingw, in particular, drops the input buffer, leaving the file 131 descriptor positioned at the end of the input buffer. I.e. ftell 132 (stream) is lost. We don't want to call the implementation's 133 fflush in this case. 134 135 We test ! freading (stream) here, rather than fwriting (stream), because 136 what we need to know is whether the stream holds a "read buffer", and on 137 mingw this is indicated by _IOREAD, regardless of _IOWRT. */ 138 if (stream == NULL || ! freading (stream)) 139 return fflush (stream); 140 141#if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */ 142 143 clear_ungetc_buffer_preserving_position (stream); 144 145 return fflush (stream); 146 147#else 148 { 149 /* Notes about the file-position indicator: 150 1) The file position indicator is incremented by fgetc() and decremented 151 by ungetc(): 152 <http://www.opengroup.org/susv3/functions/fgetc.html> 153 "... the fgetc() function shall ... advance the associated file 154 position indicator for the stream ..." 155 <http://www.opengroup.org/susv3/functions/ungetc.html> 156 "The file-position indicator is decremented by each successful 157 call to ungetc()..." 158 2) <http://www.opengroup.org/susv3/functions/ungetc.html> says: 159 "The value of the file-position indicator for the stream after 160 reading or discarding all pushed-back bytes shall be the same 161 as it was before the bytes were pushed back." 162 Here we are discarding all pushed-back bytes. But more specifically, 163 3) <http://www.opengroup.org/austin/aardvark/latest/xshbug3.txt> says: 164 "[After fflush(),] the file offset of the underlying open file 165 description shall be set to the file position of the stream, and 166 any characters pushed back onto the stream by ungetc() ... shall 167 be discarded." */ 168 169 /* POSIX does not specify fflush behavior for non-seekable input 170 streams. Some implementations purge unread data, some return 171 EBADF, some do nothing. */ 172 off_t pos = ftello (stream); 173 if (pos == -1) 174 { 175 errno = EBADF; 176 return EOF; 177 } 178 179 /* Clear the ungetc buffer. */ 180 clear_ungetc_buffer (stream); 181 182 /* To get here, we must be flushing a seekable input stream, so the 183 semantics of fpurge are now appropriate to clear the buffer. To 184 avoid losing data, the lseek is also necessary. */ 185 { 186 int result = fpurge (stream); 187 if (result != 0) 188 return result; 189 } 190 191# if (defined __sferror || defined __DragonFly__) && defined __SNPT /* FreeBSD, NetBSD, OpenBSD, DragonFly, MacOS X, Cygwin */ 192 193 { 194 /* Disable seek optimization for the next fseeko call. This tells the 195 following fseeko call to seek to the desired position directly, rather 196 than to seek to a block-aligned boundary. */ 197 int saved_flags = disable_seek_optimization (stream); 198 int result = fseeko (stream, pos, SEEK_SET); 199 200 restore_seek_optimization (stream, saved_flags); 201 return result; 202 } 203 204# else 205 206 pos = lseek (fileno (stream), pos, SEEK_SET); 207 if (pos == -1) 208 return EOF; 209 /* After a successful lseek, update the file descriptor's position cache 210 in the stream. */ 211 update_fpos_cache (stream, pos); 212 213 return 0; 214 215# endif 216 } 217#endif 218} 219