SegmentCommand.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_MACHO_SEGMENT_COMMAND_H
#define LIEF_MACHO_SEGMENT_COMMAND_H
 
#include <string>
#include <vector>
#include <ostream>
#include <memory>
 
#include "LIEF/enums.hpp"
#include "LIEF/span.hpp"
#include "LIEF/visibility.h"
 
#include "LIEF/iterators.hpp"
#include "LIEF/MachO/LoadCommand.hpp"
 
 
namespace LIEF {
class SpanStream;
namespace MachO {
 
class Binary;
class BinaryParser;
class Builder;
class DyldChainedFixupsCreator;
class DyldInfo;
class Relocation;
class Section;
 
namespace details {
struct segment_command_32;
struct segment_command_64;
}
class LIEF_API SegmentCommand : public LoadCommand {
 
  friend class DyldChainedFixupsCreator;
  friend class BinaryParser;
  friend class Binary;
  friend class Section;
  friend class Builder;
 
  public:
  using content_t = std::vector<uint8_t>;
  using sections_t = std::vector<std::unique_ptr<Section>>;
  using it_sections = ref_iterator<sections_t&, Section*>;
  using it_const_sections = const_ref_iterator<const sections_t&, const Section*>;
  using relocations_t = std::vector<std::unique_ptr<Relocation>>;
  using it_relocations = ref_iterator<relocations_t&, Relocation*>;
  using it_const_relocations = const_ref_iterator<const relocations_t&, const Relocation*>;
 
  enum class FLAGS: uint64_t  {
    HIGHVM              = 0x1u, 
    FVMLIB              = 0x2u, 
    NORELOC             = 0x4u, 
    PROTECTED_VERSION_1 = 0x8u,
    READ_ONLY           = 0x10u,
  };
  enum class VM_PROTECTIONS  {
    READ    = 0x1, 
    WRITE   = 0x2, 
    EXECUTE = 0x4, 
  };

public:

SegmentCommand();

SegmentCommand(const details::segment_command_32& cmd);

SegmentCommand(const details::segment_command_64& cmd);

SegmentCommand& operator=(SegmentCommand other);

SegmentCommand(const SegmentCommand& copy);

SegmentCommand(std::string name, content_t content);

SegmentCommand(std::string name);

void swap(SegmentCommand& other) noexcept;

std::unique_ptr<LoadCommand> clone() const override {

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

}

~SegmentCommand() override;

const std::string& name() const {

return name_;

}