xref: /bionic/tools/relocation_packer/src/elf_file_unittest.cc

// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "elf_file.h"

#include <limits.h>
#include <stdio.h>
#include <unistd.h>
#include <string>
#include <vector>
#include "debug.h"
#include "elf_traits.h"
#include "gtest/gtest.h"

namespace {

void GetDataFilePath(const char* name, std::string* path) {
  std::string data_dir;

  const char* bindir = getenv("bindir");
  if (bindir) {
    data_dir = std::string(bindir);
  } else {
    char path[PATH_MAX];
    memset(path, 0, sizeof(path));
    ASSERT_NE(-1, readlink("/proc/self/exe", path, sizeof(path) - 1));

    data_dir = std::string(path);
    size_t pos = data_dir.rfind('/');
    ASSERT_NE(std::string::npos, pos);

    data_dir.erase(pos);
  }

  *path = data_dir + "/" + name;
}

void OpenRelocsTestFile(const char* name, FILE** stream) {
  std::string path;
  GetDataFilePath(name, &path);

  FILE* testfile = fopen(path.c_str(), "rb");
  ASSERT_FALSE(testfile == NULL) << "Error opening '" << path << "'";

  FILE* temporary = tmpfile();
  ASSERT_FALSE(temporary == NULL);

  static const size_t buffer_size = 4096;
  unsigned char buffer[buffer_size];

  size_t bytes;
  do {
    bytes = fread(buffer, 1, sizeof(buffer), testfile);
    ASSERT_EQ(bytes, fwrite(buffer, 1, bytes, temporary));
  } while (bytes > 0);

  ASSERT_EQ(0, fclose(testfile));
  ASSERT_EQ(0, fseek(temporary, 0, SEEK_SET));
  ASSERT_EQ(0, lseek(fileno(temporary), 0, SEEK_SET));

  *stream = temporary;
}

void OpenRelocsTestFiles(const std::string& arch, FILE** relocs_so, FILE** packed_relocs_so) {
  const std::string base = std::string("elf_file_unittest_relocs_") + arch;
  const std::string relocs = base + ".so";
  const std::string packed_relocs = base + "_packed.so";

  OpenRelocsTestFile(relocs.c_str(), relocs_so);
  OpenRelocsTestFile(packed_relocs.c_str(), packed_relocs_so);
}

void CloseRelocsTestFile(FILE* temporary) {
  fclose(temporary);
}

void CloseRelocsTestFiles(FILE* relocs_so, FILE* packed_relocs_so) {
  CloseRelocsTestFile(relocs_so);
  CloseRelocsTestFile(packed_relocs_so);
}

void CheckFileContentsEqual(FILE* first, FILE* second) {
  ASSERT_EQ(0, fseek(first, 0, SEEK_SET));
  ASSERT_EQ(0, fseek(second, 0, SEEK_SET));

  static const size_t buffer_size = 4096;
  unsigned char first_buffer[buffer_size];
  unsigned char second_buffer[buffer_size];

  do {
    size_t first_read = fread(first_buffer, 1, sizeof(first_buffer), first);
    size_t second_read = fread(second_buffer, 1, sizeof(second_buffer), second);

    EXPECT_EQ(first_read, second_read);
    EXPECT_EQ(0, memcmp(first_buffer, second_buffer, first_read));
  } while (!feof(first) && !feof(second));

  EXPECT_TRUE(feof(first) && feof(second));
}

template <typename ELF>
static void ProcessUnpack(FILE* relocs_so, FILE* packed_relocs_so) {
  relocation_packer::ElfFile<ELF> elf_file(fileno(packed_relocs_so));

  // Ensure packing already packed elf-file does not fail the build.
  EXPECT_TRUE(elf_file.PackRelocations());

  // Unpack golden relocations, and check files are now identical.
  EXPECT_TRUE(elf_file.UnpackRelocations());
  CheckFileContentsEqual(packed_relocs_so, relocs_so);

  CloseRelocsTestFiles(relocs_so, packed_relocs_so);
}

static void RunUnpackRelocationsTestFor(const std::string& arch) {
  ASSERT_NE(static_cast<uint32_t>(EV_NONE), elf_version(EV_CURRENT));

  FILE* relocs_so = NULL;
  FILE* packed_relocs_so = NULL;
  OpenRelocsTestFiles(arch, &relocs_so, &packed_relocs_so);

  if (relocs_so != NULL && packed_relocs_so != NULL) {
    // lets detect elf class
    ASSERT_EQ(0, fseek(relocs_so, EI_CLASS, SEEK_SET))
        << "Invalid file length: " << strerror(errno);
    uint8_t elf_class = 0;
    ASSERT_EQ(1U, fread(&elf_class, 1, 1, relocs_so));
    ASSERT_EQ(0, fseek(relocs_so, 0, SEEK_SET));
    if (elf_class == ELFCLASS32) {
      ProcessUnpack<ELF32_traits>(relocs_so, packed_relocs_so);
    } else {
      ProcessUnpack<ELF64_traits>(relocs_so, packed_relocs_so);
    }
  }
}

template <typename ELF>
static void ProcessPack(FILE* relocs_so, FILE* packed_relocs_so) {
  relocation_packer::ElfFile<ELF> elf_file(fileno(relocs_so));

  // Ensure unpacking fails (not packed).
  EXPECT_FALSE(elf_file.UnpackRelocations());

  // Pack relocations, and check files are now identical.
  EXPECT_TRUE(elf_file.PackRelocations());
  CheckFileContentsEqual(relocs_so, packed_relocs_so);

  CloseRelocsTestFiles(relocs_so, packed_relocs_so);
}

static void RunPackRelocationsTestFor(const std::string& arch) {
  ASSERT_NE(static_cast<uint32_t>(EV_NONE), elf_version(EV_CURRENT));

  FILE* relocs_so = NULL;
  FILE* packed_relocs_so = NULL;
  OpenRelocsTestFiles(arch, &relocs_so, &packed_relocs_so);

  if (relocs_so != NULL && packed_relocs_so != NULL) {
    // lets detect elf class
    ASSERT_EQ(0, fseek(packed_relocs_so, EI_CLASS, SEEK_SET))
        << "Invalid file length: " << strerror(errno);
    uint8_t elf_class = 0;
    ASSERT_EQ(1U, fread(&elf_class, 1, 1, packed_relocs_so));
    fseek(packed_relocs_so, 0, SEEK_SET);
    if (elf_class == ELFCLASS32) {
      ProcessPack<ELF32_traits>(relocs_so, packed_relocs_so);
    } else {
      ProcessPack<ELF64_traits>(relocs_so, packed_relocs_so);
    }
  }
}

}  // namespace

namespace relocation_packer {

TEST(ElfFile, PackRelocationsArm32) {
  RunPackRelocationsTestFor("arm32");
}

TEST(ElfFile, PackRelocationsArm64) {
  RunPackRelocationsTestFor("arm64");
}

TEST(ElfFile, PackRelocationsMips32) {
  RunPackRelocationsTestFor("mips32");
}

TEST(ElfFile, PackRelocationsIa32) {
  RunPackRelocationsTestFor("ia32");
}

TEST(ElfFile, PackRelocationsX64) {
  RunPackRelocationsTestFor("x64");
}

TEST(ElfFile, UnpackRelocationsArm32) {
  RunUnpackRelocationsTestFor("arm32");
}

TEST(ElfFile, UnpackRelocationsArm64) {
  RunUnpackRelocationsTestFor("arm64");
}

TEST(ElfFile, UnpackRelocationsMips32) {
  RunUnpackRelocationsTestFor("mips32");
}

TEST(ElfFile, UnpackRelocationsIa32) {
  RunUnpackRelocationsTestFor("ia32");
}

TEST(ElfFile, UnpackRelocationsX64) {
  RunUnpackRelocationsTestFor("x64");
}

}  // namespace relocation_packer