libio/libioP.h

   1 /* Copyright (C) 1993-2023 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library 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 GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.
  17
  18    As a special exception, if you link the code in this file with
  19    files compiled with a GNU compiler to produce an executable,
  20    that does not cause the resulting executable to be covered by
  21    the GNU Lesser General Public License.  This exception does not
  22    however invalidate any other reasons why the executable file
  23    might be covered by the GNU Lesser General Public License.
  24    This exception applies to code released by its copyright holders
  25    in files containing the exception.  */
  26
  27 /* NOTE: libio is now exclusively used only by glibc since libstdc++ has its
  28    own implementation.  As a result, functions that were implemented for C++
  29    (like *sputn) may no longer have C++ semantics.  This is of course only
  30    relevant for internal callers of these functions since these functions are
  31    not intended for external use otherwise.
  32
  33    FIXME: All of the C++ cruft eventually needs to go away.  */
  34
  35 #ifndef _LIBIOP_H
  36 #define _LIBIOP_H 1
  37
  38 #include <stddef.h>
  39
  40 #include <errno.h>
  41 #include <libc-lock.h>
  42
  43 #include <math_ldbl_opt.h>
  44
  45 #include <stdio.h>
  46 #include <libio/libio.h>
  47 #include "iolibio.h"
  48
  49 #include <shlib-compat.h>
  50 #include <pointer_guard.h>
  51
  52 /* For historical reasons this is the name of the sysdeps header that
  53    adjusts the libio configuration.  */
  54 #include <_G_config.h>
  55
  56 #define _IO_seek_set 0
  57 #define _IO_seek_cur 1
  58 #define _IO_seek_end 2
  59
  60 /* THE JUMPTABLE FUNCTIONS.
  61
  62  * The _IO_FILE type is used to implement the FILE type in GNU libc,
  63  * as well as the streambuf class in GNU iostreams for C++.
  64  * These are all the same, just used differently.
  65  * An _IO_FILE (or FILE) object is allows followed by a pointer to
  66  * a jump table (of pointers to functions).  The pointer is accessed
  67  * with the _IO_JUMPS macro.  The jump table has an eccentric format,
  68  * so as to be compatible with the layout of a C++ virtual function table.
  69  * (as implemented by g++).  When a pointer to a streambuf object is
  70  * coerced to an (FILE*), then _IO_JUMPS on the result just
  71  * happens to point to the virtual function table of the streambuf.
  72  * Thus the _IO_JUMPS function table used for C stdio/libio does
  73  * double duty as the virtual function table for C++ streambuf.
  74  *
  75  * The entries in the _IO_JUMPS function table (and hence also the
  76  * virtual functions of a streambuf) are described below.
  77  * The first parameter of each function entry is the _IO_FILE/streambuf
  78  * object being acted on (i.e. the 'this' parameter).
  79  */
  80
  81 /* Setting this macro to 1 enables the use of the _vtable_offset bias
  82    in _IO_JUMPS_FUNCS, below.  This is only needed for new-format
  83    _IO_FILE in libc that must support old binaries (see oldfileops.c).  */
  84 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1) && !defined _IO_USE_OLD_IO_FILE
  85 # define _IO_JUMPS_OFFSET 1
  86 #else
  87 # define _IO_JUMPS_OFFSET 0
  88 #endif
  89
  90 /* Type of MEMBER in struct type TYPE.  */
  91 #define _IO_MEMBER_TYPE(TYPE, MEMBER) __typeof__ (((TYPE){}).MEMBER)
  92
  93 /* Essentially ((TYPE *) THIS)->MEMBER, but avoiding the aliasing
  94    violation in case THIS has a different pointer type.  */
  95 #define _IO_CAST_FIELD_ACCESS(THIS, TYPE, MEMBER) \
  96   (*(_IO_MEMBER_TYPE (TYPE, MEMBER) *)(((char *) (THIS)) \
  97                                        + offsetof(TYPE, MEMBER)))
  98
  99 #define _IO_JUMPS(THIS) (THIS)->vtable
 100 #define _IO_JUMPS_FILE_plus(THIS) \
 101   _IO_CAST_FIELD_ACCESS ((THIS), struct _IO_FILE_plus, vtable)
 102 #define _IO_WIDE_JUMPS(THIS) \
 103   _IO_CAST_FIELD_ACCESS ((THIS), struct _IO_FILE, _wide_data)->_wide_vtable
 104 #define _IO_CHECK_WIDE(THIS) \
 105   (_IO_CAST_FIELD_ACCESS ((THIS), struct _IO_FILE, _wide_data) != NULL)
 106
 107 #if _IO_JUMPS_OFFSET
 108 # define _IO_JUMPS_FUNC(THIS) \
 109   (IO_validate_vtable                                                   \
 110    (*(struct _IO_jump_t **) ((void *) &_IO_JUMPS_FILE_plus (THIS)       \
 111                              + (THIS)->_vtable_offset)))
 112 # define _IO_JUMPS_FUNC_UPDATE(THIS, VTABLE)                            \
 113   (*(const struct _IO_jump_t **) ((void *) &_IO_JUMPS_FILE_plus (THIS)  \
 114                                   + (THIS)->_vtable_offset) = (VTABLE))
 115 # define _IO_vtable_offset(THIS) (THIS)->_vtable_offset
 116 #else
 117 # define _IO_JUMPS_FUNC(THIS) (IO_validate_vtable (_IO_JUMPS_FILE_plus (THIS)))
 118 # define _IO_JUMPS_FUNC_UPDATE(THIS, VTABLE) \
 119   (_IO_JUMPS_FILE_plus (THIS) = (VTABLE))
 120 # define _IO_vtable_offset(THIS) 0
 121 #endif
 122 #define _IO_WIDE_JUMPS_FUNC(THIS) _IO_WIDE_JUMPS(THIS)
 123 #define JUMP_FIELD(TYPE, NAME) TYPE NAME
 124 #define JUMP0(FUNC, THIS) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS)
 125 #define JUMP1(FUNC, THIS, X1) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1)
 126 #define JUMP2(FUNC, THIS, X1, X2) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1, X2)
 127 #define JUMP3(FUNC, THIS, X1,X2,X3) (_IO_JUMPS_FUNC(THIS)->FUNC) (THIS, X1,X2, X3)
 128 #define JUMP_INIT(NAME, VALUE) VALUE
 129 #define JUMP_INIT_DUMMY JUMP_INIT(dummy, 0), JUMP_INIT (dummy2, 0)
 130
 131 #define WJUMP0(FUNC, THIS) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS)
 132 #define WJUMP1(FUNC, THIS, X1) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS, X1)
 133 #define WJUMP2(FUNC, THIS, X1, X2) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS, X1, X2)
 134 #define WJUMP3(FUNC, THIS, X1,X2,X3) (_IO_WIDE_JUMPS_FUNC(THIS)->FUNC) (THIS, X1,X2, X3)
 135
 136 /* The 'finish' function does any final cleaning up of an _IO_FILE object.
 137    It does not delete (free) it, but does everything else to finalize it.
 138    It matches the streambuf::~streambuf virtual destructor.  */
 139 typedef void (*_IO_finish_t) (FILE *, int); /* finalize */
 140 #define _IO_FINISH(FP) JUMP1 (__finish, FP, 0)
 141 #define _IO_WFINISH(FP) WJUMP1 (__finish, FP, 0)
 142
 143 /* The 'overflow' hook flushes the buffer.
 144    The second argument is a character, or EOF.
 145    It matches the streambuf::overflow virtual function. */
 146 typedef int (*_IO_overflow_t) (FILE *, int);
 147 #define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)
 148 #define _IO_WOVERFLOW(FP, CH) WJUMP1 (__overflow, FP, CH)
 149
 150 /* The 'underflow' hook tries to fills the get buffer.
 151    It returns the next character (as an unsigned char) or EOF.  The next
 152    character remains in the get buffer, and the get position is not changed.
 153    It matches the streambuf::underflow virtual function. */
 154 typedef int (*_IO_underflow_t) (FILE *);
 155 #define _IO_UNDERFLOW(FP) JUMP0 (__underflow, FP)
 156 #define _IO_WUNDERFLOW(FP) WJUMP0 (__underflow, FP)
 157
 158 /* The 'uflow' hook returns the next character in the input stream
 159    (cast to unsigned char), and increments the read position;
 160    EOF is returned on failure.
 161    It matches the streambuf::uflow virtual function, which is not in the
 162    cfront implementation, but was added to C++ by the ANSI/ISO committee. */
 163 #define _IO_UFLOW(FP) JUMP0 (__uflow, FP)
 164 #define _IO_WUFLOW(FP) WJUMP0 (__uflow, FP)
 165
 166 /* The 'pbackfail' hook handles backing up.
 167    It matches the streambuf::pbackfail virtual function. */
 168 typedef int (*_IO_pbackfail_t) (FILE *, int);
 169 #define _IO_PBACKFAIL(FP, CH) JUMP1 (__pbackfail, FP, CH)
 170 #define _IO_WPBACKFAIL(FP, CH) WJUMP1 (__pbackfail, FP, CH)
 171
 172 /* The 'xsputn' hook writes upto N characters from buffer DATA.
 173    Returns EOF or the number of character actually written.
 174    It matches the streambuf::xsputn virtual function. */
 175 typedef size_t (*_IO_xsputn_t) (FILE *FP, const void *DATA,
 176                                     size_t N);
 177 #define _IO_XSPUTN(FP, DATA, N) JUMP2 (__xsputn, FP, DATA, N)
 178 #define _IO_WXSPUTN(FP, DATA, N) WJUMP2 (__xsputn, FP, DATA, N)
 179
 180 /* The 'xsgetn' hook reads upto N characters into buffer DATA.
 181    Returns the number of character actually read.
 182    It matches the streambuf::xsgetn virtual function. */
 183 typedef size_t (*_IO_xsgetn_t) (FILE *FP, void *DATA, size_t N);
 184 #define _IO_XSGETN(FP, DATA, N) JUMP2 (__xsgetn, FP, DATA, N)
 185 #define _IO_WXSGETN(FP, DATA, N) WJUMP2 (__xsgetn, FP, DATA, N)
 186
 187 /* The 'seekoff' hook moves the stream position to a new position
 188    relative to the start of the file (if DIR==0), the current position
 189    (MODE==1), or the end of the file (MODE==2).
 190    It matches the streambuf::seekoff virtual function.
 191    It is also used for the ANSI fseek function. */
 192 typedef off64_t (*_IO_seekoff_t) (FILE *FP, off64_t OFF, int DIR,
 193                                       int MODE);
 194 #define _IO_SEEKOFF(FP, OFF, DIR, MODE) JUMP3 (__seekoff, FP, OFF, DIR, MODE)
 195 #define _IO_WSEEKOFF(FP, OFF, DIR, MODE) WJUMP3 (__seekoff, FP, OFF, DIR, MODE)
 196
 197 /* The 'seekpos' hook also moves the stream position,
 198    but to an absolute position given by a fpos64_t (seekpos).
 199    It matches the streambuf::seekpos virtual function.
 200    It is also used for the ANSI fgetpos and fsetpos functions.  */
 201 /* The _IO_seek_cur and _IO_seek_end options are not allowed. */
 202 typedef off64_t (*_IO_seekpos_t) (FILE *, off64_t, int);
 203 #define _IO_SEEKPOS(FP, POS, FLAGS) JUMP2 (__seekpos, FP, POS, FLAGS)
 204 #define _IO_WSEEKPOS(FP, POS, FLAGS) WJUMP2 (__seekpos, FP, POS, FLAGS)
 205
 206 /* The 'setbuf' hook gives a buffer to the file.
 207    It matches the streambuf::setbuf virtual function. */
 208 typedef FILE* (*_IO_setbuf_t) (FILE *, char *, ssize_t);
 209 #define _IO_SETBUF(FP, BUFFER, LENGTH) JUMP2 (__setbuf, FP, BUFFER, LENGTH)
 210 #define _IO_WSETBUF(FP, BUFFER, LENGTH) WJUMP2 (__setbuf, FP, BUFFER, LENGTH)
 211
 212 /* The 'sync' hook attempts to synchronize the internal data structures
 213    of the file with the external state.
 214    It matches the streambuf::sync virtual function. */
 215 typedef int (*_IO_sync_t) (FILE *);
 216 #define _IO_SYNC(FP) JUMP0 (__sync, FP)
 217 #define _IO_WSYNC(FP) WJUMP0 (__sync, FP)
 218
 219 /* The 'doallocate' hook is used to tell the file to allocate a buffer.
 220    It matches the streambuf::doallocate virtual function, which is not
 221    in the ANSI/ISO C++ standard, but is part traditional implementations. */
 222 typedef int (*_IO_doallocate_t) (FILE *);
 223 #define _IO_DOALLOCATE(FP) JUMP0 (__doallocate, FP)
 224 #define _IO_WDOALLOCATE(FP) WJUMP0 (__doallocate, FP)
 225
 226 /* The following four hooks (sysread, syswrite, sysclose, sysseek, and
 227    sysstat) are low-level hooks specific to this implementation.
 228    There is no correspondence in the ANSI/ISO C++ standard library.
 229    The hooks basically correspond to the Unix system functions
 230    (read, write, close, lseek, and stat) except that a FILE*
 231    parameter is used instead of an integer file descriptor;  the default
 232    implementation used for normal files just calls those functions.
 233    The advantage of overriding these functions instead of the higher-level
 234    ones (underflow, overflow etc) is that you can leave all the buffering
 235    higher-level functions.  */
 236
 237 /* The 'sysread' hook is used to read data from the external file into
 238    an existing buffer.  It generalizes the Unix read(2) function.
 239    It matches the streambuf::sys_read virtual function, which is
 240    specific to this implementation. */
 241 typedef ssize_t (*_IO_read_t) (FILE *, void *, ssize_t);
 242 #define _IO_SYSREAD(FP, DATA, LEN) JUMP2 (__read, FP, DATA, LEN)
 243 #define _IO_WSYSREAD(FP, DATA, LEN) WJUMP2 (__read, FP, DATA, LEN)
 244
 245 /* The 'syswrite' hook is used to write data from an existing buffer
 246    to an external file.  It generalizes the Unix write(2) function.
 247    It matches the streambuf::sys_write virtual function, which is
 248    specific to this implementation. */
 249 typedef ssize_t (*_IO_write_t) (FILE *, const void *, ssize_t);
 250 #define _IO_SYSWRITE(FP, DATA, LEN) JUMP2 (__write, FP, DATA, LEN)
 251 #define _IO_WSYSWRITE(FP, DATA, LEN) WJUMP2 (__write, FP, DATA, LEN)
 252
 253 /* The 'sysseek' hook is used to re-position an external file.
 254    It generalizes the Unix lseek(2) function.
 255    It matches the streambuf::sys_seek virtual function, which is
 256    specific to this implementation. */
 257 typedef off64_t (*_IO_seek_t) (FILE *, off64_t, int);
 258 #define _IO_SYSSEEK(FP, OFFSET, MODE) JUMP2 (__seek, FP, OFFSET, MODE)
 259 #define _IO_WSYSSEEK(FP, OFFSET, MODE) WJUMP2 (__seek, FP, OFFSET, MODE)
 260
 261 /* The 'sysclose' hook is used to finalize (close, finish up) an
 262    external file.  It generalizes the Unix close(2) function.
 263    It matches the streambuf::sys_close virtual function, which is
 264    specific to this implementation. */
 265 typedef int (*_IO_close_t) (FILE *); /* finalize */
 266 #define _IO_SYSCLOSE(FP) JUMP0 (__close, FP)
 267 #define _IO_WSYSCLOSE(FP) WJUMP0 (__close, FP)
 268
 269 /* The 'sysstat' hook is used to get information about an external file
 270    into a struct stat buffer.  It generalizes the Unix fstat(2) call.
 271    It matches the streambuf::sys_stat virtual function, which is
 272    specific to this implementation. */
 273 typedef int (*_IO_stat_t) (FILE *, void *);
 274 #define _IO_SYSSTAT(FP, BUF) JUMP1 (__stat, FP, BUF)
 275 #define _IO_WSYSSTAT(FP, BUF) WJUMP1 (__stat, FP, BUF)
 276
 277 /* The 'showmany' hook can be used to get an image how much input is
 278    available.  In many cases the answer will be 0 which means unknown
 279    but some cases one can provide real information.  */
 280 typedef int (*_IO_showmanyc_t) (FILE *);
 281 #define _IO_SHOWMANYC(FP) JUMP0 (__showmanyc, FP)
 282 #define _IO_WSHOWMANYC(FP) WJUMP0 (__showmanyc, FP)
 283
 284 /* The 'imbue' hook is used to get information about the currently
 285    installed locales.  */
 286 typedef void (*_IO_imbue_t) (FILE *, void *);
 287 #define _IO_IMBUE(FP, LOCALE) JUMP1 (__imbue, FP, LOCALE)
 288 #define _IO_WIMBUE(FP, LOCALE) WJUMP1 (__imbue, FP, LOCALE)
 289
 290
 291 #define _IO_CHAR_TYPE char /* unsigned char ? */
 292 #define _IO_INT_TYPE int
 293
 294 struct _IO_jump_t
 295 {
 296     JUMP_FIELD(size_t, __dummy);
 297     JUMP_FIELD(size_t, __dummy2);
 298     JUMP_FIELD(_IO_finish_t, __finish);
 299     JUMP_FIELD(_IO_overflow_t, __overflow);
 300     JUMP_FIELD(_IO_underflow_t, __underflow);
 301     JUMP_FIELD(_IO_underflow_t, __uflow);
 302     JUMP_FIELD(_IO_pbackfail_t, __pbackfail);
 303     /* showmany */
 304     JUMP_FIELD(_IO_xsputn_t, __xsputn);
 305     JUMP_FIELD(_IO_xsgetn_t, __xsgetn);
 306     JUMP_FIELD(_IO_seekoff_t, __seekoff);
 307     JUMP_FIELD(_IO_seekpos_t, __seekpos);
 308     JUMP_FIELD(_IO_setbuf_t, __setbuf);
 309     JUMP_FIELD(_IO_sync_t, __sync);
 310     JUMP_FIELD(_IO_doallocate_t, __doallocate);
 311     JUMP_FIELD(_IO_read_t, __read);
 312     JUMP_FIELD(_IO_write_t, __write);
 313     JUMP_FIELD(_IO_seek_t, __seek);
 314     JUMP_FIELD(_IO_close_t, __close);
 315     JUMP_FIELD(_IO_stat_t, __stat);
 316     JUMP_FIELD(_IO_showmanyc_t, __showmanyc);
 317     JUMP_FIELD(_IO_imbue_t, __imbue);
 318 };
 319
 320 /* We always allocate an extra word following an _IO_FILE.
 321    This contains a pointer to the function jump table used.
 322    This is for compatibility with C++ streambuf; the word can
 323    be used to smash to a pointer to a virtual function table. */
 324
 325 struct _IO_FILE_plus
 326 {
 327   FILE file;
 328   const struct _IO_jump_t *vtable;
 329 };
 330
 331 #ifdef _IO_USE_OLD_IO_FILE
 332 /* This structure is used by the compatibility code as if it were an
 333    _IO_FILE_plus, but has enough space to initialize the _mode argument
 334    of an _IO_FILE_complete.  */
 335 struct _IO_FILE_complete_plus
 336 {
 337   struct _IO_FILE_complete file;
 338   const struct _IO_jump_t *vtable;
 339 };
 340 #endif
 341
 342 /* Special file type for fopencookie function.  */
 343 struct _IO_cookie_file
 344 {
 345   struct _IO_FILE_plus __fp;
 346   void *__cookie;
 347   cookie_io_functions_t __io_functions;
 348 };
 349
 350 FILE *_IO_fopencookie (void *cookie, const char *mode,
 351                        cookie_io_functions_t io_functions);
 352
 353
 354 /* Iterator type for walking global linked list of _IO_FILE objects. */
 355
 356 typedef FILE *_IO_ITER;
 357
 358 /* Generic functions */
 359
 360 extern void _IO_switch_to_main_get_area (FILE *) __THROW;
 361 extern void _IO_switch_to_backup_area (FILE *) __THROW;
 362 extern int _IO_switch_to_get_mode (FILE *);
 363 libc_hidden_proto (_IO_switch_to_get_mode)
 364 extern void _IO_init_internal (FILE *, int) attribute_hidden;
 365 extern int _IO_sputbackc (FILE *, int) __THROW;
 366 libc_hidden_proto (_IO_sputbackc)
 367 extern int _IO_sungetc (FILE *) __THROW;
 368 extern void _IO_un_link (struct _IO_FILE_plus *) __THROW;
 369 libc_hidden_proto (_IO_un_link)
 370 extern void _IO_link_in (struct _IO_FILE_plus *) __THROW;
 371 libc_hidden_proto (_IO_link_in)
 372 extern void _IO_doallocbuf (FILE *) __THROW;
 373 libc_hidden_proto (_IO_doallocbuf)
 374 extern void _IO_unsave_markers (FILE *) __THROW;
 375 libc_hidden_proto (_IO_unsave_markers)
 376 extern void _IO_setb (FILE *, char *, char *, int) __THROW;
 377 libc_hidden_proto (_IO_setb)
 378 extern unsigned _IO_adjust_column (unsigned, const char *, int) __THROW;
 379 libc_hidden_proto (_IO_adjust_column)
 380 #define _IO_sputn(__fp, __s, __n) _IO_XSPUTN (__fp, __s, __n)
 381
 382 ssize_t _IO_least_wmarker (FILE *, wchar_t *) __THROW;
 383 libc_hidden_proto (_IO_least_wmarker)
 384 extern void _IO_switch_to_main_wget_area (FILE *) __THROW;
 385 libc_hidden_proto (_IO_switch_to_main_wget_area)
 386 extern void _IO_switch_to_wbackup_area (FILE *) __THROW;
 387 libc_hidden_proto (_IO_switch_to_wbackup_area)
 388 extern int _IO_switch_to_wget_mode (FILE *);
 389 libc_hidden_proto (_IO_switch_to_wget_mode)
 390 extern void _IO_wsetb (FILE *, wchar_t *, wchar_t *, int) __THROW;
 391 libc_hidden_proto (_IO_wsetb)
 392 extern wint_t _IO_sputbackwc (FILE *, wint_t) __THROW;
 393 libc_hidden_proto (_IO_sputbackwc)
 394 extern wint_t _IO_sungetwc (FILE *) __THROW;
 395 extern void _IO_wdoallocbuf (FILE *) __THROW;
 396 libc_hidden_proto (_IO_wdoallocbuf)
 397 extern void _IO_unsave_wmarkers (FILE *) __THROW;
 398 extern unsigned _IO_adjust_wcolumn (unsigned, const wchar_t *, int) __THROW;
 399 extern off64_t get_file_offset (FILE *fp);
 400
 401 /* Marker-related function. */
 402
 403 extern void _IO_init_marker (struct _IO_marker *, FILE *);
 404 extern void _IO_init_wmarker (struct _IO_marker *, FILE *);
 405 extern void _IO_remove_marker (struct _IO_marker *) __THROW;
 406 extern int _IO_marker_difference (struct _IO_marker *, struct _IO_marker *)
 407      __THROW;
 408 extern int _IO_marker_delta (struct _IO_marker *) __THROW;
 409 extern int _IO_wmarker_delta (struct _IO_marker *) __THROW;
 410 extern int _IO_seekmark (FILE *, struct _IO_marker *, int) __THROW;
 411 extern int _IO_seekwmark (FILE *, struct _IO_marker *, int) __THROW;
 412
 413 /* Functions for iterating global list and dealing with its lock */
 414
 415 extern _IO_ITER _IO_iter_begin (void) __THROW;
 416 libc_hidden_proto (_IO_iter_begin)
 417 extern _IO_ITER _IO_iter_end (void) __THROW;
 418 libc_hidden_proto (_IO_iter_end)
 419 extern _IO_ITER _IO_iter_next (_IO_ITER) __THROW;
 420 libc_hidden_proto (_IO_iter_next)
 421 extern FILE *_IO_iter_file (_IO_ITER) __THROW;
 422 libc_hidden_proto (_IO_iter_file)
 423 extern void _IO_list_lock (void) __THROW;
 424 libc_hidden_proto (_IO_list_lock)
 425 extern void _IO_list_unlock (void) __THROW;
 426 libc_hidden_proto (_IO_list_unlock)
 427 extern void _IO_list_resetlock (void) __THROW;
 428 libc_hidden_proto (_IO_list_resetlock)
 429 extern void _IO_enable_locks (void) __THROW;
 430 libc_hidden_proto (_IO_enable_locks)
 431
 432 /* Default jumptable functions. */
 433
 434 extern int _IO_default_underflow (FILE *) __THROW;
 435 extern int _IO_default_uflow (FILE *);
 436 libc_hidden_proto (_IO_default_uflow)
 437 extern wint_t _IO_wdefault_uflow (FILE *);
 438 libc_hidden_proto (_IO_wdefault_uflow)
 439 extern int _IO_default_doallocate (FILE *) __THROW;
 440 libc_hidden_proto (_IO_default_doallocate)
 441 extern int _IO_wdefault_doallocate (FILE *) __THROW;
 442 libc_hidden_proto (_IO_wdefault_doallocate)
 443 extern void _IO_default_finish (FILE *, int) __THROW;
 444 libc_hidden_proto (_IO_default_finish)
 445 extern void _IO_wdefault_finish (FILE *, int) __THROW;
 446 libc_hidden_proto (_IO_wdefault_finish)
 447 extern int _IO_default_pbackfail (FILE *, int) __THROW;
 448 libc_hidden_proto (_IO_default_pbackfail)
 449 extern wint_t _IO_wdefault_pbackfail (FILE *, wint_t) __THROW;
 450 libc_hidden_proto (_IO_wdefault_pbackfail)
 451 extern FILE* _IO_default_setbuf (FILE *, char *, ssize_t);
 452 extern size_t _IO_default_xsputn (FILE *, const void *, size_t);
 453 libc_hidden_proto (_IO_default_xsputn)
 454 extern size_t _IO_wdefault_xsputn (FILE *, const void *, size_t);
 455 libc_hidden_proto (_IO_wdefault_xsputn)
 456 extern size_t _IO_default_xsgetn (FILE *, void *, size_t);
 457 libc_hidden_proto (_IO_default_xsgetn)
 458 extern size_t _IO_wdefault_xsgetn (FILE *, void *, size_t);
 459 libc_hidden_proto (_IO_wdefault_xsgetn)
 460 extern off64_t _IO_default_seekoff (FILE *, off64_t, int, int)
 461      __THROW;
 462 extern off64_t _IO_default_seekpos (FILE *, off64_t, int);
 463 extern ssize_t _IO_default_write (FILE *, const void *, ssize_t);
 464 extern ssize_t _IO_default_read (FILE *, void *, ssize_t);
 465 extern int _IO_default_stat (FILE *, void *) __THROW;
 466 extern off64_t _IO_default_seek (FILE *, off64_t, int) __THROW;
 467 extern int _IO_default_sync (FILE *) __THROW;
 468 #define _IO_default_close ((_IO_close_t) _IO_default_sync)
 469 extern int _IO_default_showmanyc (FILE *) __THROW;
 470 extern void _IO_default_imbue (FILE *, void *) __THROW;
 471
 472 extern const struct _IO_jump_t _IO_file_jumps;
 473 libc_hidden_proto (_IO_file_jumps)
 474 extern const struct _IO_jump_t _IO_file_jumps_mmap attribute_hidden;
 475 extern const struct _IO_jump_t _IO_file_jumps_maybe_mmap attribute_hidden;
 476 extern const struct _IO_jump_t _IO_wfile_jumps;
 477 libc_hidden_proto (_IO_wfile_jumps)
 478 extern const struct _IO_jump_t _IO_wfile_jumps_mmap attribute_hidden;
 479 extern const struct _IO_jump_t _IO_wfile_jumps_maybe_mmap attribute_hidden;
 480 extern const struct _IO_jump_t _IO_old_file_jumps attribute_hidden;
 481 extern const struct _IO_jump_t _IO_streambuf_jumps;
 482 extern const struct _IO_jump_t _IO_old_proc_jumps attribute_hidden;
 483 extern const struct _IO_jump_t _IO_str_jumps attribute_hidden;
 484 extern const struct _IO_jump_t _IO_wstr_jumps attribute_hidden;
 485 extern int _IO_do_write (FILE *, const char *, size_t);
 486 libc_hidden_proto (_IO_do_write)
 487 extern int _IO_new_do_write (FILE *, const char *, size_t);
 488 extern int _IO_old_do_write (FILE *, const char *, size_t);
 489 extern int _IO_wdo_write (FILE *, const wchar_t *, size_t);
 490 libc_hidden_proto (_IO_wdo_write)
 491 extern int _IO_flush_all_lockp (int);
 492 extern int _IO_flush_all (void);
 493 libc_hidden_proto (_IO_flush_all)
 494 extern void _IO_flush_all_linebuffered (void);
 495 libc_hidden_proto (_IO_flush_all_linebuffered)
 496 extern int _IO_new_fgetpos (FILE *, __fpos_t *);
 497 extern int _IO_old_fgetpos (FILE *, __fpos_t *);
 498 extern int _IO_new_fsetpos (FILE *, const __fpos_t *);
 499 extern int _IO_old_fsetpos (FILE *, const __fpos_t *);
 500 extern int _IO_new_fgetpos64 (FILE *, __fpos64_t *);
 501 extern int _IO_old_fgetpos64 (FILE *, __fpos64_t *);
 502 extern int _IO_new_fsetpos64 (FILE *, const __fpos64_t *);
 503 extern int _IO_old_fsetpos64 (FILE *, const __fpos64_t *);
 504 extern void _IO_old_init (FILE *fp, int flags) __THROW;
 505
 506
 507 #define _IO_do_flush(_f) \
 508   ((_f)->_mode <= 0                                                           \
 509    ? _IO_do_write(_f, (_f)->_IO_write_base,                                   \
 510                   (_f)->_IO_write_ptr-(_f)->_IO_write_base)                   \
 511    : _IO_wdo_write(_f, (_f)->_wide_data->_IO_write_base,                      \
 512                    ((_f)->_wide_data->_IO_write_ptr                           \
 513                     - (_f)->_wide_data->_IO_write_base)))
 514 #define _IO_old_do_flush(_f) \
 515   _IO_old_do_write(_f, (_f)->_IO_write_base, \
 516                    (_f)->_IO_write_ptr-(_f)->_IO_write_base)
 517 #define _IO_in_put_mode(_fp) ((_fp)->_flags & _IO_CURRENTLY_PUTTING)
 518 #define _IO_mask_flags(fp, f, mask) \
 519        ((fp)->_flags = ((fp)->_flags & ~(mask)) | ((f) & (mask)))
 520 #define _IO_setg(fp, eb, g, eg)  ((fp)->_IO_read_base = (eb),\
 521         (fp)->_IO_read_ptr = (g), (fp)->_IO_read_end = (eg))
 522 #define _IO_wsetg(fp, eb, g, eg)  ((fp)->_wide_data->_IO_read_base = (eb),\
 523         (fp)->_wide_data->_IO_read_ptr = (g), \
 524         (fp)->_wide_data->_IO_read_end = (eg))
 525 #define _IO_setp(__fp, __p, __ep) \
 526        ((__fp)->_IO_write_base = (__fp)->_IO_write_ptr \
 527         = __p, (__fp)->_IO_write_end = (__ep))
 528 #define _IO_wsetp(__fp, __p, __ep) \
 529        ((__fp)->_wide_data->_IO_write_base \
 530         = (__fp)->_wide_data->_IO_write_ptr = __p, \
 531         (__fp)->_wide_data->_IO_write_end = (__ep))
 532 #define _IO_have_backup(fp) ((fp)->_IO_save_base != NULL)
 533 #define _IO_have_wbackup(fp) ((fp)->_wide_data->_IO_save_base != NULL)
 534 #define _IO_in_backup(fp) ((fp)->_flags & _IO_IN_BACKUP)
 535 #define _IO_have_markers(fp) ((fp)->_markers != NULL)
 536 #define _IO_blen(fp) ((fp)->_IO_buf_end - (fp)->_IO_buf_base)
 537 #define _IO_wblen(fp) ((fp)->_wide_data->_IO_buf_end \
 538                        - (fp)->_wide_data->_IO_buf_base)
 539
 540 /* Jumptable functions for files. */
 541
 542 extern int _IO_file_doallocate (FILE *) __THROW;
 543 libc_hidden_proto (_IO_file_doallocate)
 544 extern FILE* _IO_file_setbuf (FILE *, char *, ssize_t);
 545 libc_hidden_proto (_IO_file_setbuf)
 546 extern off64_t _IO_file_seekoff (FILE *, off64_t, int, int);
 547 libc_hidden_proto (_IO_file_seekoff)
 548 extern off64_t _IO_file_seekoff_mmap (FILE *, off64_t, int, int)
 549      __THROW;
 550 extern size_t _IO_file_xsputn (FILE *, const void *, size_t);
 551 libc_hidden_proto (_IO_file_xsputn)
 552 extern size_t _IO_file_xsgetn (FILE *, void *, size_t);
 553 libc_hidden_proto (_IO_file_xsgetn)
 554 extern int _IO_file_stat (FILE *, void *) __THROW;
 555 libc_hidden_proto (_IO_file_stat)
 556 extern int _IO_file_close (FILE *) __THROW;
 557 libc_hidden_proto (_IO_file_close)
 558 extern int _IO_file_close_mmap (FILE *) __THROW;
 559 extern int _IO_file_underflow (FILE *);
 560 libc_hidden_proto (_IO_file_underflow)
 561 extern int _IO_file_underflow_mmap (FILE *);
 562 extern int _IO_file_underflow_maybe_mmap (FILE *);
 563 extern int _IO_file_overflow (FILE *, int);
 564 libc_hidden_proto (_IO_file_overflow)
 565 #define _IO_file_is_open(__fp) ((__fp)->_fileno != -1)
 566 extern FILE* _IO_file_attach (FILE *, int);
 567 libc_hidden_proto (_IO_file_attach)
 568 extern FILE* _IO_file_open (FILE *, const char *, int, int, int, int);
 569 libc_hidden_proto (_IO_file_open)
 570 extern FILE* _IO_file_fopen (FILE *, const char *, const char *, int);
 571 libc_hidden_proto (_IO_file_fopen)
 572 extern ssize_t _IO_file_write (FILE *, const void *, ssize_t);
 573 extern ssize_t _IO_file_read (FILE *, void *, ssize_t);
 574 libc_hidden_proto (_IO_file_read)
 575 extern int _IO_file_sync (FILE *);
 576 libc_hidden_proto (_IO_file_sync)
 577 extern int _IO_file_close_it (FILE *);
 578 libc_hidden_proto (_IO_file_close_it)
 579 extern off64_t _IO_file_seek (FILE *, off64_t, int) __THROW;
 580 libc_hidden_proto (_IO_file_seek)
 581 extern void _IO_file_finish (FILE *, int);
 582 libc_hidden_proto (_IO_file_finish)
 583
 584 extern FILE* _IO_new_file_attach (FILE *, int);
 585 extern int _IO_new_file_close_it (FILE *);
 586 extern void _IO_new_file_finish (FILE *, int);
 587 extern FILE* _IO_new_file_fopen (FILE *, const char *, const char *,
 588                                      int);
 589 extern void _IO_no_init (FILE *, int, int, struct _IO_wide_data *,
 590                          const struct _IO_jump_t *) __THROW;
 591 extern void _IO_new_file_init_internal (struct _IO_FILE_plus *)
 592   __THROW attribute_hidden;
 593 extern FILE* _IO_new_file_setbuf (FILE *, char *, ssize_t);
 594 extern FILE* _IO_file_setbuf_mmap (FILE *, char *, ssize_t);
 595 extern int _IO_new_file_sync (FILE *);
 596 extern int _IO_new_file_underflow (FILE *);
 597 extern int _IO_new_file_overflow (FILE *, int);
 598 extern off64_t _IO_new_file_seekoff (FILE *, off64_t, int, int);
 599 extern ssize_t _IO_new_file_write (FILE *, const void *, ssize_t);
 600 extern size_t _IO_new_file_xsputn (FILE *, const void *, size_t);
 601
 602 extern FILE* _IO_old_file_setbuf (FILE *, char *, ssize_t);
 603 extern off64_t _IO_old_file_seekoff (FILE *, off64_t, int, int);
 604 extern size_t _IO_old_file_xsputn (FILE *, const void *, size_t);
 605 extern int _IO_old_file_underflow (FILE *);
 606 extern int _IO_old_file_overflow (FILE *, int);
 607 extern void _IO_old_file_init_internal (struct _IO_FILE_plus *)
 608   __THROW attribute_hidden;
 609 extern FILE* _IO_old_file_attach (FILE *, int);
 610 extern FILE* _IO_old_file_fopen (FILE *, const char *, const char *);
 611 extern ssize_t _IO_old_file_write (FILE *, const void *, ssize_t);
 612 extern int _IO_old_file_sync (FILE *);
 613 extern int _IO_old_file_close_it (FILE *);
 614 extern void _IO_old_file_finish (FILE *, int);
 615
 616 extern int _IO_wfile_doallocate (FILE *) __THROW;
 617 extern size_t _IO_wfile_xsputn (FILE *, const void *, size_t);
 618 libc_hidden_proto (_IO_wfile_xsputn)
 619 extern FILE* _IO_wfile_setbuf (FILE *, wchar_t *, ssize_t);
 620 extern wint_t _IO_wfile_sync (FILE *);
 621 libc_hidden_proto (_IO_wfile_sync)
 622 extern wint_t _IO_wfile_underflow (FILE *);
 623 libc_hidden_proto (_IO_wfile_underflow)
 624 extern wint_t _IO_wfile_overflow (FILE *, wint_t);
 625 libc_hidden_proto (_IO_wfile_overflow)
 626 extern off64_t _IO_wfile_seekoff (FILE *, off64_t, int, int);
 627 libc_hidden_proto (_IO_wfile_seekoff)
 628
 629 /* Jumptable functions for proc_files. */
 630 extern FILE* _IO_proc_open (FILE *, const char *, const char *)
 631      __THROW;
 632 extern FILE* _IO_new_proc_open (FILE *, const char *, const char *)
 633      __THROW;
 634 extern FILE* _IO_old_proc_open (FILE *, const char *, const char *);
 635 extern int _IO_proc_close (FILE *) __THROW;
 636 extern int _IO_new_proc_close (FILE *) __THROW;
 637 extern int _IO_old_proc_close (FILE *);
 638
 639 /* Jumptable functions for strfiles. */
 640 extern int _IO_str_underflow (FILE *) __THROW;
 641 libc_hidden_proto (_IO_str_underflow)
 642 extern int _IO_str_overflow (FILE *, int) __THROW;
 643 libc_hidden_proto (_IO_str_overflow)
 644 extern int _IO_str_pbackfail (FILE *, int) __THROW;
 645 libc_hidden_proto (_IO_str_pbackfail)
 646 extern off64_t _IO_str_seekoff (FILE *, off64_t, int, int) __THROW;
 647 libc_hidden_proto (_IO_str_seekoff)
 648 extern void _IO_str_finish (FILE *, int) __THROW;
 649
 650 /* Other strfile functions */
 651 struct _IO_strfile_;
 652 extern ssize_t _IO_str_count (FILE *) __THROW;
 653
 654 /* And the wide character versions.  */
 655 extern void _IO_wstr_init_static (FILE *, wchar_t *, size_t, wchar_t *)
 656      __THROW;
 657 extern ssize_t _IO_wstr_count (FILE *) __THROW;
 658 extern wint_t _IO_wstr_overflow (FILE *, wint_t) __THROW;
 659 extern wint_t _IO_wstr_underflow (FILE *) __THROW;
 660 extern off64_t _IO_wstr_seekoff (FILE *, off64_t, int, int)
 661      __THROW;
 662 extern wint_t _IO_wstr_pbackfail (FILE *, wint_t) __THROW;
 663 extern void _IO_wstr_finish (FILE *, int) __THROW;
 664
 665 /* Internal versions of v*printf that take an additional flags
 666    parameter.  */
 667 extern int __vfprintf_internal (FILE *fp, const char *format, va_list ap,
 668                                 unsigned int mode_flags)
 669     attribute_hidden;
 670 extern int __vfwprintf_internal (FILE *fp, const wchar_t *format, va_list ap,
 671                                  unsigned int mode_flags)
 672     attribute_hidden;
 673
 674 extern int __vasprintf_internal (char **result_ptr, const char *format,
 675                                  va_list ap, unsigned int mode_flags)
 676     attribute_hidden;
 677 extern int __vdprintf_internal (int d, const char *format, va_list ap,
 678                                 unsigned int mode_flags)
 679     attribute_hidden;
 680 extern int __obstack_vprintf_internal (struct obstack *ob, const char *fmt,
 681                                        va_list ap, unsigned int mode_flags)
 682     attribute_hidden;
 683
 684 /* Note: __vsprintf_internal, unlike vsprintf, does take a maxlen argument,
 685    because it's called by both vsprintf and vsprintf_chk.  If maxlen is
 686    not set to -1, overrunning the buffer will cause a prompt crash.
 687    This is the behavior of ordinary (v)sprintf functions, thus they call
 688    __vsprintf_internal with that argument set to -1.  */
 689 extern int __vsprintf_internal (char *string, size_t maxlen,
 690                                 const char *format, va_list ap,
 691                                 unsigned int mode_flags)
 692     attribute_hidden;
 693
 694 extern int __vsnprintf_internal (char *string, size_t maxlen,
 695                                  const char *format, va_list ap,
 696                                  unsigned int mode_flags)
 697     attribute_hidden;
 698 extern int __vswprintf_internal (wchar_t *string, size_t maxlen,
 699                                  const wchar_t *format, va_list ap,
 700                                  unsigned int mode_flags)
 701     attribute_hidden;
 702
 703 /* Flags for __v*printf_internal.
 704
 705    PRINTF_LDBL_IS_DBL indicates whether long double values are to be
 706    handled as having the same format as double, in which case the flag
 707    should be set to one, or as another format, otherwise.
 708
 709    PRINTF_FORTIFY, when set to one, indicates that fortification checks
 710    are to be performed in input parameters.  This is used by the
 711    __*printf_chk functions, which are used when _FORTIFY_SOURCE is
 712    defined to 1 or 2.  Otherwise, such checks are ignored.
 713
 714    PRINTF_CHK indicates, to the internal function being called, that the
 715    call is originated from one of the __*printf_chk functions.
 716
 717    PRINTF_LDBL_USES_FLOAT128 is used on platforms where the long double
 718    format used to be different from the IEC 60559 double format *and*
 719    also different from the Quadruple 128-bits IEC 60559 format (such as
 720    the IBM Extended Precision format on powerpc or the 80-bits IEC 60559
 721    format on x86), but was later converted to the Quadruple 128-bits IEC
 722    60559 format, which is the same format that the _Float128 always has
 723    (hence the `USES_FLOAT128' suffix in the name of the flag).  When set
 724    to one, this macro indicates that long double values are to be
 725    handled as having this new format.  Otherwise, they should be handled
 726    as the previous format on that platform.  */
 727 #define PRINTF_LDBL_IS_DBL              0x0001
 728 #define PRINTF_FORTIFY                  0x0002
 729 #define PRINTF_CHK                      0x0004
 730 #define PRINTF_LDBL_USES_FLOAT128       0x0008
 731
 732 extern size_t _IO_getline (FILE *,char *, size_t, int, int);
 733 libc_hidden_proto (_IO_getline)
 734 extern size_t _IO_getline_info (FILE *,char *, size_t,
 735                                     int, int, int *);
 736 libc_hidden_proto (_IO_getline_info)
 737 extern size_t _IO_getwline (FILE *,wchar_t *, size_t, wint_t, int);
 738 extern size_t _IO_getwline_info (FILE *,wchar_t *, size_t,
 739                                      wint_t, int, wint_t *);
 740
 741 extern struct _IO_FILE_plus *_IO_list_all;
 742 libc_hidden_proto (_IO_list_all)
 743 extern void (*_IO_cleanup_registration_needed) (void);
 744
 745 extern void _IO_str_init_static_internal (struct _IO_strfile_ *, char *,
 746                                           size_t, char *) __THROW;
 747 extern off64_t _IO_seekoff_unlocked (FILE *, off64_t, int, int)
 748      attribute_hidden;
 749 extern off64_t _IO_seekpos_unlocked (FILE *, off64_t, int)
 750      attribute_hidden;
 751
 752 #if _G_HAVE_MMAP
 753
 754 # include <unistd.h>
 755 # include <fcntl.h>
 756 # include <sys/mman.h>
 757 # include <sys/param.h>
 758
 759 # if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
 760 #  define MAP_ANONYMOUS MAP_ANON
 761 # endif
 762
 763 # if !defined(MAP_ANONYMOUS) || !defined(EXEC_PAGESIZE)
 764 #  undef _G_HAVE_MMAP
 765 #  define _G_HAVE_MMAP 0
 766 # endif
 767
 768 #endif /* _G_HAVE_MMAP */
 769
 770 /* Flags for __vfscanf_internal and __vfwscanf_internal.
 771
 772    SCANF_LDBL_IS_DBL indicates whether long double values are to be
 773    handled as having the same format as double, in which case the flag
 774    should be set to one, or as another format, otherwise.
 775
 776    SCANF_ISOC99_A, when set to one, indicates that the ISO C99 or POSIX
 777    behavior of the scanf functions is to be used, i.e. automatic
 778    allocation for input strings with %as, %aS and %a[, a GNU extension,
 779    is disabled. This is the behavior that the __isoc99_scanf family of
 780    functions use.  When the flag is set to zero, automatic allocation is
 781    enabled.
 782
 783    SCANF_ISOC23_BIN_CST, when set to one, indicates the %i accepts
 784    binary constants starting 0b or 0B.
 785
 786    SCANF_LDBL_USES_FLOAT128 is used on platforms where the long double
 787    format used to be different from the IEC 60559 double format *and*
 788    also different from the Quadruple 128-bits IEC 60559 format (such as
 789    the IBM Extended Precision format on powerpc or the 80-bits IEC 60559
 790    format on x86), but was later converted to the Quadruple 128-bits IEC
 791    60559 format, which is the same format that the _Float128 always has
 792    (hence the `USES_FLOAT128' suffix in the name of the flag).  When set
 793    to one, this macros indicates that long double values are to be
 794    handled as having this new format.  Otherwise, they should be handled
 795    as the previous format on that platform.  */
 796 #define SCANF_LDBL_IS_DBL               0x0001
 797 #define SCANF_ISOC99_A                  0x0002
 798 #define SCANF_ISOC23_BIN_CST            0x0004
 799 #define SCANF_LDBL_USES_FLOAT128        0x0008
 800
 801 extern int __vfscanf_internal (FILE *fp, const char *format, va_list argp,
 802                                unsigned int flags)
 803   attribute_hidden;
 804 extern int __vfwscanf_internal (FILE *fp, const wchar_t *format, va_list argp,
 805                                 unsigned int flags)
 806   attribute_hidden;
 807
 808 extern int _IO_vscanf (const char *, va_list) __THROW;
 809
 810 #ifdef _IO_MTSAFE_IO
 811 /* check following! */
 812 # ifdef _IO_USE_OLD_IO_FILE
 813 #  define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \
 814        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
 815          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (FILE *) CHAIN, FD, \
 816          0, _IO_pos_BAD, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock }
 817 # else
 818 #  define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \
 819        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
 820          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (FILE *) CHAIN, FD, \
 821          0, _IO_pos_BAD, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock, _IO_pos_BAD,\
 822          NULL, WDP, 0 }
 823 # endif
 824 #else
 825 # ifdef _IO_USE_OLD_IO_FILE
 826 #  define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \
 827        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
 828          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (FILE *) CHAIN, FD, \
 829          0, _IO_pos_BAD }
 830 # else
 831 #  define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \
 832        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
 833          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (FILE *) CHAIN, FD, \
 834          0, _IO_pos_BAD, 0, 0, { 0 }, 0, _IO_pos_BAD, \
 835          NULL, WDP, 0 }
 836 # endif
 837 #endif
 838
 839 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
 840 /* See oldstdfiles.c.  These are the old stream variables.  */
 841 extern struct _IO_FILE_plus _IO_stdin_;
 842 extern struct _IO_FILE_plus _IO_stdout_;
 843 extern struct _IO_FILE_plus _IO_stderr_;
 844
 845 static inline bool
 846 _IO_legacy_file (FILE *fp)
 847 {
 848   return fp == (FILE *) &_IO_stdin_ || fp == (FILE *) &_IO_stdout_
 849     || fp == (FILE *) &_IO_stderr_;
 850 }
 851 #endif
 852
 853 /* Deallocate a stream if it is heap-allocated.  Preallocated
 854    stdin/stdout/stderr streams are not deallocated. */
 855 static inline void
 856 _IO_deallocate_file (FILE *fp)
 857 {
 858   /* The current stream variables.  */
 859   if (fp == (FILE *) &_IO_2_1_stdin_ || fp == (FILE *) &_IO_2_1_stdout_
 860       || fp == (FILE *) &_IO_2_1_stderr_)
 861     return;
 862 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
 863   if (_IO_legacy_file (fp))
 864     return;
 865 #endif
 866   free (fp);
 867 }
 868
 869 #ifdef IO_DEBUG
 870 # define CHECK_FILE(FILE, RET) do {                             \
 871     if ((FILE) == NULL                                          \
 872         || ((FILE)->_flags & _IO_MAGIC_MASK) != _IO_MAGIC)      \
 873       {                                                         \
 874         __set_errno (EINVAL);                                   \
 875         return RET;                                             \
 876       }                                                         \
 877   } while (0)
 878 #else
 879 # define CHECK_FILE(FILE, RET) do { } while (0)
 880 #endif
 881
 882 static inline void
 883 __attribute__ ((__always_inline__))
 884 _IO_acquire_lock_fct (FILE **p)
 885 {
 886   FILE *fp = *p;
 887   if ((fp->_flags & _IO_USER_LOCK) == 0)
 888     _IO_funlockfile (fp);
 889 }
 890
 891 #if !defined _IO_MTSAFE_IO && IS_IN (libc)
 892 # define _IO_acquire_lock(_fp)                                                \
 893   do {
 894 # define _IO_release_lock(_fp)                                                \
 895   } while (0)
 896 #endif
 897
 898 /* Collect all vtables in a special section for vtable verification.
 899    These symbols cover the extent of this section.  */
 900 symbol_set_declare (__libc_IO_vtables)
 901
 902 /* libio vtables need to carry this attribute so that they pass
 903    validation.  */
 904 #define libio_vtable __attribute__ ((section ("__libc_IO_vtables")))
 905
 906 #ifdef SHARED
 907 /* If equal to &_IO_vtable_check (with pointer guard protection),
 908    unknown vtable pointers are valid.  This function pointer is solely
 909    used as a flag.  */
 910 extern void (*IO_accept_foreign_vtables) (void) attribute_hidden;
 911
 912 /* Assigns the passed function pointer (either NULL or
 913    &_IO_vtable_check) to IO_accept_foreign_vtables.  */
 914 static inline void
 915 IO_set_accept_foreign_vtables (void (*flag) (void))
 916 {
 917   PTR_MANGLE (flag);
 918   atomic_store_relaxed (&IO_accept_foreign_vtables, flag);
 919 }
 920
 921 #else  /* !SHARED */
 922
 923 /* The statically-linked version does nothing. */
 924 static inline void
 925 IO_set_accept_foreign_vtables (void (*flag) (void))
 926 {
 927 }
 928
 929 #endif
 930
 931 /* Check if unknown vtable pointers are permitted; otherwise,
 932    terminate the process.  */
 933 void _IO_vtable_check (void) attribute_hidden;
 934
 935 /* Perform vtable pointer validation.  If validation fails, terminate
 936    the process.  */
 937 static inline const struct _IO_jump_t *
 938 IO_validate_vtable (const struct _IO_jump_t *vtable)
 939 {
 940   /* Fast path: The vtable pointer is within the __libc_IO_vtables
 941      section.  */
 942   uintptr_t section_length = __stop___libc_IO_vtables - __start___libc_IO_vtables;
 943   uintptr_t ptr = (uintptr_t) vtable;
 944   uintptr_t offset = ptr - (uintptr_t) __start___libc_IO_vtables;
 945   if (__glibc_unlikely (offset >= section_length))
 946     /* The vtable pointer is not in the expected section.  Use the
 947        slow path, which will terminate the process if necessary.  */
 948     _IO_vtable_check ();
 949   return vtable;
 950 }
 951
 952 /* Character set conversion.  */
 953
 954 enum __codecvt_result
 955 {
 956   __codecvt_ok,
 957   __codecvt_partial,
 958   __codecvt_error,
 959   __codecvt_noconv
 960 };
 961
 962 enum __codecvt_result __libio_codecvt_out (struct _IO_codecvt *,
 963                                            __mbstate_t *,
 964                                            const wchar_t *,
 965                                            const wchar_t *,
 966                                            const wchar_t **, char *,
 967                                            char *, char **)
 968   attribute_hidden;
 969 enum __codecvt_result __libio_codecvt_in (struct _IO_codecvt *,
 970                                           __mbstate_t *,
 971                                           const char *, const char *,
 972                                           const char **, wchar_t *,
 973                                           wchar_t *, wchar_t **)
 974   attribute_hidden;
 975 int __libio_codecvt_encoding (struct _IO_codecvt *) attribute_hidden;
 976 int __libio_codecvt_length (struct _IO_codecvt *, __mbstate_t *,
 977                             const char *, const char *, size_t)
 978   attribute_hidden;
 979
 980 #endif /* libioP.h.  */