| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 // A library to manage RLZ information for access-points shared | |
| 6 // across different client applications. | |
| 7 | |
| 8 #include "rlz/lib/rlz_lib.h" | |
| 9 | |
| 10 #include "base/string_util.h" | |
| 11 #include "base/stringprintf.h" | |
| 12 #include "rlz/lib/assert.h" | |
| 13 #include "rlz/lib/crc32.h" | |
| 14 #include "rlz/lib/financial_ping.h" | |
| 15 #include "rlz/lib/lib_values.h" | |
| 16 #include "rlz/lib/rlz_value_store.h" | |
| 17 #include "rlz/lib/string_utils.h" | |
| 18 | |
| 19 namespace { | |
| 20 | |
| 21 // Event information returned from ping response. | |
| 22 struct ReturnedEvent { | |
| 23 rlz_lib::AccessPoint access_point; | |
| 24 rlz_lib::Event event_type; | |
| 25 }; | |
| 26 | |
| 27 // Helper functions | |
| 28 | |
| 29 bool IsAccessPointSupported(rlz_lib::AccessPoint point) { | |
| 30 switch (point) { | |
| 31 case rlz_lib::NO_ACCESS_POINT: | |
| 32 case rlz_lib::LAST_ACCESS_POINT: | |
| 33 | |
| 34 case rlz_lib::MOBILE_IDLE_SCREEN_BLACKBERRY: | |
| 35 case rlz_lib::MOBILE_IDLE_SCREEN_WINMOB: | |
| 36 case rlz_lib::MOBILE_IDLE_SCREEN_SYMBIAN: | |
| 37 // These AP's are never available on Windows PCs. | |
| 38 return false; | |
| 39 | |
| 40 case rlz_lib::IE_DEFAULT_SEARCH: | |
| 41 case rlz_lib::IE_HOME_PAGE: | |
| 42 case rlz_lib::IETB_SEARCH_BOX: | |
| 43 case rlz_lib::QUICK_SEARCH_BOX: | |
| 44 case rlz_lib::GD_DESKBAND: | |
| 45 case rlz_lib::GD_SEARCH_GADGET: | |
| 46 case rlz_lib::GD_WEB_SERVER: | |
| 47 case rlz_lib::GD_OUTLOOK: | |
| 48 case rlz_lib::CHROME_OMNIBOX: | |
| 49 case rlz_lib::CHROME_HOME_PAGE: | |
| 50 // TODO: Figure out when these settings are set to Google. | |
| 51 | |
| 52 default: | |
| 53 return true; | |
| 54 } | |
| 55 } | |
| 56 | |
| 57 // Current RLZ can only use [a-zA-Z0-9_\-] | |
| 58 // We will be more liberal and allow some additional chars, but not url meta | |
| 59 // chars. | |
| 60 bool IsGoodRlzChar(const char ch) { | |
| 61 if (IsAsciiAlpha(ch) || IsAsciiDigit(ch)) | |
| 62 return true; | |
| 63 | |
| 64 switch (ch) { | |
| 65 case '_': | |
| 66 case '-': | |
| 67 case '!': | |
| 68 case '@': | |
| 69 case '$': | |
| 70 case '*': | |
| 71 case '(': | |
| 72 case ')': | |
| 73 case ';': | |
| 74 case '.': | |
| 75 case '<': | |
| 76 case '>': | |
| 77 return true; | |
| 78 } | |
| 79 | |
| 80 return false; | |
| 81 } | |
| 82 | |
| 83 // This function will remove bad rlz chars and also limit the max rlz to some | |
| 84 // reasonable size. It also assumes that normalized_rlz is at least | |
| 85 // kMaxRlzLength+1 long. | |
| 86 void NormalizeRlz(const char* raw_rlz, char* normalized_rlz) { | |
| 87 int index = 0; | |
| 88 for (; raw_rlz[index] != 0 && index < rlz_lib::kMaxRlzLength; ++index) { | |
| 89 char current = raw_rlz[index]; | |
| 90 if (IsGoodRlzChar(current)) { | |
| 91 normalized_rlz[index] = current; | |
| 92 } else { | |
| 93 normalized_rlz[index] = '.'; | |
| 94 } | |
| 95 } | |
| 96 | |
| 97 normalized_rlz[index] = 0; | |
| 98 } | |
| 99 | |
| 100 void GetEventsFromResponseString( | |
| 101 const std::string& response_line, | |
| 102 const std::string& field_header, | |
| 103 std::vector<ReturnedEvent>* event_array) { | |
| 104 // Get the string of events. | |
| 105 std::string events = response_line.substr(field_header.size()); | |
| 106 TrimWhitespaceASCII(events, TRIM_LEADING, &events); | |
| 107 | |
| 108 int events_length = events.find_first_of("\r\n "); | |
| 109 if (events_length < 0) | |
| 110 events_length = events.size(); | |
| 111 events = events.substr(0, events_length); | |
| 112 | |
| 113 // Break this up into individual events | |
| 114 int event_end_index = -1; | |
| 115 do { | |
| 116 int event_begin = event_end_index + 1; | |
| 117 event_end_index = events.find(rlz_lib::kEventsCgiSeparator, event_begin); | |
| 118 int event_end = event_end_index; | |
| 119 if (event_end < 0) | |
| 120 event_end = events_length; | |
| 121 | |
| 122 std::string event_string = events.substr(event_begin, | |
| 123 event_end - event_begin); | |
| 124 if (event_string.size() != 3) // 3 = 2(AP) + 1(E) | |
| 125 continue; | |
| 126 | |
| 127 rlz_lib::AccessPoint point = rlz_lib::NO_ACCESS_POINT; | |
| 128 rlz_lib::Event event = rlz_lib::INVALID_EVENT; | |
| 129 if (!GetAccessPointFromName(event_string.substr(0, 2).c_str(), &point) || | |
| 130 point == rlz_lib::NO_ACCESS_POINT) { | |
| 131 continue; | |
| 132 } | |
| 133 | |
| 134 if (!GetEventFromName(event_string.substr(event_string.size() - 1).c_str(), | |
| 135 &event) || event == rlz_lib::INVALID_EVENT) { | |
| 136 continue; | |
| 137 } | |
| 138 | |
| 139 ReturnedEvent current_event = {point, event}; | |
| 140 event_array->push_back(current_event); | |
| 141 } while (event_end_index >= 0); | |
| 142 } | |
| 143 | |
| 144 // Event storage functions. | |
| 145 bool RecordStatefulEvent(rlz_lib::Product product, rlz_lib::AccessPoint point, | |
| 146 rlz_lib::Event event) { | |
| 147 rlz_lib::ScopedRlzValueStoreLock lock; | |
| 148 rlz_lib::RlzValueStore* store = lock.GetStore(); | |
| 149 if (!store || !store->HasAccess(rlz_lib::RlzValueStore::kWriteAccess)) | |
| 150 return false; | |
| 151 | |
| 152 // Write the new event to the value store. | |
| 153 const char* point_name = GetAccessPointName(point); | |
| 154 const char* event_name = GetEventName(event); | |
| 155 if (!point_name || !event_name) | |
| 156 return false; | |
| 157 | |
| 158 if (!point_name[0] || !event_name[0]) | |
| 159 return false; | |
| 160 | |
| 161 std::string new_event_value; | |
| 162 base::StringAppendF(&new_event_value, "%s%s", point_name, event_name); | |
| 163 return store->AddStatefulEvent(product, new_event_value.c_str()); | |
| 164 } | |
| 165 | |
| 166 bool GetProductEventsAsCgiHelper(rlz_lib::Product product, char* cgi, | |
| 167 size_t cgi_size, | |
| 168 rlz_lib::RlzValueStore* store) { | |
| 169 // Prepend the CGI param key to the buffer. | |
| 170 std::string cgi_arg; | |
| 171 base::StringAppendF(&cgi_arg, "%s=", rlz_lib::kEventsCgiVariable); | |
| 172 if (cgi_size <= cgi_arg.size()) | |
| 173 return false; | |
| 174 | |
| 175 size_t index; | |
| 176 for (index = 0; index < cgi_arg.size(); ++index) | |
| 177 cgi[index] = cgi_arg[index]; | |
| 178 | |
| 179 // Read stored events. | |
| 180 std::vector<std::string> events; | |
| 181 if (!store->ReadProductEvents(product, &events)) | |
| 182 return false; | |
| 183 | |
| 184 // Append the events to the buffer. | |
| 185 size_t num_values = 0; | |
| 186 | |
| 187 for (num_values = 0; num_values < events.size(); ++num_values) { | |
| 188 cgi[index] = '\0'; | |
| 189 | |
| 190 int divider = num_values > 0 ? 1 : 0; | |
| 191 int size = cgi_size - (index + divider); | |
| 192 if (size <= 0) | |
| 193 return cgi_size >= (rlz_lib::kMaxCgiLength + 1); | |
| 194 | |
| 195 strncpy(cgi + index + divider, events[num_values].c_str(), size); | |
| 196 if (divider) | |
| 197 cgi[index] = rlz_lib::kEventsCgiSeparator; | |
| 198 | |
| 199 index += std::min((int)events[num_values].length(), size) + divider; | |
| 200 } | |
| 201 | |
| 202 cgi[index] = '\0'; | |
| 203 | |
| 204 return num_values > 0; | |
| 205 } | |
| 206 | |
| 207 } // namespace | |
| 208 | |
| 209 namespace rlz_lib { | |
| 210 | |
| 211 #if defined(RLZ_NETWORK_IMPLEMENTATION_CHROME_NET) | |
| 212 bool SetURLRequestContext(net::URLRequestContextGetter* context) { | |
| 213 return FinancialPing::SetURLRequestContext(context); | |
| 214 } | |
| 215 #endif | |
| 216 | |
| 217 bool GetProductEventsAsCgi(Product product, char* cgi, size_t cgi_size) { | |
| 218 if (!cgi || cgi_size <= 0) { | |
| 219 ASSERT_STRING("GetProductEventsAsCgi: Invalid buffer"); | |
| 220 return false; | |
| 221 } | |
| 222 | |
| 223 cgi[0] = 0; | |
| 224 | |
| 225 ScopedRlzValueStoreLock lock; | |
| 226 RlzValueStore* store = lock.GetStore(); | |
| 227 if (!store || !store->HasAccess(RlzValueStore::kReadAccess)) | |
| 228 return false; | |
| 229 | |
| 230 size_t size_local = std::min( | |
| 231 static_cast<size_t>(kMaxCgiLength + 1), cgi_size); | |
| 232 bool result = GetProductEventsAsCgiHelper(product, cgi, size_local, store); | |
| 233 | |
| 234 if (!result) { | |
| 235 ASSERT_STRING("GetProductEventsAsCgi: Possibly insufficient buffer size"); | |
| 236 cgi[0] = 0; | |
| 237 return false; | |
| 238 } | |
| 239 | |
| 240 return true; | |
| 241 } | |
| 242 | |
| 243 bool RecordProductEvent(Product product, AccessPoint point, Event event) { | |
| 244 ScopedRlzValueStoreLock lock; | |
| 245 RlzValueStore* store = lock.GetStore(); | |
| 246 if (!store || !store->HasAccess(RlzValueStore::kWriteAccess)) | |
| 247 return false; | |
| 248 | |
| 249 // Get this event's value. | |
| 250 const char* point_name = GetAccessPointName(point); | |
| 251 const char* event_name = GetEventName(event); | |
| 252 if (!point_name || !event_name) | |
| 253 return false; | |
| 254 | |
| 255 if (!point_name[0] || !event_name[0]) | |
| 256 return false; | |
| 257 | |
| 258 std::string new_event_value; | |
| 259 base::StringAppendF(&new_event_value, "%s%s", point_name, event_name); | |
| 260 | |
| 261 // Check whether this event is a stateful event. If so, don't record it. | |
| 262 if (store->IsStatefulEvent(product, new_event_value.c_str())) { | |
| 263 // For a stateful event we skip recording, this function is also | |
| 264 // considered successful. | |
| 265 return true; | |
| 266 } | |
| 267 | |
| 268 // Write the new event to the value store. | |
| 269 return store->AddProductEvent(product, new_event_value.c_str()); | |
| 270 } | |
| 271 | |
| 272 bool ClearProductEvent(Product product, AccessPoint point, Event event) { | |
| 273 ScopedRlzValueStoreLock lock; | |
| 274 RlzValueStore* store = lock.GetStore(); | |
| 275 if (!store || !store->HasAccess(RlzValueStore::kWriteAccess)) | |
| 276 return false; | |
| 277 | |
| 278 // Get the event's value store value and delete it. | |
| 279 const char* point_name = GetAccessPointName(point); | |
| 280 const char* event_name = GetEventName(event); | |
| 281 if (!point_name || !event_name) | |
| 282 return false; | |
| 283 | |
| 284 if (!point_name[0] || !event_name[0]) | |
| 285 return false; | |
| 286 | |
| 287 std::string event_value; | |
| 288 base::StringAppendF(&event_value, "%s%s", point_name, event_name); | |
| 289 return store->ClearProductEvent(product, event_value.c_str()); | |
| 290 } | |
| 291 | |
| 292 // RLZ storage functions. | |
| 293 | |
| 294 bool GetAccessPointRlz(AccessPoint point, char* rlz, size_t rlz_size) { | |
| 295 if (!rlz || rlz_size <= 0) { | |
| 296 ASSERT_STRING("GetAccessPointRlz: Invalid buffer"); | |
| 297 return false; | |
| 298 } | |
| 299 | |
| 300 rlz[0] = 0; | |
| 301 | |
| 302 ScopedRlzValueStoreLock lock; | |
| 303 RlzValueStore* store = lock.GetStore(); | |
| 304 if (!store || !store->HasAccess(RlzValueStore::kReadAccess)) | |
| 305 return false; | |
| 306 | |
| 307 if (!IsAccessPointSupported(point)) | |
| 308 return false; | |
| 309 | |
| 310 return store->ReadAccessPointRlz(point, rlz, rlz_size); | |
| 311 } | |
| 312 | |
| 313 bool SetAccessPointRlz(AccessPoint point, const char* new_rlz) { | |
| 314 ScopedRlzValueStoreLock lock; | |
| 315 RlzValueStore* store = lock.GetStore(); | |
| 316 if (!store || !store->HasAccess(RlzValueStore::kWriteAccess)) | |
| 317 return false; | |
| 318 | |
| 319 if (!new_rlz) { | |
| 320 ASSERT_STRING("SetAccessPointRlz: Invalid buffer"); | |
| 321 return false; | |
| 322 } | |
| 323 | |
| 324 // Return false if the access point is not set to Google. | |
| 325 if (!IsAccessPointSupported(point)) { | |
| 326 ASSERT_STRING(("SetAccessPointRlz: " | |
| 327 "Cannot set RLZ for unsupported access point.")); | |
| 328 return false; | |
| 329 } | |
| 330 | |
| 331 // Verify the RLZ length. | |
| 332 size_t rlz_length = strlen(new_rlz); | |
| 333 if (rlz_length > kMaxRlzLength) { | |
| 334 ASSERT_STRING("SetAccessPointRlz: RLZ length is exceeds max allowed."); | |
| 335 return false; | |
| 336 } | |
| 337 | |
| 338 char normalized_rlz[kMaxRlzLength + 1]; | |
| 339 NormalizeRlz(new_rlz, normalized_rlz); | |
| 340 VERIFY(strlen(new_rlz) == rlz_length); | |
| 341 | |
| 342 // Setting RLZ to empty == clearing. | |
| 343 if (normalized_rlz[0] == 0) | |
| 344 return store->ClearAccessPointRlz(point); | |
| 345 return store->WriteAccessPointRlz(point, normalized_rlz); | |
| 346 } | |
| 347 | |
| 348 // Financial Server pinging functions. | |
| 349 | |
| 350 bool FormFinancialPingRequest(Product product, const AccessPoint* access_points, | |
| 351 const char* product_signature, | |
| 352 const char* product_brand, | |
| 353 const char* product_id, | |
| 354 const char* product_lang, | |
| 355 bool exclude_machine_id, | |
| 356 char* request, size_t request_buffer_size) { | |
| 357 if (!request || request_buffer_size == 0) | |
| 358 return false; | |
| 359 | |
| 360 request[0] = 0; | |
| 361 | |
| 362 std::string request_string; | |
| 363 if (!FinancialPing::FormRequest(product, access_points, product_signature, | |
| 364 product_brand, product_id, product_lang, | |
| 365 exclude_machine_id, &request_string)) | |
| 366 return false; | |
| 367 | |
| 368 if (request_string.size() >= request_buffer_size) | |
| 369 return false; | |
| 370 | |
| 371 strncpy(request, request_string.c_str(), request_buffer_size); | |
| 372 request[request_buffer_size - 1] = 0; | |
| 373 return true; | |
| 374 } | |
| 375 | |
| 376 bool PingFinancialServer(Product product, const char* request, char* response, | |
| 377 size_t response_buffer_size) { | |
| 378 if (!response || response_buffer_size == 0) | |
| 379 return false; | |
| 380 response[0] = 0; | |
| 381 | |
| 382 // Check if the time is right to ping. | |
| 383 if (!FinancialPing::IsPingTime(product, false)) | |
| 384 return false; | |
| 385 | |
| 386 // Send out the ping. | |
| 387 std::string response_string; | |
| 388 if (!FinancialPing::PingServer(request, &response_string)) | |
| 389 return false; | |
| 390 | |
| 391 if (response_string.size() >= response_buffer_size) | |
| 392 return false; | |
| 393 | |
| 394 strncpy(response, response_string.c_str(), response_buffer_size); | |
| 395 response[response_buffer_size - 1] = 0; | |
| 396 return true; | |
| 397 } | |
| 398 | |
| 399 bool IsPingResponseValid(const char* response, int* checksum_idx) { | |
| 400 if (!response || !response[0]) | |
| 401 return false; | |
| 402 | |
| 403 if (checksum_idx) | |
| 404 *checksum_idx = -1; | |
| 405 | |
| 406 if (strlen(response) > kMaxPingResponseLength) { | |
| 407 ASSERT_STRING("IsPingResponseValid: response is too long to parse."); | |
| 408 return false; | |
| 409 } | |
| 410 | |
| 411 // Find the checksum line. | |
| 412 std::string response_string(response); | |
| 413 | |
| 414 std::string checksum_param("\ncrc32: "); | |
| 415 int calculated_crc; | |
| 416 int checksum_index = response_string.find(checksum_param); | |
| 417 if (checksum_index >= 0) { | |
| 418 // Calculate checksum of message preceeding checksum line. | |
| 419 // (+ 1 to include the \n) | |
| 420 std::string message(response_string.substr(0, checksum_index + 1)); | |
| 421 if (!Crc32(message.c_str(), &calculated_crc)) | |
| 422 return false; | |
| 423 } else { | |
| 424 checksum_param = "crc32: "; // Empty response case. | |
| 425 if (!StartsWithASCII(response_string, checksum_param, true)) | |
| 426 return false; | |
| 427 | |
| 428 checksum_index = 0; | |
| 429 if (!Crc32("", &calculated_crc)) | |
| 430 return false; | |
| 431 } | |
| 432 | |
| 433 // Find the checksum value on the response. | |
| 434 int checksum_end = response_string.find("\n", checksum_index + 1); | |
| 435 if (checksum_end < 0) | |
| 436 checksum_end = response_string.size(); | |
| 437 | |
| 438 int checksum_begin = checksum_index + checksum_param.size(); | |
| 439 std::string checksum = response_string.substr(checksum_begin, | |
| 440 checksum_end - checksum_begin + 1); | |
| 441 TrimWhitespaceASCII(checksum, TRIM_ALL, &checksum); | |
| 442 | |
| 443 if (checksum_idx) | |
| 444 *checksum_idx = checksum_index; | |
| 445 | |
| 446 return calculated_crc == HexStringToInteger(checksum.c_str()); | |
| 447 } | |
| 448 | |
| 449 // Complex helpers built on top of other functions. | |
| 450 | |
| 451 bool ParseFinancialPingResponse(Product product, const char* response) { | |
| 452 // Update the last ping time irrespective of success. | |
| 453 FinancialPing::UpdateLastPingTime(product); | |
| 454 // Parse the ping response - update RLZs, clear events. | |
| 455 return ParsePingResponse(product, response); | |
| 456 } | |
| 457 | |
| 458 bool SendFinancialPing(Product product, const AccessPoint* access_points, | |
| 459 const char* product_signature, | |
| 460 const char* product_brand, | |
| 461 const char* product_id, const char* product_lang, | |
| 462 bool exclude_machine_id) { | |
| 463 return SendFinancialPing(product, access_points, product_signature, | |
| 464 product_brand, product_id, product_lang, | |
| 465 exclude_machine_id, false); | |
| 466 } | |
| 467 | |
| 468 | |
| 469 bool SendFinancialPing(Product product, const AccessPoint* access_points, | |
| 470 const char* product_signature, | |
| 471 const char* product_brand, | |
| 472 const char* product_id, const char* product_lang, | |
| 473 bool exclude_machine_id, | |
| 474 const bool skip_time_check) { | |
| 475 // Create the financial ping request. | |
| 476 std::string request; | |
| 477 if (!FinancialPing::FormRequest(product, access_points, product_signature, | |
| 478 product_brand, product_id, product_lang, | |
| 479 exclude_machine_id, &request)) | |
| 480 return false; | |
| 481 | |
| 482 // Check if the time is right to ping. | |
| 483 if (!FinancialPing::IsPingTime(product, skip_time_check)) | |
| 484 return false; | |
| 485 | |
| 486 // Send out the ping, update the last ping time irrespective of success. | |
| 487 FinancialPing::UpdateLastPingTime(product); | |
| 488 std::string response; | |
| 489 if (!FinancialPing::PingServer(request.c_str(), &response)) | |
| 490 return false; | |
| 491 | |
| 492 // Parse the ping response - update RLZs, clear events. | |
| 493 return ParsePingResponse(product, response.c_str()); | |
| 494 } | |
| 495 | |
| 496 // TODO: Use something like RSA to make sure the response is | |
| 497 // from a Google server. | |
| 498 bool ParsePingResponse(Product product, const char* response) { | |
| 499 rlz_lib::ScopedRlzValueStoreLock lock; | |
| 500 rlz_lib::RlzValueStore* store = lock.GetStore(); | |
| 501 if (!store || !store->HasAccess(rlz_lib::RlzValueStore::kWriteAccess)) | |
| 502 return false; | |
| 503 | |
| 504 std::string response_string(response); | |
| 505 int response_length = -1; | |
| 506 if (!IsPingResponseValid(response, &response_length)) | |
| 507 return false; | |
| 508 | |
| 509 if (0 == response_length) | |
| 510 return true; // Empty response - no parsing. | |
| 511 | |
| 512 std::string events_variable; | |
| 513 std::string stateful_events_variable; | |
| 514 base::SStringPrintf(&events_variable, "%s: ", kEventsCgiVariable); | |
| 515 base::SStringPrintf(&stateful_events_variable, "%s: ", | |
| 516 kStatefulEventsCgiVariable); | |
| 517 | |
| 518 int rlz_cgi_length = strlen(kRlzCgiVariable); | |
| 519 | |
| 520 // Split response lines. Expected response format is lines of the form: | |
| 521 // rlzW1: 1R1_____en__252 | |
| 522 int line_end_index = -1; | |
| 523 do { | |
| 524 int line_begin = line_end_index + 1; | |
| 525 line_end_index = response_string.find("\n", line_begin); | |
| 526 | |
| 527 int line_end = line_end_index; | |
| 528 if (line_end < 0) | |
| 529 line_end = response_length; | |
| 530 | |
| 531 if (line_end <= line_begin) | |
| 532 continue; // Empty line. | |
| 533 | |
| 534 std::string response_line; | |
| 535 response_line = response_string.substr(line_begin, line_end - line_begin); | |
| 536 | |
| 537 if (StartsWithASCII(response_line, kRlzCgiVariable, true)) { // An RLZ. | |
| 538 int separator_index = -1; | |
| 539 if ((separator_index = response_line.find(": ")) < 0) | |
| 540 continue; // Not a valid key-value pair. | |
| 541 | |
| 542 // Get the access point. | |
| 543 std::string point_name = | |
| 544 response_line.substr(3, separator_index - rlz_cgi_length); | |
| 545 AccessPoint point = NO_ACCESS_POINT; | |
| 546 if (!GetAccessPointFromName(point_name.c_str(), &point) || | |
| 547 point == NO_ACCESS_POINT) | |
| 548 continue; // Not a valid access point. | |
| 549 | |
| 550 // Get the new RLZ. | |
| 551 std::string rlz_value(response_line.substr(separator_index + 2)); | |
| 552 TrimWhitespaceASCII(rlz_value, TRIM_LEADING, &rlz_value); | |
| 553 | |
| 554 int rlz_length = rlz_value.find_first_of("\r\n "); | |
| 555 if (rlz_length < 0) | |
| 556 rlz_length = rlz_value.size(); | |
| 557 | |
| 558 if (rlz_length > kMaxRlzLength) | |
| 559 continue; // Too long. | |
| 560 | |
| 561 if (IsAccessPointSupported(point)) | |
| 562 SetAccessPointRlz(point, rlz_value.substr(0, rlz_length).c_str()); | |
| 563 } else if (StartsWithASCII(response_line, events_variable, true)) { | |
| 564 // Clear events which server parsed. | |
| 565 std::vector<ReturnedEvent> event_array; | |
| 566 GetEventsFromResponseString(response_line, events_variable, &event_array); | |
| 567 for (size_t i = 0; i < event_array.size(); ++i) { | |
| 568 ClearProductEvent(product, event_array[i].access_point, | |
| 569 event_array[i].event_type); | |
| 570 } | |
| 571 } else if (StartsWithASCII(response_line, stateful_events_variable, true)) { | |
| 572 // Record any stateful events the server send over. | |
| 573 std::vector<ReturnedEvent> event_array; | |
| 574 GetEventsFromResponseString(response_line, stateful_events_variable, | |
| 575 &event_array); | |
| 576 for (size_t i = 0; i < event_array.size(); ++i) { | |
| 577 RecordStatefulEvent(product, event_array[i].access_point, | |
| 578 event_array[i].event_type); | |
| 579 } | |
| 580 } | |
| 581 } while (line_end_index >= 0); | |
| 582 | |
| 583 #if defined(OS_WIN) | |
| 584 // Update the DCC in registry if needed. | |
| 585 SetMachineDealCodeFromPingResponse(response); | |
| 586 #endif | |
| 587 | |
| 588 return true; | |
| 589 } | |
| 590 | |
| 591 bool GetPingParams(Product product, const AccessPoint* access_points, | |
| 592 char* cgi, size_t cgi_size) { | |
| 593 if (!cgi || cgi_size <= 0) { | |
| 594 ASSERT_STRING("GetPingParams: Invalid buffer"); | |
| 595 return false; | |
| 596 } | |
| 597 | |
| 598 cgi[0] = 0; | |
| 599 | |
| 600 if (!access_points) { | |
| 601 ASSERT_STRING("GetPingParams: access_points is NULL"); | |
| 602 return false; | |
| 603 } | |
| 604 | |
| 605 // Add the RLZ Exchange Protocol version. | |
| 606 std::string cgi_string(kProtocolCgiArgument); | |
| 607 | |
| 608 // Copy the &rlz= over. | |
| 609 base::StringAppendF(&cgi_string, "&%s=", kRlzCgiVariable); | |
| 610 | |
| 611 { | |
| 612 // Now add each of the RLZ's. Keep the lock during all GetAccessPointRlz() | |
| 613 // calls below. | |
| 614 ScopedRlzValueStoreLock lock; | |
| 615 RlzValueStore* store = lock.GetStore(); | |
| 616 if (!store || !store->HasAccess(RlzValueStore::kReadAccess)) | |
| 617 return false; | |
| 618 bool first_rlz = true; // comma before every RLZ but the first. | |
| 619 for (int i = 0; access_points[i] != NO_ACCESS_POINT; i++) { | |
| 620 char rlz[kMaxRlzLength + 1]; | |
| 621 if (GetAccessPointRlz(access_points[i], rlz, arraysize(rlz))) { | |
| 622 const char* access_point = GetAccessPointName(access_points[i]); | |
| 623 if (!access_point) | |
| 624 continue; | |
| 625 | |
| 626 base::StringAppendF(&cgi_string, "%s%s%s%s", | |
| 627 first_rlz ? "" : kRlzCgiSeparator, | |
| 628 access_point, kRlzCgiIndicator, rlz); | |
| 629 first_rlz = false; | |
| 630 } | |
| 631 } | |
| 632 | |
| 633 #if defined(OS_WIN) | |
| 634 // Report the DCC too if not empty. DCCs are windows-only. | |
| 635 char dcc[kMaxDccLength + 1]; | |
| 636 dcc[0] = 0; | |
| 637 if (GetMachineDealCode(dcc, arraysize(dcc)) && dcc[0]) | |
| 638 base::StringAppendF(&cgi_string, "&%s=%s", kDccCgiVariable, dcc); | |
| 639 #endif | |
| 640 } | |
| 641 | |
| 642 if (cgi_string.size() >= cgi_size) | |
| 643 return false; | |
| 644 | |
| 645 strncpy(cgi, cgi_string.c_str(), cgi_size); | |
| 646 cgi[cgi_size - 1] = 0; | |
| 647 | |
| 648 return true; | |
| 649 } | |
| 650 | |
| 651 } // namespace rlz_lib | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10642009:
Add a regenerate button to regenerate the password in Windows. (Closed)
Base URL: http://git.chromium.org/chromium/src.git@master