1 /*
2 * Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include <time.h>
12
13 #include "webrtc/base/httpcommon-inl.h"
14
15 #include "webrtc/base/asyncsocket.h"
16 #include "webrtc/base/common.h"
17 #include "webrtc/base/diskcache.h"
18 #include "webrtc/base/httpclient.h"
19 #include "webrtc/base/logging.h"
20 #include "webrtc/base/pathutils.h"
21 #include "webrtc/base/scoped_ptr.h"
22 #include "webrtc/base/socketstream.h"
23 #include "webrtc/base/stringencode.h"
24 #include "webrtc/base/stringutils.h"
25 #include "webrtc/base/thread.h"
26
27 namespace rtc {
28
29 //////////////////////////////////////////////////////////////////////
30 // Helpers
31 //////////////////////////////////////////////////////////////////////
32
33 namespace {
34
35 const size_t kCacheHeader = 0;
36 const size_t kCacheBody = 1;
37
38 // Convert decimal string to integer
HttpStringToUInt(const std::string & str,size_t * val)39 bool HttpStringToUInt(const std::string& str, size_t* val) {
40 ASSERT(NULL != val);
41 char* eos = NULL;
42 *val = strtoul(str.c_str(), &eos, 10);
43 return (*eos == '\0');
44 }
45
HttpShouldCache(const HttpTransaction & t)46 bool HttpShouldCache(const HttpTransaction& t) {
47 bool verb_allows_cache = (t.request.verb == HV_GET)
48 || (t.request.verb == HV_HEAD);
49 bool is_range_response = t.response.hasHeader(HH_CONTENT_RANGE, NULL);
50 bool has_expires = t.response.hasHeader(HH_EXPIRES, NULL);
51 bool request_allows_cache =
52 has_expires || (std::string::npos != t.request.path.find('?'));
53 bool response_allows_cache =
54 has_expires || HttpCodeIsCacheable(t.response.scode);
55
56 bool may_cache = verb_allows_cache
57 && request_allows_cache
58 && response_allows_cache
59 && !is_range_response;
60
61 std::string value;
62 if (t.response.hasHeader(HH_CACHE_CONTROL, &value)) {
63 HttpAttributeList directives;
64 HttpParseAttributes(value.data(), value.size(), directives);
65 // Response Directives Summary:
66 // public - always cacheable
67 // private - do not cache in a shared cache
68 // no-cache - may cache, but must revalidate whether fresh or stale
69 // no-store - sensitive information, do not cache or store in any way
70 // max-age - supplants Expires for staleness
71 // s-maxage - use as max-age for shared caches, ignore otherwise
72 // must-revalidate - may cache, but must revalidate after stale
73 // proxy-revalidate - shared cache must revalidate
74 if (HttpHasAttribute(directives, "no-store", NULL)) {
75 may_cache = false;
76 } else if (HttpHasAttribute(directives, "public", NULL)) {
77 may_cache = true;
78 }
79 }
80 return may_cache;
81 }
82
83 enum HttpCacheState {
84 HCS_FRESH, // In cache, may use
85 HCS_STALE, // In cache, must revalidate
86 HCS_NONE // Not in cache
87 };
88
HttpGetCacheState(const HttpTransaction & t)89 HttpCacheState HttpGetCacheState(const HttpTransaction& t) {
90 // Temporaries
91 std::string s_temp;
92 time_t u_temp;
93
94 // Current time
95 time_t now = time(0);
96
97 HttpAttributeList cache_control;
98 if (t.response.hasHeader(HH_CACHE_CONTROL, &s_temp)) {
99 HttpParseAttributes(s_temp.data(), s_temp.size(), cache_control);
100 }
101
102 // Compute age of cache document
103 time_t date;
104 if (!t.response.hasHeader(HH_DATE, &s_temp)
105 || !HttpDateToSeconds(s_temp, &date))
106 return HCS_NONE;
107
108 // TODO: Timestamp when cache request sent and response received?
109 time_t request_time = date;
110 time_t response_time = date;
111
112 time_t apparent_age = 0;
113 if (response_time > date) {
114 apparent_age = response_time - date;
115 }
116
117 time_t corrected_received_age = apparent_age;
118 size_t i_temp;
119 if (t.response.hasHeader(HH_AGE, &s_temp)
120 && HttpStringToUInt(s_temp, (&i_temp))) {
121 u_temp = static_cast<time_t>(i_temp);
122 corrected_received_age = stdmax(apparent_age, u_temp);
123 }
124
125 time_t response_delay = response_time - request_time;
126 time_t corrected_initial_age = corrected_received_age + response_delay;
127 time_t resident_time = now - response_time;
128 time_t current_age = corrected_initial_age + resident_time;
129
130 // Compute lifetime of document
131 time_t lifetime;
132 if (HttpHasAttribute(cache_control, "max-age", &s_temp)) {
133 lifetime = atoi(s_temp.c_str());
134 } else if (t.response.hasHeader(HH_EXPIRES, &s_temp)
135 && HttpDateToSeconds(s_temp, &u_temp)) {
136 lifetime = u_temp - date;
137 } else if (t.response.hasHeader(HH_LAST_MODIFIED, &s_temp)
138 && HttpDateToSeconds(s_temp, &u_temp)) {
139 // TODO: Issue warning 113 if age > 24 hours
140 lifetime = static_cast<size_t>(now - u_temp) / 10;
141 } else {
142 return HCS_STALE;
143 }
144
145 return (lifetime > current_age) ? HCS_FRESH : HCS_STALE;
146 }
147
148 enum HttpValidatorStrength {
149 HVS_NONE,
150 HVS_WEAK,
151 HVS_STRONG
152 };
153
154 HttpValidatorStrength
HttpRequestValidatorLevel(const HttpRequestData & request)155 HttpRequestValidatorLevel(const HttpRequestData& request) {
156 if (HV_GET != request.verb)
157 return HVS_STRONG;
158 return request.hasHeader(HH_RANGE, NULL) ? HVS_STRONG : HVS_WEAK;
159 }
160
161 HttpValidatorStrength
HttpResponseValidatorLevel(const HttpResponseData & response)162 HttpResponseValidatorLevel(const HttpResponseData& response) {
163 std::string value;
164 if (response.hasHeader(HH_ETAG, &value)) {
165 bool is_weak = (strnicmp(value.c_str(), "W/", 2) == 0);
166 return is_weak ? HVS_WEAK : HVS_STRONG;
167 }
168 if (response.hasHeader(HH_LAST_MODIFIED, &value)) {
169 time_t last_modified, date;
170 if (HttpDateToSeconds(value, &last_modified)
171 && response.hasHeader(HH_DATE, &value)
172 && HttpDateToSeconds(value, &date)
173 && (last_modified + 60 < date)) {
174 return HVS_STRONG;
175 }
176 return HVS_WEAK;
177 }
178 return HVS_NONE;
179 }
180
GetCacheID(const HttpRequestData & request)181 std::string GetCacheID(const HttpRequestData& request) {
182 std::string id, url;
183 id.append(ToString(request.verb));
184 id.append("_");
185 request.getAbsoluteUri(&url);
186 id.append(url);
187 return id;
188 }
189
190 } // anonymous namespace
191
192 //////////////////////////////////////////////////////////////////////
193 // Public Helpers
194 //////////////////////////////////////////////////////////////////////
195
HttpWriteCacheHeaders(const HttpResponseData * response,StreamInterface * output,size_t * size)196 bool HttpWriteCacheHeaders(const HttpResponseData* response,
197 StreamInterface* output, size_t* size) {
198 size_t length = 0;
199 // Write all unknown and end-to-end headers to a cache file
200 for (HttpData::const_iterator it = response->begin();
201 it != response->end(); ++it) {
202 HttpHeader header;
203 if (FromString(header, it->first) && !HttpHeaderIsEndToEnd(header))
204 continue;
205 length += it->first.length() + 2 + it->second.length() + 2;
206 if (!output)
207 continue;
208 std::string formatted_header(it->first);
209 formatted_header.append(": ");
210 formatted_header.append(it->second);
211 formatted_header.append("\r\n");
212 StreamResult result = output->WriteAll(formatted_header.data(),
213 formatted_header.length(),
214 NULL, NULL);
215 if (SR_SUCCESS != result) {
216 return false;
217 }
218 }
219 if (output && (SR_SUCCESS != output->WriteAll("\r\n", 2, NULL, NULL))) {
220 return false;
221 }
222 length += 2;
223 if (size)
224 *size = length;
225 return true;
226 }
227
HttpReadCacheHeaders(StreamInterface * input,HttpResponseData * response,HttpData::HeaderCombine combine)228 bool HttpReadCacheHeaders(StreamInterface* input, HttpResponseData* response,
229 HttpData::HeaderCombine combine) {
230 while (true) {
231 std::string formatted_header;
232 StreamResult result = input->ReadLine(&formatted_header);
233 if ((SR_EOS == result) || (1 == formatted_header.size())) {
234 break;
235 }
236 if (SR_SUCCESS != result) {
237 return false;
238 }
239 size_t end_of_name = formatted_header.find(':');
240 if (std::string::npos == end_of_name) {
241 LOG_F(LS_WARNING) << "Malformed cache header";
242 continue;
243 }
244 size_t start_of_value = end_of_name + 1;
245 size_t end_of_value = formatted_header.length();
246 while ((start_of_value < end_of_value)
247 && isspace(formatted_header[start_of_value]))
248 ++start_of_value;
249 while ((start_of_value < end_of_value)
250 && isspace(formatted_header[end_of_value-1]))
251 --end_of_value;
252 size_t value_length = end_of_value - start_of_value;
253
254 std::string name(formatted_header.substr(0, end_of_name));
255 std::string value(formatted_header.substr(start_of_value, value_length));
256 response->changeHeader(name, value, combine);
257 }
258 return true;
259 }
260
261 //////////////////////////////////////////////////////////////////////
262 // HttpClient
263 //////////////////////////////////////////////////////////////////////
264
265 const size_t kDefaultRetries = 1;
266 const size_t kMaxRedirects = 5;
267
HttpClient(const std::string & agent,StreamPool * pool,HttpTransaction * transaction)268 HttpClient::HttpClient(const std::string& agent, StreamPool* pool,
269 HttpTransaction* transaction)
270 : agent_(agent), pool_(pool),
271 transaction_(transaction), free_transaction_(false),
272 retries_(kDefaultRetries), attempt_(0), redirects_(0),
273 redirect_action_(REDIRECT_DEFAULT),
274 uri_form_(URI_DEFAULT), cache_(NULL), cache_state_(CS_READY),
275 resolver_(NULL) {
276 base_.notify(this);
277 if (NULL == transaction_) {
278 free_transaction_ = true;
279 transaction_ = new HttpTransaction;
280 }
281 }
282
~HttpClient()283 HttpClient::~HttpClient() {
284 base_.notify(NULL);
285 base_.abort(HE_SHUTDOWN);
286 if (resolver_) {
287 resolver_->Destroy(false);
288 }
289 release();
290 if (free_transaction_)
291 delete transaction_;
292 }
293
reset()294 void HttpClient::reset() {
295 server_.Clear();
296 request().clear(true);
297 response().clear(true);
298 context_.reset();
299 redirects_ = 0;
300 base_.abort(HE_OPERATION_CANCELLED);
301 }
302
OnResolveResult(AsyncResolverInterface * resolver)303 void HttpClient::OnResolveResult(AsyncResolverInterface* resolver) {
304 if (resolver != resolver_) {
305 return;
306 }
307 int error = resolver_->GetError();
308 server_ = resolver_->address();
309 resolver_->Destroy(false);
310 resolver_ = NULL;
311 if (error != 0) {
312 LOG(LS_ERROR) << "Error " << error << " resolving name: "
313 << server_;
314 onHttpComplete(HM_CONNECT, HE_CONNECT_FAILED);
315 } else {
316 connect();
317 }
318 }
319
StartDNSLookup()320 void HttpClient::StartDNSLookup() {
321 resolver_ = new AsyncResolver();
322 resolver_->SignalDone.connect(this, &HttpClient::OnResolveResult);
323 resolver_->Start(server_);
324 }
325
set_server(const SocketAddress & address)326 void HttpClient::set_server(const SocketAddress& address) {
327 server_ = address;
328 // Setting 'Host' here allows it to be overridden before starting the request,
329 // if necessary.
330 request().setHeader(HH_HOST, HttpAddress(server_, false), true);
331 }
332
GetDocumentStream()333 StreamInterface* HttpClient::GetDocumentStream() {
334 return base_.GetDocumentStream();
335 }
336
start()337 void HttpClient::start() {
338 if (base_.mode() != HM_NONE) {
339 // call reset() to abort an in-progress request
340 ASSERT(false);
341 return;
342 }
343
344 ASSERT(!IsCacheActive());
345
346 if (request().hasHeader(HH_TRANSFER_ENCODING, NULL)) {
347 // Exact size must be known on the client. Instead of using chunked
348 // encoding, wrap data with auto-caching file or memory stream.
349 ASSERT(false);
350 return;
351 }
352
353 attempt_ = 0;
354
355 // If no content has been specified, using length of 0.
356 request().setHeader(HH_CONTENT_LENGTH, "0", false);
357
358 if (!agent_.empty()) {
359 request().setHeader(HH_USER_AGENT, agent_, false);
360 }
361
362 UriForm uri_form = uri_form_;
363 if (PROXY_HTTPS == proxy_.type) {
364 // Proxies require absolute form
365 uri_form = URI_ABSOLUTE;
366 request().version = HVER_1_0;
367 request().setHeader(HH_PROXY_CONNECTION, "Keep-Alive", false);
368 } else {
369 request().setHeader(HH_CONNECTION, "Keep-Alive", false);
370 }
371
372 if (URI_ABSOLUTE == uri_form) {
373 // Convert to absolute uri form
374 std::string url;
375 if (request().getAbsoluteUri(&url)) {
376 request().path = url;
377 } else {
378 LOG(LS_WARNING) << "Couldn't obtain absolute uri";
379 }
380 } else if (URI_RELATIVE == uri_form) {
381 // Convert to relative uri form
382 std::string host, path;
383 if (request().getRelativeUri(&host, &path)) {
384 request().setHeader(HH_HOST, host);
385 request().path = path;
386 } else {
387 LOG(LS_WARNING) << "Couldn't obtain relative uri";
388 }
389 }
390
391 if ((NULL != cache_) && CheckCache()) {
392 return;
393 }
394
395 connect();
396 }
397
connect()398 void HttpClient::connect() {
399 int stream_err;
400 if (server_.IsUnresolvedIP()) {
401 StartDNSLookup();
402 return;
403 }
404 StreamInterface* stream = pool_->RequestConnectedStream(server_, &stream_err);
405 if (stream == NULL) {
406 ASSERT(0 != stream_err);
407 LOG(LS_ERROR) << "RequestConnectedStream error: " << stream_err;
408 onHttpComplete(HM_CONNECT, HE_CONNECT_FAILED);
409 } else {
410 base_.attach(stream);
411 if (stream->GetState() == SS_OPEN) {
412 base_.send(&transaction_->request);
413 }
414 }
415 }
416
prepare_get(const std::string & url)417 void HttpClient::prepare_get(const std::string& url) {
418 reset();
419 Url<char> purl(url);
420 set_server(SocketAddress(purl.host(), purl.port()));
421 request().verb = HV_GET;
422 request().path = purl.full_path();
423 }
424
prepare_post(const std::string & url,const std::string & content_type,StreamInterface * request_doc)425 void HttpClient::prepare_post(const std::string& url,
426 const std::string& content_type,
427 StreamInterface* request_doc) {
428 reset();
429 Url<char> purl(url);
430 set_server(SocketAddress(purl.host(), purl.port()));
431 request().verb = HV_POST;
432 request().path = purl.full_path();
433 request().setContent(content_type, request_doc);
434 }
435
release()436 void HttpClient::release() {
437 if (StreamInterface* stream = base_.detach()) {
438 pool_->ReturnConnectedStream(stream);
439 }
440 }
441
ShouldRedirect(std::string * location) const442 bool HttpClient::ShouldRedirect(std::string* location) const {
443 // TODO: Unittest redirection.
444 if ((REDIRECT_NEVER == redirect_action_)
445 || !HttpCodeIsRedirection(response().scode)
446 || !response().hasHeader(HH_LOCATION, location)
447 || (redirects_ >= kMaxRedirects))
448 return false;
449 return (REDIRECT_ALWAYS == redirect_action_)
450 || (HC_SEE_OTHER == response().scode)
451 || (HV_HEAD == request().verb)
452 || (HV_GET == request().verb);
453 }
454
BeginCacheFile()455 bool HttpClient::BeginCacheFile() {
456 ASSERT(NULL != cache_);
457 ASSERT(CS_READY == cache_state_);
458
459 std::string id = GetCacheID(request());
460 CacheLock lock(cache_, id, true);
461 if (!lock.IsLocked()) {
462 LOG_F(LS_WARNING) << "Couldn't lock cache";
463 return false;
464 }
465
466 if (HE_NONE != WriteCacheHeaders(id)) {
467 return false;
468 }
469
470 scoped_ptr<StreamInterface> stream(cache_->WriteResource(id, kCacheBody));
471 if (!stream) {
472 LOG_F(LS_ERROR) << "Couldn't open body cache";
473 return false;
474 }
475 lock.Commit();
476
477 // Let's secretly replace the response document with Folgers Crystals,
478 // er, StreamTap, so that we can mirror the data to our cache.
479 StreamInterface* output = response().document.release();
480 if (!output) {
481 output = new NullStream;
482 }
483 StreamTap* tap = new StreamTap(output, stream.release());
484 response().document.reset(tap);
485 return true;
486 }
487
WriteCacheHeaders(const std::string & id)488 HttpError HttpClient::WriteCacheHeaders(const std::string& id) {
489 scoped_ptr<StreamInterface> stream(cache_->WriteResource(id, kCacheHeader));
490 if (!stream) {
491 LOG_F(LS_ERROR) << "Couldn't open header cache";
492 return HE_CACHE;
493 }
494
495 if (!HttpWriteCacheHeaders(&transaction_->response, stream.get(), NULL)) {
496 LOG_F(LS_ERROR) << "Couldn't write header cache";
497 return HE_CACHE;
498 }
499
500 return HE_NONE;
501 }
502
CompleteCacheFile()503 void HttpClient::CompleteCacheFile() {
504 // Restore previous response document
505 StreamTap* tap = static_cast<StreamTap*>(response().document.release());
506 response().document.reset(tap->Detach());
507
508 int error;
509 StreamResult result = tap->GetTapResult(&error);
510
511 // Delete the tap and cache stream (which completes cache unlock)
512 delete tap;
513
514 if (SR_SUCCESS != result) {
515 LOG(LS_ERROR) << "Cache file error: " << error;
516 cache_->DeleteResource(GetCacheID(request()));
517 }
518 }
519
CheckCache()520 bool HttpClient::CheckCache() {
521 ASSERT(NULL != cache_);
522 ASSERT(CS_READY == cache_state_);
523
524 std::string id = GetCacheID(request());
525 if (!cache_->HasResource(id)) {
526 // No cache file available
527 return false;
528 }
529
530 HttpError error = ReadCacheHeaders(id, true);
531
532 if (HE_NONE == error) {
533 switch (HttpGetCacheState(*transaction_)) {
534 case HCS_FRESH:
535 // Cache content is good, read from cache
536 break;
537 case HCS_STALE:
538 // Cache content may be acceptable. Issue a validation request.
539 if (PrepareValidate()) {
540 return false;
541 }
542 // Couldn't validate, fall through.
543 case HCS_NONE:
544 // Cache content is not useable. Issue a regular request.
545 response().clear(false);
546 return false;
547 }
548 }
549
550 if (HE_NONE == error) {
551 error = ReadCacheBody(id);
552 cache_state_ = CS_READY;
553 }
554
555 if (HE_CACHE == error) {
556 LOG_F(LS_WARNING) << "Cache failure, continuing with normal request";
557 response().clear(false);
558 return false;
559 }
560
561 SignalHttpClientComplete(this, error);
562 return true;
563 }
564
ReadCacheHeaders(const std::string & id,bool override)565 HttpError HttpClient::ReadCacheHeaders(const std::string& id, bool override) {
566 scoped_ptr<StreamInterface> stream(cache_->ReadResource(id, kCacheHeader));
567 if (!stream) {
568 return HE_CACHE;
569 }
570
571 HttpData::HeaderCombine combine =
572 override ? HttpData::HC_REPLACE : HttpData::HC_AUTO;
573
574 if (!HttpReadCacheHeaders(stream.get(), &transaction_->response, combine)) {
575 LOG_F(LS_ERROR) << "Error reading cache headers";
576 return HE_CACHE;
577 }
578
579 response().scode = HC_OK;
580 return HE_NONE;
581 }
582
ReadCacheBody(const std::string & id)583 HttpError HttpClient::ReadCacheBody(const std::string& id) {
584 cache_state_ = CS_READING;
585
586 HttpError error = HE_NONE;
587
588 size_t data_size;
589 scoped_ptr<StreamInterface> stream(cache_->ReadResource(id, kCacheBody));
590 if (!stream || !stream->GetAvailable(&data_size)) {
591 LOG_F(LS_ERROR) << "Unavailable cache body";
592 error = HE_CACHE;
593 } else {
594 error = OnHeaderAvailable(false, false, data_size);
595 }
596
597 if ((HE_NONE == error)
598 && (HV_HEAD != request().verb)
599 && response().document) {
600 // Allocate on heap to not explode the stack.
601 const int array_size = 1024 * 64;
602 scoped_ptr<char[]> buffer(new char[array_size]);
603 StreamResult result = Flow(stream.get(), buffer.get(), array_size,
604 response().document.get());
605 if (SR_SUCCESS != result) {
606 error = HE_STREAM;
607 }
608 }
609
610 return error;
611 }
612
PrepareValidate()613 bool HttpClient::PrepareValidate() {
614 ASSERT(CS_READY == cache_state_);
615 // At this point, request() contains the pending request, and response()
616 // contains the cached response headers. Reformat the request to validate
617 // the cached content.
618 HttpValidatorStrength vs_required = HttpRequestValidatorLevel(request());
619 HttpValidatorStrength vs_available = HttpResponseValidatorLevel(response());
620 if (vs_available < vs_required) {
621 return false;
622 }
623 std::string value;
624 if (response().hasHeader(HH_ETAG, &value)) {
625 request().addHeader(HH_IF_NONE_MATCH, value);
626 }
627 if (response().hasHeader(HH_LAST_MODIFIED, &value)) {
628 request().addHeader(HH_IF_MODIFIED_SINCE, value);
629 }
630 response().clear(false);
631 cache_state_ = CS_VALIDATING;
632 return true;
633 }
634
CompleteValidate()635 HttpError HttpClient::CompleteValidate() {
636 ASSERT(CS_VALIDATING == cache_state_);
637
638 std::string id = GetCacheID(request());
639
640 // Merge cached headers with new headers
641 HttpError error = ReadCacheHeaders(id, false);
642 if (HE_NONE != error) {
643 // Rewrite merged headers to cache
644 CacheLock lock(cache_, id);
645 error = WriteCacheHeaders(id);
646 }
647 if (HE_NONE != error) {
648 error = ReadCacheBody(id);
649 }
650 return error;
651 }
652
OnHeaderAvailable(bool ignore_data,bool chunked,size_t data_size)653 HttpError HttpClient::OnHeaderAvailable(bool ignore_data, bool chunked,
654 size_t data_size) {
655 // If we are ignoring the data, this is an intermediate header.
656 // TODO: don't signal intermediate headers. Instead, do all header-dependent
657 // processing now, and either set up the next request, or fail outright.
658 // TODO: by default, only write response documents with a success code.
659 SignalHeaderAvailable(this, !ignore_data, ignore_data ? 0 : data_size);
660 if (!ignore_data && !chunked && (data_size != SIZE_UNKNOWN)
661 && response().document) {
662 // Attempt to pre-allocate space for the downloaded data.
663 if (!response().document->ReserveSize(data_size)) {
664 return HE_OVERFLOW;
665 }
666 }
667 return HE_NONE;
668 }
669
670 //
671 // HttpBase Implementation
672 //
673
onHttpHeaderComplete(bool chunked,size_t & data_size)674 HttpError HttpClient::onHttpHeaderComplete(bool chunked, size_t& data_size) {
675 if (CS_VALIDATING == cache_state_) {
676 if (HC_NOT_MODIFIED == response().scode) {
677 return CompleteValidate();
678 }
679 // Should we remove conditional headers from request?
680 cache_state_ = CS_READY;
681 cache_->DeleteResource(GetCacheID(request()));
682 // Continue processing response as normal
683 }
684
685 ASSERT(!IsCacheActive());
686 if ((request().verb == HV_HEAD) || !HttpCodeHasBody(response().scode)) {
687 // HEAD requests and certain response codes contain no body
688 data_size = 0;
689 }
690 if (ShouldRedirect(NULL)
691 || ((HC_PROXY_AUTHENTICATION_REQUIRED == response().scode)
692 && (PROXY_HTTPS == proxy_.type))) {
693 // We're going to issue another request, so ignore the incoming data.
694 base_.set_ignore_data(true);
695 }
696
697 HttpError error = OnHeaderAvailable(base_.ignore_data(), chunked, data_size);
698 if (HE_NONE != error) {
699 return error;
700 }
701
702 if ((NULL != cache_)
703 && !base_.ignore_data()
704 && HttpShouldCache(*transaction_)) {
705 if (BeginCacheFile()) {
706 cache_state_ = CS_WRITING;
707 }
708 }
709 return HE_NONE;
710 }
711
onHttpComplete(HttpMode mode,HttpError err)712 void HttpClient::onHttpComplete(HttpMode mode, HttpError err) {
713 if (((HE_DISCONNECTED == err) || (HE_CONNECT_FAILED == err)
714 || (HE_SOCKET_ERROR == err))
715 && (HC_INTERNAL_SERVER_ERROR == response().scode)
716 && (attempt_ < retries_)) {
717 // If the response code has not changed from the default, then we haven't
718 // received anything meaningful from the server, so we are eligible for a
719 // retry.
720 ++attempt_;
721 if (request().document && !request().document->Rewind()) {
722 // Unable to replay the request document.
723 err = HE_STREAM;
724 } else {
725 release();
726 connect();
727 return;
728 }
729 } else if (err != HE_NONE) {
730 // fall through
731 } else if (mode == HM_CONNECT) {
732 base_.send(&transaction_->request);
733 return;
734 } else if ((mode == HM_SEND) || HttpCodeIsInformational(response().scode)) {
735 // If you're interested in informational headers, catch
736 // SignalHeaderAvailable.
737 base_.recv(&transaction_->response);
738 return;
739 } else {
740 if (!HttpShouldKeepAlive(response())) {
741 LOG(LS_VERBOSE) << "HttpClient: closing socket";
742 base_.stream()->Close();
743 }
744 std::string location;
745 if (ShouldRedirect(&location)) {
746 Url<char> purl(location);
747 set_server(SocketAddress(purl.host(), purl.port()));
748 request().path = purl.full_path();
749 if (response().scode == HC_SEE_OTHER) {
750 request().verb = HV_GET;
751 request().clearHeader(HH_CONTENT_TYPE);
752 request().clearHeader(HH_CONTENT_LENGTH);
753 request().document.reset();
754 } else if (request().document && !request().document->Rewind()) {
755 // Unable to replay the request document.
756 ASSERT(REDIRECT_ALWAYS == redirect_action_);
757 err = HE_STREAM;
758 }
759 if (err == HE_NONE) {
760 ++redirects_;
761 context_.reset();
762 response().clear(false);
763 release();
764 start();
765 return;
766 }
767 } else if ((HC_PROXY_AUTHENTICATION_REQUIRED == response().scode)
768 && (PROXY_HTTPS == proxy_.type)) {
769 std::string authorization, auth_method;
770 HttpData::const_iterator begin = response().begin(HH_PROXY_AUTHENTICATE);
771 HttpData::const_iterator end = response().end(HH_PROXY_AUTHENTICATE);
772 for (HttpData::const_iterator it = begin; it != end; ++it) {
773 HttpAuthContext *context = context_.get();
774 HttpAuthResult res = HttpAuthenticate(
775 it->second.data(), it->second.size(),
776 proxy_.address,
777 ToString(request().verb), request().path,
778 proxy_.username, proxy_.password,
779 context, authorization, auth_method);
780 context_.reset(context);
781 if (res == HAR_RESPONSE) {
782 request().setHeader(HH_PROXY_AUTHORIZATION, authorization);
783 if (request().document && !request().document->Rewind()) {
784 err = HE_STREAM;
785 } else {
786 // Explicitly do not reset the HttpAuthContext
787 response().clear(false);
788 // TODO: Reuse socket when authenticating?
789 release();
790 start();
791 return;
792 }
793 } else if (res == HAR_IGNORE) {
794 LOG(INFO) << "Ignoring Proxy-Authenticate: " << auth_method;
795 continue;
796 } else {
797 break;
798 }
799 }
800 }
801 }
802 if (CS_WRITING == cache_state_) {
803 CompleteCacheFile();
804 cache_state_ = CS_READY;
805 } else if (CS_READING == cache_state_) {
806 cache_state_ = CS_READY;
807 }
808 release();
809 SignalHttpClientComplete(this, err);
810 }
811
onHttpClosed(HttpError err)812 void HttpClient::onHttpClosed(HttpError err) {
813 // This shouldn't occur, since we return the stream to the pool upon command
814 // completion.
815 ASSERT(false);
816 }
817
818 //////////////////////////////////////////////////////////////////////
819 // HttpClientDefault
820 //////////////////////////////////////////////////////////////////////
821
HttpClientDefault(SocketFactory * factory,const std::string & agent,HttpTransaction * transaction)822 HttpClientDefault::HttpClientDefault(SocketFactory* factory,
823 const std::string& agent,
824 HttpTransaction* transaction)
825 : ReuseSocketPool(factory ? factory : Thread::Current()->socketserver()),
826 HttpClient(agent, NULL, transaction) {
827 set_pool(this);
828 }
829
830 //////////////////////////////////////////////////////////////////////
831
832 } // namespace rtc
833