Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 444 insertions, 0 deletions

diff --git a/toolkit/crashreporter/google-breakpad/src/tools/windows/symupload/symupload.cc b/toolkit/crashreporter/google-breakpad/src/tools/windows/symupload/symupload.cc
new file mode 100644
index 0000000000..7e3029326d
--- /dev/null
+++ b/toolkit/crashreporter/google-breakpad/src/tools/windows/symupload/symupload.cc
@@ -0,0 +1,394 @@
+// Copyright (c) 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Tool to upload an exe/dll and its associated symbols to an HTTP server.
+// The PDB file is located automatically, using the path embedded in the
+// executable.  The upload is sent as a multipart/form-data POST request,
+// with the following parameters:
+//  code_file: the basename of the module, e.g. "app.exe"
+//  debug_file: the basename of the debugging file, e.g. "app.pdb"
+//  debug_identifier: the debug file's identifier, usually consisting of
+//                    the guid and age embedded in the pdb, e.g.
+//                    "11111111BBBB3333DDDD555555555555F"
+//  product: the HTTP-friendly product name, e.g. "MyApp"
+//  version: the file version of the module, e.g. "1.2.3.4"
+//  os: the operating system that the module was built for, always
+//      "windows" in this implementation.
+//  cpu: the CPU that the module was built for, typically "x86".
+//  symbol_file: the contents of the breakpad-format symbol file
+
+#include <windows.h>
+#include <dbghelp.h>
+#include <wininet.h>
+
+#include <cstdio>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "common/windows/string_utils-inl.h"
+
+#include "common/windows/http_upload.h"
+#include "common/windows/pdb_source_line_writer.h"
+#include "common/windows/symbol_collector_client.h"
+
+using std::string;
+using std::wstring;
+using std::vector;
+using std::map;
+using google_breakpad::HTTPUpload;
+using google_breakpad::SymbolCollectorClient;
+using google_breakpad::SymbolStatus;
+using google_breakpad::UploadUrlResponse;
+using google_breakpad::CompleteUploadResult;
+using google_breakpad::PDBModuleInfo;
+using google_breakpad::PDBSourceLineWriter;
+using google_breakpad::WindowsStringUtils;
+
+// Extracts the file version information for the given filename,
+// as a string, for example, "1.2.3.4".  Returns true on success.
+static bool GetFileVersionString(const wchar_t *filename, wstring *version) {
+  DWORD handle;
+  DWORD version_size = GetFileVersionInfoSize(filename, &handle);
+  if (version_size < sizeof(VS_FIXEDFILEINFO)) {
+    return false;
+  }
+
+  vector<char> version_info(version_size);
+  if (!GetFileVersionInfo(filename, handle, version_size, &version_info[0])) {
+    return false;
+  }
+
+  void *file_info_buffer = NULL;
+  unsigned int file_info_length;
+  if (!VerQueryValue(&version_info[0], L"\\",
+                     &file_info_buffer, &file_info_length)) {
+    return false;
+  }
+
+  // The maximum value of each version component is 65535 (0xffff),
+  // so the max length is 24, including the terminating null.
+  wchar_t ver_string[24];
+  VS_FIXEDFILEINFO *file_info =
+    reinterpret_cast<VS_FIXEDFILEINFO*>(file_info_buffer);
+  swprintf(ver_string, sizeof(ver_string) / sizeof(ver_string[0]),
+           L"%d.%d.%d.%d",
+           file_info->dwFileVersionMS >> 16,
+           file_info->dwFileVersionMS & 0xffff,
+           file_info->dwFileVersionLS >> 16,
+           file_info->dwFileVersionLS & 0xffff);
+
+  // remove when VC++7.1 is no longer supported
+  ver_string[sizeof(ver_string) / sizeof(ver_string[0]) - 1] = L'\0';
+
+  *version = ver_string;
+  return true;
+}
+
+// Creates a new temporary file and writes the symbol data from the given
+// exe/dll file to it.  Returns the path to the temp file in temp_file_path
+// and information about the pdb in pdb_info.
+static bool DumpSymbolsToTempFile(const wchar_t *file,
+                                  wstring *temp_file_path,
+                                  PDBModuleInfo *pdb_info) {
+  google_breakpad::PDBSourceLineWriter writer;
+  // Use EXE_FILE to get information out of the exe/dll in addition to the
+  // pdb.  The name and version number of the exe/dll are of value, and
+  // there's no way to locate an exe/dll given a pdb.
+  if (!writer.Open(file, PDBSourceLineWriter::EXE_FILE)) {
+    return false;
+  }
+
+  wchar_t temp_path[_MAX_PATH];
+  if (GetTempPath(_MAX_PATH, temp_path) == 0) {
+    return false;
+  }
+
+  wchar_t temp_filename[_MAX_PATH];
+  if (GetTempFileName(temp_path, L"sym", 0, temp_filename) == 0) {
+    return false;
+  }
+
+  FILE *temp_file = NULL;
+#if _MSC_VER >= 1400  // MSVC 2005/8
+  if (_wfopen_s(&temp_file, temp_filename, L"w") != 0)
+#else  // _MSC_VER >= 1400
+  // _wfopen_s was introduced in MSVC8.  Use _wfopen for earlier environments.
+  // Don't use it with MSVC8 and later, because it's deprecated.
+  if (!(temp_file = _wfopen(temp_filename, L"w")))
+#endif  // _MSC_VER >= 1400
+  {
+    return false;
+  }
+
+  bool success = writer.WriteSymbols(temp_file);
+  fclose(temp_file);
+  if (!success) {
+    _wunlink(temp_filename);
+    return false;
+  }
+
+  *temp_file_path = temp_filename;
+
+  return writer.GetModuleInfo(pdb_info);
+}
+
+static bool DoSymUploadV2(
+    const wchar_t* api_url,
+    const wchar_t* api_key,
+    const wstring& debug_file,
+    const wstring& debug_id,
+    const wstring& symbol_file,
+    bool force) {
+  wstring url(api_url);
+  wstring key(api_key);
+
+  if (!force) {
+    SymbolStatus symbolStatus = SymbolCollectorClient::CheckSymbolStatus(
+      url,
+      key,
+      debug_file,
+      debug_id);
+    if (symbolStatus == SymbolStatus::Found) {
+      wprintf(L"Symbol file already exists, upload aborted."
+        L" Use \"-f\" to overwrite.\n");
+      return true;
+    }
+    else if (symbolStatus == SymbolStatus::Unknown) {
+      wprintf(L"Failed to get check for existing symbol.\n");
+      return false;
+    }
+  }
+
+  UploadUrlResponse uploadUrlResponse;
+  if (!SymbolCollectorClient::CreateUploadUrl(
+      url,
+      key,
+      &uploadUrlResponse)) {
+    wprintf(L"Failed to create upload URL.\n");
+    return false;
+  }
+
+  wstring signed_url = uploadUrlResponse.upload_url;
+  wstring upload_key = uploadUrlResponse.upload_key;
+  wstring response;
+  int response_code;
+  bool success = HTTPUpload::SendPutRequest(
+    signed_url,
+    symbol_file,
+    /* timeout = */ NULL,
+    &response,
+    &response_code);
+  if (!success) {
+    wprintf(L"Failed to send symbol file.\n");
+    wprintf(L"Response code: %ld\n", response_code);
+    wprintf(L"Response:\n");
+    wprintf(L"%s\n", response.c_str());
+    return false;
+  }
+  else if (response_code == 0) {
+    wprintf(L"Failed to send symbol file: No response code\n");
+    return false;
+  }
+  else if (response_code != 200) {
+    wprintf(L"Failed to send symbol file: Response code %ld\n", response_code);
+    wprintf(L"Response:\n");
+    wprintf(L"%s\n", response.c_str());
+    return false;
+  }
+
+  CompleteUploadResult completeUploadResult =
+    SymbolCollectorClient::CompleteUpload(
+      url,
+      key,
+      upload_key,
+      debug_file,
+      debug_id);
+  if (completeUploadResult == CompleteUploadResult::Error) {
+    wprintf(L"Failed to complete upload.\n");
+    return false;
+  }
+  else if (completeUploadResult == CompleteUploadResult::DuplicateData) {
+    wprintf(L"Uploaded file checksum matched existing file checksum,"
+      L" no change necessary.\n");
+  }
+  else {
+    wprintf(L"Successfully sent the symbol file.\n");
+  }
+
+  return true;
+}
+
+__declspec(noreturn) void printUsageAndExit() {
+  wprintf(L"Usage:\n\n"
+          L"    symupload [--timeout NN] [--product product_name] ^\n"
+          L"              <file.exe|file.dll> <symbol upload URL> ^\n"
+          L"              [...<symbol upload URLs>]\n\n");
+  wprintf(L"  - Timeout is in milliseconds, or can be 0 to be unlimited.\n");
+  wprintf(L"  - product_name is an HTTP-friendly product name. It must only\n"
+          L"    contain an ascii subset: alphanumeric and punctuation.\n"
+          L"    This string is case-sensitive.\n\n");
+  wprintf(L"Example:\n\n"
+          L"    symupload.exe --timeout 0 --product Chrome ^\n"
+          L"        chrome.dll http://no.free.symbol.server.for.you\n");
+  wprintf(L"\n");
+  wprintf(L"sym-upload-v2 usage:\n"
+          L"    symupload -p [-f] <file.exe|file.dll> <API-URL> <API-key>\n");
+  wprintf(L"\n");
+  wprintf(L"sym_upload_v2 Options:\n");
+  wprintf(L"    <API-URL> is the sym_upload_v2 API URL.\n");
+  wprintf(L"    <API-key> is a secret used to authenticate with the API.\n");
+  wprintf(L"    -p:\t Use sym_upload_v2 protocol.\n");
+  wprintf(L"    -f:\t Force symbol upload if already exists.\n");
+
+  exit(0);
+}
+
+int wmain(int argc, wchar_t *argv[]) {
+  const wchar_t *module;
+  const wchar_t *product = nullptr;
+  int timeout = -1;
+  int currentarg = 1;
+  bool use_sym_upload_v2 = false;
+  bool force = false;
+  const wchar_t* api_url = nullptr;
+  const wchar_t* api_key = nullptr;
+  while (argc > currentarg + 1) {
+    if (!wcscmp(L"--timeout", argv[currentarg])) {
+      timeout = _wtoi(argv[currentarg + 1]);
+      currentarg += 2;
+      continue;
+    }
+    if (!wcscmp(L"--product", argv[currentarg])) {
+      product = argv[currentarg + 1];
+      currentarg += 2;
+      continue;
+    }
+    if (!wcscmp(L"-p", argv[currentarg])) {
+      use_sym_upload_v2 = true;
+      ++currentarg;
+      continue;
+    }
+    if (!wcscmp(L"-f", argv[currentarg])) {
+      force = true;
+      ++currentarg;
+      continue;
+    }
+    break;
+  }
+
+  if (argc >= currentarg + 2)
+    module = argv[currentarg++];
+  else
+    printUsageAndExit();
+
+  wstring symbol_file;
+  PDBModuleInfo pdb_info;
+  if (!DumpSymbolsToTempFile(module, &symbol_file, &pdb_info)) {
+    fwprintf(stderr, L"Could not get symbol data from %s\n", module);
+    return 1;
+  }
+
+  wstring code_file = WindowsStringUtils::GetBaseName(wstring(module));
+  wstring file_version;
+  // Don't make a missing version a hard error.  Issue a warning, and let the
+  // server decide whether to reject files without versions.
+  if (!GetFileVersionString(module, &file_version)) {
+    fwprintf(stderr, L"Warning: Could not get file version for %s\n", module);
+  }
+
+  bool success = true;
+
+  if (use_sym_upload_v2) {
+    if (argc >= currentarg + 2) {
+      api_url = argv[currentarg++];
+      api_key = argv[currentarg++];
+
+      success = DoSymUploadV2(
+        api_url,
+        api_key,
+        pdb_info.debug_file,
+        pdb_info.debug_identifier,
+        symbol_file,
+        force);
+    } else {
+      printUsageAndExit();
+    }
+  } else {
+    map<wstring, wstring> parameters;
+    parameters[L"code_file"] = code_file;
+    parameters[L"debug_file"] = pdb_info.debug_file;
+    parameters[L"debug_identifier"] = pdb_info.debug_identifier;
+    parameters[L"os"] = L"windows";  // This version of symupload is Windows-only
+    parameters[L"cpu"] = pdb_info.cpu;
+
+    map<wstring, wstring> files;
+    files[L"symbol_file"] = symbol_file;
+
+    if (!file_version.empty()) {
+      parameters[L"version"] = file_version;
+    }
+
+    // Don't make a missing product name a hard error.  Issue a warning and let
+    // the server decide whether to reject files without product name.
+    if (product) {
+      parameters[L"product"] = product;
+    }
+    else {
+      fwprintf(
+        stderr,
+        L"Warning: No product name (flag --product) was specified for %s\n",
+        module);
+    }
+
+    while (currentarg < argc) {
+      int response_code;
+      if (!HTTPUpload::SendMultipartPostRequest(argv[currentarg], parameters, files,
+          timeout == -1 ? NULL : &timeout,
+          nullptr, &response_code)) {
+        success = false;
+        fwprintf(stderr,
+          L"Symbol file upload to %s failed. Response code = %ld\n",
+          argv[currentarg], response_code);
+      }
+      currentarg++;
+    }
+  }
+
+  _wunlink(symbol_file.c_str());
+
+  if (success) {
+    wprintf(L"Uploaded breakpad symbols for windows-%s/%s/%s (%s %s)\n",
+            pdb_info.cpu.c_str(), pdb_info.debug_file.c_str(),
+            pdb_info.debug_identifier.c_str(), code_file.c_str(),
+            file_version.c_str());
+  }
+
+  return success ? 0 : 1;
+}
diff --git a/toolkit/crashreporter/google-breakpad/src/tools/windows/symupload/symupload.gyp b/toolkit/crashreporter/google-breakpad/src/tools/windows/symupload/symupload.gyp
new file mode 100644
index 0000000000..4567a4bdfd
--- /dev/null
+++ b/toolkit/crashreporter/google-breakpad/src/tools/windows/symupload/symupload.gyp
@@ -0,0 +1,50 @@
+# Copyright 2013 Google Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+{
+  'includes': [
+    '../../../build/common.gypi',
+  ],
+  'targets': [
+    {
+      'target_name': 'symupload',
+      'type': 'executable',
+      'sources': [
+        'symupload.cc',
+      ],
+      'dependencies': [
+        '../../../common/windows/common_windows.gyp:common_windows_lib',
+      ],
+      'msvs_settings': {
+        'VCLinkerTool': {
+          'LargeAddressAware': '2',
+        },
+      },
+    },
+  ],
+}