// 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 #include #include #include #include #include #include #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 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(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" ^\n" L" [...]\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] \n"); wprintf(L"\n"); wprintf(L"sym_upload_v2 Options:\n"); wprintf(L" is the sym_upload_v2 API URL.\n"); wprintf(L" 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 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 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; }