178818e122aea0156772660ede4ef814b672120a
[WebKit-https.git] / WebCore / xml / XMLHttpRequest.cpp
1 /*
2  *  This file is part of the KDE libraries
3  *  Copyright (C) 2004, 2006 Apple Computer, Inc.
4  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Lesser General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free Software
18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include "config.h"
22 #include "XMLHttpRequest.h"
23
24 #include "CString.h"
25 #include "Cache.h"
26 #include "DOMImplementation.h"
27 #include "TextResourceDecoder.h"
28 #include "Event.h"
29 #include "EventListener.h"
30 #include "EventNames.h"
31 #include "ExceptionCode.h"
32 #include "FormData.h"
33 #include "Frame.h"
34 #include "FrameLoader.h"
35 #include "HTMLDocument.h"
36 #include "HTTPParsers.h"
37 #include "Page.h"
38 #include "PlatformString.h"
39 #include "RegularExpression.h"
40 #include "ResourceHandle.h"
41 #include "ResourceRequest.h"
42 #include "Settings.h"
43 #include "SubresourceLoader.h"
44 #include "TextEncoding.h"
45 #include "kjs_binding.h"
46 #include <kjs/protect.h>
47 #include <wtf/Vector.h>
48
49 namespace WebCore {
50
51 using namespace EventNames;
52
53 typedef HashSet<XMLHttpRequest*> RequestsSet;
54
55 static HashMap<Document*, RequestsSet*>& requestsByDocument()
56 {
57     static HashMap<Document*, RequestsSet*> map;
58     return map;
59 }
60
61 static void addToRequestsByDocument(Document* doc, XMLHttpRequest* req)
62 {
63     ASSERT(doc);
64     ASSERT(req);
65
66     RequestsSet* requests = requestsByDocument().get(doc);
67     if (!requests) {
68         requests = new RequestsSet;
69         requestsByDocument().set(doc, requests);
70     }
71
72     ASSERT(!requests->contains(req));
73     requests->add(req);
74 }
75
76 static void removeFromRequestsByDocument(Document* doc, XMLHttpRequest* req)
77 {
78     ASSERT(doc);
79     ASSERT(req);
80
81     RequestsSet* requests = requestsByDocument().get(doc);
82     ASSERT(requests);
83     ASSERT(requests->contains(req));
84     requests->remove(req);
85     if (requests->isEmpty()) {
86         requestsByDocument().remove(doc);
87         delete requests;
88     }
89 }
90
91 static bool canSetRequestHeader(const String& name)
92 {
93     static HashSet<String, CaseInsensitiveHash<String> > forbiddenHeaders;
94     
95     if (forbiddenHeaders.isEmpty()) {
96         forbiddenHeaders.add("accept-charset");
97         forbiddenHeaders.add("accept-encoding");
98         forbiddenHeaders.add("content-length");
99         forbiddenHeaders.add("expect");
100         forbiddenHeaders.add("date");
101         forbiddenHeaders.add("host");
102         forbiddenHeaders.add("keep-alive");
103         forbiddenHeaders.add("referer");
104         forbiddenHeaders.add("te");
105         forbiddenHeaders.add("trailer");
106         forbiddenHeaders.add("transfer-encoding");
107         forbiddenHeaders.add("upgrade");
108         forbiddenHeaders.add("via");
109     }
110     
111     return !forbiddenHeaders.contains(name);
112 }
113
114 // Determines if a string is a valid token, as defined by
115 // "token" in section 2.2 of RFC 2616.
116 static bool isValidToken(const String& name)
117 {
118     unsigned length = name.length();
119     for (unsigned i = 0; i < length; i++) {
120         UChar c = name[i];
121         
122         if (c >= 127 || c <= 32)
123             return false;
124         
125         if (c == '(' || c == ')' || c == '<' || c == '>' || c == '@' ||
126             c == ',' || c == ';' || c == ':' || c == '\\' || c == '\"' ||
127             c == '/' || c == '[' || c == ']' || c == '?' || c == '=' ||
128             c == '{' || c == '}')
129             return false;
130     }
131     
132     return true;
133 }
134     
135 static bool isValidHeaderValue(const String& name)
136 {
137     // FIXME: This should really match name against 
138     // field-value in section 4.2 of RFC 2616.
139         
140     return !name.contains('\r') && !name.contains('\n');
141 }
142     
143 XMLHttpRequestState XMLHttpRequest::getReadyState() const
144 {
145     return m_state;
146 }
147
148 KJS::UString XMLHttpRequest::getResponseText() const
149 {
150     return m_responseText;
151 }
152
153 Document* XMLHttpRequest::getResponseXML() const
154 {
155     if (m_state != Loaded)
156         return 0;
157
158     if (!m_createdDocument) {
159         if (m_response.isHTTP() && !responseIsXML()) {
160             // The W3C spec requires this.
161             m_responseXML = 0;
162         } else {
163             m_responseXML = m_doc->implementation()->createDocument(0);
164             m_responseXML->open();
165             m_responseXML->setURL(m_url.url());
166             // FIXME: set Last-Modified and cookies (currently, those are only available for HTMLDocuments).
167             m_responseXML->write(String(m_responseText));
168             m_responseXML->finishParsing();
169             m_responseXML->close();
170             
171             if (!m_responseXML->wellFormed())
172                 m_responseXML = 0;
173         }
174         m_createdDocument = true;
175     }
176
177     return m_responseXML.get();
178 }
179
180 EventListener* XMLHttpRequest::onReadyStateChangeListener() const
181 {
182     return m_onReadyStateChangeListener.get();
183 }
184
185 void XMLHttpRequest::setOnReadyStateChangeListener(EventListener* eventListener)
186 {
187     m_onReadyStateChangeListener = eventListener;
188 }
189
190 EventListener* XMLHttpRequest::onLoadListener() const
191 {
192     return m_onLoadListener.get();
193 }
194
195 void XMLHttpRequest::setOnLoadListener(EventListener* eventListener)
196 {
197     m_onLoadListener = eventListener;
198 }
199
200 void XMLHttpRequest::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> eventListener, bool)
201 {
202     EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
203     if (iter == m_eventListeners.end()) {
204         ListenerVector listeners;
205         listeners.append(eventListener);
206         m_eventListeners.add(eventType.impl(), listeners);
207     } else {
208         ListenerVector& listeners = iter->second;
209         for (ListenerVector::iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
210             if (*listenerIter == eventListener)
211                 return;
212         
213         listeners.append(eventListener);
214         m_eventListeners.add(eventType.impl(), listeners);
215     }
216 }
217
218 void XMLHttpRequest::removeEventListener(const AtomicString& eventType, EventListener* eventListener, bool)
219 {
220     EventListenersMap::iterator iter = m_eventListeners.find(eventType.impl());
221     if (iter == m_eventListeners.end())
222         return;
223
224     ListenerVector& listeners = iter->second;
225     for (ListenerVector::const_iterator listenerIter = listeners.begin(); listenerIter != listeners.end(); ++listenerIter)
226         if (*listenerIter == eventListener) {
227             listeners.remove(listenerIter - listeners.begin());
228             return;
229         }
230 }
231
232 bool XMLHttpRequest::dispatchEvent(PassRefPtr<Event> evt, ExceptionCode& ec, bool /*tempEvent*/)
233 {
234     // FIXME: check for other error conditions enumerated in the spec.
235     if (evt->type().isEmpty()) {
236         ec = UNSPECIFIED_EVENT_TYPE_ERR;
237         return true;
238     }
239
240     ListenerVector listenersCopy = m_eventListeners.get(evt->type().impl());
241     for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
242         evt->setTarget(this);
243         evt->setCurrentTarget(this);
244         listenerIter->get()->handleEvent(evt.get(), false);
245     }
246
247     return !evt->defaultPrevented();
248 }
249
250 XMLHttpRequest::XMLHttpRequest(Document* d)
251     : m_doc(d)
252     , m_async(true)
253     , m_loader(0)
254     , m_state(Uninitialized)
255     , m_responseText("")
256     , m_createdDocument(false)
257     , m_aborted(false)
258 {
259     ASSERT(m_doc);
260     addToRequestsByDocument(m_doc, this);
261 }
262
263 XMLHttpRequest::~XMLHttpRequest()
264 {
265     if (m_doc)
266         removeFromRequestsByDocument(m_doc, this);
267 }
268
269 void XMLHttpRequest::changeState(XMLHttpRequestState newState)
270 {
271     if (m_state != newState) {
272         m_state = newState;
273         callReadyStateChangeListener();
274     }
275 }
276
277 void XMLHttpRequest::callReadyStateChangeListener()
278 {
279     if (m_doc && m_doc->frame() && m_onReadyStateChangeListener) {
280         RefPtr<Event> evt = new Event(readystatechangeEvent, true, true);
281         evt->setTarget(this);
282         evt->setCurrentTarget(this);
283         m_onReadyStateChangeListener->handleEvent(evt.get(), false);
284     }
285     
286     if (m_doc && m_doc->frame() && m_state == Loaded) {
287         if (m_onLoadListener) {
288             RefPtr<Event> evt = new Event(loadEvent, true, true);
289             evt->setTarget(this);
290             evt->setCurrentTarget(this);
291             m_onLoadListener->handleEvent(evt.get(), false);
292         }
293         
294         ListenerVector listenersCopy = m_eventListeners.get(loadEvent.impl());
295         for (ListenerVector::const_iterator listenerIter = listenersCopy.begin(); listenerIter != listenersCopy.end(); ++listenerIter) {
296             RefPtr<Event> evt = new Event(loadEvent, true, true);
297             evt->setTarget(this);
298             evt->setCurrentTarget(this);
299             listenerIter->get()->handleEvent(evt.get(), false);
300         }
301     }
302 }
303
304 bool XMLHttpRequest::urlMatchesDocumentDomain(const KURL& url) const
305 {
306     // a local file can load anything
307     if (m_doc->isAllowedToLoadLocalResources())
308         return true;
309
310     // but a remote document can only load from the same port on the server
311     KURL documentURL = m_doc->URL();
312     if (documentURL.protocol().lower() == url.protocol().lower()
313             && documentURL.host().lower() == url.host().lower()
314             && documentURL.port() == url.port())
315         return true;
316
317     return false;
318 }
319
320 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, ExceptionCode& ec)
321 {
322     abort();
323     m_aborted = false;
324
325     // clear stuff from possible previous load
326     m_requestHeaders.clear();
327     m_response = ResourceResponse();
328     m_responseText = "";
329     m_createdDocument = false;
330     m_responseXML = 0;
331
332     changeState(Uninitialized);
333
334     if (!urlMatchesDocumentDomain(url)) {
335         ec = PERMISSION_DENIED;
336         return;
337     }
338
339     if (!isValidToken(method)) {
340         ec = SYNTAX_ERR;
341         return;
342     }
343     
344     m_url = url;
345
346     // Method names are case sensitive. But since Firefox uppercases method names it knows, we'll do the same.
347     String methodUpper(method.upper());
348     if (methodUpper == "CONNECT" || methodUpper == "COPY" || methodUpper == "DELETE" || methodUpper == "GET" || methodUpper == "HEAD"
349         || methodUpper == "INDEX" || methodUpper == "LOCK" || methodUpper == "M-POST" || methodUpper == "MKCOL" || methodUpper == "MOVE" 
350         || methodUpper == "OPTIONS" || methodUpper == "POST" || methodUpper == "PROPFIND" || methodUpper == "PROPPATCH" || methodUpper == "PUT" 
351         || methodUpper == "TRACE" || methodUpper == "UNLOCK")
352         m_method = methodUpper.deprecatedString();
353     else
354         m_method = method.deprecatedString();
355
356     m_async = async;
357
358     changeState(Open);
359 }
360
361 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, ExceptionCode& ec)
362 {
363     KURL urlWithCredentials(url);
364     urlWithCredentials.setUser(user.deprecatedString());
365     
366     open(method, urlWithCredentials, async, ec);
367 }
368
369 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, const String& password, ExceptionCode& ec)
370 {
371     KURL urlWithCredentials(url);
372     urlWithCredentials.setUser(user.deprecatedString());
373     urlWithCredentials.setPass(password.deprecatedString());
374     
375     open(method, urlWithCredentials, async, ec);
376 }
377
378 void XMLHttpRequest::send(const String& body, ExceptionCode& ec)
379 {
380     if (!m_doc)
381         return;
382
383     if (m_state != Open) {
384         ec = INVALID_STATE_ERR;
385         return;
386     }
387   
388     // FIXME: Should this abort or raise an exception instead if we already have a m_loader going?
389     if (m_loader)
390         return;
391
392     m_aborted = false;
393
394     ResourceRequest request(m_url);
395     request.setHTTPMethod(m_method);
396     
397     if (!body.isNull() && m_method != "GET" && m_method != "HEAD" && (m_url.protocol().lower() == "http" || m_url.protocol().lower() == "https")) {
398         String contentType = getRequestHeader("Content-Type");
399         if (contentType.isEmpty()) {
400             ExceptionCode ec = 0;
401             Settings* settings = m_doc->settings();
402             if (settings && settings->usesDashboardBackwardCompatibilityMode())
403                 setRequestHeader("Content-Type", "application/x-www-form-urlencoded", ec);
404             else
405                 setRequestHeader("Content-Type", "application/xml", ec);
406             ASSERT(ec == 0);
407         }
408
409         // FIXME: must use xmlEncoding for documents.
410         String charset = "UTF-8";
411       
412         TextEncoding m_encoding(charset);
413         if (!m_encoding.isValid()) // FIXME: report an error?
414             m_encoding = UTF8Encoding();
415
416         request.setHTTPBody(PassRefPtr<FormData>(new FormData(m_encoding.encode(body.characters(), body.length()))));
417     }
418
419     if (m_requestHeaders.size() > 0)
420         request.addHTTPHeaderFields(m_requestHeaders);
421
422     if (!m_async) {
423         Vector<char> data;
424         ResourceError error;
425         ResourceResponse response;
426
427         {
428             // avoid deadlock in case the loader wants to use JS on a background thread
429             KJS::JSLock::DropAllLocks dropLocks;
430             if (m_doc->frame()) 
431                 m_doc->frame()->loader()->loadResourceSynchronously(request, error, response, data);
432         }
433
434         m_loader = 0;
435         
436         if (error.isNull() || request.url().isLocalFile())
437             processSyncLoadResults(data, response);
438         else
439             ec = NETWORK_ERR;
440
441         return;
442     }
443
444     // Neither this object nor the JavaScript wrapper should be deleted while
445     // a request is in progress because we need to keep the listeners alive,
446     // and they are referenced by the JavaScript wrapper.
447     ref();
448     {
449         KJS::JSLock lock;
450         gcProtectNullTolerant(KJS::ScriptInterpreter::getDOMObject(this));
451     }
452   
453     // create can return null here, for example if we're no longer attached to a page.
454     // this is true while running onunload handlers
455     // FIXME: Maybe create can return false for other reasons too?
456     m_loader = SubresourceLoader::create(m_doc->frame(), this, request);
457 }
458
459 void XMLHttpRequest::abort()
460 {
461     bool hadLoader = m_loader;
462
463     m_aborted = true;
464     
465     if (hadLoader) {
466         m_loader->cancel();
467         m_loader = 0;
468     }
469
470     m_decoder = 0;
471
472     if (hadLoader)
473         dropProtection();
474 }
475
476 void XMLHttpRequest::dropProtection()        
477 {
478     {
479         KJS::JSLock lock;
480         KJS::JSValue* wrapper = KJS::ScriptInterpreter::getDOMObject(this);
481         KJS::gcUnprotectNullTolerant(wrapper);
482     
483         // the XHR object itself holds on to the responseText, and
484         // thus has extra cost even independent of any
485         // responseText or responseXML objects it has handed
486         // out. But it is protected from GC while loading, so this
487         // can't be recouped until the load is done, so only
488         // report the extra cost at that point.
489     
490         if (wrapper)
491             KJS::Collector::reportExtraMemoryCost(m_responseText.size() * 2);
492     }
493
494     deref();
495 }
496
497 void XMLHttpRequest::overrideMIMEType(const String& override)
498 {
499     m_mimeTypeOverride = override;
500 }
501     
502 void XMLHttpRequest::setRequestHeader(const String& name, const String& value, ExceptionCode& ec)
503 {
504     if (m_state != Open) {
505         Settings* settings = m_doc ? m_doc->settings() : 0;
506         if (settings && settings->usesDashboardBackwardCompatibilityMode())
507             return;
508
509         ec = INVALID_STATE_ERR;
510         return;
511     }
512
513     if (!isValidToken(name) || !isValidHeaderValue(value)) {
514         ec = SYNTAX_ERR;
515         return;
516     }
517         
518     if (!canSetRequestHeader(name)) {
519         if (m_doc && m_doc->frame() && m_doc->frame()->page())
520             m_doc->frame()->page()->chrome()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, "Refused to set unsafe header " + name, 1, String());
521         return;
522     }
523
524     if (!m_requestHeaders.contains(name)) {
525         m_requestHeaders.set(name, value);
526         return;
527     }
528     
529     String oldValue = m_requestHeaders.get(name);
530     m_requestHeaders.set(name, oldValue + ", " + value);
531 }
532
533 String XMLHttpRequest::getRequestHeader(const String& name) const
534 {
535     return m_requestHeaders.get(name);
536 }
537
538 String XMLHttpRequest::getAllResponseHeaders() const
539 {
540     Vector<UChar> stringBuilder;
541     String separator(": ");
542
543     HTTPHeaderMap::const_iterator end = m_response.httpHeaderFields().end();
544     for (HTTPHeaderMap::const_iterator it = m_response.httpHeaderFields().begin(); it!= end; ++it) {
545         stringBuilder.append(it->first.characters(), it->first.length());
546         stringBuilder.append(separator.characters(), separator.length());
547         stringBuilder.append(it->second.characters(), it->second.length());
548         stringBuilder.append((UChar)'\n');
549     }
550
551     return String::adopt(stringBuilder);
552 }
553
554 String XMLHttpRequest::getResponseHeader(const String& name) const
555 {
556     return m_response.httpHeaderField(name);
557 }
558
559 String XMLHttpRequest::responseMIMEType() const
560 {
561     String mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
562     if (mimeType.isEmpty()) {
563         if (m_response.isHTTP())
564             mimeType = extractMIMETypeFromMediaType(getResponseHeader("Content-Type"));
565         else
566             mimeType = m_response.mimeType();
567     }
568     if (mimeType.isEmpty())
569         mimeType = "text/xml";
570     
571     return mimeType;
572 }
573
574 bool XMLHttpRequest::responseIsXML() const
575 {
576     return DOMImplementation::isXMLMIMEType(responseMIMEType());
577 }
578
579 int XMLHttpRequest::getStatus(ExceptionCode& ec) const
580 {
581     if (m_state == Uninitialized)
582         return 0;
583     
584     if (m_response.httpStatusCode() == 0) {
585         if (m_state != Receiving && m_state != Loaded)
586             // status MUST be available in these states, but we don't get any headers from non-HTTP requests
587             ec = INVALID_STATE_ERR;
588     }
589
590     return m_response.httpStatusCode();
591 }
592
593 String XMLHttpRequest::getStatusText(ExceptionCode& ec) const
594 {
595     if (m_state == Uninitialized)
596         return "";
597     
598     if (m_response.httpStatusCode() == 0) {
599         if (m_state != Receiving && m_state != Loaded)
600             // statusText MUST be available in these states, but we don't get any headers from non-HTTP requests
601             ec = INVALID_STATE_ERR;
602         return String();
603     }
604
605     // FIXME: should try to preserve status text in response
606     return "OK";
607 }
608
609 void XMLHttpRequest::processSyncLoadResults(const Vector<char>& data, const ResourceResponse& response)
610 {
611     if (!urlMatchesDocumentDomain(response.url())) {
612         abort();
613         return;
614     }
615
616     didReceiveResponse(0, response);
617     changeState(Sent);
618     if (m_aborted)
619         return;
620
621     const char* bytes = static_cast<const char*>(data.data());
622     int len = static_cast<int>(data.size());
623
624     didReceiveData(0, bytes, len);
625     if (m_aborted)
626         return;
627
628     didFinishLoading(0);
629 }
630
631 void XMLHttpRequest::didFail(SubresourceLoader* loader, const ResourceError&)
632 {
633     didFinishLoading(loader);
634 }
635
636 void XMLHttpRequest::didFinishLoading(SubresourceLoader* loader)
637 {
638     if (m_aborted)
639         return;
640         
641     ASSERT(loader == m_loader);
642
643     if (m_state < Sent)
644         changeState(Sent);
645
646     if (m_decoder)
647         m_responseText += m_decoder->flush();
648
649     bool hadLoader = m_loader;
650     m_loader = 0;
651
652     changeState(Loaded);
653     m_decoder = 0;
654
655     if (hadLoader)
656         dropProtection();
657 }
658
659 void XMLHttpRequest::willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse& redirectResponse)
660 {
661     if (!urlMatchesDocumentDomain(request.url()))
662         abort();
663 }
664
665 void XMLHttpRequest::didReceiveResponse(SubresourceLoader*, const ResourceResponse& response)
666 {
667     m_response = response;
668     m_encoding = extractCharsetFromMediaType(m_mimeTypeOverride);
669     if (m_encoding.isEmpty())
670         m_encoding = response.textEncodingName();
671
672 }
673
674 void XMLHttpRequest::didReceiveData(SubresourceLoader*, const char* data, int len)
675 {
676     if (m_state < Sent)
677         changeState(Sent);
678   
679     if (!m_decoder) {
680         if (!m_encoding.isEmpty())
681             m_decoder = new TextResourceDecoder("text/plain", m_encoding);
682         // allow TextResourceDecoder to look inside the m_response if it's XML or HTML
683         else if (responseIsXML())
684             m_decoder = new TextResourceDecoder("application/xml");
685         else if (responseMIMEType() == "text/html")
686             m_decoder = new TextResourceDecoder("text/html");
687         else
688             m_decoder = new TextResourceDecoder("text/plain", "UTF-8");
689     }
690     if (len == 0)
691         return;
692
693     if (len == -1)
694         len = strlen(data);
695
696     String decoded = m_decoder->decode(data, len);
697
698     m_responseText += decoded;
699
700     if (!m_aborted) {
701         if (m_state != Receiving)
702             changeState(Receiving);
703         else
704             // Firefox calls readyStateChanged every time it receives data, 4449442
705             callReadyStateChangeListener();
706     }
707 }
708
709 void XMLHttpRequest::cancelRequests(Document* m_doc)
710 {
711     RequestsSet* requests = requestsByDocument().get(m_doc);
712     if (!requests)
713         return;
714     RequestsSet copy = *requests;
715     RequestsSet::const_iterator end = copy.end();
716     for (RequestsSet::const_iterator it = copy.begin(); it != end; ++it)
717         (*it)->abort();
718 }
719
720 void XMLHttpRequest::detachRequests(Document* m_doc)
721 {
722     RequestsSet* requests = requestsByDocument().get(m_doc);
723     if (!requests)
724         return;
725     requestsByDocument().remove(m_doc);
726     RequestsSet::const_iterator end = requests->end();
727     for (RequestsSet::const_iterator it = requests->begin(); it != end; ++it) {
728         (*it)->m_doc = 0;
729         (*it)->abort();
730     }
731     delete requests;
732 }
733
734 } // end namespace