DylibCommand.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 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_DYLIB_COMMAND_H
#define LIEF_MACHO_DYLIB_COMMAND_H
#include <string_view>
#include <array>
#include <memory>
#include <ostream>
#include <string>
 
#include "LIEF/visibility.h"
 
#include "LIEF/MachO/LoadCommand.hpp"
 
 
namespace LIEF::MachO {
 
namespace details {
struct dylib_command;
}

class LIEF_API DylibCommand : public LoadCommand {
  public:
  using version_t = std::array<uint16_t, 3>;
 
  public:
  static version_t int2version(uint32_t version) {
    return {{
        static_cast<uint16_t>(version >> 16),
        static_cast<uint16_t>((version >> 8) & 0xFF),
        static_cast<uint16_t>(version & 0xFF),
    }};
  }

  static uint32_t version2int(version_t version) {
    return (version[2]) | (version[1] << 8) | (version[0] << 16);
  }

  static DylibCommand weak_dylib(const std::string& name, uint32_t timestamp = 0,
                                 uint32_t current_version = 0,
                                 uint32_t compat_version = 0);

  static DylibCommand id_dylib(const std::string& name, uint32_t timestamp = 0,
                               uint32_t current_version = 0,
                               uint32_t compat_version = 0);

  static DylibCommand load_dylib(const std::string& name, uint32_t timestamp = 2,
                                 uint32_t current_version = 0,
                                 uint32_t compat_version = 0);

  static DylibCommand reexport_dylib(const std::string& name,
                                     uint32_t timestamp = 0,
                                     uint32_t current_version = 0,
                                     uint32_t compat_version = 0);

  static DylibCommand load_upward_dylib(const std::string& name,
                                        uint32_t timestamp = 0,
                                        uint32_t current_version = 0,
                                        uint32_t compat_version = 0);

  static DylibCommand lazy_load_dylib(const std::string& name,
                                      uint32_t timestamp = 0,
                                      uint32_t current_version = 0,
                                      uint32_t compat_version = 0);
 
  public:
  DylibCommand() = default;
  DylibCommand(const details::dylib_command& cmd);
 
  DylibCommand& operator=(const DylibCommand& copy) = default;
  DylibCommand(const DylibCommand& copy) = default;
 
  ~DylibCommand() override = default;
 
  std::unique_ptr<LoadCommand> clone() const override {
    return std::make_unique<DylibCommand>(*this);
  }

  std::string_view name() const LIEF_LIFETIMEBOUND {
    return name_;
  }

  uint32_t name_offset() const {
    return name_offset_;
  }

  uint32_t timestamp() const {
    return timestamp_;
  }

  version_t current_version() const {
    return int2version(current_version_);
  }

  version_t compatibility_version() const {
    return int2version(compatibility_version_);
  }
 
  void name(std::string name) {
    name_ = std::move(name);
  }
  void timestamp(uint32_t timestamp) {
    timestamp_ = timestamp;
  }
  void current_version(version_t version) {
    current_version_ = version2int(version);
  }
  void compatibility_version(version_t version) {
    compatibility_version_ = version2int(version);
  }
 
  std::ostream& print(std::ostream& os) const override;
 
  void accept(Visitor& visitor) const override;
 
  static bool classof(const LoadCommand* cmd) {
    const LoadCommand::TYPE type = cmd->command();
    return type == LoadCommand::TYPE::LOAD_UPWARD_DYLIB ||
           type == LoadCommand::TYPE::LAZY_LOAD_DYLIB ||
           type == LoadCommand::TYPE::LOAD_WEAK_DYLIB ||
           type == LoadCommand::TYPE::ID_DYLIB ||
           type == LoadCommand::TYPE::LOAD_DYLIB ||
           type == LoadCommand::TYPE::REEXPORT_DYLIB;
  }
 
  private:
  LIEF_LOCAL static DylibCommand
      create(LoadCommand::TYPE type, const std::string& name, uint32_t timestamp,
             uint32_t current_version, uint32_t compat_version);
 
  std::string name_;
  uint32_t name_offset_ = 0;
  uint32_t timestamp_ = 0;
  uint32_t current_version_ = 0;
  uint32_t compatibility_version_ = 0;
};
 
 
}
 
#endif