Add contib/libs/breakpad to export

commit_hash:9d85255f8d9249f14105e4626bf4484805b8aed4

1 files changed, 284 insertions, 0 deletions

diff --git a/contrib/libs/breakpad/src/common/linux/symbol_upload.cc b/contrib/libs/breakpad/src/common/linux/symbol_upload.cc
new file mode 100644
index 0000000000..1d5ff71965
--- /dev/null
+++ b/contrib/libs/breakpad/src/common/linux/symbol_upload.cc
@@ -0,0 +1,284 @@
+// Copyright (c) 2011 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.
+
+// symbol_upload.cc: implemented google_breakpad::sym_upload::Start, a helper
+// function for linux symbol upload tool.
+
+#include "common/linux/symbol_upload.h"
+
+#include <assert.h>
+#include <stdio.h>
+
+#include <functional>
+#include <iostream>
+#include <vector>
+
+#include "common/linux/http_upload.h"
+#include "common/linux/libcurl_wrapper.h"
+#include "common/linux/symbol_collector_client.h"
+
+namespace google_breakpad {
+namespace sym_upload {
+
+void TokenizeByChar(const string& source_string, int c,
+                    std::vector<string>* results) {
+  assert(results);
+  string::size_type cur_pos = 0, next_pos = 0;
+  while ((next_pos = source_string.find(c, cur_pos)) != string::npos) {
+    if (next_pos != cur_pos)
+      results->push_back(source_string.substr(cur_pos, next_pos - cur_pos));
+    cur_pos = next_pos + 1;
+  }
+  if (cur_pos < source_string.size() && next_pos != cur_pos)
+    results->push_back(source_string.substr(cur_pos));
+}
+
+//=============================================================================
+// Parse out the module line which have 5 parts.
+// MODULE <os> <cpu> <uuid> <module-name>
+bool ModuleDataForSymbolFile(const string& file,
+                             std::vector<string>* module_parts) {
+  assert(module_parts);
+  const size_t kModulePartNumber = 5;
+  FILE* fp = fopen(file.c_str(), "r");
+  if (fp) {
+    char buffer[1024];
+    if (fgets(buffer, sizeof(buffer), fp)) {
+      string line(buffer);
+      string::size_type line_break_pos = line.find_first_of('\n');
+      if (line_break_pos == string::npos) {
+        assert(0 && "The file is invalid!");
+        fclose(fp);
+        return false;
+      }
+      line.resize(line_break_pos);
+      const char kDelimiter = ' ';
+      TokenizeByChar(line, kDelimiter, module_parts);
+      if (module_parts->size() != kModulePartNumber)
+        module_parts->clear();
+    }
+    fclose(fp);
+  }
+
+  return module_parts->size() == kModulePartNumber;
+}
+
+//=============================================================================
+string CompactIdentifier(const string& uuid) {
+  std::vector<string> components;
+  TokenizeByChar(uuid, '-', &components);
+  string result;
+  for (size_t i = 0; i < components.size(); ++i)
+    result += components[i];
+  return result;
+}
+
+// |options| describes the current sym_upload options.
+// |module_parts| contains the strings parsed from the MODULE entry of the
+// Breakpad symbol file being uploaded.
+// |compacted_id| is the debug_id from the MODULE entry of the Breakpad symbol
+// file being uploaded, with all hyphens removed.
+bool SymUploadV1Start(
+    const Options& options,
+    std::vector<string> module_parts,
+    const string& compacted_id) {
+  std::map<string, string> parameters;
+  // Add parameters
+  if (!options.version.empty())
+    parameters["version"] = options.version;
+
+  // MODULE <os> <cpu> <uuid> <module-name>
+  // 0      1    2     3      4
+  parameters["os"] = module_parts[1];
+  parameters["cpu"] = module_parts[2];
+  parameters["debug_file"] = module_parts[4];
+  parameters["code_file"] = module_parts[4];
+  parameters["debug_identifier"] = compacted_id;
+
+  std::map<string, string> files;
+  files["symbol_file"] = options.symbolsPath;
+
+  string response, error;
+  long response_code;
+  bool success = HTTPUpload::SendRequest(options.uploadURLStr,
+                                         parameters,
+                                         files,
+                                         options.proxy,
+                                         options.proxy_user_pwd,
+                                         /*ca_certificate_file=*/"",
+                                         &response,
+                                         &response_code,
+                                         &error);
+
+  if (!success) {
+    printf("Failed to send symbol file: %s\n", error.c_str());
+    printf("Response code: %ld\n", response_code);
+    printf("Response:\n");
+    printf("%s\n", response.c_str());
+  } else if (response_code == 0) {
+    printf("Failed to send symbol file: No response code\n");
+  } else if (response_code != 200) {
+    printf("Failed to send symbol file: Response code %ld\n", response_code);
+    printf("Response:\n");
+    printf("%s\n", response.c_str());
+  } else {
+    printf("Successfully sent the symbol file.\n");
+  }
+
+  return success;
+}
+
+// |options| describes the current sym_upload options.
+// |code_id| is the basename of the module for which symbols are being
+// uploaded.
+// |debug_id| is the debug_id of the module for which symbols are being
+// uploaded.
+bool SymUploadV2Start(
+    const Options& options,
+    const string& code_file,
+    const string& debug_id,
+    const string& type) {
+  google_breakpad::LibcurlWrapper libcurl_wrapper;
+  if (!libcurl_wrapper.Init()) {
+    printf("Failed to init google_breakpad::LibcurlWrapper.\n");
+    return false;
+  }
+
+  if (!options.force) {
+    SymbolStatus symbolStatus = SymbolCollectorClient::CheckSymbolStatus(
+        &libcurl_wrapper,
+        options.uploadURLStr,
+        options.api_key,
+        code_file,
+        debug_id);
+    if (symbolStatus == SymbolStatus::Found) {
+      printf("Symbol file already exists, upload aborted."
+          " Use \"-f\" to overwrite.\n");
+      return true;
+    } else if (symbolStatus == SymbolStatus::Unknown) {
+      printf("Failed to check for existing symbol.\n");
+      return false;
+    }
+  }
+
+  UploadUrlResponse uploadUrlResponse;
+  if (!SymbolCollectorClient::CreateUploadUrl(
+      &libcurl_wrapper,
+      options.uploadURLStr,
+      options.api_key,
+      &uploadUrlResponse)) {
+    printf("Failed to create upload URL.\n");
+    return false;
+  }
+
+  string signed_url = uploadUrlResponse.upload_url;
+  string upload_key = uploadUrlResponse.upload_key;
+  string header;
+  string response;
+  long response_code;
+
+  if (!libcurl_wrapper.SendPutRequest(signed_url,
+                                      options.symbolsPath,
+                                      &response_code,
+                                      &header,
+                                      &response)) {
+    printf("Failed to send symbol file.\n");
+    printf("Response code: %ld\n", response_code);
+    printf("Response:\n");
+    printf("%s\n", response.c_str());
+    return false;
+  } else if (response_code == 0) {
+    printf("Failed to send symbol file: No response code\n");
+    return false;
+  } else if (response_code != 200) {
+    printf("Failed to send symbol file: Response code %ld\n", response_code);
+    printf("Response:\n");
+    printf("%s\n", response.c_str());
+    return false;
+  }
+
+  CompleteUploadResult completeUploadResult =
+      SymbolCollectorClient::CompleteUpload(&libcurl_wrapper,
+                                            options.uploadURLStr,
+                                            options.api_key,
+                                            upload_key,
+                                            code_file,
+                                            debug_id,
+                                            type);
+  if (completeUploadResult == CompleteUploadResult::Error) {
+    printf("Failed to complete upload.\n");
+    return false;
+  } else if (completeUploadResult == CompleteUploadResult::DuplicateData) {
+    printf("Uploaded file checksum matched existing file checksum,"
+      " no change necessary.\n");
+  } else {
+    printf("Successfully sent the symbol file.\n");
+  }
+
+  return true;
+}
+
+//=============================================================================
+void Start(Options* options) {
+  if (options->upload_protocol == UploadProtocol::SYM_UPLOAD_V2) {
+    string code_file;
+    string debug_id;
+    string type;
+
+    if (options->type.empty() || options->type == kBreakpadSymbolType) {
+      // Breakpad upload so read these from input file.
+      std::vector<string> module_parts;
+      if (!ModuleDataForSymbolFile(options->symbolsPath, &module_parts)) {
+        fprintf(stderr, "Failed to parse symbol file!\n");
+        return;
+      }
+      code_file = module_parts[4];
+      debug_id = CompactIdentifier(module_parts[3]);
+      type = kBreakpadSymbolType;
+    } else {
+      // Native upload so these must be explicitly set.
+      code_file = options->code_file;
+      debug_id = options->debug_id;
+      type = options->type;
+    }
+
+    options->success = SymUploadV2Start(*options, code_file, debug_id, type);
+  } else {
+    std::vector<string> module_parts;
+    if (!ModuleDataForSymbolFile(options->symbolsPath, &module_parts)) {
+      fprintf(stderr, "Failed to parse symbol file!\n");
+      return;
+    }
+    const string compacted_id = CompactIdentifier(module_parts[3]);
+    options->success = SymUploadV1Start(*options, module_parts, compacted_id);
+  }
+}
+
+}  // namespace sym_upload
+}  // namespace google_breakpad