rlz/lib/financial_ping.cc

   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 // Library functions related to the Financial Server ping.
   6
   7 #include "rlz/lib/financial_ping.h"
   8
   9 #include "base/atomicops.h"
  10 #include "base/basictypes.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "rlz/lib/assert.h"
  17 #include "rlz/lib/lib_values.h"
  18 #include "rlz/lib/machine_id.h"
  19 #include "rlz/lib/rlz_lib.h"
  20 #include "rlz/lib/rlz_value_store.h"
  21 #include "rlz/lib/string_utils.h"
  22
  23 #if !defined(OS_WIN)
  24 #include "base/time/time.h"
  25 #endif
  26
  27 #if defined(RLZ_NETWORK_IMPLEMENTATION_WIN_INET)
  28
  29 #include <windows.h>
  30 #include <wininet.h>
  31
  32 namespace {
  33
  34 class InternetHandle {
  35  public:
  36   InternetHandle(HINTERNET handle) { handle_ = handle; }
  37   ~InternetHandle() { if (handle_) InternetCloseHandle(handle_); }
  38   operator HINTERNET() const { return handle_; }
  39   bool operator!() const { return (handle_ == NULL); }
  40
  41  private:
  42   HINTERNET handle_;
  43 };
  44
  45 }  // namespace
  46
  47 #else
  48
  49 #include "base/bind.h"
  50 #include "base/message_loop/message_loop.h"
  51 #include "base/run_loop.h"
  52 #include "base/time/time.h"
  53 #include "net/base/load_flags.h"
  54 #include "net/url_request/url_fetcher.h"
  55 #include "net/url_request/url_fetcher_delegate.h"
  56 #include "net/url_request/url_request_context.h"
  57 #include "net/url_request/url_request_context_getter.h"
  58 #include "url/gurl.h"
  59
  60 #endif
  61
  62 namespace {
  63
  64 // Returns the time relative to a fixed point in the past in multiples of
  65 // 100 ns stepts. The point in the past is arbitrary but can't change, as the
  66 // result of this value is stored on disk.
  67 int64 GetSystemTimeAsInt64() {
  68 #if defined(OS_WIN)
  69   FILETIME now_as_file_time;
  70   // Relative to Jan 1, 1601 (UTC).
  71   GetSystemTimeAsFileTime(&now_as_file_time);
  72
  73   LARGE_INTEGER integer;
  74   integer.HighPart = now_as_file_time.dwHighDateTime;
  75   integer.LowPart = now_as_file_time.dwLowDateTime;
  76   return integer.QuadPart;
  77 #else
  78   // Seconds since epoch (Jan 1, 1970).
  79   double now_seconds = base::Time::Now().ToDoubleT();
  80   return static_cast<int64>(now_seconds * 1000 * 1000 * 10);
  81 #endif
  82 }
  83
  84 }  // namespace
  85
  86
  87 namespace rlz_lib {
  88
  89 using base::subtle::AtomicWord;
  90
  91 bool FinancialPing::FormRequest(Product product,
  92     const AccessPoint* access_points, const char* product_signature,
  93     const char* product_brand, const char* product_id,
  94     const char* product_lang, bool exclude_machine_id,
  95     std::string* request) {
  96   if (!request) {
  97     ASSERT_STRING("FinancialPing::FormRequest: request is NULL");
  98     return false;
  99   }
 100
 101   request->clear();
 102
 103   ScopedRlzValueStoreLock lock;
 104   RlzValueStore* store = lock.GetStore();
 105   if (!store || !store->HasAccess(RlzValueStore::kReadAccess))
 106     return false;
 107
 108   if (!access_points) {
 109     ASSERT_STRING("FinancialPing::FormRequest: access_points is NULL");
 110     return false;
 111   }
 112
 113   if (!product_signature) {
 114     ASSERT_STRING("FinancialPing::FormRequest: product_signature is NULL");
 115     return false;
 116   }
 117
 118   if (!SupplementaryBranding::GetBrand().empty()) {
 119     if (SupplementaryBranding::GetBrand() != product_brand) {
 120       ASSERT_STRING("FinancialPing::FormRequest: supplementary branding bad");
 121       return false;
 122     }
 123   }
 124
 125   base::StringAppendF(request, "%s?", kFinancialPingPath);
 126
 127   // Add the signature, brand, product id and language.
 128   base::StringAppendF(request, "%s=%s", kProductSignatureCgiVariable,
 129                       product_signature);
 130   if (product_brand)
 131     base::StringAppendF(request, "&%s=%s", kProductBrandCgiVariable,
 132                         product_brand);
 133
 134   if (product_id)
 135     base::StringAppendF(request, "&%s=%s", kProductIdCgiVariable, product_id);
 136
 137   if (product_lang)
 138     base::StringAppendF(request, "&%s=%s", kProductLanguageCgiVariable,
 139                         product_lang);
 140
 141   // Add the product events.
 142   char cgi[kMaxCgiLength + 1];
 143   cgi[0] = 0;
 144   bool has_events = GetProductEventsAsCgi(product, cgi, arraysize(cgi));
 145   if (has_events)
 146     base::StringAppendF(request, "&%s", cgi);
 147
 148   // If we don't have any events, we should ping all the AP's on the system
 149   // that we know about and have a current RLZ value, even if they are not
 150   // used by this product.
 151   AccessPoint all_points[LAST_ACCESS_POINT];
 152   if (!has_events) {
 153     char rlz[kMaxRlzLength + 1];
 154     int idx = 0;
 155     for (int ap = NO_ACCESS_POINT + 1; ap < LAST_ACCESS_POINT; ap++) {
 156       rlz[0] = 0;
 157       AccessPoint point = static_cast<AccessPoint>(ap);
 158       if (GetAccessPointRlz(point, rlz, arraysize(rlz)) &&
 159           rlz[0] != '\0')
 160         all_points[idx++] = point;
 161     }
 162     all_points[idx] = NO_ACCESS_POINT;
 163   }
 164
 165   // Add the RLZ's and the DCC if needed. This is the same as get PingParams.
 166   // This will also include the RLZ Exchange Protocol CGI Argument.
 167   cgi[0] = 0;
 168   if (GetPingParams(product, has_events ? access_points : all_points,
 169                     cgi, arraysize(cgi)))
 170     base::StringAppendF(request, "&%s", cgi);
 171
 172   if (has_events && !exclude_machine_id) {
 173     std::string machine_id;
 174     if (GetMachineId(&machine_id)) {
 175       base::StringAppendF(request, "&%s=%s", kMachineIdCgiVariable,
 176                           machine_id.c_str());
 177     }
 178   }
 179
 180   return true;
 181 }
 182
 183 #if defined(RLZ_NETWORK_IMPLEMENTATION_CHROME_NET)
 184 // The pointer to URLRequestContextGetter used by FinancialPing::PingServer().
 185 // It is atomic pointer because it can be accessed and modified by multiple
 186 // threads.
 187 AtomicWord g_context;
 188
 189 bool FinancialPing::SetURLRequestContext(
 190     net::URLRequestContextGetter* context) {
 191   base::subtle::Release_Store(
 192       &g_context, reinterpret_cast<AtomicWord>(context));
 193   return true;
 194 }
 195
 196 namespace {
 197
 198 class FinancialPingUrlFetcherDelegate : public net::URLFetcherDelegate {
 199  public:
 200   FinancialPingUrlFetcherDelegate(const base::Closure& callback)
 201       : callback_(callback) {
 202   }
 203   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 204
 205  private:
 206   base::Closure callback_;
 207 };
 208
 209 void FinancialPingUrlFetcherDelegate::OnURLFetchComplete(
 210     const net::URLFetcher* source) {
 211   callback_.Run();
 212 }
 213
 214 bool send_financial_ping_interrupted_for_test = false;
 215
 216 }  // namespace
 217
 218 void ShutdownCheck(base::WeakPtr<base::RunLoop> weak) {
 219   if (!weak.get())
 220     return;
 221   if (!base::subtle::Acquire_Load(&g_context)) {
 222     send_financial_ping_interrupted_for_test = true;
 223     weak->QuitClosure().Run();
 224     return;
 225   }
 226   // How frequently the financial ping thread should check
 227   // the shutdown condition?
 228   const base::TimeDelta kInterval = base::TimeDelta::FromMilliseconds(500);
 229   base::MessageLoop::current()->PostDelayedTask(
 230       FROM_HERE,
 231       base::Bind(&ShutdownCheck, weak),
 232       kInterval);
 233 }
 234 #endif
 235
 236 bool FinancialPing::PingServer(const char* request, std::string* response) {
 237   if (!response)
 238     return false;
 239
 240   response->clear();
 241
 242 #if defined(RLZ_NETWORK_IMPLEMENTATION_WIN_INET)
 243   // Initialize WinInet.
 244   InternetHandle inet_handle = InternetOpenA(kFinancialPingUserAgent,
 245                                              INTERNET_OPEN_TYPE_PRECONFIG,
 246                                              NULL, NULL, 0);
 247   if (!inet_handle)
 248     return false;
 249
 250   // Open network connection.
 251   InternetHandle connection_handle = InternetConnectA(inet_handle,
 252       kFinancialServer, kFinancialPort, "", "", INTERNET_SERVICE_HTTP,
 253       INTERNET_FLAG_NO_CACHE_WRITE, 0);
 254   if (!connection_handle)
 255     return false;
 256
 257   // Prepare the HTTP request.
 258   InternetHandle http_handle = HttpOpenRequestA(connection_handle,
 259       "GET", request, NULL, NULL, kFinancialPingResponseObjects,
 260       INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_NO_COOKIES, NULL);
 261   if (!http_handle)
 262     return false;
 263
 264   // Timeouts are probably:
 265   // INTERNET_OPTION_SEND_TIMEOUT, INTERNET_OPTION_RECEIVE_TIMEOUT
 266
 267   // Send the HTTP request. Note: Fails if user is working in off-line mode.
 268   if (!HttpSendRequest(http_handle, NULL, 0, NULL, 0))
 269     return false;
 270
 271   // Check the response status.
 272   DWORD status;
 273   DWORD status_size = sizeof(status);
 274   if (!HttpQueryInfo(http_handle, HTTP_QUERY_STATUS_CODE |
 275                      HTTP_QUERY_FLAG_NUMBER, &status, &status_size, NULL) ||
 276       200 != status)
 277     return false;
 278
 279   // Get the response text.
 280   scoped_ptr<char[]> buffer(new char[kMaxPingResponseLength]);
 281   if (buffer.get() == NULL)
 282     return false;
 283
 284   DWORD bytes_read = 0;
 285   while (InternetReadFile(http_handle, buffer.get(), kMaxPingResponseLength,
 286                           &bytes_read) && bytes_read > 0) {
 287     response->append(buffer.get(), bytes_read);
 288     bytes_read = 0;
 289   };
 290
 291   return true;
 292 #else
 293   // Copy the pointer to stack because g_context may be set to NULL
 294   // in different thread. The instance is guaranteed to exist while
 295   // the method is running.
 296   net::URLRequestContextGetter* context =
 297       reinterpret_cast<net::URLRequestContextGetter*>(
 298           base::subtle::Acquire_Load(&g_context));
 299
 300   // Browser shutdown will cause the context to be reset to NULL.
 301   if (!context)
 302     return false;
 303
 304   // Run a blocking event loop to match the win inet implementation.
 305   scoped_ptr<base::MessageLoop> message_loop;
 306   // Ensure that we have a MessageLoop.
 307   if (!base::MessageLoop::current())
 308     message_loop.reset(new base::MessageLoop);
 309   base::RunLoop loop;
 310   FinancialPingUrlFetcherDelegate delegate(loop.QuitClosure());
 311
 312   std::string url = base::StringPrintf("http://%s:%d%s",
 313                                        kFinancialServer, kFinancialPort,
 314                                        request);
 315
 316   scoped_ptr<net::URLFetcher> fetcher(net::URLFetcher::Create(
 317       GURL(url), net::URLFetcher::GET, &delegate));
 318
 319   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE |
 320                         net::LOAD_DO_NOT_SEND_AUTH_DATA |
 321                         net::LOAD_DO_NOT_PROMPT_FOR_LOGIN |
 322                         net::LOAD_DO_NOT_SEND_COOKIES |
 323                         net::LOAD_DO_NOT_SAVE_COOKIES);
 324
 325   // Ensure rlz_lib::SetURLRequestContext() has been called before sending
 326   // pings.
 327   fetcher->SetRequestContext(context);
 328
 329   base::WeakPtrFactory<base::RunLoop> weak(&loop);
 330
 331   const base::TimeDelta kTimeout = base::TimeDelta::FromMinutes(5);
 332   base::MessageLoop::ScopedNestableTaskAllower allow_nested(
 333       base::MessageLoop::current());
 334   base::MessageLoop::current()->PostTask(
 335       FROM_HERE,
 336       base::Bind(&ShutdownCheck, weak.GetWeakPtr()));
 337   base::MessageLoop::current()->PostTask(
 338       FROM_HERE,
 339       base::Bind(&net::URLFetcher::Start, base::Unretained(fetcher.get())));
 340   base::MessageLoop::current()->PostDelayedTask(
 341       FROM_HERE, loop.QuitClosure(), kTimeout);
 342
 343   loop.Run();
 344
 345   if (fetcher->GetResponseCode() != 200)
 346     return false;
 347
 348   return fetcher->GetResponseAsString(response);
 349 #endif
 350 }
 351
 352 bool FinancialPing::IsPingTime(Product product, bool no_delay) {
 353   ScopedRlzValueStoreLock lock;
 354   RlzValueStore* store = lock.GetStore();
 355   if (!store || !store->HasAccess(RlzValueStore::kReadAccess))
 356     return false;
 357
 358   int64 last_ping = 0;
 359   if (!store->ReadPingTime(product, &last_ping))
 360     return true;
 361
 362   uint64 now = GetSystemTimeAsInt64();
 363   int64 interval = now - last_ping;
 364
 365   // If interval is negative, clock was probably reset. So ping.
 366   if (interval < 0)
 367     return true;
 368
 369   // Check if this product has any unreported events.
 370   char cgi[kMaxCgiLength + 1];
 371   cgi[0] = 0;
 372   bool has_events = GetProductEventsAsCgi(product, cgi, arraysize(cgi));
 373   if (no_delay && has_events)
 374     return true;
 375
 376   return interval >= (has_events ? kEventsPingInterval : kNoEventsPingInterval);
 377 }
 378
 379
 380 bool FinancialPing::UpdateLastPingTime(Product product) {
 381   ScopedRlzValueStoreLock lock;
 382   RlzValueStore* store = lock.GetStore();
 383   if (!store || !store->HasAccess(RlzValueStore::kWriteAccess))
 384     return false;
 385
 386   uint64 now = GetSystemTimeAsInt64();
 387   return store->WritePingTime(product, now);
 388 }
 389
 390
 391 bool FinancialPing::ClearLastPingTime(Product product) {
 392   ScopedRlzValueStoreLock lock;
 393   RlzValueStore* store = lock.GetStore();
 394   if (!store || !store->HasAccess(RlzValueStore::kWriteAccess))
 395     return false;
 396   return store->ClearPingTime(product);
 397 }
 398
 399 #if defined(RLZ_NETWORK_IMPLEMENTATION_CHROME_NET)
 400 namespace test {
 401
 402 void ResetSendFinancialPingInterrupted() {
 403   send_financial_ping_interrupted_for_test = false;
 404 }
 405
 406 bool WasSendFinancialPingInterrupted() {
 407   return send_financial_ping_interrupted_for_test;
 408 }
 409
 410 }  // namespace test
 411 #endif
 412
 413 }  // namespace rlz_lib