The Tor Browser / file revision

 /*

  * 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