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#include "chrome/browser/feedback/feedback_util.h"
6
7#include <sstream>
8#include <string>
9#include <vector>
10
11#include "base/bind.h"
12#include "base/command_line.h"
13#include "base/file_util.h"
14#include "base/file_version_info.h"
15#include "base/memory/singleton.h"
16#include "base/message_loop/message_loop.h"
17#include "base/strings/stringprintf.h"
18#include "base/strings/utf_string_conversions.h"
19#include "base/win/windows_version.h"
20#include "chrome/browser/browser_process.h"
21#include "chrome/browser/metrics/variations/variations_http_header_provider.h"
22#include "chrome/browser/profiles/profile.h"
23#include "chrome/browser/safe_browsing/safe_browsing_util.h"
24#include "chrome/browser/ui/browser_list.h"
25#include "chrome/common/chrome_switches.h"
26#include "chrome/common/chrome_version_info.h"
27#include "chrome/common/metrics/metrics_log_manager.h"
28#include "content/public/browser/browser_thread.h"
29#include "content/public/browser/navigation_controller.h"
30#include "content/public/browser/web_contents.h"
31#include "content/public/common/content_client.h"
32#include "grit/generated_resources.h"
33#include "grit/locale_settings.h"
34#include "grit/theme_resources.h"
35#include "net/base/load_flags.h"
36#include "net/http/http_request_headers.h"
37#include "net/url_request/url_fetcher.h"
38#include "net/url_request/url_fetcher_delegate.h"
39#include "net/url_request/url_request_status.h"
40#include "third_party/icu/source/common/unicode/locid.h"
41#include "third_party/zlib/google/zip.h"
42#include "ui/base/l10n/l10n_util.h"
43#include "url/gurl.h"
44
45using content::WebContents;
46
47namespace {
48const base::FilePath::CharType kLogsFilename[] =
49    FILE_PATH_LITERAL("system_logs.txt");
50}
51
52namespace chrome {
53const char kAppLauncherCategoryTag[] = "AppLauncher";
54}  // namespace chrome
55
56const int kFeedbackVersion = 1;
57
58const char kReportPhishingUrl[] =
59    "http://www.google.com/safebrowsing/report_phish/";
60
61// URL to post bug reports to.
62const char kFeedbackPostUrl[] =
63    "https://www.google.com/tools/feedback/chrome/__submit";
64
65const char kProtBufMimeType[] = "application/x-protobuf";
66const char kPngMimeType[] = "image/png";
67
68// Tags we use in product specific data
69const char kChromeVersionTag[] = "CHROME VERSION";
70const char kOsVersionTag[] = "OS VERSION";
71
72const int kHttpPostSuccessNoContent = 204;
73const int kHttpPostFailNoConnection = -1;
74const int kHttpPostFailClientError = 400;
75const int kHttpPostFailServerError = 500;
76
77const int64 kInitialRetryDelay = 900000;  // 15 minutes
78const int64 kRetryDelayIncreaseFactor = 2;
79const int64 kRetryDelayLimit = 14400000;  // 4 hours
80
81#if defined(OS_CHROMEOS)
82const size_t kFeedbackMaxLength = 4 * 1024;
83const size_t kFeedbackMaxLineCount = 40;
84
85const char kArbitraryMimeType[] = "application/octet-stream";
86const char kLogsAttachmentName[] = "system_logs.zip";
87
88const char kTimestampTag[] = "TIMESTAMP";
89
90const int kChromeOSProductId = 208;
91#endif
92
93const int kChromeBrowserProductId = 237;
94
95// Simple net::URLFetcherDelegate to clean up URLFetcher on completion.
96class FeedbackUtil::PostCleanup : public net::URLFetcherDelegate {
97 public:
98  PostCleanup(Profile* profile,
99              std::string* post_body,
100              int64 previous_delay) : profile_(profile),
101                                      post_body_(post_body),
102                                      previous_delay_(previous_delay) { }
103  // Overridden from net::URLFetcherDelegate.
104  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
105
106 protected:
107  virtual ~PostCleanup() {}
108
109 private:
110  Profile* profile_;
111  std::string* post_body_;
112  int64 previous_delay_;
113
114  DISALLOW_COPY_AND_ASSIGN(PostCleanup);
115};
116
117// Don't use the data parameter, instead use the pointer we pass into every
118// post cleanup object - that pointer will be deleted and deleted only on a
119// successful post to the feedback server.
120void FeedbackUtil::PostCleanup::OnURLFetchComplete(
121    const net::URLFetcher* source) {
122  std::stringstream error_stream;
123  int response_code = source->GetResponseCode();
124  if (response_code == kHttpPostSuccessNoContent) {
125    // We've sent our report, delete the report data
126    delete post_body_;
127
128    error_stream << "Success";
129  } else {
130    // Uh oh, feedback failed, send it off to retry
131    if (previous_delay_) {
132      if (previous_delay_ < kRetryDelayLimit)
133        previous_delay_ *= kRetryDelayIncreaseFactor;
134    } else {
135      previous_delay_ = kInitialRetryDelay;
136    }
137    FeedbackUtil::DispatchFeedback(profile_, post_body_, previous_delay_);
138
139    // Process the error for debug output
140    if (response_code == kHttpPostFailNoConnection) {
141      error_stream << "No connection to server.";
142    } else if ((response_code > kHttpPostFailClientError) &&
143        (response_code < kHttpPostFailServerError)) {
144      error_stream << "Client error: HTTP response code " << response_code;
145    } else if (response_code > kHttpPostFailServerError) {
146      error_stream << "Server error: HTTP response code " << response_code;
147    } else {
148      error_stream << "Unknown error: HTTP response code " << response_code;
149    }
150  }
151
152  LOG(WARNING) << "FEEDBACK: Submission to feedback server (" <<
153               source->GetURL() << ") status: " << error_stream.str();
154
155  // Delete the URLFetcher.
156  delete source;
157  // And then delete ourselves.
158  delete this;
159}
160
161// static
162void FeedbackUtil::SetOSVersion(std::string* os_version) {
163#if defined(OS_WIN)
164  base::win::OSInfo* os_info = base::win::OSInfo::GetInstance();
165  base::win::OSInfo::VersionNumber version_number = os_info->version_number();
166  *os_version = base::StringPrintf("%d.%d.%d",
167                                   version_number.major,
168                                   version_number.minor,
169                                   version_number.build);
170  int service_pack = os_info->service_pack().major;
171  if (service_pack > 0)
172    os_version->append(base::StringPrintf("Service Pack %d", service_pack));
173#elif defined(OS_MACOSX)
174  *os_version = base::SysInfo::OperatingSystemVersion();
175#else
176  *os_version = "unknown";
177#endif
178}
179
180// static
181void FeedbackUtil::DispatchFeedback(Profile* profile,
182                                    std::string* post_body,
183                                    int64 delay) {
184  DCHECK(post_body);
185
186  base::MessageLoop::current()->PostDelayedTask(
187      FROM_HERE,
188      base::Bind(&FeedbackUtil::SendFeedback, profile, post_body, delay),
189      base::TimeDelta::FromMilliseconds(delay));
190}
191
192// static
193void FeedbackUtil::SendFeedback(Profile* profile,
194                                std::string* post_body,
195                                int64 previous_delay) {
196  DCHECK(post_body);
197
198  GURL post_url;
199  if (CommandLine::ForCurrentProcess()->
200      HasSwitch(switches::kFeedbackServer))
201    post_url = GURL(CommandLine::ForCurrentProcess()->
202        GetSwitchValueASCII(switches::kFeedbackServer));
203  else
204    post_url = GURL(kFeedbackPostUrl);
205
206  net::URLFetcher* fetcher = net::URLFetcher::Create(
207      post_url, net::URLFetcher::POST,
208      new FeedbackUtil::PostCleanup(profile, post_body, previous_delay));
209  fetcher->SetRequestContext(profile->GetRequestContext());
210  fetcher->SetLoadFlags(
211      net::LOAD_DO_NOT_SAVE_COOKIES | net::LOAD_DO_NOT_SEND_COOKIES);
212
213  net::HttpRequestHeaders headers;
214  chrome_variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders(
215      fetcher->GetOriginalURL(), profile->IsOffTheRecord(), false, &headers);
216  fetcher->SetExtraRequestHeaders(headers.ToString());
217
218  fetcher->SetUploadData(std::string(kProtBufMimeType), *post_body);
219  fetcher->Start();
220}
221
222
223// static
224void FeedbackUtil::AddFeedbackData(
225    userfeedback::ExtensionSubmit* feedback_data,
226    const std::string& key, const std::string& value) {
227  // Don't bother with empty keys or values
228  if (key == "" || value == "") return;
229  // Create log_value object and add it to the web_data object
230  userfeedback::ProductSpecificData log_value;
231  log_value.set_key(key);
232  log_value.set_value(value);
233  userfeedback::WebData* web_data = feedback_data->mutable_web_data();
234  *(web_data->add_product_specific_data()) = log_value;
235}
236
237#if defined(OS_CHROMEOS)
238bool FeedbackUtil::ValidFeedbackSize(const std::string& content) {
239  if (content.length() > kFeedbackMaxLength)
240    return false;
241  const size_t line_count = std::count(content.begin(), content.end(), '\n');
242  if (line_count > kFeedbackMaxLineCount)
243    return false;
244  return true;
245}
246#endif
247
248// static
249void FeedbackUtil::SendReport(scoped_refptr<FeedbackData> data) {
250  if (!data.get()) {
251    LOG(ERROR) << "FeedbackUtil::SendReport called with NULL data!";
252    NOTREACHED();
253    return;
254  }
255
256  // Create google feedback protocol buffer objects
257  userfeedback::ExtensionSubmit feedback_data;
258  // type id set to 0, unused field but needs to be initialized to 0
259  feedback_data.set_type_id(0);
260
261  userfeedback::CommonData* common_data = feedback_data.mutable_common_data();
262  userfeedback::WebData* web_data = feedback_data.mutable_web_data();
263
264  // Set our user agent.
265  userfeedback::Navigator* navigator = web_data->mutable_navigator();
266  navigator->set_user_agent(content::GetUserAgent(GURL()));
267
268  // Set GAIA id to 0. We're not using gaia id's for recording
269  // use feedback - we're using the e-mail field, allows users to
270  // submit feedback from incognito mode and specify any mail id
271  // they wish
272  common_data->set_gaia_id(0);
273
274  // Add the user e-mail to the feedback object
275  common_data->set_user_email(data->user_email());
276
277  // Add the description to the feedback object
278  common_data->set_description(data->description());
279
280  // Add the language
281  std::string chrome_locale = g_browser_process->GetApplicationLocale();
282  common_data->set_source_description_language(chrome_locale);
283
284  // Set the url
285  web_data->set_url(data->page_url());
286
287  // Add the Chrome version
288  chrome::VersionInfo version_info;
289  if (version_info.is_valid()) {
290    std::string chrome_version = version_info.Name() + " - " +
291        version_info.Version() +
292        " (" + version_info.LastChange() + ")";
293    AddFeedbackData(&feedback_data, std::string(kChromeVersionTag),
294                    chrome_version);
295  }
296
297  // We don't need the OS version for ChromeOS since we get it in
298  // CHROMEOS_RELEASE_VERSION from /etc/lsb-release
299#if !defined(OS_CHROMEOS)
300  // Add OS version (eg, for WinXP SP2: "5.1.2600 Service Pack 2").
301  std::string os_version;
302  SetOSVersion(&os_version);
303  AddFeedbackData(&feedback_data, std::string(kOsVersionTag), os_version);
304#endif
305
306  // Include the page image if we have one.
307  if (data->image().get() && data->image()->size()) {
308    userfeedback::PostedScreenshot screenshot;
309    screenshot.set_mime_type(kPngMimeType);
310    // Set the dimensions of the screenshot
311    userfeedback::Dimensions dimensions;
312    gfx::Rect& screen_size = GetScreenshotSize();
313    dimensions.set_width(static_cast<float>(screen_size.width()));
314    dimensions.set_height(static_cast<float>(screen_size.height()));
315    *(screenshot.mutable_dimensions()) = dimensions;
316
317    int image_data_size = data->image()->size();
318    char* image_data = reinterpret_cast<char*>(&(data->image()->front()));
319    screenshot.set_binary_content(std::string(image_data, image_data_size));
320
321    // Set the screenshot object in feedback
322    *(feedback_data.mutable_screenshot()) = screenshot;
323  }
324
325#if defined(OS_CHROMEOS)
326  if (data->sys_info()) {
327    // Add the product specific data
328    for (chromeos::SystemLogsResponse::const_iterator i =
329        data->sys_info()->begin(); i != data->sys_info()->end(); ++i) {
330      if (ValidFeedbackSize(i->second)) {
331        AddFeedbackData(&feedback_data, i->first, i->second);
332      }
333    }
334
335    if (data->compressed_logs() && data->compressed_logs()->size()) {
336      userfeedback::ProductSpecificBinaryData attachment;
337      attachment.set_mime_type(kArbitraryMimeType);
338      attachment.set_name(kLogsAttachmentName);
339      attachment.set_data(*(data->compressed_logs()));
340      *(feedback_data.add_product_specific_binary_data()) = attachment;
341    }
342  }
343
344  if (data->timestamp() != "")
345    AddFeedbackData(&feedback_data, std::string(kTimestampTag),
346                    data->timestamp());
347
348  if (data->attached_filename() != "" &&
349      data->attached_filedata() &&
350      data->attached_filedata()->size()) {
351    userfeedback::ProductSpecificBinaryData attached_file;
352    attached_file.set_mime_type(kArbitraryMimeType);
353    attached_file.set_name(data->attached_filename());
354    attached_file.set_data(*data->attached_filedata());
355    *(feedback_data.add_product_specific_binary_data()) = attached_file;
356  }
357#endif
358
359  // Set our category tag if we have one
360  if (data->category_tag().size())
361    feedback_data.set_bucket(data->category_tag());
362
363  // Set our Chrome specific data
364  userfeedback::ChromeData chrome_data;
365  chrome_data.set_chrome_platform(
366#if defined(OS_CHROMEOS)
367      userfeedback::ChromeData_ChromePlatform_CHROME_OS);
368  userfeedback::ChromeOsData chrome_os_data;
369  chrome_os_data.set_category(
370      userfeedback::ChromeOsData_ChromeOsCategory_OTHER);
371  *(chrome_data.mutable_chrome_os_data()) = chrome_os_data;
372  feedback_data.set_product_id(kChromeOSProductId);
373#else
374      userfeedback::ChromeData_ChromePlatform_CHROME_BROWSER);
375  userfeedback::ChromeBrowserData chrome_browser_data;
376  chrome_browser_data.set_category(
377      userfeedback::ChromeBrowserData_ChromeBrowserCategory_OTHER);
378  *(chrome_data.mutable_chrome_browser_data()) = chrome_browser_data;
379  feedback_data.set_product_id(kChromeBrowserProductId);
380#endif
381
382  *(feedback_data.mutable_chrome_data()) = chrome_data;
383
384  // Serialize our report to a string pointer we can pass around
385  std::string* post_body = new std::string;
386  feedback_data.SerializeToString(post_body);
387
388  // We have the body of our POST, so send it off to the server with 0 delay
389  DispatchFeedback(data->profile(), post_body, 0);
390}
391
392#if defined(FULL_SAFE_BROWSING)
393// static
394void FeedbackUtil::ReportPhishing(WebContents* current_tab,
395                                  const std::string& phishing_url) {
396  current_tab->GetController().LoadURL(
397      safe_browsing_util::GeneratePhishingReportUrl(
398          kReportPhishingUrl, phishing_url,
399          false /* not client-side detection */),
400      content::Referrer(),
401      content::PAGE_TRANSITION_LINK,
402      std::string());
403}
404#endif
405
406static std::vector<unsigned char>* screenshot_png = NULL;
407static gfx::Rect* screenshot_size = NULL;
408
409// static
410std::vector<unsigned char>* FeedbackUtil::GetScreenshotPng() {
411  if (screenshot_png == NULL)
412    screenshot_png = new std::vector<unsigned char>;
413  return screenshot_png;
414}
415
416// static
417void FeedbackUtil::ClearScreenshotPng() {
418  if (screenshot_png)
419    screenshot_png->clear();
420}
421
422// static
423gfx::Rect& FeedbackUtil::GetScreenshotSize() {
424  if (screenshot_size == NULL)
425    screenshot_size = new gfx::Rect();
426  return *screenshot_size;
427}
428
429// static
430void FeedbackUtil::SetScreenshotSize(const gfx::Rect& rect) {
431  gfx::Rect& screen_size = GetScreenshotSize();
432  screen_size = rect;
433}
434
435// static
436bool FeedbackUtil::ZipString(const std::string& logs,
437                             std::string* compressed_logs) {
438  base::FilePath temp_path;
439  base::FilePath zip_file;
440
441  // Create a temporary directory, put the logs into a file in it. Create
442  // another temporary file to receive the zip file in.
443  if (!file_util::CreateNewTempDirectory(FILE_PATH_LITERAL(""), &temp_path))
444    return false;
445  if (file_util::WriteFile(temp_path.Append(kLogsFilename),
446                           logs.c_str(), logs.size()) == -1)
447    return false;
448  if (!file_util::CreateTemporaryFile(&zip_file))
449    return false;
450
451  if (!zip::Zip(temp_path, zip_file, false))
452    return false;
453
454  if (!file_util::ReadFileToString(zip_file, compressed_logs))
455    return false;
456
457  return true;
458}
459