static void populateHeadersObject(ScriptObject* object, const HTTPHeaderMap& headers)
{
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) {
object->set(it->first.string(), it->second);
}
}
bool WebSocketHandshake::processHeaders(const HTTPHeaderMap& headers)
{
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != headers.end(); ++it) {
switch (m_mode) {
case Normal:
if (it->first == "websocket-origin")
m_wsOrigin = it->second;
else if (it->first == "websocket-location")
m_wsLocation = it->second;
else if (it->first == "websocket-protocol")
m_wsProtocol = it->second;
else if (it->first == "set-cookie")
m_setCookie = it->second;
else if (it->first == "set-cookie2")
m_setCookie2 = it->second;
continue;
case Incomplete:
case Failed:
case Connected:
ASSERT_NOT_REACHED();
}
ASSERT_NOT_REACHED();
}
return true;
}
void CurlDownload::addHeaders(const ResourceRequest& request)
{
if (request.httpHeaderFields().size() > 0) {
struct curl_slist* headers = 0;
HTTPHeaderMap customHeaders = request.httpHeaderFields();
HTTPHeaderMap::const_iterator end = customHeaders.end();
for (HTTPHeaderMap::const_iterator it = customHeaders.begin(); it != end; ++it) {
const String& value = it->value;
String headerString(it->key);
if (value.isEmpty())
// Insert the ; to tell curl that this header has an empty value.
headerString.append(";");
else {
headerString.append(": ");
headerString.append(value);
}
CString headerLatin1 = headerString.latin1();
headers = curl_slist_append(headers, headerLatin1.data());
}
if (headers) {
curl_easy_setopt(m_curlHandle, CURLOPT_HTTPHEADER, headers);
m_customHeaders = headers;
}
}
}
bool ArgumentCoder<ResourceResponse>::decode(ArgumentDecoder* decoder, ResourceResponse& resourceResponse)
{
if (kShouldSerializeWebCoreData) {
bool responseIsNull;
if (!decoder->decode(responseIsNull))
return false;
if (responseIsNull) {
resourceResponse = ResourceResponse();
return true;
}
ResourceResponse response;
String url;
if (!decoder->decode(url))
return false;
response.setURL(KURL(KURL(), url));
int32_t httpStatusCode;
if (!decoder->decode(httpStatusCode))
return false;
response.setHTTPStatusCode(httpStatusCode);
HTTPHeaderMap headers;
if (!decoder->decode(headers))
return false;
for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it)
response.setHTTPHeaderField(it->key, it->value);
String mimeType;
if (!decoder->decode(mimeType))
return false;
response.setMimeType(mimeType);
String textEncodingName;
if (!decoder->decode(textEncodingName))
return false;
response.setTextEncodingName(textEncodingName);
int64_t contentLength;
if (!decoder->decode(contentLength))
return false;
response.setExpectedContentLength(contentLength);
String httpStatusText;
if (!decoder->decode(httpStatusText))
return false;
response.setHTTPStatusText(httpStatusText);
String suggestedFilename;
if (!decoder->decode(suggestedFilename))
return false;
response.setSuggestedFilename(suggestedFilename);
resourceResponse = response;
}
return decodePlatformData(decoder, resourceResponse);
}
void InspectorResourceAgent::willLoadXHR(ThreadableLoaderClient* client, const String& method, const KURL& url, bool async, PassRefPtr<FormData> formData, const HTTPHeaderMap& headers, bool includeCredentials)
{
RefPtr<XHRReplayData> xhrReplayData = XHRReplayData::create(method, url, async, formData, includeCredentials);
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it!= end; ++it)
xhrReplayData->addHeader(it->key, it->value);
m_pendingXHRReplayData.set(client, xhrReplayData);
}
static PassRefPtr<InspectorObject> buildObjectForHeaders(const HTTPHeaderMap& headers)
{
RefPtr<InspectorObject> headersObject = InspectorObject::create();
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
headersObject->setString(it->first.string(), it->second);
return headersObject;
}
bool PreflightResultCacheItem::allowsCrossSiteHeaders(const HTTPHeaderMap& requestHeaders) const
{
HTTPHeaderMap::const_iterator end = requestHeaders.end();
for (HTTPHeaderMap::const_iterator it = requestHeaders.begin(); it != end; ++it) {
if (!m_headers.contains(it->first) && !isOnAccessControlSimpleRequestHeaderWhitelist(it->first))
return false;
}
return true;
}
bool CrossOriginPreflightResultCacheItem::allowsCrossOriginHeaders(const HTTPHeaderMap& requestHeaders, String& errorDescription) const
{
HTTPHeaderMap::const_iterator end = requestHeaders.end();
for (HTTPHeaderMap::const_iterator it = requestHeaders.begin(); it != end; ++it) {
if (!m_headers.contains(it->first) && !isOnAccessControlSimpleRequestHeaderWhitelist(it->first, it->second)) {
errorDescription = "Request header field " + it->first.string() + " is not allowed by Access-Control-Allow-Headers.";
return false;
}
}
return true;
}
bool FetchUtils::isSimpleOrForbiddenRequest(const String& method, const HTTPHeaderMap& headerMap)
{
if (!isSimpleMethod(method))
return false;
HTTPHeaderMap::const_iterator end = headerMap.end();
for (HTTPHeaderMap::const_iterator it = headerMap.begin(); it != end; ++it) {
if (!isSimpleHeader(it->key, it->value) && !isForbiddenHeaderName(it->key))
return false;
}
return true;
}
bool isSimpleCrossOriginAccessRequest(const String& method, const HTTPHeaderMap& headerMap)
{
if (!isOnAccessControlSimpleRequestMethodWhitelist(method))
return false;
HTTPHeaderMap::const_iterator end = headerMap.end();
for (HTTPHeaderMap::const_iterator it = headerMap.begin(); it != end; ++it) {
if (!isOnAccessControlSimpleRequestHeaderWhitelist(it->first, it->second))
return false;
}
return true;
}
bool ResourceHandle::startHttp(String urlString)
{
if (!session) {
session = soup_session_async_new();
soup_session_add_feature(session, SOUP_SESSION_FEATURE(getCookieJar()));
const char* soup_debug = g_getenv("WEBKIT_SOUP_LOGGING");
if (soup_debug) {
int soup_debug_level = atoi(soup_debug);
SoupLogger* logger = soup_logger_new(static_cast<SoupLoggerLogLevel>(soup_debug_level), -1);
soup_logger_attach(logger, session);
g_object_unref(logger);
}
}
SoupMessage* msg;
msg = soup_message_new(request().httpMethod().utf8().data(), urlString.utf8().data());
g_signal_connect(msg, "restarted", G_CALLBACK(restartedCallback), this);
g_signal_connect(msg, "got-headers", G_CALLBACK(gotHeadersCallback), this);
g_signal_connect(msg, "got-chunk", G_CALLBACK(gotChunkCallback), this);
HTTPHeaderMap customHeaders = d->m_request.httpHeaderFields();
if (!customHeaders.isEmpty()) {
HTTPHeaderMap::const_iterator end = customHeaders.end();
for (HTTPHeaderMap::const_iterator it = customHeaders.begin(); it != end; ++it)
soup_message_headers_append(msg->request_headers, it->first.utf8().data(), it->second.utf8().data());
}
FormData* httpBody = d->m_request.httpBody();
if (httpBody && !httpBody->isEmpty()) {
// Making a copy of the request body isn't the most efficient way to
// serialize it, but by far the most simple. Dealing with individual
// FormData elements and shared buffers should be more memory
// efficient.
//
// This possibly isn't handling file uploads/attachments, for which
// shared buffers or streaming should definitely be used.
Vector<char> body;
httpBody->flatten(body);
soup_message_set_request(msg, d->m_request.httpContentType().utf8().data(),
SOUP_MEMORY_COPY, body.data(), body.size());
}
d->m_msg = static_cast<SoupMessage*>(g_object_ref(msg));
soup_session_queue_message(session, d->m_msg, finishedCallback, this);
return true;
}
static void addHeadersFromHashMap(CFMutableURLRequestRef request, const HTTPHeaderMap& requestHeaders)
{
if (!requestHeaders.size())
return;
HTTPHeaderMap::const_iterator end = requestHeaders.end();
for (HTTPHeaderMap::const_iterator it = requestHeaders.begin(); it != end; ++it) {
CFStringRef key = it->first.createCFString();
CFStringRef value = it->second.createCFString();
CFURLRequestSetHTTPHeaderFieldValue(request, key, value);
CFRelease(key);
CFRelease(value);
}
}
bool FetchUtils::isSimpleRequest(const String& method, const HTTPHeaderMap& headerMap)
{
if (!isSimpleMethod(method))
return false;
HTTPHeaderMap::const_iterator end = headerMap.end();
for (HTTPHeaderMap::const_iterator it = headerMap.begin(); it != end; ++it) {
// Preflight is required for MIME types that can not be sent via form
// submission.
if (!isSimpleHeader(it->key, it->value))
return false;
}
return true;
}
static inline void setHeaderFields(CFMutableURLRequestRef request, const HTTPHeaderMap& requestHeaders)
{
// Remove existing headers first, as some of them may no longer be present in the map.
RetainPtr<CFDictionaryRef> oldHeaderFields(AdoptCF, CFURLRequestCopyAllHTTPHeaderFields(request));
CFIndex oldHeaderFieldCount = CFDictionaryGetCount(oldHeaderFields.get());
if (oldHeaderFieldCount) {
Vector<CFStringRef> oldHeaderFieldNames(oldHeaderFieldCount);
CFDictionaryGetKeysAndValues(oldHeaderFields.get(), reinterpret_cast<const void**>(&oldHeaderFieldNames[0]), 0);
for (CFIndex i = 0; i < oldHeaderFieldCount; ++i)
CFURLRequestSetHTTPHeaderFieldValue(request, oldHeaderFieldNames[i], 0);
}
for (HTTPHeaderMap::const_iterator it = requestHeaders.begin(), end = requestHeaders.end(); it != end; ++it)
CFURLRequestSetHTTPHeaderFieldValue(request, it->key.string().createCFString().get(), it->value.createCFString().get());
}
static void addHeaders(JSContextRef context, JSObjectRef object, const HTTPHeaderMap& headers)
{
ASSERT_ARG(context, context);
ASSERT_ARG(object, object);
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it) {
JSStringRef field = JSStringCreateWithCharacters(it->first.characters(), it->first.length());
JSStringRef valueString = JSStringCreateWithCharacters(it->second.characters(), it->second.length());
JSValueRef value = JSValueMakeString(context, valueString);
JSObjectSetProperty(context, object, field, value, kJSPropertyAttributeNone, 0);
JSStringRelease(field);
JSStringRelease(valueString);
}
}
static bool canSkipPrelight(PreflightResultCache::iterator cacheIt, bool includeCredentials, const String& method, const HTTPHeaderMap& requestHeaders)
{
PreflightResultCacheItem* item = cacheIt->second;
if (item->m_absoluteExpiryTime < currentTime())
return false;
if (includeCredentials && !item->m_credentials)
return false;
if (!item->m_methods->contains(method) && method != "GET" && method != "POST")
return false;
HTTPHeaderMap::const_iterator end = requestHeaders.end();
for (HTTPHeaderMap::const_iterator it = requestHeaders.begin(); it != end; ++it) {
if (!item->m_headers->contains(it->first) && !isOnAccessControlSimpleRequestHeaderWhitelist(it->first))
return false;
}
return true;
}
SoupMessage* ResourceRequest::toSoupMessage() const
{
SoupMessage* soupMessage = soup_message_new(httpMethod().utf8().data(), url().string().utf8().data());
if (!soupMessage)
return 0;
HTTPHeaderMap headers = httpHeaderFields();
SoupMessageHeaders* soupHeaders = soupMessage->request_headers;
if (!headers.isEmpty()) {
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data());
}
// Body data is only handled at ResourceHandleSoup::startHttp for
// now; this is because this may not be a good place to go
// openning and mmapping files. We should maybe revisit this.
return soupMessage;
}
void WebSocketServerConnection::sendHTTPResponseHeader(int statusCode, const String& statusText, const HTTPHeaderMap& headerFields)
{
StringBuilder builder;
builder.append("HTTP/1.1 ");
builder.append(String::number(statusCode));
builder.append(" ");
builder.append(statusText);
builder.append("\r\n");
HTTPHeaderMap::const_iterator end = headerFields.end();
for (HTTPHeaderMap::const_iterator it = headerFields.begin(); it != end; ++it) {
builder.append(it->first);
builder.append(": ");
builder.append(it->second + "\r\n");
}
builder.append("\r\n");
CString header = builder.toString().latin1();
m_socket->send(header.data(), header.length());
}
SoupMessage* ResourceResponse::toSoupMessage() const
{
// This GET here is just because SoupMessage wants it, we dn't really know.
SoupMessage* soupMessage = soup_message_new("GET", url().string().utf8().data());
if (!soupMessage)
return 0;
soupMessage->status_code = httpStatusCode();
HTTPHeaderMap headers = httpHeaderFields();
SoupMessageHeaders* soupHeaders = soupMessage->response_headers;
if (!headers.isEmpty()) {
HTTPHeaderMap::const_iterator end = headers.end();
for (HTTPHeaderMap::const_iterator it = headers.begin(); it != end; ++it)
soup_message_headers_append(soupHeaders, it->first.string().utf8().data(), it->second.utf8().data());
}
// Body data is not in the message.
return soupMessage;
}
void ResourceRequest::addHTTPHeaderFields(const HTTPHeaderMap& headerFields)
{
HTTPHeaderMap::const_iterator end = headerFields.end();
for (HTTPHeaderMap::const_iterator it = headerFields.begin(); it != end; ++it)
addHTTPHeaderField(it->key, it->value);
}
bool ArgumentCoder<ResourceResponse>::decode(ArgumentDecoder* decoder, ResourceResponse& resourceResponse)
{
bool responseIsNull;
if (!decoder->decode(responseIsNull))
return false;
if (responseIsNull) {
resourceResponse = ResourceResponse();
return true;
}
ResourceResponse response;
String url;
if (!decoder->decode(url))
return false;
response.setURL(KURL(KURL(), url));
int32_t httpStatusCode;
if (!decoder->decode(httpStatusCode))
return false;
response.setHTTPStatusCode(httpStatusCode);
HTTPHeaderMap headers;
if (!decoder->decode(headers))
return false;
for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it)
response.setHTTPHeaderField(it->first, it->second);
uint32_t soupMessageFlags;
if (!decoder->decode(soupMessageFlags))
return false;
response.setSoupMessageFlags(static_cast<SoupMessageFlags>(soupMessageFlags));
String mimeType;
if (!decoder->decode(mimeType))
return false;
response.setMimeType(mimeType);
String textEncodingName;
if (!decoder->decode(textEncodingName))
return false;
response.setTextEncodingName(textEncodingName);
int64_t contentLength;
if (!decoder->decode(contentLength))
return false;
response.setExpectedContentLength(contentLength);
String httpStatusText;
if (!decoder->decode(httpStatusText))
return false;
response.setHTTPStatusText(httpStatusText);
String suggestedFilename;
if (!decoder->decode(suggestedFilename))
return false;
response.setSuggestedFilename(suggestedFilename);
resourceResponse = response;
return true;
}
void ResourceRequestBase::addHTTPHeaderFields(const HTTPHeaderMap& headerFields)
{
HTTPHeaderMap::const_iterator end = headerFields.end();
for (HTTPHeaderMap::const_iterator it = headerFields.begin(); it != end; ++it)
addHTTPHeaderField(it->first, it->second);
}
void ResourceHandleManager::initializeHandle(ResourceHandle* job)
{
KURL kurl = job->request().url();
// Remove any fragment part, otherwise curl will send it as part of the request.
kurl.setRef("");
ResourceHandleInternal* d = job->getInternal();
String url = kurl.string();
if (kurl.isLocalFile()) {
String query = kurl.query();
// Remove any query part sent to a local file.
if (!query.isEmpty())
url = url.left(url.find(query));
// Determine the MIME type based on the path.
d->m_response.setMimeType(MIMETypeRegistry::getMIMETypeForPath(url));
}
d->m_handle = curl_easy_init();
#ifndef NDEBUG
if (getenv("DEBUG_CURL"))
curl_easy_setopt(d->m_handle, CURLOPT_VERBOSE, 1);
#endif
curl_easy_setopt(d->m_handle, CURLOPT_PRIVATE, job);
curl_easy_setopt(d->m_handle, CURLOPT_ERRORBUFFER, m_curlErrorBuffer);
curl_easy_setopt(d->m_handle, CURLOPT_WRITEFUNCTION, writeCallback);
curl_easy_setopt(d->m_handle, CURLOPT_WRITEDATA, job);
curl_easy_setopt(d->m_handle, CURLOPT_HEADERFUNCTION, headerCallback);
curl_easy_setopt(d->m_handle, CURLOPT_WRITEHEADER, job);
curl_easy_setopt(d->m_handle, CURLOPT_AUTOREFERER, 1);
curl_easy_setopt(d->m_handle, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(d->m_handle, CURLOPT_MAXREDIRS, 10);
curl_easy_setopt(d->m_handle, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
curl_easy_setopt(d->m_handle, CURLOPT_SHARE, m_curlShareHandle);
curl_easy_setopt(d->m_handle, CURLOPT_DNS_CACHE_TIMEOUT, 60 * 5); // 5 minutes
// FIXME: Enable SSL verification when we have a way of shipping certs
// and/or reporting SSL errors to the user.
if (ignoreSSLErrors)
curl_easy_setopt(d->m_handle, CURLOPT_SSL_VERIFYPEER, false);
// enable gzip and deflate through Accept-Encoding:
curl_easy_setopt(d->m_handle, CURLOPT_ENCODING, "");
// url must remain valid through the request
ASSERT(!d->m_url);
// url is in ASCII so latin1() will only convert it to char* without character translation.
d->m_url = strdup(url.latin1().data());
curl_easy_setopt(d->m_handle, CURLOPT_URL, d->m_url);
if (m_cookieJarFileName) {
curl_easy_setopt(d->m_handle, CURLOPT_COOKIEFILE, m_cookieJarFileName);
curl_easy_setopt(d->m_handle, CURLOPT_COOKIEJAR, m_cookieJarFileName);
}
struct curl_slist* headers = 0;
if (job->request().httpHeaderFields().size() > 0) {
HTTPHeaderMap customHeaders = job->request().httpHeaderFields();
HTTPHeaderMap::const_iterator end = customHeaders.end();
for (HTTPHeaderMap::const_iterator it = customHeaders.begin(); it != end; ++it) {
String key = it->first;
String value = it->second;
String headerString(key);
headerString.append(": ");
headerString.append(value);
CString headerLatin1 = headerString.latin1();
headers = curl_slist_append(headers, headerLatin1.data());
}
}
if ("GET" == job->request().httpMethod())
curl_easy_setopt(d->m_handle, CURLOPT_HTTPGET, TRUE);
else if ("POST" == job->request().httpMethod())
setupPOST(job, &headers);
else if ("PUT" == job->request().httpMethod())
setupPUT(job, &headers);
else if ("HEAD" == job->request().httpMethod())
curl_easy_setopt(d->m_handle, CURLOPT_NOBODY, TRUE);
if (headers) {
curl_easy_setopt(d->m_handle, CURLOPT_HTTPHEADER, headers);
d->m_customHeaders = headers;
}
}
void ResourceHandleManager::startJob(ResourceHandle* job)
{
ResourceHandleInternal* d = job->getInternal();
DeprecatedString url = job->request().url().url();
d->m_handle = curl_easy_init();
#ifndef NDEBUG
if (getenv("DEBUG_CURL"))
curl_easy_setopt(d->m_handle, CURLOPT_VERBOSE, 1);
#endif
curl_easy_setopt(d->m_handle, CURLOPT_PRIVATE, job);
curl_easy_setopt(d->m_handle, CURLOPT_ERRORBUFFER, m_curlErrorBuffer);
curl_easy_setopt(d->m_handle, CURLOPT_WRITEFUNCTION, writeCallback);
curl_easy_setopt(d->m_handle, CURLOPT_WRITEDATA, job);
curl_easy_setopt(d->m_handle, CURLOPT_HEADERFUNCTION, headerCallback);
curl_easy_setopt(d->m_handle, CURLOPT_WRITEHEADER, job);
curl_easy_setopt(d->m_handle, CURLOPT_AUTOREFERER, 1);
curl_easy_setopt(d->m_handle, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(d->m_handle, CURLOPT_MAXREDIRS, 10);
curl_easy_setopt(d->m_handle, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
curl_easy_setopt(d->m_handle, CURLOPT_SHARE, m_curlShareHandle);
curl_easy_setopt(d->m_handle, CURLOPT_DNS_CACHE_TIMEOUT, 60 * 5); // 5 minutes
// enable gzip and deflate through Accept-Encoding:
curl_easy_setopt(d->m_handle, CURLOPT_ENCODING, "");
// url must remain valid through the request
ASSERT(!d->m_url);
d->m_url = strdup(url.ascii());
curl_easy_setopt(d->m_handle, CURLOPT_URL, d->m_url);
if (m_cookieJarFileName) {
curl_easy_setopt(d->m_handle, CURLOPT_COOKIEFILE, m_cookieJarFileName);
curl_easy_setopt(d->m_handle, CURLOPT_COOKIEJAR, m_cookieJarFileName);
}
if (job->request().httpHeaderFields().size() > 0) {
struct curl_slist* headers = 0;
HTTPHeaderMap customHeaders = job->request().httpHeaderFields();
HTTPHeaderMap::const_iterator end = customHeaders.end();
for (HTTPHeaderMap::const_iterator it = customHeaders.begin(); it != end; ++it) {
String key = it->first;
String value = it->second;
String headerString(key);
headerString.append(": ");
headerString.append(value);
CString headerLatin1 = headerString.latin1();
headers = curl_slist_append(headers, headerLatin1.data());
}
curl_easy_setopt(d->m_handle, CURLOPT_HTTPHEADER, headers);
d->m_customHeaders = headers;
}
if ("GET" == job->request().httpMethod())
curl_easy_setopt(d->m_handle, CURLOPT_HTTPGET, TRUE);
else if ("POST" == job->request().httpMethod())
setupPOST(job);
else if ("PUT" == job->request().httpMethod())
setupPUT(job);
else if ("HEAD" == job->request().httpMethod())
curl_easy_setopt(d->m_handle, CURLOPT_NOBODY, TRUE);
CURLMcode ret = curl_multi_add_handle(m_curlMultiHandle, d->m_handle);
// don't call perform, because events must be async
// timeout will occur and do curl_multi_perform
if (ret && ret != CURLM_CALL_MULTI_PERFORM) {
#ifndef NDEBUG
printf("Error %d starting job %s\n", ret, job->request().url().url().ascii());
#endif
job->cancel();
return;
}
}
