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