The Tor Browser: build/stlport/src/details/fstream_unistd.cpp@129ffea94266 (annotated)

build/stlport/src/details/fstream_unistd.cpp@129ffea94266 (annotated)

build/stlport/src/details/fstream_unistd.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * 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

The Tor Browser / annotate

build/stlport/src/details/fstream_unistd.cpp@129ffea94266 (annotated)

build/stlport/src/details/fstream_unistd.cpp