From ba02c1bd6981675aaf5a0b6cddb7457e53d5eed1 Mon Sep 17 00:00:00 2001 From: Brett Weiland Date: Mon, 4 Jan 2021 16:32:01 -0600 Subject: new file: HeapLAB+Bible.pdf new file: HeapLAB/.glibc/glibc_2.23/ld-2.23.so new file: HeapLAB/.glibc/glibc_2.23/ld.so.2 new file: HeapLAB/.glibc/glibc_2.23/libc-2.23.so new file: HeapLAB/.glibc/glibc_2.23/libc.so.6 new file: HeapLAB/.glibc/glibc_2.23/libio/genops.c new file: HeapLAB/.glibc/glibc_2.23/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.23_unsafe-unlink/ld-2.23.so new file: HeapLAB/.glibc/glibc_2.23_unsafe-unlink/ld.so.2 new file: HeapLAB/.glibc/glibc_2.23_unsafe-unlink/libc-2.23.so new file: HeapLAB/.glibc/glibc_2.23_unsafe-unlink/libc.so.6 new file: HeapLAB/.glibc/glibc_2.23_unsafe-unlink/libio/genops.c new file: HeapLAB/.glibc/glibc_2.23_unsafe-unlink/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.24/ld-2.24.so new file: HeapLAB/.glibc/glibc_2.24/ld.so.2 new file: HeapLAB/.glibc/glibc_2.24/libc-2.24.so new file: HeapLAB/.glibc/glibc_2.24/libc.so.6 new file: HeapLAB/.glibc/glibc_2.24/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.25/ld-2.25.so new file: HeapLAB/.glibc/glibc_2.25/ld.so.2 new file: HeapLAB/.glibc/glibc_2.25/libc-2.25.so new file: HeapLAB/.glibc/glibc_2.25/libc.so.6 new file: HeapLAB/.glibc/glibc_2.25/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.26/ld-2.26.so new file: HeapLAB/.glibc/glibc_2.26/ld.so.2 new file: HeapLAB/.glibc/glibc_2.26/libc-2.26.so new file: HeapLAB/.glibc/glibc_2.26/libc.so.6 new file: HeapLAB/.glibc/glibc_2.26/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.26_no-tcache/ld-2.26.so new file: HeapLAB/.glibc/glibc_2.26_no-tcache/ld.so.2 new file: HeapLAB/.glibc/glibc_2.26_no-tcache/libc-2.26.so new file: HeapLAB/.glibc/glibc_2.26_no-tcache/libc.so.6 new file: HeapLAB/.glibc/glibc_2.26_no-tcache/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.27/ld-2.27.so new file: HeapLAB/.glibc/glibc_2.27/ld.so.2 new file: HeapLAB/.glibc/glibc_2.27/libc-2.27.so new file: HeapLAB/.glibc/glibc_2.27/libc.so.6 new file: HeapLAB/.glibc/glibc_2.27/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.27_no-tcache/ld-2.27.so new file: HeapLAB/.glibc/glibc_2.27_no-tcache/ld.so.2 new file: HeapLAB/.glibc/glibc_2.27_no-tcache/libc-2.27.so new file: HeapLAB/.glibc/glibc_2.27_no-tcache/libc.so.6 new file: HeapLAB/.glibc/glibc_2.27_no-tcache/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.27_ubuntu1804/.debug/ld-2.27.so new file: HeapLAB/.glibc/glibc_2.27_ubuntu1804/.debug/libc-2.27.so new file: HeapLAB/.glibc/glibc_2.27_ubuntu1804/ld-2.27.so new file: HeapLAB/.glibc/glibc_2.27_ubuntu1804/ld.so.2 new file: HeapLAB/.glibc/glibc_2.27_ubuntu1804/libc-2.27.so new file: HeapLAB/.glibc/glibc_2.27_ubuntu1804/libc.so.6 new file: HeapLAB/.glibc/glibc_2.28/ld-2.28.so new file: HeapLAB/.glibc/glibc_2.28/ld.so.2 new file: HeapLAB/.glibc/glibc_2.28/libc-2.28.so new file: HeapLAB/.glibc/glibc_2.28/libc.so.6 new file: HeapLAB/.glibc/glibc_2.28/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.28_no-tcache/ld-2.28.so new file: HeapLAB/.glibc/glibc_2.28_no-tcache/ld.so.2 new file: HeapLAB/.glibc/glibc_2.28_no-tcache/libc-2.28.so new file: HeapLAB/.glibc/glibc_2.28_no-tcache/libc.so.6 new file: HeapLAB/.glibc/glibc_2.28_no-tcache/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.29/ld-2.29.so new file: HeapLAB/.glibc/glibc_2.29/ld.so.2 new file: HeapLAB/.glibc/glibc_2.29/libc-2.29.so new file: HeapLAB/.glibc/glibc_2.29/libc.so.6 new file: HeapLAB/.glibc/glibc_2.29/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.29_no-tcache/ld-2.29.so new file: HeapLAB/.glibc/glibc_2.29_no-tcache/ld.so.2 new file: HeapLAB/.glibc/glibc_2.29_no-tcache/libc-2.29.so new file: HeapLAB/.glibc/glibc_2.29_no-tcache/libc.so.6 new file: HeapLAB/.glibc/glibc_2.29_no-tcache/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.29_ubuntu1904/.debug/ld-2.29.so new file: HeapLAB/.glibc/glibc_2.29_ubuntu1904/.debug/libc-2.29.so new file: HeapLAB/.glibc/glibc_2.29_ubuntu1904/ld-2.29.so new file: HeapLAB/.glibc/glibc_2.29_ubuntu1904/ld.so.2 new file: HeapLAB/.glibc/glibc_2.29_ubuntu1904/libc-2.29.so new file: HeapLAB/.glibc/glibc_2.29_ubuntu1904/libc.so.6 new file: HeapLAB/.glibc/glibc_2.30/ld-2.30.so new file: HeapLAB/.glibc/glibc_2.30/ld.so.2 new file: HeapLAB/.glibc/glibc_2.30/libc-2.30.so new file: HeapLAB/.glibc/glibc_2.30/libc.so.6 new file: HeapLAB/.glibc/glibc_2.30/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.30_no-tcache/ld-2.30.so new file: HeapLAB/.glibc/glibc_2.30_no-tcache/ld.so.2 new file: HeapLAB/.glibc/glibc_2.30_no-tcache/libc-2.30.so new file: HeapLAB/.glibc/glibc_2.30_no-tcache/libc.so.6 new file: HeapLAB/.glibc/glibc_2.30_no-tcache/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.31/ld-2.31.so new file: HeapLAB/.glibc/glibc_2.31/ld.so.2 new file: HeapLAB/.glibc/glibc_2.31/libc-2.31.so new file: HeapLAB/.glibc/glibc_2.31/libc.so.6 new file: HeapLAB/.glibc/glibc_2.31/malloc/malloc.c new file: HeapLAB/.glibc/glibc_2.31_no-tcache/ld-2.31.so new file: HeapLAB/.glibc/glibc_2.31_no-tcache/ld.so.2 new file: HeapLAB/.glibc/glibc_2.31_no-tcache/libc-2.31.so new file: HeapLAB/.glibc/glibc_2.31_no-tcache/libc.so.6 new file: HeapLAB/.glibc/glibc_2.31_no-tcache/malloc/malloc.c new file: HeapLAB/.src/demo_fastbins.c new file: HeapLAB/.src/demo_top_chunk.c new file: HeapLAB/.src/demo_unsortedbin.c new file: HeapLAB/HeapLab - GLIBC Heap Exploitation.pdf new file: HeapLAB/challenge-fastbin_dup/.gdb_history new file: HeapLAB/challenge-fastbin_dup/bruh.py new file: HeapLAB/challenge-fastbin_dup/fastbin_dup_2 new file: HeapLAB/challenge-fastbin_dup/pwntools_template.py new file: HeapLAB/challenge-one_byte/one_byte new file: HeapLAB/challenge-one_byte/pwntools_template.py new file: HeapLAB/fastbin_dup/demo new file: HeapLAB/fastbin_dup/fastbin_dup new file: HeapLAB/fastbin_dup/pwntools_template.py new file: HeapLAB/house_of_force/demo new file: HeapLAB/house_of_force/house_of_force new file: HeapLAB/house_of_force/pwntools_template.py new file: HeapLAB/house_of_orange/house_of_orange new file: HeapLAB/house_of_orange/pwntools_template.py new file: HeapLAB/malloc_testbed/.links/ld.so.2 new file: HeapLAB/malloc_testbed/.links/libc.so.6 new file: HeapLAB/malloc_testbed/change_glibc_version.py new file: HeapLAB/malloc_testbed/malloc_testbed new file: HeapLAB/malloc_testbed/pwntools_template.py new file: HeapLAB/safe_unlink/pwntools_template.py new file: HeapLAB/safe_unlink/safe_unlink new file: HeapLAB/unsafe_unlink/demo new file: HeapLAB/unsafe_unlink/pwntools_template.py new file: HeapLAB/unsafe_unlink/unsafe_unlink new file: original.gz --- HeapLAB/.glibc/glibc_2.23/libio/genops.c | 1253 ++++++++++++++++++++++++++++++ 1 file changed, 1253 insertions(+) create mode 100644 HeapLAB/.glibc/glibc_2.23/libio/genops.c (limited to 'HeapLAB/.glibc/glibc_2.23/libio/genops.c') diff --git a/HeapLAB/.glibc/glibc_2.23/libio/genops.c b/HeapLAB/.glibc/glibc_2.23/libio/genops.c new file mode 100644 index 0000000..5803cbf --- /dev/null +++ b/HeapLAB/.glibc/glibc_2.23/libio/genops.c @@ -0,0 +1,1253 @@ +/* Copyright (C) 1993-2016 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . + + As a special exception, if you link the code in this file with + files compiled with a GNU compiler to produce an executable, + that does not cause the resulting executable to be covered by + the GNU Lesser General Public License. This exception does not + however invalidate any other reasons why the executable file + might be covered by the GNU Lesser General Public License. + This exception applies to code released by its copyright holders + in files containing the exception. */ + +/* Generic or default I/O operations. */ + +#include "libioP.h" +#include +#include +#include +#ifdef _LIBC +#include +#endif + +#ifdef _IO_MTSAFE_IO +static _IO_lock_t list_all_lock = _IO_lock_initializer; +#endif + +/* Used to signal modifications to the list of FILE decriptors. */ +static int _IO_list_all_stamp; + + +static _IO_FILE *run_fp; + +#ifdef _IO_MTSAFE_IO +static void +flush_cleanup (void *not_used) +{ + if (run_fp != NULL) + _IO_funlockfile (run_fp); + _IO_lock_unlock (list_all_lock); +} +#endif + +void +_IO_un_link (struct _IO_FILE_plus *fp) +{ + if (fp->file._flags & _IO_LINKED) + { + struct _IO_FILE **f; +#ifdef _IO_MTSAFE_IO + _IO_cleanup_region_start_noarg (flush_cleanup); + _IO_lock_lock (list_all_lock); + run_fp = (_IO_FILE *) fp; + _IO_flockfile ((_IO_FILE *) fp); +#endif + if (_IO_list_all == NULL) + ; + else if (fp == _IO_list_all) + { + _IO_list_all = (struct _IO_FILE_plus *) _IO_list_all->file._chain; + ++_IO_list_all_stamp; + } + else + for (f = &_IO_list_all->file._chain; *f; f = &(*f)->_chain) + if (*f == (_IO_FILE *) fp) + { + *f = fp->file._chain; + ++_IO_list_all_stamp; + break; + } + fp->file._flags &= ~_IO_LINKED; +#ifdef _IO_MTSAFE_IO + _IO_funlockfile ((_IO_FILE *) fp); + run_fp = NULL; + _IO_lock_unlock (list_all_lock); + _IO_cleanup_region_end (0); +#endif + } +} +libc_hidden_def (_IO_un_link) + +void +_IO_link_in (struct _IO_FILE_plus *fp) +{ + if ((fp->file._flags & _IO_LINKED) == 0) + { + fp->file._flags |= _IO_LINKED; +#ifdef _IO_MTSAFE_IO + _IO_cleanup_region_start_noarg (flush_cleanup); + _IO_lock_lock (list_all_lock); + run_fp = (_IO_FILE *) fp; + _IO_flockfile ((_IO_FILE *) fp); +#endif + fp->file._chain = (_IO_FILE *) _IO_list_all; + _IO_list_all = fp; + ++_IO_list_all_stamp; +#ifdef _IO_MTSAFE_IO + _IO_funlockfile ((_IO_FILE *) fp); + run_fp = NULL; + _IO_lock_unlock (list_all_lock); + _IO_cleanup_region_end (0); +#endif + } +} +libc_hidden_def (_IO_link_in) + +/* Return minimum _pos markers + Assumes the current get area is the main get area. */ +_IO_ssize_t _IO_least_marker (_IO_FILE *fp, char *end_p); + +_IO_ssize_t +_IO_least_marker (_IO_FILE *fp, char *end_p) +{ + _IO_ssize_t least_so_far = end_p - fp->_IO_read_base; + struct _IO_marker *mark; + for (mark = fp->_markers; mark != NULL; mark = mark->_next) + if (mark->_pos < least_so_far) + least_so_far = mark->_pos; + return least_so_far; +} + +/* Switch current get area from backup buffer to (start of) main get area. */ + +void +_IO_switch_to_main_get_area (_IO_FILE *fp) +{ + char *tmp; + fp->_flags &= ~_IO_IN_BACKUP; + /* Swap _IO_read_end and _IO_save_end. */ + tmp = fp->_IO_read_end; + fp->_IO_read_end = fp->_IO_save_end; + fp->_IO_save_end= tmp; + /* Swap _IO_read_base and _IO_save_base. */ + tmp = fp->_IO_read_base; + fp->_IO_read_base = fp->_IO_save_base; + fp->_IO_save_base = tmp; + /* Set _IO_read_ptr. */ + fp->_IO_read_ptr = fp->_IO_read_base; +} + +/* Switch current get area from main get area to (end of) backup area. */ + +void +_IO_switch_to_backup_area (_IO_FILE *fp) +{ + char *tmp; + fp->_flags |= _IO_IN_BACKUP; + /* Swap _IO_read_end and _IO_save_end. */ + tmp = fp->_IO_read_end; + fp->_IO_read_end = fp->_IO_save_end; + fp->_IO_save_end = tmp; + /* Swap _IO_read_base and _IO_save_base. */ + tmp = fp->_IO_read_base; + fp->_IO_read_base = fp->_IO_save_base; + fp->_IO_save_base = tmp; + /* Set _IO_read_ptr. */ + fp->_IO_read_ptr = fp->_IO_read_end; +} + +int +_IO_switch_to_get_mode (_IO_FILE *fp) +{ + if (fp->_IO_write_ptr > fp->_IO_write_base) + if (_IO_OVERFLOW (fp, EOF) == EOF) + return EOF; + if (_IO_in_backup (fp)) + fp->_IO_read_base = fp->_IO_backup_base; + else + { + fp->_IO_read_base = fp->_IO_buf_base; + if (fp->_IO_write_ptr > fp->_IO_read_end) + fp->_IO_read_end = fp->_IO_write_ptr; + } + fp->_IO_read_ptr = fp->_IO_write_ptr; + + fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr; + + fp->_flags &= ~_IO_CURRENTLY_PUTTING; + return 0; +} +libc_hidden_def (_IO_switch_to_get_mode) + +void +_IO_free_backup_area (_IO_FILE *fp) +{ + if (_IO_in_backup (fp)) + _IO_switch_to_main_get_area (fp); /* Just in case. */ + free (fp->_IO_save_base); + fp->_IO_save_base = NULL; + fp->_IO_save_end = NULL; + fp->_IO_backup_base = NULL; +} +libc_hidden_def (_IO_free_backup_area) + +#if 0 +int +_IO_switch_to_put_mode (_IO_FILE *fp) +{ + fp->_IO_write_base = fp->_IO_read_ptr; + fp->_IO_write_ptr = fp->_IO_read_ptr; + /* Following is wrong if line- or un-buffered? */ + fp->_IO_write_end = (fp->_flags & _IO_IN_BACKUP + ? fp->_IO_read_end : fp->_IO_buf_end); + + fp->_IO_read_ptr = fp->_IO_read_end; + fp->_IO_read_base = fp->_IO_read_end; + + fp->_flags |= _IO_CURRENTLY_PUTTING; + return 0; +} +#endif + +int +__overflow (_IO_FILE *f, int ch) +{ + /* This is a single-byte stream. */ + if (f->_mode == 0) + _IO_fwide (f, -1); + return _IO_OVERFLOW (f, ch); +} +libc_hidden_def (__overflow) + +static int save_for_backup (_IO_FILE *fp, char *end_p) +#ifdef _LIBC + internal_function +#endif + ; + +static int +#ifdef _LIBC +internal_function +#endif +save_for_backup (_IO_FILE *fp, char *end_p) +{ + /* Append [_IO_read_base..end_p] to backup area. */ + _IO_ssize_t least_mark = _IO_least_marker (fp, end_p); + /* needed_size is how much space we need in the backup area. */ + _IO_size_t needed_size = (end_p - fp->_IO_read_base) - least_mark; + /* FIXME: Dubious arithmetic if pointers are NULL */ + _IO_size_t current_Bsize = fp->_IO_save_end - fp->_IO_save_base; + _IO_size_t avail; /* Extra space available for future expansion. */ + _IO_ssize_t delta; + struct _IO_marker *mark; + if (needed_size > current_Bsize) + { + char *new_buffer; + avail = 100; + new_buffer = (char *) malloc (avail + needed_size); + if (new_buffer == NULL) + return EOF; /* FIXME */ + if (least_mark < 0) + { +#ifdef _LIBC + __mempcpy (__mempcpy (new_buffer + avail, + fp->_IO_save_end + least_mark, + -least_mark), + fp->_IO_read_base, + end_p - fp->_IO_read_base); +#else + memcpy (new_buffer + avail, + fp->_IO_save_end + least_mark, + -least_mark); + memcpy (new_buffer + avail - least_mark, + fp->_IO_read_base, + end_p - fp->_IO_read_base); +#endif + } + else + memcpy (new_buffer + avail, + fp->_IO_read_base + least_mark, + needed_size); + free (fp->_IO_save_base); + fp->_IO_save_base = new_buffer; + fp->_IO_save_end = new_buffer + avail + needed_size; + } + else + { + avail = current_Bsize - needed_size; + if (least_mark < 0) + { + memmove (fp->_IO_save_base + avail, + fp->_IO_save_end + least_mark, + -least_mark); + memcpy (fp->_IO_save_base + avail - least_mark, + fp->_IO_read_base, + end_p - fp->_IO_read_base); + } + else if (needed_size > 0) + memcpy (fp->_IO_save_base + avail, + fp->_IO_read_base + least_mark, + needed_size); + } + fp->_IO_backup_base = fp->_IO_save_base + avail; + /* Adjust all the streammarkers. */ + delta = end_p - fp->_IO_read_base; + for (mark = fp->_markers; mark != NULL; mark = mark->_next) + mark->_pos -= delta; + return 0; +} + +int +__underflow (_IO_FILE *fp) +{ +#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T + if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1) + return EOF; +#endif + + if (fp->_mode == 0) + _IO_fwide (fp, -1); + if (_IO_in_put_mode (fp)) + if (_IO_switch_to_get_mode (fp) == EOF) + return EOF; + if (fp->_IO_read_ptr < fp->_IO_read_end) + return *(unsigned char *) fp->_IO_read_ptr; + if (_IO_in_backup (fp)) + { + _IO_switch_to_main_get_area (fp); + if (fp->_IO_read_ptr < fp->_IO_read_end) + return *(unsigned char *) fp->_IO_read_ptr; + } + if (_IO_have_markers (fp)) + { + if (save_for_backup (fp, fp->_IO_read_end)) + return EOF; + } + else if (_IO_have_backup (fp)) + _IO_free_backup_area (fp); + return _IO_UNDERFLOW (fp); +} +libc_hidden_def (__underflow) + +int +__uflow (_IO_FILE *fp) +{ +#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T + if (_IO_vtable_offset (fp) == 0 && _IO_fwide (fp, -1) != -1) + return EOF; +#endif + + if (fp->_mode == 0) + _IO_fwide (fp, -1); + if (_IO_in_put_mode (fp)) + if (_IO_switch_to_get_mode (fp) == EOF) + return EOF; + if (fp->_IO_read_ptr < fp->_IO_read_end) + return *(unsigned char *) fp->_IO_read_ptr++; + if (_IO_in_backup (fp)) + { + _IO_switch_to_main_get_area (fp); + if (fp->_IO_read_ptr < fp->_IO_read_end) + return *(unsigned char *) fp->_IO_read_ptr++; + } + if (_IO_have_markers (fp)) + { + if (save_for_backup (fp, fp->_IO_read_end)) + return EOF; + } + else if (_IO_have_backup (fp)) + _IO_free_backup_area (fp); + return _IO_UFLOW (fp); +} +libc_hidden_def (__uflow) + +void +_IO_setb (_IO_FILE *f, char *b, char *eb, int a) +{ + if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF)) + free (f->_IO_buf_base); + f->_IO_buf_base = b; + f->_IO_buf_end = eb; + if (a) + f->_flags &= ~_IO_USER_BUF; + else + f->_flags |= _IO_USER_BUF; +} +libc_hidden_def (_IO_setb) + +void +_IO_doallocbuf (_IO_FILE *fp) +{ + if (fp->_IO_buf_base) + return; + if (!(fp->_flags & _IO_UNBUFFERED) || fp->_mode > 0) + if (_IO_DOALLOCATE (fp) != EOF) + return; + _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0); +} +libc_hidden_def (_IO_doallocbuf) + +int +_IO_default_underflow (_IO_FILE *fp) +{ + return EOF; +} + +int +_IO_default_uflow (_IO_FILE *fp) +{ + int ch = _IO_UNDERFLOW (fp); + if (ch == EOF) + return EOF; + return *(unsigned char *) fp->_IO_read_ptr++; +} +libc_hidden_def (_IO_default_uflow) + +_IO_size_t +_IO_default_xsputn (_IO_FILE *f, const void *data, _IO_size_t n) +{ + const char *s = (char *) data; + _IO_size_t more = n; + if (more <= 0) + return 0; + for (;;) + { + /* Space available. */ + if (f->_IO_write_ptr < f->_IO_write_end) + { + _IO_size_t count = f->_IO_write_end - f->_IO_write_ptr; + if (count > more) + count = more; + if (count > 20) + { +#ifdef _LIBC + f->_IO_write_ptr = __mempcpy (f->_IO_write_ptr, s, count); +#else + memcpy (f->_IO_write_ptr, s, count); + f->_IO_write_ptr += count; +#endif + s += count; + } + else if (count) + { + char *p = f->_IO_write_ptr; + _IO_ssize_t i; + for (i = count; --i >= 0; ) + *p++ = *s++; + f->_IO_write_ptr = p; + } + more -= count; + } + if (more == 0 || _IO_OVERFLOW (f, (unsigned char) *s++) == EOF) + break; + more--; + } + return n - more; +} +libc_hidden_def (_IO_default_xsputn) + +_IO_size_t +_IO_sgetn (_IO_FILE *fp, void *data, _IO_size_t n) +{ + /* FIXME handle putback buffer here! */ + return _IO_XSGETN (fp, data, n); +} +libc_hidden_def (_IO_sgetn) + +_IO_size_t +_IO_default_xsgetn (_IO_FILE *fp, void *data, _IO_size_t n) +{ + _IO_size_t more = n; + char *s = (char*) data; + for (;;) + { + /* Data available. */ + if (fp->_IO_read_ptr < fp->_IO_read_end) + { + _IO_size_t count = fp->_IO_read_end - fp->_IO_read_ptr; + if (count > more) + count = more; + if (count > 20) + { +#ifdef _LIBC + s = __mempcpy (s, fp->_IO_read_ptr, count); +#else + memcpy (s, fp->_IO_read_ptr, count); + s += count; +#endif + fp->_IO_read_ptr += count; + } + else if (count) + { + char *p = fp->_IO_read_ptr; + int i = (int) count; + while (--i >= 0) + *s++ = *p++; + fp->_IO_read_ptr = p; + } + more -= count; + } + if (more == 0 || __underflow (fp) == EOF) + break; + } + return n - more; +} +libc_hidden_def (_IO_default_xsgetn) + +#if 0 +/* Seems not to be needed. --drepper */ +int +_IO_sync (_IO_FILE *fp) +{ + return 0; +} +#endif + +_IO_FILE * +_IO_default_setbuf (_IO_FILE *fp, char *p, _IO_ssize_t len) +{ + if (_IO_SYNC (fp) == EOF) + return NULL; + if (p == NULL || len == 0) + { + fp->_flags |= _IO_UNBUFFERED; + _IO_setb (fp, fp->_shortbuf, fp->_shortbuf+1, 0); + } + else + { + fp->_flags &= ~_IO_UNBUFFERED; + _IO_setb (fp, p, p+len, 0); + } + fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0; + fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0; + return fp; +} + +_IO_off64_t +_IO_default_seekpos (_IO_FILE *fp, _IO_off64_t pos, int mode) +{ + return _IO_SEEKOFF (fp, pos, 0, mode); +} + +int +_IO_default_doallocate (_IO_FILE *fp) +{ + char *buf; + + buf = malloc(_IO_BUFSIZ); + if (__glibc_unlikely (buf == NULL)) + return EOF; + + _IO_setb (fp, buf, buf+_IO_BUFSIZ, 1); + return 1; +} +libc_hidden_def (_IO_default_doallocate) + +void +_IO_init (_IO_FILE *fp, int flags) +{ + _IO_no_init (fp, flags, -1, NULL, NULL); +} +libc_hidden_def (_IO_init) + +void +_IO_old_init (_IO_FILE *fp, int flags) +{ + fp->_flags = _IO_MAGIC|flags; + fp->_flags2 = 0; + fp->_IO_buf_base = NULL; + fp->_IO_buf_end = NULL; + fp->_IO_read_base = NULL; + fp->_IO_read_ptr = NULL; + fp->_IO_read_end = NULL; + fp->_IO_write_base = NULL; + fp->_IO_write_ptr = NULL; + fp->_IO_write_end = NULL; + fp->_chain = NULL; /* Not necessary. */ + + fp->_IO_save_base = NULL; + fp->_IO_backup_base = NULL; + fp->_IO_save_end = NULL; + fp->_markers = NULL; + fp->_cur_column = 0; +#if _IO_JUMPS_OFFSET + fp->_vtable_offset = 0; +#endif +#ifdef _IO_MTSAFE_IO + if (fp->_lock != NULL) + _IO_lock_init (*fp->_lock); +#endif +} + +void +_IO_no_init (_IO_FILE *fp, int flags, int orientation, + struct _IO_wide_data *wd, const struct _IO_jump_t *jmp) +{ + _IO_old_init (fp, flags); + fp->_mode = orientation; +#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T + if (orientation >= 0) + { + fp->_wide_data = wd; + fp->_wide_data->_IO_buf_base = NULL; + fp->_wide_data->_IO_buf_end = NULL; + fp->_wide_data->_IO_read_base = NULL; + fp->_wide_data->_IO_read_ptr = NULL; + fp->_wide_data->_IO_read_end = NULL; + fp->_wide_data->_IO_write_base = NULL; + fp->_wide_data->_IO_write_ptr = NULL; + fp->_wide_data->_IO_write_end = NULL; + fp->_wide_data->_IO_save_base = NULL; + fp->_wide_data->_IO_backup_base = NULL; + fp->_wide_data->_IO_save_end = NULL; + + fp->_wide_data->_wide_vtable = jmp; + } + else + /* Cause predictable crash when a wide function is called on a byte + stream. */ + fp->_wide_data = (struct _IO_wide_data *) -1L; +#endif + fp->_freeres_list = NULL; +} + +int +_IO_default_sync (_IO_FILE *fp) +{ + return 0; +} + +/* The way the C++ classes are mapped into the C functions in the + current implementation, this function can get called twice! */ + +void +_IO_default_finish (_IO_FILE *fp, int dummy) +{ + struct _IO_marker *mark; + if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF)) + { + free (fp->_IO_buf_base); + fp->_IO_buf_base = fp->_IO_buf_end = NULL; + } + + for (mark = fp->_markers; mark != NULL; mark = mark->_next) + mark->_sbuf = NULL; + + if (fp->_IO_save_base) + { + free (fp->_IO_save_base); + fp->_IO_save_base = NULL; + } + + _IO_un_link ((struct _IO_FILE_plus *) fp); + +#ifdef _IO_MTSAFE_IO + if (fp->_lock != NULL) + _IO_lock_fini (*fp->_lock); +#endif +} +libc_hidden_def (_IO_default_finish) + +_IO_off64_t +_IO_default_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode) +{ + return _IO_pos_BAD; +} + +int +_IO_sputbackc (_IO_FILE *fp, int c) +{ + int result; + + if (fp->_IO_read_ptr > fp->_IO_read_base + && (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c) + { + fp->_IO_read_ptr--; + result = (unsigned char) c; + } + else + result = _IO_PBACKFAIL (fp, c); + + if (result != EOF) + fp->_flags &= ~_IO_EOF_SEEN; + + return result; +} +libc_hidden_def (_IO_sputbackc) + +int +_IO_sungetc (_IO_FILE *fp) +{ + int result; + + if (fp->_IO_read_ptr > fp->_IO_read_base) + { + fp->_IO_read_ptr--; + result = (unsigned char) *fp->_IO_read_ptr; + } + else + result = _IO_PBACKFAIL (fp, EOF); + + if (result != EOF) + fp->_flags &= ~_IO_EOF_SEEN; + + return result; +} + +#if 0 /* Work in progress */ +/* Seems not to be needed. */ +#if 0 +void +_IO_set_column (_IO_FILE *fp, int c) +{ + if (c == -1) + fp->_column = -1; + else + fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base); +} +#else +int +_IO_set_column (_IO_FILE *fp, int i) +{ + fp->_cur_column = i + 1; + return 0; +} +#endif +#endif + + +unsigned +_IO_adjust_column (unsigned start, const char *line, int count) +{ + const char *ptr = line + count; + while (ptr > line) + if (*--ptr == '\n') + return line + count - ptr - 1; + return start + count; +} +libc_hidden_def (_IO_adjust_column) + +#if 0 +/* Seems not to be needed. --drepper */ +int +_IO_get_column (_IO_FILE *fp) +{ + if (fp->_cur_column) + return _IO_adjust_column (fp->_cur_column - 1, + fp->_IO_write_base, + fp->_IO_write_ptr - fp->_IO_write_base); + return -1; +} +#endif + + +int +_IO_flush_all_lockp (int do_lock) +{ + int result = 0; + struct _IO_FILE *fp; + int last_stamp; + +#ifdef _IO_MTSAFE_IO + __libc_cleanup_region_start (do_lock, flush_cleanup, NULL); + if (do_lock) + _IO_lock_lock (list_all_lock); +#endif + + last_stamp = _IO_list_all_stamp; + fp = (_IO_FILE *) _IO_list_all; + while (fp != NULL) + { + run_fp = fp; + if (do_lock) + _IO_flockfile (fp); + + if (((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base) +#if defined _LIBC || defined _GLIBCPP_USE_WCHAR_T + || (_IO_vtable_offset (fp) == 0 + && fp->_mode > 0 && (fp->_wide_data->_IO_write_ptr + > fp->_wide_data->_IO_write_base)) +#endif + ) + && _IO_OVERFLOW (fp, EOF) == EOF) + result = EOF; + + if (do_lock) + _IO_funlockfile (fp); + run_fp = NULL; + + if (last_stamp != _IO_list_all_stamp) + { + /* Something was added to the list. Start all over again. */ + fp = (_IO_FILE *) _IO_list_all; + last_stamp = _IO_list_all_stamp; + } + else + fp = fp->_chain; + } + +#ifdef _IO_MTSAFE_IO + if (do_lock) + _IO_lock_unlock (list_all_lock); + __libc_cleanup_region_end (0); +#endif + + return result; +} + + +int +_IO_flush_all (void) +{ + /* We want locking. */ + return _IO_flush_all_lockp (1); +} +libc_hidden_def (_IO_flush_all) + +void +_IO_flush_all_linebuffered (void) +{ + struct _IO_FILE *fp; + int last_stamp; + +#ifdef _IO_MTSAFE_IO + _IO_cleanup_region_start_noarg (flush_cleanup); + _IO_lock_lock (list_all_lock); +#endif + + last_stamp = _IO_list_all_stamp; + fp = (_IO_FILE *) _IO_list_all; + while (fp != NULL) + { + run_fp = fp; + _IO_flockfile (fp); + + if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF) + _IO_OVERFLOW (fp, EOF); + + _IO_funlockfile (fp); + run_fp = NULL; + + if (last_stamp != _IO_list_all_stamp) + { + /* Something was added to the list. Start all over again. */ + fp = (_IO_FILE *) _IO_list_all; + last_stamp = _IO_list_all_stamp; + } + else + fp = fp->_chain; + } + +#ifdef _IO_MTSAFE_IO + _IO_lock_unlock (list_all_lock); + _IO_cleanup_region_end (0); +#endif +} +libc_hidden_def (_IO_flush_all_linebuffered) +#ifdef _LIBC +weak_alias (_IO_flush_all_linebuffered, _flushlbf) +#endif + + +/* The following is a bit tricky. In general, we want to unbuffer the + streams so that all output which follows is seen. If we are not + looking for memory leaks it does not make much sense to free the + actual buffer because this will happen anyway once the program + terminated. If we do want to look for memory leaks we have to free + the buffers. Whether something is freed is determined by the + function sin the libc_freeres section. Those are called as part of + the atexit routine, just like _IO_cleanup. The problem is we do + not know whether the freeres code is called first or _IO_cleanup. + if the former is the case, we set the DEALLOC_BUFFER variable to + true and _IO_unbuffer_all will take care of the rest. If + _IO_unbuffer_all is called first we add the streams to a list + which the freeres function later can walk through. */ +static void _IO_unbuffer_all (void); + +static bool dealloc_buffers; +static _IO_FILE *freeres_list; + +static void +_IO_unbuffer_all (void) +{ + struct _IO_FILE *fp; + for (fp = (_IO_FILE *) _IO_list_all; fp; fp = fp->_chain) + { + if (! (fp->_flags & _IO_UNBUFFERED) + /* Iff stream is un-orientated, it wasn't used. */ + && fp->_mode != 0) + { +#ifdef _IO_MTSAFE_IO + int cnt; +#define MAXTRIES 2 + for (cnt = 0; cnt < MAXTRIES; ++cnt) + if (fp->_lock == NULL || _IO_lock_trylock (*fp->_lock) == 0) + break; + else + /* Give the other thread time to finish up its use of the + stream. */ + __sched_yield (); +#endif + + if (! dealloc_buffers && !(fp->_flags & _IO_USER_BUF)) + { + fp->_flags |= _IO_USER_BUF; + + fp->_freeres_list = freeres_list; + freeres_list = fp; + fp->_freeres_buf = fp->_IO_buf_base; + } + + _IO_SETBUF (fp, NULL, 0); + + if (fp->_mode > 0) + _IO_wsetb (fp, NULL, NULL, 0); + +#ifdef _IO_MTSAFE_IO + if (cnt < MAXTRIES && fp->_lock != NULL) + _IO_lock_unlock (*fp->_lock); +#endif + } + + /* Make sure that never again the wide char functions can be + used. */ + fp->_mode = -1; + } +} + + +libc_freeres_fn (buffer_free) +{ + dealloc_buffers = true; + + while (freeres_list != NULL) + { + free (freeres_list->_freeres_buf); + + freeres_list = freeres_list->_freeres_list; + } +} + + +int +_IO_cleanup (void) +{ + /* We do *not* want locking. Some threads might use streams but + that is their problem, we flush them underneath them. */ + int result = _IO_flush_all_lockp (0); + + /* We currently don't have a reliable mechanism for making sure that + C++ static destructors are executed in the correct order. + So it is possible that other static destructors might want to + write to cout - and they're supposed to be able to do so. + + The following will make the standard streambufs be unbuffered, + which forces any output from late destructors to be written out. */ + _IO_unbuffer_all (); + + return result; +} + + +void +_IO_init_marker (struct _IO_marker *marker, _IO_FILE *fp) +{ + marker->_sbuf = fp; + if (_IO_in_put_mode (fp)) + _IO_switch_to_get_mode (fp); + if (_IO_in_backup (fp)) + marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end; + else + marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base; + + /* Should perhaps sort the chain? */ + marker->_next = fp->_markers; + fp->_markers = marker; +} + +void +_IO_remove_marker (struct _IO_marker *marker) +{ + /* Unlink from sb's chain. */ + struct _IO_marker **ptr = &marker->_sbuf->_markers; + for (; ; ptr = &(*ptr)->_next) + { + if (*ptr == NULL) + break; + else if (*ptr == marker) + { + *ptr = marker->_next; + return; + } + } +#if 0 + if _sbuf has a backup area that is no longer needed, should we delete + it now, or wait until the next underflow? +#endif +} + +#define BAD_DELTA EOF + +int +_IO_marker_difference (struct _IO_marker *mark1, struct _IO_marker *mark2) +{ + return mark1->_pos - mark2->_pos; +} + +/* Return difference between MARK and current position of MARK's stream. */ +int +_IO_marker_delta (struct _IO_marker *mark) +{ + int cur_pos; + if (mark->_sbuf == NULL) + return BAD_DELTA; + if (_IO_in_backup (mark->_sbuf)) + cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end; + else + cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base; + return mark->_pos - cur_pos; +} + +int +_IO_seekmark (_IO_FILE *fp, struct _IO_marker *mark, int delta) +{ + if (mark->_sbuf != fp) + return EOF; + if (mark->_pos >= 0) + { + if (_IO_in_backup (fp)) + _IO_switch_to_main_get_area (fp); + fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos; + } + else + { + if (!_IO_in_backup (fp)) + _IO_switch_to_backup_area (fp); + fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos; + } + return 0; +} + +void +_IO_unsave_markers (_IO_FILE *fp) +{ + struct _IO_marker *mark = fp->_markers; + if (mark) + { +#ifdef TODO + streampos offset = seekoff (0, ios::cur, ios::in); + if (offset != EOF) + { + offset += eGptr () - Gbase (); + for ( ; mark != NULL; mark = mark->_next) + mark->set_streampos (mark->_pos + offset); + } + else + { + for ( ; mark != NULL; mark = mark->_next) + mark->set_streampos (EOF); + } +#endif + fp->_markers = 0; + } + + if (_IO_have_backup (fp)) + _IO_free_backup_area (fp); +} +libc_hidden_def (_IO_unsave_markers) + +#if 0 +/* Seems not to be needed. --drepper */ +int +_IO_nobackup_pbackfail (_IO_FILE *fp, int c) +{ + if (fp->_IO_read_ptr > fp->_IO_read_base) + fp->_IO_read_ptr--; + if (c != EOF && *fp->_IO_read_ptr != c) + *fp->_IO_read_ptr = c; + return (unsigned char) c; +} +#endif + +int +_IO_default_pbackfail (_IO_FILE *fp, int c) +{ + if (fp->_IO_read_ptr > fp->_IO_read_base && !_IO_in_backup (fp) + && (unsigned char) fp->_IO_read_ptr[-1] == c) + --fp->_IO_read_ptr; + else + { + /* Need to handle a filebuf in write mode (switch to read mode). FIXME!*/ + if (!_IO_in_backup (fp)) + { + /* We need to keep the invariant that the main get area + logically follows the backup area. */ + if (fp->_IO_read_ptr > fp->_IO_read_base && _IO_have_backup (fp)) + { + if (save_for_backup (fp, fp->_IO_read_ptr)) + return EOF; + } + else if (!_IO_have_backup (fp)) + { + /* No backup buffer: allocate one. */ + /* Use nshort buffer, if unused? (probably not) FIXME */ + int backup_size = 128; + char *bbuf = (char *) malloc (backup_size); + if (bbuf == NULL) + return EOF; + fp->_IO_save_base = bbuf; + fp->_IO_save_end = fp->_IO_save_base + backup_size; + fp->_IO_backup_base = fp->_IO_save_end; + } + fp->_IO_read_base = fp->_IO_read_ptr; + _IO_switch_to_backup_area (fp); + } + else if (fp->_IO_read_ptr <= fp->_IO_read_base) + { + /* Increase size of existing backup buffer. */ + _IO_size_t new_size; + _IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base; + char *new_buf; + new_size = 2 * old_size; + new_buf = (char *) malloc (new_size); + if (new_buf == NULL) + return EOF; + memcpy (new_buf + (new_size - old_size), fp->_IO_read_base, + old_size); + free (fp->_IO_read_base); + _IO_setg (fp, new_buf, new_buf + (new_size - old_size), + new_buf + new_size); + fp->_IO_backup_base = fp->_IO_read_ptr; + } + + *--fp->_IO_read_ptr = c; + } + return (unsigned char) c; +} +libc_hidden_def (_IO_default_pbackfail) + +_IO_off64_t +_IO_default_seek (_IO_FILE *fp, _IO_off64_t offset, int dir) +{ + return _IO_pos_BAD; +} + +int +_IO_default_stat (_IO_FILE *fp, void *st) +{ + return EOF; +} + +_IO_ssize_t +_IO_default_read (_IO_FILE *fp, void *data, _IO_ssize_t n) +{ + return -1; +} + +_IO_ssize_t +_IO_default_write (_IO_FILE *fp, const void *data, _IO_ssize_t n) +{ + return 0; +} + +int +_IO_default_showmanyc (_IO_FILE *fp) +{ + return -1; +} + +void +_IO_default_imbue (_IO_FILE *fp, void *locale) +{ +} + +_IO_ITER +_IO_iter_begin (void) +{ + return (_IO_ITER) _IO_list_all; +} +libc_hidden_def (_IO_iter_begin) + +_IO_ITER +_IO_iter_end (void) +{ + return NULL; +} +libc_hidden_def (_IO_iter_end) + +_IO_ITER +_IO_iter_next (_IO_ITER iter) +{ + return iter->_chain; +} +libc_hidden_def (_IO_iter_next) + +_IO_FILE * +_IO_iter_file (_IO_ITER iter) +{ + return iter; +} +libc_hidden_def (_IO_iter_file) + +void +_IO_list_lock (void) +{ +#ifdef _IO_MTSAFE_IO + _IO_lock_lock (list_all_lock); +#endif +} +libc_hidden_def (_IO_list_lock) + +void +_IO_list_unlock (void) +{ +#ifdef _IO_MTSAFE_IO + _IO_lock_unlock (list_all_lock); +#endif +} +libc_hidden_def (_IO_list_unlock) + +void +_IO_list_resetlock (void) +{ +#ifdef _IO_MTSAFE_IO + _IO_lock_init (list_all_lock); +#endif +} +libc_hidden_def (_IO_list_resetlock) + + +#ifdef TODO +#if defined(linux) +#define IO_CLEANUP ; +#endif + +#ifdef IO_CLEANUP + IO_CLEANUP +#else +struct __io_defs { + __io_defs() { } + ~__io_defs() { _IO_cleanup (); } +}; +__io_defs io_defs__; +#endif + +#endif /* TODO */ + +#ifdef text_set_element +text_set_element(__libc_atexit, _IO_cleanup); +#endif -- cgit v1.2.3