base/file_version_info_win.cc

   1 // Copyright 2011 The Chromium Authors
   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
   9 #include <stddef.h>
  10
  11 #include <utility>
  12
  13 #include "base/check.h"
  14 #include "base/files/file_path.h"
  15 #include "base/memory/ptr_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 std::u16string FileVersionInfoWin::company_name() {
 100   return GetStringValue(u"CompanyName");
 101 }
 102
 103 std::u16string FileVersionInfoWin::company_short_name() {
 104   return GetStringValue(u"CompanyShortName");
 105 }
 106
 107 std::u16string FileVersionInfoWin::internal_name() {
 108   return GetStringValue(u"InternalName");
 109 }
 110
 111 std::u16string FileVersionInfoWin::product_name() {
 112   return GetStringValue(u"ProductName");
 113 }
 114
 115 std::u16string FileVersionInfoWin::product_short_name() {
 116   return GetStringValue(u"ProductShortName");
 117 }
 118
 119 std::u16string FileVersionInfoWin::product_version() {
 120   return GetStringValue(u"ProductVersion");
 121 }
 122
 123 std::u16string FileVersionInfoWin::file_description() {
 124   return GetStringValue(u"FileDescription");
 125 }
 126
 127 std::u16string FileVersionInfoWin::file_version() {
 128   return GetStringValue(u"FileVersion");
 129 }
 130
 131 std::u16string FileVersionInfoWin::original_filename() {
 132   return GetStringValue(u"OriginalFilename");
 133 }
 134
 135 std::u16string FileVersionInfoWin::special_build() {
 136   return GetStringValue(u"SpecialBuild");
 137 }
 138
 139 bool FileVersionInfoWin::GetValue(const char16_t* name,
 140                                   std::u16string* 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<char16_t*>(value_ptr), size - 1);
 162       return true;
 163     }
 164   }
 165   return false;
 166 }
 167
 168 std::u16string FileVersionInfoWin::GetStringValue(const char16_t* name) const {
 169   std::u16string str;
 170   GetValue(name, &str);
 171   return str;
 172 }
 173
 174 base::Version FileVersionInfoWin::GetFileVersion() const {
 175   return base::Version({HIWORD(fixed_file_info_->dwFileVersionMS),
 176                         LOWORD(fixed_file_info_->dwFileVersionMS),
 177                         HIWORD(fixed_file_info_->dwFileVersionLS),
 178                         LOWORD(fixed_file_info_->dwFileVersionLS)});
 179 }
 180
 181 FileVersionInfoWin::FileVersionInfoWin(std::vector<uint8_t>&& data,
 182                                        WORD language,
 183                                        WORD code_page)
 184     : owned_data_(std::move(data)),
 185       data_(owned_data_.data()),
 186       language_(language),
 187       code_page_(code_page),
 188       fixed_file_info_(GetVsFixedFileInfo(data_)) {
 189   DCHECK(!owned_data_.empty());
 190 }
 191
 192 FileVersionInfoWin::FileVersionInfoWin(void* data,
 193                                        WORD language,
 194                                        WORD code_page)
 195     : data_(data),
 196       language_(language),
 197       code_page_(code_page),
 198       fixed_file_info_(GetVsFixedFileInfo(data)) {
 199   DCHECK(data_);
 200 }