The Tor Browser / file comparison

comparison: dom/plugins/base/nsNPAPIPluginStreamListener.cpp

dom/plugins/base/nsNPAPIPluginStreamListener.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:9055ef88a9c8
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 "nsNPAPIPluginStreamListener.h"
7 #include "plstr.h"
8 #include "prmem.h"
9 #include "nsDirectoryServiceDefs.h"
10 #include "nsDirectoryServiceUtils.h"
11 #include "nsIFile.h"
12 #include "nsNetUtil.h"
13 #include "nsPluginHost.h"
14 #include "nsNPAPIPlugin.h"
15 #include "nsPluginLogging.h"
16 #include "nsPluginStreamListenerPeer.h"
17
18 #include <stdint.h>
19 #include <algorithm>
20
21 nsNPAPIStreamWrapper::nsNPAPIStreamWrapper(nsIOutputStream *outputStream,
22 nsNPAPIPluginStreamListener *streamListener)
23 {
24 mOutputStream = outputStream;
25 mStreamListener = streamListener;
26
27 memset(&mNPStream, 0, sizeof(mNPStream));
28 mNPStream.ndata = static_cast<void*>(this);
29 }
30
31 nsNPAPIStreamWrapper::~nsNPAPIStreamWrapper()
32 {
33 if (mOutputStream) {
34 mOutputStream->Close();
35 }
36 }
37
38 NS_IMPL_ISUPPORTS(nsPluginStreamToFile, nsIOutputStream)
39
40 nsPluginStreamToFile::nsPluginStreamToFile(const char* target,
41 nsIPluginInstanceOwner* owner)
42 : mTarget(PL_strdup(target)),
43 mOwner(owner)
44 {
45 nsresult rv;
46 nsCOMPtr<nsIFile> pluginTmp;
47 rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(pluginTmp));
48 if (NS_FAILED(rv)) return;
49
50 mTempFile = do_QueryInterface(pluginTmp, &rv);
51 if (NS_FAILED(rv)) return;
52
53 // need to create a file with a unique name - use target as the basis
54 rv = mTempFile->AppendNative(nsDependentCString(target));
55 if (NS_FAILED(rv)) return;
56
57 // Yes, make it unique.
58 rv = mTempFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0700);
59 if (NS_FAILED(rv)) return;
60
61 // create the file
62 rv = NS_NewLocalFileOutputStream(getter_AddRefs(mOutputStream), mTempFile, -1, 00600);
63 if (NS_FAILED(rv))
64 return;
65
66 // construct the URL we'll use later in calls to GetURL()
67 NS_GetURLSpecFromFile(mTempFile, mFileURL);
68
69 #ifdef DEBUG
70 printf("File URL = %s\n", mFileURL.get());
71 #endif
72 }
73
74 nsPluginStreamToFile::~nsPluginStreamToFile()
75 {
76 // should we be deleting mTempFile here?
77 if (nullptr != mTarget)
78 PL_strfree(mTarget);
79 }
80
81 NS_IMETHODIMP
82 nsPluginStreamToFile::Flush()
83 {
84 return NS_OK;
85 }
86
87 NS_IMETHODIMP
88 nsPluginStreamToFile::Write(const char* aBuf, uint32_t aCount,
89 uint32_t *aWriteCount)
90 {
91 mOutputStream->Write(aBuf, aCount, aWriteCount);
92 mOutputStream->Flush();
93 mOwner->GetURL(mFileURL.get(), mTarget, nullptr, nullptr, 0);
94
95 return NS_OK;
96 }
97
98 NS_IMETHODIMP
99 nsPluginStreamToFile::WriteFrom(nsIInputStream *inStr, uint32_t count,
100 uint32_t *_retval)
101 {
102 NS_NOTREACHED("WriteFrom");
103 return NS_ERROR_NOT_IMPLEMENTED;
104 }
105
106 NS_IMETHODIMP
107 nsPluginStreamToFile::WriteSegments(nsReadSegmentFun reader, void * closure,
108 uint32_t count, uint32_t *_retval)
109 {
110 NS_NOTREACHED("WriteSegments");
111 return NS_ERROR_NOT_IMPLEMENTED;
112 }
113
114 NS_IMETHODIMP
115 nsPluginStreamToFile::IsNonBlocking(bool *aNonBlocking)
116 {
117 *aNonBlocking = false;
118 return NS_OK;
119 }
120
121 NS_IMETHODIMP
122 nsPluginStreamToFile::Close(void)
123 {
124 mOutputStream->Close();
125 mOwner->GetURL(mFileURL.get(), mTarget, nullptr, nullptr, 0);
126 return NS_OK;
127 }
128
129 // nsNPAPIPluginStreamListener Methods
130
131 NS_IMPL_ISUPPORTS(nsNPAPIPluginStreamListener,
132 nsITimerCallback, nsIHTTPHeaderListener)
133
134 nsNPAPIPluginStreamListener::nsNPAPIPluginStreamListener(nsNPAPIPluginInstance* inst,
135 void* notifyData,
136 const char* aURL)
137 : mStreamBuffer(nullptr),
138 mNotifyURL(aURL ? PL_strdup(aURL) : nullptr),
139 mInst(inst),
140 mStreamBufferSize(0),
141 mStreamBufferByteCount(0),
142 mStreamType(NP_NORMAL),
143 mStreamStarted(false),
144 mStreamCleanedUp(false),
145 mCallNotify(notifyData ? true : false),
146 mIsSuspended(false),
147 mIsPluginInitJSStream(mInst->mInPluginInitCall &&
148 aURL && strncmp(aURL, "javascript:",
149 sizeof("javascript:") - 1) == 0),
150 mRedirectDenied(false),
151 mResponseHeaderBuf(nullptr)
152 {
153 mNPStreamWrapper = new nsNPAPIStreamWrapper(nullptr, this);
154 mNPStreamWrapper->mNPStream.notifyData = notifyData;
155 }
156
157 nsNPAPIPluginStreamListener::~nsNPAPIPluginStreamListener()
158 {
159 // remove this from the plugin instance's stream list
160 nsTArray<nsNPAPIPluginStreamListener*> *streamListeners = mInst->StreamListeners();
161 streamListeners->RemoveElement(this);
162
163 // For those cases when NewStream is never called, we still may need
164 // to fire a notification callback. Return network error as fallback
165 // reason because for other cases, notify should have already been
166 // called for other reasons elsewhere.
167 CallURLNotify(NPRES_NETWORK_ERR);
168
169 // lets get rid of the buffer
170 if (mStreamBuffer) {
171 PR_Free(mStreamBuffer);
172 mStreamBuffer=nullptr;
173 }
174
175 if (mNotifyURL)
176 PL_strfree(mNotifyURL);
177
178 if (mResponseHeaderBuf)
179 PL_strfree(mResponseHeaderBuf);
180
181 if (mNPStreamWrapper) {
182 delete mNPStreamWrapper;
183 }
184 }
185
186 nsresult
187 nsNPAPIPluginStreamListener::CleanUpStream(NPReason reason)
188 {
189 nsresult rv = NS_ERROR_FAILURE;
190
191 // Various bits of code in the rest of this method may result in the
192 // deletion of this object. Use a KungFuDeathGrip to keep ourselves
193 // alive during cleanup.
194 nsRefPtr<nsNPAPIPluginStreamListener> kungFuDeathGrip(this);
195
196 if (mStreamCleanedUp)
197 return NS_OK;
198
199 mStreamCleanedUp = true;
200
201 StopDataPump();
202
203 // Release any outstanding redirect callback.
204 if (mHTTPRedirectCallback) {
205 mHTTPRedirectCallback->OnRedirectVerifyCallback(NS_ERROR_FAILURE);
206 mHTTPRedirectCallback = nullptr;
207 }
208
209 // Seekable streams have an extra addref when they are created which must
210 // be matched here.
211 if (NP_SEEK == mStreamType && mStreamStarted)
212 NS_RELEASE_THIS();
213
214 if (mStreamListenerPeer) {
215 mStreamListenerPeer->CancelRequests(NS_BINDING_ABORTED);
216 mStreamListenerPeer = nullptr;
217 }
218
219 if (!mInst || !mInst->CanFireNotifications())
220 return rv;
221
222 PluginDestructionGuard guard(mInst);
223
224 nsNPAPIPlugin* plugin = mInst->GetPlugin();
225 if (!plugin || !plugin->GetLibrary())
226 return rv;
227
228 NPPluginFuncs* pluginFunctions = plugin->PluginFuncs();
229
230 NPP npp;
231 mInst->GetNPP(&npp);
232
233 if (mStreamStarted && pluginFunctions->destroystream) {
234 NPPAutoPusher nppPusher(npp);
235
236 NPError error;
237 NS_TRY_SAFE_CALL_RETURN(error, (*pluginFunctions->destroystream)(npp, &mNPStreamWrapper->mNPStream, reason), mInst,
238 NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO);
239
240 NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
241 ("NPP DestroyStream called: this=%p, npp=%p, reason=%d, return=%d, url=%s\n",
242 this, npp, reason, error, mNPStreamWrapper->mNPStream.url));
243
244 if (error == NPERR_NO_ERROR)
245 rv = NS_OK;
246 }
247
248 mStreamStarted = false;
249
250 // fire notification back to plugin, just like before
251 CallURLNotify(reason);
252
253 return rv;
254 }
255
256 void
257 nsNPAPIPluginStreamListener::CallURLNotify(NPReason reason)
258 {
259 if (!mCallNotify || !mInst || !mInst->CanFireNotifications())
260 return;
261
262 PluginDestructionGuard guard(mInst);
263
264 mCallNotify = false; // only do this ONCE and prevent recursion
265
266 nsNPAPIPlugin* plugin = mInst->GetPlugin();
267 if (!plugin || !plugin->GetLibrary())
268 return;
269
270 NPPluginFuncs* pluginFunctions = plugin->PluginFuncs();
271
272 if (pluginFunctions->urlnotify) {
273 NPP npp;
274 mInst->GetNPP(&npp);
275
276 NS_TRY_SAFE_CALL_VOID((*pluginFunctions->urlnotify)(npp, mNotifyURL, reason, mNPStreamWrapper->mNPStream.notifyData), mInst,
277 NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO);
278
279 NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
280 ("NPP URLNotify called: this=%p, npp=%p, notify=%p, reason=%d, url=%s\n",
281 this, npp, mNPStreamWrapper->mNPStream.notifyData, reason, mNotifyURL));
282 }
283 }
284
285 nsresult
286 nsNPAPIPluginStreamListener::OnStartBinding(nsPluginStreamListenerPeer* streamPeer)
287 {
288 if (!mInst || !mInst->CanFireNotifications() || mStreamCleanedUp)
289 return NS_ERROR_FAILURE;
290
291 PluginDestructionGuard guard(mInst);
292
293 nsNPAPIPlugin* plugin = mInst->GetPlugin();
294 if (!plugin || !plugin->GetLibrary())
295 return NS_ERROR_FAILURE;
296
297 NPPluginFuncs* pluginFunctions = plugin->PluginFuncs();
298
299 if (!pluginFunctions->newstream)
300 return NS_ERROR_FAILURE;
301
302 NPP npp;
303 mInst->GetNPP(&npp);
304
305 bool seekable;
306 char* contentType;
307 uint16_t streamType = NP_NORMAL;
308 NPError error;
309
310 streamPeer->GetURL(&mNPStreamWrapper->mNPStream.url);
311 streamPeer->GetLength((uint32_t*)&(mNPStreamWrapper->mNPStream.end));
312 streamPeer->GetLastModified((uint32_t*)&(mNPStreamWrapper->mNPStream.lastmodified));
313 streamPeer->IsSeekable(&seekable);
314 streamPeer->GetContentType(&contentType);
315
316 if (!mResponseHeaders.IsEmpty()) {
317 mResponseHeaderBuf = PL_strdup(mResponseHeaders.get());
318 mNPStreamWrapper->mNPStream.headers = mResponseHeaderBuf;
319 }
320
321 mStreamListenerPeer = streamPeer;
322
323 NPPAutoPusher nppPusher(npp);
324
325 NS_TRY_SAFE_CALL_RETURN(error, (*pluginFunctions->newstream)(npp, (char*)contentType, &mNPStreamWrapper->mNPStream, seekable, &streamType), mInst,
326 NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO);
327
328 NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
329 ("NPP NewStream called: this=%p, npp=%p, mime=%s, seek=%d, type=%d, return=%d, url=%s\n",
330 this, npp, (char *)contentType, seekable, streamType, error, mNPStreamWrapper->mNPStream.url));
331
332 if (error != NPERR_NO_ERROR)
333 return NS_ERROR_FAILURE;
334
335 switch(streamType)
336 {
337 case NP_NORMAL:
338 mStreamType = NP_NORMAL;
339 break;
340 case NP_ASFILEONLY:
341 mStreamType = NP_ASFILEONLY;
342 break;
343 case NP_ASFILE:
344 mStreamType = NP_ASFILE;
345 break;
346 case NP_SEEK:
347 mStreamType = NP_SEEK;
348 // Seekable streams should continue to exist even after OnStopRequest
349 // is fired, so we AddRef ourself an extra time and Release when the
350 // plugin calls NPN_DestroyStream (CleanUpStream). If the plugin never
351 // calls NPN_DestroyStream the stream will be destroyed before the plugin
352 // instance is destroyed.
353 NS_ADDREF_THIS();
354 break;
355 default:
356 return NS_ERROR_FAILURE;
357 }
358
359 mStreamStarted = true;
360 return NS_OK;
361 }
362
363 void
364 nsNPAPIPluginStreamListener::SuspendRequest()
365 {
366 NS_ASSERTION(!mIsSuspended,
367 "Suspending a request that's already suspended!");
368
369 nsresult rv = StartDataPump();
370 if (NS_FAILED(rv))
371 return;
372
373 mIsSuspended = true;
374
375 if (mStreamListenerPeer) {
376 mStreamListenerPeer->SuspendRequests();
377 }
378 }
379
380 void
381 nsNPAPIPluginStreamListener::ResumeRequest()
382 {
383 mStreamListenerPeer->ResumeRequests();
384 mIsSuspended = false;
385 }
386
387 nsresult
388 nsNPAPIPluginStreamListener::StartDataPump()
389 {
390 nsresult rv;
391 mDataPumpTimer = do_CreateInstance("@mozilla.org/timer;1", &rv);
392 NS_ENSURE_SUCCESS(rv, rv);
393
394 // Start pumping data to the plugin every 100ms until it obeys and
395 // eats the data.
396 return mDataPumpTimer->InitWithCallback(this, 100,
397 nsITimer::TYPE_REPEATING_SLACK);
398 }
399
400 void
401 nsNPAPIPluginStreamListener::StopDataPump()
402 {
403 if (mDataPumpTimer) {
404 mDataPumpTimer->Cancel();
405 mDataPumpTimer = nullptr;
406 }
407 }
408
409 // Return true if a javascript: load that was started while the plugin
410 // was being initialized is still in progress.
411 bool
412 nsNPAPIPluginStreamListener::PluginInitJSLoadInProgress()
413 {
414 if (!mInst)
415 return false;
416
417 nsTArray<nsNPAPIPluginStreamListener*> *streamListeners = mInst->StreamListeners();
418 for (unsigned int i = 0; i < streamListeners->Length(); i++) {
419 if (streamListeners->ElementAt(i)->mIsPluginInitJSStream) {
420 return true;
421 }
422 }
423
424 return false;
425 }
426
427 // This method is called when there's more data available off the
428 // network, but it's also called from our data pump when we're feeding
429 // the plugin data that we already got off the network, but the plugin
430 // was unable to consume it at the point it arrived. In the case when
431 // the plugin pump calls this method, the input argument will be null,
432 // and the length will be the number of bytes available in our
433 // internal buffer.
434 nsresult
435 nsNPAPIPluginStreamListener::OnDataAvailable(nsPluginStreamListenerPeer* streamPeer,
436 nsIInputStream* input,
437 uint32_t length)
438 {
439 if (!length || !mInst || !mInst->CanFireNotifications())
440 return NS_ERROR_FAILURE;
441
442 PluginDestructionGuard guard(mInst);
443
444 // Just in case the caller switches plugin info on us.
445 mStreamListenerPeer = streamPeer;
446
447 nsNPAPIPlugin* plugin = mInst->GetPlugin();
448 if (!plugin || !plugin->GetLibrary())
449 return NS_ERROR_FAILURE;
450
451 NPPluginFuncs* pluginFunctions = plugin->PluginFuncs();
452
453 // check out if plugin implements NPP_Write call
454 if (!pluginFunctions->write)
455 return NS_ERROR_FAILURE; // it'll cancel necko transaction
456
457 if (!mStreamBuffer) {
458 // To optimize the mem usage & performance we have to allocate
459 // mStreamBuffer here in first ODA when length of data available
460 // in input stream is known. mStreamBuffer will be freed in DTOR.
461 // we also have to remember the size of that buff to make safe
462 // consecutive Read() calls form input stream into our buff.
463
464 uint32_t contentLength;
465 streamPeer->GetLength(&contentLength);
466
467 mStreamBufferSize = std::max(length, contentLength);
468
469 // Limit the size of the initial buffer to MAX_PLUGIN_NECKO_BUFFER
470 // (16k). This buffer will grow if needed, as in the case where
471 // we're getting data faster than the plugin can process it.
472 mStreamBufferSize = std::min(mStreamBufferSize,
473 uint32_t(MAX_PLUGIN_NECKO_BUFFER));
474
475 mStreamBuffer = (char*) PR_Malloc(mStreamBufferSize);
476 if (!mStreamBuffer)
477 return NS_ERROR_OUT_OF_MEMORY;
478 }
479
480 // prepare NPP_ calls params
481 NPP npp;
482 mInst->GetNPP(&npp);
483
484 int32_t streamPosition;
485 streamPeer->GetStreamOffset(&streamPosition);
486 int32_t streamOffset = streamPosition;
487
488 if (input) {
489 streamOffset += length;
490
491 // Set new stream offset for the next ODA call regardless of how
492 // following NPP_Write call will behave we pretend to consume all
493 // data from the input stream. It's possible that current steam
494 // position will be overwritten from NPP_RangeRequest call made
495 // from NPP_Write, so we cannot call SetStreamOffset after
496 // NPP_Write.
497 //
498 // Note: there is a special case when data flow should be
499 // temporarily stopped if NPP_WriteReady returns 0 (bug #89270)
500 streamPeer->SetStreamOffset(streamOffset);
501
502 // set new end in case the content is compressed
503 // initial end is less than end of decompressed stream
504 // and some plugins (e.g. acrobat) can fail.
505 if ((int32_t)mNPStreamWrapper->mNPStream.end < streamOffset)
506 mNPStreamWrapper->mNPStream.end = streamOffset;
507 }
508
509 nsresult rv = NS_OK;
510 while (NS_SUCCEEDED(rv) && length > 0) {
511 if (input && length) {
512 if (mStreamBufferSize < mStreamBufferByteCount + length && mIsSuspended) {
513 // We're in the ::OnDataAvailable() call that we might get
514 // after suspending a request, or we suspended the request
515 // from within this ::OnDataAvailable() call while there's
516 // still data in the input, and we don't have enough space to
517 // store what we got off the network. Reallocate our internal
518 // buffer.
519 mStreamBufferSize = mStreamBufferByteCount + length;
520 char *buf = (char*)PR_Realloc(mStreamBuffer, mStreamBufferSize);
521 if (!buf)
522 return NS_ERROR_OUT_OF_MEMORY;
523
524 mStreamBuffer = buf;
525 }
526
527 uint32_t bytesToRead =
528 std::min(length, mStreamBufferSize - mStreamBufferByteCount);
529
530 uint32_t amountRead = 0;
531 rv = input->Read(mStreamBuffer + mStreamBufferByteCount, bytesToRead,
532 &amountRead);
533 NS_ENSURE_SUCCESS(rv, rv);
534
535 if (amountRead == 0) {
536 NS_NOTREACHED("input->Read() returns no data, it's almost impossible "
537 "to get here");
538
539 break;
540 }
541
542 mStreamBufferByteCount += amountRead;
543 length -= amountRead;
544 } else {
545 // No input, nothing to read. Set length to 0 so that we don't
546 // keep iterating through this outer loop any more.
547
548 length = 0;
549 }
550
551 // Temporary pointer to the beginning of the data we're writing as
552 // we loop and feed the plugin data.
553 char *ptrStreamBuffer = mStreamBuffer;
554
555 // it is possible plugin's NPP_Write() returns 0 byte consumed. We
556 // use zeroBytesWriteCount to count situation like this and break
557 // the loop
558 int32_t zeroBytesWriteCount = 0;
559
560 // mStreamBufferByteCount tells us how many bytes there are in the
561 // buffer. WriteReady returns to us how many bytes the plugin is
562 // ready to handle.
563 while (mStreamBufferByteCount > 0) {
564 int32_t numtowrite;
565 if (pluginFunctions->writeready) {
566 NPPAutoPusher nppPusher(npp);
567
568 NS_TRY_SAFE_CALL_RETURN(numtowrite, (*pluginFunctions->writeready)(npp, &mNPStreamWrapper->mNPStream), mInst,
569 NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO);
570 NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY,
571 ("NPP WriteReady called: this=%p, npp=%p, "
572 "return(towrite)=%d, url=%s\n",
573 this, npp, numtowrite, mNPStreamWrapper->mNPStream.url));
574
575 if (!mStreamStarted) {
576 // The plugin called NPN_DestroyStream() from within
577 // NPP_WriteReady(), kill the stream.
578
579 return NS_BINDING_ABORTED;
580 }
581
582 // if WriteReady returned 0, the plugin is not ready to handle
583 // the data, suspend the stream (if it isn't already
584 // suspended).
585 //
586 // Also suspend the stream if the stream we're loading is not
587 // a javascript: URL load that was initiated during plugin
588 // initialization and there currently is such a stream
589 // loading. This is done to work around a Windows Media Player
590 // plugin bug where it can't deal with being fed data for
591 // other streams while it's waiting for data from the
592 // javascript: URL loads it requests during
593 // initialization. See bug 386493 for more details.
594
595 if (numtowrite <= 0 ||
596 (!mIsPluginInitJSStream && PluginInitJSLoadInProgress())) {
597 if (!mIsSuspended) {
598 SuspendRequest();
599 }
600
601 // Break out of the inner loop, but keep going through the
602 // outer loop in case there's more data to read from the
603 // input stream.
604
605 break;
606 }
607
608 numtowrite = std::min(numtowrite, mStreamBufferByteCount);
609 } else {
610 // if WriteReady is not supported by the plugin, just write
611 // the whole buffer
612 numtowrite = mStreamBufferByteCount;
613 }
614
615 NPPAutoPusher nppPusher(npp);
616
617 int32_t writeCount = 0; // bytes consumed by plugin instance
618 NS_TRY_SAFE_CALL_RETURN(writeCount, (*pluginFunctions->write)(npp, &mNPStreamWrapper->mNPStream, streamPosition, numtowrite, ptrStreamBuffer), mInst,
619 NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO);
620
621 NPP_PLUGIN_LOG(PLUGIN_LOG_NOISY,
622 ("NPP Write called: this=%p, npp=%p, pos=%d, len=%d, "
623 "buf=%s, return(written)=%d, url=%s\n",
624 this, npp, streamPosition, numtowrite,
625 ptrStreamBuffer, writeCount, mNPStreamWrapper->mNPStream.url));
626
627 if (!mStreamStarted) {
628 // The plugin called NPN_DestroyStream() from within
629 // NPP_Write(), kill the stream.
630 return NS_BINDING_ABORTED;
631 }
632
633 if (writeCount > 0) {
634 NS_ASSERTION(writeCount <= mStreamBufferByteCount,
635 "Plugin read past the end of the available data!");
636
637 writeCount = std::min(writeCount, mStreamBufferByteCount);
638 mStreamBufferByteCount -= writeCount;
639
640 streamPosition += writeCount;
641
642 zeroBytesWriteCount = 0;
643
644 if (mStreamBufferByteCount > 0) {
645 // This alignment code is most likely bogus, but we'll leave
646 // it in for now in case it matters for some plugins on some
647 // architectures. Who knows...
648 if (writeCount % sizeof(intptr_t)) {
649 // memmove will take care about alignment
650 memmove(mStreamBuffer, ptrStreamBuffer + writeCount,
651 mStreamBufferByteCount);
652 ptrStreamBuffer = mStreamBuffer;
653 } else {
654 // if aligned we can use ptrStreamBuffer += to eliminate
655 // memmove()
656 ptrStreamBuffer += writeCount;
657 }
658 }
659 } else if (writeCount == 0) {
660 // if NPP_Write() returns writeCount == 0 lets say 3 times in
661 // a row, suspend the request and continue feeding the plugin
662 // the data we got so far. Once that data is consumed, we'll
663 // resume the request.
664 if (mIsSuspended || ++zeroBytesWriteCount == 3) {
665 if (!mIsSuspended) {
666 SuspendRequest();
667 }
668
669 // Break out of the for loop, but keep going through the
670 // while loop in case there's more data to read from the
671 // input stream.
672
673 break;
674 }
675 } else {
676 // Something's really wrong, kill the stream.
677 rv = NS_ERROR_FAILURE;
678
679 break;
680 }
681 } // end of inner while loop
682
683 if (mStreamBufferByteCount && mStreamBuffer != ptrStreamBuffer) {
684 memmove(mStreamBuffer, ptrStreamBuffer, mStreamBufferByteCount);
685 }
686 }
687
688 if (streamPosition != streamOffset) {
689 // The plugin didn't consume all available data, or consumed some
690 // of our cached data while we're pumping cached data. Adjust the
691 // plugin info's stream offset to match reality, except if the
692 // plugin info's stream offset was set by a re-entering
693 // NPN_RequestRead() call.
694
695 int32_t postWriteStreamPosition;
696 streamPeer->GetStreamOffset(&postWriteStreamPosition);
697
698 if (postWriteStreamPosition == streamOffset) {
699 streamPeer->SetStreamOffset(streamPosition);
700 }
701 }
702
703 return rv;
704 }
705
706 nsresult
707 nsNPAPIPluginStreamListener::OnFileAvailable(nsPluginStreamListenerPeer* streamPeer,
708 const char* fileName)
709 {
710 if (!mInst || !mInst->CanFireNotifications())
711 return NS_ERROR_FAILURE;
712
713 PluginDestructionGuard guard(mInst);
714
715 nsNPAPIPlugin* plugin = mInst->GetPlugin();
716 if (!plugin || !plugin->GetLibrary())
717 return NS_ERROR_FAILURE;
718
719 NPPluginFuncs* pluginFunctions = plugin->PluginFuncs();
720
721 if (!pluginFunctions->asfile)
722 return NS_ERROR_FAILURE;
723
724 NPP npp;
725 mInst->GetNPP(&npp);
726
727 NS_TRY_SAFE_CALL_VOID((*pluginFunctions->asfile)(npp, &mNPStreamWrapper->mNPStream, fileName), mInst,
728 NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO);
729
730 NPP_PLUGIN_LOG(PLUGIN_LOG_NORMAL,
731 ("NPP StreamAsFile called: this=%p, npp=%p, url=%s, file=%s\n",
732 this, npp, mNPStreamWrapper->mNPStream.url, fileName));
733
734 return NS_OK;
735 }
736
737 nsresult
738 nsNPAPIPluginStreamListener::OnStopBinding(nsPluginStreamListenerPeer* streamPeer,
739 nsresult status)
740 {
741 StopDataPump();
742
743 if (NS_FAILED(status)) {
744 // The stream was destroyed, or died for some reason. Make sure we
745 // cancel the underlying request.
746 if (mStreamListenerPeer) {
747 mStreamListenerPeer->CancelRequests(status);
748 }
749 }
750
751 if (!mInst || !mInst->CanFireNotifications())
752 return NS_ERROR_FAILURE;
753
754 NPReason reason = NS_FAILED(status) ? NPRES_NETWORK_ERR : NPRES_DONE;
755 if (mRedirectDenied || status == NS_BINDING_ABORTED) {
756 reason = NPRES_USER_BREAK;
757 }
758
759 // The following code can result in the deletion of 'this'. Don't
760 // assume we are alive after this!
761 //
762 // Delay cleanup if the stream is of type NP_SEEK and status isn't
763 // NS_BINDING_ABORTED (meaning the plugin hasn't called NPN_DestroyStream).
764 // This is because even though we're done delivering data the plugin may
765 // want to seek. Eventually either the plugin will call NPN_DestroyStream
766 // or we'll perform cleanup when the instance goes away. See bug 91140.
767 if (mStreamType != NP_SEEK ||
768 (NP_SEEK == mStreamType && NS_BINDING_ABORTED == status)) {
769 return CleanUpStream(reason);
770 }
771
772 return NS_OK;
773 }
774
775 nsresult
776 nsNPAPIPluginStreamListener::GetStreamType(int32_t *result)
777 {
778 *result = mStreamType;
779 return NS_OK;
780 }
781
782 NS_IMETHODIMP
783 nsNPAPIPluginStreamListener::Notify(nsITimer *aTimer)
784 {
785 NS_ASSERTION(aTimer == mDataPumpTimer, "Uh, wrong timer?");
786
787 int32_t oldStreamBufferByteCount = mStreamBufferByteCount;
788
789 nsresult rv = OnDataAvailable(mStreamListenerPeer, nullptr, mStreamBufferByteCount);
790
791 if (NS_FAILED(rv)) {
792 // We ran into an error, no need to keep firing this timer then.
793 aTimer->Cancel();
794 return NS_OK;
795 }
796
797 if (mStreamBufferByteCount != oldStreamBufferByteCount &&
798 ((mStreamStarted && mStreamBufferByteCount < 1024) ||
799 mStreamBufferByteCount == 0)) {
800 // The plugin read some data and we've got less than 1024 bytes in
801 // our buffer (or its empty and the stream is already
802 // done). Resume the request so that we get more data off the
803 // network.
804 ResumeRequest();
805 // Necko will pump data now that we've resumed the request.
806 StopDataPump();
807 }
808
809 return NS_OK;
810 }
811
812 NS_IMETHODIMP
813 nsNPAPIPluginStreamListener::StatusLine(const char* line)
814 {
815 mResponseHeaders.Append(line);
816 mResponseHeaders.Append('\n');
817 return NS_OK;
818 }
819
820 NS_IMETHODIMP
821 nsNPAPIPluginStreamListener::NewResponseHeader(const char* headerName,
822 const char* headerValue)
823 {
824 mResponseHeaders.Append(headerName);
825 mResponseHeaders.Append(": ");
826 mResponseHeaders.Append(headerValue);
827 mResponseHeaders.Append('\n');
828 return NS_OK;
829 }
830
831 bool
832 nsNPAPIPluginStreamListener::HandleRedirectNotification(nsIChannel *oldChannel, nsIChannel *newChannel,
833 nsIAsyncVerifyRedirectCallback* callback)
834 {
835 nsCOMPtr<nsIHttpChannel> oldHttpChannel = do_QueryInterface(oldChannel);
836 nsCOMPtr<nsIHttpChannel> newHttpChannel = do_QueryInterface(newChannel);
837 if (!oldHttpChannel || !newHttpChannel) {
838 return false;
839 }
840
841 if (!mInst || !mInst->CanFireNotifications()) {
842 return false;
843 }
844
845 nsNPAPIPlugin* plugin = mInst->GetPlugin();
846 if (!plugin || !plugin->GetLibrary()) {
847 return false;
848 }
849
850 NPPluginFuncs* pluginFunctions = plugin->PluginFuncs();
851 if (!pluginFunctions->urlredirectnotify) {
852 return false;
853 }
854
855 // A non-null closure is required for redirect handling support.
856 if (mNPStreamWrapper->mNPStream.notifyData) {
857 uint32_t status;
858 if (NS_SUCCEEDED(oldHttpChannel->GetResponseStatus(&status))) {
859 nsCOMPtr<nsIURI> uri;
860 if (NS_SUCCEEDED(newHttpChannel->GetURI(getter_AddRefs(uri))) && uri) {
861 nsAutoCString spec;
862 if (NS_SUCCEEDED(uri->GetAsciiSpec(spec))) {
863 // At this point the plugin will be responsible for making the callback
864 // so save the callback object.
865 mHTTPRedirectCallback = callback;
866
867 NPP npp;
868 mInst->GetNPP(&npp);
869 #if defined(XP_WIN)
870 NS_TRY_SAFE_CALL_VOID((*pluginFunctions->urlredirectnotify)(npp, spec.get(), static_cast<int32_t>(status), mNPStreamWrapper->mNPStream.notifyData), mInst,
871 NS_PLUGIN_CALL_UNSAFE_TO_REENTER_GECKO);
872 #else
873 MAIN_THREAD_JNI_REF_GUARD;
874 (*pluginFunctions->urlredirectnotify)(npp, spec.get(), static_cast<int32_t>(status), mNPStreamWrapper->mNPStream.notifyData);
875 #endif
876 return true;
877 }
878 }
879 }
880 }
881
882 callback->OnRedirectVerifyCallback(NS_ERROR_FAILURE);
883 return true;
884 }
885
886 void
887 nsNPAPIPluginStreamListener::URLRedirectResponse(NPBool allow)
888 {
889 if (mHTTPRedirectCallback) {
890 mHTTPRedirectCallback->OnRedirectVerifyCallback(allow ? NS_OK : NS_ERROR_FAILURE);
891 mRedirectDenied = allow ? false : true;
892 mHTTPRedirectCallback = nullptr;
893 }
894 }
895
896 void*
897 nsNPAPIPluginStreamListener::GetNotifyData()
898 {
899 if (mNPStreamWrapper) {
900 return mNPStreamWrapper->mNPStream.notifyData;
901 }
902 return nullptr;
903 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial