DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (e7e658ec1e98)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsPluginHost_h_
#define nsPluginHost_h_

#include "mozilla/LinkedList.h"
#include "mozilla/StaticPtr.h"

#include "nsIPluginHost.h"
#include "nsIObserver.h"
#include "nsCOMPtr.h"
#include "prlink.h"
#include "nsIPluginTag.h"
#include "nsPluginsDir.h"
#include "nsPluginDirServiceProvider.h"
#include "nsWeakReference.h"
#include "nsIPrompt.h"
#include "MainThreadUtils.h"
#include "nsTArray.h"
#include "nsINamed.h"
#include "nsTObserverArray.h"
#include "nsITimer.h"
#include "nsPluginTags.h"
#include "nsIEffectiveTLDService.h"
#include "nsIIDNService.h"
#include "nsCRT.h"
#include "mozilla/dom/PromiseNativeHandler.h"

#ifdef XP_WIN
#  include <minwindef.h>
#  include "nsIWindowsRegKey.h"
#endif

namespace mozilla {
namespace plugins {
class FakePluginTag;
class PluginTag;
class BlocklistPromiseHandler;
}  // namespace plugins
}  // namespace mozilla

class nsNPAPIPlugin;
class nsIFile;
class nsIChannel;
class nsPluginNativeWindow;
class nsObjectLoadingContent;
class nsPluginInstanceOwner;
class nsPluginUnloadRunnable;
class nsNPAPIPluginInstance;
class nsNPAPIPluginStreamListener;
class nsIPluginInstanceOwner;
class nsIInputStream;
class nsIStreamListener;
#ifndef npapi_h_
struct _NPP;
typedef _NPP* NPP;
#endif

class nsInvalidPluginTag : public nsISupports {
  virtual ~nsInvalidPluginTag();

 public:
  explicit nsInvalidPluginTag(const char* aFullPath,
                              int64_t aLastModifiedTime = 0);

  NS_DECL_ISUPPORTS

  nsCString mFullPath;
  int64_t mLastModifiedTime;
  bool mSeen;

  RefPtr<nsInvalidPluginTag> mPrev;
  RefPtr<nsInvalidPluginTag> mNext;
};

class nsPluginHost final : public nsIPluginHost,
                           public nsIObserver,
                           public nsITimerCallback,
                           public nsSupportsWeakReference,
                           public nsINamed {
  friend class nsPluginTag;
  friend class nsFakePluginTag;
  virtual ~nsPluginHost();

 public:
  nsPluginHost();

  static already_AddRefed<nsPluginHost> GetInst();

  NS_DECL_ISUPPORTS
  NS_DECL_NSIPLUGINHOST
  NS_DECL_NSIOBSERVER
  NS_DECL_NSITIMERCALLBACK
  NS_DECL_NSINAMED

  nsresult LoadPlugins();
  nsresult UnloadPlugins();

  nsresult SetUpPluginInstance(const nsACString& aMimeType, nsIURI* aURL,
                               nsPluginInstanceOwner* aOwner);

  // Acts like a bitfield
  enum PluginFilter {
    eExcludeNone = nsIPluginHost::EXCLUDE_NONE,
    eExcludeDisabled = nsIPluginHost::EXCLUDE_DISABLED,
    eExcludeFake = nsIPluginHost::EXCLUDE_FAKE
  };
  // FIXME-jsplugins comment about fake
  bool HavePluginForType(const nsACString& aMimeType,
                         PluginFilter aFilter = eExcludeDisabled);

  // FIXME-jsplugins what if fake has different extensions
  bool HavePluginForExtension(const nsACString& aExtension,
                              /* out */ nsACString& aMimeType,
                              PluginFilter aFilter = eExcludeDisabled);

  void GetPlugins(nsTArray<nsCOMPtr<nsIInternalPluginTag>>& aPluginArray,
                  bool aIncludeDisabled = false);

  nsresult FindPluginsForContent(
      uint32_t aPluginEpoch, nsTArray<mozilla::plugins::PluginTag>* aPlugins,
      nsTArray<mozilla::plugins::FakePluginTag>* aFakePlugins,
      uint32_t* aNewPluginEpoch);

  nsresult GetURL(nsISupports* pluginInst, const char* url, const char* target,
                  nsNPAPIPluginStreamListener* streamListener,
                  const char* altHost, const char* referrer,
                  bool forceJSEnabled);
  nsresult PostURL(nsISupports* pluginInst, const char* url,
                   uint32_t postDataLen, const char* postData,
                   const char* target,
                   nsNPAPIPluginStreamListener* streamListener,
                   const char* altHost, const char* referrer,
                   bool forceJSEnabled, uint32_t postHeadersLength,
                   const char* postHeaders);

  nsresult UserAgent(const char** retstring);
  nsresult ParsePostBufferToFixHeaders(const char* inPostData,
                                       uint32_t inPostDataLen,
                                       char** outPostData,
                                       uint32_t* outPostDataLen);
  nsresult NewPluginNativeWindow(nsPluginNativeWindow** aPluginNativeWindow);

  void AddIdleTimeTarget(nsIPluginInstanceOwner* objectFrame, bool isVisible);
  void RemoveIdleTimeTarget(nsIPluginInstanceOwner* objectFrame);

  nsresult GetPluginName(nsNPAPIPluginInstance* aPluginInstance,
                         const char** aPluginName);
  nsresult StopPluginInstance(nsNPAPIPluginInstance* aInstance);
  nsresult GetPluginTagForInstance(nsNPAPIPluginInstance* aPluginInstance,
                                   nsIPluginTag** aPluginTag);

  nsresult NewPluginURLStream(const nsString& aURL,
                              nsNPAPIPluginInstance* aInstance,
                              nsNPAPIPluginStreamListener* aListener,
                              nsIInputStream* aPostStream = nullptr,
                              const char* aHeadersData = nullptr,
                              uint32_t aHeadersDataLen = 0);

  nsresult GetURLWithHeaders(
      nsNPAPIPluginInstance* pluginInst, const char* url,
      const char* target = nullptr,
      nsNPAPIPluginStreamListener* streamListener = nullptr,
      const char* altHost = nullptr, const char* referrer = nullptr,
      bool forceJSEnabled = false, uint32_t getHeadersLength = 0,
      const char* getHeaders = nullptr);

  nsresult AddHeadersToChannel(const char* aHeadersData,
                               uint32_t aHeadersDataLen,
                               nsIChannel* aGenericChannel);

  // Helper that checks if a type is whitelisted in plugin.allowed_types.
  // Always returns true if plugin.allowed_types is not set
  static bool IsTypeWhitelisted(const char* aType);

  // Helper that checks if a plugin of a given MIME type can be loaded by the
  // parent process. It checks the plugin.load_in_parent_process.<mime> pref.
  // Always returns false if plugin.load_in_parent_process.<mime> is not set.
  static bool ShouldLoadTypeInParent(const nsACString& aMimeType);

  /**
   * Returns true if a plugin can be used to load the requested MIME type. Used
   * for short circuiting before sending things to plugin code.
   */
  static bool CanUsePluginForMIMEType(const nsACString& aMIMEType);

  // checks whether aType is a type we recognize for potential special handling
  enum SpecialType {
    eSpecialType_None,
    // Needed to whitelist for async init support
    eSpecialType_Test,
    // Informs some decisions about OOP and quirks
    eSpecialType_Flash
  };
  static SpecialType GetSpecialType(const nsACString& aMIMEType);

  static nsresult PostPluginUnloadEvent(PRLibrary* aLibrary);

  void PluginCrashed(nsNPAPIPlugin* plugin, const nsAString& pluginDumpID,
                     const nsAString& browserDumpID);

  nsNPAPIPluginInstance* FindInstance(const char* mimetype);
  nsNPAPIPluginInstance* FindOldestStoppedInstance();
  uint32_t StoppedInstanceCount();

  nsTArray<RefPtr<nsNPAPIPluginInstance>>* InstanceArray();

  // Return the tag for |aLibrary| if found, nullptr if not.
  nsPluginTag* FindTagForLibrary(PRLibrary* aLibrary);

  // The last argument should be false if we already have an in-flight stream
  // and don't need to set up a new stream.
  nsresult InstantiatePluginInstance(const nsACString& aMimeType, nsIURI* aURL,
                                     nsObjectLoadingContent* aContent,
                                     nsPluginInstanceOwner** aOwner);

  // Does not accept nullptr and should never fail.
  nsPluginTag* TagForPlugin(nsNPAPIPlugin* aPlugin);

  nsPluginTag* PluginWithId(uint32_t aId);

  nsresult GetPlugin(const nsACString& aMimeType, nsNPAPIPlugin** aPlugin);
  nsresult GetPluginForContentProcess(uint32_t aPluginId,
                                      nsNPAPIPlugin** aPlugin);
  void NotifyContentModuleDestroyed(uint32_t aPluginId);

  nsresult NewPluginStreamListener(nsIURI* aURL,
                                   nsNPAPIPluginInstance* aInstance,
                                   nsIStreamListener** aStreamListener);

  void CreateWidget(nsPluginInstanceOwner* aOwner);

  nsresult EnumerateSiteData(const nsACString& domain,
                             const nsTArray<nsCString>& sites,
                             nsTArray<nsCString>& result, bool firstMatchOnly);

  nsresult SendPluginsToContent();
  nsresult SetPluginsInContent(
      uint32_t aPluginEpoch, nsTArray<mozilla::plugins::PluginTag>& aPlugins,
      nsTArray<mozilla::plugins::FakePluginTag>& aFakePlugins);

 private:
  friend class nsPluginUnloadRunnable;
  friend class mozilla::plugins::BlocklistPromiseHandler;

  void DestroyRunningInstances(nsPluginTag* aPluginTag);

  // Writes updated plugins settings to disk and unloads the plugin
  // if it is now disabled. Should only be called by the plugin tag in question
  void UpdatePluginInfo(nsPluginTag* aPluginTag);

  nsresult TrySetUpPluginInstance(const nsACString& aMimeType, nsIURI* aURL,
                                  nsPluginInstanceOwner* aOwner);

  // FIXME-jsplugins comment here about when things may be fake
  nsPluginTag* FindPreferredPlugin(const nsTArray<nsPluginTag*>& matches);

  // Find a plugin for the given type.  If aIncludeFake is true a fake plugin
  // will be preferred if one exists; otherwise a fake plugin will never be
  // returned.  If aCheckEnabled is false, disabled plugins can be returned.
  nsIInternalPluginTag* FindPluginForType(const nsACString& aMimeType,
                                          bool aIncludeFake,
                                          bool aCheckEnabled);

  // Find specifically a fake plugin for the given type.  If aCheckEnabled is
  // false, disabled plugins can be returned.
  nsFakePluginTag* FindFakePluginForType(const nsACString& aMimeType,
                                         bool aCheckEnabled);

  // Find specifically a fake plugin for the given extension.  If aCheckEnabled
  // is false, disabled plugins can be returned.  aMimeType will be filled in
  // with the MIME type the plugin is registered for.
  nsFakePluginTag* FindFakePluginForExtension(const nsACString& aExtension,
                                              /* out */ nsACString& aMimeType,
                                              bool aCheckEnabled);

  // Find specifically a native (NPAPI) plugin for the given type.  If
  // aCheckEnabled is false, disabled plugins can be returned.
  nsPluginTag* FindNativePluginForType(const nsACString& aMimeType,
                                       bool aCheckEnabled);

  // Find specifically a native (NPAPI) plugin for the given extension.  If
  // aCheckEnabled is false, disabled plugins can be returned.  aMimeType will
  // be filled in with the MIME type the plugin is registered for.
  nsPluginTag* FindNativePluginForExtension(const nsACString& aExtension,
                                            /* out */ nsACString& aMimeType,
                                            bool aCheckEnabled);

  nsresult FindStoppedPluginForURL(nsIURI* aURL,
                                   nsIPluginInstanceOwner* aOwner);

  nsresult FindPlugins(bool aCreatePluginList, bool* aPluginsChanged);

  // FIXME revisit, no ns prefix
  // Registers or unregisters the given mime type with the category manager
  enum nsRegisterType {
    ePluginRegister,
    ePluginUnregister,
    // Checks if this type should still be registered first
    ePluginMaybeUnregister
  };
  void RegisterWithCategoryManager(const nsCString& aMimeType,
                                   nsRegisterType aType);

  void AddPluginTag(nsPluginTag* aPluginTag);

  void UpdatePluginBlocklistState(nsPluginTag* aPluginTag,
                                  bool aShouldSoftblock = false);

  nsresult ScanPluginsDirectory(nsIFile* pluginsDir, bool aCreatePluginList,
                                bool* aPluginsChanged);

  nsresult ScanPluginsDirectoryList(nsISimpleEnumerator* dirEnum,
                                    bool aCreatePluginList,
                                    bool* aPluginsChanged);

  nsresult EnsurePluginLoaded(nsPluginTag* aPluginTag);

  bool IsRunningPlugin(nsPluginTag* aPluginTag);

  // Stores all plugins info into the registry
  nsresult WritePluginInfo();

  // Loads all cached plugins info into mCachedPlugins
  nsresult ReadPluginInfo();

  // Given a file path, returns the plugins info from our cache
  // and removes it from the cache.
  void RemoveCachedPluginsInfo(const char* filePath, nsPluginTag** result);

  // Checks to see if a tag object is in our list of live tags.
  bool IsLiveTag(nsIPluginTag* tag);

  // Checks our list of live tags for an equivalent tag.
  nsPluginTag* HaveSamePlugin(const nsPluginTag* aPluginTag);

  // Returns the first plugin at |path|
  nsPluginTag* FirstPluginWithPath(const nsCString& path);

  nsresult EnsurePrivateDirServiceProvider();

  void OnPluginInstanceDestroyed(nsPluginTag* aPluginTag);

  // To be used by the chrome process whenever the set of plugins changes.
  void IncrementChromeEpoch();

  // To be used by the chrome process; returns the current epoch.
  uint32_t ChromeEpoch();

  // To be used by the content process to get/set the last observed epoch value
  // from the chrome process.
  uint32_t ChromeEpochForContent();
  void SetChromeEpochForContent(uint32_t aEpoch);

  void UpdateInMemoryPluginInfo(nsPluginTag* aPluginTag);

  nsresult ActuallyReloadPlugins();

  RefPtr<nsPluginTag> mPlugins;
  RefPtr<nsPluginTag> mCachedPlugins;
  RefPtr<nsInvalidPluginTag> mInvalidPlugins;

  nsTArray<RefPtr<nsFakePluginTag>> mFakePlugins;

  bool mPluginsLoaded;

  // set by pref plugin.override_internal_types
  bool mOverrideInternalTypes;

  // set by pref plugin.disable
  bool mPluginsDisabled;

  // Any instances in this array will have valid plugin objects via GetPlugin().
  // When removing an instance it might not die - be sure to null out it's
  // plugin.
  nsTArray<RefPtr<nsNPAPIPluginInstance>> mInstances;

  nsCOMPtr<nsIFile> mPluginRegFile;
#ifdef XP_WIN
  RefPtr<nsPluginDirServiceProvider> mPrivateDirServiceProvider;

  // In order to reload plugins when they change, we watch the registry via
  // this object.
  nsCOMPtr<nsIWindowsRegKey> mRegKeyHKLM;
  nsCOMPtr<nsIWindowsRegKey> mRegKeyHKCU;
#endif

  nsCOMPtr<nsIEffectiveTLDService> mTLDService;
  nsCOMPtr<nsIIDNService> mIDNService;

  // Helpers for ClearSiteData and SiteHasData.
  nsresult NormalizeHostname(nsCString& host);

  nsWeakPtr mCurrentDocument;  // weak reference, we use it to id document only

  // This epoch increases each time we load the list of plugins from disk.
  // In the chrome process, this stores the actual epoch.
  // In the content process, this stores the last epoch value observed
  // when reading plugins from chrome.
  uint32_t mPluginEpoch;

  static nsIFile* sPluginTempDir;

  // We need to hold a global ptr to ourselves because we register for
  // two different CIDs for some reason...
  static mozilla::StaticRefPtr<nsPluginHost> sInst;
};

class PluginDestructionGuard
    : public mozilla::LinkedListElement<PluginDestructionGuard> {
 public:
  explicit PluginDestructionGuard(nsNPAPIPluginInstance* aInstance);
  explicit PluginDestructionGuard(NPP npp);

  ~PluginDestructionGuard();

  static bool DelayDestroy(nsNPAPIPluginInstance* aInstance);

 protected:
  void Init() {
    NS_ASSERTION(NS_IsMainThread(), "Should be on the main thread");

    mDelayedDestroy = false;

    sList.insertBack(this);
  }

  RefPtr<nsNPAPIPluginInstance> mInstance;
  bool mDelayedDestroy;

  static mozilla::LinkedList<PluginDestructionGuard> sList;
};

#endif  // nsPluginHost_h_