blob: f25664dc11e8624ebcda0f7e2cc04d4042b51f80 [file] [log] [blame]
/*
* Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
* Copyright (C) 2008 Collabora, Ltd. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "PluginStream.h"
#include "PluginDebug.h"
#include "WebResourceLoadScheduler.h"
#include <WebCore/DocumentLoader.h>
#include <WebCore/Frame.h>
#include <WebCore/FrameLoader.h>
#include <WebCore/HTTPHeaderNames.h>
#include <WebCore/SharedBuffer.h>
#include <WebCore/SubresourceLoader.h>
#include <wtf/CompletionHandler.h>
#include <wtf/StringExtras.h>
#include <wtf/text/CString.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/text/WTFString.h>
// We use -2 here because some plugins like to return -1 to indicate error
// and this way we won't clash with them.
static const int WebReasonNone = -2;
using std::max;
using std::min;
namespace WebCore {
typedef HashMap<NPStream*, NPP> StreamMap;
static StreamMap& streams()
{
static StreamMap staticStreams;
return staticStreams;
}
PluginStream::PluginStream(PluginStreamClient* client, Frame* frame, const ResourceRequest& resourceRequest, bool sendNotification, void* notifyData, const NPPluginFuncs* pluginFuncs, NPP instance, const PluginQuirkSet& quirks)
: m_resourceRequest(resourceRequest)
, m_client(client)
, m_frame(frame)
, m_notifyData(notifyData)
, m_sendNotification(sendNotification)
, m_streamState(StreamBeforeStarted)
, m_loadManually(false)
, m_delayDeliveryTimer(*this, &PluginStream::delayDeliveryTimerFired)
, m_tempFileHandle(FileSystem::invalidPlatformFileHandle)
, m_pluginFuncs(pluginFuncs)
, m_instance(instance)
, m_quirks(quirks)
{
ASSERT(m_instance);
m_stream.url = 0;
m_stream.ndata = 0;
m_stream.pdata = 0;
m_stream.end = 0;
m_stream.notifyData = 0;
m_stream.lastmodified = 0;
m_stream.headers = 0;
streams().add(&m_stream, m_instance);
}
PluginStream::~PluginStream()
{
ASSERT(m_streamState != StreamStarted);
ASSERT(!m_loader);
fastFree((char*)m_stream.url);
streams().remove(&m_stream);
}
void PluginStream::start()
{
ASSERT(!m_loadManually);
ASSERT(m_frame);
webResourceLoadScheduler().schedulePluginStreamLoad(*m_frame, *this, ResourceRequest(m_resourceRequest), [this, protectedThis = makeRef(*this)] (RefPtr<WebCore::NetscapePlugInStreamLoader>&& loader) {
m_loader = WTFMove(loader);
});
}
void PluginStream::stop()
{
m_streamState = StreamStopped;
if (m_loadManually) {
ASSERT(!m_loader);
DocumentLoader* documentLoader = m_frame->loader().activeDocumentLoader();
ASSERT(documentLoader);
if (documentLoader->isLoadingMainResource())
documentLoader->cancelMainResourceLoad(m_frame->loader().cancelledError(m_resourceRequest));
return;
}
if (m_loader) {
m_loader->cancel();
m_loader = nullptr;
}
m_client = 0;
}
static uint32_t lastModifiedDateMS(const ResourceResponse& response)
{
auto lastModified = response.lastModified();
if (!lastModified)
return 0;
return lastModified.value().secondsSinceEpoch().millisecondsAs<uint32_t>();
}
void PluginStream::startStream()
{
ASSERT(m_streamState == StreamBeforeStarted);
const URL& responseURL = m_resourceResponse.url();
// Some plugins (Flash) expect that javascript URLs are passed back decoded as this is the
// format used when requesting the URL.
if (protocolIsJavaScript(responseURL))
m_stream.url = fastStrDup(decodeURLEscapeSequences(responseURL.string()).utf8().data());
else
m_stream.url = fastStrDup(responseURL.string().utf8().data());
CString mimeTypeStr = m_resourceResponse.mimeType().utf8();
long long expectedContentLength = m_resourceResponse.expectedContentLength();
if (m_resourceResponse.isHTTP()) {
StringBuilder stringBuilder;
String separator = ASCIILiteral(": ");
String statusLine = "HTTP " + String::number(m_resourceResponse.httpStatusCode()) + " OK\n";
stringBuilder.append(statusLine);
HTTPHeaderMap::const_iterator end = m_resourceResponse.httpHeaderFields().end();
for (HTTPHeaderMap::const_iterator it = m_resourceResponse.httpHeaderFields().begin(); it != end; ++it) {
stringBuilder.append(it->key);
stringBuilder.append(separator);
stringBuilder.append(it->value);
stringBuilder.append('\n');
}
m_headers = stringBuilder.toString().utf8();
// If the content is encoded (most likely compressed), then don't send its length to the plugin,
// which is only interested in the decoded length, not yet known at the moment.
// <rdar://problem/4470599> tracks a request for -[NSURLResponse expectedContentLength] to incorporate this logic.
String contentEncoding = m_resourceResponse.httpHeaderField(HTTPHeaderName::ContentEncoding);
if (!contentEncoding.isNull() && contentEncoding != "identity")
expectedContentLength = -1;
}
m_stream.headers = m_headers.data();
m_stream.pdata = 0;
m_stream.ndata = this;
m_stream.end = max(expectedContentLength, 0LL);
m_stream.lastmodified = lastModifiedDateMS(m_resourceResponse);
m_stream.notifyData = m_notifyData;
m_transferMode = NP_NORMAL;
m_offset = 0;
m_reason = WebReasonNone;
// Protect the stream if destroystream is called from within the newstream handler
RefPtr<PluginStream> protect(this);
// calling into a plug-in could result in re-entrance if the plug-in yields
// control to the system (rdar://5744899). prevent this by deferring further
// loading while calling into the plug-in.
if (m_loader)
m_loader->setDefersLoading(true);
NPError npErr = m_pluginFuncs->newstream(m_instance, (NPMIMEType)mimeTypeStr.data(), &m_stream, false, &m_transferMode);
if (m_loader)
m_loader->setDefersLoading(false);
// If the stream was destroyed in the call to newstream we return
if (m_reason != WebReasonNone)
return;
if (npErr != NPERR_NO_ERROR) {
cancelAndDestroyStream(npErr);
return;
}
m_streamState = StreamStarted;
if (m_transferMode == NP_NORMAL)
return;
m_path = FileSystem::openTemporaryFile("WKP", m_tempFileHandle);
// Something went wrong, cancel loading the stream
if (!FileSystem::isHandleValid(m_tempFileHandle))
cancelAndDestroyStream(NPRES_NETWORK_ERR);
}
NPP PluginStream::ownerForStream(NPStream* stream)
{
return streams().get(stream);
}
void PluginStream::cancelAndDestroyStream(NPReason reason)
{
RefPtr<PluginStream> protect(this);
destroyStream(reason);
stop();
}
void PluginStream::destroyStream(NPReason reason)
{
m_reason = reason;
if (m_reason != NPRES_DONE) {
// Stop any pending data from being streamed
if (m_deliveryData)
m_deliveryData->resize(0);
} else if (m_deliveryData && m_deliveryData->size() > 0) {
// There is more data to be streamed, don't destroy the stream now.
return;
}
destroyStream();
}
void PluginStream::destroyStream()
{
if (m_streamState == StreamStopped)
return;
ASSERT(m_reason != WebReasonNone);
ASSERT(!m_deliveryData || m_deliveryData->size() == 0);
FileSystem::closeFile(m_tempFileHandle);
bool newStreamCalled = m_stream.ndata;
// Protect from destruction if:
// NPN_DestroyStream is called from NPP_NewStream or
// PluginStreamClient::streamDidFinishLoading() removes the last reference
RefPtr<PluginStream> protect(this);
if (newStreamCalled) {
if (m_reason == NPRES_DONE && (m_transferMode == NP_ASFILE || m_transferMode == NP_ASFILEONLY)) {
ASSERT(!m_path.isNull());
if (m_loader)
m_loader->setDefersLoading(true);
m_pluginFuncs->asfile(m_instance, &m_stream, m_path.utf8().data());
if (m_loader)
m_loader->setDefersLoading(false);
}
if (m_streamState != StreamBeforeStarted) {
if (m_loader)
m_loader->setDefersLoading(true);
NPError npErr = m_pluginFuncs->destroystream(m_instance, &m_stream, m_reason);
if (m_loader)
m_loader->setDefersLoading(false);
LOG_NPERROR(npErr);
}
m_stream.ndata = 0;
}
if (m_sendNotification) {
// Flash 9 can dereference null if we call NPP_URLNotify without first calling NPP_NewStream
// for requests made with NPN_PostURLNotify; see <rdar://5588807>
if (m_loader)
m_loader->setDefersLoading(true);
if (!newStreamCalled && m_quirks.contains(PluginQuirkFlashURLNotifyBug) &&
equalLettersIgnoringASCIICase(m_resourceRequest.httpMethod(), "post")) {
m_transferMode = NP_NORMAL;
m_stream.url = "";
m_stream.notifyData = m_notifyData;
static char emptyMimeType[] = "";
m_pluginFuncs->newstream(m_instance, emptyMimeType, &m_stream, false, &m_transferMode);
m_pluginFuncs->destroystream(m_instance, &m_stream, m_reason);
// in successful requests, the URL is dynamically allocated and freed in our
// destructor, so reset it to 0
m_stream.url = 0;
}
m_pluginFuncs->urlnotify(m_instance, m_resourceRequest.url().string().utf8().data(), m_reason, m_notifyData);
if (m_loader)
m_loader->setDefersLoading(false);
}
m_streamState = StreamStopped;
if (!m_loadManually && m_client)
m_client->streamDidFinishLoading(this);
if (!m_path.isNull())
FileSystem::deleteFile(m_path);
}
void PluginStream::delayDeliveryTimerFired()
{
deliverData();
}
void PluginStream::deliverData()
{
ASSERT(m_deliveryData);
if (m_streamState == StreamStopped)
// FIXME: We should cancel our job in the SubresourceLoader on error so we don't reach this case
return;
ASSERT(m_streamState != StreamBeforeStarted);
if (!m_stream.ndata || m_deliveryData->size() == 0)
return;
int32_t totalBytes = m_deliveryData->size();
int32_t totalBytesDelivered = 0;
if (m_loader)
m_loader->setDefersLoading(true);
while (totalBytesDelivered < totalBytes) {
int32_t deliveryBytes = m_pluginFuncs->writeready(m_instance, &m_stream);
if (deliveryBytes <= 0) {
m_delayDeliveryTimer.startOneShot(0_s);
break;
} else {
deliveryBytes = min(deliveryBytes, totalBytes - totalBytesDelivered);
int32_t dataLength = deliveryBytes;
char* data = m_deliveryData->data() + totalBytesDelivered;
// Write the data
deliveryBytes = m_pluginFuncs->write(m_instance, &m_stream, m_offset, dataLength, (void*)data);
if (deliveryBytes < 0) {
LOG_PLUGIN_NET_ERROR();
if (m_loader)
m_loader->setDefersLoading(false);
cancelAndDestroyStream(NPRES_NETWORK_ERR);
return;
}
deliveryBytes = min(deliveryBytes, dataLength);
m_offset += deliveryBytes;
totalBytesDelivered += deliveryBytes;
}
}
if (m_loader)
m_loader->setDefersLoading(false);
if (totalBytesDelivered > 0) {
if (totalBytesDelivered < totalBytes) {
int remainingBytes = totalBytes - totalBytesDelivered;
memmove(m_deliveryData->data(), m_deliveryData->data() + totalBytesDelivered, remainingBytes);
m_deliveryData->resize(remainingBytes);
} else {
m_deliveryData->resize(0);
if (m_reason != WebReasonNone)
destroyStream();
}
}
}
void PluginStream::sendJavaScriptStream(const URL& requestURL, const CString& resultString)
{
didReceiveResponse(0, ResourceResponse(requestURL, "text/plain", resultString.length(), ""));
if (m_streamState == StreamStopped)
return;
if (!resultString.isNull()) {
didReceiveData(0, resultString.data(), resultString.length());
if (m_streamState == StreamStopped)
return;
}
m_loader = nullptr;
destroyStream(resultString.isNull() ? NPRES_NETWORK_ERR : NPRES_DONE);
}
void PluginStream::willSendRequest(NetscapePlugInStreamLoader*, ResourceRequest&& request, const ResourceResponse&, CompletionHandler<void(WebCore::ResourceRequest&&)>&& callback)
{
// FIXME: We should notify the plug-in with NPP_URLRedirectNotify here.
callback(WTFMove(request));
}
void PluginStream::didReceiveResponse(NetscapePlugInStreamLoader* loader, const ResourceResponse& response)
{
ASSERT_UNUSED(loader, loader == m_loader);
ASSERT(m_streamState == StreamBeforeStarted);
m_resourceResponse = response;
startStream();
}
void PluginStream::didReceiveData(NetscapePlugInStreamLoader* loader, const char* data, int length)
{
ASSERT_UNUSED(loader, loader == m_loader);
ASSERT(m_streamState == StreamStarted);
// If the plug-in cancels the stream in deliverData it could be deleted,
// so protect it here.
RefPtr<PluginStream> protect(this);
if (m_transferMode != NP_ASFILEONLY) {
if (!m_deliveryData)
m_deliveryData = std::make_unique<Vector<char>>();
int oldSize = m_deliveryData->size();
m_deliveryData->resize(oldSize + length);
memcpy(m_deliveryData->data() + oldSize, data, length);
deliverData();
}
if (m_streamState != StreamStopped && FileSystem::isHandleValid(m_tempFileHandle)) {
int bytesWritten = FileSystem::writeToFile(m_tempFileHandle, data, length);
if (bytesWritten != length)
cancelAndDestroyStream(NPRES_NETWORK_ERR);
}
}
void PluginStream::didFail(NetscapePlugInStreamLoader* loader, const ResourceError&)
{
ASSERT_UNUSED(loader, loader == m_loader);
LOG_PLUGIN_NET_ERROR();
// destroyStream can result in our being deleted
RefPtr<PluginStream> protect(this);
destroyStream(NPRES_NETWORK_ERR);
m_loader = nullptr;
}
void PluginStream::didFinishLoading(NetscapePlugInStreamLoader* loader)
{
ASSERT_UNUSED(loader, loader == m_loader);
ASSERT(m_streamState == StreamStarted);
// destroyStream can result in our being deleted
RefPtr<PluginStream> protect(this);
destroyStream(NPRES_DONE);
m_loader = nullptr;
}
bool PluginStream::wantsAllStreams() const
{
if (!m_pluginFuncs->getvalue)
return false;
void* result = nullptr;
if (m_pluginFuncs->getvalue(m_instance, NPPVpluginWantsAllNetworkStreams, &result) != NPERR_NO_ERROR)
return false;
return !!result;
}
}