libio/libioP.h

   1 /* Copyright (C) 1993-2024 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 int __printf_buffer_as_file_overflow (FILE *fp, int ch);
 473 extern size_t __printf_buffer_as_file_xsputn (FILE *fp, const void *buf,
 474                                               size_t len);
 475 extern wint_t __wprintf_buffer_as_file_overflow (FILE *fp, int ch);
 476 extern size_t __wprintf_buffer_as_file_xsputn (FILE *fp, const void *buf,
 477                                                size_t len);
 478
 479 enum
 480 {
 481   IO_STR_JUMPS                    = 0,
 482   IO_WSTR_JUMPS                   = 1,
 483   IO_FILE_JUMPS                   = 2,
 484   IO_FILE_JUMPS_MMAP              = 3,
 485   IO_FILE_JUMPS_MAYBE_MMAP        = 4,
 486   IO_WFILE_JUMPS                  = 5,
 487   IO_WFILE_JUMPS_MMAP             = 6,
 488   IO_WFILE_JUMPS_MAYBE_MMAP       = 7,
 489   IO_COOKIE_JUMPS                 = 8,
 490   IO_PROC_JUMPS                   = 9,
 491   IO_MEM_JUMPS                    = 10,
 492   IO_WMEM_JUMPS                   = 11,
 493   IO_PRINTF_BUFFER_AS_FILE_JUMPS  = 12,
 494   IO_WPRINTF_BUFFER_AS_FILE_JUMPS = 13,
 495 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
 496   IO_OLD_FILE_JUMPS               = 14,
 497   IO_OLD_PROC_JUMPS               = 15,
 498   IO_OLD_COOKIED_JUMPS            = 16,
 499   IO_VTABLES_NUM                  = IO_OLD_COOKIED_JUMPS + 1,
 500 #elif SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
 501   IO_OLD_COOKIED_JUMPS            = 14,
 502   IO_VTABLES_NUM                  = IO_OLD_COOKIED_JUMPS + 1,
 503 #else
 504   IO_VTABLES_NUM                  = IO_WPRINTF_BUFFER_AS_FILE_JUMPS + 1
 505 #endif
 506 };
 507 #define IO_VTABLES_LEN (IO_VTABLES_NUM * sizeof (struct _IO_jump_t))
 508
 509 extern const struct _IO_jump_t __io_vtables[] attribute_hidden;
 510 #define _IO_str_jumps                    (__io_vtables[IO_STR_JUMPS])
 511 #define _IO_wstr_jumps                   (__io_vtables[IO_WSTR_JUMPS])
 512 #define _IO_file_jumps                   (__io_vtables[IO_FILE_JUMPS])
 513 #define _IO_file_jumps_mmap              (__io_vtables[IO_FILE_JUMPS_MMAP])
 514 #define _IO_file_jumps_maybe_mmap        (__io_vtables[IO_FILE_JUMPS_MAYBE_MMAP])
 515 #define _IO_wfile_jumps                  (__io_vtables[IO_WFILE_JUMPS])
 516 #define _IO_wfile_jumps_mmap             (__io_vtables[IO_WFILE_JUMPS_MMAP])
 517 #define _IO_wfile_jumps_maybe_mmap       (__io_vtables[IO_WFILE_JUMPS_MAYBE_MMAP])
 518 #define _IO_cookie_jumps                 (__io_vtables[IO_COOKIE_JUMPS])
 519 #define _IO_proc_jumps                   (__io_vtables[IO_PROC_JUMPS])
 520 #define _IO_mem_jumps                    (__io_vtables[IO_MEM_JUMPS])
 521 #define _IO_wmem_jumps                   (__io_vtables[IO_WMEM_JUMPS])
 522 #define _IO_printf_buffer_as_file_jumps  (__io_vtables[IO_PRINTF_BUFFER_AS_FILE_JUMPS])
 523 #define _IO_wprintf_buffer_as_file_jumps (__io_vtables[IO_WPRINTF_BUFFER_AS_FILE_JUMPS])
 524 #define _IO_old_file_jumps               (__io_vtables[IO_OLD_FILE_JUMPS])
 525 #define _IO_old_proc_jumps               (__io_vtables[IO_OLD_PROC_JUMPS])
 526 #define _IO_old_cookie_jumps             (__io_vtables[IO_OLD_COOKIED_JUMPS])
 527
 528 #ifdef SHARED
 529 # define libio_static_fn_required(name)
 530 #else
 531 # define libio_static_fn_required(name) __asm (".globl " #name);
 532 #endif
 533
 534 extern int _IO_do_write (FILE *, const char *, size_t);
 535 libc_hidden_proto (_IO_do_write)
 536 extern int _IO_new_do_write (FILE *, const char *, size_t);
 537 extern int _IO_old_do_write (FILE *, const char *, size_t);
 538 extern int _IO_wdo_write (FILE *, const wchar_t *, size_t);
 539 libc_hidden_proto (_IO_wdo_write)
 540 extern int _IO_flush_all (void);
 541 libc_hidden_proto (_IO_flush_all)
 542 extern void _IO_flush_all_linebuffered (void);
 543 libc_hidden_proto (_IO_flush_all_linebuffered)
 544 extern int _IO_new_fgetpos (FILE *, __fpos_t *);
 545 extern int _IO_old_fgetpos (FILE *, __fpos_t *);
 546 extern int _IO_new_fsetpos (FILE *, const __fpos_t *);
 547 extern int _IO_old_fsetpos (FILE *, const __fpos_t *);
 548 extern int _IO_new_fgetpos64 (FILE *, __fpos64_t *);
 549 extern int _IO_old_fgetpos64 (FILE *, __fpos64_t *);
 550 extern int _IO_new_fsetpos64 (FILE *, const __fpos64_t *);
 551 extern int _IO_old_fsetpos64 (FILE *, const __fpos64_t *);
 552 extern void _IO_old_init (FILE *fp, int flags) __THROW;
 553
 554
 555 #define _IO_do_flush(_f) \
 556   ((_f)->_mode <= 0                                                           \
 557    ? _IO_do_write(_f, (_f)->_IO_write_base,                                   \
 558                   (_f)->_IO_write_ptr-(_f)->_IO_write_base)                   \
 559    : _IO_wdo_write(_f, (_f)->_wide_data->_IO_write_base,                      \
 560                    ((_f)->_wide_data->_IO_write_ptr                           \
 561                     - (_f)->_wide_data->_IO_write_base)))
 562 #define _IO_old_do_flush(_f) \
 563   _IO_old_do_write(_f, (_f)->_IO_write_base, \
 564                    (_f)->_IO_write_ptr-(_f)->_IO_write_base)
 565 #define _IO_in_put_mode(_fp) ((_fp)->_flags & _IO_CURRENTLY_PUTTING)
 566 #define _IO_mask_flags(fp, f, mask) \
 567        ((fp)->_flags = ((fp)->_flags & ~(mask)) | ((f) & (mask)))
 568 #define _IO_setg(fp, eb, g, eg)  ((fp)->_IO_read_base = (eb),\
 569         (fp)->_IO_read_ptr = (g), (fp)->_IO_read_end = (eg))
 570 #define _IO_wsetg(fp, eb, g, eg)  ((fp)->_wide_data->_IO_read_base = (eb),\
 571         (fp)->_wide_data->_IO_read_ptr = (g), \
 572         (fp)->_wide_data->_IO_read_end = (eg))
 573 #define _IO_setp(__fp, __p, __ep) \
 574        ((__fp)->_IO_write_base = (__fp)->_IO_write_ptr \
 575         = __p, (__fp)->_IO_write_end = (__ep))
 576 #define _IO_wsetp(__fp, __p, __ep) \
 577        ((__fp)->_wide_data->_IO_write_base \
 578         = (__fp)->_wide_data->_IO_write_ptr = __p, \
 579         (__fp)->_wide_data->_IO_write_end = (__ep))
 580 #define _IO_have_backup(fp) ((fp)->_IO_save_base != NULL)
 581 #define _IO_have_wbackup(fp) ((fp)->_wide_data->_IO_save_base != NULL)
 582 #define _IO_in_backup(fp) ((fp)->_flags & _IO_IN_BACKUP)
 583 #define _IO_have_markers(fp) ((fp)->_markers != NULL)
 584 #define _IO_blen(fp) ((fp)->_IO_buf_end - (fp)->_IO_buf_base)
 585 #define _IO_wblen(fp) ((fp)->_wide_data->_IO_buf_end \
 586                        - (fp)->_wide_data->_IO_buf_base)
 587
 588 /* Jumptable functions for files. */
 589
 590 extern int _IO_file_doallocate (FILE *) __THROW;
 591 libc_hidden_proto (_IO_file_doallocate)
 592 extern FILE* _IO_file_setbuf (FILE *, char *, ssize_t);
 593 libc_hidden_proto (_IO_file_setbuf)
 594 extern off64_t _IO_file_seekoff (FILE *, off64_t, int, int);
 595 libc_hidden_proto (_IO_file_seekoff)
 596 extern off64_t _IO_file_seekoff_mmap (FILE *, off64_t, int, int)
 597      __THROW;
 598 extern size_t _IO_file_xsputn (FILE *, const void *, size_t);
 599 libc_hidden_proto (_IO_file_xsputn)
 600 extern size_t _IO_file_xsgetn (FILE *, void *, size_t);
 601 libc_hidden_proto (_IO_file_xsgetn)
 602 extern int _IO_file_stat (FILE *, void *) __THROW;
 603 libc_hidden_proto (_IO_file_stat)
 604 extern int _IO_file_close (FILE *) __THROW;
 605 libc_hidden_proto (_IO_file_close)
 606 extern int _IO_file_close_mmap (FILE *) __THROW;
 607 extern int _IO_file_underflow (FILE *);
 608 libc_hidden_proto (_IO_file_underflow)
 609 extern int _IO_file_underflow_mmap (FILE *);
 610 extern int _IO_file_underflow_maybe_mmap (FILE *);
 611 extern int _IO_file_overflow (FILE *, int);
 612 libc_hidden_proto (_IO_file_overflow)
 613 #define _IO_file_is_open(__fp) ((__fp)->_fileno != -1)
 614 extern FILE* _IO_file_attach (FILE *, int);
 615 libc_hidden_proto (_IO_file_attach)
 616 extern FILE* _IO_file_open (FILE *, const char *, int, int, int, int);
 617 libc_hidden_proto (_IO_file_open)
 618 extern FILE* _IO_file_fopen (FILE *, const char *, const char *, int);
 619 libc_hidden_proto (_IO_file_fopen)
 620 extern ssize_t _IO_file_write (FILE *, const void *, ssize_t);
 621 extern ssize_t _IO_file_read (FILE *, void *, ssize_t);
 622 libc_hidden_proto (_IO_file_read)
 623 extern int _IO_file_sync (FILE *);
 624 libc_hidden_proto (_IO_file_sync)
 625 extern int _IO_file_close_it (FILE *);
 626 libc_hidden_proto (_IO_file_close_it)
 627 extern off64_t _IO_file_seek (FILE *, off64_t, int) __THROW;
 628 libc_hidden_proto (_IO_file_seek)
 629 extern void _IO_file_finish (FILE *, int);
 630 libc_hidden_proto (_IO_file_finish)
 631
 632 extern FILE* _IO_new_file_attach (FILE *, int);
 633 extern int _IO_new_file_close_it (FILE *);
 634 extern void _IO_new_file_finish (FILE *, int);
 635 extern FILE* _IO_new_file_fopen (FILE *, const char *, const char *,
 636                                      int);
 637 extern void _IO_no_init (FILE *, int, int, struct _IO_wide_data *,
 638                          const struct _IO_jump_t *) __THROW;
 639 extern void _IO_new_file_init_internal (struct _IO_FILE_plus *)
 640   __THROW attribute_hidden;
 641 extern FILE* _IO_new_file_setbuf (FILE *, char *, ssize_t);
 642 extern FILE* _IO_file_setbuf_mmap (FILE *, char *, ssize_t);
 643 extern int _IO_new_file_sync (FILE *);
 644 extern int _IO_file_sync_mmap (FILE *) attribute_hidden;
 645 extern size_t  _IO_file_xsgetn_maybe_mmap (FILE *fp, void *data, size_t n)
 646   attribute_hidden;
 647 extern size_t _IO_file_xsgetn_mmap (FILE *fp, void *data, size_t n)
 648   attribute_hidden;
 649 extern off64_t _IO_file_seekoff_maybe_mmap (FILE *fp, off64_t offset, int dir,
 650                                             int mode)
 651      attribute_hidden;
 652 extern int _IO_new_file_underflow (FILE *);
 653 extern int _IO_new_file_overflow (FILE *, int);
 654 extern off64_t _IO_new_file_seekoff (FILE *, off64_t, int, int);
 655 extern ssize_t _IO_new_file_write (FILE *, const void *, ssize_t);
 656 extern size_t _IO_new_file_xsputn (FILE *, const void *, size_t);
 657
 658 extern FILE* _IO_old_file_setbuf (FILE *, char *, ssize_t);
 659 extern off64_t _IO_old_file_seekoff (FILE *, off64_t, int, int);
 660 extern size_t _IO_old_file_xsputn (FILE *, const void *, size_t);
 661 extern int _IO_old_file_underflow (FILE *);
 662 extern int _IO_old_file_overflow (FILE *, int);
 663 extern void _IO_old_file_init_internal (struct _IO_FILE_plus *)
 664   __THROW attribute_hidden;
 665 extern FILE* _IO_old_file_attach (FILE *, int);
 666 extern FILE* _IO_old_file_fopen (FILE *, const char *, const char *);
 667 extern ssize_t _IO_old_file_write (FILE *, const void *, ssize_t);
 668 extern int _IO_old_file_sync (FILE *);
 669 extern int _IO_old_file_close_it (FILE *);
 670 extern void _IO_old_file_finish (FILE *, int);
 671
 672 extern int _IO_wfile_doallocate (FILE *) __THROW;
 673 extern size_t _IO_wfile_xsputn (FILE *, const void *, size_t);
 674 libc_hidden_proto (_IO_wfile_xsputn)
 675 extern FILE* _IO_wfile_setbuf (FILE *, wchar_t *, ssize_t);
 676 extern wint_t _IO_wfile_sync (FILE *);
 677 libc_hidden_proto (_IO_wfile_sync)
 678 extern wint_t _IO_wfile_underflow (FILE *);
 679 libc_hidden_proto (_IO_wfile_underflow)
 680 extern wint_t _IO_wfile_overflow (FILE *, wint_t);
 681 libc_hidden_proto (_IO_wfile_overflow)
 682 extern off64_t _IO_wfile_seekoff (FILE *, off64_t, int, int);
 683 libc_hidden_proto (_IO_wfile_seekoff)
 684 extern wint_t _IO_wfile_underflow_maybe_mmap (FILE *fp)
 685      attribute_hidden;
 686 extern wint_t _IO_wfile_underflow_mmap (FILE *fp)
 687      attribute_hidden;
 688
 689 /* Jumptable functions for proc_files. */
 690 extern FILE* _IO_proc_open (FILE *, const char *, const char *)
 691      __THROW;
 692 extern FILE* _IO_new_proc_open (FILE *, const char *, const char *)
 693      __THROW;
 694 extern FILE* _IO_old_proc_open (FILE *, const char *, const char *);
 695 extern int _IO_proc_close (FILE *) __THROW;
 696 extern int _IO_new_proc_close (FILE *) __THROW;
 697 extern int _IO_old_proc_close (FILE *);
 698
 699 /* Jumptable functions for strfiles. */
 700 extern int _IO_str_underflow (FILE *) __THROW;
 701 libc_hidden_proto (_IO_str_underflow)
 702 extern int _IO_str_overflow (FILE *, int) __THROW;
 703 libc_hidden_proto (_IO_str_overflow)
 704 extern int _IO_str_pbackfail (FILE *, int) __THROW;
 705 libc_hidden_proto (_IO_str_pbackfail)
 706 extern off64_t _IO_str_seekoff (FILE *, off64_t, int, int) __THROW
 707  ;
 708 libc_hidden_proto (_IO_str_seekoff)
 709 extern void _IO_str_finish (FILE *, int) __THROW;
 710 extern int _IO_str_chk_overflow (FILE *fp, int c) __THROW
 711   attribute_hidden;
 712
 713 /* Jumptable functions for fopencookie.  */
 714 extern ssize_t _IO_cookie_read (FILE *fp, void *buf, ssize_t size)
 715   attribute_hidden;
 716 extern ssize_t _IO_cookie_write (FILE *fp, const void *buf, ssize_t size)
 717   attribute_hidden;
 718 extern off64_t _IO_cookie_seek (FILE *fp, off64_t offset, int dir)
 719   attribute_hidden;
 720 extern int _IO_cookie_close (FILE *fp) attribute_hidden;
 721 extern off64_t _IO_cookie_seekoff (FILE *fp, off64_t offset, int dir, int mode)
 722   attribute_hidden;
 723 extern off64_t _IO_old_cookie_seek (FILE *fp, off64_t offset, int dir)
 724   attribute_hidden;
 725
 726 /* Jumptable functions for obstack.  */
 727 extern int __IO_obstack_overflow (FILE *fp, int c) attribute_hidden;
 728 extern size_t __IO_obstack_xsputn (FILE *fp, const void *data, size_t n)
 729   attribute_hidden;
 730
 731 /* Jumptable functions for open_{w}memstream.  */
 732 extern int _IO_mem_sync (FILE* fp) __THROW attribute_hidden;
 733 extern void _IO_mem_finish (FILE* fp, int) __THROW attribute_hidden;
 734 extern int _IO_wmem_sync (FILE* fp) __THROW attribute_hidden;
 735 extern void _IO_wmem_finish (FILE* fp, int) __THROW attribute_hidden;
 736
 737 /* Other strfile functions */
 738 struct _IO_strfile_;
 739 extern ssize_t _IO_str_count (FILE *) __THROW;
 740 extern int _IO_strn_overflow (FILE *fp, int c) __THROW attribute_hidden;
 741
 742 /* And the wide character versions.  */
 743 extern void _IO_wstr_init_static (FILE *, wchar_t *, size_t, wchar_t *)
 744      __THROW;
 745 extern ssize_t _IO_wstr_count (FILE *) __THROW;
 746 extern wint_t _IO_wstr_overflow (FILE *, wint_t) __THROW;
 747 extern wint_t _IO_wstr_underflow (FILE *) __THROW;
 748 extern off64_t _IO_wstr_seekoff (FILE *, off64_t, int, int)
 749      __THROW;
 750 extern wint_t _IO_wstr_pbackfail (FILE *, wint_t) __THROW;
 751 extern void _IO_wstr_finish (FILE *, int) __THROW;
 752
 753 /* Helper functions.  */
 754 int _IO_helper_overflow (FILE *s, int c);
 755 int _IO_whelper_overflow (FILE *s, int c);
 756
 757 /* Internal versions of v*printf that take an additional flags
 758    parameter.  */
 759 extern int __vfprintf_internal (FILE *fp, const char *format, va_list ap,
 760                                 unsigned int mode_flags)
 761     attribute_hidden;
 762 extern int __vfwprintf_internal (FILE *fp, const wchar_t *format, va_list ap,
 763                                  unsigned int mode_flags)
 764     attribute_hidden;
 765
 766 extern int __vasprintf_internal (char **result_ptr, const char *format,
 767                                  va_list ap, unsigned int mode_flags)
 768     attribute_hidden;
 769 extern int __vdprintf_internal (int d, const char *format, va_list ap,
 770                                 unsigned int mode_flags)
 771     attribute_hidden;
 772 extern int __obstack_vprintf_internal (struct obstack *ob, const char *fmt,
 773                                        va_list ap, unsigned int mode_flags)
 774     attribute_hidden;
 775
 776 /* Note: __vsprintf_internal, unlike vsprintf, does take a maxlen argument,
 777    because it's called by both vsprintf and vsprintf_chk.  If maxlen is
 778    not set to -1, overrunning the buffer will cause a prompt crash.
 779    This is the behavior of ordinary (v)sprintf functions, thus they call
 780    __vsprintf_internal with that argument set to -1.  */
 781 extern int __vsprintf_internal (char *string, size_t maxlen,
 782                                 const char *format, va_list ap,
 783                                 unsigned int mode_flags)
 784     attribute_hidden;
 785
 786 extern int __vsnprintf_internal (char *string, size_t maxlen,
 787                                  const char *format, va_list ap,
 788                                  unsigned int mode_flags)
 789     attribute_hidden;
 790 extern int __vswprintf_internal (wchar_t *string, size_t maxlen,
 791                                  const wchar_t *format, va_list ap,
 792                                  unsigned int mode_flags)
 793     attribute_hidden;
 794
 795 /* Flags for __v*printf_internal.
 796
 797    PRINTF_LDBL_IS_DBL indicates whether long double values are to be
 798    handled as having the same format as double, in which case the flag
 799    should be set to one, or as another format, otherwise.
 800
 801    PRINTF_FORTIFY, when set to one, indicates that fortification checks
 802    are to be performed in input parameters.  This is used by the
 803    __*printf_chk functions, which are used when _FORTIFY_SOURCE is
 804    defined to 1 or 2.  Otherwise, such checks are ignored.
 805
 806    PRINTF_CHK indicates, to the internal function being called, that the
 807    call is originated from one of the __*printf_chk functions.
 808
 809    PRINTF_LDBL_USES_FLOAT128 is used on platforms where the long double
 810    format used to be different from the IEC 60559 double format *and*
 811    also different from the Quadruple 128-bits IEC 60559 format (such as
 812    the IBM Extended Precision format on powerpc or the 80-bits IEC 60559
 813    format on x86), but was later converted to the Quadruple 128-bits IEC
 814    60559 format, which is the same format that the _Float128 always has
 815    (hence the `USES_FLOAT128' suffix in the name of the flag).  When set
 816    to one, this macro indicates that long double values are to be
 817    handled as having this new format.  Otherwise, they should be handled
 818    as the previous format on that platform.  */
 819 #define PRINTF_LDBL_IS_DBL              0x0001
 820 #define PRINTF_FORTIFY                  0x0002
 821 #define PRINTF_CHK                      0x0004
 822 #define PRINTF_LDBL_USES_FLOAT128       0x0008
 823
 824 extern size_t _IO_getline (FILE *,char *, size_t, int, int);
 825 libc_hidden_proto (_IO_getline)
 826 extern size_t _IO_getline_info (FILE *,char *, size_t,
 827                                     int, int, int *);
 828 libc_hidden_proto (_IO_getline_info)
 829 extern size_t _IO_getwline (FILE *,wchar_t *, size_t, wint_t, int);
 830 extern size_t _IO_getwline_info (FILE *,wchar_t *, size_t,
 831                                      wint_t, int, wint_t *);
 832
 833 extern struct _IO_FILE_plus *_IO_list_all;
 834 libc_hidden_proto (_IO_list_all)
 835 extern void (*_IO_cleanup_registration_needed) (void);
 836
 837 extern void _IO_str_init_static_internal (struct _IO_strfile_ *, char *,
 838                                           size_t, char *) __THROW;
 839 extern off64_t _IO_seekoff_unlocked (FILE *, off64_t, int, int)
 840      attribute_hidden;
 841 extern off64_t _IO_seekpos_unlocked (FILE *, off64_t, int)
 842      attribute_hidden;
 843
 844 #if _G_HAVE_MMAP
 845
 846 # include <unistd.h>
 847 # include <fcntl.h>
 848 # include <sys/mman.h>
 849 # include <sys/param.h>
 850
 851 # if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
 852 #  define MAP_ANONYMOUS MAP_ANON
 853 # endif
 854
 855 # if !defined(MAP_ANONYMOUS) || !defined(EXEC_PAGESIZE)
 856 #  undef _G_HAVE_MMAP
 857 #  define _G_HAVE_MMAP 0
 858 # endif
 859
 860 #endif /* _G_HAVE_MMAP */
 861
 862 /* Flags for __vfscanf_internal and __vfwscanf_internal.
 863
 864    SCANF_LDBL_IS_DBL indicates whether long double values are to be
 865    handled as having the same format as double, in which case the flag
 866    should be set to one, or as another format, otherwise.
 867
 868    SCANF_ISOC99_A, when set to one, indicates that the ISO C99 or POSIX
 869    behavior of the scanf functions is to be used, i.e. automatic
 870    allocation for input strings with %as, %aS and %a[, a GNU extension,
 871    is disabled. This is the behavior that the __isoc99_scanf family of
 872    functions use.  When the flag is set to zero, automatic allocation is
 873    enabled.
 874
 875    SCANF_ISOC23_BIN_CST, when set to one, indicates the %i accepts
 876    binary constants starting 0b or 0B.
 877
 878    SCANF_LDBL_USES_FLOAT128 is used on platforms where the long double
 879    format used to be different from the IEC 60559 double format *and*
 880    also different from the Quadruple 128-bits IEC 60559 format (such as
 881    the IBM Extended Precision format on powerpc or the 80-bits IEC 60559
 882    format on x86), but was later converted to the Quadruple 128-bits IEC
 883    60559 format, which is the same format that the _Float128 always has
 884    (hence the `USES_FLOAT128' suffix in the name of the flag).  When set
 885    to one, this macros indicates that long double values are to be
 886    handled as having this new format.  Otherwise, they should be handled
 887    as the previous format on that platform.  */
 888 #define SCANF_LDBL_IS_DBL               0x0001
 889 #define SCANF_ISOC99_A                  0x0002
 890 #define SCANF_ISOC23_BIN_CST            0x0004
 891 #define SCANF_LDBL_USES_FLOAT128        0x0008
 892
 893 extern int __vfscanf_internal (FILE *fp, const char *format, va_list argp,
 894                                unsigned int flags)
 895   attribute_hidden;
 896 extern int __vfwscanf_internal (FILE *fp, const wchar_t *format, va_list argp,
 897                                 unsigned int flags)
 898   attribute_hidden;
 899
 900 extern int _IO_vscanf (const char *, va_list) __THROW;
 901
 902 #ifdef _IO_MTSAFE_IO
 903 /* check following! */
 904 # ifdef _IO_USE_OLD_IO_FILE
 905 #  define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \
 906        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
 907          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (FILE *) CHAIN, FD, \
 908          0, _IO_pos_BAD, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock }
 909 # else
 910 #  define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \
 911        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
 912          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (FILE *) CHAIN, FD, \
 913          0, _IO_pos_BAD, 0, 0, { 0 }, &_IO_stdfile_##FD##_lock, _IO_pos_BAD,\
 914          NULL, WDP, 0 }
 915 # endif
 916 #else
 917 # ifdef _IO_USE_OLD_IO_FILE
 918 #  define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \
 919        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
 920          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (FILE *) CHAIN, FD, \
 921          0, _IO_pos_BAD }
 922 # else
 923 #  define FILEBUF_LITERAL(CHAIN, FLAGS, FD, WDP) \
 924        { _IO_MAGIC+_IO_LINKED+_IO_IS_FILEBUF+FLAGS, \
 925          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (FILE *) CHAIN, FD, \
 926          0, _IO_pos_BAD, 0, 0, { 0 }, 0, _IO_pos_BAD, \
 927          NULL, WDP, 0 }
 928 # endif
 929 #endif
 930
 931 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
 932 /* See oldstdfiles.c.  These are the old stream variables.  */
 933 extern struct _IO_FILE_plus _IO_stdin_;
 934 extern struct _IO_FILE_plus _IO_stdout_;
 935 extern struct _IO_FILE_plus _IO_stderr_;
 936
 937 static inline bool
 938 _IO_legacy_file (FILE *fp)
 939 {
 940   return fp == (FILE *) &_IO_stdin_ || fp == (FILE *) &_IO_stdout_
 941     || fp == (FILE *) &_IO_stderr_;
 942 }
 943 #endif
 944
 945 /* Deallocate a stream if it is heap-allocated.  Preallocated
 946    stdin/stdout/stderr streams are not deallocated. */
 947 static inline void
 948 _IO_deallocate_file (FILE *fp)
 949 {
 950   /* The current stream variables.  */
 951   if (fp == (FILE *) &_IO_2_1_stdin_ || fp == (FILE *) &_IO_2_1_stdout_
 952       || fp == (FILE *) &_IO_2_1_stderr_)
 953     return;
 954 #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
 955   if (_IO_legacy_file (fp))
 956     return;
 957 #endif
 958   free (fp);
 959 }
 960
 961 #ifdef IO_DEBUG
 962 # define CHECK_FILE(FILE, RET) do {                             \
 963     if ((FILE) == NULL                                          \
 964         || ((FILE)->_flags & _IO_MAGIC_MASK) != _IO_MAGIC)      \
 965       {                                                         \
 966         __set_errno (EINVAL);                                   \
 967         return RET;                                             \
 968       }                                                         \
 969   } while (0)
 970 #else
 971 # define CHECK_FILE(FILE, RET) do { } while (0)
 972 #endif
 973
 974 static inline void
 975 __attribute__ ((__always_inline__))
 976 _IO_acquire_lock_fct (FILE **p)
 977 {
 978   FILE *fp = *p;
 979   if ((fp->_flags & _IO_USER_LOCK) == 0)
 980     _IO_funlockfile (fp);
 981 }
 982
 983 #if !defined _IO_MTSAFE_IO && IS_IN (libc)
 984 # define _IO_acquire_lock(_fp)                                                \
 985   do {
 986 # define _IO_release_lock(_fp)                                                \
 987   } while (0)
 988 #endif
 989
 990 #ifdef SHARED
 991 /* If equal to &_IO_vtable_check (with pointer guard protection),
 992    unknown vtable pointers are valid.  This function pointer is solely
 993    used as a flag.  */
 994 extern void (*IO_accept_foreign_vtables) (void) attribute_hidden;
 995
 996 /* Assigns the passed function pointer (either NULL or
 997    &_IO_vtable_check) to IO_accept_foreign_vtables.  */
 998 static inline void
 999 IO_set_accept_foreign_vtables (void (*flag) (void))
1000 {
1001   PTR_MANGLE (flag);
1002   atomic_store_relaxed (&IO_accept_foreign_vtables, flag);
1003 }
1004
1005 #else  /* !SHARED */
1006
1007 /* The statically-linked version does nothing. */
1008 static inline void
1009 IO_set_accept_foreign_vtables (void (*flag) (void))
1010 {
1011 }
1012
1013 #endif
1014
1015 /* Check if unknown vtable pointers are permitted; otherwise,
1016    terminate the process.  */
1017 void _IO_vtable_check (void) attribute_hidden;
1018
1019 /* Perform vtable pointer validation.  If validation fails, terminate
1020    the process.  */
1021 static inline const struct _IO_jump_t *
1022 IO_validate_vtable (const struct _IO_jump_t *vtable)
1023 {
1024   uintptr_t ptr = (uintptr_t) vtable;
1025   uintptr_t offset = ptr - (uintptr_t) &__io_vtables;
1026   if (__glibc_unlikely (offset >= IO_VTABLES_LEN))
1027     /* The vtable pointer is not in the expected section.  Use the
1028        slow path, which will terminate the process if necessary.  */
1029     _IO_vtable_check ();
1030   return vtable;
1031 }
1032
1033 /* Character set conversion.  */
1034
1035 enum __codecvt_result
1036 {
1037   __codecvt_ok,
1038   __codecvt_partial,
1039   __codecvt_error,
1040   __codecvt_noconv
1041 };
1042
1043 enum __codecvt_result __libio_codecvt_out (struct _IO_codecvt *,
1044                                            __mbstate_t *,
1045                                            const wchar_t *,
1046                                            const wchar_t *,
1047                                            const wchar_t **, char *,
1048                                            char *, char **)
1049   attribute_hidden;
1050 enum __codecvt_result __libio_codecvt_in (struct _IO_codecvt *,
1051                                           __mbstate_t *,
1052                                           const char *, const char *,
1053                                           const char **, wchar_t *,
1054                                           wchar_t *, wchar_t **)
1055   attribute_hidden;
1056 int __libio_codecvt_encoding (struct _IO_codecvt *) attribute_hidden;
1057 int __libio_codecvt_length (struct _IO_codecvt *, __mbstate_t *,
1058                             const char *, const char *, size_t)
1059   attribute_hidden;
1060
1061 #endif /* libioP.h.  */