// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements. See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership. The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License. You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied. See the License for the

// specific language governing permissions and limitations

// under the License.

// This file is copied from

// https://github.com/ClickHouse/ClickHouse/blob/master/src/Common/Elf.cpp

// and modified by Doris

#if defined(__ELF__) && !defined(__FreeBSD__)

#include "common/elf.h"

#include <fcntl.h>

#include <fmt/format.h>

#include <sys/mman.h>

#include <unistd.h>

#include <cstring>

#include <system_error>

#include "common/logging.h"

#include "common/macros.h"

#include "util/unaligned.h"

namespace doris {

Elf::Elf(const std::string& path) {

_file = path;

std::error_code ec;

elf_size = std::filesystem::file_size(_file, ec);

if (ec) {

LOG(FATAL) << fmt::format("failed to get file size {}: ({}), {}", _file.native(),

ec.value(), ec.message());

}

/// Check if it's an elf.

if (elf_size < sizeof(ElfEhdr)) {

LOG(FATAL) << fmt::format("The size of supposedly ELF file '{}' is too small", path);

}

RETRY_ON_EINTR(_fd, open(_file.c_str(), O_RDONLY));

if (_fd < 0) {

LOG(FATAL) << fmt::format("failed to open {}", _file.native());

}

mapped = static_cast<char*>(mmap(nullptr, elf_size, PROT_READ, MAP_SHARED, _fd, 0));

if (MAP_FAILED == mapped) {

LOG(FATAL) << fmt::format("MMappedFileDescriptor: Cannot mmap {}, read from {}.", elf_size,

path);

}

header = reinterpret_cast<const ElfEhdr*>(mapped);

if (memcmp(header->e_ident,

"\x7F"

"ELF",

4) != 0) {

LOG(FATAL) << fmt::format("The file '{}' is not ELF according to magic", path);

}

/// Get section header.

ElfOff section_header_offset = header->e_shoff;

uint16_t section_header_num_entries = header->e_shnum;

if (!section_header_offset || !section_header_num_entries ||

section_header_offset + section_header_num_entries * sizeof(ElfShdr) > elf_size) {

LOG(FATAL) << fmt::format(

"The ELF '{}' is truncated (section header points after end of file)", path);

}

section_headers = reinterpret_cast<const ElfShdr*>(mapped + section_header_offset);

/// The string table with section names.

auto section_names_strtab = findSection([&](const Section& section, size_t idx) {

return section.header.sh_type == SHT_STRTAB && header->e_shstrndx == idx;

});

if (!section_names_strtab) {

LOG(FATAL) << fmt::format("The ELF '{}' doesn't have string table with section names",

path);

}

ElfOff section_names_offset = section_names_strtab->header.sh_offset;

if (section_names_offset >= elf_size) {

LOG(FATAL) << fmt::format(

"The ELF '{}' is truncated (section names string table points after end of file)",

path);

}

section_names = reinterpret_cast<const char*>(mapped + section_names_offset);

/// Get program headers

ElfOff program_header_offset = header->e_phoff;

uint16_t program_header_num_entries = header->e_phnum;

if (!program_header_offset || !program_header_num_entries ||

program_header_offset + program_header_num_entries * sizeof(ElfPhdr) > elf_size) {

LOG(FATAL) << fmt::format(

"The ELF '{}' is truncated (program header points after end of file)", path);

}

program_headers = reinterpret_cast<const ElfPhdr*>(mapped + program_header_offset);

}

Elf::~Elf() {

if (mapped) {

munmap(static_cast<void*>(mapped), elf_size);

}

if (_fd > 0) {

int res = ::close(_fd);

if (-1 == res) {

LOG(WARNING) << fmt::format("failed to close {}", _file.native());

}

_fd = -1;

}

}

Elf::Section::Section(const ElfShdr& header_, const Elf& elf_) : header(header_), elf(elf_) {}

bool Elf::iterateSections(std::function<bool(const Section& section, size_t idx)>&& pred) const {

for (size_t idx = 0; idx < header->e_shnum; ++idx) {

Section section(section_headers[idx], *this);

/// Sections spans after end of file.

if (section.header.sh_offset + section.header.sh_size > elf_size) {

continue;

}

if (pred(section, idx)) {

return true;

}

}

return false;

}

std::optional<Elf::Section> Elf::findSection(

std::function<bool(const Section& section, size_t idx)>&& pred) const {

std::optional<Elf::Section> result;

iterateSections([&](const Section& section, size_t idx) {

if (pred(section, idx)) {

result.emplace(section);

return true;

}

return false;

});

return result;

}

std::optional<Elf::Section> Elf::findSectionByName(const char* name) const {

return findSection(

[&](const Section& section, size_t) { return 0 == strcmp(name, section.name()); });

}

std::string Elf::getBuildID() const {

/// Section headers are the first choice for a debuginfo file

if (std::string build_id; iterateSections([&build_id](const Section& section, size_t) {

if (section.header.sh_type == SHT_NOTE) {

build_id = Elf::getBuildID(section.begin(), section.size());

if (!build_id.empty()) {

return true;

}

}

return false;

})) {

return build_id;

}

/// fallback to PHDR

for (size_t idx = 0; idx < header->e_phnum; ++idx) {

const ElfPhdr& phdr = program_headers[idx];

if (phdr.p_type == PT_NOTE) {

return getBuildID(mapped + phdr.p_offset, phdr.p_filesz);

}

}

return {};

}

#if defined(OS_SUNOS)

std::string Elf::getBuildID(const char* nhdr_pos, size_t size) {

return {};

}

#else

std::string Elf::getBuildID(const char* nhdr_pos, size_t size) {

const char* nhdr_end = nhdr_pos + size;

while (nhdr_pos < nhdr_end) {

ElfNhdr nhdr = unaligned_load<ElfNhdr>(nhdr_pos);

nhdr_pos += sizeof(ElfNhdr) + nhdr.n_namesz;

if (nhdr.n_type == NT_GNU_BUILD_ID) {

const char* build_id = nhdr_pos;

return {build_id, nhdr.n_descsz};

}

nhdr_pos += nhdr.n_descsz;

}

return {};

}

#endif // OS_SUNOS

std::string Elf::getStoredBinaryHash() const {

if (auto section = findSectionByName(".clickhouse.hash")) {

return {section->begin(), section->end()};

} else {

return {};

}

}

const char* Elf::Section::name() const {

if (!elf.section_names) {

LOG(FATAL) << fmt::format("Section names are not initialized");

}

/// TODO buffer overflow is possible, we may need to check strlen.

return elf.section_names + header.sh_name;

}

const char* Elf::Section::begin() const {

return elf.mapped + header.sh_offset;

}

const char* Elf::Section::end() const {

return begin() + size();

}

size_t Elf::Section::size() const {

return header.sh_size;

}

} // namespace doris

#endif