DyldInfo.hpp

/* Copyright 2017 - 2023 R. Thomas
 * Copyright 2017 - 2023 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_MACHO_DYLD_INFO_COMMAND_H
#define LIEF_MACHO_DYLD_INFO_COMMAND_H
#include <string>
#include <set>
#include <vector>
#include <ostream>
#include <memory>
 
#include "LIEF/visibility.h"
#include "LIEF/types.hpp"
#include "LIEF/span.hpp"
 
#include "LIEF/MachO/LoadCommand.hpp"
#include "LIEF/MachO/type_traits.hpp"
#include "LIEF/iterators.hpp"
 
namespace LIEF {
class vector_iostream;
class BinaryStream;
namespace MachO {
 
class Binary;
class BinaryParser;
class Builder;
class DyldBindingInfo;
class ExportInfo;
class LinkEdit;
class RelocationDyld;
 
namespace details {
struct dyld_info_command;
}
 
class LIEF_API DyldInfo : public LoadCommand {
 
  friend class BinaryParser;
  friend class Binary;
  friend class Builder;
  friend class LinkEdit;
 
  public:
  using info_t = std::pair<uint32_t, uint32_t>;
 
  using binding_info_t = std::vector<std::unique_ptr<DyldBindingInfo>>;
 
  using it_binding_info = ref_iterator<binding_info_t&, DyldBindingInfo*>;
 
  using it_const_binding_info = const_ref_iterator<const binding_info_t&, DyldBindingInfo*>;
 
  using export_info_t = std::vector<std::unique_ptr<ExportInfo>>;
 
  using it_export_info = ref_iterator<export_info_t&, ExportInfo*>;
 
  using it_const_export_info = const_ref_iterator<const export_info_t&, ExportInfo*>;
 
 
  enum class BINDING_ENCODING_VERSION {
    UNKNOWN = 0,
    V1,
    V2
  };
 
  DyldInfo();
  DyldInfo(const details::dyld_info_command& dyld_info_cmd);
 
  DyldInfo& operator=(DyldInfo other);
  DyldInfo(const DyldInfo& copy);
 
  void swap(DyldInfo& other);
 
  DyldInfo* clone() const override;
 
  ~DyldInfo() override;
 
  const info_t& rebase() const;
 
  span<const uint8_t> rebase_opcodes() const;
  span<uint8_t>       rebase_opcodes();
 
  void rebase_opcodes(buffer_t raw);
 
 
  std::string show_rebases_opcodes() const;
 
  const info_t& bind() const;
 
  span<const uint8_t> bind_opcodes() const;
  span<uint8_t>       bind_opcodes();
 
  void bind_opcodes(buffer_t raw);
 
  std::string show_bind_opcodes() const;
 
  const info_t& weak_bind() const;
 
  span<const uint8_t> weak_bind_opcodes() const;
  span<uint8_t>       weak_bind_opcodes();
 
  void weak_bind_opcodes(buffer_t raw);
 
  std::string show_weak_bind_opcodes() const;
 
  const info_t& lazy_bind() const;
 
  span<const uint8_t> lazy_bind_opcodes() const;
  span<uint8_t>       lazy_bind_opcodes();
 
  void lazy_bind_opcodes(buffer_t raw);
 
  std::string show_lazy_bind_opcodes() const;
 
  it_binding_info       bindings();
  it_const_binding_info bindings() const;
 
  const info_t& export_info() const;
 
  it_export_info       exports();
  it_const_export_info exports() const;
 
  span<const uint8_t> export_trie() const;
  span<uint8_t>       export_trie();
 
  void export_trie(buffer_t raw);
 
  std::string show_export_trie() const;
 
  void rebase(const info_t& info);
  void bind(const info_t& info);
  void weak_bind(const info_t& info);
  void lazy_bind(const info_t& info);
  void export_info(const info_t& info);
 
  void set_rebase_offset(uint32_t offset);
  void set_rebase_size(uint32_t size);
 
  void set_bind_offset(uint32_t offset);
  void set_bind_size(uint32_t size);
 
  void set_weak_bind_offset(uint32_t offset);
  void set_weak_bind_size(uint32_t size);
 
  void set_lazy_bind_offset(uint32_t offset);
  void set_lazy_bind_size(uint32_t size);
 
  void set_export_offset(uint32_t offset);
  void set_export_size(uint32_t size);
 
  void add(std::unique_ptr<ExportInfo> info);
 
 
  void accept(Visitor& visitor) const override;
 
  std::ostream& print(std::ostream& os) const override;
 
  static bool classof(const LoadCommand* cmd);
 
  private:
  using bind_container_t = std::set<DyldBindingInfo*, std::function<bool(DyldBindingInfo*, DyldBindingInfo*)>>;
 
  void show_bindings(std::ostream& os, span<const uint8_t> buffer, bool is_lazy = false) const;
 
  void show_trie(std::ostream& output, std::string output_prefix, BinaryStream& stream, uint64_t start, uint64_t end, const std::string& prefix) const;
 
  LIEF_LOCAL DyldInfo& update_standard_bindings(const bind_container_t& bindings, vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_standard_bindings_v1(const bind_container_t& bindings, vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_standard_bindings_v2(const bind_container_t& bindings,
                                                   std::vector<RelocationDyld*> rebases, vector_iostream& stream);
 
  LIEF_LOCAL DyldInfo& update_weak_bindings(const bind_container_t& bindings, vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_lazy_bindings(const bind_container_t& bindings, vector_iostream& stream);
 
  LIEF_LOCAL DyldInfo& update_rebase_info(vector_iostream& stream);
  LIEF_LOCAL DyldInfo& update_binding_info(vector_iostream& stream, details::dyld_info_command& cmd);
  LIEF_LOCAL DyldInfo& update_export_trie(vector_iostream& stream);
 
  info_t   rebase_;
  span<uint8_t> rebase_opcodes_;
 
  info_t   bind_;
  span<uint8_t> bind_opcodes_;
 
  info_t   weak_bind_;
  span<uint8_t> weak_bind_opcodes_;
 
  info_t   lazy_bind_;
  span<uint8_t> lazy_bind_opcodes_;
 
  info_t   export_;
  span<uint8_t> export_trie_;
 
  export_info_t  export_info_;
  binding_info_t binding_info_;
 
  BINDING_ENCODING_VERSION binding_encoding_version_ = BINDING_ENCODING_VERSION::UNKNOWN;
 
  Binary* binary_ = nullptr;
};
 
}
}
#endif