dom/base/nsPluginArray.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsPluginArray.h"
   7
   8 #include "mozilla/Preferences.h"
   9 #include "mozilla/dom/PluginArrayBinding.h"
  10 #include "mozilla/dom/PluginBinding.h"
  11
  12 #include "nsCharSeparatedTokenizer.h"
  13 #include "nsMimeTypeArray.h"
  14 #include "Navigator.h"
  15 #include "nsIDocShell.h"
  16 #include "nsIWebNavigation.h"
  17 #include "nsPluginHost.h"
  18 #include "nsPluginTags.h"
  19 #include "nsIObserverService.h"
  20 #include "nsIWeakReference.h"
  21 #include "mozilla/Services.h"
  22 #include "nsIInterfaceRequestorUtils.h"
  23
  24 using namespace mozilla;
  25 using namespace mozilla::dom;
  26
  27 nsPluginArray::nsPluginArray(nsPIDOMWindow* aWindow)
  28   : mWindow(aWindow)
  29 {
  30   SetIsDOMBinding();
  31 }
  32
  33 void
  34 nsPluginArray::Init()
  35 {
  36   nsCOMPtr<nsIObserverService> obsService =
  37     mozilla::services::GetObserverService();
  38   if (obsService) {
  39     obsService->AddObserver(this, "plugin-info-updated", true);
  40   }
  41 }
  42
  43 nsPluginArray::~nsPluginArray()
  44 {
  45 }
  46
  47 nsPIDOMWindow*
  48 nsPluginArray::GetParentObject() const
  49 {
  50   MOZ_ASSERT(mWindow);
  51   return mWindow;
  52 }
  53
  54 JSObject*
  55 nsPluginArray::WrapObject(JSContext* aCx)
  56 {
  57   return PluginArrayBinding::Wrap(aCx, this);
  58 }
  59
  60 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPluginArray)
  61 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPluginArray)
  62 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPluginArray)
  63   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  64   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)
  65   NS_INTERFACE_MAP_ENTRY(nsIObserver)
  66   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
  67 NS_INTERFACE_MAP_END
  68
  69 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsPluginArray,
  70                                       mWindow,
  71                                       mPlugins,
  72                                       mHiddenPlugins)
  73
  74 static void
  75 GetPluginMimeTypes(const nsTArray<nsRefPtr<nsPluginElement> >& aPlugins,
  76                    nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes)
  77 {
  78   for (uint32_t i = 0; i < aPlugins.Length(); ++i) {
  79     nsPluginElement *plugin = aPlugins[i];
  80     aMimeTypes.AppendElements(plugin->MimeTypes());
  81   }
  82 }
  83
  84 static bool
  85 operator<(const nsRefPtr<nsMimeType>& lhs, const nsRefPtr<nsMimeType>& rhs)
  86 {
  87   // Sort MIME types alphabetically by type name.
  88   return lhs->Type() < rhs->Type();
  89 }
  90
  91 void
  92 nsPluginArray::GetMimeTypes(nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes,
  93                             nsTArray<nsRefPtr<nsMimeType> >& aHiddenMimeTypes)
  94 {
  95   aMimeTypes.Clear();
  96   aHiddenMimeTypes.Clear();
  97
  98   if (!AllowPlugins()) {
  99     return;
 100   }
 101
 102   EnsurePlugins();
 103
 104   GetPluginMimeTypes(mPlugins, aMimeTypes);
 105   GetPluginMimeTypes(mHiddenPlugins, aHiddenMimeTypes);
 106
 107   // Alphabetize the enumeration order of non-hidden MIME types to reduce
 108   // fingerprintable entropy based on plugins' installation file times.
 109   aMimeTypes.Sort();
 110 }
 111
 112 nsPluginElement*
 113 nsPluginArray::Item(uint32_t aIndex)
 114 {
 115   bool unused;
 116   return IndexedGetter(aIndex, unused);
 117 }
 118
 119 nsPluginElement*
 120 nsPluginArray::NamedItem(const nsAString& aName)
 121 {
 122   bool unused;
 123   return NamedGetter(aName, unused);
 124 }
 125
 126 void
 127 nsPluginArray::Refresh(bool aReloadDocuments)
 128 {
 129   nsRefPtr<nsPluginHost> pluginHost = nsPluginHost::GetInst();
 130
 131   if(!AllowPlugins() || !pluginHost) {
 132     return;
 133   }
 134
 135   // NS_ERROR_PLUGINS_PLUGINSNOTCHANGED on reloading plugins indicates
 136   // that plugins did not change and was not reloaded
 137   if (pluginHost->ReloadPlugins() ==
 138       NS_ERROR_PLUGINS_PLUGINSNOTCHANGED) {
 139     nsTArray<nsRefPtr<nsPluginTag> > newPluginTags;
 140     pluginHost->GetPlugins(newPluginTags);
 141
 142     // Check if the number of plugins we know about are different from
 143     // the number of plugin tags the plugin host knows about. If the
 144     // lengths are different, we refresh. This is safe because we're
 145     // notified for every plugin enabling/disabling event that
 146     // happens, and therefore the lengths will be in sync only when
 147     // the both arrays contain the same plugin tags (though as
 148     // different types).
 149     uint32_t pluginCount = mPlugins.Length() + mHiddenPlugins.Length();
 150     if (newPluginTags.Length() == pluginCount) {
 151       return;
 152     }
 153   }
 154
 155   mPlugins.Clear();
 156   mHiddenPlugins.Clear();
 157
 158   nsCOMPtr<nsIDOMNavigator> navigator;
 159   mWindow->GetNavigator(getter_AddRefs(navigator));
 160
 161   if (!navigator) {
 162     return;
 163   }
 164
 165   static_cast<mozilla::dom::Navigator*>(navigator.get())->RefreshMIMEArray();
 166
 167   nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(mWindow);
 168   if (aReloadDocuments && webNav) {
 169     webNav->Reload(nsIWebNavigation::LOAD_FLAGS_NONE);
 170   }
 171 }
 172
 173 nsPluginElement*
 174 nsPluginArray::IndexedGetter(uint32_t aIndex, bool &aFound)
 175 {
 176   aFound = false;
 177
 178   if (!AllowPlugins()) {
 179     return nullptr;
 180   }
 181
 182   EnsurePlugins();
 183
 184   aFound = aIndex < mPlugins.Length();
 185
 186   return aFound ? mPlugins[aIndex] : nullptr;
 187 }
 188
 189 void
 190 nsPluginArray::Invalidate()
 191 {
 192   nsCOMPtr<nsIObserverService> obsService =
 193     mozilla::services::GetObserverService();
 194   if (obsService) {
 195     obsService->RemoveObserver(this, "plugin-info-updated");
 196   }
 197 }
 198
 199 static nsPluginElement*
 200 FindPlugin(const nsTArray<nsRefPtr<nsPluginElement> >& aPlugins,
 201            const nsAString& aName)
 202 {
 203   for (uint32_t i = 0; i < aPlugins.Length(); ++i) {
 204     nsAutoString pluginName;
 205     nsPluginElement* plugin = aPlugins[i];
 206     plugin->GetName(pluginName);
 207
 208     if (pluginName.Equals(aName)) {
 209       return plugin;
 210     }
 211   }
 212
 213   return nullptr;
 214 }
 215
 216 nsPluginElement*
 217 nsPluginArray::NamedGetter(const nsAString& aName, bool &aFound)
 218 {
 219   aFound = false;
 220
 221   if (!AllowPlugins()) {
 222     return nullptr;
 223   }
 224
 225   EnsurePlugins();
 226
 227   nsPluginElement* plugin = FindPlugin(mPlugins, aName);
 228   if (!plugin) {
 229     plugin = FindPlugin(mHiddenPlugins, aName);
 230   }
 231
 232   aFound = (plugin != nullptr);
 233   return plugin;
 234 }
 235
 236 bool
 237 nsPluginArray::NameIsEnumerable(const nsAString& aName)
 238 {
 239   return true;
 240 }
 241
 242 uint32_t
 243 nsPluginArray::Length()
 244 {
 245   if (!AllowPlugins()) {
 246     return 0;
 247   }
 248
 249   EnsurePlugins();
 250
 251   return mPlugins.Length();
 252 }
 253
 254 void
 255 nsPluginArray::GetSupportedNames(unsigned, nsTArray<nsString>& aRetval)
 256 {
 257   aRetval.Clear();
 258
 259   if (!AllowPlugins()) {
 260     return;
 261   }
 262
 263   for (uint32_t i = 0; i < mPlugins.Length(); ++i) {
 264     nsAutoString pluginName;
 265     mPlugins[i]->GetName(pluginName);
 266
 267     aRetval.AppendElement(pluginName);
 268   }
 269 }
 270
 271 NS_IMETHODIMP
 272 nsPluginArray::Observe(nsISupports *aSubject, const char *aTopic,
 273                        const char16_t *aData) {
 274   if (!nsCRT::strcmp(aTopic, "plugin-info-updated")) {
 275     Refresh(false);
 276   }
 277
 278   return NS_OK;
 279 }
 280
 281 bool
 282 nsPluginArray::AllowPlugins() const
 283 {
 284   nsCOMPtr<nsIDocShell> docShell = mWindow ? mWindow->GetDocShell() : nullptr;
 285
 286   return docShell && docShell->PluginsAllowedInCurrentDoc();
 287 }
 288
 289 static bool
 290 HasStringPrefix(const nsCString& str, const nsACString& prefix) {
 291   return str.Compare(prefix.BeginReading(), false, prefix.Length()) == 0;
 292 }
 293
 294 static bool
 295 IsPluginEnumerable(const nsTArray<nsCString>& enumerableNames,
 296                    const nsPluginTag* pluginTag)
 297 {
 298   const nsCString& pluginName = pluginTag->mName;
 299
 300   const uint32_t length = enumerableNames.Length();
 301   for (uint32_t i = 0; i < length; i++) {
 302     const nsCString& name = enumerableNames[i];
 303     if (HasStringPrefix(pluginName, name)) {
 304       return true; // don't hide plugin
 305     }
 306   }
 307
 308   return false; // hide plugin!
 309 }
 310
 311 static bool
 312 operator<(const nsRefPtr<nsPluginElement>& lhs,
 313           const nsRefPtr<nsPluginElement>& rhs)
 314 {
 315   // Sort plugins alphabetically by name.
 316   return lhs->PluginTag()->mName < rhs->PluginTag()->mName;
 317 }
 318
 319 void
 320 nsPluginArray::EnsurePlugins()
 321 {
 322   if (!mPlugins.IsEmpty() || !mHiddenPlugins.IsEmpty()) {
 323     // We already have an array of plugin elements.
 324     return;
 325   }
 326
 327   nsRefPtr<nsPluginHost> pluginHost = nsPluginHost::GetInst();
 328   if (!pluginHost) {
 329     // We have no plugin host.
 330     return;
 331   }
 332
 333   nsTArray<nsRefPtr<nsPluginTag> > pluginTags;
 334   pluginHost->GetPlugins(pluginTags);
 335
 336   nsTArray<nsCString> enumerableNames;
 337
 338   const nsAdoptingCString& enumerableNamesPref =
 339       Preferences::GetCString("plugins.enumerable_names");
 340
 341   bool disablePluginHiding = !enumerableNamesPref ||
 342                              enumerableNamesPref.EqualsLiteral("*");
 343
 344   if (!disablePluginHiding) {
 345     nsCCharSeparatedTokenizer tokens(enumerableNamesPref, ',');
 346     while (tokens.hasMoreTokens()) {
 347       const nsCSubstring& token = tokens.nextToken();
 348       if (!token.IsEmpty()) {
 349         enumerableNames.AppendElement(token);
 350       }
 351     }
 352   }
 353
 354   // need to wrap each of these with a nsPluginElement, which is
 355   // scriptable.
 356   for (uint32_t i = 0; i < pluginTags.Length(); ++i) {
 357     nsPluginTag* pluginTag = pluginTags[i];
 358
 359     // Add the plugin to the list of hidden plugins or non-hidden plugins?
 360     nsTArray<nsRefPtr<nsPluginElement> >& pluginArray =
 361         (disablePluginHiding || IsPluginEnumerable(enumerableNames, pluginTag))
 362         ? mPlugins
 363         : mHiddenPlugins;
 364
 365     pluginArray.AppendElement(new nsPluginElement(mWindow, pluginTag));
 366   }
 367
 368   // Alphabetize the enumeration order of non-hidden plugins to reduce
 369   // fingerprintable entropy based on plugins' installation file times.
 370   mPlugins.Sort();
 371 }
 372
 373 // nsPluginElement implementation.
 374
 375 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPluginElement)
 376 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPluginElement)
 377 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPluginElement)
 378   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
 379   NS_INTERFACE_MAP_ENTRY(nsISupports)
 380 NS_INTERFACE_MAP_END
 381
 382 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(nsPluginElement, mWindow, mMimeTypes)
 383
 384 nsPluginElement::nsPluginElement(nsPIDOMWindow* aWindow,
 385                                  nsPluginTag* aPluginTag)
 386   : mWindow(aWindow),
 387     mPluginTag(aPluginTag)
 388 {
 389   SetIsDOMBinding();
 390 }
 391
 392 nsPluginElement::~nsPluginElement()
 393 {
 394 }
 395
 396 nsPIDOMWindow*
 397 nsPluginElement::GetParentObject() const
 398 {
 399   MOZ_ASSERT(mWindow);
 400   return mWindow;
 401 }
 402
 403 JSObject*
 404 nsPluginElement::WrapObject(JSContext* aCx)
 405 {
 406   return PluginBinding::Wrap(aCx, this);
 407 }
 408
 409 void
 410 nsPluginElement::GetDescription(nsString& retval) const
 411 {
 412   CopyUTF8toUTF16(mPluginTag->mDescription, retval);
 413 }
 414
 415 void
 416 nsPluginElement::GetFilename(nsString& retval) const
 417 {
 418   CopyUTF8toUTF16(mPluginTag->mFileName, retval);
 419 }
 420
 421 void
 422 nsPluginElement::GetVersion(nsString& retval) const
 423 {
 424   CopyUTF8toUTF16(mPluginTag->mVersion, retval);
 425 }
 426
 427 void
 428 nsPluginElement::GetName(nsString& retval) const
 429 {
 430   CopyUTF8toUTF16(mPluginTag->mName, retval);
 431 }
 432
 433 nsMimeType*
 434 nsPluginElement::Item(uint32_t aIndex)
 435 {
 436   EnsurePluginMimeTypes();
 437
 438   return mMimeTypes.SafeElementAt(aIndex);
 439 }
 440
 441 nsMimeType*
 442 nsPluginElement::NamedItem(const nsAString& aName)
 443 {
 444   bool unused;
 445   return NamedGetter(aName, unused);
 446 }
 447
 448 nsMimeType*
 449 nsPluginElement::IndexedGetter(uint32_t aIndex, bool &aFound)
 450 {
 451   EnsurePluginMimeTypes();
 452
 453   aFound = aIndex < mMimeTypes.Length();
 454
 455   return aFound ? mMimeTypes[aIndex] : nullptr;
 456 }
 457
 458 nsMimeType*
 459 nsPluginElement::NamedGetter(const nsAString& aName, bool &aFound)
 460 {
 461   EnsurePluginMimeTypes();
 462
 463   aFound = false;
 464
 465   for (uint32_t i = 0; i < mMimeTypes.Length(); ++i) {
 466     if (mMimeTypes[i]->Type().Equals(aName)) {
 467       aFound = true;
 468
 469       return mMimeTypes[i];
 470     }
 471   }
 472
 473   return nullptr;
 474 }
 475
 476 bool
 477 nsPluginElement::NameIsEnumerable(const nsAString& aName)
 478 {
 479   return true;
 480 }
 481
 482 uint32_t
 483 nsPluginElement::Length()
 484 {
 485   EnsurePluginMimeTypes();
 486
 487   return mMimeTypes.Length();
 488 }
 489
 490 void
 491 nsPluginElement::GetSupportedNames(unsigned, nsTArray<nsString>& retval)
 492 {
 493   EnsurePluginMimeTypes();
 494
 495   for (uint32_t i = 0; i < mMimeTypes.Length(); ++i) {
 496     retval.AppendElement(mMimeTypes[i]->Type());
 497   }
 498 }
 499
 500 nsTArray<nsRefPtr<nsMimeType> >&
 501 nsPluginElement::MimeTypes()
 502 {
 503   EnsurePluginMimeTypes();
 504
 505   return mMimeTypes;
 506 }
 507
 508 void
 509 nsPluginElement::EnsurePluginMimeTypes()
 510 {
 511   if (!mMimeTypes.IsEmpty()) {
 512     return;
 513   }
 514
 515   for (uint32_t i = 0; i < mPluginTag->mMimeTypes.Length(); ++i) {
 516     NS_ConvertUTF8toUTF16 type(mPluginTag->mMimeTypes[i]);
 517     mMimeTypes.AppendElement(new nsMimeType(mWindow, this, i, type));
 518   }
 519 }