编译好的Crashpad库 (x86 & x64) - Release & Debug 版本

// Copyright 2014 The Crashpad Authors. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef CRASHPAD_CLIENT_CRASHPAD_CLIENT_H_ #define CRASHPAD_CLIENT_CRASHPAD_CLIENT_H_ #include <map> #include <set> #include <string> #include <vector> #include <stdint.h> #include "base/files/file_path.h" #include "base/macros.h" #include "build/build_config.h" #include "util/file/file_io.h" #include "util/misc/capture_context.h" #if defined(OS_APPLE) #include "base/mac/scoped_mach_port.h" #elif defined(OS_WIN) #include <windows.h> #include "util/win/scoped_handle.h" #elif defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_ANDROID) #include <signal.h> #include <ucontext.h> #endif namespace crashpad { #if defined(OS_WIN) void IgnoreNextException(bool value); #endif //! \brief The primary interface for an application to have Crashpad monitor //! it for crashes. class CrashpadClient { public: CrashpadClient(); ~CrashpadClient(); #if defined(OS_WIN) bool StartHandlerForBacktrace(const base::FilePath& handler, const base::FilePath& database, const base::FilePath& metrics_dir, const std::string& url, const std::map<std::string, std::string>& annotations, const std::vector<std::string>& arguments, const std::map<std::string, std::string>& fileAttachments, bool restartable, bool asynchronous_start); #endif //! \brief Starts a Crashpad handler process, performing any necessary //! handshake to configure it. //! //! This method directs crashes to the Crashpad handler. On macOS, this is //! applicable to this process and all subsequent child processes. On Windows, //! child processes must also register by using SetHandlerIPCPipe(). //! //! On macOS, this method starts a Crashpad handler and obtains a Mach send //! right corresponding to a receive right held by the handler process. The //! handler process runs an exception server on this port. This method sets //! the task’s exception port for `EXC_CRASH`, `EXC_RESOURCE`, and `EXC_GUARD` //! exceptions to the Mach send right obtained. The handler will be installed //! with behavior `EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES` and thread //! state flavor `MACHINE_THREAD_STATE`. Exception ports are inherited, so a //! Crashpad handler started here will remain the handler for any child //! processes created after StartHandler() is called. These child processes do //! not need to call StartHandler() or be aware of Crashpad in any way. The //! Crashpad handler will receive crashes from child processes that have //! inherited it as their exception handler even after the process that called //! StartHandler() exits. //! //! On Windows, if \a asynchronous_start is `true`, this function will not //! directly call `CreateProcess()`, making it suitable for use in a //! `DllMain()`. In that case, the handler is started from a background //! thread, deferring the handler's startup. Nevertheless, regardless of the //! value of \a asynchronous_start, after calling this method, the global //! unhandled exception filter is set up, and all crashes will be handled by //! Crashpad. Optionally, use WaitForHandlerStart() to join with the //! background thread and retrieve the status of handler startup. //! //! On Fuchsia, this method binds to the exception port of the current default //! job, and starts a Crashpad handler to monitor that port. //! //! On Linux, this method starts a Crashpad handler, connected to this process //! via an `AF_UNIX` socket pair and installs signal handlers to request crash //! dumps on the client's socket end. //! //! \param[in] handler The path to a Crashpad handler executable. //! \param[in] database The path to a Crashpad database. The handler will be //! started with this path as its `--database` argument. //! \param[in] metrics_dir The path to an already existing directory where //! metrics files can be stored. The handler will be started with this //! path as its `--metrics-dir` argument. //! \param[in] url The URL of an upload server. The handler will be started //! with this URL as its `--url` argument. //! \param[in] annotations Process annotations to set in each crash report. //! The handler will be started with an `--annotation` argument for each //! element in this map. //! \param[in] arguments Additional arguments to pass to the Crashpad handler. //! Arguments passed in other parameters and arguments required to perform //! the handshake are the responsibility of this method, and must not be //! specified in this parameter. //! \param[in] restartable If `true`, the handler will be restarted if it //! dies, if this behavior is supported. This option is not available on //! all platforms, and does not function on all OS versions. If it is //! not supported, it will be ignored. //! \param[out] asynchronous_start If `true`, the handler will be started from //! a background thread. Optionally, WaitForHandlerStart() can be used at //! a suitable time to retreive the result of background startup. This //! option is only used on Windows. //! \param[in] attachments Vector that stores file paths that should be //! captured with each report at the time of the crash. //! //! \return `true` on success, `false` on failure with a message logged. bool StartHandler(const base::FilePath& handler, const base::FilePath& database, const base::FilePath& metrics_dir, const std::string& url, const std::map<std::string, std::string>& annotations, const std::vector<std::string>& arguments, bool restartable, bool asynchronous_start, const std::vector<base::FilePath>& attachments = {}); #if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_CHROMEOS) || DOXYGEN //! \brief Retrieve the socket and process ID for the handler. //! //! `StartHandler()` must have successfully been called before calling this //! method. //! //! \param[out] sock The socket connected to the handler, if not `nullptr`. //! \param[out] pid The handler's process ID, if not `nullptr`. //! \return `true` on success. Otherwise `false` with a message logged. static bool GetHandlerSocket(int* sock, pid_t* pid); //! \brief Sets the socket to a presumably-running Crashpad handler process //! which was started with StartHandler(). //! //! This method installs a signal handler to request crash dumps on \a sock. //! //! \param[in] sock A socket connected to a Crashpad handler. //! \param[in] pid The process ID of the handler, used to set the handler as //! this process' ptracer. 0 indicates it is not necessary to set the //! handler as this process' ptracer. -1 indicates that the handler's //! process ID should be determined by communicating over the socket. bool SetHandlerSocket(ScopedFileHandle sock, pid_t pid); //! \brief Uses `sigaltstack()` to allocate a signal stack for the calling //! thread. //! //! This method allocates an alte