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

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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 "mozilla/FileUtils.h"

#include <errno.h>

#include <stdio.h>

#include "nscore.h"

#include "private/pprio.h"

#include "prmem.h"

#include "mozilla/Assertions.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(MOZILLA_INTERNAL_API)

#include "nsString.h"

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 (ret == -1) {

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

    store.fst_flags = F_ALLOCATEALL;

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

    if (ret == -1) {

      return false;

    }

  }

  return ftruncate(fd, aLength) == 0;

#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;

}

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

}

mozilla::PathString

mozilla::GetLibraryName(mozilla::pathstr_t aDirectory, const char* aLib)

{

#ifdef XP_WIN

  nsAutoString fullName;

  if (aDirectory) {

    fullName.Assign(aDirectory);

    fullName.Append('\\');

  }

  AppendUTF8toUTF16(MakeStringSpan(aLib), fullName);

  if (!strstr(aLib, ".dll")) {

    fullName.AppendLiteral(".dll");

  }

  return std::move(fullName);

#else

  char* temp = PR_GetLibraryName(aDirectory, aLib);

  if (!temp) {

    return EmptyCString();

  }

  nsAutoCString libname(temp);

  PR_FreeLibraryName(temp);

  return std::move(libname);

#endif

}

mozilla::PathString

mozilla::GetLibraryFilePathname(mozilla::pathstr_t aName, PRFuncPtr aAddr)

{

#ifdef XP_WIN

  HMODULE handle = GetModuleHandleW(char16ptr_t(aName));

  if (!handle) {

    return EmptyString();

  }

  nsAutoString path;

  path.SetLength(MAX_PATH);

  DWORD len = GetModuleFileNameW(handle, char16ptr_t(path.BeginWriting()),

                                 path.Length());

  if (!len) {

    return EmptyString();

  }

  path.SetLength(len);

  return std::move(path);

#else

  char* temp = PR_GetLibraryFilePathname(aName, aAddr);

  if (!temp) {

    return EmptyCString();

  }

  nsAutoCString path(temp);

  PR_Free(temp); // PR_GetLibraryFilePathname() uses PR_Malloc().

  return std::move(path);

#endif

}

#endif // defined(MOZILLA_INTERNAL_API)

#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:

  explicit 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) ||

      // Upcast e_phentsize so the multiplication is done in the same precision

      // as the subsequent addition, to satisfy static analyzers and avoid

      // issues with abnormally large program header tables.

      (elf.ehdr.e_phoff + (static_cast<Elf_Off>(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

}