PlatformCertificateInfo::PlatformCertificateInfo(const ResourceResponse& response)
{
CFURLResponseRef cfResponse = response.cfURLResponse();
if (!cfResponse)
return;
#if PLATFORM(CG)
CFDictionaryRef certificateInfo = wkGetSSLCertificateInfo(cfResponse);
if (!certificateInfo)
return;
void* data = wkGetSSLCertificateChainContext(certificateInfo);
if (!data)
return;
PCCERT_CHAIN_CONTEXT chainContext = static_cast<PCCERT_CHAIN_CONTEXT>(data);
if (chainContext->cChain < 1)
return;
// The first simple chain starts with the leaf certificate and ends with a trusted root or self-signed certificate.
PCERT_SIMPLE_CHAIN firstSimpleChain = chainContext->rgpChain[0];
for (unsigned i = 0; i < firstSimpleChain->cElement; ++i) {
PCCERT_CONTEXT certificateContext = firstSimpleChain->rgpElement[i]->pCertContext;
PCCERT_CONTEXT certificateContextCopy = ::CertDuplicateCertificateContext(certificateContext);
m_certificateChain.append(certificateContextCopy);
}
#else
// FIXME: WinCairo implementation
#endif
}
void ResourceHandle::loadResourceSynchronously(NetworkingContext* context, const ResourceRequest& request, StoredCredentials storedCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& vector)
{
LOG(Network, "ResourceHandle::loadResourceSynchronously:%s allowStoredCredentials:%u", request.url().string().utf8().data(), storedCredentials);
ASSERT(!request.isEmpty());
ASSERT(response.isNull());
ASSERT(error.isNull());
OwnPtr<WebCoreSynchronousLoaderClient> client = WebCoreSynchronousLoaderClient::create(response, error);
client->setAllowStoredCredentials(storedCredentials == AllowStoredCredentials);
RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, client.get(), false /*defersLoading*/, true /*shouldContentSniff*/));
handle->d->m_storageSession = context->storageSession();
if (handle->d->m_scheduledFailureType != NoFailure) {
error = context->blockedError(request);
return;
}
handle->createCFURLConnection(storedCredentials == AllowStoredCredentials, shouldRelaxThirdPartyCookiePolicy(context, request.url()), ResourceHandle::shouldContentSniffURL(request.url()));
CFURLConnectionScheduleWithRunLoop(handle->connection(), CFRunLoopGetCurrent(), synchronousLoadRunLoopMode());
CFURLConnectionScheduleDownloadWithRunLoop(handle->connection(), CFRunLoopGetCurrent(), synchronousLoadRunLoopMode());
CFURLConnectionStart(handle->connection());
while (!client->isDone())
CFRunLoopRunInMode(synchronousLoadRunLoopMode(), UINT_MAX, true);
CFURLConnectionCancel(handle->connection());
if (error.isNull() && response.mimeType().isNull())
setDefaultMIMEType(response.cfURLResponse());
RetainPtr<CFDataRef> data = client->data();
if (!error.isNull()) {
response = ResourceResponse(request.url(), String(), 0, String(), String());
CFErrorRef cfError = error;
CFStringRef domain = CFErrorGetDomain(cfError);
// FIXME: Return the actual response for failed authentication.
if (domain == kCFErrorDomainCFNetwork)
response.setHTTPStatusCode(CFErrorGetCode(cfError));
else
response.setHTTPStatusCode(404);
}
if (data) {
ASSERT(vector.isEmpty());
vector.append(CFDataGetBytePtr(data.get()), CFDataGetLength(data.get()));
}
}
bool ResourceResponse::platformCompare(const ResourceResponse& a, const ResourceResponse& b)
{
// CFEqual crashes if you pass it 0 so do an early check before calling it.
if (!a.cfURLResponse() || !b.cfURLResponse())
return a.cfURLResponse() == b.cfURLResponse();
return CFEqual(a.cfURLResponse(), b.cfURLResponse());
}
void ArgumentCoder<ResourceResponse>::encode(ArgumentEncoder* encoder, const ResourceResponse& resourceResponse)
{
#if USE(CFNETWORK)
bool responseIsPresent = resourceResponse.cfURLResponse();
encoder->encode(responseIsPresent);
if (!responseIsPresent)
return;
RetainPtr<CFDictionaryRef> dictionary(AdoptCF, wkCFURLResponseCreateSerializableRepresentation(resourceResponse.cfURLResponse(), CoreIPC::tokenNullTypeRef()));
CoreIPC::encode(encoder, dictionary.get());
#endif
}
void WebDownload::init(ResourceHandle* handle, const ResourceRequest& request, const ResourceResponse& response, IWebDownloadDelegate* delegate)
{
m_delegate = delegate ? delegate : DefaultDownloadDelegate::sharedInstance();
CFURLConnectionRef connection = handle->connection();
if (!connection) {
LOG_ERROR("WebDownload::WebDownload(ResourceHandle*,...) called with an inactive ResourceHandle");
return;
}
CFURLDownloadClient client = {0, this, 0, 0, 0, didStartCallback, willSendRequestCallback, didReceiveAuthenticationChallengeCallback,
didReceiveResponseCallback, willResumeWithResponseCallback, didReceiveDataCallback, shouldDecodeDataOfMIMETypeCallback,
decideDestinationWithSuggestedObjectNameCallback, didCreateDestinationCallback, didFinishCallback, didFailCallback};
m_request.adoptRef(WebMutableURLRequest::createInstance(request));
m_download.adoptCF(CFURLDownloadCreateAndStartWithLoadingConnection(0, connection, request.cfURLRequest(), response.cfURLResponse(), &client));
// It is possible for CFURLDownloadCreateAndStartWithLoadingConnection() to fail if the passed in CFURLConnection is not in a "downloadable state"
// However, we should never hit that case
if (!m_download) {
ASSERT_NOT_REACHED();
LOG_ERROR("WebDownload - Failed to create WebDownload from existing connection (%s)", request.url().string().utf8().data());
} else
LOG(Download, "WebDownload - Created WebDownload %p from existing connection (%s)", this, request.url().string().utf8().data());
// The CFURLDownload either starts successfully and retains the CFURLConnection,
// or it fails to creating and we have a now-useless connection with a dangling ref.
// Either way, we need to release the connection to balance out ref counts
handle->releaseConnectionForDownload();
CFRelease(connection);
}
void Download::startWithHandle(ResourceHandle* handle, const ResourceResponse& response)
{
ASSERT(!m_download);
CFURLConnectionRef connection = handle->connection();
if (!connection)
return;
CFURLDownloadClient client = {0, this, 0, 0, 0, didStartCallback, willSendRequestCallback, didReceiveAuthenticationChallengeCallback,
didReceiveResponseCallback, willResumeWithResponseCallback, didReceiveDataCallback, shouldDecodeDataOfMIMETypeCallback,
decideDestinationWithSuggestedObjectNameCallback, didCreateDestinationCallback, didFinishCallback, didFailCallback};
m_download.adoptCF(CFURLDownloadCreateAndStartWithLoadingConnection(0, connection, handle->firstRequest().cfURLRequest(), response.cfURLResponse(), &client));
// It is possible for CFURLDownloadCreateAndStartWithLoadingConnection() to fail if the passed in CFURLConnection is not in a "downloadable state"
// However, we should never hit that case
if (!m_download)
ASSERT_NOT_REACHED();
// The CFURLDownload either starts successfully and retains the CFURLConnection,
// or it fails to creating and we have a now-useless connection with a dangling ref.
// Either way, we need to release the connection to balance out ref counts
handle->releaseConnectionForDownload();
CFRelease(connection);
}
bool ResourceResponse::platformCompare(const ResourceResponse& a, const ResourceResponse& b)
{
return CFEqual(a.cfURLResponse(), b.cfURLResponse());
}
