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()); }