/*
* Copyright (c) 1999
* Silicon Graphics Computer Systems, Inc.
*
* Copyright (c) 1999
* Boris Fomitchev
*
* This material is provided "as is", with absolutely no warranty expressed
* or implied. Any use is at your own risk.
*
* Permission to use or copy this software for any purpose is hereby granted
* without fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is granted,
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*
*/
#if defined (__SUNPPRO_CC) && !defined (_STLP_NO_NEW_C_HEADERS)
# include <time.h>
// For sunpro, it chokes if time.h is included through stat.h
#endif
#include <fstream>
#ifdef __CYGWIN__
# define __int64 long long
#endif
extern "C" {
// open/close/read/write
#include <sys/stat.h> // For stat
#if !defined (_CRAY) && ! defined (__EMX__)
# include <sys/mman.h> // For mmap
#endif
// on HP-UX 11, this one contradicts with pthread.h on pthread_atfork, unless we unset this
#if defined (__hpux) && defined (__GNUC__)
# undef _INCLUDE_POSIX1C_SOURCE
#endif
#include <unistd.h>
#include <fcntl.h>
}
#ifdef __APPLE__
# include <sys/sysctl.h>
#endif
const _STLP_fd INVALID_STLP_FD = -1;
#ifndef O_ACCMODE
# define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)
#endif
// Compare with streamoff definition in stl/char_traits.h!
#if defined (_STLP_USE_DEFAULT_FILE_OFFSET) || \
(!defined(_LARGEFILE_SOURCE) && !defined (_LARGEFILE64_SOURCE))
# define FSTAT fstat
# define STAT stat
# define LSEEK lseek
# define MMAP mmap
# define OPEN open
#else
# define FSTAT fstat64
# define STAT stat64
# define LSEEK lseek64
# define MMAP mmap64
# define OPEN open64
#endif
#ifndef MAP_FAILED /* MMAP failure return code */
# define MAP_FAILED -1
#endif
_STLP_BEGIN_NAMESPACE
static ios_base::openmode flag_to_openmode(int mode)
{
ios_base::openmode ret = ios_base::__default_mode;
switch ( mode & O_ACCMODE ) {
case O_RDONLY:
ret = ios_base::in;
break;
case O_WRONLY:
ret = ios_base::out;
break;
case O_RDWR:
ret = ios_base::in | ios_base::out;
break;
}
if ( mode & O_APPEND )
ret |= ios_base::app;
return ret;
}
_STLP_MOVE_TO_PRIV_NAMESPACE
// Helper functions for _Filebuf_base.
static bool __is_regular_file(_STLP_fd fd) {
struct STAT buf;
return FSTAT(fd, &buf) == 0 && S_ISREG(buf.st_mode);
}
// Number of characters in the file.
static streamoff __file_size(_STLP_fd fd) {
streamoff ret = 0;
struct STAT buf;
if (FSTAT(fd, &buf) == 0 && S_ISREG(buf.st_mode))
ret = buf.st_size > 0 ? buf.st_size : 0;
return ret;
}
_STLP_MOVE_TO_STD_NAMESPACE
size_t _Filebuf_base::_M_page_size = 4096;
_Filebuf_base::_Filebuf_base()
: _M_file_id(INVALID_STLP_FD),
_M_openmode(0),
_M_is_open(false),
_M_should_close(false)
{}
void _Filebuf_base::_S_initialize()
{
#if defined (__APPLE__)
int mib[2];
size_t pagesize, len;
mib[0] = CTL_HW;
mib[1] = HW_PAGESIZE;
len = sizeof(pagesize);
sysctl(mib, 2, &pagesize, &len, NULL, 0);
_M_page_size = pagesize;
#elif defined (__DJGPP) && defined (_CRAY)
_M_page_size = BUFSIZ;
#else
_M_page_size = sysconf(_SC_PAGESIZE);
#endif
}
// Return the size of the file. This is a wrapper for stat.
// Returns zero if the size cannot be determined or is ill-defined.
streamoff _Filebuf_base::_M_file_size()
{
return _STLP_PRIV __file_size(_M_file_id);
}
bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode,
long permission)
{
_STLP_fd file_no;
if (_M_is_open)
return false;
int flags = 0;
// Unix makes no distinction between text and binary files.
switch ( openmode & (~ios_base::ate & ~ios_base::binary) ) {
case ios_base::out:
case ios_base::out | ios_base::trunc:
flags = O_WRONLY | O_CREAT | O_TRUNC;
break;
case ios_base::app:
case ios_base::out | ios_base::app:
flags = O_WRONLY | O_CREAT | O_APPEND;
break;
case ios_base::in:
flags = O_RDONLY;
permission = 0; // Irrelevant unless we're writing.
break;
case ios_base::in | ios_base::out:
flags = O_RDWR;
break;
case ios_base::in | ios_base::out | ios_base::trunc:
flags = O_RDWR | O_CREAT | O_TRUNC;
break;
case ios_base::in | ios_base::app:
case ios_base::in | ios_base::out | ios_base::app:
flags = O_RDWR | O_CREAT | O_APPEND;
break;
default: // The above are the only combinations of
return false; // flags allowed by the C++ standard.
}
file_no = OPEN(name, flags, permission);
if (file_no < 0)
return false;
_M_is_open = true;
if ((openmode & (ios_base::ate | ios_base::app)) && (LSEEK(file_no, 0, SEEK_END) == -1)) {
_M_is_open = false;
}
_M_file_id = file_no;
_M_should_close = _M_is_open;
_M_openmode = openmode;
if (_M_is_open)
_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
return (_M_is_open != 0);
}
bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode)
{
// This doesn't really grant everyone in the world read/write
// access. On Unix, file-creation system calls always clear
// bits that are set in the umask from the permissions flag.
return this->_M_open(name, openmode, S_IRUSR | S_IWUSR | S_IRGRP |
S_IWGRP | S_IROTH | S_IWOTH);
}
// Associated the filebuf with a file descriptor pointing to an already-
// open file. Mode is set to be consistent with the way that the file
// was opened.
bool _Filebuf_base::_M_open(int file_no, ios_base::openmode)
{
if (_M_is_open || file_no < 0)
return false;
int mode = fcntl(file_no, F_GETFL);
if (mode == -1)
return false;
_M_openmode = flag_to_openmode(mode);
_M_file_id = file_no;
_M_is_open = true;
_M_should_close = false;
_M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
return true;
}
bool _Filebuf_base::_M_close()
{
if (!_M_is_open)
return false;
bool ok = _M_should_close ? (close(_M_file_id) == 0) : true;
_M_is_open = _M_should_close = false;
_M_openmode = 0;
return ok;
}
// Read up to n characters into a buffer. Return value is number of
// characters read.
ptrdiff_t _Filebuf_base::_M_read(char* buf, ptrdiff_t n)
{
return read(_M_file_id, buf, n);
}
// Write n characters from a buffer. Return value: true if we managed
// to write the entire buffer, false if we didn't.
bool _Filebuf_base::_M_write(char* buf, ptrdiff_t n)
{
for (;;) {
ptrdiff_t written = write(_M_file_id, buf, n);
if (n == written) {
return true;
}
if (written > 0 && written < n) {
n -= written;
buf += written;
} else {
return false;
}
}
}
// Wrapper for lseek or the like.
streamoff _Filebuf_base::_M_seek(streamoff offset, ios_base::seekdir dir)
{
int whence;
switch ( dir ) {
case ios_base::beg:
if (offset < 0 /* || offset > _M_file_size() */ )
return streamoff(-1);
whence = SEEK_SET;
break;
case ios_base::cur:
whence = SEEK_CUR;
break;
case ios_base::end:
if (/* offset > 0 || */ -offset > _M_file_size() )
return streamoff(-1);
whence = SEEK_END;
break;
default:
return streamoff(-1);
}
return LSEEK(_M_file_id, offset, whence);
}
// Attempts to memory-map len bytes of the current file, starting
// at position offset. Precondition: offset is a multiple of the
// page size. Postcondition: return value is a null pointer if the
// memory mapping failed. Otherwise the return value is a pointer to
// the memory-mapped file and the file position is set to offset.
void* _Filebuf_base::_M_mmap(streamoff offset, streamoff len)
{
void* base;
#if !defined (__DJGPP) && !defined (_CRAY)
base = MMAP(0, len, PROT_READ, MAP_PRIVATE, _M_file_id, offset);
if (base != (void*)MAP_FAILED) {
if (LSEEK(_M_file_id, offset + len, SEEK_SET) < 0) {
this->_M_unmap(base, len);
base = 0;
}
} else
base =0;
#else
_STLP_MARK_PARAMETER_AS_UNUSED(&offset)
_STLP_MARK_PARAMETER_AS_UNUSED(&len)
base = 0;
#endif
return base;
}
void _Filebuf_base::_M_unmap(void* base, streamoff len)
{
// precondition : there is a valid mapping at the moment
#if !defined (__DJGPP) && !defined (_CRAY)
munmap((char*)base, len);
#else
_STLP_MARK_PARAMETER_AS_UNUSED(&len)
_STLP_MARK_PARAMETER_AS_UNUSED(base)
#endif
}
_STLP_END_NAMESPACE