2011-04-19 Vsevolod Vlasov <vsevik@chromium.org>
[WebKit.git] / Source / WebCore / platform / network / curl / ResourceHandleCurl.cpp
1 /*
2  * Copyright (C) 2004, 2006 Apple Computer, Inc.  All rights reserved.
3  * Copyright (C) 2005, 2006 Michael Emmel mike.emmel@gmail.com
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27
28 #include "config.h"
29 #include "ResourceHandle.h"
30
31 #include "CachedResourceLoader.h"
32 #include "NotImplemented.h"
33 #include "ResourceHandleInternal.h"
34 #include "ResourceHandleManager.h"
35 #include "SharedBuffer.h"
36
37 #if PLATFORM(WIN) && USE(CF)
38 #include <wtf/PassRefPtr.h>
39 #include <wtf/RetainPtr.h>
40 #endif
41
42 namespace WebCore {
43
44 class WebCoreSynchronousLoader : public ResourceHandleClient {
45 public:
46     WebCoreSynchronousLoader();
47
48     virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);
49     virtual void didReceiveData(ResourceHandle*, const char*, int, int encodedDataLength);
50     virtual void didFinishLoading(ResourceHandle*, double /*finishTime*/);
51     virtual void didFail(ResourceHandle*, const ResourceError&);
52
53     ResourceResponse resourceResponse() const { return m_response; }
54     ResourceError resourceError() const { return m_error; }
55     Vector<char> data() const { return m_data; }
56
57 private:
58     ResourceResponse m_response;
59     ResourceError m_error;
60     Vector<char> m_data;
61 };
62
63 WebCoreSynchronousLoader::WebCoreSynchronousLoader()
64 {
65 }
66
67 void WebCoreSynchronousLoader::didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
68 {
69     m_response = response;
70 }
71
72 void WebCoreSynchronousLoader::didReceiveData(ResourceHandle*, const char* data, int length, int)
73 {
74     m_data.append(data, length);
75 }
76
77 void WebCoreSynchronousLoader::didFinishLoading(ResourceHandle*, double)
78 {
79 }
80
81 void WebCoreSynchronousLoader::didFail(ResourceHandle*, const ResourceError& error)
82 {
83     m_error = error;
84 }
85
86 ResourceHandleInternal::~ResourceHandleInternal()
87 {
88     fastFree(m_url);
89     if (m_customHeaders)
90         curl_slist_free_all(m_customHeaders);
91 }
92
93 ResourceHandle::~ResourceHandle()
94 {
95     cancel();
96 }
97
98 bool ResourceHandle::start(NetworkingContext* context)
99 {
100     // The frame could be null if the ResourceHandle is not associated to any
101     // Frame, e.g. if we are downloading a file.
102     // If the frame is not null but the page is null this must be an attempted
103     // load from an unload handler, so let's just block it.
104     // If both the frame and the page are not null the context is valid.
105     if (context && !context->isValid())
106         return false;
107
108     ResourceHandleManager::sharedInstance()->add(this);
109     return true;
110 }
111
112 void ResourceHandle::cancel()
113 {
114     ResourceHandleManager::sharedInstance()->cancel(this);
115 }
116
117 PassRefPtr<SharedBuffer> ResourceHandle::bufferedData()
118 {
119     return 0;
120 }
121
122 bool ResourceHandle::supportsBufferedData()
123 {
124     return false;
125 }
126
127 #if PLATFORM(WIN) && USE(CF)
128 static HashSet<String>& allowsAnyHTTPSCertificateHosts()
129 {
130     static HashSet<String> hosts;
131
132     return hosts;
133 }
134
135 void ResourceHandle::setHostAllowsAnyHTTPSCertificate(const String& host)
136 {
137     allowsAnyHTTPSCertificateHosts().add(host.lower());
138 }
139 #endif
140
141 #if PLATFORM(WIN) && USE(CF)
142 // FIXME:  The CFDataRef will need to be something else when
143 // building without 
144 static HashMap<String, RetainPtr<CFDataRef> >& clientCerts()
145 {
146     static HashMap<String, RetainPtr<CFDataRef> > certs;
147     return certs;
148 }
149
150 void ResourceHandle::setClientCertificate(const String& host, CFDataRef cert)
151 {
152     clientCerts().set(host.lower(), cert);
153 }
154 #endif
155
156 void ResourceHandle::platformSetDefersLoading(bool defers)
157 {
158 #if LIBCURL_VERSION_NUM > 0x071200
159     if (!d->m_handle)
160         return;
161
162     if (defers) {
163         CURLcode error = curl_easy_pause(d->m_handle, CURLPAUSE_ALL);
164         // If we could not defer the handle, so don't do it.
165         if (error != CURLE_OK)
166             return;
167     } else {
168         CURLcode error = curl_easy_pause(d->m_handle, CURLPAUSE_CONT);
169         if (error != CURLE_OK)
170             // Restarting the handle has failed so just cancel it.
171             cancel();
172     }
173 #else
174     LOG_ERROR("Deferred loading is implemented if libcURL version is above 7.18.0");
175 #endif
176 }
177
178 bool ResourceHandle::willLoadFromCache(ResourceRequest&, Frame*)
179 {
180     notImplemented();
181     return false;
182 }
183
184 bool ResourceHandle::loadsBlocked()
185 {
186     notImplemented();
187     return false;
188 }
189
190 void ResourceHandle::loadResourceSynchronously(NetworkingContext*, const ResourceRequest& request, StoredCredentials storedCredentials, ResourceError& error, ResourceResponse& response, Vector<char>& data)
191 {
192     WebCoreSynchronousLoader syncLoader;
193     RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, &syncLoader, true, false));
194
195     ResourceHandleManager* manager = ResourceHandleManager::sharedInstance();
196
197     manager->dispatchSynchronousJob(handle.get());
198
199     error = syncLoader.resourceError();
200     data = syncLoader.data();
201     response = syncLoader.resourceResponse();
202 }
203
204 //stubs needed for windows version
205 void ResourceHandle::didReceiveAuthenticationChallenge(const AuthenticationChallenge&) 
206 {
207     notImplemented();
208 }
209
210 void ResourceHandle::receivedCredential(const AuthenticationChallenge&, const Credential&) 
211 {
212     notImplemented();
213 }
214
215 void ResourceHandle::receivedRequestToContinueWithoutCredential(const AuthenticationChallenge&) 
216 {
217     notImplemented();
218 }
219
220 void ResourceHandle::receivedCancellation(const AuthenticationChallenge&)
221 {
222     notImplemented();
223 }
224
225 } // namespace WebCore