chrome/browser/component_updater/pepper_flash_component_installer.cc

   1 // Copyright (c) 2013 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 "chrome/browser/component_updater/flash_component_installer.h"
   6
   7 #include <string.h>
   8
   9 #include <vector>
  10
  11 #include "base/base_paths.h"
  12 #include "base/bind.h"
  13 #include "base/command_line.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/file_util.h"
  16 #include "base/files/file_enumerator.h"
  17 #include "base/files/file_path.h"
  18 #include "base/logging.h"
  19 #include "base/path_service.h"
  20 #include "base/strings/string_split.h"
  21 #include "base/strings/string_util.h"
  22 #include "base/strings/stringprintf.h"
  23 #include "base/strings/utf_string_conversions.h"
  24 #include "base/values.h"
  25 #include "base/version.h"
  26 #include "build/build_config.h"
  27 #include "chrome/browser/component_updater/component_updater_service.h"
  28 #include "chrome/browser/component_updater/ppapi_utils.h"
  29 #include "chrome/browser/plugins/plugin_prefs.h"
  30 #include "chrome/common/chrome_constants.h"
  31 #include "chrome/common/chrome_paths.h"
  32 #include "chrome/common/chrome_switches.h"
  33 #include "chrome/common/pepper_flash.h"
  34 #include "content/public/browser/browser_thread.h"
  35 #include "content/public/browser/plugin_service.h"
  36 #include "content/public/common/content_constants.h"
  37 #include "content/public/common/pepper_plugin_info.h"
  38 #include "ppapi/c/private/ppb_pdf.h"
  39 #include "ppapi/shared_impl/ppapi_permissions.h"
  40
  41 #include "flapper_version.h"  // In SHARED_INTERMEDIATE_DIR.
  42
  43 using content::BrowserThread;
  44 using content::PluginService;
  45
  46 namespace component_updater {
  47
  48 namespace {
  49
  50 // File name of the Pepper Flash component manifest on different platforms.
  51 const char kPepperFlashManifestName[] = "Flapper";
  52
  53 #if defined(GOOGLE_CHROME_BUILD) && !defined(OS_LINUX)
  54 // CRX hash. The extension id is: mimojjlkmoijpicakmndhoigimigcmbb.
  55 const uint8 kSha2Hash[] = {0xc8, 0xce, 0x99, 0xba, 0xce, 0x89, 0xf8, 0x20,
  56                            0xac, 0xd3, 0x7e, 0x86, 0x8c, 0x86, 0x2c, 0x11,
  57                            0xb9, 0x40, 0xc5, 0x55, 0xaf, 0x08, 0x63, 0x70,
  58                            0x54, 0xf9, 0x56, 0xd3, 0xe7, 0x88, 0xba, 0x8c};
  59
  60 // If we don't have a Pepper Flash component, this is the version we claim.
  61 const char kNullVersion[] = "0.0.0.0";
  62
  63 #endif  // defined(GOOGLE_CHROME_BUILD) && !defined(OS_LINUX)
  64
  65 // Name of the Pepper Flash OS in the component manifest.
  66 const char kPepperFlashOperatingSystem[] =
  67 #if defined(OS_MACOSX)
  68     "mac";
  69 #elif defined(OS_WIN)
  70     "win";
  71 #else  // OS_LINUX, etc. TODO(viettrungluu): Separate out Chrome OS and Android?
  72     "linux";
  73 #endif
  74
  75 // Name of the Pepper Flash architecture in the component manifest.
  76 const char kPepperFlashArch[] =
  77 #if defined(ARCH_CPU_X86)
  78     "ia32";
  79 #elif defined(ARCH_CPU_X86_64)
  80     "x64";
  81 #else  // TODO(viettrungluu): Support an ARM check?
  82     "???";
  83 #endif
  84
  85 // The base directory on Windows looks like:
  86 // <profile>\AppData\Local\Google\Chrome\User Data\PepperFlash\.
  87 base::FilePath GetPepperFlashBaseDirectory() {
  88   base::FilePath result;
  89   PathService::Get(chrome::DIR_COMPONENT_UPDATED_PEPPER_FLASH_PLUGIN, &result);
  90   return result;
  91 }
  92
  93 #if defined(GOOGLE_CHROME_BUILD) && !defined(OS_LINUX)
  94 // Install directory for pepper flash debugger dlls will be like
  95 // c:\windows\system32\macromed\flash\, or basically the Macromed\Flash
  96 // subdirectory of the Windows system directory.
  97 base::FilePath GetPepperFlashDebuggerDirectory() {
  98   base::FilePath result;
  99   PathService::Get(chrome::DIR_PEPPER_FLASH_DEBUGGER_PLUGIN, &result);
 100   return result;
 101 }
 102
 103 // Pepper Flash plugins have the version encoded in the path itself
 104 // so we need to enumerate the directories to find the full path.
 105 // On success, |latest_dir| returns something like:
 106 // <profile>\AppData\Local\Google\Chrome\User Data\PepperFlash\10.3.44.555\.
 107 // |latest_version| returns the corresponding version number. |older_dirs|
 108 // returns directories of all older versions.
 109 bool GetPepperFlashDirectory(base::FilePath* latest_dir,
 110                              Version* latest_version,
 111                              std::vector<base::FilePath>* older_dirs) {
 112   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 113   base::FilePath base_dir = GetPepperFlashBaseDirectory();
 114   bool found = false;
 115   base::FileEnumerator
 116       file_enumerator(base_dir, false, base::FileEnumerator::DIRECTORIES);
 117   for (base::FilePath path = file_enumerator.Next(); !path.value().empty();
 118        path = file_enumerator.Next()) {
 119     Version version(path.BaseName().MaybeAsASCII());
 120     if (!version.IsValid())
 121       continue;
 122     if (found) {
 123       if (version.CompareTo(*latest_version) > 0) {
 124         older_dirs->push_back(*latest_dir);
 125         *latest_dir = path;
 126         *latest_version = version;
 127       } else {
 128         older_dirs->push_back(path);
 129       }
 130     } else {
 131       *latest_dir = path;
 132       *latest_version = version;
 133       found = true;
 134     }
 135   }
 136   return found;
 137 }
 138
 139 #if defined(OS_WIN)
 140 const wchar_t kPepperFlashDebuggerDLLSearchString[] =
 141 #if defined(ARCH_CPU_X86)
 142     L"pepflashplayer32*.dll";
 143 #elif defined(ARCH_CPU_X86_64)
 144     L"pepflashplayer64*.dll";
 145 #else
 146 #error Unsupported Windows CPU architecture.
 147 #endif  // defined(ARCH_CPU_X86)
 148 #endif  // defined(OS_WIN)
 149
 150 bool GetPepperFlashDebuggerPath(base::FilePath* dll_path,
 151                                 Version* dll_version) {
 152   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 153   base::FilePath debugger_dir = GetPepperFlashDebuggerDirectory();
 154   // If path doesn't exist they simply don't have the flash debugger installed.
 155   if (!base::PathExists(debugger_dir))
 156     return false;
 157
 158   bool found = false;
 159 #if defined(OS_WIN)
 160   // Enumerate any DLLs that match the appropriate pattern for this DLL, and
 161   // pick the highest version number we find.
 162   base::FileEnumerator file_enumerator(debugger_dir,
 163                                        false,
 164                                        base::FileEnumerator::FILES,
 165                                        kPepperFlashDebuggerDLLSearchString);
 166   for (base::FilePath path = file_enumerator.Next(); !path.value().empty();
 167        path = file_enumerator.Next()) {
 168     // Version number is embedded in file name like basename_x_y_z.dll. Extract.
 169     std::string file_name(path.BaseName().RemoveExtension().MaybeAsASCII());
 170     // file_name should now be basename_x_y_z. Split along '_' for version.
 171     std::vector<std::string> components;
 172     base::SplitString(file_name, '_', &components);
 173     // Should have at least one version number.
 174     if (components.size() <= 1)
 175       continue;
 176     // Meld version components back into a string, now separated by periods, so
 177     // Version can parse it.
 178     std::string version_string(components[1]);
 179     for (size_t i = 2; i < components.size(); ++i) {
 180       version_string += "." + components[i];
 181     }
 182     Version version(version_string);
 183     if (!version.IsValid())
 184       continue;
 185     if (found) {
 186       if (version.CompareTo(*dll_version) > 0) {
 187         *dll_path = path;
 188         *dll_version = version;
 189       }
 190     } else {
 191       *dll_path = path;
 192       *dll_version = version;
 193       found = true;
 194     }
 195   }
 196 #endif
 197   return found;
 198 }
 199 #endif  // defined(GOOGLE_CHROME_BUILD) && !defined(OS_LINUX)
 200
 201 // Returns true if the Pepper |interface_name| is implemented  by this browser.
 202 // It does not check if the interface is proxied.
 203 bool SupportsPepperInterface(const char* interface_name) {
 204   if (IsSupportedPepperInterface(interface_name))
 205     return true;
 206   // The PDF interface is invisible to SupportsInterface() on the browser
 207   // process because it is provided using PpapiInterfaceFactoryManager. We need
 208   // to check for that as well.
 209   // TODO(cpu): make this more sane.
 210   return (strcmp(interface_name, PPB_PDF_INTERFACE) == 0);
 211 }
 212
 213 bool MakePepperFlashPluginInfo(const base::FilePath& flash_path,
 214                                const Version& flash_version,
 215                                bool out_of_process,
 216                                bool is_debugger,
 217                                content::PepperPluginInfo* plugin_info) {
 218   if (!flash_version.IsValid())
 219     return false;
 220   const std::vector<uint16> ver_nums = flash_version.components();
 221   if (ver_nums.size() < 3)
 222     return false;
 223
 224   plugin_info->is_internal = false;
 225   plugin_info->is_out_of_process = out_of_process;
 226   plugin_info->path = flash_path;
 227   plugin_info->name = content::kFlashPluginName;
 228   plugin_info->permissions = kPepperFlashPermissions;
 229
 230   // The description is like "Shockwave Flash 10.2 r154".
 231   plugin_info->description = base::StringPrintf("%s %d.%d r%d",
 232       content::kFlashPluginName, ver_nums[0], ver_nums[1], ver_nums[2]);
 233   if (is_debugger) {
 234     plugin_info->description += " Debug";
 235   }
 236
 237   plugin_info->version = flash_version.GetString();
 238
 239   content::WebPluginMimeType swf_mime_type(content::kFlashPluginSwfMimeType,
 240                                            content::kFlashPluginSwfExtension,
 241                                            content::kFlashPluginName);
 242   plugin_info->mime_types.push_back(swf_mime_type);
 243   content::WebPluginMimeType spl_mime_type(content::kFlashPluginSplMimeType,
 244                                            content::kFlashPluginSplExtension,
 245                                            content::kFlashPluginName);
 246   plugin_info->mime_types.push_back(spl_mime_type);
 247   return true;
 248 }
 249
 250 bool IsPepperFlash(const content::WebPluginInfo& plugin) {
 251   // We try to recognize Pepper Flash by the following criteria:
 252   // * It is a Pepper plug-in.
 253   // * It has the special Flash permissions.
 254   return plugin.is_pepper_plugin() &&
 255          (plugin.pepper_permissions & ppapi::PERMISSION_FLASH);
 256 }
 257
 258 void RegisterPepperFlashWithChrome(const base::FilePath& path,
 259                                    const Version& version,
 260                                    bool is_debugger) {
 261   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 262   content::PepperPluginInfo plugin_info;
 263   if (!MakePepperFlashPluginInfo(
 264           path, version, true, is_debugger, &plugin_info))
 265     return;
 266
 267   // If this is the non-debugger version, we enumerate any installed versions of
 268   // pepper flash to make sure we only replace the installed version with a
 269   // newer version.
 270   if (!is_debugger) {
 271     std::vector<content::WebPluginInfo> plugins;
 272     PluginService::GetInstance()->GetInternalPlugins(&plugins);
 273     for (std::vector<content::WebPluginInfo>::const_iterator it =
 274              plugins.begin();
 275          it != plugins.end();
 276          ++it) {
 277       if (!IsPepperFlash(*it))
 278         continue;
 279
 280       // Do it only if the version we're trying to register is newer.
 281       Version registered_version(base::UTF16ToUTF8(it->version));
 282       if (registered_version.IsValid() &&
 283           version.CompareTo(registered_version) <= 0) {
 284         return;
 285       }
 286
 287       // If the version is newer, remove the old one first.
 288       PluginService::GetInstance()->UnregisterInternalPlugin(it->path);
 289       break;
 290     }
 291   }
 292
 293   // We only ask for registration at the beginning for the non-debugger plugin,
 294   // that way the debugger plugin doesn't automatically clobber the built-in or
 295   // updated non-debugger version.
 296   PluginService::GetInstance()->RegisterInternalPlugin(
 297       plugin_info.ToWebPluginInfo(), !is_debugger);
 298   PluginService::GetInstance()->RefreshPlugins();
 299 }
 300
 301 // Returns true if this browser implements one of the interfaces given in
 302 // |interface_string|, which is a '|'-separated string of interface names.
 303 bool CheckPepperFlashInterfaceString(const std::string& interface_string) {
 304   std::vector<std::string> interface_names;
 305   base::SplitString(interface_string, '|', &interface_names);
 306   for (size_t i = 0; i < interface_names.size(); i++) {
 307     if (SupportsPepperInterface(interface_names[i].c_str()))
 308       return true;
 309   }
 310   return false;
 311 }
 312
 313 // Returns true if this browser implements all the interfaces that Flash
 314 // specifies in its component installer manifest.
 315 bool CheckPepperFlashInterfaces(const base::DictionaryValue& manifest) {
 316   const base::ListValue* interface_list = NULL;
 317
 318   // We don't *require* an interface list, apparently.
 319   if (!manifest.GetList("x-ppapi-required-interfaces", &interface_list))
 320     return true;
 321
 322   for (size_t i = 0; i < interface_list->GetSize(); i++) {
 323     std::string interface_string;
 324     if (!interface_list->GetString(i, &interface_string))
 325       return false;
 326     if (!CheckPepperFlashInterfaceString(interface_string))
 327       return false;
 328   }
 329
 330   return true;
 331 }
 332
 333 }  // namespace
 334
 335 class PepperFlashComponentInstaller : public ComponentInstaller {
 336  public:
 337   explicit PepperFlashComponentInstaller(const Version& version);
 338
 339   virtual ~PepperFlashComponentInstaller() {}
 340
 341   virtual void OnUpdateError(int error) OVERRIDE;
 342
 343   virtual bool Install(const base::DictionaryValue& manifest,
 344                        const base::FilePath& unpack_path) OVERRIDE;
 345
 346   virtual bool GetInstalledFile(const std::string& file,
 347                                 base::FilePath* installed_file) OVERRIDE;
 348
 349  private:
 350   Version current_version_;
 351 };
 352
 353 PepperFlashComponentInstaller::PepperFlashComponentInstaller(
 354     const Version& version) : current_version_(version) {
 355   DCHECK(version.IsValid());
 356 }
 357
 358 void PepperFlashComponentInstaller::OnUpdateError(int error) {
 359   NOTREACHED() << "Pepper Flash update error: " << error;
 360 }
 361
 362 bool PepperFlashComponentInstaller::Install(
 363     const base::DictionaryValue& manifest,
 364     const base::FilePath& unpack_path) {
 365   Version version;
 366   if (!CheckPepperFlashManifest(manifest, &version))
 367     return false;
 368   if (current_version_.CompareTo(version) > 0)
 369     return false;
 370   if (!base::PathExists(unpack_path.Append(
 371           chrome::kPepperFlashPluginFilename)))
 372     return false;
 373   // Passed the basic tests. Time to install it.
 374   base::FilePath path =
 375       GetPepperFlashBaseDirectory().AppendASCII(version.GetString());
 376   if (base::PathExists(path))
 377     return false;
 378   if (!base::Move(unpack_path, path))
 379     return false;
 380   // Installation is done. Now tell the rest of chrome. Both the path service
 381   // and to the plugin service.
 382   current_version_ = version;
 383   PathService::Override(chrome::DIR_PEPPER_FLASH_PLUGIN, path);
 384   path = path.Append(chrome::kPepperFlashPluginFilename);
 385   BrowserThread::PostTask(
 386       BrowserThread::UI,
 387       FROM_HERE,
 388       base::Bind(&RegisterPepperFlashWithChrome, path, version, false));
 389   return true;
 390 }
 391
 392 bool PepperFlashComponentInstaller::GetInstalledFile(
 393     const std::string& file, base::FilePath* installed_file) {
 394   return false;
 395 }
 396
 397 bool CheckPepperFlashManifest(const base::DictionaryValue& manifest,
 398                               Version* version_out) {
 399   std::string name;
 400   manifest.GetStringASCII("name", &name);
 401   // TODO(viettrungluu): Support WinFlapper for now, while we change the format
 402   // of the manifest. (Should be safe to remove checks for "WinFlapper" in, say,
 403   // Nov. 2011.)  crbug.com/98458
 404   if (name != kPepperFlashManifestName && name != "WinFlapper")
 405     return false;
 406
 407   std::string proposed_version;
 408   manifest.GetStringASCII("version", &proposed_version);
 409   Version version(proposed_version.c_str());
 410   if (!version.IsValid())
 411     return false;
 412
 413   if (!CheckPepperFlashInterfaces(manifest))
 414     return false;
 415
 416   // TODO(viettrungluu): See above TODO.
 417   if (name == "WinFlapper") {
 418     *version_out = version;
 419     return true;
 420   }
 421
 422   std::string os;
 423   manifest.GetStringASCII("x-ppapi-os", &os);
 424   if (os != kPepperFlashOperatingSystem)
 425     return false;
 426
 427   std::string arch;
 428   manifest.GetStringASCII("x-ppapi-arch", &arch);
 429   if (arch != kPepperFlashArch)
 430     return false;
 431
 432   *version_out = version;
 433   return true;
 434 }
 435
 436 namespace {
 437
 438 #if defined(GOOGLE_CHROME_BUILD) && !defined(OS_LINUX)
 439 void FinishPepperFlashUpdateRegistration(ComponentUpdateService* cus,
 440                                          const Version& version) {
 441   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 442   CrxComponent pepflash;
 443   pepflash.name = "pepper_flash";
 444   pepflash.installer = new PepperFlashComponentInstaller(version);
 445   pepflash.version = version;
 446   pepflash.pk_hash.assign(kSha2Hash, &kSha2Hash[sizeof(kSha2Hash)]);
 447   if (cus->RegisterComponent(pepflash) != ComponentUpdateService::kOk) {
 448     NOTREACHED() << "Pepper Flash component registration failed.";
 449   }
 450 }
 451
 452 void StartPepperFlashUpdateRegistration(ComponentUpdateService* cus) {
 453   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 454   base::FilePath path = GetPepperFlashBaseDirectory();
 455   if (!base::PathExists(path)) {
 456     if (!base::CreateDirectory(path)) {
 457       NOTREACHED() << "Could not create Pepper Flash directory.";
 458       return;
 459     }
 460   }
 461
 462   Version version(kNullVersion);
 463   std::vector<base::FilePath> older_dirs;
 464   if (GetPepperFlashDirectory(&path, &version, &older_dirs)) {
 465     path = path.Append(chrome::kPepperFlashPluginFilename);
 466     if (base::PathExists(path)) {
 467       BrowserThread::PostTask(
 468           BrowserThread::UI,
 469           FROM_HERE,
 470           base::Bind(&RegisterPepperFlashWithChrome, path, version, false));
 471     } else {
 472       version = Version(kNullVersion);
 473     }
 474   }
 475
 476   BrowserThread::PostTask(
 477       BrowserThread::UI, FROM_HERE,
 478       base::Bind(&FinishPepperFlashUpdateRegistration, cus, version));
 479
 480   // Remove older versions of Pepper Flash.
 481   for (std::vector<base::FilePath>::iterator iter = older_dirs.begin();
 482        iter != older_dirs.end(); ++iter) {
 483     base::DeleteFile(*iter, true);
 484   }
 485
 486   // Check for Debugging version of Flash and register if present.
 487   base::FilePath debugger_path;
 488   Version debugger_version(kNullVersion);
 489   if (GetPepperFlashDebuggerPath(&debugger_path, &debugger_version)) {
 490     BrowserThread::PostTask(BrowserThread::UI,
 491                             FROM_HERE,
 492                             base::Bind(&RegisterPepperFlashWithChrome,
 493                                        debugger_path,
 494                                        debugger_version,
 495                                        true));
 496   }
 497 }
 498 #endif  // defined(GOOGLE_CHROME_BUILD) && !defined(OS_LINUX)
 499
 500 }  // namespace
 501
 502 void RegisterPepperFlashComponent(ComponentUpdateService* cus) {
 503   #if defined(GOOGLE_CHROME_BUILD) && !defined(OS_LINUX)
 504   // Component updated flash supersedes bundled flash therefore if that one
 505   // is disabled then this one should never install.
 506   CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 507   if (cmd_line->HasSwitch(switches::kDisableBundledPpapiFlash))
 508     return;
 509   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 510                           base::Bind(&StartPepperFlashUpdateRegistration, cus));
 511   #endif
 512 }
 513
 514 }  // namespace component_updater
 515