JavaScriptCore:
[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 const 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     {
329         KJS::JSLock lock;
330         m_responseText = "";
331     }
332     m_createdDocument = false;
333     m_responseXML = 0;
334
335     changeState(Uninitialized);
336
337     if (!urlMatchesDocumentDomain(url)) {
338         ec = PERMISSION_DENIED;
339         return;
340     }
341
342     if (!isValidToken(method)) {
343         ec = SYNTAX_ERR;
344         return;
345     }
346     
347     m_url = url;
348
349     // Method names are case sensitive. But since Firefox uppercases method names it knows, we'll do the same.
350     String methodUpper(method.upper());
351     if (methodUpper == "CONNECT" || methodUpper == "COPY" || methodUpper == "DELETE" || methodUpper == "GET" || methodUpper == "HEAD"
352         || methodUpper == "INDEX" || methodUpper == "LOCK" || methodUpper == "M-POST" || methodUpper == "MKCOL" || methodUpper == "MOVE" 
353         || methodUpper == "OPTIONS" || methodUpper == "POST" || methodUpper == "PROPFIND" || methodUpper == "PROPPATCH" || methodUpper == "PUT" 
354         || methodUpper == "TRACE" || methodUpper == "UNLOCK")
355         m_method = methodUpper.deprecatedString();
356     else
357         m_method = method.deprecatedString();
358
359     m_async = async;
360
361     changeState(Open);
362 }
363
364 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, ExceptionCode& ec)
365 {
366     KURL urlWithCredentials(url);
367     urlWithCredentials.setUser(user.deprecatedString());
368     
369     open(method, urlWithCredentials, async, ec);
370 }
371
372 void XMLHttpRequest::open(const String& method, const KURL& url, bool async, const String& user, const String& password, ExceptionCode& ec)
373 {
374     KURL urlWithCredentials(url);
375     urlWithCredentials.setUser(user.deprecatedString());
376     urlWithCredentials.setPass(password.deprecatedString());
377     
378     open(method, urlWithCredentials, async, ec);
379 }
380
381 void XMLHttpRequest::send(const String& body, ExceptionCode& ec)
382 {
383     if (!m_doc)
384         return;
385
386     if (m_state != Open) {
387         ec = INVALID_STATE_ERR;
388         return;
389     }
390   
391     // FIXME: Should this abort or raise an exception instead if we already have a m_loader going?
392     if (m_loader)
393         return;
394
395     m_aborted = false;
396
397     ResourceRequest request(m_url);
398     request.setHTTPMethod(m_method);
399     
400     if (!body.isNull() && m_method != "GET" && m_method != "HEAD" && (m_url.protocol().lower() == "http" || m_url.protocol().lower() == "https")) {
401         String contentType = getRequestHeader("Content-Type");
402         if (contentType.isEmpty()) {
403             ExceptionCode ec = 0;
404             Settings* settings = m_doc->settings();
405             if (settings && settings->usesDashboardBackwardCompatibilityMode())
406                 setRequestHeader("Content-Type", "application/x-www-form-urlencoded", ec);
407             else
408                 setRequestHeader("Content-Type", "application/xml", ec);
409             ASSERT(ec == 0);
410         }
411
412         // FIXME: must use xmlEncoding for documents.
413         String charset = "UTF-8";
414       
415         TextEncoding m_encoding(charset);
416         if (!m_encoding.isValid()) // FIXME: report an error?
417             m_encoding = UTF8Encoding();
418
419         request.setHTTPBody(PassRefPtr<FormData>(new FormData(m_encoding.encode(body.characters(), body.length()))));
420     }
421
422     if (m_requestHeaders.size() > 0)
423         request.addHTTPHeaderFields(m_requestHeaders);
424
425     if (!m_async) {
426         Vector<char> data;
427         ResourceError error;
428         ResourceResponse response;
429
430         {
431             // avoid deadlock in case the loader wants to use JS on a background thread
432             KJS::JSLock::DropAllLocks dropLocks;
433             if (m_doc->frame()) 
434                 m_doc->frame()->loader()->loadResourceSynchronously(request, error, response, data);
435         }
436
437         m_loader = 0;
438         
439         if (error.isNull() || request.url().isLocalFile())
440             processSyncLoadResults(data, response);
441         else
442             ec = NETWORK_ERR;
443
444         return;
445     }
446
447     // Neither this object nor the JavaScript wrapper should be deleted while
448     // a request is in progress because we need to keep the listeners alive,
449     // and they are referenced by the JavaScript wrapper.
450     ref();
451     {
452         KJS::JSLock lock;
453         gcProtectNullTolerant(KJS::ScriptInterpreter::getDOMObject(this));
454     }
455   
456     // create can return null here, for example if we're no longer attached to a page.
457     // this is true while running onunload handlers
458     // FIXME: Maybe create can return false for other reasons too?
459     m_loader = SubresourceLoader::create(m_doc->frame(), this, request);
460 }
461
462 void XMLHttpRequest::abort()
463 {
464     bool hadLoader = m_loader;
465
466     m_aborted = true;
467     
468     if (hadLoader) {
469         m_loader->cancel();
470         m_loader = 0;
471     }
472
473     m_decoder = 0;
474
475     if (hadLoader)
476         dropProtection();
477 }
478
479 void XMLHttpRequest::dropProtection()        
480 {
481     {
482         KJS::JSLock lock;
483         KJS::JSValue* wrapper = KJS::ScriptInterpreter::getDOMObject(this);
484         KJS::gcUnprotectNullTolerant(wrapper);
485     
486         // the XHR object itself holds on to the responseText, and
487         // thus has extra cost even independent of any
488         // responseText or responseXML objects it has handed
489         // out. But it is protected from GC while loading, so this
490         // can't be recouped until the load is done, so only
491         // report the extra cost at that point.
492     
493         if (wrapper)
494             KJS::Collector::reportExtraMemoryCost(m_responseText.size() * 2);
495     }
496
497     deref();
498 }
499
500 void XMLHttpRequest::overrideMIMEType(const String& override)
501 {
502     m_mimeTypeOverride = override;
503 }
504     
505 void XMLHttpRequest::setRequestHeader(const String& name, const String& value, ExceptionCode& ec)
506 {
507     if (m_state != Open) {
508         Settings* settings = m_doc ? m_doc->settings() : 0;
509         if (settings && settings->usesDashboardBackwardCompatibilityMode())
510             return;
511
512         ec = INVALID_STATE_ERR;
513         return;
514     }
515
516     if (!isValidToken(name) || !isValidHeaderValue(value)) {
517         ec = SYNTAX_ERR;
518         return;
519     }
520         
521     if (!canSetRequestHeader(name)) {
522         if (m_doc && m_doc->frame() && m_doc->frame()->page())
523             m_doc->frame()->page()->chrome()->addMessageToConsole(JSMessageSource, ErrorMessageLevel, "Refused to set unsafe header " + name, 1, String());
524         return;
525     }
526
527     if (!m_requestHeaders.contains(name)) {
528         m_requestHeaders.set(name, value);
529         return;
530     }
531     
532     String oldValue = m_requestHeaders.get(name);
533     m_requestHeaders.set(name, oldValue + ", " + value);
534 }
535
536 String XMLHttpRequest::getRequestHeader(const String& name) const
537 {
538     return m_requestHeaders.get(name);
539 }
540
541 String XMLHttpRequest::getAllResponseHeaders() const
542 {
543     Vector<UChar> stringBuilder;
544     String separator(": ");
545
546     HTTPHeaderMap::const_iterator end = m_response.httpHeaderFields().end();
547     for (HTTPHeaderMap::const_iterator it = m_response.httpHeaderFields().begin(); it!= end; ++it) {
548         stringBuilder.append(it->first.characters(), it->first.length());
549         stringBuilder.append(separator.characters(), separator.length());
550         stringBuilder.append(it->second.characters(), it->second.length());
551         stringBuilder.append((UChar)'\n');
552     }
553
554     return String::adopt(stringBuilder);
555 }
556
557 String XMLHttpRequest::getResponseHeader(const String& name) const
558 {
559     return m_response.httpHeaderField(name);
560 }
561
562 String XMLHttpRequest::responseMIMEType() const
563 {
564     String mimeType = extractMIMETypeFromMediaType(m_mimeTypeOverride);
565     if (mimeType.isEmpty()) {
566         if (m_response.isHTTP())
567             mimeType = extractMIMETypeFromMediaType(getResponseHeader("Content-Type"));
568         else
569             mimeType = m_response.mimeType();
570     }
571     if (mimeType.isEmpty())
572         mimeType = "text/xml";
573     
574     return mimeType;
575 }
576
577 bool XMLHttpRequest::responseIsXML() const
578 {
579     return DOMImplementation::isXMLMIMEType(responseMIMEType());
580 }
581
582 int XMLHttpRequest::getStatus(ExceptionCode& ec) const
583 {
584     if (m_state == Uninitialized)
585         return 0;
586     
587     if (m_response.httpStatusCode() == 0) {
588         if (m_state != Receiving && m_state != Loaded)
589             // status MUST be available in these states, but we don't get any headers from non-HTTP requests
590             ec = INVALID_STATE_ERR;
591     }
592
593     return m_response.httpStatusCode();
594 }
595
596 String XMLHttpRequest::getStatusText(ExceptionCode& ec) const
597 {
598     if (m_state == Uninitialized)
599         return "";
600     
601     if (m_response.httpStatusCode() == 0) {
602         if (m_state != Receiving && m_state != Loaded)
603             // statusText MUST be available in these states, but we don't get any headers from non-HTTP requests
604             ec = INVALID_STATE_ERR;
605         return String();
606     }
607
608     // FIXME: should try to preserve status text in response
609     return "OK";
610 }
611
612 void XMLHttpRequest::processSyncLoadResults(const Vector<char>& data, const ResourceResponse& response)
613 {
614     if (!urlMatchesDocumentDomain(response.url())) {
615         abort();
616         return;
617     }
618
619     didReceiveResponse(0, response);
620     changeState(Sent);
621     if (m_aborted)
622         return;
623
624     const char* bytes = static_cast<const char*>(data.data());
625     int len = static_cast<int>(data.size());
626
627     didReceiveData(0, bytes, len);
628     if (m_aborted)
629         return;
630
631     didFinishLoading(0);
632 }
633
634 void XMLHttpRequest::didFail(SubresourceLoader* loader, const ResourceError&)
635 {
636     didFinishLoading(loader);
637 }
638
639 void XMLHttpRequest::didFinishLoading(SubresourceLoader* loader)
640 {
641     if (m_aborted)
642         return;
643         
644     ASSERT(loader == m_loader);
645
646     if (m_state < Sent)
647         changeState(Sent);
648
649     {
650         KJS::JSLock lock;
651         if (m_decoder)
652             m_responseText += m_decoder->flush();
653     }
654
655     bool hadLoader = m_loader;
656     m_loader = 0;
657
658     changeState(Loaded);
659     m_decoder = 0;
660
661     if (hadLoader)
662         dropProtection();
663 }
664
665 void XMLHttpRequest::willSendRequest(SubresourceLoader*, ResourceRequest& request, const ResourceResponse& redirectResponse)
666 {
667     if (!urlMatchesDocumentDomain(request.url()))
668         abort();
669 }
670
671 void XMLHttpRequest::didReceiveResponse(SubresourceLoader*, const ResourceResponse& response)
672 {
673     m_response = response;
674     m_encoding = extractCharsetFromMediaType(m_mimeTypeOverride);
675     if (m_encoding.isEmpty())
676         m_encoding = response.textEncodingName();
677
678 }
679
680 void XMLHttpRequest::didReceiveData(SubresourceLoader*, const char* data, int len)
681 {
682     if (m_state < Sent)
683         changeState(Sent);
684   
685     if (!m_decoder) {
686         if (!m_encoding.isEmpty())
687             m_decoder = new TextResourceDecoder("text/plain", m_encoding);
688         // allow TextResourceDecoder to look inside the m_response if it's XML or HTML
689         else if (responseIsXML())
690             m_decoder = new TextResourceDecoder("application/xml");
691         else if (responseMIMEType() == "text/html")
692             m_decoder = new TextResourceDecoder("text/html");
693         else
694             m_decoder = new TextResourceDecoder("text/plain", "UTF-8");
695     }
696     if (len == 0)
697         return;
698
699     if (len == -1)
700         len = strlen(data);
701
702     String decoded = m_decoder->decode(data, len);
703
704     {
705         KJS::JSLock lock;
706         m_responseText += decoded;
707     }
708
709     if (!m_aborted) {
710         if (m_state != Receiving)
711             changeState(Receiving);
712         else
713             // Firefox calls readyStateChanged every time it receives data, 4449442
714             callReadyStateChangeListener();
715     }
716 }
717
718 void XMLHttpRequest::cancelRequests(Document* m_doc)
719 {
720     RequestsSet* requests = requestsByDocument().get(m_doc);
721     if (!requests)
722         return;
723     RequestsSet copy = *requests;
724     RequestsSet::const_iterator end = copy.end();
725     for (RequestsSet::const_iterator it = copy.begin(); it != end; ++it)
726         (*it)->abort();
727 }
728
729 void XMLHttpRequest::detachRequests(Document* m_doc)
730 {
731     RequestsSet* requests = requestsByDocument().get(m_doc);
732     if (!requests)
733         return;
734     requestsByDocument().remove(m_doc);
735     RequestsSet::const_iterator end = requests->end();
736     for (RequestsSet::const_iterator it = requests->begin(); it != end; ++it) {
737         (*it)->m_doc = 0;
738         (*it)->abort();
739     }
740     delete requests;
741 }
742
743 } // end namespace