base/file_version_info_win.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/file_version_info_win.h"
   6
   7 #include <windows.h>
   8 #include <stddef.h>
   9
  10 #include <utility>
  11
  12 #include "base/check.h"
  13 #include "base/files/file_path.h"
  14 #include "base/memory/ptr_util.h"
  15 #include "base/stl_util.h"
  16 #include "base/strings/string_util.h"
  17 #include "base/threading/scoped_blocking_call.h"
  18 #include "base/win/resource_util.h"
  19
  20 namespace {
  21
  22 struct LanguageAndCodePage {
  23   WORD language;
  24   WORD code_page;
  25 };
  26
  27 // Returns the \VarFileInfo\Translation value extracted from the
  28 // VS_VERSION_INFO resource in |data|.
  29 LanguageAndCodePage* GetTranslate(const void* data) {
  30   static constexpr wchar_t kTranslation[] = L"\\VarFileInfo\\Translation";
  31   LPVOID translate = nullptr;
  32   UINT dummy_size;
  33   if (::VerQueryValue(data, kTranslation, &translate, &dummy_size))
  34     return static_cast<LanguageAndCodePage*>(translate);
  35   return nullptr;
  36 }
  37
  38 const VS_FIXEDFILEINFO& GetVsFixedFileInfo(const void* data) {
  39   static constexpr wchar_t kRoot[] = L"\\";
  40   LPVOID fixed_file_info = nullptr;
  41   UINT dummy_size;
  42   CHECK(::VerQueryValue(data, kRoot, &fixed_file_info, &dummy_size));
  43   return *static_cast<VS_FIXEDFILEINFO*>(fixed_file_info);
  44 }
  45
  46 }  // namespace
  47
  48 FileVersionInfoWin::~FileVersionInfoWin() = default;
  49
  50 // static
  51 std::unique_ptr<FileVersionInfo>
  52 FileVersionInfo::CreateFileVersionInfoForModule(HMODULE module) {
  53   void* data;
  54   size_t version_info_length;
  55   const bool has_version_resource = base::win::GetResourceFromModule(
  56       module, VS_VERSION_INFO, RT_VERSION, &data, &version_info_length);
  57   if (!has_version_resource)
  58     return nullptr;
  59
  60   const LanguageAndCodePage* translate = GetTranslate(data);
  61   if (!translate)
  62     return nullptr;
  63
  64   return base::WrapUnique(
  65       new FileVersionInfoWin(data, translate->language, translate->code_page));
  66 }
  67
  68 // static
  69 std::unique_ptr<FileVersionInfo> FileVersionInfo::CreateFileVersionInfo(
  70     const base::FilePath& file_path) {
  71   return FileVersionInfoWin::CreateFileVersionInfoWin(file_path);
  72 }
  73
  74 // static
  75 std::unique_ptr<FileVersionInfoWin>
  76 FileVersionInfoWin::CreateFileVersionInfoWin(const base::FilePath& file_path) {
  77   base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
  78                                                 base::BlockingType::MAY_BLOCK);
  79
  80   DWORD dummy;
  81   const wchar_t* path = file_path.value().c_str();
  82   const DWORD length = ::GetFileVersionInfoSize(path, &dummy);
  83   if (length == 0)
  84     return nullptr;
  85
  86   std::vector<uint8_t> data(length, 0);
  87
  88   if (!::GetFileVersionInfo(path, dummy, length, data.data()))
  89     return nullptr;
  90
  91   const LanguageAndCodePage* translate = GetTranslate(data.data());
  92   if (!translate)
  93     return nullptr;
  94
  95   return base::WrapUnique(new FileVersionInfoWin(
  96       std::move(data), translate->language, translate->code_page));
  97 }
  98
  99 base::string16 FileVersionInfoWin::company_name() {
 100   return GetStringValue(STRING16_LITERAL("CompanyName"));
 101 }
 102
 103 base::string16 FileVersionInfoWin::company_short_name() {
 104   return GetStringValue(STRING16_LITERAL("CompanyShortName"));
 105 }
 106
 107 base::string16 FileVersionInfoWin::internal_name() {
 108   return GetStringValue(STRING16_LITERAL("InternalName"));
 109 }
 110
 111 base::string16 FileVersionInfoWin::product_name() {
 112   return GetStringValue(STRING16_LITERAL("ProductName"));
 113 }
 114
 115 base::string16 FileVersionInfoWin::product_short_name() {
 116   return GetStringValue(STRING16_LITERAL("ProductShortName"));
 117 }
 118
 119 base::string16 FileVersionInfoWin::product_version() {
 120   return GetStringValue(STRING16_LITERAL("ProductVersion"));
 121 }
 122
 123 base::string16 FileVersionInfoWin::file_description() {
 124   return GetStringValue(STRING16_LITERAL("FileDescription"));
 125 }
 126
 127 base::string16 FileVersionInfoWin::file_version() {
 128   return GetStringValue(STRING16_LITERAL("FileVersion"));
 129 }
 130
 131 base::string16 FileVersionInfoWin::original_filename() {
 132   return GetStringValue(STRING16_LITERAL("OriginalFilename"));
 133 }
 134
 135 base::string16 FileVersionInfoWin::special_build() {
 136   return GetStringValue(STRING16_LITERAL("SpecialBuild"));
 137 }
 138
 139 bool FileVersionInfoWin::GetValue(const base::char16* name,
 140                                   base::string16* value) const {
 141   const struct LanguageAndCodePage lang_codepages[] = {
 142       // Use the language and codepage from the DLL.
 143       {language_, code_page_},
 144       // Use the default language and codepage from the DLL.
 145       {::GetUserDefaultLangID(), code_page_},
 146       // Use the language from the DLL and Latin codepage (most common).
 147       {language_, 1252},
 148       // Use the default language and Latin codepage (most common).
 149       {::GetUserDefaultLangID(), 1252},
 150   };
 151
 152   for (const auto& lang_codepage : lang_codepages) {
 153     wchar_t sub_block[MAX_PATH];
 154     _snwprintf_s(sub_block, MAX_PATH, MAX_PATH,
 155                  L"\\StringFileInfo\\%04x%04x\\%ls", lang_codepage.language,
 156                  lang_codepage.code_page, base::as_wcstr(name));
 157     LPVOID value_ptr = nullptr;
 158     uint32_t size;
 159     BOOL r = ::VerQueryValue(data_, sub_block, &value_ptr, &size);
 160     if (r && value_ptr && size) {
 161       value->assign(static_cast<base::char16*>(value_ptr), size - 1);
 162       return true;
 163     }
 164   }
 165   return false;
 166 }
 167
 168 base::string16 FileVersionInfoWin::GetStringValue(
 169     const base::char16* name) const {
 170   base::string16 str;
 171   GetValue(name, &str);
 172   return str;
 173 }
 174
 175 base::Version FileVersionInfoWin::GetFileVersion() const {
 176   return base::Version({HIWORD(fixed_file_info_.dwFileVersionMS),
 177                         LOWORD(fixed_file_info_.dwFileVersionMS),
 178                         HIWORD(fixed_file_info_.dwFileVersionLS),
 179                         LOWORD(fixed_file_info_.dwFileVersionLS)});
 180 }
 181
 182 FileVersionInfoWin::FileVersionInfoWin(std::vector<uint8_t>&& data,
 183                                        WORD language,
 184                                        WORD code_page)
 185     : owned_data_(std::move(data)),
 186       data_(owned_data_.data()),
 187       language_(language),
 188       code_page_(code_page),
 189       fixed_file_info_(GetVsFixedFileInfo(data_)) {
 190   DCHECK(!owned_data_.empty());
 191 }
 192
 193 FileVersionInfoWin::FileVersionInfoWin(void* data,
 194                                        WORD language,
 195                                        WORD code_page)
 196     : data_(data),
 197       language_(language),
 198       code_page_(code_page),
 199       fixed_file_info_(GetVsFixedFileInfo(data)) {
 200   DCHECK(data_);
 201 }