The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

  * This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 #include <errno.h>

 #include <stdio.h>

 #include "nscore.h"

 #include "nsStringGlue.h"

 #include "private/pprio.h"

 #include "mozilla/Assertions.h"

 #include "mozilla/FileUtils.h"

 #if defined(XP_MACOSX)

 #include <fcntl.h>

 #include <unistd.h>

 #include <mach/machine.h>

 #include <mach-o/fat.h>

 #include <mach-o/loader.h>

 #include <sys/mman.h>

 #include <sys/stat.h>

 #include <limits.h>

 #elif defined(XP_UNIX)

 #include <fcntl.h>

 #include <unistd.h>

 #if defined(LINUX)

 #include <elf.h>

 #endif

 #include <sys/types.h>

 #include <sys/stat.h>

 #elif defined(XP_WIN)

 #include <windows.h>

 #endif

 // Functions that are not to be used in standalone glue must be implemented

 // within this #if block

 #if !defined(XPCOM_GLUE)

 bool 

 mozilla::fallocate(PRFileDesc *aFD, int64_t aLength) 

 {

 #if defined(HAVE_POSIX_FALLOCATE)

   return posix_fallocate(PR_FileDesc2NativeHandle(aFD), 0, aLength) == 0;

 #elif defined(XP_WIN)

   int64_t oldpos = PR_Seek64(aFD, 0, PR_SEEK_CUR);

   if (oldpos == -1)

     return false;

   if (PR_Seek64(aFD, aLength, PR_SEEK_SET) != aLength)

     return false;

   bool retval = (0 != SetEndOfFile((HANDLE)PR_FileDesc2NativeHandle(aFD)));

   PR_Seek64(aFD, oldpos, PR_SEEK_SET);

   return retval;

 #elif defined(XP_MACOSX)

   int fd = PR_FileDesc2NativeHandle(aFD);

   fstore_t store = {F_ALLOCATECONTIG, F_PEOFPOSMODE, 0, aLength};

   // Try to get a continous chunk of disk space

   int ret = fcntl(fd, F_PREALLOCATE, &store);

   if (-1 == ret) {

     // OK, perhaps we are too fragmented, allocate non-continuous

     store.fst_flags = F_ALLOCATEALL;

     ret = fcntl(fd, F_PREALLOCATE, &store);

     if (-1 == ret)

       return false;

   }

   return 0 == ftruncate(fd, aLength);

 #elif defined(XP_UNIX)

   // The following is copied from fcntlSizeHint in sqlite

   /* If the OS does not have posix_fallocate(), fake it. First use

   ** ftruncate() to set the file size, then write a single byte to

   ** the last byte in each block within the extended region. This

   ** is the same technique used by glibc to implement posix_fallocate()

   ** on systems that do not have a real fallocate() system call.

   */

   int64_t oldpos = PR_Seek64(aFD, 0, PR_SEEK_CUR);

   if (oldpos == -1)

     return false;

   struct stat buf;

   int fd = PR_FileDesc2NativeHandle(aFD);

   if (fstat(fd, &buf))

     return false;

   if (buf.st_size >= aLength)

     return false;

   const int nBlk = buf.st_blksize;

   if (!nBlk)

     return false;

   if (ftruncate(fd, aLength))

     return false;

   int nWrite; // Return value from write()

   int64_t iWrite = ((buf.st_size + 2 * nBlk - 1) / nBlk) * nBlk - 1; // Next offset to write to

   while (iWrite < aLength) {

     nWrite = 0;

     if (PR_Seek64(aFD, iWrite, PR_SEEK_SET) == iWrite)

       nWrite = PR_Write(aFD, "", 1);

     if (nWrite != 1) break;

     iWrite += nBlk;

   }

   PR_Seek64(aFD, oldpos, PR_SEEK_SET);

   return nWrite == 1;

 #endif

   return false;

 }

 #ifdef ReadSysFile_PRESENT

 bool

 mozilla::ReadSysFile(

   const char* aFilename,

   char* aBuf,

   size_t aBufSize)

 {

   int fd = MOZ_TEMP_FAILURE_RETRY(open(aFilename, O_RDONLY));

   if (fd < 0) {

     return false;

   }

   ScopedClose autoClose(fd);

   if (aBufSize == 0) {

     return true;

   }

   ssize_t bytesRead;

   size_t offset = 0;

   do {

     bytesRead = MOZ_TEMP_FAILURE_RETRY(

       read(fd, aBuf + offset, aBufSize - offset));

     if (bytesRead == -1) {

       return false;

     }

     offset += bytesRead;

   } while (bytesRead > 0 && offset < aBufSize);

   MOZ_ASSERT(offset <= aBufSize);

   if (offset > 0 && aBuf[offset - 1] == '\n') {

     offset--;

   }

   if (offset == aBufSize) {

     MOZ_ASSERT(offset > 0);

     offset--;

   }

   aBuf[offset] = '\0';

   return true;

 }

 bool

 mozilla::ReadSysFile(

   const char* aFilename,

   int* aVal)

 {

   char valBuf[32];

   if (!ReadSysFile(aFilename, valBuf, sizeof(valBuf))) {

     return false;

   }

   return sscanf(valBuf, "%d", aVal) == 1;

 }

 bool

 mozilla::ReadSysFile(

   const char* aFilename,

   bool* aVal)

 {

   int v;

   if (!ReadSysFile(aFilename, &v)) {

     return false;

   }

   *aVal = (v != 0);

   return true;

 }

 #endif /* ReadSysFile_PRESENT */

 void

 mozilla::ReadAheadLib(nsIFile* aFile)

 {

 #if defined(XP_WIN)

   nsAutoString path;

   if (!aFile || NS_FAILED(aFile->GetPath(path))) {

     return;

   }

   ReadAheadLib(path.get());

 #elif defined(LINUX) && !defined(ANDROID) || defined(XP_MACOSX)

   nsAutoCString nativePath;

   if (!aFile || NS_FAILED(aFile->GetNativePath(nativePath))) {

     return;

   }

   ReadAheadLib(nativePath.get());

 #endif

 }

 void

 mozilla::ReadAheadFile(nsIFile* aFile, const size_t aOffset,

                        const size_t aCount, mozilla::filedesc_t* aOutFd)

 {

 #if defined(XP_WIN)

   nsAutoString path;

   if (!aFile || NS_FAILED(aFile->GetPath(path))) {

     return;

   }

   ReadAheadFile(path.get(), aOffset, aCount, aOutFd);

 #elif defined(LINUX) && !defined(ANDROID) || defined(XP_MACOSX)

   nsAutoCString nativePath;

   if (!aFile || NS_FAILED(aFile->GetNativePath(nativePath))) {

     return;

   }

   ReadAheadFile(nativePath.get(), aOffset, aCount, aOutFd);

 #endif

 }

 #endif // !defined(XPCOM_GLUE)

 #if defined(LINUX) && !defined(ANDROID)

 static const unsigned int bufsize = 4096;

 #ifdef __LP64__

 typedef Elf64_Ehdr Elf_Ehdr;

 typedef Elf64_Phdr Elf_Phdr;

 static const unsigned char ELFCLASS = ELFCLASS64;

 typedef Elf64_Off Elf_Off;

 #else

 typedef Elf32_Ehdr Elf_Ehdr;

 typedef Elf32_Phdr Elf_Phdr;

 static const unsigned char ELFCLASS = ELFCLASS32;

 typedef Elf32_Off Elf_Off;

 #endif

 #elif defined(XP_MACOSX)

 #if defined(__i386__)

 static const uint32_t CPU_TYPE = CPU_TYPE_X86;

 #elif defined(__x86_64__)

 static const uint32_t CPU_TYPE = CPU_TYPE_X86_64;

 #elif defined(__ppc__)

 static const uint32_t CPU_TYPE = CPU_TYPE_POWERPC;

 #elif defined(__ppc64__)

 static const uint32_t CPU_TYPE = CPU_TYPE_POWERPC64;

 #else

 #error Unsupported CPU type

 #endif

 #ifdef __LP64__

 #undef LC_SEGMENT

 #define LC_SEGMENT LC_SEGMENT_64

 #undef MH_MAGIC

 #define MH_MAGIC MH_MAGIC_64

 #define cpu_mach_header mach_header_64

 #define segment_command segment_command_64

 #else

 #define cpu_mach_header mach_header

 #endif

 class ScopedMMap

 {

 public:

   ScopedMMap(const char *aFilePath)

     : buf(nullptr)

   {

     fd = open(aFilePath, O_RDONLY);

     if (fd < 0) {

       return;

     }

     struct stat st;

     if (fstat(fd, &st) < 0) {

       return;

     }

     size = st.st_size;

     buf = (char *)mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0);

   }

   ~ScopedMMap()

   {

     if (buf) {

       munmap(buf, size);

     }

     if (fd >= 0) {

       close(fd);

     }

   }

   operator char *() { return buf; }

   int getFd() { return fd; }

 private:

   int fd;

   char *buf;

   size_t size;

 };

 #endif

 void

 mozilla::ReadAhead(mozilla::filedesc_t aFd, const size_t aOffset,

                    const size_t aCount)

 {

 #if defined(XP_WIN)

   LARGE_INTEGER fpOriginal;

   LARGE_INTEGER fpOffset;

 #if defined(HAVE_LONG_LONG)

   fpOffset.QuadPart = 0;

 #else

   fpOffset.u.LowPart = 0;

   fpOffset.u.HighPart = 0;

 #endif

   // Get the current file pointer so that we can restore it. This isn't

   // really necessary other than to provide the same semantics regarding the

   // file pointer that other platforms do

   if (!SetFilePointerEx(aFd, fpOffset, &fpOriginal, FILE_CURRENT)) {

     return;

   }

   if (aOffset) {

 #if defined(HAVE_LONG_LONG)

     fpOffset.QuadPart = static_cast<LONGLONG>(aOffset);

 #else

     fpOffset.u.LowPart = aOffset;

     fpOffset.u.HighPart = 0;

 #endif

     if (!SetFilePointerEx(aFd, fpOffset, nullptr, FILE_BEGIN)) {

       return;

     }

   }

   char buf[64 * 1024];

   size_t totalBytesRead = 0;

   DWORD dwBytesRead;

   // Do dummy reads to trigger kernel-side readhead via FILE_FLAG_SEQUENTIAL_SCAN.

   // Abort when underfilling because during testing the buffers are read fully

   // A buffer that's not keeping up would imply that readahead isn't working right

   while (totalBytesRead < aCount &&

          ReadFile(aFd, buf, sizeof(buf), &dwBytesRead, nullptr) &&

          dwBytesRead == sizeof(buf)) {

     totalBytesRead += dwBytesRead;

   }

   // Restore the file pointer

   SetFilePointerEx(aFd, fpOriginal, nullptr, FILE_BEGIN);

 #elif defined(LINUX) && !defined(ANDROID)

   readahead(aFd, aOffset, aCount);

 #elif defined(XP_MACOSX)

   struct radvisory ra;

   ra.ra_offset = aOffset;

   ra.ra_count = aCount;

   // The F_RDADVISE fcntl is equivalent to Linux' readahead() system call.

   fcntl(aFd, F_RDADVISE, &ra);

 #endif

 }

 void

 mozilla::ReadAheadLib(mozilla::pathstr_t aFilePath)

 {

   if (!aFilePath) {

     return;

   }

 #if defined(XP_WIN)

   ReadAheadFile(aFilePath);

 #elif defined(LINUX) && !defined(ANDROID)

   int fd = open(aFilePath, O_RDONLY);

   if (fd < 0) {

     return;

   }

   union {

     char buf[bufsize];

     Elf_Ehdr ehdr;

   } elf;

   // Read ELF header (ehdr) and program header table (phdr).

   // We check that the ELF magic is found, that the ELF class matches

   // our own, and that the program header table as defined in the ELF

   // headers fits in the buffer we read.

   if ((read(fd, elf.buf, bufsize) <= 0) ||

       (memcmp(elf.buf, ELFMAG, 4)) ||

       (elf.ehdr.e_ident[EI_CLASS] != ELFCLASS) ||

       (elf.ehdr.e_phoff + elf.ehdr.e_phentsize * elf.ehdr.e_phnum >= bufsize)) {

     close(fd);

     return;

   }

   // The program header table contains segment definitions. One such

   // segment type is PT_LOAD, which describes how the dynamic loader

   // is going to map the file in memory. We use that information to

   // find the biggest offset from the library that will be mapped in

   // memory.

   Elf_Phdr *phdr = (Elf_Phdr *)&elf.buf[elf.ehdr.e_phoff];

   Elf_Off end = 0;

   for (int phnum = elf.ehdr.e_phnum; phnum; phdr++, phnum--) {

     if ((phdr->p_type == PT_LOAD) &&

         (end < phdr->p_offset + phdr->p_filesz)) {

       end = phdr->p_offset + phdr->p_filesz;

     }

   }

   // Let the kernel read ahead what the dynamic loader is going to

   // map in memory soon after.

   if (end > 0) {

     ReadAhead(fd, 0, end);

   }

   close(fd);

 #elif defined(XP_MACOSX)

   ScopedMMap buf(aFilePath);

   char *base = buf;

   if (!base) {

     return;

   }

   // An OSX binary might either be a fat (universal) binary or a

   // Mach-O binary. A fat binary actually embeds several Mach-O

   // binaries. If we have a fat binary, find the offset where the

   // Mach-O binary for our CPU type can be found.

   struct fat_header *fh = (struct fat_header *)base;

   if (OSSwapBigToHostInt32(fh->magic) == FAT_MAGIC) {

     uint32_t nfat_arch = OSSwapBigToHostInt32(fh->nfat_arch);

     struct fat_arch *arch = (struct fat_arch *)&buf[sizeof(struct fat_header)];

     for (; nfat_arch; arch++, nfat_arch--) {

       if (OSSwapBigToHostInt32(arch->cputype) == CPU_TYPE) {

         base += OSSwapBigToHostInt32(arch->offset);

         break;

       }

     }

     if (base == buf) {

       return;

     }

   }

   // Check Mach-O magic in the Mach header

   struct cpu_mach_header *mh = (struct cpu_mach_header *)base;

   if (mh->magic != MH_MAGIC) {

     return;

   }

   // The Mach header is followed by a sequence of load commands.

   // Each command has a header containing the command type and the

   // command size. LD_SEGMENT commands describes how the dynamic

   // loader is going to map the file in memory. We use that

   // information to find the biggest offset from the library that

   // will be mapped in memory.

   char *cmd = &base[sizeof(struct cpu_mach_header)];

   uint32_t end = 0;

   for (uint32_t ncmds = mh->ncmds; ncmds; ncmds--) {

     struct segment_command *sh = (struct segment_command *)cmd;

     if (sh->cmd != LC_SEGMENT) {

       continue;

     }

     if (end < sh->fileoff + sh->filesize) {

       end = sh->fileoff + sh->filesize;

     }

     cmd += sh->cmdsize;

   }

   // Let the kernel read ahead what the dynamic loader is going to

   // map in memory soon after.

   if (end > 0) {

     ReadAhead(buf.getFd(), base - buf, end);

   }

 #endif

 }

 void

 mozilla::ReadAheadFile(mozilla::pathstr_t aFilePath, const size_t aOffset,

                        const size_t aCount, mozilla::filedesc_t* aOutFd)

 {

 #if defined(XP_WIN)

   if (!aFilePath) {

     if (aOutFd) {

       *aOutFd = INVALID_HANDLE_VALUE;

     }

     return;

   }

   HANDLE fd = CreateFileW(aFilePath, GENERIC_READ, FILE_SHARE_READ, nullptr,

                           OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, nullptr);

   if (aOutFd) {

     *aOutFd = fd;

   }

   if (fd == INVALID_HANDLE_VALUE) {

     return;

   }

   ReadAhead(fd, aOffset, aCount);

   if (!aOutFd) {

     CloseHandle(fd);

   }

 #elif defined(LINUX) && !defined(ANDROID) || defined(XP_MACOSX)

   if (!aFilePath) {

     if (aOutFd) {

       *aOutFd = -1;

     }

     return;

   }

   int fd = open(aFilePath, O_RDONLY);

   if (aOutFd) {

     *aOutFd = fd;

   }

   if (fd < 0) {

     return;

   }

   size_t count;

   if (aCount == SIZE_MAX) {

     struct stat st;

     if (fstat(fd, &st) < 0) {

       if (!aOutFd) {

         close(fd);

       }

       return;

     }

     count = st.st_size;

   } else {

     count = aCount;

   }

   ReadAhead(fd, aOffset, count);

   if (!aOutFd) {

     close(fd);

   }

 #endif

 }