| // Wrapper of C-language FILE struct -*- C++ -*- |
| |
| // Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. |
| // |
| // This file is part of the GNU ISO C++ Library. This library is free |
| // software; you can redistribute it and/or modify it under the |
| // terms of the GNU General Public License as published by the |
| // Free Software Foundation; either version 2, or (at your option) |
| // any later version. |
| |
| // This 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 General Public License for more details. |
| |
| // You should have received a copy of the GNU General Public License along |
| // with this library; see the file COPYING. If not, write to the Free |
| // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, |
| // USA. |
| |
| // As a special exception, you may use this file as part of a free software |
| // library without restriction. Specifically, if other files instantiate |
| // templates or use macros or inline functions from this file, or you compile |
| // this file and link it with other files to produce an executable, this |
| // file does not by itself cause the resulting executable to be covered by |
| // the GNU General Public License. This exception does not however |
| // invalidate any other reasons why the executable file might be covered by |
| // the GNU General Public License. |
| |
| // |
| // ISO C++ 14882: 27.8 File-based streams |
| // |
| |
| #include <bits/basic_file.h> |
| #include <fcntl.h> |
| #include <errno.h> |
| |
| #ifdef _GLIBCXX_HAVE_POLL |
| #include <poll.h> |
| #endif |
| |
| // Pick up ioctl on Solaris 2.8 |
| #ifdef _GLIBCXX_HAVE_UNISTD_H |
| #include <unistd.h> |
| #endif |
| |
| // Pick up FIONREAD on Solaris 2 |
| #ifdef _GLIBCXX_HAVE_SYS_IOCTL_H |
| #define BSD_COMP |
| #include <sys/ioctl.h> |
| #endif |
| |
| // Pick up FIONREAD on Solaris 2.5. |
| #ifdef _GLIBCXX_HAVE_SYS_FILIO_H |
| #include <sys/filio.h> |
| #endif |
| |
| #ifdef _GLIBCXX_HAVE_SYS_UIO_H |
| #include <sys/uio.h> |
| #endif |
| |
| #if defined(_GLIBCXX_HAVE_S_ISREG) || defined(_GLIBCXX_HAVE_S_IFREG) |
| # include <sys/stat.h> |
| # ifdef _GLIBCXX_HAVE_S_ISREG |
| # define _GLIBCXX_ISREG(x) S_ISREG(x) |
| # else |
| # define _GLIBCXX_ISREG(x) (((x) & S_IFMT) == S_IFREG) |
| # endif |
| #endif |
| |
| #include <limits> // For <off_t>::max() and min() and <streamsize>::max() |
| |
| namespace __gnu_internal |
| { |
| // Map ios_base::openmode flags to a string for use in fopen(). |
| // Table of valid combinations as given in [lib.filebuf.members]/2. |
| static const char* |
| fopen_mode(std::ios_base::openmode mode) |
| { |
| enum |
| { |
| in = std::ios_base::in, |
| out = std::ios_base::out, |
| trunc = std::ios_base::trunc, |
| app = std::ios_base::app, |
| binary = std::ios_base::binary |
| }; |
| |
| switch (mode & (in|out|trunc|app|binary)) |
| { |
| case ( out ): return "w"; |
| case ( out |app ): return "a"; |
| case ( out|trunc ): return "w"; |
| case (in ): return "r"; |
| case (in|out ): return "r+"; |
| case (in|out|trunc ): return "w+"; |
| |
| case ( out |binary): return "wb"; |
| case ( out |app|binary): return "ab"; |
| case ( out|trunc |binary): return "wb"; |
| case (in |binary): return "rb"; |
| case (in|out |binary): return "r+b"; |
| case (in|out|trunc |binary): return "w+b"; |
| |
| default: return 0; // invalid |
| } |
| } |
| |
| // Wrapper handling partial write. |
| static std::streamsize |
| xwrite(int __fd, const char* __s, std::streamsize __n) |
| { |
| std::streamsize __nleft = __n; |
| |
| for (;;) |
| { |
| const std::streamsize __ret = write(__fd, __s, __nleft); |
| if (__ret == -1L && errno == EINTR) |
| continue; |
| if (__ret == -1L) |
| break; |
| |
| __nleft -= __ret; |
| if (__nleft == 0) |
| break; |
| |
| __s += __ret; |
| } |
| |
| return __n - __nleft; |
| } |
| |
| #ifdef _GLIBCXX_HAVE_WRITEV |
| // Wrapper handling partial writev. |
| static std::streamsize |
| xwritev(int __fd, const char* __s1, std::streamsize __n1, |
| const char* __s2, std::streamsize __n2) |
| { |
| std::streamsize __nleft = __n1 + __n2; |
| std::streamsize __n1_left = __n1; |
| |
| struct iovec __iov[2]; |
| __iov[1].iov_base = const_cast<char*>(__s2); |
| __iov[1].iov_len = __n2; |
| |
| for (;;) |
| { |
| __iov[0].iov_base = const_cast<char*>(__s1); |
| __iov[0].iov_len = __n1_left; |
| |
| const std::streamsize __ret = writev(__fd, __iov, 2); |
| if (__ret == -1L && errno == EINTR) |
| continue; |
| if (__ret == -1L) |
| break; |
| |
| __nleft -= __ret; |
| if (__nleft == 0) |
| break; |
| |
| const std::streamsize __off = __ret - __n1_left; |
| if (__off >= 0) |
| { |
| __nleft -= xwrite(__fd, __s2 + __off, __n2 - __off); |
| break; |
| } |
| |
| __s1 += __ret; |
| __n1_left -= __ret; |
| } |
| |
| return __n1 + __n2 - __nleft; |
| } |
| #endif |
| } // namespace __gnu_internal |
| |
| namespace std |
| { |
| // Definitions for __basic_file<char>. |
| __basic_file<char>::__basic_file(__c_lock* /*__lock*/) |
| : _M_cfile(NULL), _M_cfile_created(false) { } |
| |
| __basic_file<char>::~__basic_file() |
| { this->close(); } |
| |
| __basic_file<char>* |
| __basic_file<char>::sys_open(__c_file* __file, ios_base::openmode) |
| { |
| __basic_file* __ret = NULL; |
| if (!this->is_open() && __file) |
| { |
| int __err; |
| errno = 0; |
| do |
| __err = this->sync(); |
| while (__err && errno == EINTR); |
| if (!__err) |
| { |
| _M_cfile = __file; |
| _M_cfile_created = false; |
| __ret = this; |
| } |
| } |
| return __ret; |
| } |
| |
| __basic_file<char>* |
| __basic_file<char>::sys_open(int __fd, ios_base::openmode __mode) |
| { |
| __basic_file* __ret = NULL; |
| const char* __c_mode = __gnu_internal::fopen_mode(__mode); |
| if (__c_mode && !this->is_open() && (_M_cfile = fdopen(__fd, __c_mode))) |
| { |
| char* __buf = NULL; |
| _M_cfile_created = true; |
| if (__fd == 0) |
| setvbuf(_M_cfile, __buf, _IONBF, 0); |
| __ret = this; |
| } |
| return __ret; |
| } |
| |
| __basic_file<char>* |
| __basic_file<char>::open(const char* __name, ios_base::openmode __mode, |
| int /*__prot*/) |
| { |
| __basic_file* __ret = NULL; |
| const char* __c_mode = __gnu_internal::fopen_mode(__mode); |
| if (__c_mode && !this->is_open()) |
| { |
| #ifdef _GLIBCXX_USE_LFS |
| if ((_M_cfile = fopen64(__name, __c_mode))) |
| #else |
| if ((_M_cfile = fopen(__name, __c_mode))) |
| #endif |
| { |
| _M_cfile_created = true; |
| __ret = this; |
| } |
| } |
| return __ret; |
| } |
| |
| bool |
| __basic_file<char>::is_open() const |
| { return _M_cfile != 0; } |
| |
| int |
| __basic_file<char>::fd() |
| { return fileno(_M_cfile); } |
| |
| __c_file* |
| __basic_file<char>::file() |
| { return _M_cfile; } |
| |
| __basic_file<char>* |
| __basic_file<char>::close() |
| { |
| __basic_file* __ret = static_cast<__basic_file*>(NULL); |
| if (this->is_open()) |
| { |
| int __err = 0; |
| if (_M_cfile_created) |
| { |
| // In general, no need to zero errno in advance if checking |
| // for error first. However, C89/C99 (at variance with IEEE |
| // 1003.1, f.i.) do not mandate that fclose must set errno |
| // upon error. |
| errno = 0; |
| do |
| __err = fclose(_M_cfile); |
| while (__err && errno == EINTR); |
| } |
| _M_cfile = 0; |
| if (!__err) |
| __ret = this; |
| } |
| return __ret; |
| } |
| |
| streamsize |
| __basic_file<char>::xsgetn(char* __s, streamsize __n) |
| { |
| streamsize __ret; |
| do |
| __ret = read(this->fd(), __s, __n); |
| while (__ret == -1L && errno == EINTR); |
| return __ret; |
| } |
| |
| streamsize |
| __basic_file<char>::xsputn(const char* __s, streamsize __n) |
| { return __gnu_internal::xwrite(this->fd(), __s, __n); } |
| |
| streamsize |
| __basic_file<char>::xsputn_2(const char* __s1, streamsize __n1, |
| const char* __s2, streamsize __n2) |
| { |
| streamsize __ret = 0; |
| #ifdef _GLIBCXX_HAVE_WRITEV |
| __ret = __gnu_internal::xwritev(this->fd(), __s1, __n1, __s2, __n2); |
| #else |
| if (__n1) |
| __ret = __gnu_internal::xwrite(this->fd(), __s1, __n1); |
| |
| if (__ret == __n1) |
| __ret += __gnu_internal::xwrite(this->fd(), __s2, __n2); |
| #endif |
| return __ret; |
| } |
| |
| streamoff |
| __basic_file<char>::seekoff(streamoff __off, ios_base::seekdir __way) |
| { |
| #ifdef _GLIBCXX_USE_LFS |
| return lseek64(this->fd(), __off, __way); |
| #else |
| if (__off > numeric_limits<off_t>::max() |
| || __off < numeric_limits<off_t>::min()) |
| return -1L; |
| return lseek(this->fd(), __off, __way); |
| #endif |
| } |
| |
| int |
| __basic_file<char>::sync() |
| { return fflush(_M_cfile); } |
| |
| streamsize |
| __basic_file<char>::showmanyc() |
| { |
| #ifdef FIONREAD |
| // Pipes and sockets. |
| #ifdef _GLIBCXX_FIONREAD_TAKES_OFF_T |
| off_t __num = 0; |
| #else |
| int __num = 0; |
| #endif |
| int __r = ioctl(this->fd(), FIONREAD, &__num); |
| if (!__r && __num >= 0) |
| return __num; |
| #endif |
| |
| #ifdef _GLIBCXX_HAVE_POLL |
| // Cheap test. |
| struct pollfd __pfd[1]; |
| __pfd[0].fd = this->fd(); |
| __pfd[0].events = POLLIN; |
| if (poll(__pfd, 1, 0) <= 0) |
| return 0; |
| #endif |
| |
| #if defined(_GLIBCXX_HAVE_S_ISREG) || defined(_GLIBCXX_HAVE_S_IFREG) |
| // Regular files. |
| #ifdef _GLIBCXX_USE_LFS |
| struct stat64 __buffer; |
| const int __err = fstat64(this->fd(), &__buffer); |
| if (!__err && _GLIBCXX_ISREG(__buffer.st_mode)) |
| { |
| const streamoff __off = __buffer.st_size - lseek64(this->fd(), 0, |
| ios_base::cur); |
| return std::min(__off, streamoff(numeric_limits<streamsize>::max())); |
| } |
| #else |
| struct stat __buffer; |
| const int __err = fstat(this->fd(), &__buffer); |
| if (!__err && _GLIBCXX_ISREG(__buffer.st_mode)) |
| return __buffer.st_size - lseek(this->fd(), 0, ios_base::cur); |
| #endif |
| #endif |
| return 0; |
| } |
| } // namespace std |