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 "base/files/file_path.h"
  11 #include "base/logging.h"
  12 #include "base/threading/thread_restrictions.h"
  13 #include "base/win/resource_util.h"
  14
  15 using base::FilePath;
  16
  17 namespace {
  18
  19 struct LanguageAndCodePage {
  20   WORD language;
  21   WORD code_page;
  22 };
  23
  24 // Returns the \\VarFileInfo\\Translation value extracted from the
  25 // VS_VERSION_INFO resource in |data|.
  26 LanguageAndCodePage* GetTranslate(const void* data) {
  27   LanguageAndCodePage* translate = nullptr;
  28   UINT length;
  29   if (::VerQueryValue(data, L"\\VarFileInfo\\Translation",
  30                       reinterpret_cast<void**>(&translate), &length)) {
  31     return translate;
  32   }
  33   return nullptr;
  34 }
  35
  36 VS_FIXEDFILEINFO* GetVsFixedFileInfo(const void* data) {
  37   VS_FIXEDFILEINFO* fixed_file_info = nullptr;
  38   UINT length;
  39   if (::VerQueryValue(data, L"\\", reinterpret_cast<void**>(&fixed_file_info),
  40                       &length)) {
  41     return fixed_file_info;
  42   }
  43   return nullptr;
  44 }
  45
  46 }  // namespace
  47
  48 FileVersionInfoWin::~FileVersionInfoWin() = default;
  49
  50 // static
  51 FileVersionInfo* FileVersionInfo::CreateFileVersionInfoForModule(
  52     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 new FileVersionInfoWin(data, translate->language,
  65                                 translate->code_page);
  66 }
  67
  68 // static
  69 FileVersionInfo* FileVersionInfo::CreateFileVersionInfo(
  70     const FilePath& file_path) {
  71   base::AssertBlockingAllowed();
  72
  73   DWORD dummy;
  74   const wchar_t* path = file_path.value().c_str();
  75   const DWORD length = ::GetFileVersionInfoSize(path, &dummy);
  76   if (length == 0)
  77     return nullptr;
  78
  79   std::vector<uint8_t> data(length, 0);
  80
  81   if (!::GetFileVersionInfo(path, dummy, length, data.data()))
  82     return nullptr;
  83
  84   const LanguageAndCodePage* translate = GetTranslate(data.data());
  85   if (!translate)
  86     return nullptr;
  87
  88   return new FileVersionInfoWin(std::move(data), translate->language,
  89                                 translate->code_page);
  90 }
  91
  92 base::string16 FileVersionInfoWin::company_name() {
  93   return GetStringValue(L"CompanyName");
  94 }
  95
  96 base::string16 FileVersionInfoWin::company_short_name() {
  97   return GetStringValue(L"CompanyShortName");
  98 }
  99
 100 base::string16 FileVersionInfoWin::internal_name() {
 101   return GetStringValue(L"InternalName");
 102 }
 103
 104 base::string16 FileVersionInfoWin::product_name() {
 105   return GetStringValue(L"ProductName");
 106 }
 107
 108 base::string16 FileVersionInfoWin::product_short_name() {
 109   return GetStringValue(L"ProductShortName");
 110 }
 111
 112 base::string16 FileVersionInfoWin::comments() {
 113   return GetStringValue(L"Comments");
 114 }
 115
 116 base::string16 FileVersionInfoWin::legal_copyright() {
 117   return GetStringValue(L"LegalCopyright");
 118 }
 119
 120 base::string16 FileVersionInfoWin::product_version() {
 121   return GetStringValue(L"ProductVersion");
 122 }
 123
 124 base::string16 FileVersionInfoWin::file_description() {
 125   return GetStringValue(L"FileDescription");
 126 }
 127
 128 base::string16 FileVersionInfoWin::legal_trademarks() {
 129   return GetStringValue(L"LegalTrademarks");
 130 }
 131
 132 base::string16 FileVersionInfoWin::private_build() {
 133   return GetStringValue(L"PrivateBuild");
 134 }
 135
 136 base::string16 FileVersionInfoWin::file_version() {
 137   return GetStringValue(L"FileVersion");
 138 }
 139
 140 base::string16 FileVersionInfoWin::original_filename() {
 141   return GetStringValue(L"OriginalFilename");
 142 }
 143
 144 base::string16 FileVersionInfoWin::special_build() {
 145   return GetStringValue(L"SpecialBuild");
 146 }
 147
 148 base::string16 FileVersionInfoWin::last_change() {
 149   return GetStringValue(L"LastChange");
 150 }
 151
 152 bool FileVersionInfoWin::is_official_build() {
 153   return (GetStringValue(L"Official Build").compare(L"1") == 0);
 154 }
 155
 156 bool FileVersionInfoWin::GetValue(const wchar_t* name,
 157                                   std::wstring* value_str) {
 158   WORD lang_codepage[8];
 159   size_t i = 0;
 160   // Use the language and codepage from the DLL.
 161   lang_codepage[i++] = language_;
 162   lang_codepage[i++] = code_page_;
 163   // Use the default language and codepage from the DLL.
 164   lang_codepage[i++] = ::GetUserDefaultLangID();
 165   lang_codepage[i++] = code_page_;
 166   // Use the language from the DLL and Latin codepage (most common).
 167   lang_codepage[i++] = language_;
 168   lang_codepage[i++] = 1252;
 169   // Use the default language and Latin codepage (most common).
 170   lang_codepage[i++] = ::GetUserDefaultLangID();
 171   lang_codepage[i++] = 1252;
 172
 173   i = 0;
 174   while (i < arraysize(lang_codepage)) {
 175     wchar_t sub_block[MAX_PATH];
 176     WORD language = lang_codepage[i++];
 177     WORD code_page = lang_codepage[i++];
 178     _snwprintf_s(sub_block, MAX_PATH, MAX_PATH,
 179                  L"\\StringFileInfo\\%04x%04x\\%ls", language, code_page, name);
 180     LPVOID value = NULL;
 181     uint32_t size;
 182     BOOL r = ::VerQueryValue(data_, sub_block, &value, &size);
 183     if (r && value) {
 184       value_str->assign(static_cast<wchar_t*>(value));
 185       return true;
 186     }
 187   }
 188   return false;
 189 }
 190
 191 std::wstring FileVersionInfoWin::GetStringValue(const wchar_t* name) {
 192   std::wstring str;
 193   if (GetValue(name, &str))
 194     return str;
 195   else
 196     return L"";
 197 }
 198
 199 FileVersionInfoWin::FileVersionInfoWin(std::vector<uint8_t>&& data,
 200                                        WORD language,
 201                                        WORD code_page)
 202     : owned_data_(std::move(data)),
 203       data_(owned_data_.data()),
 204       language_(language),
 205       code_page_(code_page),
 206       fixed_file_info_(GetVsFixedFileInfo(data_)) {
 207   DCHECK(!owned_data_.empty());
 208 }
 209
 210 FileVersionInfoWin::FileVersionInfoWin(void* data,
 211                                        WORD language,
 212                                        WORD code_page)
 213     : data_(data),
 214       language_(language),
 215       code_page_(code_page),
 216       fixed_file_info_(GetVsFixedFileInfo(data)) {
 217   DCHECK(data_);
 218 }