1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "google_apis/gcm/engine/registration_request.h"
6
7 #include "base/bind.h"
8 #include "base/message_loop/message_loop.h"
9 #include "base/metrics/histogram.h"
10 #include "base/strings/string_number_conversions.h"
11 #include "base/values.h"
12 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
13 #include "net/base/escape.h"
14 #include "net/base/load_flags.h"
15 #include "net/http/http_request_headers.h"
16 #include "net/http/http_status_code.h"
17 #include "net/url_request/url_fetcher.h"
18 #include "net/url_request/url_request_context_getter.h"
19 #include "net/url_request/url_request_status.h"
20 #include "url/gurl.h"
21
22 namespace gcm {
23
24 namespace {
25
26 const char kRegistrationRequestContentType[] =
27 "application/x-www-form-urlencoded";
28
29 // Request constants.
30 const char kAppIdKey[] = "app";
31 const char kDeviceIdKey[] = "device";
32 const char kLoginHeader[] = "AidLogin";
33 const char kSenderKey[] = "sender";
34
35 // Request validation constants.
36 const size_t kMaxSenders = 100;
37
38 // Response constants.
39 const char kErrorPrefix[] = "Error=";
40 const char kTokenPrefix[] = "token=";
41 const char kDeviceRegistrationError[] = "PHONE_REGISTRATION_ERROR";
42 const char kAuthenticationFailed[] = "AUTHENTICATION_FAILED";
43 const char kInvalidSender[] = "INVALID_SENDER";
44 const char kInvalidParameters[] = "INVALID_PARAMETERS";
45
BuildFormEncoding(const std::string & key,const std::string & value,std::string * out)46 void BuildFormEncoding(const std::string& key,
47 const std::string& value,
48 std::string* out) {
49 if (!out->empty())
50 out->append("&");
51 out->append(key + "=" + net::EscapeUrlEncodedData(value, true));
52 }
53
54 // Gets correct status from the error message.
GetStatusFromError(const std::string & error)55 RegistrationRequest::Status GetStatusFromError(const std::string& error) {
56 // TODO(fgorski): Improve error parsing in case there is nore then just an
57 // Error=ERROR_STRING in response.
58 if (error.find(kDeviceRegistrationError) != std::string::npos)
59 return RegistrationRequest::DEVICE_REGISTRATION_ERROR;
60 if (error.find(kAuthenticationFailed) != std::string::npos)
61 return RegistrationRequest::AUTHENTICATION_FAILED;
62 if (error.find(kInvalidSender) != std::string::npos)
63 return RegistrationRequest::INVALID_SENDER;
64 if (error.find(kInvalidParameters) != std::string::npos)
65 return RegistrationRequest::INVALID_PARAMETERS;
66 return RegistrationRequest::UNKNOWN_ERROR;
67 }
68
69 // Indicates whether a retry attempt should be made based on the status of the
70 // last request.
ShouldRetryWithStatus(RegistrationRequest::Status status)71 bool ShouldRetryWithStatus(RegistrationRequest::Status status) {
72 return status == RegistrationRequest::UNKNOWN_ERROR ||
73 status == RegistrationRequest::AUTHENTICATION_FAILED ||
74 status == RegistrationRequest::DEVICE_REGISTRATION_ERROR ||
75 status == RegistrationRequest::HTTP_NOT_OK ||
76 status == RegistrationRequest::URL_FETCHING_FAILED ||
77 status == RegistrationRequest::RESPONSE_PARSING_FAILED;
78 }
79
RecordRegistrationStatusToUMA(RegistrationRequest::Status status)80 void RecordRegistrationStatusToUMA(RegistrationRequest::Status status) {
81 UMA_HISTOGRAM_ENUMERATION("GCM.RegistrationRequestStatus", status,
82 RegistrationRequest::STATUS_COUNT);
83 }
84
85 } // namespace
86
RequestInfo(uint64 android_id,uint64 security_token,const std::string & app_id,const std::vector<std::string> & sender_ids)87 RegistrationRequest::RequestInfo::RequestInfo(
88 uint64 android_id,
89 uint64 security_token,
90 const std::string& app_id,
91 const std::vector<std::string>& sender_ids)
92 : android_id(android_id),
93 security_token(security_token),
94 app_id(app_id),
95 sender_ids(sender_ids) {
96 }
97
~RequestInfo()98 RegistrationRequest::RequestInfo::~RequestInfo() {}
99
RegistrationRequest(const GURL & registration_url,const RequestInfo & request_info,const net::BackoffEntry::Policy & backoff_policy,const RegistrationCallback & callback,int max_retry_count,scoped_refptr<net::URLRequestContextGetter> request_context_getter,GCMStatsRecorder * recorder)100 RegistrationRequest::RegistrationRequest(
101 const GURL& registration_url,
102 const RequestInfo& request_info,
103 const net::BackoffEntry::Policy& backoff_policy,
104 const RegistrationCallback& callback,
105 int max_retry_count,
106 scoped_refptr<net::URLRequestContextGetter> request_context_getter,
107 GCMStatsRecorder* recorder)
108 : callback_(callback),
109 request_info_(request_info),
110 registration_url_(registration_url),
111 backoff_entry_(&backoff_policy),
112 request_context_getter_(request_context_getter),
113 retries_left_(max_retry_count),
114 recorder_(recorder),
115 weak_ptr_factory_(this) {
116 DCHECK_GE(max_retry_count, 0);
117 }
118
~RegistrationRequest()119 RegistrationRequest::~RegistrationRequest() {}
120
Start()121 void RegistrationRequest::Start() {
122 DCHECK(!callback_.is_null());
123 DCHECK(request_info_.android_id != 0UL);
124 DCHECK(request_info_.security_token != 0UL);
125 DCHECK(0 < request_info_.sender_ids.size() &&
126 request_info_.sender_ids.size() <= kMaxSenders);
127
128 DCHECK(!url_fetcher_.get());
129 url_fetcher_.reset(net::URLFetcher::Create(
130 registration_url_, net::URLFetcher::POST, this));
131 url_fetcher_->SetRequestContext(request_context_getter_.get());
132 url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
133 net::LOAD_DO_NOT_SAVE_COOKIES);
134
135 std::string android_id = base::Uint64ToString(request_info_.android_id);
136 std::string auth_header =
137 std::string(net::HttpRequestHeaders::kAuthorization) + ": " +
138 kLoginHeader + " " + android_id + ":" +
139 base::Uint64ToString(request_info_.security_token);
140 url_fetcher_->SetExtraRequestHeaders(auth_header);
141
142 std::string body;
143 BuildFormEncoding(kAppIdKey, request_info_.app_id, &body);
144 BuildFormEncoding(kDeviceIdKey, android_id, &body);
145
146 std::string senders;
147 for (std::vector<std::string>::const_iterator iter =
148 request_info_.sender_ids.begin();
149 iter != request_info_.sender_ids.end();
150 ++iter) {
151 DCHECK(!iter->empty());
152 if (!senders.empty())
153 senders.append(",");
154 senders.append(*iter);
155 }
156 BuildFormEncoding(kSenderKey, senders, &body);
157 UMA_HISTOGRAM_COUNTS("GCM.RegistrationSenderIdCount",
158 request_info_.sender_ids.size());
159
160 DVLOG(1) << "Performing registration for: " << request_info_.app_id;
161 DVLOG(1) << "Registration request: " << body;
162 url_fetcher_->SetUploadData(kRegistrationRequestContentType, body);
163 recorder_->RecordRegistrationSent(request_info_.app_id, senders);
164 request_start_time_ = base::TimeTicks::Now();
165 url_fetcher_->Start();
166 }
167
RetryWithBackoff(bool update_backoff)168 void RegistrationRequest::RetryWithBackoff(bool update_backoff) {
169 if (update_backoff) {
170 DCHECK_GT(retries_left_, 0);
171 --retries_left_;
172 url_fetcher_.reset();
173 backoff_entry_.InformOfRequest(false);
174 }
175
176 if (backoff_entry_.ShouldRejectRequest()) {
177 DVLOG(1) << "Delaying GCM registration of app: "
178 << request_info_.app_id << ", for "
179 << backoff_entry_.GetTimeUntilRelease().InMilliseconds()
180 << " milliseconds.";
181 base::MessageLoop::current()->PostDelayedTask(
182 FROM_HERE,
183 base::Bind(&RegistrationRequest::RetryWithBackoff,
184 weak_ptr_factory_.GetWeakPtr(),
185 false),
186 backoff_entry_.GetTimeUntilRelease());
187 return;
188 }
189
190 Start();
191 }
192
ParseResponse(const net::URLFetcher * source,std::string * token)193 RegistrationRequest::Status RegistrationRequest::ParseResponse(
194 const net::URLFetcher* source, std::string* token) {
195 if (!source->GetStatus().is_success()) {
196 LOG(ERROR) << "URL fetching failed.";
197 return URL_FETCHING_FAILED;
198 }
199
200 std::string response;
201 if (!source->GetResponseAsString(&response)) {
202 LOG(ERROR) << "Failed to parse registration response as a string.";
203 return RESPONSE_PARSING_FAILED;
204 }
205
206 if (source->GetResponseCode() == net::HTTP_OK) {
207 size_t token_pos = response.find(kTokenPrefix);
208 if (token_pos != std::string::npos) {
209 *token = response.substr(token_pos + arraysize(kTokenPrefix) - 1);
210 return SUCCESS;
211 }
212 }
213
214 // If we are able to parse a meaningful known error, let's do so. Some errors
215 // will have HTTP_BAD_REQUEST, some will have HTTP_OK response code.
216 size_t error_pos = response.find(kErrorPrefix);
217 if (error_pos != std::string::npos) {
218 std::string error = response.substr(
219 error_pos + arraysize(kErrorPrefix) - 1);
220 return GetStatusFromError(error);
221 }
222
223 // If we cannot tell what the error is, but at least we know response code was
224 // not OK.
225 if (source->GetResponseCode() != net::HTTP_OK) {
226 DLOG(ERROR) << "URL fetching HTTP response code is not OK. It is "
227 << source->GetResponseCode();
228 return HTTP_NOT_OK;
229 }
230
231 return UNKNOWN_ERROR;
232 }
233
OnURLFetchComplete(const net::URLFetcher * source)234 void RegistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
235 std::string token;
236 Status status = ParseResponse(source, &token);
237 RecordRegistrationStatusToUMA(status);
238 recorder_->RecordRegistrationResponse(
239 request_info_.app_id,
240 request_info_.sender_ids,
241 status);
242
243 if (ShouldRetryWithStatus(status)) {
244 if (retries_left_ > 0) {
245 recorder_->RecordRegistrationRetryRequested(
246 request_info_.app_id,
247 request_info_.sender_ids,
248 retries_left_);
249 RetryWithBackoff(true);
250 return;
251 }
252
253 status = REACHED_MAX_RETRIES;
254 recorder_->RecordRegistrationResponse(
255 request_info_.app_id,
256 request_info_.sender_ids,
257 status);
258 RecordRegistrationStatusToUMA(status);
259 }
260
261 if (status == SUCCESS) {
262 UMA_HISTOGRAM_COUNTS("GCM.RegistrationRetryCount",
263 backoff_entry_.failure_count());
264 UMA_HISTOGRAM_TIMES("GCM.RegistrationCompleteTime",
265 base::TimeTicks::Now() - request_start_time_);
266 }
267 callback_.Run(status, token);
268 }
269
270 } // namespace gcm
271