WebCore/xml/XMLHttpRequest.cpp - WebKit - Git at Google

 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 2004, 2006 Apple Computer, Inc.
  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */

 #include "config.h"
 #include "XMLHttpRequest.h"

 #include "CString.h"
 #include "Cache.h"
 #include "DOMImplementation.h"
 #include "TextResourceDecoder.h"
 #include "Event.h"
 #include "EventListener.h"
 #include "EventNames.h"
 #include "ExceptionCode.h"
 #include "FormData.h"
 #include "Frame.h"
 #include "FrameLoader.h"
 #include "HTMLDocument.h"
 #include "HTTPParsers.h"
 #include "Page.h"
 #include "PlatformString.h"
 #include "RegularExpression.h"
 #include "ResourceHandle.h"
 #include "ResourceRequest.h"
 #include "Settings.h"
 #include "SubresourceLoader.h"
 #include "TextEncoding.h"
 #include "kjs_binding.h"
 #include <kjs/protect.h>
 #include <wtf/Vector.h>

 namespace WebCore {

 using namespace EventNames;

 typedef HashSet<XMLHttpRequest*> RequestsSet;

 static HashMap<Document*, RequestsSet*>& requestsByDocument()
 {
     static HashMap<Document*, RequestsSet*> map;
     return map;
 }

 static void addToRequestsByDocument(Document* doc, XMLHttpRequest* req)
 {
     ASSERT(doc);
     ASSERT(req);

     RequestsSet* requests = requestsByDocument().get(doc);
     if (!requests) {
         requests = new RequestsSet;
         requestsByDocument().set(doc, requests);
     }

     ASSERT(!requests->contains(req));
     requests->add(req);
 }

 static void removeFromRequestsByDocument(Document* doc, XMLHttpRequest* req)
 {
     ASSERT(doc);
     ASSERT(req);

     RequestsSet* requests = requestsByDocument().get(doc);
     ASSERT(requests);
     ASSERT(requests->contains(req));
     requests->remove(req);
     if (requests->isEmpty()) {
         requestsByDocument().remove(doc);
         delete requests;
     }
 }

 static bool canSetRequestHeader(const String& name)
 {
     static HashSet<String, CaseInsensitiveHash<String> > forbiddenHeaders;

     if (forbiddenHeaders.isEmpty()) {
         forbiddenHeaders.add("accept-charset");
         forbiddenHeaders.add("accept-encoding");
         forbiddenHeaders.add("content-length");
         forbiddenHeaders.add("expect");
         forbiddenHeaders.add("date");
         forbiddenHeaders.add("host");
         forbiddenHeaders.add("keep-alive");
         forbiddenHeaders.add("referer");
         forbiddenHeaders.add("te");
         forbiddenHeaders.add("trailer");
         forbiddenHeaders.add("transfer-encoding");
         forbiddenHeaders.add("upgrade");
         forbiddenHeaders.add("via");
     }

     return !forbiddenHeaders.contains(name);
 }

 // Determines if a string is a valid token, as defined by
 // "token" in section 2.2 of RFC 2616.
 static bool isValidToken(const String& name)
 {
     unsigned length = name.length();
     for (unsigned i = 0; i < length; i++) {
         UChar c = name[i];

         if (c >= 127 || c <= 32)
             return false;

         if (c == '(' || c == ')' || c == '<' || c == '>' || c == '@' ||
             c == ',' || c == ';' || c == ':' || c == '\\' || c == '\"' ||
             c == '/' || c == '[' || c == ']' || c == '?' || c == '=' ||
             c == '{' || c == '}')
             return false;
     }

     return true;
 }

 static bool isValidHeaderValue(const String& name)
 {
     // FIXME: This should really match name against
     // field-value in section 4.2 of RFC 2616.

     return !name.contains('\r') && !name.contains('\n');
 }

 XMLHttpRequestState XMLHttpRequest::getReadyState() const
 {
     return m_state;
 }

 const KJS::UString& XMLHttpRequest::getResponseText() const
 {
     return m_responseText;
 }

 Document* XMLHttpRequest::getResponseXML() const
 {
     if (m_state != Loaded)
         return 0;

     if (!m_createdDocument) {
         if (m_response.isHTTP() && !responseIsXML()) {
             // The W3C spec requires this.
             m_responseXML = 0;
         } else {
             m_responseXML = m_doc->implementation()->createDocument(0);
             m_responseXML->open();
             m_responseXML->setURL(m_url.url());
             // FIXME: set Last-Modified and cookies (currently, those are only available for HTMLDocuments).
             m_responseXML->write(String(m_responseText));
             m_responseXML->finishParsing();
             m_responseXML->close();

             if (!m_responseXML->wellFormed())
                 m_responseXML = 0;
         }
         m_createdDocument = true;
     }

     return m_responseXML.get();
 }

 EventListener* XMLHttpRequest::onReadyStateChangeListener() const
 {
     return m_onReadyStateChangeListener.get();
 }

 void XMLHttpRequest::setOnReadyStateChangeListener(EventListener* eventListener)
 {
     m_onReadyStateChangeListener = eventListener;
 }

 EventListener* XMLHttpRequest::onLoadListener() const
 {
     return m_onLoadListener.get();
 }

 void XMLHttpRequest::setOnLoadListener(EventListener* eventListener)
 {
     m_onLoadListener = eventListener;
 }

 void XMLHttpRequest::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> eventListener, bool)
 {
     EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
     if (iter == m_eventListeners.end()) {
         ListenerVector listeners;
         listeners.append(eventListener);
         m_eventListeners.add(eventType.impl(), listeners);
     } else {
         ListenerVector& listeners = iter->second;
         for (ListenerVector::iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
             if (*listenerIter == eventListener)
                 return;

         listeners.append(eventListener);
         m_eventListeners.add(eventType.impl(), listeners);
     }
 }

 void XMLHttpRequest::removeEventListener(const AtomicString& eventType, EventListener* eventListener, bool)
 {
     EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
     if (iter == m_eventListeners.end())
         return;

     ListenerVector& listeners = iter->second;
     for (ListenerVector::const_iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
         if (*listenerIter == eventListener) {
             listeners.remove(listenerIter - listeners.begin());
             return;
         }
 }

 bool XMLHttpRequest::dispatchEvent(PassRefPtr<Event> evt, ExceptionCode& ec, bool /*tempEvent*/)
 {
     // FIXME: check for other error conditions enumerated in the spec.
     if (evt->type().isEmpty()) {
         ec = UNSPECIFIED_EVENT_TYPE_ERR;
         return true;
     }

     ListenerVector listenersCopy = m_eventListeners.get(evt->type().impl());
     for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
         evt->setTarget(this);
         evt->setCurrentTarget(this);
         listenerIter->get()->handleEvent(evt.get(), false);
     }

     return !evt->defaultPrevented();
 }

 XMLHttpRequest::XMLHttpRequest(Document* d)
     : m_doc(d)
     , m_async(true)
     , m_loader(0)
     , m_state(Uninitialized)
     , m_responseText("")
     , m_createdDocument(false)
     , m_aborted(false)
 {
     ASSERT(m_doc);
     addToRequestsByDocument(m_doc, this);
 }

 XMLHttpRequest::~XMLHttpRequest()
 {
     if (m_doc)
         removeFromRequestsByDocument(m_doc, this);
 }

 void XMLHttpRequest::changeState(XMLHttpRequestState newState)
 {
     if (m_state != newState) {
         m_state = newState;
         callReadyStateChangeListener();
     }
 }

 void XMLHttpRequest::callReadyStateChangeListener()
 {
     if (m_doc && m_doc->frame() && m_onReadyStateChangeListener) {
         RefPtr<Event> evt = new Event(readystatechangeEvent, true, true);
         evt->setTarget(this);
         evt->setCurrentTarget(this);
         m_onReadyStateChangeListener->handleEvent(evt.get(), false);
     }

     if (m_doc && m_doc->frame() && m_state == Loaded) {
         if (m_onLoadListener) {
             RefPtr<Event> evt = new Event(loadEvent, true, true);
             evt->setTarget(this);
             evt->setCurrentTarget(this);
             m_onLoadListener->handleEvent(evt.get(), false);
         }

         ListenerVector listenersCopy = m_eventListeners.get(loadEvent.impl());
         for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
             RefPtr<Event> evt = new Event(loadEvent, true, true);
             evt->setTarget(this);
             evt->setCurrentTarget(this);
             listenerIter->get()->handleEvent(evt.get(), false);
         }
     }
 }

 bool XMLHttpRequest::urlMatchesDocumentDomain(const KURL& url) const
 {
     // a local file can load anything
     if (m_doc->isAllowedToLoadLocalResources())
         return true;

     // but a remote document can only load from the same port on the server
     KURL documentURL = m_doc->URL();
     if (documentURL.protocol().lower() == url.protocol().lower()
             && documentURL.host().lower() == url.host().lower()
             && documentURL.port() == url.port())
         return true;

     return false;
 }

 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionCode& ec)
 {
     abort();
     m_aborted = false;

     // clear stuff from possible previous load
     m_requestHeaders.clear();
     m_response = ResourceResponse();
     {
         KJS::JSLock lock;
         m_responseText = "";
     }
     m_createdDocument = false;
     m_responseXML = 0;

     changeState(Uninitialized);

     if (!urlMatchesDocumentDomain(url)) {
         ec = PERMISSION_DENIED;
         return;
     }

     if (!isValidToken(method)) {
         ec = SYNTAX_ERR;
         return;
     }

     m_url = url;

     // Method names are case sensitive. But since Firefox uppercases method names it knows, we'll do the same.
     String methodUpper(method.upper());
     if (methodUpper == "CONNECT" || methodUpper == "COPY" || methodUpper == "DELETE" || methodUpper == "GET" || methodUpper == "HEAD"
         || methodUpper == "INDEX" || methodUpper == "LOCK" || methodUpper == "M-POST" || methodUpper == "MKCOL" || methodUpper == "MOVE"
         || methodUpper == "OPTIONS" || methodUpper == "POST" || methodUpper == "PROPFIND" || methodUpper == "PROPPATCH" || methodUpper == "PUT"
         || methodUpper == "TRACE" || methodUpper == "UNLOCK")
         m_method = methodUpper.deprecatedString();
     else
         m_method = method.deprecatedString();

     m_async = async;

     changeState(Open);
 }

 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, ExceptionCode& ec)
 {
     KURL urlWithCredentials(url);
     urlWithCredentials.setUser(user.deprecatedString());

     open(method, urlWithCredentials, async, ec);
 }

 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, const String& password, ExceptionCode& ec)
 {
     KURL urlWithCredentials(url);
     urlWithCredentials.setUser(user.deprecatedString());
     urlWithCredentials.setPass(password.deprecatedString());

     open(method, urlWithCredentials, async, ec);
 }

 void XMLHttpRequest::send(const String& body, ExceptionCode& ec)
 {
     if (!m_doc)
         return;

     if (m_state != Open) {
         ec = INVALID_STATE_ERR;
         return;
     }

     // FIXME: Should this abort or raise an exception instead if we already have a m_loader going?
     if (m_loader)
         return;

     m_aborted = false;

     ResourceRequest request(m_url);
     request.setHTTPMethod(m_method);

     if (!body.isNull() && m_method != "GET" && m_method != "HEAD" && (m_url.protocol().lower() == "http" || m_url.protocol().lower() == "https")) {
         String contentType = getRequestHeader("Content-Type");
         if (contentType.isEmpty()) {
             ExceptionCode ec = 0;
             Settings* settings = m_doc->settings();
             if (settings && settings->usesDashboardBackwardCompatibilityMode())
                 setRequestHeader("Content-Type", "application/x-www-form-urlencoded", ec);
             else
                 setRequestHeader("Content-Type", "application/xml", ec);
             ASSERT(ec == 0);
         }

         // FIXME: must use xmlEncoding for documents.
         String charset = "UTF-8";

         TextEncoding m_encoding(charset);
         if (!m_encoding.isValid()) // FIXME: report an error?
             m_encoding = UTF8Encoding();

         request.setHTTPBody(PassRefPtr<FormData>(new FormData(m_encoding.encode(body.characters(), body.length()))));
     }

     if (m_requestHeaders.size() > 0)
         request.addHTTPHeaderFields(m_requestHeaders);

     if (!m_async) {
         Vector<char> data;
         ResourceError error;
         ResourceResponse response;

         {
             // avoid deadlock in case the loader wants to use JS on a background thread
             KJS::JSLock::DropAllLocks dropLocks;
             if (m_doc->frame())
                 m_doc->frame()->loader()->loadResourceSynchronously(request, error, response, data);
         }

         m_loader = 0;

         // No exception for file:/// resources, see <rdar://problem/4962298>.
         // Also, if we have an HTTP response, then it wasn't a network error in fact.
         if (error.isNull() || request.url().isLocalFile() || response.httpStatusCode() > 0)
             processSyncLoadResults(data, response);
         else
             ec = NETWORK_ERR;

         return;
     }

     // Neither this object nor the JavaScript wrapper should be deleted while
     // a request is in progress because we need to keep the listeners alive,
     // and they are referenced by the JavaScript wrapper.
     ref();
     {
         KJS::JSLock lock;
         gcProtectNullTolerant(KJS::ScriptInterpreter::getDOMObject(this));
     }

     // create can return null here, for example if we're no longer attached to a page.
     // this is true while running onunload handlers
     // FIXME: Maybe create can return false for other reasons too?
     m_loader = SubresourceLoader::create(m_doc->frame(), this, request, false, true, false);
 }

 void XMLHttpRequest::abort()
 {
     bool hadLoader = m_loader;

     m_aborted = true;

     if (hadLoader) {
         m_loader->cancel();
         m_loader = 0;
     }

     m_decoder = 0;

     if (hadLoader)
         dropProtection();
 }

 void XMLHttpRequest::dropProtection()
 {
     {
         KJS::JSLock lock;
         KJS::JSValue* wrapper = KJS::ScriptInterpreter::getDOMObject(this);
         KJS::gcUnprotectNullTolerant(wrapper);

         // the XHR object itself holds on to the responseText, and
         // thus has extra cost even independent of any
         // responseText or responseXML objects it has handed
         // out. But it is protected from GC while loading, so this
         // can't be recouped until the load is done, so only
         // report the extra cost at that point.

         if (wrapper)
             KJS::Collector::reportExtraMemoryCost(m_responseText.size() * 2);
     }

     deref();
 }

 void XMLHttpRequest::overrideMIMEType(const String& override)
 {
     m_mimeTypeOverride = override;
 }

 void XMLHttpRequest::setRequestHeader(const String& name, const String& value, ExceptionCode& ec)
 {
     if (m_state != Open) {
         Settings* settings = m_doc ? m_doc->settings() : 0;
         if (settings && settings->usesDashboardBackwardCompatibilityMode())
             return;

         ec = INVALID_STATE_ERR;
         return;
     }

     if (!isValidToken(name) || !isValidHeaderValue(value)) {
         ec = SYNTAX_ERR;
         return;
     }

     if (!canSetRequestHeader(name)) {
         if (m_doc && m_doc->frame() && m_doc->frame()->page())
             m_doc->frame()->page()->chrome()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, "Refused to set unsafe header " + name, 1, String());
         return;
     }

     if (!m_requestHeaders.contains(name)) {
         m_requestHeaders.set(name, value);
         return;
     }

     String oldValue = m_requestHeaders.get(name);
     m_requestHeaders.set(name, oldValue + ", " + value);
 }

 String XMLHttpRequest::getRequestHeader(const String& name) const
 {
     return m_requestHeaders.get(name);
 }

 String XMLHttpRequest::getAllResponseHeaders() const
 {
     Vector<UChar> stringBuilder;
     String separator(": ");

     HTTPHeaderMap::const_iterator end = m_response.httpHeaderFields().end();
     for (HTTPHeaderMap::const_iterator it = m_response.httpHeaderFields().begin(); it!= end; ++it) {
         stringBuilder.append(it->first.characters(), it->first.length());
         stringBuilder.append(separator.characters(), separator.length());
         stringBuilder.append(it->second.characters(), it->second.length());
         stringBuilder.append((UChar)'\n');
     }

     return String::adopt(stringBuilder);
 }

 String XMLHttpRequest::getResponseHeader(const String& name) const
 {
     return m_response.httpHeaderField(name);
 }

 String XMLHttpRequest::responseMIMEType() const
 {
     String mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
     if (mimeType.isEmpty()) {
         if (m_response.isHTTP())
             mimeType = extractMIMETypeFromMediaType(getResponseHeader("Content-Type"));
         else
             mimeType = m_response.mimeType();
     }
     if (mimeType.isEmpty())
         mimeType = "text/xml";

     return mimeType;
 }

 bool XMLHttpRequest::responseIsXML() const
 {
     return DOMImplementation::isXMLMIMEType(responseMIMEType());
 }

 int XMLHttpRequest::getStatus(ExceptionCode& ec) const
 {
     if (m_state == Uninitialized)
         return 0;

     if (m_response.httpStatusCode() == 0) {
         if (m_state != Receiving && m_state != Loaded)
             // status MUST be available in these states, but we don't get any headers from non-HTTP requests
             ec = INVALID_STATE_ERR;
     }

     return m_response.httpStatusCode();
 }

 String XMLHttpRequest::getStatusText(ExceptionCode& ec) const
 {
     if (m_state == Uninitialized)
         return "";

     if (m_response.httpStatusCode() == 0) {
         if (m_state != Receiving && m_state != Loaded)
             // statusText MUST be available in these states, but we don't get any headers from non-HTTP requests
             ec = INVALID_STATE_ERR;
         return String();
     }

     // FIXME: should try to preserve status text in response
     return "OK";
 }

 void XMLHttpRequest::processSyncLoadResults(const Vector<char>& data, const ResourceResponse& response)
 {
     if (!urlMatchesDocumentDomain(response.url())) {
         abort();
         return;
     }

     didReceiveResponse(0, response);
     changeState(Sent);
     if (m_aborted)
         return;

     const char* bytes = static_cast<const char*>(data.data());
     int len = static_cast<int>(data.size());

     didReceiveData(0, bytes, len);
     if (m_aborted)
         return;

     didFinishLoading(0);
 }

 void XMLHttpRequest::didFail(SubresourceLoader* loader, const ResourceError&)
 {
     didFinishLoading(loader);
 }

 void XMLHttpRequest::didFinishLoading(SubresourceLoader* loader)
 {
     if (m_aborted)
         return;

     ASSERT(loader == m_loader);

     if (m_state < Sent)
         changeState(Sent);

     {
         KJS::JSLock lock;
         if (m_decoder)
             m_responseText += m_decoder->flush();
     }

     bool hadLoader = m_loader;
     m_loader = 0;

     changeState(Loaded);
     m_decoder = 0;

     if (hadLoader)
         dropProtection();
 }

 void XMLHttpRequest::willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse& redirectResponse)
 {
     if (!urlMatchesDocumentDomain(request.url()))
         abort();
 }

 void XMLHttpRequest::didReceiveResponse(SubresourceLoader*, const ResourceResponse& response)
 {
     m_response = response;
     m_encoding = extractCharsetFromMediaType(m_mimeTypeOverride);
     if (m_encoding.isEmpty())
         m_encoding = response.textEncodingName();

 }

 void XMLHttpRequest::receivedCancellation(SubresourceLoader*, const AuthenticationChallenge& challenge)
 {
     m_response = challenge.failureResponse();
 }

 void XMLHttpRequest::didReceiveData(SubresourceLoader*, const char* data, int len)
 {
     if (m_state < Sent)
         changeState(Sent);

     if (!m_decoder) {
         if (!m_encoding.isEmpty())
             m_decoder = new TextResourceDecoder("text/plain", m_encoding);
         // allow TextResourceDecoder to look inside the m_response if it's XML or HTML
         else if (responseIsXML())
             m_decoder = new TextResourceDecoder("application/xml");
         else if (responseMIMEType() == "text/html")
             m_decoder = new TextResourceDecoder("text/html");
         else
             m_decoder = new TextResourceDecoder("text/plain", "UTF-8");
     }
     if (len == 0)
         return;

     if (len == -1)
         len = strlen(data);

     String decoded = m_decoder->decode(data, len);

     {
         KJS::JSLock lock;
         m_responseText += decoded;
     }

     if (!m_aborted) {
         if (m_state != Receiving)
             changeState(Receiving);
         else
             // Firefox calls readyStateChanged every time it receives data, 4449442
             callReadyStateChangeListener();
     }
 }

 void XMLHttpRequest::cancelRequests(Document* m_doc)
 {
     RequestsSet* requests = requestsByDocument().get(m_doc);
     if (!requests)
         return;
     RequestsSet copy = *requests;
     RequestsSet::const_iterator end = copy.end();
     for (RequestsSet::const_iterator it = copy.begin(); it != end; ++it)
         (*it)->abort();
 }

 void XMLHttpRequest::detachRequests(Document* m_doc)
 {
     RequestsSet* requests = requestsByDocument().get(m_doc);
     if (!requests)
         return;
     requestsByDocument().remove(m_doc);
     RequestsSet::const_iterator end = requests->end();
     for (RequestsSet::const_iterator it = requests->begin(); it != end; ++it) {
         (*it)->m_doc = 0;
         (*it)->abort();
     }
     delete requests;
 }

 } // end namespace
	/*
	* This file is part of the KDE libraries
	* Copyright (C) 2004, 2006 Apple Computer, Inc.
	* Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include "config.h"
	#include "XMLHttpRequest.h"

	#include "CString.h"
	#include "Cache.h"
	#include "DOMImplementation.h"
	#include "TextResourceDecoder.h"
	#include "Event.h"
	#include "EventListener.h"
	#include "EventNames.h"
	#include "ExceptionCode.h"
	#include "FormData.h"
	#include "Frame.h"
	#include "FrameLoader.h"
	#include "HTMLDocument.h"
	#include "HTTPParsers.h"
	#include "Page.h"
	#include "PlatformString.h"
	#include "RegularExpression.h"
	#include "ResourceHandle.h"
	#include "ResourceRequest.h"
	#include "Settings.h"
	#include "SubresourceLoader.h"
	#include "TextEncoding.h"
	#include "kjs_binding.h"
	#include <kjs/protect.h>
	#include <wtf/Vector.h>

	namespace WebCore {

	using namespace EventNames;

	typedef HashSet<XMLHttpRequest*> RequestsSet;

	static HashMap<Document, RequestsSet>& requestsByDocument()
	{
	static HashMap<Document, RequestsSet> map;
	return map;
	}

	static void addToRequestsByDocument(Document* doc, XMLHttpRequest* req)
	{
	ASSERT(doc);
	ASSERT(req);

	RequestsSet* requests = requestsByDocument().get(doc);
	if (!requests) {
	requests = new RequestsSet;
	requestsByDocument().set(doc, requests);
	}

	ASSERT(!requests->contains(req));
	requests->add(req);
	}

	static void removeFromRequestsByDocument(Document* doc, XMLHttpRequest* req)
	{
	ASSERT(doc);
	ASSERT(req);

	RequestsSet* requests = requestsByDocument().get(doc);
	ASSERT(requests);
	ASSERT(requests->contains(req));
	requests->remove(req);
	if (requests->isEmpty()) {
	requestsByDocument().remove(doc);
	delete requests;
	}
	}

	static bool canSetRequestHeader(const String& name)
	{
	static HashSet<String, CaseInsensitiveHash<String> > forbiddenHeaders;

	if (forbiddenHeaders.isEmpty()) {
	forbiddenHeaders.add("accept-charset");
	forbiddenHeaders.add("accept-encoding");
	forbiddenHeaders.add("content-length");
	forbiddenHeaders.add("expect");
	forbiddenHeaders.add("date");
	forbiddenHeaders.add("host");
	forbiddenHeaders.add("keep-alive");
	forbiddenHeaders.add("referer");
	forbiddenHeaders.add("te");
	forbiddenHeaders.add("trailer");
	forbiddenHeaders.add("transfer-encoding");
	forbiddenHeaders.add("upgrade");
	forbiddenHeaders.add("via");
	}

	return !forbiddenHeaders.contains(name);
	}

	// Determines if a string is a valid token, as defined by
	// "token" in section 2.2 of RFC 2616.
	static bool isValidToken(const String& name)
	{
	unsigned length = name.length();
	for (unsigned i = 0; i < length; i++) {
	UChar c = name[i];

	if (c >= 127 \|\| c <= 32)
	return false;

	if (c == '(' \|\| c == ')' \|\| c == '<' \|\| c == '>' \|\| c == '@' \|\|
	c == ',' \|\| c == ';' \|\| c == ':' \|\| c == '\\' \|\| c == '\"' \|\|
	c == '/' \|\| c == '[' \|\| c == ']' \|\| c == '?' \|\| c == '=' \|\|
	c == '{' \|\| c == '}')
	return false;
	}

	return true;
	}

	static bool isValidHeaderValue(const String& name)
	{
	// FIXME: This should really match name against
	// field-value in section 4.2 of RFC 2616.

	return !name.contains('\r') && !name.contains('\n');
	}

	XMLHttpRequestState XMLHttpRequest::getReadyState() const
	{
	return m_state;
	}

	const KJS::UString& XMLHttpRequest::getResponseText() const
	{
	return m_responseText;
	}

	Document* XMLHttpRequest::getResponseXML() const
	{
	if (m_state != Loaded)
	return 0;

	if (!m_createdDocument) {
	if (m_response.isHTTP() && !responseIsXML()) {
	// The W3C spec requires this.
	m_responseXML = 0;
	} else {
	m_responseXML = m_doc->implementation()->createDocument(0);
	m_responseXML->open();
	m_responseXML->setURL(m_url.url());
	// FIXME: set Last-Modified and cookies (currently, those are only available for HTMLDocuments).
	m_responseXML->write(String(m_responseText));
	m_responseXML->finishParsing();
	m_responseXML->close();

	if (!m_responseXML->wellFormed())
	m_responseXML = 0;
	}
	m_createdDocument = true;
	}

	return m_responseXML.get();
	}

	EventListener* XMLHttpRequest::onReadyStateChangeListener() const
	{
	return m_onReadyStateChangeListener.get();
	}

	void XMLHttpRequest::setOnReadyStateChangeListener(EventListener* eventListener)
	{
	m_onReadyStateChangeListener = eventListener;
	}

	EventListener* XMLHttpRequest::onLoadListener() const
	{
	return m_onLoadListener.get();
	}

	void XMLHttpRequest::setOnLoadListener(EventListener* eventListener)
	{
	m_onLoadListener = eventListener;
	}

	void XMLHttpRequest::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> eventListener, bool)
	{
	EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
	if (iter == m_eventListeners.end()) {
	ListenerVector listeners;
	listeners.append(eventListener);
	m_eventListeners.add(eventType.impl(), listeners);
	} else {
	ListenerVector& listeners = iter->second;
	for (ListenerVector::iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
	if (*listenerIter == eventListener)
	return;

	listeners.append(eventListener);
	m_eventListeners.add(eventType.impl(), listeners);
	}
	}

	void XMLHttpRequest::removeEventListener(const AtomicString& eventType, EventListener* eventListener, bool)
	{
	EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
	if (iter == m_eventListeners.end())
	return;

	ListenerVector& listeners = iter->second;
	for (ListenerVector::const_iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
	if (*listenerIter == eventListener) {
	listeners.remove(listenerIter - listeners.begin());
	return;
	}
	}

	bool XMLHttpRequest::dispatchEvent(PassRefPtr<Event> evt, ExceptionCode& ec, bool /tempEvent/)
	{
	// FIXME: check for other error conditions enumerated in the spec.
	if (evt->type().isEmpty()) {
	ec = UNSPECIFIED_EVENT_TYPE_ERR;
	return true;
	}

	ListenerVector listenersCopy = m_eventListeners.get(evt->type().impl());
	for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
	evt->setTarget(this);
	evt->setCurrentTarget(this);
	listenerIter->get()->handleEvent(evt.get(), false);
	}

	return !evt->defaultPrevented();
	}

	XMLHttpRequest::XMLHttpRequest(Document* d)
	: m_doc(d)
	, m_async(true)
	, m_loader(0)
	, m_state(Uninitialized)
	, m_responseText("")
	, m_createdDocument(false)
	, m_aborted(false)
	{
	ASSERT(m_doc);
	addToRequestsByDocument(m_doc, this);
	}

	XMLHttpRequest::~XMLHttpRequest()
	{
	if (m_doc)
	removeFromRequestsByDocument(m_doc, this);
	}

	void XMLHttpRequest::changeState(XMLHttpRequestState newState)
	{
	if (m_state != newState) {
	m_state = newState;
	callReadyStateChangeListener();
	}
	}

	void XMLHttpRequest::callReadyStateChangeListener()
	{
	if (m_doc && m_doc->frame() && m_onReadyStateChangeListener) {
	RefPtr<Event> evt = new Event(readystatechangeEvent, true, true);
	evt->setTarget(this);
	evt->setCurrentTarget(this);
	m_onReadyStateChangeListener->handleEvent(evt.get(), false);
	}

	if (m_doc && m_doc->frame() && m_state == Loaded) {
	if (m_onLoadListener) {
	RefPtr<Event> evt = new Event(loadEvent, true, true);
	evt->setTarget(this);
	evt->setCurrentTarget(this);
	m_onLoadListener->handleEvent(evt.get(), false);
	}

	ListenerVector listenersCopy = m_eventListeners.get(loadEvent.impl());
	for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
	RefPtr<Event> evt = new Event(loadEvent, true, true);
	evt->setTarget(this);
	evt->setCurrentTarget(this);
	listenerIter->get()->handleEvent(evt.get(), false);
	}
	}
	}

	bool XMLHttpRequest::urlMatchesDocumentDomain(const KURL& url) const
	{
	// a local file can load anything
	if (m_doc->isAllowedToLoadLocalResources())
	return true;

	// but a remote document can only load from the same port on the server
	KURL documentURL = m_doc->URL();
	if (documentURL.protocol().lower() == url.protocol().lower()
	&& documentURL.host().lower() == url.host().lower()
	&& documentURL.port() == url.port())
	return true;

	return false;
	}

	void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionCode& ec)
	{
	abort();
	m_aborted = false;

	// clear stuff from possible previous load
	m_requestHeaders.clear();
	m_response = ResourceResponse();
	{
	KJS::JSLock lock;
	m_responseText = "";
	}
	m_createdDocument = false;
	m_responseXML = 0;

	changeState(Uninitialized);

	if (!urlMatchesDocumentDomain(url)) {
	ec = PERMISSION_DENIED;
	return;
	}

	if (!isValidToken(method)) {
	ec = SYNTAX_ERR;
	return;
	}

	m_url = url;

	// Method names are case sensitive. But since Firefox uppercases method names it knows, we'll do the same.
	String methodUpper(method.upper());
	if (methodUpper == "CONNECT" \|\| methodUpper == "COPY" \|\| methodUpper == "DELETE" \|\| methodUpper == "GET" \|\| methodUpper == "HEAD"
	\|\| methodUpper == "INDEX" \|\| methodUpper == "LOCK" \|\| methodUpper == "M-POST" \|\| methodUpper == "MKCOL" \|\| methodUpper == "MOVE"
	\|\| methodUpper == "OPTIONS" \|\| methodUpper == "POST" \|\| methodUpper == "PROPFIND" \|\| methodUpper == "PROPPATCH" \|\| methodUpper == "PUT"
	\|\| methodUpper == "TRACE" \|\| methodUpper == "UNLOCK")
	m_method = methodUpper.deprecatedString();
	else
	m_method = method.deprecatedString();

	m_async = async;

	changeState(Open);
	}

	void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, ExceptionCode& ec)
	{
	KURL urlWithCredentials(url);
	urlWithCredentials.setUser(user.deprecatedString());

	open(method, urlWithCredentials, async, ec);
	}

	void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, const String& password, ExceptionCode& ec)
	{
	KURL urlWithCredentials(url);
	urlWithCredentials.setUser(user.deprecatedString());
	urlWithCredentials.setPass(password.deprecatedString());

	open(method, urlWithCredentials, async, ec);
	}

	void XMLHttpRequest::send(const String& body, ExceptionCode& ec)
	{
	if (!m_doc)
	return;

	if (m_state != Open) {
	ec = INVALID_STATE_ERR;
	return;
	}

	// FIXME: Should this abort or raise an exception instead if we already have a m_loader going?
	if (m_loader)
	return;

	m_aborted = false;

	ResourceRequest request(m_url);
	request.setHTTPMethod(m_method);

	if (!body.isNull() && m_method != "GET" && m_method != "HEAD" && (m_url.protocol().lower() == "http" \|\| m_url.protocol().lower() == "https")) {
	String contentType = getRequestHeader("Content-Type");
	if (contentType.isEmpty()) {
	ExceptionCode ec = 0;
	Settings* settings = m_doc->settings();
	if (settings && settings->usesDashboardBackwardCompatibilityMode())
	setRequestHeader("Content-Type", "application/x-www-form-urlencoded", ec);
	else
	setRequestHeader("Content-Type", "application/xml", ec);
	ASSERT(ec == 0);
	}

	// FIXME: must use xmlEncoding for documents.
	String charset = "UTF-8";

	TextEncoding m_encoding(charset);
	if (!m_encoding.isValid()) // FIXME: report an error?
	m_encoding = UTF8Encoding();

	request.setHTTPBody(PassRefPtr<FormData>(new FormData(m_encoding.encode(body.characters(), body.length()))));
	}

	if (m_requestHeaders.size() > 0)
	request.addHTTPHeaderFields(m_requestHeaders);

	if (!m_async) {
	Vector<char> data;
	ResourceError error;
	ResourceResponse response;

	{
	// avoid deadlock in case the loader wants to use JS on a background thread
	KJS::JSLock::DropAllLocks dropLocks;
	if (m_doc->frame())
	m_doc->frame()->loader()->loadResourceSynchronously(request, error, response, data);
	}

	m_loader = 0;

	// No exception for file:/// resources, see <rdar://problem/4962298>.
	// Also, if we have an HTTP response, then it wasn't a network error in fact.
	if (error.isNull() \|\| request.url().isLocalFile() \|\| response.httpStatusCode() > 0)
	processSyncLoadResults(data, response);
	else
	ec = NETWORK_ERR;

	return;
	}

	// Neither this object nor the JavaScript wrapper should be deleted while
	// a request is in progress because we need to keep the listeners alive,
	// and they are referenced by the JavaScript wrapper.
	ref();
	{
	KJS::JSLock lock;
	gcProtectNullTolerant(KJS::ScriptInterpreter::getDOMObject(this));
	}

	// create can return null here, for example if we're no longer attached to a page.
	// this is true while running onunload handlers
	// FIXME: Maybe create can return false for other reasons too?
	m_loader = SubresourceLoader::create(m_doc->frame(), this, request, false, true, false);
	}

	void XMLHttpRequest::abort()
	{
	bool hadLoader = m_loader;

	m_aborted = true;

	if (hadLoader) {
	m_loader->cancel();
	m_loader = 0;
	}

	m_decoder = 0;

	if (hadLoader)
	dropProtection();
	}

	void XMLHttpRequest::dropProtection()
	{
	{
	KJS::JSLock lock;
	KJS::JSValue* wrapper = KJS::ScriptInterpreter::getDOMObject(this);
	KJS::gcUnprotectNullTolerant(wrapper);

	// the XHR object itself holds on to the responseText, and
	// thus has extra cost even independent of any
	// responseText or responseXML objects it has handed
	// out. But it is protected from GC while loading, so this
	// can't be recouped until the load is done, so only
	// report the extra cost at that point.

	if (wrapper)
	KJS::Collector::reportExtraMemoryCost(m_responseText.size() * 2);
	}

	deref();
	}

	void XMLHttpRequest::overrideMIMEType(const String& override)
	{
	m_mimeTypeOverride = override;
	}

	void XMLHttpRequest::setRequestHeader(const String& name, const String& value, ExceptionCode& ec)
	{
	if (m_state != Open) {
	Settings* settings = m_doc ? m_doc->settings() : 0;
	if (settings && settings->usesDashboardBackwardCompatibilityMode())
	return;

	ec = INVALID_STATE_ERR;
	return;
	}

	if (!isValidToken(name) \|\| !isValidHeaderValue(value)) {
	ec = SYNTAX_ERR;
	return;
	}

	if (!canSetRequestHeader(name)) {
	if (m_doc && m_doc->frame() && m_doc->frame()->page())
	m_doc->frame()->page()->chrome()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, "Refused to set unsafe header " + name, 1, String());
	return;
	}

	if (!m_requestHeaders.contains(name)) {
	m_requestHeaders.set(name, value);
	return;
	}

	String oldValue = m_requestHeaders.get(name);
	m_requestHeaders.set(name, oldValue + ", " + value);
	}

	String XMLHttpRequest::getRequestHeader(const String& name) const
	{
	return m_requestHeaders.get(name);
	}

	String XMLHttpRequest::getAllResponseHeaders() const
	{
	Vector<UChar> stringBuilder;
	String separator(": ");

	HTTPHeaderMap::const_iterator end = m_response.httpHeaderFields().end();
	for (HTTPHeaderMap::const_iterator it = m_response.httpHeaderFields().begin(); it!= end; ++it) {
	stringBuilder.append(it->first.characters(), it->first.length());
	stringBuilder.append(separator.characters(), separator.length());
	stringBuilder.append(it->second.characters(), it->second.length());
	stringBuilder.append((UChar)'\n');
	}

	return String::adopt(stringBuilder);
	}

	String XMLHttpRequest::getResponseHeader(const String& name) const
	{
	return m_response.httpHeaderField(name);
	}

	String XMLHttpRequest::responseMIMEType() const
	{
	String mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
	if (mimeType.isEmpty()) {
	if (m_response.isHTTP())
	mimeType = extractMIMETypeFromMediaType(getResponseHeader("Content-Type"));
	else
	mimeType = m_response.mimeType();
	}
	if (mimeType.isEmpty())
	mimeType = "text/xml";

	return mimeType;
	}

	bool XMLHttpRequest::responseIsXML() const
	{
	return DOMImplementation::isXMLMIMEType(responseMIMEType());
	}

	int XMLHttpRequest::getStatus(ExceptionCode& ec) const
	{
	if (m_state == Uninitialized)
	return 0;

	if (m_response.httpStatusCode() == 0) {
	if (m_state != Receiving && m_state != Loaded)
	// status MUST be available in these states, but we don't get any headers from non-HTTP requests
	ec = INVALID_STATE_ERR;
	}

	return m_response.httpStatusCode();
	}

	String XMLHttpRequest::getStatusText(ExceptionCode& ec) const
	{
	if (m_state == Uninitialized)
	return "";

	if (m_response.httpStatusCode() == 0) {
	if (m_state != Receiving && m_state != Loaded)
	// statusText MUST be available in these states, but we don't get any headers from non-HTTP requests
	ec = INVALID_STATE_ERR;
	return String();
	}

	// FIXME: should try to preserve status text in response
	return "OK";
	}

	void XMLHttpRequest::processSyncLoadResults(const Vector<char>& data, const ResourceResponse& response)
	{
	if (!urlMatchesDocumentDomain(response.url())) {
	abort();
	return;
	}

	didReceiveResponse(0, response);
	changeState(Sent);
	if (m_aborted)
	return;

	const char* bytes = static_cast<const char*>(data.data());
	int len = static_cast<int>(data.size());

	didReceiveData(0, bytes, len);
	if (m_aborted)
	return;

	didFinishLoading(0);
	}

	void XMLHttpRequest::didFail(SubresourceLoader* loader, const ResourceError&)
	{
	didFinishLoading(loader);
	}

	void XMLHttpRequest::didFinishLoading(SubresourceLoader* loader)
	{
	if (m_aborted)
	return;

	ASSERT(loader == m_loader);

	if (m_state < Sent)
	changeState(Sent);

	{
	KJS::JSLock lock;
	if (m_decoder)
	m_responseText += m_decoder->flush();
	}

	bool hadLoader = m_loader;
	m_loader = 0;

	changeState(Loaded);
	m_decoder = 0;

	if (hadLoader)
	dropProtection();
	}

	void XMLHttpRequest::willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse& redirectResponse)
	{
	if (!urlMatchesDocumentDomain(request.url()))
	abort();
	}

	void XMLHttpRequest::didReceiveResponse(SubresourceLoader*, const ResourceResponse& response)
	{
	m_response = response;
	m_encoding = extractCharsetFromMediaType(m_mimeTypeOverride);
	if (m_encoding.isEmpty())
	m_encoding = response.textEncodingName();

	}

	void XMLHttpRequest::receivedCancellation(SubresourceLoader*, const AuthenticationChallenge& challenge)
	{
	m_response = challenge.failureResponse();
	}

	void XMLHttpRequest::didReceiveData(SubresourceLoader, const char data, int len)
	{
	if (m_state < Sent)
	changeState(Sent);

	if (!m_decoder) {
	if (!m_encoding.isEmpty())
	m_decoder = new TextResourceDecoder("text/plain", m_encoding);
	// allow TextResourceDecoder to look inside the m_response if it's XML or HTML
	else if (responseIsXML())
	m_decoder = new TextResourceDecoder("application/xml");
	else if (responseMIMEType() == "text/html")
	m_decoder = new TextResourceDecoder("text/html");
	else
	m_decoder = new TextResourceDecoder("text/plain", "UTF-8");
	}
	if (len == 0)
	return;

	if (len == -1)
	len = strlen(data);

	String decoded = m_decoder->decode(data, len);

	{
	KJS::JSLock lock;
	m_responseText += decoded;
	}

	if (!m_aborted) {
	if (m_state != Receiving)
	changeState(Receiving);
	else
	// Firefox calls readyStateChanged every time it receives data, 4449442
	callReadyStateChangeListener();
	}
	}

	void XMLHttpRequest::cancelRequests(Document* m_doc)
	{
	RequestsSet* requests = requestsByDocument().get(m_doc);
	if (!requests)
	return;
	RequestsSet copy = *requests;
	RequestsSet::const_iterator end = copy.end();
	for (RequestsSet::const_iterator it = copy.begin(); it != end; ++it)
	(*it)->abort();
	}

	void XMLHttpRequest::detachRequests(Document* m_doc)
	{
	RequestsSet* requests = requestsByDocument().get(m_doc);
	if (!requests)
	return;
	requestsByDocument().remove(m_doc);
	RequestsSet::const_iterator end = requests->end();
	for (RequestsSet::const_iterator it = requests->begin(); it != end; ++it) {
	(*it)->m_doc = 0;
	(*it)->abort();
	}
	delete requests;
	}

	} // end namespace