The Tor Browser / file comparison

comparison: dom/plugins/base/nsNPAPIPlugin.cpp

dom/plugins/base/nsNPAPIPlugin.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:8e9882488383
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 "base/basictypes.h"
7
8 /* This must occur *after* layers/PLayerTransaction.h to avoid typedefs conflicts. */
9 #include "mozilla/ArrayUtils.h"
10
11 #include "pratom.h"
12 #include "prmem.h"
13 #include "prenv.h"
14 #include "prclist.h"
15
16 #include "jsfriendapi.h"
17
18 #include "nsPluginHost.h"
19 #include "nsNPAPIPlugin.h"
20 #include "nsNPAPIPluginInstance.h"
21 #include "nsNPAPIPluginStreamListener.h"
22 #include "nsPluginStreamListenerPeer.h"
23 #include "nsIServiceManager.h"
24 #include "nsThreadUtils.h"
25 #include "mozilla/Preferences.h"
26 #include "nsPluginInstanceOwner.h"
27
28 #include "nsPluginsDir.h"
29 #include "nsPluginLogging.h"
30
31 #include "nsIDOMElement.h"
32 #include "nsPIDOMWindow.h"
33 #include "nsGlobalWindow.h"
34 #include "nsIDocument.h"
35 #include "nsIContent.h"
36 #include "nsIScriptGlobalObject.h"
37 #include "nsIScriptContext.h"
38 #include "nsIUnicodeNormalizer.h"
39 #include "nsDOMJSUtils.h"
40 #include "nsIPrincipal.h"
41 #include "nsWildCard.h"
42 #include "nsContentUtils.h"
43 #include "nsCxPusher.h"
44
45 #include "nsIXPConnect.h"
46
47 #include "nsIObserverService.h"
48 #include <prinrval.h>
49
50 #ifdef MOZ_WIDGET_COCOA
51 #include <Carbon/Carbon.h>
52 #include <ApplicationServices/ApplicationServices.h>
53 #include <OpenGL/OpenGL.h>
54 #include "nsCocoaFeatures.h"
55 #endif
56
57 // needed for nppdf plugin
58 #if (MOZ_WIDGET_GTK)
59 #include <gdk/gdk.h>
60 #include <gdk/gdkx.h>
61 #if (MOZ_WIDGET_GTK == 2)
62 #include "gtk2xtbin.h"
63 #endif
64 #endif
65
66 #include "nsJSUtils.h"
67 #include "nsJSNPRuntime.h"
68 #include "nsIHttpAuthManager.h"
69 #include "nsICookieService.h"
70 #include "nsILoadContext.h"
71 #include "nsIDocShell.h"
72
73 #include "nsNetUtil.h"
74
75 #include "mozilla/Mutex.h"
76 #include "mozilla/PluginLibrary.h"
77 using mozilla::PluginLibrary;
78
79 #include "mozilla/PluginPRLibrary.h"
80 using mozilla::PluginPRLibrary;
81
82 #include "mozilla/plugins/PluginModuleParent.h"
83 using mozilla::plugins::PluginModuleParent;
84
85 #ifdef MOZ_X11
86 #include "mozilla/X11Util.h"
87 #endif
88
89 #ifdef XP_WIN
90 #include <windows.h>
91 #include "mozilla/WindowsVersion.h"
92 #ifdef ACCESSIBILITY
93 #include "mozilla/a11y/Compatibility.h"
94 #endif
95 #endif
96
97 #ifdef MOZ_WIDGET_ANDROID
98 #include <android/log.h>
99 #include "android_npapi.h"
100 #include "ANPBase.h"
101 #include "AndroidBridge.h"
102 #undef LOG
103 #define LOG(args...) __android_log_print(ANDROID_LOG_INFO, "GeckoPlugins" , ## args)
104 #endif
105
106 using namespace mozilla;
107 using namespace mozilla::plugins::parent;
108
109 // We should make this const...
110 static NPNetscapeFuncs sBrowserFuncs = {
111 sizeof(sBrowserFuncs),
112 (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR,
113 _geturl,
114 _posturl,
115 _requestread,
116 _newstream,
117 _write,
118 _destroystream,
119 _status,
120 _useragent,
121 _memalloc,
122 _memfree,
123 _memflush,
124 _reloadplugins,
125 _getJavaEnv,
126 _getJavaPeer,
127 _geturlnotify,
128 _posturlnotify,
129 _getvalue,
130 _setvalue,
131 _invalidaterect,
132 _invalidateregion,
133 _forceredraw,
134 _getstringidentifier,
135 _getstringidentifiers,
136 _getintidentifier,
137 _identifierisstring,
138 _utf8fromidentifier,
139 _intfromidentifier,
140 _createobject,
141 _retainobject,
142 _releaseobject,
143 _invoke,
144 _invokeDefault,
145 _evaluate,
146 _getproperty,
147 _setproperty,
148 _removeproperty,
149 _hasproperty,
150 _hasmethod,
151 _releasevariantvalue,
152 _setexception,
153 _pushpopupsenabledstate,
154 _poppopupsenabledstate,
155 _enumerate,
156 _pluginthreadasynccall,
157 _construct,
158 _getvalueforurl,
159 _setvalueforurl,
160 _getauthenticationinfo,
161 _scheduletimer,
162 _unscheduletimer,
163 _popupcontextmenu,
164 _convertpoint,
165 nullptr, // handleevent, unimplemented
166 nullptr, // unfocusinstance, unimplemented
167 _urlredirectresponse,
168 _initasyncsurface,
169 _finalizeasyncsurface,
170 _setcurrentasyncsurface
171 };
172
173 static Mutex *sPluginThreadAsyncCallLock = nullptr;
174 static PRCList sPendingAsyncCalls = PR_INIT_STATIC_CLIST(&sPendingAsyncCalls);
175
176 // POST/GET stream type
177 enum eNPPStreamTypeInternal {
178 eNPPStreamTypeInternal_Get,
179 eNPPStreamTypeInternal_Post
180 };
181
182 PRIntervalTime NS_NotifyBeginPluginCall(NSPluginCallReentry aReentryState)
183 {
184 nsNPAPIPluginInstance::BeginPluginCall(aReentryState);
185 return PR_IntervalNow();
186 }
187
188 // This function sends a notification using the observer service to any object
189 // registered to listen to the "experimental-notify-plugin-call" subject.
190 // Each "experimental-notify-plugin-call" notification carries with it the run
191 // time value in milliseconds that the call took to execute.
192 void NS_NotifyPluginCall(PRIntervalTime startTime, NSPluginCallReentry aReentryState)
193 {
194 nsNPAPIPluginInstance::EndPluginCall(aReentryState);
195
196 PRIntervalTime endTime = PR_IntervalNow() - startTime;
197 nsCOMPtr<nsIObserverService> notifyUIService =
198 mozilla::services::GetObserverService();
199 if (!notifyUIService)
200 return;
201
202 float runTimeInSeconds = float(endTime) / PR_TicksPerSecond();
203 nsAutoString runTimeString;
204 runTimeString.AppendFloat(runTimeInSeconds);
205 const char16_t* runTime = runTimeString.get();
206 notifyUIService->NotifyObservers(nullptr, "experimental-notify-plugin-call",
207 runTime);
208 }
209
210 static void CheckClassInitialized()
211 {
212 static bool initialized = false;
213
214 if (initialized)
215 return;
216
217 if (!sPluginThreadAsyncCallLock)
218 sPluginThreadAsyncCallLock = new Mutex("nsNPAPIPlugin.sPluginThreadAsyncCallLock");
219
220 initialized = true;
221
222 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,("NPN callbacks initialized\n"));
223 }
224
225 NS_IMPL_ISUPPORTS0(nsNPAPIPlugin)
226
227 nsNPAPIPlugin::nsNPAPIPlugin()
228 {
229 memset((void*)&mPluginFuncs, 0, sizeof(mPluginFuncs));
230 mPluginFuncs.size = sizeof(mPluginFuncs);
231 mPluginFuncs.version = (NP_VERSION_MAJOR << 8) | NP_VERSION_MINOR;
232
233 mLibrary = nullptr;
234 }
235
236 nsNPAPIPlugin::~nsNPAPIPlugin()
237 {
238 delete mLibrary;
239 mLibrary = nullptr;
240 }
241
242 void
243 nsNPAPIPlugin::PluginCrashed(const nsAString& pluginDumpID,
244 const nsAString& browserDumpID)
245 {
246 nsRefPtr<nsPluginHost> host = nsPluginHost::GetInst();
247 host->PluginCrashed(this, pluginDumpID, browserDumpID);
248 }
249
250 bool
251 nsNPAPIPlugin::RunPluginOOP(const nsPluginTag *aPluginTag)
252 {
253 if (PR_GetEnv("MOZ_DISABLE_OOP_PLUGINS")) {
254 return false;
255 }
256
257 if (!aPluginTag) {
258 return false;
259 }
260
261 #ifdef ACCESSIBILITY
262 // Certain assistive technologies don't want oop Flash, thus we have a special
263 // pref for them to disable oop Flash (refer to bug 785047 for details).
264 bool useA11yPref = false;
265 #ifdef XP_WIN
266 useA11yPref = a11y::Compatibility::IsJAWS();
267 #endif
268 #endif
269
270 #ifdef XP_WIN
271 // On Windows Vista+, we force Flash to run in OOPP mode because Adobe
272 // doesn't test Flash in-process and there are known stability bugs.
273 if (aPluginTag->mIsFlashPlugin && IsVistaOrLater()) {
274 #ifdef ACCESSIBILITY
275 if (!useA11yPref)
276 return true;
277 #else
278 return true;
279 #endif
280 }
281 #endif
282
283 nsIPrefBranch* prefs = Preferences::GetRootBranch();
284 if (!prefs) {
285 return false;
286 }
287
288 // Get per-library whitelist/blacklist pref string
289 // "dom.ipc.plugins.enabled.filename.dll" and fall back to the default value
290 // of "dom.ipc.plugins.enabled"
291 // The "filename.dll" part can contain shell wildcard pattern
292
293 nsAutoCString prefFile(aPluginTag->mFullPath.get());
294 int32_t slashPos = prefFile.RFindCharInSet("/\\");
295 if (kNotFound == slashPos)
296 return false;
297 prefFile.Cut(0, slashPos + 1);
298 ToLowerCase(prefFile);
299
300 #ifdef XP_MACOSX
301 #if defined(__i386__)
302 nsAutoCString prefGroupKey("dom.ipc.plugins.enabled.i386.");
303 #elif defined(__x86_64__)
304 nsAutoCString prefGroupKey("dom.ipc.plugins.enabled.x86_64.");
305 #elif defined(__ppc__)
306 nsAutoCString prefGroupKey("dom.ipc.plugins.enabled.ppc.");
307 #endif
308 #else
309 nsAutoCString prefGroupKey("dom.ipc.plugins.enabled.");
310 #endif
311
312 #ifdef ACCESSIBILITY
313 if (useA11yPref)
314 prefGroupKey.AssignLiteral("dom.ipc.plugins.enabled.a11y.");
315 #endif
316
317 // Java plugins include a number of different file names,
318 // so use the mime type (mIsJavaPlugin) and a special pref.
319 if (aPluginTag->mIsJavaPlugin &&
320 !Preferences::GetBool("dom.ipc.plugins.java.enabled", true)) {
321 return false;
322 }
323
324 uint32_t prefCount;
325 char** prefNames;
326 nsresult rv = prefs->GetChildList(prefGroupKey.get(),
327 &prefCount, &prefNames);
328
329 bool oopPluginsEnabled = false;
330 bool prefSet = false;
331
332 if (NS_SUCCEEDED(rv) && prefCount > 0) {
333 uint32_t prefixLength = prefGroupKey.Length();
334 for (uint32_t currentPref = 0; currentPref < prefCount; currentPref++) {
335 // Get the mask
336 const char* maskStart = prefNames[currentPref] + prefixLength;
337 bool match = false;
338
339 int valid = NS_WildCardValid(maskStart);
340 if (valid == INVALID_SXP) {
341 continue;
342 }
343 else if(valid == NON_SXP) {
344 // mask is not a shell pattern, compare it as normal string
345 match = (strcmp(prefFile.get(), maskStart) == 0);
346 }
347 else {
348 match = (NS_WildCardMatch(prefFile.get(), maskStart, 0) == MATCH);
349 }
350
351 if (match && NS_SUCCEEDED(Preferences::GetBool(prefNames[currentPref],
352 &oopPluginsEnabled))) {
353 prefSet = true;
354 break;
355 }
356 }
357 NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefNames);
358 }
359
360 if (!prefSet) {
361 oopPluginsEnabled =
362 #ifdef XP_MACOSX
363 #if defined(__i386__)
364 Preferences::GetBool("dom.ipc.plugins.enabled.i386", false);
365 #elif defined(__x86_64__)
366 Preferences::GetBool("dom.ipc.plugins.enabled.x86_64", false);
367 #elif defined(__ppc__)
368 Preferences::GetBool("dom.ipc.plugins.enabled.ppc", false);
369 #endif
370 #else
371 #ifdef ACCESSIBILITY
372 useA11yPref ? Preferences::GetBool("dom.ipc.plugins.enabled.a11y", false) :
373 #endif
374 Preferences::GetBool("dom.ipc.plugins.enabled", false);
375 #endif
376 }
377
378 return oopPluginsEnabled;
379 }
380
381 inline PluginLibrary*
382 GetNewPluginLibrary(nsPluginTag *aPluginTag)
383 {
384 if (!aPluginTag) {
385 return nullptr;
386 }
387
388 if (nsNPAPIPlugin::RunPluginOOP(aPluginTag)) {
389 return PluginModuleParent::LoadModule(aPluginTag->mFullPath.get());
390 }
391 return new PluginPRLibrary(aPluginTag->mFullPath.get(), aPluginTag->mLibrary);
392 }
393
394 // Creates an nsNPAPIPlugin object. One nsNPAPIPlugin object exists per plugin (not instance).
395 nsresult
396 nsNPAPIPlugin::CreatePlugin(nsPluginTag *aPluginTag, nsNPAPIPlugin** aResult)
397 {
398 *aResult = nullptr;
399
400 if (!aPluginTag) {
401 return NS_ERROR_FAILURE;
402 }
403
404 CheckClassInitialized();
405
406 nsRefPtr<nsNPAPIPlugin> plugin = new nsNPAPIPlugin();
407 if (!plugin)
408 return NS_ERROR_OUT_OF_MEMORY;
409
410 PluginLibrary* pluginLib = GetNewPluginLibrary(aPluginTag);
411 if (!pluginLib) {
412 return NS_ERROR_FAILURE;
413 }
414
415 #if defined(XP_MACOSX) || defined(MOZ_WIDGET_ANDROID)
416 if (!pluginLib->HasRequiredFunctions()) {
417 NS_WARNING("Not all necessary functions exposed by plugin, it will not load.");
418 return NS_ERROR_FAILURE;
419 }
420 #endif
421
422 plugin->mLibrary = pluginLib;
423 pluginLib->SetPlugin(plugin);
424
425 NPError pluginCallError;
426 nsresult rv;
427
428 // Exchange NPAPI entry points.
429 #if defined(XP_WIN)
430 // NP_GetEntryPoints must be called before NP_Initialize on Windows.
431 rv = pluginLib->NP_GetEntryPoints(&plugin->mPluginFuncs, &pluginCallError);
432 if (rv != NS_OK || pluginCallError != NPERR_NO_ERROR) {
433 return NS_ERROR_FAILURE;
434 }
435
436 // NP_Initialize must be called after NP_GetEntryPoints on Windows.
437 rv = pluginLib->NP_Initialize(&sBrowserFuncs, &pluginCallError);
438 if (rv != NS_OK || pluginCallError != NPERR_NO_ERROR) {
439 return NS_ERROR_FAILURE;
440 }
441 #elif defined(XP_MACOSX)
442 // NP_Initialize must be called before NP_GetEntryPoints on Mac OS X.
443 // We need to match WebKit's behavior.
444 rv = pluginLib->NP_Initialize(&sBrowserFuncs, &pluginCallError);
445 if (rv != NS_OK || pluginCallError != NPERR_NO_ERROR) {
446 return NS_ERROR_FAILURE;
447 }
448
449 rv = pluginLib->NP_GetEntryPoints(&plugin->mPluginFuncs, &pluginCallError);
450 if (rv != NS_OK || pluginCallError != NPERR_NO_ERROR) {
451 return NS_ERROR_FAILURE;
452 }
453 #elif defined(MOZ_WIDGET_GONK)
454 #else
455 rv = pluginLib->NP_Initialize(&sBrowserFuncs, &plugin->mPluginFuncs, &pluginCallError);
456 if (rv != NS_OK || pluginCallError != NPERR_NO_ERROR) {
457 return NS_ERROR_FAILURE;
458 }
459 #endif
460
461 plugin.forget(aResult);
462 return NS_OK;
463 }
464
465 PluginLibrary*
466 nsNPAPIPlugin::GetLibrary()
467 {
468 return mLibrary;
469 }
470
471 NPPluginFuncs*
472 nsNPAPIPlugin::PluginFuncs()
473 {
474 return &mPluginFuncs;
475 }
476
477 nsresult
478 nsNPAPIPlugin::Shutdown()
479 {
480 NPP_PLUGIN_LOG(PLUGIN_LOG_BASIC,
481 ("NPP Shutdown to be called: this=%p\n", this));
482
483 NPError shutdownError;
484 mLibrary->NP_Shutdown(&shutdownError);
485
486 return NS_OK;
487 }
488
489 nsresult
490 nsNPAPIPlugin::RetainStream(NPStream *pstream, nsISupports **aRetainedPeer)
491 {
492 if (!aRetainedPeer)
493 return NS_ERROR_NULL_POINTER;
494
495 *aRetainedPeer = nullptr;
496
497 if (!pstream || !pstream->ndata)
498 return NS_ERROR_NULL_POINTER;
499
500 nsNPAPIStreamWrapper* streamWrapper = static_cast<nsNPAPIStreamWrapper*>(pstream->ndata);
501 nsNPAPIPluginStreamListener* listener = streamWrapper->GetStreamListener();
502 if (!listener) {
503 return NS_ERROR_NULL_POINTER;
504 }
505
506 nsIStreamListener* streamListener = listener->GetStreamListenerPeer();
507 if (!streamListener) {
508 return NS_ERROR_NULL_POINTER;
509 }
510
511 *aRetainedPeer = streamListener;
512 NS_ADDREF(*aRetainedPeer);
513 return NS_OK;
514 }
515
516 // Create a new NPP GET or POST (given in the type argument) url
517 // stream that may have a notify callback
518 NPError
519 MakeNewNPAPIStreamInternal(NPP npp, const char *relativeURL, const char *target,
520 eNPPStreamTypeInternal type,
521 bool bDoNotify = false,
522 void *notifyData = nullptr, uint32_t len = 0,
523 const char *buf = nullptr, NPBool file = false)
524 {
525 if (!npp)
526 return NPERR_INVALID_INSTANCE_ERROR;
527
528 PluginDestructionGuard guard(npp);
529
530 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *) npp->ndata;
531 if (!inst || !inst->IsRunning())
532 return NPERR_INVALID_INSTANCE_ERROR;
533
534 nsCOMPtr<nsIPluginHost> pluginHostCOM = do_GetService(MOZ_PLUGIN_HOST_CONTRACTID);
535 nsPluginHost *pluginHost = static_cast<nsPluginHost*>(pluginHostCOM.get());
536 if (!pluginHost) {
537 return NPERR_GENERIC_ERROR;
538 }
539
540 nsRefPtr<nsNPAPIPluginStreamListener> listener;
541 // Set aCallNotify here to false. If pluginHost->GetURL or PostURL fail,
542 // the listener's destructor will do the notification while we are about to
543 // return a failure code.
544 // Call SetCallNotify(true) below after we are sure we cannot return a failure
545 // code.
546 if (!target) {
547 inst->NewStreamListener(relativeURL, notifyData,
548 getter_AddRefs(listener));
549 if (listener) {
550 listener->SetCallNotify(false);
551 }
552 }
553
554 switch (type) {
555 case eNPPStreamTypeInternal_Get:
556 {
557 if (NS_FAILED(pluginHost->GetURL(inst, relativeURL, target, listener,
558 nullptr, nullptr, false)))
559 return NPERR_GENERIC_ERROR;
560 break;
561 }
562 case eNPPStreamTypeInternal_Post:
563 {
564 if (NS_FAILED(pluginHost->PostURL(inst, relativeURL, len, buf, file,
565 target, listener, nullptr, nullptr,
566 false, 0, nullptr)))
567 return NPERR_GENERIC_ERROR;
568 break;
569 }
570 default:
571 NS_ERROR("how'd I get here");
572 }
573
574 if (listener) {
575 // SetCallNotify(bDoNotify) here, see comment above.
576 listener->SetCallNotify(bDoNotify);
577 }
578
579 return NPERR_NO_ERROR;
580 }
581
582 #if defined(MOZ_MEMORY_WINDOWS)
583 extern "C" size_t malloc_usable_size(const void *ptr);
584 #endif
585
586 namespace {
587
588 static char *gNPPException;
589
590 class nsPluginThreadRunnable : public nsRunnable,
591 public PRCList
592 {
593 public:
594 nsPluginThreadRunnable(NPP instance, PluginThreadCallback func,
595 void *userData);
596 virtual ~nsPluginThreadRunnable();
597
598 NS_IMETHOD Run();
599
600 bool IsForInstance(NPP instance)
601 {
602 return (mInstance == instance);
603 }
604
605 void Invalidate()
606 {
607 mFunc = nullptr;
608 }
609
610 bool IsValid()
611 {
612 return (mFunc != nullptr);
613 }
614
615 private:
616 NPP mInstance;
617 PluginThreadCallback mFunc;
618 void *mUserData;
619 };
620
621 static nsIDocument *
622 GetDocumentFromNPP(NPP npp)
623 {
624 NS_ENSURE_TRUE(npp, nullptr);
625
626 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)npp->ndata;
627 NS_ENSURE_TRUE(inst, nullptr);
628
629 PluginDestructionGuard guard(inst);
630
631 nsRefPtr<nsPluginInstanceOwner> owner = inst->GetOwner();
632 NS_ENSURE_TRUE(owner, nullptr);
633
634 nsCOMPtr<nsIDocument> doc;
635 owner->GetDocument(getter_AddRefs(doc));
636
637 return doc;
638 }
639
640 static JSContext *
641 GetJSContextFromDoc(nsIDocument *doc)
642 {
643 nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(doc->GetWindow());
644 NS_ENSURE_TRUE(sgo, nullptr);
645
646 nsIScriptContext *scx = sgo->GetContext();
647 NS_ENSURE_TRUE(scx, nullptr);
648
649 return scx->GetNativeContext();
650 }
651
652 static JSContext *
653 GetJSContextFromNPP(NPP npp)
654 {
655 nsIDocument *doc = GetDocumentFromNPP(npp);
656 NS_ENSURE_TRUE(doc, nullptr);
657
658 return GetJSContextFromDoc(doc);
659 }
660
661 static already_AddRefed<nsIChannel>
662 GetChannelFromNPP(NPP npp)
663 {
664 nsCOMPtr<nsIDocument> doc = GetDocumentFromNPP(npp);
665 if (!doc)
666 return nullptr;
667 nsCOMPtr<nsPIDOMWindow> domwindow = doc->GetWindow();
668 nsCOMPtr<nsIChannel> channel;
669 if (domwindow) {
670 nsCOMPtr<nsIDocShell> docShell = domwindow->GetDocShell();
671 if (docShell) {
672 docShell->GetCurrentDocumentChannel(getter_AddRefs(channel));
673 }
674 }
675 return channel.forget();
676 }
677
678 static NPIdentifier
679 doGetIdentifier(JSContext *cx, const NPUTF8* name)
680 {
681 NS_ConvertUTF8toUTF16 utf16name(name);
682
683 JSString *str = ::JS_InternUCStringN(cx, utf16name.get(), utf16name.Length());
684
685 if (!str)
686 return nullptr;
687
688 return StringToNPIdentifier(cx, str);
689 }
690
691 #if defined(MOZ_MEMORY_WINDOWS)
692 BOOL
693 InHeap(HANDLE hHeap, LPVOID lpMem)
694 {
695 BOOL success = FALSE;
696 PROCESS_HEAP_ENTRY he;
697 he.lpData = nullptr;
698 while (HeapWalk(hHeap, &he) != 0) {
699 if (he.lpData == lpMem) {
700 success = TRUE;
701 break;
702 }
703 }
704 HeapUnlock(hHeap);
705 return success;
706 }
707 #endif
708
709 } /* anonymous namespace */
710
711 NPPExceptionAutoHolder::NPPExceptionAutoHolder()
712 : mOldException(gNPPException)
713 {
714 gNPPException = nullptr;
715 }
716
717 NPPExceptionAutoHolder::~NPPExceptionAutoHolder()
718 {
719 NS_ASSERTION(!gNPPException, "NPP exception not properly cleared!");
720
721 gNPPException = mOldException;
722 }
723
724 nsPluginThreadRunnable::nsPluginThreadRunnable(NPP instance,
725 PluginThreadCallback func,
726 void *userData)
727 : mInstance(instance), mFunc(func), mUserData(userData)
728 {
729 if (!sPluginThreadAsyncCallLock) {
730 // Failed to create lock, not much we can do here then...
731 mFunc = nullptr;
732
733 return;
734 }
735
736 PR_INIT_CLIST(this);
737
738 {
739 MutexAutoLock lock(*sPluginThreadAsyncCallLock);
740
741 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
742 if (!inst || !inst->IsRunning()) {
743 // The plugin was stopped, ignore this async call.
744 mFunc = nullptr;
745
746 return;
747 }
748
749 PR_APPEND_LINK(this, &sPendingAsyncCalls);
750 }
751 }
752
753 nsPluginThreadRunnable::~nsPluginThreadRunnable()
754 {
755 if (!sPluginThreadAsyncCallLock) {
756 return;
757 }
758
759 {
760 MutexAutoLock lock(*sPluginThreadAsyncCallLock);
761
762 PR_REMOVE_LINK(this);
763 }
764 }
765
766 NS_IMETHODIMP
767 nsPluginThreadRunnable::Run()
768 {
769 if (mFunc) {
770 PluginDestructionGuard guard(mInstance);
771
772 NS_TRY_SAFE_CALL_VOID(mFunc(mUserData), nullptr,
773 NS_PLUGIN_CALL_SAFE_TO_REENTER_GECKO);
774 }
775
776 return NS_OK;
777 }
778
779 void
780 OnPluginDestroy(NPP instance)
781 {
782 if (!sPluginThreadAsyncCallLock) {
783 return;
784 }
785
786 {
787 MutexAutoLock lock(*sPluginThreadAsyncCallLock);
788
789 if (PR_CLIST_IS_EMPTY(&sPendingAsyncCalls)) {
790 return;
791 }
792
793 nsPluginThreadRunnable *r =
794 (nsPluginThreadRunnable *)PR_LIST_HEAD(&sPendingAsyncCalls);
795
796 do {
797 if (r->IsForInstance(instance)) {
798 r->Invalidate();
799 }
800
801 r = (nsPluginThreadRunnable *)PR_NEXT_LINK(r);
802 } while (r != &sPendingAsyncCalls);
803 }
804 }
805
806 void
807 OnShutdown()
808 {
809 NS_ASSERTION(PR_CLIST_IS_EMPTY(&sPendingAsyncCalls),
810 "Pending async plugin call list not cleaned up!");
811
812 if (sPluginThreadAsyncCallLock) {
813 delete sPluginThreadAsyncCallLock;
814
815 sPluginThreadAsyncCallLock = nullptr;
816 }
817 }
818
819 AsyncCallbackAutoLock::AsyncCallbackAutoLock()
820 {
821 if (sPluginThreadAsyncCallLock) {
822 sPluginThreadAsyncCallLock->Lock();
823 }
824 }
825
826 AsyncCallbackAutoLock::~AsyncCallbackAutoLock()
827 {
828 if (sPluginThreadAsyncCallLock) {
829 sPluginThreadAsyncCallLock->Unlock();
830 }
831 }
832
833
834 NPP NPPStack::sCurrentNPP = nullptr;
835
836 const char *
837 PeekException()
838 {
839 return gNPPException;
840 }
841
842 void
843 PopException()
844 {
845 NS_ASSERTION(gNPPException, "Uh, no NPP exception to pop!");
846
847 if (gNPPException) {
848 free(gNPPException);
849
850 gNPPException = nullptr;
851 }
852 }
853
854 //
855 // Static callbacks that get routed back through the new C++ API
856 //
857
858 namespace mozilla {
859 namespace plugins {
860 namespace parent {
861
862 NPError
863 _geturl(NPP npp, const char* relativeURL, const char* target)
864 {
865 if (!NS_IsMainThread()) {
866 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_geturl called from the wrong thread\n"));
867 return NPERR_INVALID_PARAM;
868 }
869
870 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
871 ("NPN_GetURL: npp=%p, target=%s, url=%s\n", (void *)npp, target,
872 relativeURL));
873
874 PluginDestructionGuard guard(npp);
875
876 // Block Adobe Acrobat from loading URLs that are not http:, https:,
877 // or ftp: URLs if the given target is null.
878 if (!target && relativeURL &&
879 (strncmp(relativeURL, "http:", 5) != 0) &&
880 (strncmp(relativeURL, "https:", 6) != 0) &&
881 (strncmp(relativeURL, "ftp:", 4) != 0)) {
882 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *) npp->ndata;
883
884
885 const char *name = nullptr;
886 nsRefPtr<nsPluginHost> host = nsPluginHost::GetInst();
887 host->GetPluginName(inst, &name);
888
889 if (name && strstr(name, "Adobe") && strstr(name, "Acrobat")) {
890 return NPERR_NO_ERROR;
891 }
892 }
893
894 return MakeNewNPAPIStreamInternal(npp, relativeURL, target,
895 eNPPStreamTypeInternal_Get);
896 }
897
898 NPError
899 _geturlnotify(NPP npp, const char* relativeURL, const char* target,
900 void* notifyData)
901 {
902 if (!NS_IsMainThread()) {
903 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_geturlnotify called from the wrong thread\n"));
904 return NPERR_INVALID_PARAM;
905 }
906
907 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
908 ("NPN_GetURLNotify: npp=%p, target=%s, notify=%p, url=%s\n", (void*)npp,
909 target, notifyData, relativeURL));
910
911 PluginDestructionGuard guard(npp);
912
913 return MakeNewNPAPIStreamInternal(npp, relativeURL, target,
914 eNPPStreamTypeInternal_Get, true,
915 notifyData);
916 }
917
918 NPError
919 _posturlnotify(NPP npp, const char *relativeURL, const char *target,
920 uint32_t len, const char *buf, NPBool file, void *notifyData)
921 {
922 if (!NS_IsMainThread()) {
923 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_posturlnotify called from the wrong thread\n"));
924 return NPERR_INVALID_PARAM;
925 }
926 if (!buf)
927 return NPERR_INVALID_PARAM;
928
929 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
930 ("NPN_PostURLNotify: npp=%p, target=%s, len=%d, file=%d, "
931 "notify=%p, url=%s, buf=%s\n",
932 (void*)npp, target, len, file, notifyData, relativeURL,
933 buf));
934
935 PluginDestructionGuard guard(npp);
936
937 return MakeNewNPAPIStreamInternal(npp, relativeURL, target,
938 eNPPStreamTypeInternal_Post, true,
939 notifyData, len, buf, file);
940 }
941
942 NPError
943 _posturl(NPP npp, const char *relativeURL, const char *target,
944 uint32_t len, const char *buf, NPBool file)
945 {
946 if (!NS_IsMainThread()) {
947 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_posturl called from the wrong thread\n"));
948 return NPERR_INVALID_PARAM;
949 }
950 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
951 ("NPN_PostURL: npp=%p, target=%s, file=%d, len=%d, url=%s, "
952 "buf=%s\n",
953 (void*)npp, target, file, len, relativeURL, buf));
954
955 PluginDestructionGuard guard(npp);
956
957 return MakeNewNPAPIStreamInternal(npp, relativeURL, target,
958 eNPPStreamTypeInternal_Post, false, nullptr,
959 len, buf, file);
960 }
961
962 NPError
963 _newstream(NPP npp, NPMIMEType type, const char* target, NPStream* *result)
964 {
965 if (!NS_IsMainThread()) {
966 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_newstream called from the wrong thread\n"));
967 return NPERR_INVALID_PARAM;
968 }
969 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
970 ("NPN_NewStream: npp=%p, type=%s, target=%s\n", (void*)npp,
971 (const char *)type, target));
972
973 NPError err = NPERR_INVALID_INSTANCE_ERROR;
974 if (npp && npp->ndata) {
975 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance*)npp->ndata;
976
977 PluginDestructionGuard guard(inst);
978
979 nsCOMPtr<nsIOutputStream> stream;
980 if (NS_SUCCEEDED(inst->NewStreamFromPlugin((const char*) type, target,
981 getter_AddRefs(stream)))) {
982 nsNPAPIStreamWrapper* wrapper = new nsNPAPIStreamWrapper(stream, nullptr);
983 if (wrapper) {
984 (*result) = &wrapper->mNPStream;
985 err = NPERR_NO_ERROR;
986 } else {
987 err = NPERR_OUT_OF_MEMORY_ERROR;
988 }
989 } else {
990 err = NPERR_GENERIC_ERROR;
991 }
992 }
993 return err;
994 }
995
996 int32_t
997 _write(NPP npp, NPStream *pstream, int32_t len, void *buffer)
998 {
999 if (!NS_IsMainThread()) {
1000 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_write called from the wrong thread\n"));
1001 return 0;
1002 }
1003 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
1004 ("NPN_Write: npp=%p, url=%s, len=%d, buffer=%s\n", (void*)npp,
1005 pstream->url, len, (char*)buffer));
1006
1007 // negative return indicates failure to the plugin
1008 if (!npp)
1009 return -1;
1010
1011 PluginDestructionGuard guard(npp);
1012
1013 nsNPAPIStreamWrapper* wrapper = static_cast<nsNPAPIStreamWrapper*>(pstream->ndata);
1014 if (!wrapper) {
1015 return -1;
1016 }
1017
1018 nsIOutputStream* stream = wrapper->GetOutputStream();
1019 if (!stream) {
1020 return -1;
1021 }
1022
1023 uint32_t count = 0;
1024 nsresult rv = stream->Write((char *)buffer, len, &count);
1025
1026 if (NS_FAILED(rv)) {
1027 return -1;
1028 }
1029
1030 return (int32_t)count;
1031 }
1032
1033 NPError
1034 _destroystream(NPP npp, NPStream *pstream, NPError reason)
1035 {
1036 if (!NS_IsMainThread()) {
1037 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_write called from the wrong thread\n"));
1038 return NPERR_INVALID_PARAM;
1039 }
1040 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
1041 ("NPN_DestroyStream: npp=%p, url=%s, reason=%d\n", (void*)npp,
1042 pstream->url, (int)reason));
1043
1044 if (!npp)
1045 return NPERR_INVALID_INSTANCE_ERROR;
1046
1047 PluginDestructionGuard guard(npp);
1048
1049 nsNPAPIStreamWrapper *streamWrapper = static_cast<nsNPAPIStreamWrapper*>(pstream->ndata);
1050 if (!streamWrapper) {
1051 return NPERR_INVALID_PARAM;
1052 }
1053
1054 nsNPAPIPluginStreamListener *listener = streamWrapper->GetStreamListener();
1055 if (listener) {
1056 // This type of stream is going from the browser to the plugin. It's either the
1057 // initial src/data stream or another stream resulting from NPN_GetURL* or
1058 // NPN_PostURL*.
1059 //
1060 // Calling OnStopBinding on the listener may cause it to be deleted due to the
1061 // releasing of its last references.
1062 listener->OnStopBinding(nullptr, NS_BINDING_ABORTED);
1063 } else {
1064 // This type of stream (NPStream) was created via NPN_NewStream. The plugin holds
1065 // the reference until it is to be deleted here. Deleting the wrapper will
1066 // release the wrapped nsIOutputStream.
1067 //
1068 // The NPStream the plugin references should always be a sub-object of it's own
1069 // 'ndata', which is our nsNPAPIStramWrapper. See bug 548441.
1070 NS_ASSERTION((char*)streamWrapper <= (char*)pstream &&
1071 ((char*)pstream) + sizeof(*pstream)
1072 <= ((char*)streamWrapper) + sizeof(*streamWrapper),
1073 "pstream is not a subobject of wrapper");
1074 delete streamWrapper;
1075 }
1076
1077 // 'listener' and/or 'streamWrapper' may be invalid (deleted) at this point. Don't
1078 // touch them again!
1079
1080 return NPERR_NO_ERROR;
1081 }
1082
1083 void
1084 _status(NPP npp, const char *message)
1085 {
1086 if (!NS_IsMainThread()) {
1087 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_status called from the wrong thread\n"));
1088 return;
1089 }
1090 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_Status: npp=%p, message=%s\n",
1091 (void*)npp, message));
1092
1093 if (!npp || !npp->ndata) {
1094 NS_WARNING("_status: npp or npp->ndata == 0");
1095 return;
1096 }
1097
1098 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance*)npp->ndata;
1099
1100 PluginDestructionGuard guard(inst);
1101
1102 inst->ShowStatus(message);
1103 }
1104
1105 void
1106 _memfree (void *ptr)
1107 {
1108 if (!NS_IsMainThread()) {
1109 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_memfree called from the wrong thread\n"));
1110 }
1111 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY, ("NPN_MemFree: ptr=%p\n", ptr));
1112
1113 if (ptr)
1114 nsMemory::Free(ptr);
1115 }
1116
1117 uint32_t
1118 _memflush(uint32_t size)
1119 {
1120 if (!NS_IsMainThread()) {
1121 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_memflush called from the wrong thread\n"));
1122 }
1123 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY, ("NPN_MemFlush: size=%d\n", size));
1124
1125 nsMemory::HeapMinimize(true);
1126 return 0;
1127 }
1128
1129 void
1130 _reloadplugins(NPBool reloadPages)
1131 {
1132 if (!NS_IsMainThread()) {
1133 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_reloadplugins called from the wrong thread\n"));
1134 return;
1135 }
1136 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
1137 ("NPN_ReloadPlugins: reloadPages=%d\n", reloadPages));
1138
1139 nsCOMPtr<nsIPluginHost> pluginHost(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID));
1140 if (!pluginHost)
1141 return;
1142
1143 pluginHost->ReloadPlugins();
1144 }
1145
1146 void
1147 _invalidaterect(NPP npp, NPRect *invalidRect)
1148 {
1149 if (!NS_IsMainThread()) {
1150 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_invalidaterect called from the wrong thread\n"));
1151 return;
1152 }
1153 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
1154 ("NPN_InvalidateRect: npp=%p, top=%d, left=%d, bottom=%d, "
1155 "right=%d\n", (void *)npp, invalidRect->top,
1156 invalidRect->left, invalidRect->bottom, invalidRect->right));
1157
1158 if (!npp || !npp->ndata) {
1159 NS_WARNING("_invalidaterect: npp or npp->ndata == 0");
1160 return;
1161 }
1162
1163 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance*)npp->ndata;
1164
1165 PluginDestructionGuard guard(inst);
1166
1167 inst->InvalidateRect((NPRect *)invalidRect);
1168 }
1169
1170 void
1171 _invalidateregion(NPP npp, NPRegion invalidRegion)
1172 {
1173 if (!NS_IsMainThread()) {
1174 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_invalidateregion called from the wrong thread\n"));
1175 return;
1176 }
1177 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
1178 ("NPN_InvalidateRegion: npp=%p, region=%p\n", (void*)npp,
1179 (void*)invalidRegion));
1180
1181 if (!npp || !npp->ndata) {
1182 NS_WARNING("_invalidateregion: npp or npp->ndata == 0");
1183 return;
1184 }
1185
1186 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance*)npp->ndata;
1187
1188 PluginDestructionGuard guard(inst);
1189
1190 inst->InvalidateRegion((NPRegion)invalidRegion);
1191 }
1192
1193 void
1194 _forceredraw(NPP npp)
1195 {
1196 }
1197
1198 NPObject*
1199 _getwindowobject(NPP npp)
1200 {
1201 if (!NS_IsMainThread()) {
1202 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_getwindowobject called from the wrong thread\n"));
1203 return nullptr;
1204 }
1205
1206 // The window want to return here is the outer window, *not* the inner (since
1207 // we don't know what the plugin will do with it).
1208 nsIDocument* doc = GetDocumentFromNPP(npp);
1209 NS_ENSURE_TRUE(doc, nullptr);
1210 nsCOMPtr<nsPIDOMWindow> outer = do_QueryInterface(doc->GetWindow());
1211 NS_ENSURE_TRUE(outer, nullptr);
1212
1213 AutoJSContext cx;
1214 JS::Rooted<JSObject*> global(cx, static_cast<nsGlobalWindow*>(outer.get())->GetGlobalJSObject());
1215 return nsJSObjWrapper::GetNewOrUsed(npp, cx, global);
1216 }
1217
1218 NPObject*
1219 _getpluginelement(NPP npp)
1220 {
1221 if (!NS_IsMainThread()) {
1222 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_getpluginelement called from the wrong thread\n"));
1223 return nullptr;
1224 }
1225
1226 nsNPAPIPluginInstance* inst = static_cast<nsNPAPIPluginInstance*>(npp->ndata);
1227 if (!inst)
1228 return nullptr;
1229
1230 nsCOMPtr<nsIDOMElement> element;
1231 inst->GetDOMElement(getter_AddRefs(element));
1232
1233 if (!element)
1234 return nullptr;
1235
1236 AutoPushJSContext cx(GetJSContextFromNPP(npp));
1237 NS_ENSURE_TRUE(cx, nullptr);
1238 JSAutoRequest ar(cx); // Unnecessary once bug 868130 lands.
1239
1240 nsCOMPtr<nsIXPConnect> xpc(do_GetService(nsIXPConnect::GetCID()));
1241 NS_ENSURE_TRUE(xpc, nullptr);
1242
1243 nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
1244 xpc->WrapNative(cx, ::JS::CurrentGlobalOrNull(cx), element,
1245 NS_GET_IID(nsIDOMElement),
1246 getter_AddRefs(holder));
1247 NS_ENSURE_TRUE(holder, nullptr);
1248
1249 JS::Rooted<JSObject*> obj(cx, holder->GetJSObject());
1250 NS_ENSURE_TRUE(obj, nullptr);
1251
1252 return nsJSObjWrapper::GetNewOrUsed(npp, cx, obj);
1253 }
1254
1255 NPIdentifier
1256 _getstringidentifier(const NPUTF8* name)
1257 {
1258 if (!name) {
1259 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS, ("NPN_getstringidentifier: passed null name"));
1260 return nullptr;
1261 }
1262 if (!NS_IsMainThread()) {
1263 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_getstringidentifier called from the wrong thread\n"));
1264 }
1265
1266 AutoSafeJSContext cx;
1267 return doGetIdentifier(cx, name);
1268 }
1269
1270 void
1271 _getstringidentifiers(const NPUTF8** names, int32_t nameCount,
1272 NPIdentifier *identifiers)
1273 {
1274 if (!NS_IsMainThread()) {
1275 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_getstringidentifiers called from the wrong thread\n"));
1276 }
1277
1278 AutoSafeJSContext cx;
1279
1280 for (int32_t i = 0; i < nameCount; ++i) {
1281 if (names[i]) {
1282 identifiers[i] = doGetIdentifier(cx, names[i]);
1283 } else {
1284 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS, ("NPN_getstringidentifiers: passed null name"));
1285 identifiers[i] = nullptr;
1286 }
1287 }
1288 }
1289
1290 NPIdentifier
1291 _getintidentifier(int32_t intid)
1292 {
1293 if (!NS_IsMainThread()) {
1294 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_getstringidentifier called from the wrong thread\n"));
1295 }
1296 return IntToNPIdentifier(intid);
1297 }
1298
1299 NPUTF8*
1300 _utf8fromidentifier(NPIdentifier id)
1301 {
1302 if (!NS_IsMainThread()) {
1303 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_utf8fromidentifier called from the wrong thread\n"));
1304 }
1305 if (!id)
1306 return nullptr;
1307
1308 if (!NPIdentifierIsString(id)) {
1309 return nullptr;
1310 }
1311
1312 JSString *str = NPIdentifierToString(id);
1313
1314 return
1315 ToNewUTF8String(nsDependentString(::JS_GetInternedStringChars(str),
1316 ::JS_GetStringLength(str)));
1317 }
1318
1319 int32_t
1320 _intfromidentifier(NPIdentifier id)
1321 {
1322 if (!NS_IsMainThread()) {
1323 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_intfromidentifier called from the wrong thread\n"));
1324 }
1325
1326 if (!NPIdentifierIsInt(id)) {
1327 return INT32_MIN;
1328 }
1329
1330 return NPIdentifierToInt(id);
1331 }
1332
1333 bool
1334 _identifierisstring(NPIdentifier id)
1335 {
1336 if (!NS_IsMainThread()) {
1337 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_identifierisstring called from the wrong thread\n"));
1338 }
1339
1340 return NPIdentifierIsString(id);
1341 }
1342
1343 NPObject*
1344 _createobject(NPP npp, NPClass* aClass)
1345 {
1346 if (!NS_IsMainThread()) {
1347 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_createobject called from the wrong thread\n"));
1348 return nullptr;
1349 }
1350 if (!npp) {
1351 NS_ERROR("Null npp passed to _createobject()!");
1352
1353 return nullptr;
1354 }
1355
1356 PluginDestructionGuard guard(npp);
1357
1358 if (!aClass) {
1359 NS_ERROR("Null class passed to _createobject()!");
1360
1361 return nullptr;
1362 }
1363
1364 NPPAutoPusher nppPusher(npp);
1365
1366 NPObject *npobj;
1367
1368 if (aClass->allocate) {
1369 npobj = aClass->allocate(npp, aClass);
1370 } else {
1371 npobj = (NPObject *)PR_Malloc(sizeof(NPObject));
1372 }
1373
1374 if (npobj) {
1375 npobj->_class = aClass;
1376 npobj->referenceCount = 1;
1377 NS_LOG_ADDREF(npobj, 1, "BrowserNPObject", sizeof(NPObject));
1378 }
1379
1380 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1381 ("Created NPObject %p, NPClass %p\n", npobj, aClass));
1382
1383 return npobj;
1384 }
1385
1386 NPObject*
1387 _retainobject(NPObject* npobj)
1388 {
1389 if (!NS_IsMainThread()) {
1390 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_retainobject called from the wrong thread\n"));
1391 }
1392 if (npobj) {
1393 #ifdef NS_BUILD_REFCNT_LOGGING
1394 int32_t refCnt =
1395 #endif
1396 PR_ATOMIC_INCREMENT((int32_t*)&npobj->referenceCount);
1397 NS_LOG_ADDREF(npobj, refCnt, "BrowserNPObject", sizeof(NPObject));
1398 }
1399
1400 return npobj;
1401 }
1402
1403 void
1404 _releaseobject(NPObject* npobj)
1405 {
1406 if (!NS_IsMainThread()) {
1407 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_releaseobject called from the wrong thread\n"));
1408 }
1409 if (!npobj)
1410 return;
1411
1412 int32_t refCnt = PR_ATOMIC_DECREMENT((int32_t*)&npobj->referenceCount);
1413 NS_LOG_RELEASE(npobj, refCnt, "BrowserNPObject");
1414
1415 if (refCnt == 0) {
1416 nsNPObjWrapper::OnDestroy(npobj);
1417
1418 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1419 ("Deleting NPObject %p, refcount hit 0\n", npobj));
1420
1421 if (npobj->_class && npobj->_class->deallocate) {
1422 npobj->_class->deallocate(npobj);
1423 } else {
1424 PR_Free(npobj);
1425 }
1426 }
1427 }
1428
1429 bool
1430 _invoke(NPP npp, NPObject* npobj, NPIdentifier method, const NPVariant *args,
1431 uint32_t argCount, NPVariant *result)
1432 {
1433 if (!NS_IsMainThread()) {
1434 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_invoke called from the wrong thread\n"));
1435 return false;
1436 }
1437 if (!npp || !npobj || !npobj->_class || !npobj->_class->invoke)
1438 return false;
1439
1440 PluginDestructionGuard guard(npp);
1441
1442 NPPExceptionAutoHolder nppExceptionHolder;
1443 NPPAutoPusher nppPusher(npp);
1444
1445 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1446 ("NPN_Invoke(npp %p, npobj %p, method %p, args %d\n", npp,
1447 npobj, method, argCount));
1448
1449 return npobj->_class->invoke(npobj, method, args, argCount, result);
1450 }
1451
1452 bool
1453 _invokeDefault(NPP npp, NPObject* npobj, const NPVariant *args,
1454 uint32_t argCount, NPVariant *result)
1455 {
1456 if (!NS_IsMainThread()) {
1457 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_invokedefault called from the wrong thread\n"));
1458 return false;
1459 }
1460 if (!npp || !npobj || !npobj->_class || !npobj->_class->invokeDefault)
1461 return false;
1462
1463 NPPExceptionAutoHolder nppExceptionHolder;
1464 NPPAutoPusher nppPusher(npp);
1465
1466 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1467 ("NPN_InvokeDefault(npp %p, npobj %p, args %d\n", npp,
1468 npobj, argCount));
1469
1470 return npobj->_class->invokeDefault(npobj, args, argCount, result);
1471 }
1472
1473 bool
1474 _evaluate(NPP npp, NPObject* npobj, NPString *script, NPVariant *result)
1475 {
1476 if (!NS_IsMainThread()) {
1477 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_evaluate called from the wrong thread\n"));
1478 return false;
1479 }
1480 if (!npp)
1481 return false;
1482
1483 NPPAutoPusher nppPusher(npp);
1484
1485 nsIDocument *doc = GetDocumentFromNPP(npp);
1486 NS_ENSURE_TRUE(doc, false);
1487
1488 nsGlobalWindow* win = static_cast<nsGlobalWindow*>(doc->GetInnerWindow());
1489 if (NS_WARN_IF(!win || !win->FastGetGlobalJSObject())) {
1490 return false;
1491 }
1492
1493 AutoSafeJSContext cx;
1494 JSAutoCompartment ac(cx, win->FastGetGlobalJSObject());
1495
1496 JS::Rooted<JSObject*> obj(cx, nsNPObjWrapper::GetNewOrUsed(npp, cx, npobj));
1497
1498 if (!obj) {
1499 return false;
1500 }
1501
1502 obj = JS_ObjectToInnerObject(cx, obj);
1503 NS_ABORT_IF_FALSE(obj,
1504 "JS_ObjectToInnerObject should never return null with non-null input.");
1505
1506 if (result) {
1507 // Initialize the out param to void
1508 VOID_TO_NPVARIANT(*result);
1509 }
1510
1511 if (!script || !script->UTF8Length || !script->UTF8Characters) {
1512 // Nothing to evaluate.
1513
1514 return true;
1515 }
1516
1517 NS_ConvertUTF8toUTF16 utf16script(script->UTF8Characters,
1518 script->UTF8Length);
1519
1520 nsIPrincipal *principal = doc->NodePrincipal();
1521
1522 nsAutoCString specStr;
1523 const char *spec;
1524
1525 nsCOMPtr<nsIURI> uri;
1526 principal->GetURI(getter_AddRefs(uri));
1527
1528 if (uri) {
1529 uri->GetSpec(specStr);
1530 spec = specStr.get();
1531 } else {
1532 // No URI in a principal means it's the system principal. If the
1533 // document URI is a chrome:// URI, pass that in as the URI of the
1534 // script, else pass in null for the filename as there's no way to
1535 // know where this document really came from. Passing in null here
1536 // also means that the script gets treated by XPConnect as if it
1537 // needs additional protection, which is what we want for unknown
1538 // chrome code anyways.
1539
1540 uri = doc->GetDocumentURI();
1541 bool isChrome = false;
1542
1543 if (uri && NS_SUCCEEDED(uri->SchemeIs("chrome", &isChrome)) && isChrome) {
1544 uri->GetSpec(specStr);
1545 spec = specStr.get();
1546 } else {
1547 spec = nullptr;
1548 }
1549 }
1550
1551 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1552 ("NPN_Evaluate(npp %p, npobj %p, script <<<%s>>>) called\n",
1553 npp, npobj, script->UTF8Characters));
1554
1555 JS::CompileOptions options(cx);
1556 options.setFileAndLine(spec, 0)
1557 .setVersion(JSVERSION_DEFAULT);
1558 JS::Rooted<JS::Value> rval(cx);
1559 nsJSUtils::EvaluateOptions evalOptions;
1560 nsresult rv = nsJSUtils::EvaluateString(cx, utf16script, obj, options,
1561 evalOptions, &rval);
1562
1563 return NS_SUCCEEDED(rv) &&
1564 (!result || JSValToNPVariant(npp, cx, rval, result));
1565 }
1566
1567 bool
1568 _getproperty(NPP npp, NPObject* npobj, NPIdentifier property,
1569 NPVariant *result)
1570 {
1571 if (!NS_IsMainThread()) {
1572 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_getproperty called from the wrong thread\n"));
1573 return false;
1574 }
1575 if (!npp || !npobj || !npobj->_class || !npobj->_class->getProperty)
1576 return false;
1577
1578 NPPExceptionAutoHolder nppExceptionHolder;
1579 NPPAutoPusher nppPusher(npp);
1580
1581 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1582 ("NPN_GetProperty(npp %p, npobj %p, property %p) called\n",
1583 npp, npobj, property));
1584
1585 if (!npobj->_class->getProperty(npobj, property, result))
1586 return false;
1587
1588 // If a Java plugin tries to get the document.URL or document.documentURI
1589 // property from us, don't pass back a value that Java won't be able to
1590 // understand -- one that will make the URL(String) constructor throw a
1591 // MalformedURL exception. Passing such a value causes Java Plugin2 to
1592 // crash (to throw a RuntimeException in Plugin2Manager.getDocumentBase()).
1593 // Also don't pass back a value that Java is likely to mishandle.
1594
1595 nsNPAPIPluginInstance* inst = (nsNPAPIPluginInstance*) npp->ndata;
1596 if (!inst)
1597 return false;
1598 nsNPAPIPlugin* plugin = inst->GetPlugin();
1599 if (!plugin)
1600 return false;
1601 nsRefPtr<nsPluginHost> host = nsPluginHost::GetInst();
1602 nsPluginTag* pluginTag = host->TagForPlugin(plugin);
1603 if (!pluginTag->mIsJavaPlugin)
1604 return true;
1605
1606 if (!NPVARIANT_IS_STRING(*result))
1607 return true;
1608
1609 NPUTF8* propertyName = _utf8fromidentifier(property);
1610 if (!propertyName)
1611 return true;
1612 bool notURL =
1613 (PL_strcasecmp(propertyName, "URL") &&
1614 PL_strcasecmp(propertyName, "documentURI"));
1615 _memfree(propertyName);
1616 if (notURL)
1617 return true;
1618
1619 NPObject* window_obj = _getwindowobject(npp);
1620 if (!window_obj)
1621 return true;
1622
1623 NPVariant doc_v;
1624 NPObject* document_obj = nullptr;
1625 NPIdentifier doc_id = _getstringidentifier("document");
1626 bool ok = npobj->_class->getProperty(window_obj, doc_id, &doc_v);
1627 _releaseobject(window_obj);
1628 if (ok) {
1629 if (NPVARIANT_IS_OBJECT(doc_v)) {
1630 document_obj = NPVARIANT_TO_OBJECT(doc_v);
1631 } else {
1632 _releasevariantvalue(&doc_v);
1633 return true;
1634 }
1635 } else {
1636 return true;
1637 }
1638 _releaseobject(document_obj);
1639 if (document_obj != npobj)
1640 return true;
1641
1642 NPString urlnp = NPVARIANT_TO_STRING(*result);
1643 nsXPIDLCString url;
1644 url.Assign(urlnp.UTF8Characters, urlnp.UTF8Length);
1645
1646 bool javaCompatible = false;
1647 if (NS_FAILED(NS_CheckIsJavaCompatibleURLString(url, &javaCompatible)))
1648 javaCompatible = false;
1649 if (javaCompatible)
1650 return true;
1651
1652 // If Java won't be able to interpret the original value of document.URL or
1653 // document.documentURI, or is likely to mishandle it, pass back something
1654 // that Java will understand but won't be able to use to access the network,
1655 // and for which same-origin checks will always fail.
1656
1657 if (inst->mFakeURL.IsVoid()) {
1658 // Abort (do an error return) if NS_MakeRandomInvalidURLString() fails.
1659 if (NS_FAILED(NS_MakeRandomInvalidURLString(inst->mFakeURL))) {
1660 _releasevariantvalue(result);
1661 return false;
1662 }
1663 }
1664
1665 _releasevariantvalue(result);
1666 char* fakeurl = (char *) _memalloc(inst->mFakeURL.Length() + 1);
1667 strcpy(fakeurl, inst->mFakeURL);
1668 STRINGZ_TO_NPVARIANT(fakeurl, *result);
1669
1670 return true;
1671 }
1672
1673 bool
1674 _setproperty(NPP npp, NPObject* npobj, NPIdentifier property,
1675 const NPVariant *value)
1676 {
1677 if (!NS_IsMainThread()) {
1678 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_setproperty called from the wrong thread\n"));
1679 return false;
1680 }
1681 if (!npp || !npobj || !npobj->_class || !npobj->_class->setProperty)
1682 return false;
1683
1684 NPPExceptionAutoHolder nppExceptionHolder;
1685 NPPAutoPusher nppPusher(npp);
1686
1687 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1688 ("NPN_SetProperty(npp %p, npobj %p, property %p) called\n",
1689 npp, npobj, property));
1690
1691 return npobj->_class->setProperty(npobj, property, value);
1692 }
1693
1694 bool
1695 _removeproperty(NPP npp, NPObject* npobj, NPIdentifier property)
1696 {
1697 if (!NS_IsMainThread()) {
1698 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_removeproperty called from the wrong thread\n"));
1699 return false;
1700 }
1701 if (!npp || !npobj || !npobj->_class || !npobj->_class->removeProperty)
1702 return false;
1703
1704 NPPExceptionAutoHolder nppExceptionHolder;
1705 NPPAutoPusher nppPusher(npp);
1706
1707 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1708 ("NPN_RemoveProperty(npp %p, npobj %p, property %p) called\n",
1709 npp, npobj, property));
1710
1711 return npobj->_class->removeProperty(npobj, property);
1712 }
1713
1714 bool
1715 _hasproperty(NPP npp, NPObject* npobj, NPIdentifier propertyName)
1716 {
1717 if (!NS_IsMainThread()) {
1718 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_hasproperty called from the wrong thread\n"));
1719 return false;
1720 }
1721 if (!npp || !npobj || !npobj->_class || !npobj->_class->hasProperty)
1722 return false;
1723
1724 NPPExceptionAutoHolder nppExceptionHolder;
1725 NPPAutoPusher nppPusher(npp);
1726
1727 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1728 ("NPN_HasProperty(npp %p, npobj %p, property %p) called\n",
1729 npp, npobj, propertyName));
1730
1731 return npobj->_class->hasProperty(npobj, propertyName);
1732 }
1733
1734 bool
1735 _hasmethod(NPP npp, NPObject* npobj, NPIdentifier methodName)
1736 {
1737 if (!NS_IsMainThread()) {
1738 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_hasmethod called from the wrong thread\n"));
1739 return false;
1740 }
1741 if (!npp || !npobj || !npobj->_class || !npobj->_class->hasMethod)
1742 return false;
1743
1744 NPPExceptionAutoHolder nppExceptionHolder;
1745 NPPAutoPusher nppPusher(npp);
1746
1747 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1748 ("NPN_HasMethod(npp %p, npobj %p, property %p) called\n",
1749 npp, npobj, methodName));
1750
1751 return npobj->_class->hasMethod(npobj, methodName);
1752 }
1753
1754 bool
1755 _enumerate(NPP npp, NPObject *npobj, NPIdentifier **identifier,
1756 uint32_t *count)
1757 {
1758 if (!NS_IsMainThread()) {
1759 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_enumerate called from the wrong thread\n"));
1760 return false;
1761 }
1762 if (!npp || !npobj || !npobj->_class)
1763 return false;
1764
1765 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,
1766 ("NPN_Enumerate(npp %p, npobj %p) called\n", npp, npobj));
1767
1768 if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(npobj->_class) ||
1769 !npobj->_class->enumerate) {
1770 *identifier = 0;
1771 *count = 0;
1772 return true;
1773 }
1774
1775 NPPExceptionAutoHolder nppExceptionHolder;
1776 NPPAutoPusher nppPusher(npp);
1777
1778 return npobj->_class->enumerate(npobj, identifier, count);
1779 }
1780
1781 bool
1782 _construct(NPP npp, NPObject* npobj, const NPVariant *args,
1783 uint32_t argCount, NPVariant *result)
1784 {
1785 if (!NS_IsMainThread()) {
1786 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_construct called from the wrong thread\n"));
1787 return false;
1788 }
1789 if (!npp || !npobj || !npobj->_class ||
1790 !NP_CLASS_STRUCT_VERSION_HAS_CTOR(npobj->_class) ||
1791 !npobj->_class->construct) {
1792 return false;
1793 }
1794
1795 NPPExceptionAutoHolder nppExceptionHolder;
1796 NPPAutoPusher nppPusher(npp);
1797
1798 return npobj->_class->construct(npobj, args, argCount, result);
1799 }
1800
1801 void
1802 _releasevariantvalue(NPVariant* variant)
1803 {
1804 if (!NS_IsMainThread()) {
1805 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_releasevariantvalue called from the wrong thread\n"));
1806 }
1807 switch (variant->type) {
1808 case NPVariantType_Void :
1809 case NPVariantType_Null :
1810 case NPVariantType_Bool :
1811 case NPVariantType_Int32 :
1812 case NPVariantType_Double :
1813 break;
1814 case NPVariantType_String :
1815 {
1816 const NPString *s = &NPVARIANT_TO_STRING(*variant);
1817
1818 if (s->UTF8Characters) {
1819 #if defined(MOZ_MEMORY_WINDOWS)
1820 if (malloc_usable_size((void *)s->UTF8Characters) != 0) {
1821 PR_Free((void *)s->UTF8Characters);
1822 } else {
1823 void *p = (void *)s->UTF8Characters;
1824 DWORD nheaps = 0;
1825 nsAutoTArray<HANDLE, 50> heaps;
1826 nheaps = GetProcessHeaps(0, heaps.Elements());
1827 heaps.AppendElements(nheaps);
1828 GetProcessHeaps(nheaps, heaps.Elements());
1829 for (DWORD i = 0; i < nheaps; i++) {
1830 if (InHeap(heaps[i], p)) {
1831 HeapFree(heaps[i], 0, p);
1832 break;
1833 }
1834 }
1835 }
1836 #else
1837 NS_Free((void *)s->UTF8Characters);
1838 #endif
1839 }
1840 break;
1841 }
1842 case NPVariantType_Object:
1843 {
1844 NPObject *npobj = NPVARIANT_TO_OBJECT(*variant);
1845
1846 if (npobj)
1847 _releaseobject(npobj);
1848
1849 break;
1850 }
1851 default:
1852 NS_ERROR("Unknown NPVariant type!");
1853 }
1854
1855 VOID_TO_NPVARIANT(*variant);
1856 }
1857
1858 void
1859 _setexception(NPObject* npobj, const NPUTF8 *message)
1860 {
1861 if (!NS_IsMainThread()) {
1862 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_setexception called from the wrong thread\n"));
1863 return;
1864 }
1865
1866 if (!message) return;
1867
1868 if (gNPPException) {
1869 // If a plugin throws multiple exceptions, we'll only report the
1870 // last one for now.
1871 free(gNPPException);
1872 }
1873
1874 gNPPException = strdup(message);
1875 }
1876
1877 NPError
1878 _getvalue(NPP npp, NPNVariable variable, void *result)
1879 {
1880 if (!NS_IsMainThread()) {
1881 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_getvalue called from the wrong thread\n"));
1882 return NPERR_INVALID_PARAM;
1883 }
1884 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_GetValue: npp=%p, var=%d\n",
1885 (void*)npp, (int)variable));
1886
1887 nsresult res;
1888
1889 PluginDestructionGuard guard(npp);
1890
1891 switch(variable) {
1892 #if defined(XP_UNIX) && !defined(XP_MACOSX)
1893 case NPNVxDisplay : {
1894 #if defined(MOZ_X11)
1895 if (npp) {
1896 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *) npp->ndata;
1897 bool windowless = false;
1898 inst->IsWindowless(&windowless);
1899 // The documentation on the types for many variables in NP(N|P)_GetValue
1900 // is vague. Often boolean values are NPBool (1 byte), but
1901 // https://developer.mozilla.org/en/XEmbed_Extension_for_Mozilla_Plugins
1902 // treats NPPVpluginNeedsXEmbed as PRBool (int), and
1903 // on x86/32-bit, flash stores to this using |movl 0x1,&needsXEmbed|.
1904 // thus we can't use NPBool for needsXEmbed, or the three bytes above
1905 // it on the stack would get clobbered. so protect with the larger bool.
1906 int needsXEmbed = 0;
1907 if (!windowless) {
1908 res = inst->GetValueFromPlugin(NPPVpluginNeedsXEmbed, &needsXEmbed);
1909 // If the call returned an error code make sure we still use our default value.
1910 if (NS_FAILED(res)) {
1911 needsXEmbed = 0;
1912 }
1913 }
1914 if (windowless || needsXEmbed) {
1915 (*(Display **)result) = mozilla::DefaultXDisplay();
1916 return NPERR_NO_ERROR;
1917 }
1918 }
1919 #if (MOZ_WIDGET_GTK == 2)
1920 // adobe nppdf calls XtGetApplicationNameAndClass(display,
1921 // &instance, &class) we have to init Xt toolkit before get
1922 // XtDisplay just call gtk_xtbin_new(w,0) once
1923 static GtkWidget *gtkXtBinHolder = 0;
1924 if (!gtkXtBinHolder) {
1925 gtkXtBinHolder = gtk_xtbin_new(gdk_get_default_root_window(),0);
1926 // it crashes on destroy, let it leak
1927 // gtk_widget_destroy(gtkXtBinHolder);
1928 }
1929 (*(Display **)result) = GTK_XTBIN(gtkXtBinHolder)->xtdisplay;
1930 return NPERR_NO_ERROR;
1931 #endif
1932 #endif
1933 return NPERR_GENERIC_ERROR;
1934 }
1935
1936 case NPNVxtAppContext:
1937 return NPERR_GENERIC_ERROR;
1938 #endif
1939
1940 #if defined(XP_WIN) || (MOZ_WIDGET_GTK == 2) || defined(MOZ_WIDGET_QT)
1941 case NPNVnetscapeWindow: {
1942 if (!npp || !npp->ndata)
1943 return NPERR_INVALID_INSTANCE_ERROR;
1944
1945 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *) npp->ndata;
1946
1947 nsRefPtr<nsPluginInstanceOwner> owner = inst->GetOwner();
1948 NS_ENSURE_TRUE(owner, NPERR_NO_ERROR);
1949
1950 if (NS_SUCCEEDED(owner->GetNetscapeWindow(result))) {
1951 return NPERR_NO_ERROR;
1952 }
1953 return NPERR_GENERIC_ERROR;
1954 }
1955 #endif
1956
1957 case NPNVjavascriptEnabledBool: {
1958 *(NPBool*)result = false;
1959 bool js = false;
1960 res = Preferences::GetBool("javascript.enabled", &js);
1961 if (NS_SUCCEEDED(res)) {
1962 *(NPBool*)result = js;
1963 }
1964 return NPERR_NO_ERROR;
1965 }
1966
1967 case NPNVasdEnabledBool:
1968 *(NPBool*)result = false;
1969 return NPERR_NO_ERROR;
1970
1971 case NPNVisOfflineBool: {
1972 bool offline = false;
1973 nsCOMPtr<nsIIOService> ioservice =
1974 do_GetService(NS_IOSERVICE_CONTRACTID, &res);
1975 if (NS_SUCCEEDED(res))
1976 res = ioservice->GetOffline(&offline);
1977 if (NS_FAILED(res))
1978 return NPERR_GENERIC_ERROR;
1979
1980 *(NPBool*)result = offline;
1981 return NPERR_NO_ERROR;
1982 }
1983
1984 case NPNVToolkit: {
1985 #ifdef MOZ_WIDGET_GTK
1986 *((NPNToolkitType*)result) = NPNVGtk2;
1987 #endif
1988
1989 #ifdef MOZ_WIDGET_QT
1990 /* Fake toolkit so flash plugin works */
1991 *((NPNToolkitType*)result) = NPNVGtk2;
1992 #endif
1993 if (*(NPNToolkitType*)result)
1994 return NPERR_NO_ERROR;
1995
1996 return NPERR_GENERIC_ERROR;
1997 }
1998
1999 case NPNVSupportsXEmbedBool: {
2000 #ifdef MOZ_WIDGET_GTK
2001 *(NPBool*)result = true;
2002 #elif defined(MOZ_WIDGET_QT)
2003 // Desktop Flash fail to initialize if browser does not support NPNVSupportsXEmbedBool
2004 // even when wmode!=windowed, lets return fake support
2005 fprintf(stderr, "Fake support for XEmbed plugins in Qt port\n");
2006 *(NPBool*)result = true;
2007 #else
2008 *(NPBool*)result = false;
2009 #endif
2010 return NPERR_NO_ERROR;
2011 }
2012
2013 case NPNVWindowNPObject: {
2014 *(NPObject **)result = _getwindowobject(npp);
2015
2016 return *(NPObject **)result ? NPERR_NO_ERROR : NPERR_GENERIC_ERROR;
2017 }
2018
2019 case NPNVPluginElementNPObject: {
2020 *(NPObject **)result = _getpluginelement(npp);
2021
2022 return *(NPObject **)result ? NPERR_NO_ERROR : NPERR_GENERIC_ERROR;
2023 }
2024
2025 case NPNVSupportsWindowless: {
2026 #if defined(XP_WIN) || defined(XP_MACOSX) || \
2027 (defined(MOZ_X11) && (defined(MOZ_WIDGET_GTK) || defined(MOZ_WIDGET_QT)))
2028 *(NPBool*)result = true;
2029 #else
2030 *(NPBool*)result = false;
2031 #endif
2032 return NPERR_NO_ERROR;
2033 }
2034
2035 case NPNVprivateModeBool: {
2036 bool privacy;
2037 nsNPAPIPluginInstance *inst = static_cast<nsNPAPIPluginInstance*>(npp->ndata);
2038 if (!inst)
2039 return NPERR_GENERIC_ERROR;
2040
2041 nsresult rv = inst->IsPrivateBrowsing(&privacy);
2042 if (NS_FAILED(rv))
2043 return NPERR_GENERIC_ERROR;
2044 *(NPBool*)result = (NPBool)privacy;
2045 return NPERR_NO_ERROR;
2046 }
2047
2048 case NPNVdocumentOrigin: {
2049 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)npp->ndata;
2050 if (!inst) {
2051 return NPERR_GENERIC_ERROR;
2052 }
2053
2054 nsCOMPtr<nsIDOMElement> element;
2055 inst->GetDOMElement(getter_AddRefs(element));
2056 if (!element) {
2057 return NPERR_GENERIC_ERROR;
2058 }
2059
2060 nsCOMPtr<nsIContent> content(do_QueryInterface(element));
2061 if (!content) {
2062 return NPERR_GENERIC_ERROR;
2063 }
2064
2065 nsIPrincipal* principal = content->NodePrincipal();
2066
2067 nsAutoString utf16Origin;
2068 res = nsContentUtils::GetUTFOrigin(principal, utf16Origin);
2069 if (NS_FAILED(res)) {
2070 return NPERR_GENERIC_ERROR;
2071 }
2072
2073 nsCOMPtr<nsIUnicodeNormalizer> normalizer = do_GetService(NS_UNICODE_NORMALIZER_CONTRACTID);
2074 if (!normalizer) {
2075 return NPERR_GENERIC_ERROR;
2076 }
2077
2078 nsAutoString normalizedUTF16Origin;
2079 res = normalizer->NormalizeUnicodeNFKC(utf16Origin, normalizedUTF16Origin);
2080 if (NS_FAILED(res)) {
2081 return NPERR_GENERIC_ERROR;
2082 }
2083
2084 *(char**)result = ToNewUTF8String(normalizedUTF16Origin);
2085 return *(char**)result ? NPERR_NO_ERROR : NPERR_GENERIC_ERROR;
2086 }
2087
2088 #ifdef XP_MACOSX
2089 case NPNVpluginDrawingModel: {
2090 if (npp) {
2091 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance*)npp->ndata;
2092 if (inst) {
2093 NPDrawingModel drawingModel;
2094 inst->GetDrawingModel((int32_t*)&drawingModel);
2095 *(NPDrawingModel*)result = drawingModel;
2096 return NPERR_NO_ERROR;
2097 }
2098 }
2099 else {
2100 return NPERR_GENERIC_ERROR;
2101 }
2102 }
2103
2104 #ifndef NP_NO_QUICKDRAW
2105 case NPNVsupportsQuickDrawBool: {
2106 *(NPBool*)result = false;
2107
2108 return NPERR_NO_ERROR;
2109 }
2110 #endif
2111
2112 case NPNVsupportsCoreGraphicsBool: {
2113 *(NPBool*)result = true;
2114
2115 return NPERR_NO_ERROR;
2116 }
2117
2118 case NPNVsupportsCoreAnimationBool: {
2119 *(NPBool*)result = nsCocoaFeatures::SupportCoreAnimationPlugins();
2120
2121 return NPERR_NO_ERROR;
2122 }
2123
2124 case NPNVsupportsInvalidatingCoreAnimationBool: {
2125 *(NPBool*)result = nsCocoaFeatures::SupportCoreAnimationPlugins();
2126
2127 return NPERR_NO_ERROR;
2128 }
2129
2130 case NPNVsupportsCompositingCoreAnimationPluginsBool: {
2131 *(NPBool*)result = PR_TRUE;
2132
2133 return NPERR_NO_ERROR;
2134 }
2135
2136 #ifndef NP_NO_CARBON
2137 case NPNVsupportsCarbonBool: {
2138 *(NPBool*)result = false;
2139
2140 return NPERR_NO_ERROR;
2141 }
2142 #endif
2143 case NPNVsupportsCocoaBool: {
2144 *(NPBool*)result = true;
2145
2146 return NPERR_NO_ERROR;
2147 }
2148
2149 case NPNVsupportsUpdatedCocoaTextInputBool: {
2150 *(NPBool*)result = true;
2151 return NPERR_NO_ERROR;
2152 }
2153
2154 case NPNVcontentsScaleFactor: {
2155 nsNPAPIPluginInstance *inst =
2156 (nsNPAPIPluginInstance *) (npp ? npp->ndata : nullptr);
2157 double scaleFactor = inst ? inst->GetContentsScaleFactor() : 1.0;
2158 *(double*)result = scaleFactor;
2159 return NPERR_NO_ERROR;
2160 }
2161 #endif
2162
2163 #ifdef MOZ_WIDGET_ANDROID
2164 case kLogInterfaceV0_ANPGetValue: {
2165 LOG("get log interface");
2166 ANPLogInterfaceV0 *i = (ANPLogInterfaceV0 *) result;
2167 InitLogInterface(i);
2168 return NPERR_NO_ERROR;
2169 }
2170
2171 case kBitmapInterfaceV0_ANPGetValue: {
2172 LOG("get bitmap interface");
2173 ANPBitmapInterfaceV0 *i = (ANPBitmapInterfaceV0 *) result;
2174 InitBitmapInterface(i);
2175 return NPERR_NO_ERROR;
2176 }
2177
2178 case kMatrixInterfaceV0_ANPGetValue: {
2179 LOG("get matrix interface");
2180 ANPMatrixInterfaceV0 *i = (ANPMatrixInterfaceV0 *) result;
2181 InitMatrixInterface(i);
2182 return NPERR_NO_ERROR;
2183 }
2184
2185 case kPathInterfaceV0_ANPGetValue: {
2186 LOG("get path interface");
2187 ANPPathInterfaceV0 *i = (ANPPathInterfaceV0 *) result;
2188 InitPathInterface(i);
2189 return NPERR_NO_ERROR;
2190 }
2191
2192 case kTypefaceInterfaceV0_ANPGetValue: {
2193 LOG("get typeface interface");
2194 ANPTypefaceInterfaceV0 *i = (ANPTypefaceInterfaceV0 *) result;
2195 InitTypeFaceInterface(i);
2196 return NPERR_NO_ERROR;
2197 }
2198
2199 case kPaintInterfaceV0_ANPGetValue: {
2200 LOG("get paint interface");
2201 ANPPaintInterfaceV0 *i = (ANPPaintInterfaceV0 *) result;
2202 InitPaintInterface(i);
2203 return NPERR_NO_ERROR;
2204 }
2205
2206 case kCanvasInterfaceV0_ANPGetValue: {
2207 LOG("get canvas interface");
2208 ANPCanvasInterfaceV0 *i = (ANPCanvasInterfaceV0 *) result;
2209 InitCanvasInterface(i);
2210 return NPERR_NO_ERROR;
2211 }
2212
2213 case kWindowInterfaceV0_ANPGetValue: {
2214 LOG("get window interface");
2215 ANPWindowInterfaceV0 *i = (ANPWindowInterfaceV0 *) result;
2216 InitWindowInterface(i);
2217 return NPERR_NO_ERROR;
2218 }
2219
2220 case kAudioTrackInterfaceV0_ANPGetValue: {
2221 LOG("get audio interface");
2222 ANPAudioTrackInterfaceV0 *i = (ANPAudioTrackInterfaceV0 *) result;
2223 InitAudioTrackInterfaceV0(i);
2224 return NPERR_NO_ERROR;
2225 }
2226
2227 case kEventInterfaceV0_ANPGetValue: {
2228 LOG("get event interface");
2229 ANPEventInterfaceV0 *i = (ANPEventInterfaceV0 *) result;
2230 InitEventInterface(i);
2231 return NPERR_NO_ERROR;
2232 }
2233
2234 case kSystemInterfaceV0_ANPGetValue: {
2235 LOG("get system interface");
2236 ANPSystemInterfaceV0* i = reinterpret_cast<ANPSystemInterfaceV0*>(result);
2237 InitSystemInterface(i);
2238 return NPERR_NO_ERROR;
2239 }
2240
2241 case kSurfaceInterfaceV0_ANPGetValue: {
2242 LOG("get surface interface");
2243 ANPSurfaceInterfaceV0 *i = (ANPSurfaceInterfaceV0 *) result;
2244 InitSurfaceInterface(i);
2245 return NPERR_NO_ERROR;
2246 }
2247
2248 case kSupportedDrawingModel_ANPGetValue: {
2249 LOG("get supported drawing model");
2250 uint32_t* bits = reinterpret_cast<uint32_t*>(result);
2251 *bits = kBitmap_ANPDrawingModel && kSurface_ANPDrawingModel;
2252 return NPERR_NO_ERROR;
2253 }
2254
2255 case kJavaContext_ANPGetValue: {
2256 jobject ret = mozilla::widget::android::GeckoAppShell::GetContext();
2257 if (!ret)
2258 return NPERR_GENERIC_ERROR;
2259
2260 int32_t* i = reinterpret_cast<int32_t*>(result);
2261 *i = reinterpret_cast<int32_t>(ret);
2262 return NPERR_NO_ERROR;
2263 }
2264
2265 case kAudioTrackInterfaceV1_ANPGetValue: {
2266 LOG("get audio interface v1");
2267 ANPAudioTrackInterfaceV1 *i = (ANPAudioTrackInterfaceV1 *) result;
2268 InitAudioTrackInterfaceV1(i);
2269 return NPERR_NO_ERROR;
2270 }
2271
2272 case kNativeWindowInterfaceV0_ANPGetValue: {
2273 LOG("get native window interface v0");
2274 ANPNativeWindowInterfaceV0* i = (ANPNativeWindowInterfaceV0 *) result;
2275 InitNativeWindowInterface(i);
2276 return NPERR_NO_ERROR;
2277 }
2278
2279 case kOpenGLInterfaceV0_ANPGetValue: {
2280 LOG("get openGL interface");
2281 ANPOpenGLInterfaceV0 *i = (ANPOpenGLInterfaceV0*) result;
2282 InitOpenGLInterface(i);
2283 return NPERR_NO_ERROR;
2284 }
2285
2286 case kWindowInterfaceV1_ANPGetValue: {
2287 LOG("get Window interface V1");
2288 ANPWindowInterfaceV1 *i = (ANPWindowInterfaceV1 *) result;
2289 InitWindowInterfaceV1(i);
2290 return NPERR_NO_ERROR;
2291 }
2292
2293 case kWindowInterfaceV2_ANPGetValue: {
2294 LOG("get Window interface V2");
2295 ANPWindowInterfaceV2 *i = (ANPWindowInterfaceV2 *) result;
2296 InitWindowInterfaceV2(i);
2297 return NPERR_NO_ERROR;
2298 }
2299
2300 case kVideoInterfaceV0_ANPGetValue: {
2301 LOG("get video interface");
2302 ANPVideoInterfaceV0 *i = (ANPVideoInterfaceV0*) result;
2303 InitVideoInterfaceV0(i);
2304 return NPERR_NO_ERROR;
2305 }
2306
2307 case kVideoInterfaceV1_ANPGetValue: {
2308 LOG("get video interface");
2309 ANPVideoInterfaceV1 *i = (ANPVideoInterfaceV1*) result;
2310 InitVideoInterfaceV1(i);
2311 return NPERR_NO_ERROR;
2312 }
2313
2314
2315 case kSystemInterfaceV1_ANPGetValue: {
2316 LOG("get system interface v1");
2317 ANPSystemInterfaceV1* i = reinterpret_cast<ANPSystemInterfaceV1*>(result);
2318 InitSystemInterfaceV1(i);
2319 return NPERR_NO_ERROR;
2320 }
2321
2322 case kSystemInterfaceV2_ANPGetValue: {
2323 LOG("get system interface v2");
2324 ANPSystemInterfaceV2* i = reinterpret_cast<ANPSystemInterfaceV2*>(result);
2325 InitSystemInterfaceV2(i);
2326 return NPERR_NO_ERROR;
2327 }
2328
2329 #endif
2330
2331 // we no longer hand out any XPCOM objects
2332 case NPNVDOMElement:
2333 // fall through
2334 case NPNVDOMWindow:
2335 // fall through
2336 case NPNVserviceManager:
2337 // old XPCOM objects, no longer supported, but null out the out
2338 // param to avoid crashing plugins that still try to use this.
2339 *(nsISupports**)result = nullptr;
2340 // fall through
2341 default:
2342 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_getvalue unhandled get value: %d\n", variable));
2343 return NPERR_GENERIC_ERROR;
2344 }
2345 }
2346
2347 NPError
2348 _setvalue(NPP npp, NPPVariable variable, void *result)
2349 {
2350 if (!NS_IsMainThread()) {
2351 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_setvalue called from the wrong thread\n"));
2352 return NPERR_INVALID_PARAM;
2353 }
2354 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_SetValue: npp=%p, var=%d\n",
2355 (void*)npp, (int)variable));
2356
2357 if (!npp)
2358 return NPERR_INVALID_INSTANCE_ERROR;
2359
2360 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *) npp->ndata;
2361
2362 NS_ASSERTION(inst, "null instance");
2363
2364 if (!inst)
2365 return NPERR_INVALID_INSTANCE_ERROR;
2366
2367 PluginDestructionGuard guard(inst);
2368
2369 switch (variable) {
2370
2371 // we should keep backward compatibility with NPAPI where the
2372 // actual pointer value is checked rather than its content
2373 // when passing booleans
2374 case NPPVpluginWindowBool: {
2375 #ifdef XP_MACOSX
2376 // This setting doesn't apply to OS X (only to Windows and Unix/Linux).
2377 // See https://developer.mozilla.org/En/NPN_SetValue#section_5. Return
2378 // NPERR_NO_ERROR here to conform to other browsers' behavior on OS X
2379 // (e.g. Safari and Opera).
2380 return NPERR_NO_ERROR;
2381 #else
2382 NPBool bWindowless = (result == nullptr);
2383 return inst->SetWindowless(bWindowless);
2384 #endif
2385 }
2386 case NPPVpluginTransparentBool: {
2387 NPBool bTransparent = (result != nullptr);
2388 return inst->SetTransparent(bTransparent);
2389 }
2390
2391 case NPPVjavascriptPushCallerBool: {
2392 return NPERR_NO_ERROR;
2393 }
2394
2395 case NPPVpluginKeepLibraryInMemory: {
2396 NPBool bCached = (result != nullptr);
2397 inst->SetCached(bCached);
2398 return NPERR_NO_ERROR;
2399 }
2400
2401 case NPPVpluginUsesDOMForCursorBool: {
2402 bool useDOMForCursor = (result != nullptr);
2403 return inst->SetUsesDOMForCursor(useDOMForCursor);
2404 }
2405
2406 #ifndef MOZ_WIDGET_ANDROID
2407 // On android, their 'drawing model' uses the same constant!
2408 case NPPVpluginDrawingModel: {
2409 if (inst) {
2410 inst->SetDrawingModel((NPDrawingModel)NS_PTR_TO_INT32(result));
2411 return NPERR_NO_ERROR;
2412 }
2413 else {
2414 return NPERR_GENERIC_ERROR;
2415 }
2416 }
2417 #endif
2418
2419 #ifdef XP_MACOSX
2420 case NPPVpluginEventModel: {
2421 if (inst) {
2422 inst->SetEventModel((NPEventModel)NS_PTR_TO_INT32(result));
2423 return NPERR_NO_ERROR;
2424 }
2425 else {
2426 return NPERR_GENERIC_ERROR;
2427 }
2428 }
2429 #endif
2430 #ifdef MOZ_WIDGET_ANDROID
2431 case kRequestDrawingModel_ANPSetValue:
2432 if (inst)
2433 inst->SetANPDrawingModel(NS_PTR_TO_INT32(result));
2434 return NPERR_NO_ERROR;
2435 case kAcceptEvents_ANPSetValue:
2436 return NPERR_NO_ERROR;
2437 #endif
2438 default:
2439 return NPERR_GENERIC_ERROR;
2440 }
2441 }
2442
2443 NPError
2444 _requestread(NPStream *pstream, NPByteRange *rangeList)
2445 {
2446 if (!NS_IsMainThread()) {
2447 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_requestread called from the wrong thread\n"));
2448 return NPERR_INVALID_PARAM;
2449 }
2450 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_RequestRead: stream=%p\n",
2451 (void*)pstream));
2452
2453 #ifdef PLUGIN_LOGGING
2454 for(NPByteRange * range = rangeList; range != nullptr; range = range->next)
2455 PR_LOG(nsPluginLogging::gNPNLog,PLUGIN_LOG_NOISY,
2456 ("%i-%i", range->offset, range->offset + range->length - 1));
2457
2458 PR_LOG(nsPluginLogging::gNPNLog,PLUGIN_LOG_NOISY, ("\n\n"));
2459 PR_LogFlush();
2460 #endif
2461
2462 if (!pstream || !rangeList || !pstream->ndata)
2463 return NPERR_INVALID_PARAM;
2464
2465 nsNPAPIStreamWrapper* streamWrapper = static_cast<nsNPAPIStreamWrapper*>(pstream->ndata);
2466 nsNPAPIPluginStreamListener* streamlistener = streamWrapper->GetStreamListener();
2467 if (!streamlistener) {
2468 return NPERR_GENERIC_ERROR;
2469 }
2470
2471 int32_t streamtype = NP_NORMAL;
2472
2473 streamlistener->GetStreamType(&streamtype);
2474
2475 if (streamtype != NP_SEEK)
2476 return NPERR_STREAM_NOT_SEEKABLE;
2477
2478 if (!streamlistener->mStreamListenerPeer)
2479 return NPERR_GENERIC_ERROR;
2480
2481 nsresult rv = streamlistener->mStreamListenerPeer->RequestRead((NPByteRange *)rangeList);
2482 if (NS_FAILED(rv))
2483 return NPERR_GENERIC_ERROR;
2484
2485 return NPERR_NO_ERROR;
2486 }
2487
2488 // Deprecated, only stubbed out
2489 void* /* OJI type: JRIEnv* */
2490 _getJavaEnv()
2491 {
2492 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_GetJavaEnv\n"));
2493 return nullptr;
2494 }
2495
2496 const char *
2497 _useragent(NPP npp)
2498 {
2499 if (!NS_IsMainThread()) {
2500 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_useragent called from the wrong thread\n"));
2501 return nullptr;
2502 }
2503 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_UserAgent: npp=%p\n", (void*)npp));
2504
2505 nsCOMPtr<nsIPluginHost> pluginHostCOM(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID));
2506 nsPluginHost *pluginHost = static_cast<nsPluginHost*>(pluginHostCOM.get());
2507 if (!pluginHost) {
2508 return nullptr;
2509 }
2510
2511 const char *retstr;
2512 nsresult rv = pluginHost->UserAgent(&retstr);
2513 if (NS_FAILED(rv))
2514 return nullptr;
2515
2516 return retstr;
2517 }
2518
2519 void *
2520 _memalloc (uint32_t size)
2521 {
2522 if (!NS_IsMainThread()) {
2523 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL,("NPN_memalloc called from the wrong thread\n"));
2524 }
2525 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY, ("NPN_MemAlloc: size=%d\n", size));
2526 return nsMemory::Alloc(size);
2527 }
2528
2529 // Deprecated, only stubbed out
2530 void* /* OJI type: jref */
2531 _getJavaPeer(NPP npp)
2532 {
2533 NPN_PLUGIN_LOG(PLUGIN_LOG_NORMAL, ("NPN_GetJavaPeer: npp=%p\n", (void*)npp));
2534 return nullptr;
2535 }
2536
2537 void
2538 _pushpopupsenabledstate(NPP npp, NPBool enabled)
2539 {
2540 if (!NS_IsMainThread()) {
2541 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_pushpopupsenabledstate called from the wrong thread\n"));
2542 return;
2543 }
2544 nsNPAPIPluginInstance *inst = npp ? (nsNPAPIPluginInstance *)npp->ndata : nullptr;
2545 if (!inst)
2546 return;
2547
2548 inst->PushPopupsEnabledState(enabled);
2549 }
2550
2551 void
2552 _poppopupsenabledstate(NPP npp)
2553 {
2554 if (!NS_IsMainThread()) {
2555 NPN_PLUGIN_LOG(PLUGIN_LOG_ALWAYS,("NPN_poppopupsenabledstate called from the wrong thread\n"));
2556 return;
2557 }
2558 nsNPAPIPluginInstance *inst = npp ? (nsNPAPIPluginInstance *)npp->ndata : nullptr;
2559 if (!inst)
2560 return;
2561
2562 inst->PopPopupsEnabledState();
2563 }
2564
2565 void
2566 _pluginthreadasynccall(NPP instance, PluginThreadCallback func, void *userData)
2567 {
2568 if (NS_IsMainThread()) {
2569 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,("NPN_pluginthreadasynccall called from the main thread\n"));
2570 } else {
2571 NPN_PLUGIN_LOG(PLUGIN_LOG_NOISY,("NPN_pluginthreadasynccall called from a non main thread\n"));
2572 }
2573 nsRefPtr<nsPluginThreadRunnable> evt =
2574 new nsPluginThreadRunnable(instance, func, userData);
2575
2576 if (evt && evt->IsValid()) {
2577 NS_DispatchToMainThread(evt);
2578 }
2579 }
2580
2581 NPError
2582 _getvalueforurl(NPP instance, NPNURLVariable variable, const char *url,
2583 char **value, uint32_t *len)
2584 {
2585 if (!instance) {
2586 return NPERR_INVALID_PARAM;
2587 }
2588
2589 if (!url || !*url || !len) {
2590 return NPERR_INVALID_URL;
2591 }
2592
2593 *len = 0;
2594
2595 switch (variable) {
2596 case NPNURLVProxy:
2597 {
2598 nsCOMPtr<nsIPluginHost> pluginHostCOM(do_GetService(MOZ_PLUGIN_HOST_CONTRACTID));
2599 nsPluginHost *pluginHost = static_cast<nsPluginHost*>(pluginHostCOM.get());
2600 if (pluginHost && NS_SUCCEEDED(pluginHost->FindProxyForURL(url, value))) {
2601 *len = *value ? strlen(*value) : 0;
2602 return NPERR_NO_ERROR;
2603 }
2604 break;
2605 }
2606 case NPNURLVCookie:
2607 {
2608 nsCOMPtr<nsICookieService> cookieService =
2609 do_GetService(NS_COOKIESERVICE_CONTRACTID);
2610
2611 if (!cookieService)
2612 return NPERR_GENERIC_ERROR;
2613
2614 // Make an nsURI from the url argument
2615 nsCOMPtr<nsIURI> uri;
2616 if (NS_FAILED(NS_NewURI(getter_AddRefs(uri), nsDependentCString(url)))) {
2617 return NPERR_GENERIC_ERROR;
2618 }
2619
2620 nsCOMPtr<nsIChannel> channel = GetChannelFromNPP(instance);
2621
2622 if (NS_FAILED(cookieService->GetCookieString(uri, channel, value)) ||
2623 !*value) {
2624 return NPERR_GENERIC_ERROR;
2625 }
2626
2627 *len = strlen(*value);
2628 return NPERR_NO_ERROR;
2629 }
2630
2631 break;
2632 default:
2633 // Fall through and return an error...
2634 ;
2635 }
2636
2637 return NPERR_GENERIC_ERROR;
2638 }
2639
2640 NPError
2641 _setvalueforurl(NPP instance, NPNURLVariable variable, const char *url,
2642 const char *value, uint32_t len)
2643 {
2644 if (!instance) {
2645 return NPERR_INVALID_PARAM;
2646 }
2647
2648 if (!url || !*url) {
2649 return NPERR_INVALID_URL;
2650 }
2651
2652 switch (variable) {
2653 case NPNURLVCookie:
2654 {
2655 if (!url || !value || (0 >= len))
2656 return NPERR_INVALID_PARAM;
2657
2658 nsresult rv = NS_ERROR_FAILURE;
2659 nsCOMPtr<nsIIOService> ioService(do_GetService(NS_IOSERVICE_CONTRACTID, &rv));
2660 if (NS_FAILED(rv))
2661 return NPERR_GENERIC_ERROR;
2662
2663 nsCOMPtr<nsICookieService> cookieService = do_GetService(NS_COOKIESERVICE_CONTRACTID, &rv);
2664 if (NS_FAILED(rv))
2665 return NPERR_GENERIC_ERROR;
2666
2667 nsCOMPtr<nsIURI> uriIn;
2668 rv = ioService->NewURI(nsDependentCString(url), nullptr, nullptr, getter_AddRefs(uriIn));
2669 if (NS_FAILED(rv))
2670 return NPERR_GENERIC_ERROR;
2671
2672 nsCOMPtr<nsIChannel> channel = GetChannelFromNPP(instance);
2673
2674 char *cookie = (char*)value;
2675 char c = cookie[len];
2676 cookie[len] = '\0';
2677 rv = cookieService->SetCookieString(uriIn, nullptr, cookie, channel);
2678 cookie[len] = c;
2679 if (NS_SUCCEEDED(rv))
2680 return NPERR_NO_ERROR;
2681 }
2682
2683 break;
2684 case NPNURLVProxy:
2685 // We don't support setting proxy values, fall through...
2686 default:
2687 // Fall through and return an error...
2688 ;
2689 }
2690
2691 return NPERR_GENERIC_ERROR;
2692 }
2693
2694 NPError
2695 _getauthenticationinfo(NPP instance, const char *protocol, const char *host,
2696 int32_t port, const char *scheme, const char *realm,
2697 char **username, uint32_t *ulen, char **password,
2698 uint32_t *plen)
2699 {
2700 if (!instance || !protocol || !host || !scheme || !realm || !username ||
2701 !ulen || !password || !plen)
2702 return NPERR_INVALID_PARAM;
2703
2704 *username = nullptr;
2705 *password = nullptr;
2706 *ulen = 0;
2707 *plen = 0;
2708
2709 nsDependentCString proto(protocol);
2710
2711 if (!proto.LowerCaseEqualsLiteral("http") &&
2712 !proto.LowerCaseEqualsLiteral("https"))
2713 return NPERR_GENERIC_ERROR;
2714
2715 nsCOMPtr<nsIHttpAuthManager> authManager =
2716 do_GetService("@mozilla.org/network/http-auth-manager;1");
2717 if (!authManager)
2718 return NPERR_GENERIC_ERROR;
2719
2720 nsNPAPIPluginInstance *inst = static_cast<nsNPAPIPluginInstance*>(instance->ndata);
2721 if (!inst)
2722 return NPERR_GENERIC_ERROR;
2723
2724 bool authPrivate = false;
2725 if (NS_FAILED(inst->IsPrivateBrowsing(&authPrivate)))
2726 return NPERR_GENERIC_ERROR;
2727
2728 nsIDocument *doc = GetDocumentFromNPP(instance);
2729 NS_ENSURE_TRUE(doc, NPERR_GENERIC_ERROR);
2730 nsIPrincipal *principal = doc->NodePrincipal();
2731
2732 nsAutoString unused, uname16, pwd16;
2733 if (NS_FAILED(authManager->GetAuthIdentity(proto, nsDependentCString(host),
2734 port, nsDependentCString(scheme),
2735 nsDependentCString(realm),
2736 EmptyCString(), unused, uname16,
2737 pwd16, authPrivate, principal))) {
2738 return NPERR_GENERIC_ERROR;
2739 }
2740
2741 NS_ConvertUTF16toUTF8 uname8(uname16);
2742 NS_ConvertUTF16toUTF8 pwd8(pwd16);
2743
2744 *username = ToNewCString(uname8);
2745 *ulen = *username ? uname8.Length() : 0;
2746
2747 *password = ToNewCString(pwd8);
2748 *plen = *password ? pwd8.Length() : 0;
2749
2750 return NPERR_NO_ERROR;
2751 }
2752
2753 uint32_t
2754 _scheduletimer(NPP instance, uint32_t interval, NPBool repeat, PluginTimerFunc timerFunc)
2755 {
2756 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
2757 if (!inst)
2758 return 0;
2759
2760 return inst->ScheduleTimer(interval, repeat, timerFunc);
2761 }
2762
2763 void
2764 _unscheduletimer(NPP instance, uint32_t timerID)
2765 {
2766 #ifdef MOZ_WIDGET_ANDROID
2767 // Sometimes Flash calls this with a dead NPP instance. Ensure the one we have
2768 // here is valid and maps to a nsNPAPIPluginInstance.
2769 nsNPAPIPluginInstance *inst = nsNPAPIPluginInstance::GetFromNPP(instance);
2770 #else
2771 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
2772 #endif
2773 if (!inst)
2774 return;
2775
2776 inst->UnscheduleTimer(timerID);
2777 }
2778
2779 NPError
2780 _popupcontextmenu(NPP instance, NPMenu* menu)
2781 {
2782 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
2783 if (!inst)
2784 return NPERR_GENERIC_ERROR;
2785
2786 return inst->PopUpContextMenu(menu);
2787 }
2788
2789 NPError
2790 _initasyncsurface(NPP instance, NPSize *size, NPImageFormat format, void *initData, NPAsyncSurface *surface)
2791 {
2792 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
2793 if (!inst)
2794 return NPERR_GENERIC_ERROR;
2795
2796 return inst->InitAsyncSurface(size, format, initData, surface);
2797 }
2798
2799 NPError
2800 _finalizeasyncsurface(NPP instance, NPAsyncSurface *surface)
2801 {
2802 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
2803 if (!inst)
2804 return NPERR_GENERIC_ERROR;
2805
2806 return inst->FinalizeAsyncSurface(surface);
2807 }
2808
2809 void
2810 _setcurrentasyncsurface(NPP instance, NPAsyncSurface *surface, NPRect *changed)
2811 {
2812 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
2813 if (!inst)
2814 return;
2815
2816 inst->SetCurrentAsyncSurface(surface, changed);
2817 }
2818
2819 NPBool
2820 _convertpoint(NPP instance, double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace)
2821 {
2822 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
2823 if (!inst)
2824 return false;
2825
2826 return inst->ConvertPoint(sourceX, sourceY, sourceSpace, destX, destY, destSpace);
2827 }
2828
2829 void
2830 _urlredirectresponse(NPP instance, void* notifyData, NPBool allow)
2831 {
2832 nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)instance->ndata;
2833 if (!inst) {
2834 return;
2835 }
2836
2837 inst->URLRedirectResponse(notifyData, allow);
2838 }
2839
2840 } /* namespace parent */
2841 } /* namespace plugins */
2842 } /* namespace mozilla */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial