1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/*
* Copyright 2004 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_BASE_HTTPCLIENT_H__
#define WEBRTC_BASE_HTTPCLIENT_H__
#include "webrtc/base/common.h"
#include "webrtc/base/httpbase.h"
#include "webrtc/base/nethelpers.h"
#include "webrtc/base/proxyinfo.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/sigslot.h"
#include "webrtc/base/socketaddress.h"
#include "webrtc/base/socketpool.h"
namespace rtc {
//////////////////////////////////////////////////////////////////////
// Client-specific http utilities
//////////////////////////////////////////////////////////////////////
// Write cache-relevant response headers to output stream. If size is non-null,
// it contains the length of the output in bytes. output may be null if only
// the length is desired.
bool HttpWriteCacheHeaders(const HttpResponseData* response,
StreamInterface* output, size_t* size);
// Read cached headers from a stream, and them merge them into the response
// object using the specified combine operation.
bool HttpReadCacheHeaders(StreamInterface* input,
HttpResponseData* response,
HttpData::HeaderCombine combine);
//////////////////////////////////////////////////////////////////////
// HttpClient
// Implements an HTTP 1.1 client.
//////////////////////////////////////////////////////////////////////
class DiskCache;
class HttpClient;
class IPNetPool;
class SignalThread;
// What to do: Define STRICT_HTTP_ERROR=1 in your makefile. Use HttpError in
// your code (HttpErrorType should only be used for code that is shared
// with groups which have not yet migrated).
#if STRICT_HTTP_ERROR
typedef HttpError HttpErrorType;
#else // !STRICT_HTTP_ERROR
typedef int HttpErrorType;
#endif // !STRICT_HTTP_ERROR
class HttpClient : private IHttpNotify, public sigslot::has_slots<> {
public:
// If HttpRequestData and HttpResponseData objects are provided, they must
// be freed by the caller. Otherwise, an internal object is allocated.
HttpClient(const std::string& agent, StreamPool* pool,
HttpTransaction* transaction = NULL);
~HttpClient() override;
void set_pool(StreamPool* pool) { pool_ = pool; }
void set_agent(const std::string& agent) { agent_ = agent; }
const std::string& agent() const { return agent_; }
void set_proxy(const ProxyInfo& proxy) { proxy_ = proxy; }
const ProxyInfo& proxy() const { return proxy_; }
// Request retries occur when the connection closes before the beginning of
// an http response is received. In these cases, the http server may have
// timed out the keepalive connection before it received our request. Note
// that if a request document cannot be rewound, no retry is made. The
// default is 1.
void set_request_retries(size_t retries) { retries_ = retries; }
size_t request_retries() const { return retries_; }
enum RedirectAction { REDIRECT_DEFAULT, REDIRECT_ALWAYS, REDIRECT_NEVER };
void set_redirect_action(RedirectAction action) { redirect_action_ = action; }
RedirectAction redirect_action() const { return redirect_action_; }
enum UriForm { URI_DEFAULT, URI_ABSOLUTE, URI_RELATIVE };
void set_uri_form(UriForm form) { uri_form_ = form; }
UriForm uri_form() const { return uri_form_; }
void set_cache(DiskCache* cache) { ASSERT(!IsCacheActive()); cache_ = cache; }
bool cache_enabled() const { return (NULL != cache_); }
// reset clears the server, request, and response structures. It will also
// abort an active request.
void reset();
void set_server(const SocketAddress& address);
const SocketAddress& server() const { return server_; }
// Note: in order for HttpClient to retry a POST in response to
// an authentication challenge, a redirect response, or socket disconnection,
// the request document must support 'replaying' by calling Rewind() on it.
HttpTransaction* transaction() { return transaction_; }
const HttpTransaction* transaction() const { return transaction_; }
HttpRequestData& request() { return transaction_->request; }
const HttpRequestData& request() const { return transaction_->request; }
HttpResponseData& response() { return transaction_->response; }
const HttpResponseData& response() const { return transaction_->response; }
// convenience methods
void prepare_get(const std::string& url);
void prepare_post(const std::string& url, const std::string& content_type,
StreamInterface* request_doc);
// Convert HttpClient to a pull-based I/O model.
StreamInterface* GetDocumentStream();
// After you finish setting up your request, call start.
void start();
// Signalled when the header has finished downloading, before the document
// content is processed. You may change the response document in response
// to this signal. The second parameter indicates whether this is an
// intermediate (false) or final (true) header. An intermediate header is
// one that generates another request, such as a redirect or authentication
// challenge. The third parameter indicates the length of the response
// document, or else SIZE_UNKNOWN. Note: Do NOT abort the request in response
// to this signal.
sigslot::signal3<HttpClient*,bool,size_t> SignalHeaderAvailable;
// Signalled when the current request finishes. On success, err is 0.
sigslot::signal2<HttpClient*,HttpErrorType> SignalHttpClientComplete;
protected:
void connect();
void release();
bool ShouldRedirect(std::string* location) const;
bool BeginCacheFile();
HttpError WriteCacheHeaders(const std::string& id);
void CompleteCacheFile();
bool CheckCache();
HttpError ReadCacheHeaders(const std::string& id, bool override);
HttpError ReadCacheBody(const std::string& id);
bool PrepareValidate();
HttpError CompleteValidate();
HttpError OnHeaderAvailable(bool ignore_data, bool chunked, size_t data_size);
void StartDNSLookup();
void OnResolveResult(AsyncResolverInterface* resolver);
// IHttpNotify Interface
HttpError onHttpHeaderComplete(bool chunked, size_t& data_size) override;
void onHttpComplete(HttpMode mode, HttpError err) override;
void onHttpClosed(HttpError err) override;
private:
enum CacheState { CS_READY, CS_WRITING, CS_READING, CS_VALIDATING };
bool IsCacheActive() const { return (cache_state_ > CS_READY); }
std::string agent_;
StreamPool* pool_;
HttpBase base_;
SocketAddress server_;
ProxyInfo proxy_;
HttpTransaction* transaction_;
bool free_transaction_;
size_t retries_, attempt_, redirects_;
RedirectAction redirect_action_;
UriForm uri_form_;
scoped_ptr<HttpAuthContext> context_;
DiskCache* cache_;
CacheState cache_state_;
AsyncResolverInterface* resolver_;
};
//////////////////////////////////////////////////////////////////////
// HttpClientDefault - Default implementation of HttpClient
//////////////////////////////////////////////////////////////////////
class HttpClientDefault : public ReuseSocketPool, public HttpClient {
public:
HttpClientDefault(SocketFactory* factory, const std::string& agent,
HttpTransaction* transaction = NULL);
};
//////////////////////////////////////////////////////////////////////
} // namespace rtc
#endif // WEBRTC_BASE_HTTPCLIENT_H__
|
