ResourceVersion.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_PE_RESOURCE_VERSION_H
#define LIEF_PE_RESOURCE_VERSION_H
#include <cstdint>
#include <ostream>
#include <string>
 
#include "LIEF/Object.hpp"
#include "LIEF/errors.hpp"
#include "LIEF/visibility.h"
#include <optional>
 
#include "LIEF/PE/resources/ResourceStringFileInfo.hpp"
#include "LIEF/PE/resources/ResourceVarFileInfo.hpp"
 
namespace LIEF {
class BinaryStream;
 
namespace PE {
class ResourceData;

class LIEF_API ResourceVersion : public Object {
  public:
  static result<ResourceVersion> parse(const ResourceData& node);
  static result<ResourceVersion> parse(const uint8_t* p, size_t sz);
  static result<ResourceVersion> parse(BinaryStream& stream);

  struct LIEF_API fixed_file_info_t {
    enum class VERSION_OS : uint32_t {
      UNKNOWN = 0x00000000,

      DOS = 0x00010000,

      OS216 = 0x00020000,

      OS232 = 0x00030000,

      NT = 0x00040000,

      WINCE = 0x00050000,

      WINDOWS16 = 0x00000001,

      PM16 = 0x00000002,

      PM32 = 0x00000003,

      WINDOWS32 = 0x00000004,

      DOS_WINDOWS16 = DOS | WINDOWS16,

      DOS_WINDOWS32 = DOS | WINDOWS32,

      OS216_PM16 = OS216 | PM16,

      OS232_PM32 = OS232 | PM32,

      NT_WINDOWS32 = NT | WINDOWS32,
    };
 
    enum class FILE_TYPE : uint32_t {
      UNKNOWN = 0x00000000,

      APP = 0x00000001,

      DLL = 0x00000002,

      DRV = 0x00000003,

      FONT = 0x00000004,

      VXD = 0x00000005,

      STATIC_LIB = 0x00000007,
    };
 
    static constexpr auto DRV_K = uint64_t(1) << 33;
    static constexpr auto FONT_K = uint64_t(1) << 34;
 
    enum class FILE_TYPE_DETAILS : uint64_t {
      UNKNOWN = 0x00000000,
      DRV_PRINTER = 0x00000001 | DRV_K,
      DRV_KEYBOARD = 0x00000002 | DRV_K,
      DRV_LANGUAGE = 0x00000003 | DRV_K,
      DRV_DISPLAY = 0x00000004 | DRV_K,
      DRV_MOUSE = 0x00000005 | DRV_K,
      DRV_NETWORK = 0x00000006 | DRV_K,
      DRV_SYSTEM = 0x00000007 | DRV_K,
      DRV_INSTALLABLE = 0x00000008 | DRV_K,
      DRV_SOUND = 0x00000009 | DRV_K,
      DRV_COMM = 0x0000000A | DRV_K,
 
      DRV_INPUTMETHOD = 0x0000000B | DRV_K,

      DRV_VERSIONED_PRINTER = 0x0000000C,

      FONT_RASTER = 0x00000001 | FONT_K,

      FONT_VECTOR = 0x00000002 | FONT_K,

      FONT_TRUETYPE = 0x00000003 | FONT_K,
    };
 
    enum class FILE_FLAGS : uint32_t {
      DEBUG = 0x00000001,

      INFO_INFERRED = 0x00000010,

      PATCHED = 0x00000004,

      PRERELEASE = 0x00000002,

      PRIVATEBUILD = 0x00000008,

      SPECIALBUILD = 0x00000020,
    };
 
    static constexpr auto SIGNATURE_VALUE = 0xFEEF04BD;
    uint32_t signature = 0;

    uint32_t struct_version = 0;

    uint32_t file_version_ms = 0;

    uint32_t file_version_ls = 0;

    uint32_t product_version_ms = 0;

    uint32_t product_version_ls = 0;

    uint32_t file_flags_mask = 0;

    uint32_t file_flags = 0;

    uint32_t file_os = 0;

    uint32_t file_type = 0;

    uint32_t file_subtype = 0;

    uint32_t file_date_ms = 0;

    uint32_t file_date_ls = 0;

    bool has(FILE_FLAGS f) const {
      return ((file_flags & file_flags_mask) & (uint32_t)f) != 0;
    }

    std::vector<FILE_FLAGS> flags() const;
 
    FILE_TYPE_DETAILS file_type_details() const {
      if (file_subtype == 0) {
        return FILE_TYPE_DETAILS::UNKNOWN;
      }
 
      auto ty = FILE_TYPE(file_type);
      if (ty == FILE_TYPE::DRV) {
        return FILE_TYPE_DETAILS(file_subtype | DRV_K);
      }
 
      if (ty == FILE_TYPE::FONT) {
        return FILE_TYPE_DETAILS(file_subtype | FONT_K);
      }
 
      return FILE_TYPE_DETAILS::UNKNOWN;
    }
 
    std::string to_string() const;
 
    LIEF_API friend std::ostream& operator<<(std::ostream& os,
                                             const fixed_file_info_t& info) {
      os << info.to_string();
      return os;
    }
  };
 
  ResourceVersion(const ResourceVersion&) = default;
  ResourceVersion& operator=(const ResourceVersion&) = default;
 
  ResourceVersion(ResourceVersion&&) = default;
  ResourceVersion& operator=(ResourceVersion&&) = default;
 
  ~ResourceVersion() override = default;

  const fixed_file_info_t& file_info() const {
    return fixed_file_info_;
  }
 
  fixed_file_info_t& file_info() {
    return fixed_file_info_;
  }

  ResourceStringFileInfo* string_file_info() {
    if (auto& info = string_file_info_) {
      return &info.value();
    }
    return nullptr;
  }
 
  const ResourceStringFileInfo* string_file_info() const {
    return const_cast<ResourceVersion*>(this)->string_file_info();
  }

  ResourceVarFileInfo* var_file_info() {
    if (auto& info = var_file_info_) {
      return &info.value();
    }
    return nullptr;
  }

  uint16_t type() const {
    return type_;
  }

  const std::u16string& key() const {
    return key_;
  }

  std::string key_u8() const;
 
  ResourceVersion& type(uint16_t value) {
    type_ = value;
    return *this;
  }
 
  ResourceVersion& key(std::u16string value) {
    key_ = std::move(value);
    return *this;
  }
  const ResourceVarFileInfo* var_file_info() const {
    return const_cast<ResourceVersion*>(this)->var_file_info();
  }
 
  ResourceVersion& var_file_info(ResourceVarFileInfo info) {
    var_file_info_ = std::move(info);
    return *this;
  }
 
  ResourceVersion& string_file_info(ResourceStringFileInfo info) {
    string_file_info_ = std::move(info);
    return *this;
  }
 
  void accept(Visitor& visitor) const override;
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os,
                                           const ResourceVersion& version);
 
  private:
  ResourceVersion() = default;
 
  static ok_error_t parse_children(ResourceVersion& version, BinaryStream& stream);
  static ok_error_t parse_child(ResourceVersion& version, BinaryStream& stream);
  static ok_error_t parse_fixed_file_info(ResourceVersion& version,
                                          BinaryStream& stream);
  static ok_error_t parse_str_file_info(ResourceVersion& version,
                                        BinaryStream& stream);
  static ok_error_t parse_var_file_info(ResourceVersion& version,
                                        BinaryStream& stream);
 
  uint16_t type_ = 0;
  std::u16string key_;
  fixed_file_info_t fixed_file_info_;
 
  std::optional<ResourceStringFileInfo> string_file_info_;
  std::optional<ResourceVarFileInfo> var_file_info_;
};
 
LIEF_API const char* to_string(ResourceVersion::fixed_file_info_t::FILE_FLAGS e);
LIEF_API const char* to_string(ResourceVersion::fixed_file_info_t::VERSION_OS e);
LIEF_API const char* to_string(ResourceVersion::fixed_file_info_t::FILE_TYPE e);
LIEF_API const char*
    to_string(ResourceVersion::fixed_file_info_t::FILE_TYPE_DETAILS e);
 
}
}
 
#endif