Note.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2024 R. Thomas
 * Copyright 2017 - 2024 Quarkslab
 *
 * Licensed 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.
 */
#ifndef LIEF_ELF_NOTE_H
#define LIEF_ELF_NOTE_H
 
#include <vector>
#include <ostream>
#include <memory>
 
#include "LIEF/Object.hpp"
#include "LIEF/visibility.h"
#include "LIEF/errors.hpp"
#include "LIEF/span.hpp"
 
#include "LIEF/ELF/Header.hpp"
 
namespace LIEF {
class BinaryStream;
namespace ELF {
class Binary;
class Parser;
class Builder;
class LIEF_API Note : public Object {
  friend class Parser;
  friend class Builder;
  friend class Binary;
 
  public:  using description_t = std::vector<uint8_t>;
  enum class TYPE {
    UNKNOWN = 0,    GNU_ABI_TAG,    GNU_HWCAP,    GNU_BUILD_ID,    GNU_GOLD_VERSION,    GNU_PROPERTY_TYPE_0,
 
    GNU_BUILD_ATTRIBUTE_OPEN,
    GNU_BUILD_ATTRIBUTE_FUNC,
    CRASHPAD,
    CORE_PRSTATUS,
    CORE_FPREGSET,    CORE_PRPSINFO,
    CORE_TASKSTRUCT,    CORE_AUXV,
    CORE_PSTATUS,    CORE_FPREGS,    CORE_PSINFO,
    CORE_LWPSTATUS,
    CORE_LWPSINFO,
    CORE_WIN32PSTATUS,
    CORE_FILE,
    CORE_PRXFPREG,
    CORE_SIGINFO,
 
    CORE_ARM_VFP,
    CORE_ARM_TLS,
    CORE_ARM_HW_BREAK,
    CORE_ARM_HW_WATCH,
    CORE_ARM_SYSTEM_CALL,
    CORE_ARM_SVE,
    CORE_ARM_PAC_MASK,
    CORE_ARM_PACA_KEYS,
    CORE_ARM_PACG_KEYS,
    CORE_TAGGED_ADDR_CTRL,
    CORE_PAC_ENABLED_KEYS,
 
    CORE_X86_TLS,
    CORE_X86_IOPERM,
    CORE_X86_XSTATE,
    CORE_X86_CET,
    ANDROID_IDENT,
    ANDROID_MEMTAG,
    ANDROID_KUSER,
    GO_BUILDID,    STAPSDT,    QNX_STACK
  };

public: static result<TYPE> convert_type(Header::FILE_TYPE ftype, uint32_t type,

const std::string& name);

static result<const char*> type_to_section(TYPE type);

static result<std::string> note_to_section(const Note& note) {

const std::string& sec_name = note.section_name();

if (sec_name.empty()) {

return type_to_section(note.type());

}

return sec_name;

}

static result<const char*> type_owner(TYPE type);

static std::unique_ptr<Note> create(

const std::string& name, uint32_t type, description_t description,

std::string section_name,

Header::FILE_TYPE ftype = Header::FILE_TYPE::NONE, ARCH arch = ARCH::NONE,

Header::CLASS cls = Header::CLASS::NONE);

static std::unique_ptr<Note> create(

const std::string& name, TYPE type, description_t description,

std::string section_name,

ARCH arch = ARCH::NONE, Header::CLASS cls = Header::CLASS::NONE);

static std::unique_ptr<Note> create(BinaryStream& stream,

std::string section_name,

Header::FILE_TYPE ftype = Header::FILE_TYPE::NONE, ARCH arch = ARCH::NONE,

Header::CLASS cls = Header::CLASS::NONE);

Note& operator=(const Note& copy) = default;

Note(const Note& copy) = default;

~Note() override = default;

virtual std::unique_ptr<Note> clone() const {

return std::unique_ptr<Note>(new Note(*this));

}