diff --git a/crashrpt/bin/CrashSender1403.exe b/crashrpt/win32/bin/CrashSender1403.exe similarity index 100% rename from crashrpt/bin/CrashSender1403.exe rename to crashrpt/win32/bin/CrashSender1403.exe diff --git a/crashrpt/bin/crashrpt_lang.ini b/crashrpt/win32/bin/crashrpt_lang.ini similarity index 100% rename from crashrpt/bin/crashrpt_lang.ini rename to crashrpt/win32/bin/crashrpt_lang.ini diff --git a/crashrpt/bin/dbghelp.dll b/crashrpt/win32/bin/dbghelp.dll similarity index 100% rename from crashrpt/bin/dbghelp.dll rename to crashrpt/win32/bin/dbghelp.dll diff --git a/crashrpt/include/CrashRpt.h b/crashrpt/win32/include/CrashRpt.h similarity index 100% rename from crashrpt/include/CrashRpt.h rename to crashrpt/win32/include/CrashRpt.h diff --git a/crashrpt/include/CrashRptProbe.h b/crashrpt/win32/include/CrashRptProbe.h similarity index 100% rename from crashrpt/include/CrashRptProbe.h rename to crashrpt/win32/include/CrashRptProbe.h diff --git a/crashrpt/lib/dll/CrashRpt.dll b/crashrpt/win32/lib/dll/CrashRpt.dll similarity index 100% rename from crashrpt/lib/dll/CrashRpt.dll rename to crashrpt/win32/lib/dll/CrashRpt.dll diff --git a/crashrpt/lib/dll/CrashRpt.lib b/crashrpt/win32/lib/dll/CrashRpt.lib similarity index 100% rename from crashrpt/lib/dll/CrashRpt.lib rename to crashrpt/win32/lib/dll/CrashRpt.lib diff --git a/crashrpt/lib/dll/CrashRptD.dll b/crashrpt/win32/lib/dll/CrashRptD.dll similarity index 100% rename from crashrpt/lib/dll/CrashRptD.dll rename to crashrpt/win32/lib/dll/CrashRptD.dll diff --git a/crashrpt/lib/dll/CrashRptD.lib b/crashrpt/win32/lib/dll/CrashRptD.lib similarity index 100% rename from crashrpt/lib/dll/CrashRptD.lib rename to crashrpt/win32/lib/dll/CrashRptD.lib diff --git a/crashrpt/lib/dll/readme.txt b/crashrpt/win32/lib/dll/readme.txt similarity index 100% rename from crashrpt/lib/dll/readme.txt rename to crashrpt/win32/lib/dll/readme.txt diff --git a/crashrpt/lib/static/CrashRptLIB.lib b/crashrpt/win32/lib/static/CrashRptLIB.lib similarity index 100% rename from crashrpt/lib/static/CrashRptLIB.lib rename to crashrpt/win32/lib/static/CrashRptLIB.lib diff --git a/crashrpt/lib/static/CrashRptLIBd.lib b/crashrpt/win32/lib/static/CrashRptLIBd.lib similarity index 100% rename from crashrpt/lib/static/CrashRptLIBd.lib rename to crashrpt/win32/lib/static/CrashRptLIBd.lib diff --git a/crashrpt/lib/static/readme.txt b/crashrpt/win32/lib/static/readme.txt similarity index 100% rename from crashrpt/lib/static/readme.txt rename to crashrpt/win32/lib/static/readme.txt diff --git a/crashrpt/win64/bin/CrashSender1500.exe b/crashrpt/win64/bin/CrashSender1500.exe new file mode 100644 index 0000000..784e294 Binary files /dev/null and b/crashrpt/win64/bin/CrashSender1500.exe differ diff --git a/crashrpt/win64/bin/crashrpt_lang.ini b/crashrpt/win64/bin/crashrpt_lang.ini new file mode 100644 index 0000000..5c0dfbf Binary files /dev/null and b/crashrpt/win64/bin/crashrpt_lang.ini differ diff --git a/crashrpt/win64/bin/dbghelp.dll b/crashrpt/win64/bin/dbghelp.dll new file mode 100644 index 0000000..18d074b Binary files /dev/null and b/crashrpt/win64/bin/dbghelp.dll differ diff --git a/crashrpt/win64/include/CrashRpt.h b/crashrpt/win64/include/CrashRpt.h new file mode 100644 index 0000000..e5eb3e2 --- /dev/null +++ b/crashrpt/win64/include/CrashRpt.h @@ -0,0 +1,1831 @@ +/************************************************************************************* +This file is a part of CrashRpt library. +Copyright (c) 2003-2013 The CrashRpt project authors. All Rights Reserved. + +Use of this source code is governed by a BSD-style license +that can be found in the License.txt file in the root of the source +tree. All contributing project authors may +be found in the Authors.txt file in the root of the source tree. +***************************************************************************************/ + +/*! \file CrashRpt.h +* \brief Defines the interface for the CrashRpt.DLL. +* \date 2003 +* \author Michael Carruth +* \author Oleg Krivtsov (zeXspectrum) +*/ + +#ifndef _CRASHRPT_H_ +#define _CRASHRPT_H_ + +#include +#include + +// Define SAL macros to be empty if some old Visual Studio used +#ifndef __reserved +#define __reserved +#endif +#ifndef __in +#define __in +#endif +#ifndef __in_opt +#define __in_opt +#endif +#ifndef __out_ecount_z +#define __out_ecount_z(x) +#endif + +#ifdef __cplusplus +#define CRASHRPT_EXTERNC extern "C" +#else +#define CRASHRPT_EXTERNC +#endif + +#define CRASHRPTAPI(rettype) CRASHRPT_EXTERNC rettype WINAPI + +//! Current CrashRpt version +#define CRASHRPT_VER 1500 + +/*! \defgroup CrashRptAPI CrashRpt Functions */ +/*! \defgroup DeprecatedAPI Obsolete Functions */ +/*! \defgroup CrashRptStructs CrashRpt Structures */ +/*! \defgroup CrashRptWrappers CrashRpt Wrapper Classes */ + +/*! \ingroup DeprecatedAPI +* \brief Client crash callback function prototype +* \param[in] lpvState Must be set to NULL. +* +* \remarks +* +* This function is deprecated, it is recommended to use \ref PFNCRASHCALLBACK() +* instead. +* +* The crash callback function is called when crash occurs. This way client application is +* notified about the crash. +* +* It is generally unsafe to do complex actions (e.g. memory allocation, heap operations) inside of this callback. +* The application state may be unstable. +* +* One reason the application may use this callback for is to close handles to open log files that the +* application plans to include into the error report. Files should be accessible for reading, otherwise +* CrashRpt won't be able to include them into error report. +* +* It is also possible (but not recommended) to add files, properties, desktop screenshots, +* registry keys inside of the crash callback function. +* +* The crash callback function should typically return \c TRUE to allow generate error report. +* Returning \c FALSE will prevent crash report generation. +* +* The following example shows how to use the crash callback function. +* +* \code +* // define the crash callback +* BOOL CALLBACK CrashCallback(LPVOID lpvState) +* { +* // Do something... +* +* return TRUE; +* } +* \endcode +* +* \sa crAddFile2(), PFNCRASHCALLBACK() +*/ +typedef BOOL (CALLBACK *LPGETLOGFILE) (__reserved LPVOID lpvState); + +// Exception types used in CR_EXCEPTION_INFO::exctype structure member. +#define CR_SEH_EXCEPTION 0 //!< SEH exception. +#define CR_CPP_TERMINATE_CALL 1 //!< C++ terminate() call. +#define CR_CPP_UNEXPECTED_CALL 2 //!< C++ unexpected() call. +#define CR_CPP_PURE_CALL 3 //!< C++ pure virtual function call (VS .NET and later). +#define CR_CPP_NEW_OPERATOR_ERROR 4 //!< C++ new operator fault (VS .NET and later). +#define CR_CPP_SECURITY_ERROR 5 //!< Buffer overrun error (VS .NET only). +#define CR_CPP_INVALID_PARAMETER 6 //!< Invalid parameter exception (VS 2005 and later). +#define CR_CPP_SIGABRT 7 //!< C++ SIGABRT signal (abort). +#define CR_CPP_SIGFPE 8 //!< C++ SIGFPE signal (flotating point exception). +#define CR_CPP_SIGILL 9 //!< C++ SIGILL signal (illegal instruction). +#define CR_CPP_SIGINT 10 //!< C++ SIGINT signal (CTRL+C). +#define CR_CPP_SIGSEGV 11 //!< C++ SIGSEGV signal (invalid storage access). +#define CR_CPP_SIGTERM 12 //!< C++ SIGTERM signal (termination request). + + +/*! \ingroup CrashRptStructs +* \brief This structure contains information about the crash. +* +* The information provided by this structure includes the exception type, exception code, +* exception pointers and so on. These are needed to generate crash minidump file and +* provide the developer with other information about the error. This structure is used by +* the crGenerateErrorReport() function. Pointer to this structure is also passed to the +* crash callback function (see the \ref PFNCRASHCALLBACK() function prototype). +* +* Structure members details are provided below: +* +* \b cb [in] +* +* This must contain the size of this structure in bytes. +* +* \b pexcptrs [in, optional] +* +* Should contain the exception pointers. If this parameter is NULL, +* the current CPU state is used to generate exception pointers. +* +* \b exctype [in] +* +* The type of exception. This parameter may be one of the following: +* - \ref CR_SEH_EXCEPTION SEH (Structured Exception Handling) exception +* - \ref CR_CPP_TERMINATE_CALL C++ terminate() function call +* - \ref CR_CPP_UNEXPECTED_CALL C++ unexpected() function call +* - \ref CR_CPP_PURE_CALL Pure virtual method call (Visual Studio .NET 2003 and later) +* - \ref CR_CPP_NEW_OPERATOR_ERROR C++ 'new' operator error (Visual Studio .NET 2003 and later) +* - \ref CR_CPP_SECURITY_ERROR Buffer overrun (Visual Studio .NET 2003 only) +* - \ref CR_CPP_INVALID_PARAMETER Invalid parameter error (Visual Studio 2005 and later) +* - \ref CR_CPP_SIGABRT C++ SIGABRT signal +* - \ref CR_CPP_SIGFPE C++ floating point exception +* - \ref CR_CPP_SIGILL C++ illegal instruction +* - \ref CR_CPP_SIGINT C++ SIGINT signal +* - \ref CR_CPP_SIGSEGV C++ invalid storage access +* - \ref CR_CPP_SIGTERM C++ termination request +* +* \b code [in, optional] +* +* Used if \a exctype is \ref CR_SEH_EXCEPTION and represents the SEH exception code. +* If \a pexptrs is NULL, this value is used when generating exception information for initializing +* \c pexptrs->ExceptionRecord->ExceptionCode member, otherwise it is ignored. +* +* \b fpe_subcode [in, optional] +* +* Used if \a exctype is equal to \ref CR_CPP_SIGFPE. It defines the floating point +* exception subcode (see \c signal() function ducumentation in MSDN). +* +* \b expression, \b function, \b file and \b line [in, optional] +* +* These parameters are used when \a exctype is \ref CR_CPP_INVALID_PARAMETER. +* These members are typically non-zero when using debug version of CRT. +* +* \b bManual [in] +* +* Since v.1.2.4, \a bManual parameter should be equal to TRUE if the report is generated manually. +* The value of \a bManual parameter affects the automatic application restart behavior. If the application +* restart is requested by the \ref CR_INST_APP_RESTART flag of CR_INSTALL_INFO::dwFlags structure member, +* and if \a bManual is FALSE, the application will be +* restarted after error report generation. If \a bManual is TRUE, the application won't be restarted. +* +* \b hSenderProcess [out] +* +* As of v.1.2.8, \a hSenderProcess parameter will contain the handle to the CrashSender.exe process when +* \ref crGenerateErrorReport function returns. The caller may use this handle to wait until CrashSender.exe +* process exits and check the exit code. When the handle is not needed anymore, release it with the \b CloseHandle() function. +*/ + +typedef struct tagCR_EXCEPTION_INFO +{ + WORD cb; //!< Size of this structure in bytes; should be initialized before using. + PEXCEPTION_POINTERS pexcptrs; //!< Exception pointers. + int exctype; //!< Exception type. + DWORD code; //!< Code of SEH exception. + unsigned int fpe_subcode; //!< Floating point exception subcode. + const wchar_t* expression; //!< Assertion expression. + const wchar_t* function; //!< Function in which assertion happened. + const wchar_t* file; //!< File in which assertion happened. + unsigned int line; //!< Line number. + BOOL bManual; //!< Flag telling if the error report is generated manually or not. + HANDLE hSenderProcess; //!< Handle to the CrashSender.exe process. +} +CR_EXCEPTION_INFO; + +typedef CR_EXCEPTION_INFO* PCR_EXCEPTION_INFO; + +// Stages of crash report generation (used by the crash callback function). +#define CR_CB_STAGE_PREPARE 10 //!< Stage after exception pointers've been retrieved. +#define CR_CB_STAGE_FINISH 20 //!< Stage after the launch of CrashSender.exe process. + +/*! \ingroup CrashRptStructs +* \struct CR_CRASH_CALLBACK_INFOW() +* \brief This structure contains information passed to crash callback function PFNCRASHCALLBACK(). +* +* \remarks +* +* The information contained in this structure may be used by the crash callback function +* to determine what type of crash has occurred and perform some action. For example, +* the client application may prefer to continue its execution on some type of crash, and +* terminate itself on another type of crash. +* +* Below, the stucture fields are described: +* +* \b cb [in] +* +* This contains the size of this structure in bytes. +* +* \b nStage [in] +* +* This field specifies the crash report generation stage. The callback function +* can be called once per each stage (depending on callback function's return value). +* Currently, there are two stages: +* - \ref CR_CB_STAGE_PREPARE Stage after exception pointers've been retrieved. +* - \ref CR_CB_STAGE_FINISH Stage after the launch of CrashSender.exe process. +* +* \b pszErrorReportFolder [in] +* +* This field contains the absolute path to the directory containing uncompressed +* crash report files. +* +* \b pExceptionInfo [in] +* +* This field contains a pointer to \ref CR_EXCEPTION_INFO structure. +* +* \b pUserParam [in, optional] +* +* This is a pointer to user-specified data passed to the crSetCrashCallback() function +* as \b pUserParam argument. +* +* \b bContinueExecution [in, out] +* +* This field is set to FALSE by default. The crash callback function may set it +* to true if it wants to continue its execution after crash report generation +* (otherwise the program will be terminated). +* +* \ref CR_CRASH_CALLBACK_INFOW and \ref CR_CRASH_CALLBACK_INFOA are +* wide-character and multi-byte character versions of \ref CR_CRASH_CALLBACK_INFO +* structure. In your program, use the \ref CR_CRASH_CALLBACK_INFO typedef which +* is a character-set-independent version of the structure name. +* +* \sa PFNCRASHCALLBACK() +*/ +typedef struct tagCR_CRASH_CALLBACK_INFOW +{ + WORD cb; //!< Size of this structure in bytes. + int nStage; //!< Stage. + LPCWSTR pszErrorReportFolder; //!< Directory where crash report files are located. + CR_EXCEPTION_INFO* pExceptionInfo; //!< Pointer to information about the crash. + LPVOID pUserParam; //!< Pointer to user-defined data. + BOOL bContinueExecution; //!< Whether to terminate the process (the default) or to continue program execution. +} +CR_CRASH_CALLBACK_INFOW; + +/*! \ingroup CrashRptStructs +* \struct CR_CRASH_CALLBACK_INFOA +* \copydoc CR_CRASH_CALLBACK_INFOW +*/ +typedef struct tagCR_CRASH_CALLBACK_INFOA +{ + WORD cb; //!< Size of this structure in bytes. + int nStage; //!< Stage. + LPCSTR pszErrorReportFolder; //!< Directory where crash report files are located. + CR_EXCEPTION_INFO* pExceptionInfo; //!< Pointer to information about the crash. + LPVOID pUserParam; //!< Pointer to user-defined data. + BOOL bContinueExecution; //!< Whether to terminate the process (the default) or to continue program execution. +} +CR_CRASH_CALLBACK_INFOA; + +/*! \brief Character set-independent mapping of CR_CRASH_CALLBACK_INFOW and CR_CRASH_CALLBACK_INFOA structures. +* \ingroup CrashRptStructs +*/ +#ifdef UNICODE +typedef CR_CRASH_CALLBACK_INFOW CR_CRASH_CALLBACK_INFO; +#else +typedef CR_CRASH_CALLBACK_INFOA CR_CRASH_CALLBACK_INFO; +#endif // UNICODE + +// Constants that may be returned by the crash callback function. +#define CR_CB_CANCEL 0 //!< Cancel crash report generation on the current stage. +#define CR_CB_DODEFAULT 1 //!< Proceed to the next stages of crash report generation without calling crash callback function. +#define CR_CB_NOTIFY_NEXT_STAGE 2 //!< Proceed and call the crash callback for the next stage. + +/*! \ingroup CrashRptAPI +* \brief Client crash callback function prototype. +* \param[in] pInfo Points to information about the crash. +* +* \remarks +* +* The crash callback function is called when a crash occurs. This way client application is +* notified about the crash. +* +* Crash information is passed by CrashRpt to the callback function through the \b pInfo parameter as +* a pointer to \ref CR_CRASH_CALLBACK_INFO structure. See below for a code example. +* +* It is generally unsafe to do complex actions (e.g. memory allocation, heap operations) inside of this callback. +* The application state may be unstable. +* +* One reason the application may use this callback for is to close handles to open log files that the +* application plans to include into the error report. Files should be accessible for reading, otherwise +* CrashRpt won't be able to include them into error report. +* +* It is also possible (but not recommended) to add files (see crAddFile2()), +* properties (see crAddProperty()), desktop screenshots (see crAddScreenshot2()) +* and registry keys (see crAddRegKey()) inside of the crash callback function. +* +* By default, CrashRpt terminates the client application after crash report generation and +* launching the CrashSender.exe process. However, it is possible to continue program +* execution after crash report generation by seting \ref CR_CRASH_CALLBACK_INFO::bContinueExecution +* structure field to \a TRUE. +* +* The crash report generation consists of several stages. First, exception pointers are retrieved +* and the callback function is called for the first time. The callback function may check the +* retrieved exception information and decide wheter to proceed with crash report generation or to +* continue client program execution. On the next stage, the \a CrashSender.exe +* process is launched and the crash callback function is (optionally) called for the second time. +* Further crash report data collection and delivery work is performed in \a CrashSender.exe process. +* The crash callback may use the provided handle to \a CrashSender.exe process to wait until it exits. +* +* The crash callback function should typically return \ref CR_CB_DODEFAULT constant to proceed +* with error report generation without being called back on the next stage(s). Returning the +* \ref CR_CB_NOTIFY_NEXT_STAGE constant causes CrashRpt to call the crash callback function on the next +* stage, too. Returning \ref CR_CB_CANCEL constant will prevent further stage(s) of crash report generation. +* +* \ref PFNCRASHCALLBACKW() and \ref PFNCRASHCALLBACKA() are +* wide-character and multi-byte character versions of \ref PFNCRASHCALLBACK() +* function. +* +* The following code example shows the simplest way of using the crash callback function: +* +* \code +* // Define the crash callback +* int CALLBACK CrashCallback(CR_CRASH_CALLBACK_INFO* pInfo) +* { +* +* // Do something... +* +* // Proceed with crash report generation. +* // This return code also makes CrashRpt to not call this callback function for +* // the next crash report generation stage. +* return CR_CB_DODEFAULT; +* } +* \endcode +* +* The following code example shows how to use the crash callback function to be notified +* on every stage of crash report generation: +* +* \code +* // Define the crash callback +* int CALLBACK CrashCallback(CR_CRASH_CALLBACK_INFO* pInfo) +* { +* +* // We want to continue program execution after crash report generation +* pInfo->bContinueExecution = TRUE; +* +* switch(pInfo->nStage) +* { +* case CR_CB_STAGE_PREPARE: +* // do something +* break; +* case CR_CB_STAGE_FINISH: +* // do something +* break; +* } +* +* // Proceed to the next stage. +* return CR_CB_NOTIFY_NEXT_STAGE; +* } +* \endcode +* +* \sa CR_CRASH_CALLBACK_INFO, crSetCrashCallback(), crAddFile2(), crAddProperty(), crAddScreenshot2(), crAddRegKey() +*/ +typedef int (CALLBACK *PFNCRASHCALLBACKW) (CR_CRASH_CALLBACK_INFOW* pInfo); + +/*! \ingroup CrashRptAPI +* \copydoc PFNCRASHCALLBACKW() +*/ +typedef int (CALLBACK *PFNCRASHCALLBACKA) (CR_CRASH_CALLBACK_INFOA* pInfo); + +/*! \brief Character set-independent mapping of \ref PFNCRASHCALLBACKW() and \ref PFNCRASHCALLBACKA() function prototrypes. +* \ingroup CrashRptStructs +*/ +#ifdef UNICODE +typedef PFNCRASHCALLBACKW PFNCRASHCALLBACK; +#else +typedef PFNCRASHCALLBACKA PFNCRASHCALLBACK; +#endif // UNICODE + +/*! \ingroup CrashRptAPI +* \brief Sets the crash callback function. +* +* \return This function returns zero if succeeded. Use crGetLastErrorMsg() to retrieve the error message on fail. +* +* \param[in] pfnCallbackFunc Pointer to the crash callback function. +* \param[in] lpParam User defined parameter. Optional. +* +* \remarks +* +* Use this to set the crash callback function that will be called on crash. This function +* is available since v.1.4.0. +* +* For the crash callback function prototype, see documentation for PFNCRASHCALLBACK(). +* +* Optional \b lpParam parameter can be a pointer to user-defined data. It will be passed to the +* crash callback function as \ref CR_CRASH_CALLBACK_INFO::pUserParam structure member. +* +* \sa +* PFNCRASHCALLBACK() +*/ + +CRASHRPTAPI(int) +crSetCrashCallbackW( + PFNCRASHCALLBACKW pfnCallbackFunc, + LPVOID lpParam + ); + +CRASHRPTAPI(int) +crSetEmailSubjectW( + LPCWSTR pszSubject +); + +CRASHRPTAPI(int) +crSetEmailSubjectA( + LPCSTR pszSubject +); + +/*! \brief Character set-independent mapping of crSetEmailSubjectW() and crSetEmailSubjectA() functions. +* \ingroup CrashRptAPI +*/ +#ifdef UNICODE +#define crSetEmailSubject crSetEmailSubjectW +#else +#define crSetEmailSubject crSetEmailSubjectA +#endif //UNICODE + +/*! \ingroup CrashRptAPI +* \copydoc crSetCrashCallbackW() +*/ +CRASHRPTAPI(int) +crSetCrashCallbackA( + PFNCRASHCALLBACKA pfnCallbackFunc, + LPVOID lpParam + ); + + +/*! \brief Character set-independent mapping of crSetCrashCallbackW() and crSetCrashCallbackA() functions. +* \ingroup CrashRptAPI +*/ +#ifdef UNICODE +#define crSetCrashCallback crSetCrashCallbackW +#else +#define crSetCrashCallback crSetCrashCallbackA +#endif //UNICODE + +// Array indices for CR_INSTALL_INFO::uPriorities. +#define CR_HTTP 0 //!< Send error report via HTTP (or HTTPS) connection. +#define CR_SMTP 1 //!< Send error report via SMTP connection. +#define CR_SMAPI 2 //!< Send error report via simple MAPI (using default mail client). + +//! Special priority constant that allows to skip certain delivery method. +#define CR_NEGATIVE_PRIORITY ((UINT)-1) + +// Flags for CR_INSTALL_INFO::dwFlags +#define CR_INST_STRUCTURED_EXCEPTION_HANDLER 0x1 //!< Install SEH handler (deprecated name, use \ref CR_INST_SEH_EXCEPTION_HANDLER instead). +#define CR_INST_SEH_EXCEPTION_HANDLER 0x1 //!< Install SEH handler. +#define CR_INST_TERMINATE_HANDLER 0x2 //!< Install terminate handler. +#define CR_INST_UNEXPECTED_HANDLER 0x4 //!< Install unexpected handler. +#define CR_INST_PURE_CALL_HANDLER 0x8 //!< Install pure call handler (VS .NET and later). +#define CR_INST_NEW_OPERATOR_ERROR_HANDLER 0x10 //!< Install new operator error handler (VS .NET and later). +#define CR_INST_SECURITY_ERROR_HANDLER 0x20 //!< Install security error handler (VS .NET and later). +#define CR_INST_INVALID_PARAMETER_HANDLER 0x40 //!< Install invalid parameter handler (VS 2005 and later). +#define CR_INST_SIGABRT_HANDLER 0x80 //!< Install SIGABRT signal handler. +#define CR_INST_SIGFPE_HANDLER 0x100 //!< Install SIGFPE signal handler. +#define CR_INST_SIGILL_HANDLER 0x200 //!< Install SIGILL signal handler. +#define CR_INST_SIGINT_HANDLER 0x400 //!< Install SIGINT signal handler. +#define CR_INST_SIGSEGV_HANDLER 0x800 //!< Install SIGSEGV signal handler. +#define CR_INST_SIGTERM_HANDLER 0x1000 //!< Install SIGTERM signal handler. + +#define CR_INST_ALL_POSSIBLE_HANDLERS 0x1FFF //!< Install all possible exception handlers. +#define CR_INST_CRT_EXCEPTION_HANDLERS 0x1FFE //!< Install exception handlers for the linked CRT module. + +#define CR_INST_NO_GUI 0x2000 //!< Do not show GUI, send report silently (use for non-GUI apps only). +#define CR_INST_HTTP_BINARY_ENCODING 0x4000 //!< Deprecated, do not use. +#define CR_INST_DONT_SEND_REPORT 0x8000 //!< Don't send error report immediately, just save it locally. +#define CR_INST_APP_RESTART 0x10000 //!< Restart the application on crash. +#define CR_INST_NO_MINIDUMP 0x20000 //!< Do not include minidump file to crash report. +#define CR_INST_SEND_QUEUED_REPORTS 0x40000 //!< CrashRpt should send error reports that are waiting to be delivered. +#define CR_INST_STORE_ZIP_ARCHIVES 0x80000 //!< CrashRpt should store both uncompressed error report files and ZIP archives. +#define CR_INST_SEND_MANDATORY 0x100000 //!< This flag removes the "Close" and "Other actions" buttons from Error Report dialog, thus making the sending procedure mandatory for user. +#define CR_INST_SHOW_ADDITIONAL_INFO_FIELDS 0x200000 //!< Makes "Your E-mail" and "Describe what you were doing when the problem occurred" fields of Error Report dialog always visible. +#define CR_INST_ALLOW_ATTACH_MORE_FILES 0x400000 //!< Adds an ability for user to attach more files to crash report by clicking "Attach More File(s)" item from context menu of Error Report Details dialog. +#define CR_INST_AUTO_THREAD_HANDLERS 0x800000 //!< If this flag is set, installs exception handlers for newly created threads automatically. + +/*! \ingroup CrashRptStructs +* \struct CR_INSTALL_INFOW() +* \brief This structure defines the general information used by crInstallW() function. +* +* \remarks +* +* \ref CR_INSTALL_INFOW and \ref CR_INSTALL_INFOA structures are wide-character and multi-byte character +* versions of \ref CR_INSTALL_INFO. \ref CR_INSTALL_INFO typedef defines character set independent mapping. +* +* Below, structure members are described in details. Required parameters must always be specified, while optional +* ones may be set with 0 (zero) or NULL. Most of parameters are optional. +* +* \b cb [in, required] +* +* This must contain the size of this structure in bytes. +* +* \b pszAppName [in, optional] +* +* This is the friendly name of the client application. The application name is +* displayed in the Error Report dialog. If this parameter is NULL, the name of EXE file +* that was used to start caller process becomes the application name. +* +* \b pszAppVersion [in, optional] +* +* Should be the application version. Example: "1.0.1". +* +* If this equals to NULL, product version is extracted from the executable file which started +* the caller process, and this product version is used as application version. If the executable file +* doesn's have a version info resource, the \ref crInstall() function will fail. +* +* \b pszEmailTo [in, optional] +* +* This is the email address of the recipient of error reports (or several E-mail adresses separated with semicolon), +* for example "name@example.com" or "person1@example.com;person2@someserver.com". If several E-mail addresses are +* specified, error report will be delivered to each of them. If this parameter equals to NULL, +* the crash report won't be sent using E-mail client. +* +* Keep this NULL if you plan to use large error reports (more than several MB in size), because +* large emails may be rejected by the mail server. +* +* \b pszEmailSubject [in, optional] +* +* This is the subject of the email message. If this parameter is NULL, +* the default subject of form '[app_name] [app_version] Error Report' is generated. +* +* \a pszUrl is the URL of a server-side script that would receive crash report data via HTTP or HTTPS +* connection. If this parmeter is NULL, HTTP(S) connection won't be used to send crash reports. For +* example of a server-side script that can receive crash reports, see \ref sending_error_reports. +* +* HTTP(S) transport is the recommended way of sending large error reports (more than several MB in size). +* To define a custom port for HTTP(S) connection, use the following URL format: "http://example.com[:port]/crashrpt.php" or +* "https://example.com[:port]/crashrpt.php", where optional \a port is the placeholder for the port number. +* +* \b pszCrashSenderPath [in, optional] +* +* This is the absolute path to the directory where CrashSender.exe is located. +* The crash sender process is responsible for letting end user know about the crash and +* sending the error report. If this is NULL, it is assumed that CrashSender.exe is located in +* the same directory as CrashRpt.dll. +* +* +* \b uPriorities [in, optional] +* +* This is an array that defines the preferred methods of sending error reports. +* The available methods are: HTTP (or HTTPS) connection, SMTP connection or simple MAPI (default mail client). +* +* A priority is a non-negative integer number or special constant \ref CR_NEGATIVE_PRIORITY. +* The greater positive number defines the greater priority. +* Specify the \ref CR_NEGATIVE_PRIORITY to skip the given delivery method. +* +* The element having index \ref CR_HTTP defines priority for using HTML connection. +* The element having index \ref CR_SMTP defines priority for using SMTP connection. +* The element having index \ref CR_SMAPI defines priority for using the default mail client. +* +* The methods having greater priority will be tried first. If priorities are equal to each other, HTTP (or HTTPS) +* connection will be tried the first, SMTP connection will be tried the second and simple MAPI will be tried +* the last. +* +* \b dwFlags [in, optional] +* +* Since v1.1.2, \a dwFlags can be used to define behavior parameters. This can be a combination of the following values: +* +* +*
Use the combination of the following constants to specify what exception handlers to install: +*
\ref CR_INST_ALL_POSSIBLE_HANDLERS Install all available exception handlers. +*
\ref CR_INST_SEH_EXCEPTION_HANDLER Install SEH exception handler. +*
\ref CR_INST_PURE_CALL_HANDLER Install pure call handler (VS .NET and later). +*
\ref CR_INST_NEW_OPERATOR_ERROR_HANDLER Install new operator error handler (VS .NET and later). +*
\ref CR_INST_SECURITY_ERROR_HANDLER Install security errror handler (VS .NET and later). +*
\ref CR_INST_INVALID_PARAMETER_HANDLER Install invalid parameter handler (VS 2005 and later). +*
\ref CR_INST_SIGABRT_HANDLER Install SIGABRT signal handler. +*
\ref CR_INST_SIGINT_HANDLER Install SIGINT signal handler. +*
\ref CR_INST_SIGTERM_HANDLER Install SIGTERM signal handler. +*
Use the combination of the following constants to define behavior parameters: +*
\ref CR_INST_NO_GUI +* Available since v.1.2.2 Do not show GUI. +* +* It is not recommended to use this flag for regular GUI-based applications. +* Use this only for services that have no GUI. +*
\ref CR_INST_DONT_SEND_REPORT +* Available since v.1.2.2 This parameter means 'do not send error report immediately on crash, just save it locally'. +* Use this if you have direct access to the machine where crash happens and do not need +* to send report over the Internet. You can use this in couple with \ref CR_INST_STORE_ZIP_ARCHIVES flag to store zipped error reports +* along with uncompressed error report files. +*
\ref CR_INST_APP_RESTART +* Available since v.1.2.4 This parameter allows to automatically restart the application on crash. The command line +* for the application is taken from \a pszRestartCmdLine parameter. To avoid cyclic restarts of an application which crashes on startup, +* the application is restarted only if at least 60 seconds elapsed since its start. +*
\ref CR_INST_NO_MINIDUMP +* Available since v.1.2.4 Specify this parameter if you want minidump file not to be included into crash report. The default +* behavior is to include the minidump file. +* +*
\ref CR_INST_SEND_QUEUED_REPORTS +* Available since v.1.2.5 Specify this parameter to send all queued reports. Those +* report files are by default stored in %LOCAL_APPDATA%\\CrashRpt\\UnsentCrashReports\\%AppName%_%AppVersion% folder. +* If this is specified, CrashRpt checks if it's time to remind user about recent errors in the application and offers to send +* all queued error reports. +* +*
\ref CR_INST_STORE_ZIP_ARCHIVES +* Available since v.1.2.7 This parameter can be used in couple with \ref CR_INST_DONT_SEND_REPORT flag to store not only uncompressed +* error report files, but also ZIP archives. By default (if this flag omitted) CrashRpt stores all error report files +* in uncompressed state. +* +*
\ref CR_INST_SEND_MANDATORY +* Available since v.1.3.1 This parameter makes sending procedure mandatory by removing the "Close" button +* and "Other actions..." button from the Error Report dialog. Typically, it is not recommended to use this flag, +* unless you intentionally want users to always send error reports for your application. +*
\ref CR_INST_SHOW_ADDITIONAL_INFO_FIELDS +* Available since v.1.3.1 This parameter makes "Your E-mail" and "Describe what you were doing when the +* problem occurred" fields of Error Report dialog always visible. By default (when this parameter not specified), +* these fields are hidden and user needs to click the "Provide additional info (recommended)" link to show them. +* +*
\ref CR_INST_ALLOW_ATTACH_MORE_FILES +* Available since v.1.3.1 Adds an ability for user to attach more files to crash report by choosing +* "Attach More File(s)" item from context menu of Error Report Details dialog. By default this feature is disabled. +* +*
\ref CR_INST_AUTO_THREAD_HANDLERS +* Available since v.1.4.2 Specifying this flag results in automatic installation of all available exception handlers to +* all threads that will be created in the future. This flag only works if CrashRpt is compiled as a DLL, it does +* not work if you compile CrashRpt as static library. +*
+* +* \b pszPrivacyPolicyURL [in, optional] +* +* This parameter defines the URL for the Privacy Policy hyperlink of the +* Error Report dialog. If this parameter is NULL, the link is not displayed. For information on +* the Privacy Policy, see \ref error_report. This parameter is available since v1.1.2. +* +* \b pszDebugHelpDLL [in, optional] +* +* This parameter defines the location of the dbghelp.dll to load. +* If this parameter is NULL, the dbghelp.dll is searched using the default search sequence. +* This parameter is available since v1.2.1. +* +* \b uMiniDumpType [in, optional] +* +* This parameter defines the minidump type. For the list of available minidump +* types, see the documentation for the MiniDumpWriteDump() function in MSDN. +* Parameter is available since v.1.2.1. +* +* It is recommended to set this +* parameter with zero (equivalent of MiniDumpNormal constant). Other values may increase the minidump +* size significantly. +* +* \b pszErrorReportSaveDir [in, optional] +* +* This parameter defines the directory where to save the error reports. +* If this is NULL, the default directory is used (%%LOCAL_APP_DATA%\\CrashRpt\\UnsentCrashReports\\%%AppName%%_%%AppVersion%). +* This parameter is available since v.1.2.2. +* +* \b pszRestartCmdLine [in, optional] +* +* This parameter defines the string that specifies the +* command-line arguments for the application when it is restarted (when using \ref CR_INST_APP_RESTART flag). +* Do not include the name of the executable in the command line; it is added automatically. This parameter +* can be NULL. Available since v.1.2.4. +* +* \b pszLangFilePath [in, optional] +* +* This parameter defines the absolute path (including file name) for language file. +* If this is NULL, the lang file is assumed to be located in the same dir as CrashSender.exe file and have +* the name crashrpt_lang.ini. +* This parameter is available since v.1.2.4. +* +* \b pszEmailText [in, optional] +* +* This parameter defines the custom E-mail text that is used when deliverying error report +* as E-mail. If this is NULL, the default E-mail text is used. It is recommended to set this parameter with NULL. +* This parameter is available since v.1.2.4. +* +* \b pszSmtpProxy [in, optional] +* +* This parameter defines the network address (IP or domain) and, optionally, port formatted as "address[:port]" +* of SMTP server. Examples: "192.168.1.1:2525", "mail.example.com:25". +* If this parameter is NULL, the SMTP server address is resolved using the MX record of recipient's mailbox. +* You should typically set this parameter with NULL, except in the +* case when your software is a server and custom SMTP configuration is required. This parameter is available since v.1.2.4. +* +* \b pszCustomSenderIcon [in, optional] +* +* This parameter can be used to define a custom icon for Error Report dialog. This parameter is +* available since v.1.2.8. +* +* The value of this parameter should be absolute path to the module containing the icon resource, followed +* by resource identifier separated by comma. You can set this parameter with NULL to use the default icon. +* +* The resource identifier is a zero-based index of the icon to retrieve. For example, if this value is 0, +* the first icon in the specified file is used. If the identifier is a negative number not equal to -1, +* the icon in the specified file whose resource identifier is equal to the absolute value of the resource +* identifier is used. +* Example: "D:\MyApp\Resources.dll, -128". +* +* \b pszSmtpLogin [in, optional] +* +* This parameter defines the login name for SMTP authentication. It is typically used together with +* \ref pszSmtpProxy and \ref pszSmtpPassword parameter. +* If this parameter is ommitted (NULL), no SMTP autentication is used. This parameter is available since v.1.3.1. +* +* \b pszSmtpPassword [in, optional] +* +* This parameter defines the password for SMTP authentication. It is used in pair with \ref pszSmtpLogin parameter. +* This parameter is available since v.1.3.1. +* +* \b nRestartTimeout [in, optional] +* +* This parameter defines the timeout (in seconds) for the application restart (when using \ref CR_INST_APP_RESTART flag). +* It is recommended to set this with zero (in such a case, the default restart timeout of 60 seconds is applied). +* Available since v.1.4.3. +*/ + +typedef struct tagCR_INSTALL_INFOW +{ + WORD cb; //!< Size of this structure in bytes; must be initialized before using! + LPCWSTR pszAppName; //!< Name of application. + LPCWSTR pszAppVersion; //!< Application version. + LPCWSTR pszEmailTo; //!< E-mail address of crash reports recipient. + LPCWSTR pszEmailSubject; //!< Subject of crash report e-mail. + LPCWSTR pszUrl; //!< URL of server-side script (used in HTTP connection). + LPCWSTR pszCrashSenderPath; //!< Directory name where CrashSender.exe is located. + LPGETLOGFILE pfnCrashCallback; //!< Deprecated, do not use. + UINT uPriorities[5]; //!< Array of error sending transport priorities. + DWORD dwFlags; //!< Flags. + LPCWSTR pszPrivacyPolicyURL; //!< URL of privacy policy agreement. + LPCWSTR pszDebugHelpDLL; //!< File name or folder of Debug help DLL. + MINIDUMP_TYPE uMiniDumpType; //!< Minidump type. + LPCWSTR pszErrorReportSaveDir; //!< Directory where to save error reports. + LPCWSTR pszRestartCmdLine; //!< Command line for application restart (without executable name). + LPCWSTR pszLangFilePath; //!< Path to the language file (including file name). + LPCWSTR pszEmailText; //!< Custom E-mail text (used when deliverying report as E-mail). + LPCWSTR pszSmtpProxy; //!< Network address and port to be used as SMTP proxy. + LPCWSTR pszCustomSenderIcon; //!< Custom icon used for Error Report dialog. + LPCWSTR pszSmtpLogin; //!< Login name used for SMTP authentication when sending error report as E-mail. + LPCWSTR pszSmtpPassword; //!< Password used for SMTP authentication when sending error report as E-mail. + int nRestartTimeout; //!< Timeout for application restart. + int nMaxReportsPerDay; //!< Maximum number of crash reports that will be sent per calendar day. +} +CR_INSTALL_INFOW; + +typedef CR_INSTALL_INFOW* PCR_INSTALL_INFOW; + +/*! \ingroup CrashRptStructs +* \struct CR_INSTALL_INFOA +* \copydoc CR_INSTALL_INFOW +*/ + +typedef struct tagCR_INSTALL_INFOA +{ + WORD cb; //!< Size of this structure in bytes; must be initialized before using! + LPCSTR pszAppName; //!< Name of application. + LPCSTR pszAppVersion; //!< Application version. + LPCSTR pszEmailTo; //!< E-mail address of crash reports recipient. + LPCSTR pszEmailSubject; //!< Subject of crash report e-mail. + LPCSTR pszUrl; //!< URL of server-side script (used in HTTP connection). + LPCSTR pszCrashSenderPath; //!< Directory name where CrashSender.exe is located. + LPGETLOGFILE pfnCrashCallback; //!< Deprecated, do not use. + UINT uPriorities[5]; //!< Array of error sending transport priorities. + DWORD dwFlags; //!< Flags. + LPCSTR pszPrivacyPolicyURL; //!< URL of privacy policy agreement. + LPCSTR pszDebugHelpDLL; //!< File name or folder of Debug help DLL. + MINIDUMP_TYPE uMiniDumpType; //!< Mini dump type. + LPCSTR pszErrorReportSaveDir; //!< Directory where to save error reports. + LPCSTR pszRestartCmdLine; //!< Command line for application restart (without executable name). + LPCSTR pszLangFilePath; //!< Path to the language file (including file name). + LPCSTR pszEmailText; //!< Custom E-mail text (used when deliverying report as E-mail). + LPCSTR pszSmtpProxy; //!< Network address and port to be used as SMTP proxy. + LPCSTR pszCustomSenderIcon; //!< Custom icon used for Error Report dialog. + LPCSTR pszSmtpLogin; //!< Login name used for SMTP authentication when sending error report as E-mail. + LPCSTR pszSmtpPassword; //!< Password used for SMTP authentication when sending error report as E-mail. + int nRestartTimeout; //!< Timeout for application restart. + int nMaxReportsPerDay; //!< Maximum number of crash reports that will be sent per calendar day. +} +CR_INSTALL_INFOA; + +typedef CR_INSTALL_INFOA* PCR_INSTALL_INFOA; + +/*! \brief Character set-independent mapping of CR_INSTALL_INFOW and CR_INSTALL_INFOA structures. +* \ingroup CrashRptStructs +*/ +#ifdef UNICODE +typedef CR_INSTALL_INFOW CR_INSTALL_INFO; +typedef PCR_INSTALL_INFOW PCR_INSTALL_INFO; +#else +typedef CR_INSTALL_INFOA CR_INSTALL_INFO; +typedef PCR_INSTALL_INFOA PCR_INSTALL_INFO; +#endif // UNICODE + +/*! \ingroup CrashRptAPI +* \brief Installs exception handlers for the caller process. +* +* \return +* This function returns zero if succeeded. +* +* \param[in] pInfo General congiration information. +* +* \remarks +* +* This function installs unhandled exception filter for the caller process. +* It also installs various CRT exception/error handlers that function for all threads of the caller process. +* For more information, see \ref exception_handling +* +* Below is the list of installed handlers: +* - Top-level SEH exception filter [ \c SetUnhandledExceptionFilter() ] +* - C++ pure virtual call handler (Visual Studio .NET 2003 and later) [ \c _set_purecall_handler() ] +* - C++ invalid parameter handler (Visual Studio .NET 2005 and later) [ \c _set_invalid_parameter_handler() ] +* - C++ new operator error handler (Visual Studio .NET 2003 and later) [ \c _set_new_handler() ] +* - C++ buffer overrun handler (Visual Studio .NET 2003 only) [ \c _set_security_error_handler() ] +* - C++ abort handler [ \c signal(SIGABRT) ] +* - C++ illegal instruction handler [ \c signal(SIGINT) ] +* - C++ termination request [ \c signal(SIGTERM) ] +* +* In a multithreaded program, additionally use crInstallToCurrentThread2() function for each execution +* thread, except the main one. +* +* The \a pInfo parameter contains all required information needed to install CrashRpt. +* +* This function fails when \a pInfo->pszCrashSenderPath doesn't contain valid path to CrashSender.exe +* or when \a pInfo->pszCrashSenderPath is equal to NULL, but \b CrashSender.exe is not located in the +* directory where \b CrashRpt.dll located. +* +* On crash, the crash minidump file is created, which contains CPU information and +* stack trace information. Also XML file is created that contains additional +* information that may be helpful for crash analysis. These files along with several additional +* files added with crAddFile2() are packed to a single ZIP file. +* +* When crash information is collected, another process, CrashSender.exe, is launched +* and the process where crash had occured is terminated. The CrashSender process is +* responsible for letting the user know about the crash and send the error report. +* +* The error report can be sent over E-mail using address and subject passed to the +* function as \ref CR_INSTALL_INFO structure members. Another way of sending error report is an HTTP +* request using \a pszUrl member of \ref CR_INSTALL_INFO. +* +* This function may fail if an appropriate language file (\b crashrpt_lang.ini) is not found +* in the directory where the \b CrashSender.exe file is located. +* +* If this function fails, use crGetLastErrorMsg() to retrieve the error message. +* +* crInstallW() and crInstallA() are wide-character and multi-byte character versions of crInstall() +* function. The \ref crInstall macro defines character set independent mapping for these functions. +* +* For code example, see \ref simple_example. +* +* \sa crInstallW(), crInstallA(), crInstall(), CR_INSTALL_INFOW, +* CR_INSTALL_INFOA, CR_INSTALL_INFO, crUninstall(), +* CrAutoInstallHelper +*/ + +CRASHRPTAPI(int) +crInstallW( + __in PCR_INSTALL_INFOW pInfo + ); + +/*! \ingroup CrashRptAPI +* \copydoc crInstallW() +*/ + +CRASHRPTAPI(int) +crInstallA( + __in PCR_INSTALL_INFOA pInfo + ); + +/*! \brief Character set-independent mapping of crInstallW() and crInstallA() functions. +* \ingroup CrashRptAPI +*/ +#ifdef UNICODE +#define crInstall crInstallW +#else +#define crInstall crInstallA +#endif //UNICODE + +/*! \ingroup CrashRptAPI +* \brief Uninitializes the CrashRpt library and unsinstalls exception handlers previously installed with crInstall(). +* +* \return +* This function returns zero if succeeded. +* +* \remarks +* +* Call this function on application exit to uninitialize the library and uninstall exception +* handlers previously installed with crInstall(). After function call, the exception handlers +* are restored to states they had before calling crInstall(). +* +* This function fails if crInstall() wasn't previously called in context of the +* caller process. +* +* When this function fails, use the crGetLastErrorMsg() function to retrieve the error message. +* +* \sa crInstallW(), crInstallA(), crInstall(), +* CrAutoInstallHelper +*/ + +CRASHRPTAPI(int) +crUninstall(); + +/*! \ingroup CrashRptAPI +* \brief Installs exception handlers to the caller thread. +* \return This function returns zero if succeeded. +* \param[in] dwFlags Flags. +* +* \remarks +* +* This function is available since v.1.1.2. +* +* The function sets exception handlers for the caller thread. If you have +* several execution threads, you ought to call the function for each thread, +* except the main one. +* +* \a dwFlags defines what exception handlers to install. Use zero value +* to install all possible exception handlers. Or use a combination of the following constants: +* +* - \ref CR_INST_TERMINATE_HANDLER Install terminate handler +* - \ref CR_INST_UNEXPECTED_HANDLER Install unexpected handler +* - \ref CR_INST_SIGFPE_HANDLER Install SIGFPE signal handler +* - \ref CR_INST_SIGILL_HANDLER Install SIGILL signal handler +* - \ref CR_INST_SIGSEGV_HANDLER Install SIGSEGV signal handler +* +* Example: +* +* \code +* DWORD WINAPI ThreadProc(LPVOID lpParam) +* { +* // Install exception handlers +* crInstallToCurrentThread2(0); +* +* // Your code... +* +* // Uninstall exception handlers +* crUninstallFromCurrentThread(); +* +* return 0; +* } +* \endcode +* +* \sa +* crInstall() +*/ + +CRASHRPTAPI(int) +crInstallToCurrentThread2(DWORD dwFlags); + +/*! \ingroup CrashRptAPI +* \brief Uninstalls C++ exception handlers from the current thread. +* \return This function returns zero if succeeded. +* +* \remarks +* +* This function unsets exception handlers from the caller thread. If you have +* several execution threads, you ought to call the function for each thread. +* After calling this function, the exception handlers for current thread are +* replaced with the handlers that were before call of crInstallToCurrentThread2(). +* +* This function fails if crInstallToCurrentThread2() wasn't called for current thread. +* +* When this function fails, use crGetLastErrorMsg() to retrieve the error message. +* +* No need to call this function for the main execution thread. The crUninstall() +* will automatically uninstall C++ exception handlers for the main thread. +* +* \sa crInstallToCurrentThread2(), +* crUninstallFromCurrentThread(), CrThreadAutoInstallHelper +*/ + +CRASHRPTAPI(int) +crUninstallFromCurrentThread(); + +// Flags for crAddFile2() function. + +#define CR_AF_TAKE_ORIGINAL_FILE 0 //!< Take the original file (do not copy it to the error report folder). +#define CR_AF_MAKE_FILE_COPY 1 //!< Copy the file to the error report folder. +#define CR_AF_FILE_MUST_EXIST 0 //!< Function will fail if file doesn't exist at the moment of function call. +#define CR_AF_MISSING_FILE_OK 2 //!< Do not fail if file is missing (assume it will be created later). +#define CR_AF_ALLOW_DELETE 4 //!< If this flag is specified, the file will be deletable from context menu of Error Report Details dialog. + +/*! \ingroup CrashRptAPI +* \brief Adds a file to crash report. +* +* \return This function returns zero if succeeded. +* +* \param[in] pszFile Absolute path to the file (or file search pattern) to add to crash report, required. +* \param[in] pszDestFile Destination file name, optional. +* \param[in] pszDesc File description (used in Error Report Details dialog), optional. +* \param[in] dwFlags Flags, optional. +* +* This function can be called anytime after crInstall() to add one or more +* files to the generated crash report. +* +* When this function is called, the file is marked to be added to the error report, +* then the function returns control to the caller. +* When a crash occurs, all marked files are added to the report by the \b CrashSender.exe process. +* If a file is locked by someone for exclusive access, the file won't be included. +* Inside of \ref PFNCRASHCALLBACK() crash callback, +* close open file handles and ensure files to be included are acessible for reading. +* +* \a pszFile should be either a valid absolute path to the file or a file search +* pattern (e.g. "*.log") to be added to crash report. +* +* \a pszDestFile should be the name of destination file. This parameter can be used +* to specify different file name for the file in ZIP archive. If this parameter is NULL, the pszFile +* file name is used as destination file name. If \a pszFile is a search pattern, this argument +* is ignored. +* +* \a pszDesc is a short description of the file. It can be NULL. +* +* \a dwFlags parameter defines the behavior of the function. This can be a combination of the following flags: +* - \ref CR_AF_TAKE_ORIGINAL_FILE On crash, the \b CrashSender.exe process will try to locate the file from its original location. This behavior is the default one. +* - \ref CR_AF_MAKE_FILE_COPY On crash, the \b CrashSender.exe process will make a copy of the file and save it to the error report folder. +* +* - \ref CR_AF_FILE_MUST_EXIST The function will fail if file doesn't exist at the moment of function call (the default behavior). +* - \ref CR_AF_MISSING_FILE_OK The function will not fail if file is missing (assume it will be created later). +* +* - \ref CR_AF_ALLOW_DELETE If this flag is specified, the user will be able to delete the file from error report using context menu of Error Report Details dialog. +* +* If you do not use error report delivery (\ref CR_INST_DONT_SEND_REPORT flag) or if you use postponed error report delivery +* (if you specify \ref CR_INST_SEND_QUEUED_REPORTS flag) +* you must also specify the \ref CR_AF_MAKE_FILE_COPY as \a dwFlags parameter value. This will +* guarantee that a snapshot of your file at the moment of crash is taken and saved to the error report folder. +* The error report folder is a folder where files included into the crash report are stored +* until they are sent to recipient. +* +* This function fails if \a pszFile doesn't exist at the moment of function call, +* unless you specify \ref CR_AF_MISSING_FILE_OK flag. +* +* The crAddFile2W() and crAddFile2A() are wide-character and multibyte-character +* versions of crAddFile2() function. The crAddFile2() macro defines character set +* independent mapping. +* +* Usage example: +* +* \code +* +* // Add the error.log file to crash report. At the moment of crash, +* // the file will be copied to crash report folder. The end user +* // will be able to delete the file using CrashRpt GUI. +* int nResult = crAddFile2( +* _T("C:\\Program Files (x86)\MyApp\\error.log"), +* _T("error.log"), +* _T("Log file"), +* CR_AF_MAKE_FILE_COPY|CR_AF_ALLOW_DELETE); +* if(nResult!=0) +* { +* // Get the status message +* TCHAR szErrorMsg[256]; +* crGetLastErrorMsg(szErrorMsg, 256); +* } +* +* // Add all *.txt files found in the folder. At the moment of crash, +* // the file(s) will be copied to crash report folder. The end user +* // won't be able to delete the file(s). +* crAddFile2(_T("C:\\Program Files (x86)\MyApp\\*.txt"), +* NULL, _T("TXT file"), CR_AF_MAKE_FILE_COPY); +* +* \endcode +* +* \sa crAddFile2W(), crAddFile2A(), crAddFile2() +*/ + +CRASHRPTAPI(int) +crAddFile2W( + LPCWSTR pszFile, + LPCWSTR pszDestFile, + LPCWSTR pszDesc, + DWORD dwFlags + ); + +/*! \ingroup CrashRptAPI +* \copydoc crAddFile2W() +*/ + +CRASHRPTAPI(int) +crAddFile2A( + LPCSTR pszFile, + LPCSTR pszDestFile, + LPCSTR pszDesc, + DWORD dwFlags + ); + +/*! \brief Character set-independent mapping of crAddFile2W() and crAddFile2A() functions. +* \ingroup CrashRptAPI +*/ +#ifdef UNICODE +#define crAddFile2 crAddFile2W +#else +#define crAddFile2 crAddFile2A +#endif //UNICODE + + +// Flags for crAddScreenshot function. +#define CR_AS_VIRTUAL_SCREEN 0 //!< Take a screenshot of the virtual screen. +#define CR_AS_MAIN_WINDOW 1 //!< Take a screenshot of application's main window. +#define CR_AS_PROCESS_WINDOWS 2 //!< Take a screenshot of all visible process windows. +#define CR_AS_GRAYSCALE_IMAGE 4 //!< Make a grayscale image instead of a full-color one. +#define CR_AS_USE_JPEG_FORMAT 8 //!< Store screenshots as JPG files. +#define CR_AS_ALLOW_DELETE 16 //!< If this flag is specified, the file will be deletable from context menu of Error Report Details dialog. + +/*! \ingroup DeprecatedAPI +* \brief Adds a screenshot to the crash report. +* +* \return This function returns zero if succeeded. Use crGetLastErrorMsg() to retrieve the error message on fail. +* +* \param[in] dwFlags Flags, optional. +* +* \remarks +* +* As of v.1.3.1, this function is deprecated and may be removed in one of the next releases. Use +* \ref crAddScreenshot2() function instead. +* +* This function can be used to take a screenshot at the moment of crash and add it to the error report. +* Screenshot information may help the developer to better understand the state of the application +* at the moment of crash and reproduce the error. +* +* When this function is called, screenshot flags are saved, +* then the function returns control to the caller. +* When crash occurs, screenshot is made by the \b CrashSender.exe process and added to the report. +* +* \b dwFlags +* +* - \ref CR_AS_ALLOW_DELETE If this flag is specified, the user will be able to delete the file from error report using context menu of Error Report Details dialog. +* +* Use one of the following constants to specify what part of virtual screen to capture: +* - \ref CR_AS_VIRTUAL_SCREEN Use this to take a screenshot of the whole desktop (virtual screen). +* - \ref CR_AS_MAIN_WINDOW Use this to take a screenshot of the application's main window. +* - \ref CR_AS_PROCESS_WINDOWS Use this to take a screenshot of all visible windows that belong to the process. +* +* The main application window is a window that has a caption (\b WS_CAPTION), system menu (\b WS_SYSMENU) and +* the \b WS_EX_APPWINDOW extended style. If CrashRpt doesn't find such window, it considers the first found process window as +* the main window. +* +* Screenshots are added in form of PNG files by default. You can specify the \ref CR_AS_USE_JPEG_FORMAT flag to save +* screenshots as JPEG files instead. +* +* In addition, you can specify the \ref CR_AS_GRAYSCALE_IMAGE flag to make a grayscale screenshot +* (by default color image is made). Grayscale image gives smaller file size. +* +* If you use JPEG image format, you may better use the \ref crAddScreenshot2() function, that allows to +* define JPEG image quality. +* +* When capturing entire desktop consisting of several monitors, +* one screenshot file is added per each monitor. +* +* You should be careful when using this feature, because screenshots may contain user-identifying +* or private information. Always specify purposes you will use collected +* information for in your Privacy Policy. +* +* \sa +* crAddFile2() +*/ + +CRASHRPTAPI(int) +crAddScreenshot( + DWORD dwFlags + ); + +/*! \ingroup CrashRptAPI +* \brief Adds a screenshot to the crash report. +* +* \return This function returns zero if succeeded. Use crGetLastErrorMsg() to retrieve the error message on fail. +* +* \param[in] dwFlags Flags, optional. +* \param[in] nJpegQuality Defines the JPEG image quality, optional. +* +* \remarks +* +* This function can be used to take a screenshot at the moment of crash and add it to the error report. +* Screenshot information may help the developer to better understand state of the application +* at the moment of crash and reproduce the error. +* +* When this function is called, screenshot flags are saved, then the function returns control to the caller. +* When crash occurs, screenshot is made by the \b CrashSender.exe process and added to the report. +* +* \b dwFlags +* +* Use one of the following constants to specify what part of virtual screen to capture: +* - \ref CR_AS_VIRTUAL_SCREEN Use this to take a screenshot of the whole desktop (virtual screen). +* - \ref CR_AS_MAIN_WINDOW Use this to take a screenshot of the main application main window. +* - \ref CR_AS_PROCESS_WINDOWS Use this to take a screenshot of all visible windows that belong to the process. +* +* The main application window is a window that has a caption (\b WS_CAPTION), system menu (\b WS_SYSMENU) and +* the \b WS_EX_APPWINDOW extended style. If CrashRpt doesn't find such window, it considers the first found process window as +* the main window. +* +* Screenshots are added in form of PNG files by default. You can specify the \ref CR_AS_USE_JPEG_FORMAT flag to save +* screenshots as JPEG files instead. +* +* If you use JPEG format, you can use the \a nJpegQuality parameter to define the JPEG image quality. +* This should be the number between 0 and 100, inclusively. The bigger the number, the better the quality and the bigger the JPEG file size. +* If you use PNG file format, this parameter is ignored. +* +* In addition, you can specify the \ref CR_AS_GRAYSCALE_IMAGE flag to make a grayscale screenshot +* (by default color image is made). Grayscale image gives smaller file size. +* +* When capturing entire desktop consisting of several monitors, +* one screenshot file is added per each monitor. +* +* You should be careful when using this feature, because screenshots may contain user-identifying +* or private information. Always specify purposes you will use collected +* information for in your Privacy Policy. +* +* \sa +* crAddFile2() +*/ + +CRASHRPTAPI(int) +crAddScreenshot2( + DWORD dwFlags, + int nJpegQuality + ); + +// Flags for crAddVideo function. +#define CR_AV_VIRTUAL_SCREEN 0 //!< Capture the whole virtual screen. +#define CR_AV_MAIN_WINDOW 1 //!< Capture the area of application's main window. +#define CR_AV_PROCESS_WINDOWS 2 //!< Capture all visible process windows. +#define CR_AV_QUALITY_LOW 0 //!< Low quality video encoding, smaller file size. +#define CR_AV_QUALITY_GOOD 4 //!< Good encoding quality, larger file size. +#define CR_AV_QUALITY_BEST 8 //!< The best encoding quality, the largest file size. +#define CR_AV_NO_GUI 16 //!< Do not display the notification dialog. +#define CR_AV_ALLOW_DELETE 32 //!< If this flag is specified, the file will be deletable from context menu of Error Report Details dialog. + +/*! \ingroup CrashRptAPI +* \brief Allows to record what happened before crash to a video file and include the file to crash report. +* +* \return This function returns zero if succeeded. Use \ref crGetLastErrorMsg() to retrieve the error message on failure. +* +* \param[in] dwFlags Flags, optional. +* \param[in] nDuration Video duration (in milliseconds). Optional. +* \param[in] nFrameInterval Interval between subsequent frames (in milliseconds). Optional. +* \param[in] pDesiredFrameSize Defines the desired video frame size, optional. +* \param[in] hWndParent Window that becomes the parent for GUI displayed by this function. Optional. +* +* \remarks +* +* This function is available as of v.1.4.0. +* +* \b dwFlags can be a combination of the following constants: +* +* - use one of the following constants to specify what part of virtual screen to capture: +* - \ref CR_AV_VIRTUAL_SCREEN Use this to capture the whole desktop (virtual screen). This is the default. +* - \ref CR_AV_MAIN_WINDOW Use this to capture the application's main window. +* - \ref CR_AV_PROCESS_WINDOWS Use this to capture all visible windows that belong to the process. +* +* - use one of the following constants to define the desired video encoding quality: +* - \ref CR_AV_QUALITY_LOW Low-quality video encoding. This is the default. +* - \ref CR_AV_QUALITY_GOOD Good encoding quality, larger file. +* - \ref CR_AV_QUALITY_BEST The best encoding quality, the largest file. +* +* - use the \ref CR_AV_ALLOW_DELETE to allow the user to delete the recorded video file from error report using context menu of Error Report Details dialog. +* +* The main application window is a window that has a caption (\b WS_CAPTION), system menu (\b WS_SYSMENU) and +* the \b WS_EX_APPWINDOW extended style. If CrashRpt doesn't find such a window, it considers the first found process window as +* the main window. +* +* When the function is called, it displays a dialog notifying the user about video recording. +* The displayed dialog's parent window can be specified with the \b hWndParent argument. +* If the \b hWndParent is \a NULL, the currently active process window becomes the parent. +* If you do not want to display the dialog, specify the \ref CR_AV_NO_GUI flag for \b dwFlags argument. +* +* The recorded video will be maximum \b nDuration milliseconds long with \b nFrameInterval +* milliseconds interval between subsequent video frames. If \b nDuration and\or \b nFrameInterval +* are set to zero (0), the default implementation-defined duration and frame interval are used. +* +* The \b pDesiredFrameSize parameter allows to define the desired video frame size. +* Frame width and height must be a multiple of 16 (OGG Theora video codec's requirement). +* If they are not, they are modified automatically to be a multiple of 16. +* +* To preserve correct aspect ratio of the captured area, set \b pDesiredFrameSize->cx or \b pDesiredFrameSize->cy +* to zero. For example, setting \b pDesiredFrameSize->cx=640 and \b pDesiredFrameSize->cy=0 +* results in video frames whose width is 640 pixels and height is calculated to preserve the +* correct aspect ratio of the captured area. If both \b cx and \b cy are specified, the aspect ratio +* of the captured area is not preserved. +* +* Setting the \b pDesiredFrameSize +* parameter to \a NULL makes the function to determine the best video frame size automatically. +* +* This function can be used to record the state of end user's desktop just before the moment +* of crash and add the video file to the error report. The recorded information may help the +* software vendor to better understand the state of the client application at the moment of +* crash and reproduce the error. +* +* When this function is called, CrashRpt launches another process named \b CrashSender.exe. +* The \b CrashSender.exe process then continuously captures the desktop screenshots in background +* mode and stores them to disk as image files. To avoid high CPU load, image files are stored +* in uncompressed state as raw bitmap (BMP) files. When the count of screenshot files exceeds +* the predefined maximum number, the old screenshot files are reused cyclically. +* +* If the client application does not crash and its main code or main window loop exits successfully, +* the captured desktop screenshot files are removed by the \ref crUninstall() function call and +* \b CrashSender.exe process is terminated. +* +* If the client application crashes at some moment of time, the recorded screenshot files are compressed by +* OGG Theora video codec and written into an .OGG file. The +* uncompressed temporary screenshots are then removed, and the resulting +* OGG file is included into crash report archive. +* +* The OGG video format is a widely used +* video container provided by the open-source OGG Project. +* OGG files can be opened in a browser like Google Chrome or Mozilla Firefox or in +* another video player understanding this format, like ffmpeg. +* +* Use this function only when necessary, because it may cause end user's computer performance +* loss. It also requires some amount of free disk space. +* +* The recorded video may contain user-identifying or private information. Always +* specify the purposes you will use collected information for in your Privacy Policy. +* +* Usage example: +* +* \code +* +* // First install CrashRpt with crInstall() function +* +* ... +* +* SIZE FrameSize = {0, 600}; // Frames 600 px in height +* // Frame width is calculated automatically +* +* // Start capturing desktop. Desktop capture video will +* // be added to crash report on crash +* int nResult = crAddVideo( +* CR_AV_VIRTUAL_SCREEN|CR_AV_QUALITY_GOOD, // Capture entire desktop +* // Good encoding quality +* 10000, // 10 seconds long video +* 300, // 300 msec between frames (3.33 FPS) +* &FrameSize, +* NULL +* ); +* +* \endcode +* +* \sa +* crAddFile2(), crAddScreenshot2(), crAddRegKey(), crUninstall(). +*/ + +CRASHRPTAPI(int) +crAddVideo( + DWORD dwFlags, + int nDuration, + int nFrameInterval, + PSIZE pDesiredFrameSize, + HWND hWndParent + ); + +/*! \ingroup CrashRptAPI +* \brief Adds a string property to the crash report. +* +* \return This function returns zero if succeeded. Use crGetLastErrorMsg() to retrieve the error message on fail. +* +* \param[in] pszPropName Name of the property, required. +* \param[in] pszPropValue Value of the property, required. +* +* \remarks +* +* Use this function to add a string property to the crash description XML file. +* User-added properties are listed under \ tag of the XML file. +* In the XML file properties are ordered by names in alphabetic order. +* +* The following example shows how to add information about the amount of free disk space +* to the crash description XML file: +* +* \code +* // It is assumed that you already calculated the amount of free disk space, +* // converted it to text and stored it as szFreeSpace string. +* LPCTSTR szFreeSpace = _T("0 Kb"); +* crAddProperty(_T("FreeDiskSpace"), szFreeSpace); +* +* \endcode +* +* \sa +* crAddFile2(), crAddScreenshot() +*/ + +CRASHRPTAPI(int) +crAddPropertyW( + LPCWSTR pszPropName, + LPCWSTR pszPropValue + ); + +/*! \ingroup CrashRptAPI +* \copydoc crAddPropertyW() +*/ + +CRASHRPTAPI(int) +crAddPropertyA( + LPCSTR pszPropName, + LPCSTR pszPropValue + ); + +/*! \brief Character set-independent mapping of crAddPropertyW() and crAddPropertyA() functions. +* \ingroup CrashRptAPI +*/ +#ifdef UNICODE +#define crAddProperty crAddPropertyW +#else +#define crAddProperty crAddPropertyA +#endif //UNICODE + +// Flags that can be passed to crAddRegKey() function +#define CR_AR_ALLOW_DELETE 0x1 //!< If this flag is specified, the file will be deletable from context menu of Error Report Details dialog. + +/*! \ingroup CrashRptAPI +* \brief Adds a registry key dump to the crash report. +* +* \return This function returns zero if succeeded. Use crGetLastErrorMsg() to retrieve the error message on fail. +* +* \param[in] pszRegKey Registry key to dump, required. +* \param[in] pszDstFileName Name of the destination file, required. +* \param[in] dwFlags Flags, reserved. +* +* \remarks +* +* Use this function to add a dump of a Windows registry key into the crash report. This function +* is available since v.1.2.6. +* +* The \a pszRegKey parameter must be the name of the registry key. The key name should begin with "HKEY_CURRENT_USER" +* or "HKEY_LOCAL_MACHINE". Other root keys are not supported. +* +* The content of the key specified by the \a pszRegKey parameter will be stored in a human-readable XML +* format and included into the error report as \a pszDstFileName destination file. You can dump multiple registry keys +* to the same destination file. +* +* The \a dwFlags parameter can be either set to zero (no flags) or with the following constant: +* +* - \ref CR_AR_ALLOW_DELETE allows the user to delete the file from error report using context menu of Error Report Details dialog. +* +* The following example shows how to dump two registry keys to a single \a regkey.xml file: +* +* \code +* +* crAddRegKey(_T("HKEY_CURRENT_USER\\Software\\MyApp"), _T("regkey.xml"), 0); +* crAddRegKey(_T("HKEY_LOCAL_MACHINE\\Software\\MyApp"), _T("regkey.xml"), 0); +* +* \endcode +* +* \sa +* crAddFile2(), crAddScreenshot(), crAddProperty() +*/ + +CRASHRPTAPI(int) +crAddRegKeyW( + LPCWSTR pszRegKey, + LPCWSTR pszDstFileName, + DWORD dwFlags + ); + +/*! \ingroup CrashRptAPI +* \copydoc crAddRegKeyW() +*/ + +CRASHRPTAPI(int) +crAddRegKeyA( + LPCSTR pszRegKey, + LPCSTR pszDstFileName, + DWORD dwFlags + ); + +/*! \brief Character set-independent mapping of crAddRegKeyW() and crAddRegKeyA() functions. +* \ingroup CrashRptAPI +*/ +#ifdef UNICODE +#define crAddRegKey crAddRegKeyW +#else +#define crAddRegKey crAddRegKeyA +#endif //UNICODE + +/*! \ingroup CrashRptAPI +* \brief Manually generates an error report. +* +* \return This function returns zero if succeeded. When failed, it returns a non-zero value. +* Use crGetLastErrorMsg() function to retrieve the error message. +* +* \param[in] pExceptionInfo Exception information. +* +* \remarks +* +* Call this function to manually generate a crash report. When crash information is collected, +* control is returned to the caller. The crGenerateErrorReport() doesn't terminate the caller process. +* +* The crash report may contain the crash minidump file, crash description file in XML format and +* additional custom files added with a function like crAddFile2(). +* +* The exception information should be passed using \ref CR_EXCEPTION_INFO structure. +* +* The following example shows how to use crGenerateErrorReport() function. +* +* \code +* CR_EXCEPTION_INFO ei; +* memset(&ei, 0, sizeof(CR_EXCEPTION_INFO)); +* ei.cb = sizeof(CR_EXCEPTION_INFO); +* ei.exctype = CR_SEH_EXCEPTION; +* ei.code = 1234; +* ei.pexcptrs = NULL; +* +* int result = crGenerateErrorReport(&ei); +* +* if(result!=0) +* { +* // If goes here, crGenerateErrorReport() has failed +* // Get the last error message +* TCHAR szErrorMsg[256]; +* crGetLastErrorMsg(szErrorMsg, 256); +* } +* +* // Manually terminate program +* ExitProcess(0); +* +* \endcode +*/ + +CRASHRPTAPI(int) +crGenerateErrorReport( + __in_opt CR_EXCEPTION_INFO* pExceptionInfo + ); + +/*! \ingroup CrashRptAPI +* \brief Can be used as a SEH exception filter. +* +* \return This function returns \c EXCEPTION_EXECUTE_HANDLER if succeeds; otherwise \c EXCEPTION_CONTINUE_SEARCH. +* +* \param[in] code Exception code. +* \param[in] ep Exception pointers. +* +* \remarks +* +* This function can be called instead of a SEH exception filter +* inside of __try{}__except(Expression){} construction. The function generates an error report +* and returns control to the exception handler block. +* +* The exception code is usually retrieved with \b GetExceptionCode() intrinsic function +* and the exception pointers are retrieved with \b GetExceptionInformation() intrinsic +* function. +* +* If an error occurs, this function returns \c EXCEPTION_CONTINUE_SEARCH. +* Use crGetLastErrorMsg() to retrieve the error message on fail. +* +* The following example shows how to use crExceptionFilter(). +* +* \code +* int* p = NULL; // pointer to NULL +* __try +* { +* *p = 13; // causes an access violation exception; +* } +* __except(crExceptionFilter(GetExceptionCode(), GetExceptionInformation())) +* { +* // Terminate program +* ExitProcess(1); +* } +* +* \endcode +*/ + +CRASHRPTAPI(int) +crExceptionFilter( + unsigned int code, + __in_opt struct _EXCEPTION_POINTERS* ep); + + +// Flags used by crEmulateCrash() function +#define CR_NONCONTINUABLE_EXCEPTION 32 //!< Non continuable sofware exception. +#define CR_THROW 33 //!< Throw C++ typed exception. +#define CR_STACK_OVERFLOW 34 //!< Stack overflow. + +/*! \ingroup CrashRptAPI +* \brief Emulates a predefined crash situation. +* +* \return This function doesn't return if succeded. If failed, returns non-zero value. Call crGetLastErrorMsg() +* to get the last error message. +* +* \param[in] ExceptionType Type of crash. +* +* \remarks +* +* This function uses some a priori incorrect or vulnerable code or raises a C++ signal or raises an uncontinuable +* software exception to cause crash. +* +* This function can be used to test if CrashRpt handles a crash situation correctly. +* +* CrashRpt will intercept an error or exception if crInstall() and/or crInstallToCurrentThread2() +* were previously called. crInstall() installs exception handlers that function on per-process basis. +* crInstallToCurrentThread2() installs exception handlers that function on per-thread basis. +* +* \a ExceptionType can be one of the following constants: +* - \ref CR_SEH_EXCEPTION This will generate a null pointer exception. +* - \ref CR_CPP_TERMINATE_CALL This results in call of terminate() C++ function. +* - \ref CR_CPP_UNEXPECTED_CALL This results in call of unexpected() C++ function. +* - \ref CR_CPP_PURE_CALL This emulates a call of pure virtual method call of a C++ class instance (Visual Studio .NET 2003 and later). +* - \ref CR_CPP_NEW_OPERATOR_ERROR This emulates C++ new operator failure (Visual Studio .NET 2003 and later). +* - \ref CR_CPP_SECURITY_ERROR This emulates copy of large amount of data to a small buffer (Visual Studio .NET 2003 only). +* - \ref CR_CPP_INVALID_PARAMETER This emulates an invalid parameter C++ exception (Visual Studio 2005 and later). +* - \ref CR_CPP_SIGABRT This raises SIGABRT signal (abnormal program termination). +* - \ref CR_CPP_SIGFPE This causes floating point exception. +* - \ref CR_CPP_SIGILL This raises SIGILL signal (illegal instruction signal). +* - \ref CR_CPP_SIGINT This raises SIGINT signal. +* - \ref CR_CPP_SIGSEGV This raises SIGSEGV signal. +* - \ref CR_CPP_SIGTERM This raises SIGTERM signal (program termination request). +* - \ref CR_NONCONTINUABLE_EXCEPTION This raises a noncontinuable software exception (expected result +* is the same as in \ref CR_SEH_EXCEPTION). +* - \ref CR_THROW This throws a C++ typed exception (expected result is the same as in \ref CR_CPP_TERMINATE_CALL). +* - \ref CR_STACK_OVERFLOW This causes stack overflow. +* +* The \ref CR_SEH_EXCEPTION uses null pointer write operation to cause the access violation. +* +* The \ref CR_NONCONTINUABLE_EXCEPTION has the same effect as \ref CR_SEH_EXCEPTION, but it uses +* \b RaiseException() WinAPI function to raise noncontinuable software exception. +* +* The following example shows how to use crEmulateCrash() function. +* +* \code +* // emulate null pointer exception (access violation) +* crEmulateCrash(CR_SEH_EXCEPTION); +* \endcode +* +*/ + +#if _MSC_VER >= 1900 +CRASHRPTAPI(int) +crEmulateCrash( + unsigned ExceptionType) noexcept(false); +#else +CRASHRPTAPI(int) +crEmulateCrash( + unsigned ExceptionType) throw(...); +#endif + + + +/*! \ingroup CrashRptAPI +* \brief Gets the last CrashRpt error message. +* +* \return This function returns length of error message in characters. If output buffer is invalid, returns a negative number. +* +* \param[out] pszBuffer Pointer to the buffer. +* \param[in] uBuffSize Size of buffer in characters. +* +* \remarks +* +* This function gets the last CrashRpt error message. You can use this function +* to retrieve the text status of the last called CrashRpt function. +* +* If buffer is too small for the error message, the message is truncated. +* +* crGetLastErrorMsgW() and crGetLastErrorMsgA() are wide-character and multi-byte character versions +* of crGetLastErrorMsg(). The crGetLastErrorMsg() macro defines character set independent mapping. +* +* The following example shows how to use crGetLastErrorMsg() function. +* +* \code +* +* // .. call some CrashRpt function +* +* // Get the status message +* TCHAR szErrorMsg[256]; +* crGetLastErrorMsg(szErrorMsg, 256); +* \endcode +* +* \sa crGetLastErrorMsgA(), crGetLastErrorMsgW(), crGetLastErrorMsg() +*/ + +CRASHRPTAPI(int) +crGetLastErrorMsgW( + __out_ecount_z(uBuffSize) LPWSTR pszBuffer, + UINT uBuffSize); + +/*! \ingroup CrashRptAPI +* \copydoc crGetLastErrorMsgW() +* +*/ + +CRASHRPTAPI(int) +crGetLastErrorMsgA( + __out_ecount_z(uBuffSize) LPSTR pszBuffer, + UINT uBuffSize); + +/*! \brief Defines character set-independent mapping for crGetLastErrorMsgW() and crGetLastErrorMsgA(). +* \ingroup CrashRptAPI +*/ + +#ifdef UNICODE +#define crGetLastErrorMsg crGetLastErrorMsgW +#else +#define crGetLastErrorMsg crGetLastErrorMsgA +#endif //UNICODE + + +//// Helper wrapper classes + +#ifndef _CRASHRPT_NO_WRAPPERS + +/*! \class CrAutoInstallHelper +* \ingroup CrashRptWrappers +* \brief Installs exception handlers in constructor and uninstalls in destructor. +* \remarks +* Use this class to easily install/uninstall exception handlers in you \b main() +* or \b WinMain() function. +* +* This wrapper class calls crInstall() in its constructor and calls crUninstall() in +* its destructor. +* +* Use CrAutoInstallHelper::m_nInstallStatus member to check the return status of crInstall(). +* +* Example: +* +* \code +* #include +* +* void main() +* { +* CR_INSTALL_INFO info; +* memset(&info, 0, sizeof(CR_INSTALL_INFO)); +* info.cb = sizeof(CR_INSTALL_INFO); +* info.pszAppName = _T("My App Name"); +* info.pszAppVersion = _T("1.2.3"); +* info.pszEmailSubject = "Error Report from My App v.1.2.3"; +* // The address to send reports by E-mail +* info.pszEmailTo = _T("myname@hotmail.com"); +* // The URL to send reports via HTTP connection +* info.pszUrl = _T("http://myappname.com/utils/crashrpt.php"); +* info.pfnCrashCallback = CrashCallback; +* info.uPriorities[CR_HTTP] = 3; // Try HTTP first +* info.uPriorities[CR_SMTP] = 2; // Try SMTP second +* info.uPriorities[CR_SMAPI] = 1; // Try system email program last +* +* // Install crash reporting +* CrAutoInstallHelper cr_install_helper(&info); +* // Check that installed OK +* assert(cr_install_helper.m_nInstallStatus==0); +* +* // Your code follows here ... +* +* } +* \endcode +*/ + +class CrAutoInstallHelper +{ +public: + + //! Installs exception handlers to the caller process + CrAutoInstallHelper(__in PCR_INSTALL_INFOA pInfo) + { + m_nInstallStatus = crInstallA(pInfo); + } + + //! Installs exception handlers to the caller process + CrAutoInstallHelper(__in PCR_INSTALL_INFOW pInfo) + { + m_nInstallStatus = crInstallW(pInfo); + } + + //! Uninstalls exception handlers from the caller process + ~CrAutoInstallHelper() + { + if(m_nInstallStatus==0) + crUninstall(); + } + + //! Install status + int m_nInstallStatus; +}; + +/*! \class CrThreadAutoInstallHelper +* \ingroup CrashRptWrappers +* \brief Installs (uninstalls) exception handlers for the caller thread in class' constructor (destructor). +* +* \remarks +* +* This wrapper class calls crInstallToCurrentThread2() in its constructor and +* calls crUninstallFromCurrentThread() in its destructor. +* +* Use CrThreadAutoInstallHelper::m_nInstallStatus member to check +* the return status of crInstallToCurrentThread2(). +* +* Example: +* +* \code +* DWORD WINAPI ThreadProc(LPVOID lpParam) +* { +* CrThreadAutoInstallHelper cr_thread_install_helper(); +* assert(cr_thread_install_helper.m_nInstallStatus==0); +* +* // Your code follows here ... +* } +* \endcode +*/ + +class CrThreadAutoInstallHelper +{ +public: + + //! Installs exception handlers to the caller thread + CrThreadAutoInstallHelper(DWORD dwFlags=0) + { + m_nInstallStatus = crInstallToCurrentThread2(dwFlags); + } + + //! Uninstalls exception handlers from the caller thread + ~CrThreadAutoInstallHelper() + { + if (m_nInstallStatus == 0) + crUninstallFromCurrentThread(); + } + + //! Install status + int m_nInstallStatus; +}; + +#endif //!_CRASHRPT_NO_WRAPPERS + +#endif //_CRASHRPT_H_ + + diff --git a/crashrpt/win64/include/CrashRptProbe.h b/crashrpt/win64/include/CrashRptProbe.h new file mode 100644 index 0000000..e5eb069 --- /dev/null +++ b/crashrpt/win64/include/CrashRptProbe.h @@ -0,0 +1,470 @@ +/************************************************************************************* +This file is a part of CrashRpt library. +Copyright (c) 2003-2013 The CrashRpt project authors. All Rights Reserved. + +Use of this source code is governed by a BSD-style license +that can be found in the License.txt file in the root of the source +tree. All contributing project authors may +be found in the Authors.txt file in the root of the source tree. +***************************************************************************************/ + +/*! \file CrashRptProbe.h +* \brief Defines the interface for the CrashRptProbe.DLL. +* \date 2009-2011 +* \author zexspectrum +*/ + +#ifndef __CRASHRPT_PROBE_H__ +#define __CRASHRPT_PROBE_H__ + +#ifdef __cplusplus +#define CRASHRPTPROBE_EXTERNC extern "C" +#else +#define CRASHRPTPROBE_EXTERNC +#endif + +// Define SAL macros to be empty if some old Visual Studio used +#ifndef __reserved +#define __reserved +#endif +#ifndef __in +#define __in +#endif +#ifndef __in_opt +#define __in_opt +#endif +#ifndef __out +#define __out +#endif +#ifndef __out_ecount +#define __out_ecount(x) +#endif +#ifndef __out_ecount_z +#define __out_ecount_z(x) +#endif + +#define CRASHRPTPROBE_API(rettype) CRASHRPTPROBE_EXTERNC rettype WINAPI + +//! Handle to an opened error report. +typedef int CrpHandle; + +/*! \defgroup CrashRptProbeAPI CrashRptProbe Functions*/ + +/*! \ingroup CrashRptProbeAPI +* \brief Opens a zipped crash report file. +* +* \return This function returns zero on success. +* +* \param[in] pszFileName Zipped report file name. +* \param[in] pszMd5Hash String containing MD5 hash for the ZIP file data. +* \param[in] pszSymSearchPath Symbol files (PDB) search path. +* \param[in] dwFlags Flags, reserved for future use. +* \param[out] phReport Handle to the opened crash report. +* +* \remarks +* +* Use this function to open a ZIP archive containing an error report. The error report typically contains +* several compressed files, such as XML crash description file, crash minidump file, and (optionally) +* application-defined files. +* +* \a pszFileName should be the name of the error report (ZIP file) to open. Absolute or relative path accepted. +* This parameter is required. +* +* \a pszMd5Hash is a string containing the MD5 hash calculated for \a pszFileName. The MD5 +* hash is a sequence of 16 characters being used for integrity checks. +* If this parameter is NULL, integrity check is not performed. +* +* If the error report is delivered by HTTP, the MD5 hash can be extracted by server-side script from the +* 'md5' parameter. When the error report is delivered by email, the MD5 hash is attached to the mail message. +* The integrity check can be performed to ensure the error report was not corrupted during delivery. +* For more information, see \ref sending_error_reports. +* +* \a pszSymSearchPath parameter defines where to look for symbols files (*.PDB). You can specify the list of +* semicolon-separated directories to search in. If this parameter is NULL, the default search sequence is used. +* For the default search sequence, see the documentation for \b SymInitialize() function in MSDN. +* +* Symbol files are required for crash report processing. They contain various information used by the debugger. +* For more information about saving symbol files, see \ref preparing_to_software_release. +* +* \a dwFlags is currently not used, should be zero. +* +* \a phReport parameter receives the handle to the opened crash report. If the function fails, +* this parameter becomes zero. +* +* This function does the following when opening report file: +* - It performs integrity checks for the error report being opened, if MD5 hash is specified. +* - It searches for crashrpt.xml and crashdump.dml files inside of ZIP archive, if such files +* do not present, it assumes the report was generated by CrashRpt v1.0. In such case it searches for +* any file having *.dmp or *.xml extension and assumes these are valid XML and DMP file. +* - It extracts and loads the XML file and checks its structure. +* - It extracts the minidump file to the temporary location. +* +* On failure, use crpGetLastErrorMsg() function to get the last error message. +* +* Use the crpCloseErrorReport() function to close the opened error report. +* +* \note +* +* The crpOpenErrorReportW() and crpOpenErrorReportA() are wide character and multibyte +* character versions of crpOpenErrorReport(). +* +* +* \sa +* crpCloseErrorReport() +*/ + +CRASHRPTPROBE_API(int) +crpOpenErrorReportW( + __in LPCWSTR pszFileName, + __in_opt LPCWSTR pszMd5Hash, + __in_opt LPCWSTR pszSymSearchPath, + __reserved DWORD dwFlags, + __out CrpHandle* phReport + ); + +/*! \ingroup CrashRptProbeAPI +* \copydoc crpOpenErrorReportW() +* +*/ + +CRASHRPTPROBE_API(int) +crpOpenErrorReportA( + __in LPCSTR pszFileName, + __in_opt LPCSTR pszMd5Hash, + __in_opt LPCSTR pszSymSearchPath, + __reserved DWORD dwFlags, + __out CrpHandle* phReport + ); + +/*! \brief Character set-independent mapping of crpOpenErrorReportW() and crpOpenErrorReportA() functions. +* \ingroup CrashRptProbeAPI +*/ + +#ifdef UNICODE +#define crpOpenErrorReport crpOpenErrorReportW +#else +#define crpOpenErrorReport crpOpenErrorReportA +#endif //UNICODE + +/*! \ingroup CrashRptProbeAPI +* \brief Closes the crash report. +* \return This function returns zero on success. +* \param[in] hReport Handle to the opened error report. +* +* \remarks +* +* Use this function to close the error report previously opened with crpOpenErrorReport() +* function. +* +* If this function fails, use crpGetLastErrorMsg() function to get the error message. +* +* \sa +* crpOpenErrorReport(), crpOpenErrorReportW(), crpOpenErrorReportA(), crpGetLastErrorMsg() +*/ + +CRASHRPTPROBE_API(int) +crpCloseErrorReport( + CrpHandle hReport + ); + +/* Table names passed to crpGetProperty() function. */ + +#define CRP_TBL_XMLDESC_MISC _T("XmlDescMisc") //!< Table: Miscellaneous info contained in crash description XML file. +#define CRP_TBL_XMLDESC_FILE_ITEMS _T("XmlDescFileItems") //!< Table: The list of file items contained in error report. +#define CRP_TBL_XMLDESC_CUSTOM_PROPS _T("XmlDescCustomProps") //!< Table: The list of application-defined properties (available since v.1.2.1). +#define CRP_TBL_MDMP_MISC _T("MdmpMisc") //!< Table: Miscellaneous info contained in crash minidump file. +#define CRP_TBL_MDMP_MODULES _T("MdmpModules") //!< Table: The list of loaded modules. +#define CRP_TBL_MDMP_THREADS _T("MdmpThreads") //!< Table: The list of threads. +#define CRP_TBL_MDMP_LOAD_LOG _T("MdmpLoadLog") //!< Table: Minidump loading log. + +/* Meta information */ + +#define CRP_META_ROW_COUNT _T("RowCount") //!< Row count in the table. + +/* Column names passed to crpGetProperty() function. */ + +// Columns IDs of the CRP_XMLDESC_MISC table +#define CRP_COL_CRASHRPT_VERSION _T("CrashRptVersion") //!< Column: Version of CrashRpt library that generated the report. +#define CRP_COL_CRASH_GUID _T("CrashGUID") //!< Column: Globally unique identifier (GUID) of the error report. +#define CRP_COL_APP_NAME _T("AppName") //!< Column: Application name. +#define CRP_COL_APP_VERSION _T("AppVersion") //!< Column: Application version. +#define CRP_COL_IMAGE_NAME _T("ImageName") //!< Column: Path to the executable file. +#define CRP_COL_OPERATING_SYSTEM _T("OperatingSystem") //!< Column: Opration system name, including build number and service pack. +#define CRP_COL_SYSTEM_TIME_UTC _T("SystemTimeUTC") //!< Column: Time (UTC) when the crash occured. +#define CRP_COL_EXCEPTION_TYPE _T("ExceptionType") //!< Column: Code of exception handler that cought the exception. +#define CRP_COL_EXCEPTION_CODE _T("ExceptionCode") //!< Column: Exception code; for the structured exceptions only. +#define CRP_COL_INVPARAM_FUNCTION _T("InvParamFunction") //!< Column: Function name; for invalid parameter errors only. +#define CRP_COL_INVPARAM_EXPRESSION _T("InvParamExpression") //!< Column: Expression; for invalid parameter errors only. +#define CRP_COL_INVPARAM_FILE _T("InvParamFile") //!< Column: Source file name; for invalid parameter errors only. +#define CRP_COL_INVPARAM_LINE _T("InvParamLine") //!< Column: Source line; for invalid parameter errors only. +#define CRP_COL_FPE_SUBCODE _T("FPESubcode") //!< Column: Subcode of floating point exception; for FPE exceptions only. +#define CRP_COL_USER_EMAIL _T("UserEmail") //!< Column: Email of the user who sent this report. +#define CRP_COL_PROBLEM_DESCRIPTION _T("ProblemDescription") //!< Column: User-provided problem description. +#define CRP_COL_MEMORY_USAGE_KBYTES _T("MemoryUsageKbytes") //!< Column: Memory usage at the moment of crash (in KB). +#define CRP_COL_GUI_RESOURCE_COUNT _T("GUIResourceCount") //!< Column: Count of used GUI resources at the moment of crash. +#define CRP_COL_OPEN_HANDLE_COUNT _T("OpenHandleCount") //!< Column: Count of open handles at the moment of crash. +#define CRP_COL_OS_IS_64BIT _T("OSIs64Bit") //!< Column: Operating system is 64-bit. +#define CRP_COL_GEO_LOCATION _T("GeoLocation") //!< Column: Geographic location of the error report sender. + +// Column IDs of the CRP_XMLDESC_FILE_ITEMS table +#define CRP_COL_FILE_ITEM_NAME _T("FileItemName") //!< Column: File list: Name of the file contained in the report. +#define CRP_COL_FILE_ITEM_DESCRIPTION _T("FileItemDescription") //!< Column: File list: Description of the file contained in the report. + +// Column IDs of the CRP_XMLDESC_CUSTOM_PROPS table +#define CRP_COL_PROPERTY_NAME _T("PropertyName") //!< Column: Name of the application-defined property. +#define CRP_COL_PROPERTY_VALUE _T("PropertyValue") //!< Column: Value of the application-defined property. + +// Column IDs of the CRP_MDMP_MISC table +#define CRP_COL_CPU_ARCHITECTURE _T("CPUArchitecture") //!< Column: Processor architecture. +#define CRP_COL_CPU_COUNT _T("CPUCount") //!< Column: Number of processors. +#define CRP_COL_PRODUCT_TYPE _T("ProductType") //!< Column: Type of system (server or workstation). +#define CRP_COL_OS_VER_MAJOR _T("OSVerMajor") //!< Column: OS major version. +#define CRP_COL_OS_VER_MINOR _T("OSVerMinor") //!< Column: OS minor version. +#define CRP_COL_OS_VER_BUILD _T("OSVerBuild") //!< Column: OS build number. +#define CRP_COL_OS_VER_CSD _T("OSVerCSD") //!< Column: The latest service pack installed. +#define CRP_COL_EXCPTRS_EXCEPTION_CODE _T("ExptrsExceptionCode") //!< Column: Code of the structured exception. +#define CRP_COL_EXCEPTION_ADDRESS _T("ExceptionAddress") //!< Column: Exception address. +#define CRP_COL_EXCEPTION_THREAD_ROWID _T("ExceptionThreadROWID") //!< Column: ROWID in \ref CRP_TBL_MDMP_THREADS of the thread in which exception occurred. +#define CRP_COL_EXCEPTION_THREAD_STACK_MD5 _T("ExceptionThreadStackMD5") //!< Column: MD5 hash of the stack trace of the thread where exception occurred. +#define CRP_COL_EXCEPTION_MODULE_ROWID _T("ExceptionModuleROWID") //!< Column: ROWID in \ref CRP_TBL_MDMP_MODULES of the module in which exception occurred. + +// Column IDs of the CRP_MDMP_MODULES table +#define CRP_COL_MODULE_NAME _T("ModuleName") //!< Column: Module name. +#define CRP_COL_MODULE_IMAGE_NAME _T("ModuleImageName") //!< Column: Image name containing full path. +#define CRP_COL_MODULE_BASE_ADDRESS _T("ModuleBaseAddress") //!< Column: Module base load address. +#define CRP_COL_MODULE_SIZE _T("ModuleSize") //!< Column: Module size. +#define CRP_COL_MODULE_LOADED_PDB_NAME _T("LoadedPDBName") //!< Column: The full path and file name of the .pdb file. +#define CRP_COL_MODULE_LOADED_IMAGE_NAME _T("LoadedImageName") //!< Column: The full path and file name of executable file. +#define CRP_COL_MODULE_SYM_LOAD_STATUS _T("ModuleSymLoadStatus") //!< Column: Symbol load status for the module. + +// Column IDs of the CRP_MDMP_THREADS table +#define CRP_COL_THREAD_ID _T("ThdeadID") //!< Column: Thread ID. +#define CRP_COL_THREAD_STACK_TABLEID _T("ThreadStackTABLEID") //!< Column: The table ID of the table containing stack trace for this thread. + +// Column IDs of a stack trace table +#define CRP_COL_STACK_MODULE_ROWID _T("StackModuleROWID") //!< Column: Stack trace: ROWID of the module in the CRP_TBL_MODULES table. +#define CRP_COL_STACK_SYMBOL_NAME _T("StackSymbolName") //!< Column: Stack trace: symbol name. +#define CRP_COL_STACK_OFFSET_IN_SYMBOL _T("StackOffsetInSymbol") //!< Column: Stack trace: offset in symbol, hexadecimal. +#define CRP_COL_STACK_SOURCE_FILE _T("StackSourceFile") //!< Column: Stack trace: source file name. +#define CRP_COL_STACK_SOURCE_LINE _T("StackSourceLine") //!< Column: Stack trace: source file line number. +#define CRP_COL_STACK_ADDR_PC_OFFSET _T("StackAddrPCOffset") //!< Column: Stack trace: AddrPC offset. + +// Column IDs of the CRP_MDMP_LOAD_LOG table +#define CRP_COL_LOAD_LOG_ENTRY _T("LoadLogEntry") //!< Column: A entry of the minidump loading log. + +/*! \ingroup CrashRptProbeAPI +* \brief Retrieves a string property from crash report. +* \return This function returns zero on success, with one exception (see Remarks for more information). +* +* \param[in] hReport Handle to the previously opened crash report. +* \param[in] lpszTableId Table ID. +* \param[in] lpszColumnId Column ID. +* \param[in] nRowIndex Index of the row in the table. +* \param[out] lpszBuffer Output buffer. +* \param[in] cchBuffSize Size of the output buffer in characters. +* \param[out] pcchCount Count of characters written to the buffer. +* +* \remarks +* +* Use this function to retrieve data from the crash report that was previously opened with the +* crpOpenErrorReport() function. +* +* Properties are organized into tables having rows and columns. For the list of available tables, +* see \ref using_crashrptprobe_api. +* +* To get the number of rows in a table, pass the constant \ref CRP_META_ROW_COUNT as column ID. In this case the +* function returns number of rows as its return value, or negative value on failure. +* +* In all other cases the function returns zero on success. +* +* Some properties are loaded from crash description XML file, while others are loaded from crash minidump file. +* The minidump is loaded once when you retrive a property from it. This reduces the overall processing time. +* +* \a hReport should be the handle to the opened error report. +* +* \a lpszTableId represente the ID of the table. +* +* \a lpszColumnId represents the ID of the column in the table. +* +* \a nRowIndex defines the zero-based index of the row in the table. +* +* \a lpszBuffer defines the buffer where retrieved property value will be placed. If this parameter +* is NULL, it is ignored and \a pcchCount is set with the required size in characters of the buffer. +* +* \a cchBuffSize defines the buffer size in characters. To calculate required buffer size, set \a lpszBuffer with NULL, +* the function will set \a pcchCount with the number of characters required. +* +* \a pcchCount is set with the actual count of characters copied to the \a lpszBuffer. If this parameter is NULL, +* it is ignored. +* +* If this function fails, use crpGetLastErrorMsg() function to get the error message. +* +* For code examples of using this function, see \ref crashrptprobe_api_examples. +* +* \note +* The crpGetPropertyW() and crpGetPropertyA() are wide character and multibyte +* character versions of crpGetProperty(). +* +* \sa +* crpGetPropertyW(), crpGetPropertyA(), crpOpenErrorReport(), crpGetLastErrorMsg() +*/ + +CRASHRPTPROBE_API(int) +crpGetPropertyW( + CrpHandle hReport, + LPCWSTR lpszTableId, + LPCWSTR lpszColumnId, + INT nRowIndex, + __out_ecount_z(pcchBuffSize) LPWSTR lpszBuffer, + ULONG cchBuffSize, + __out PULONG pcchCount + ); + +/*! \ingroup CrashRptProbeAPI +* \copydoc crpGetPropertyW() +* +*/ + +CRASHRPTPROBE_API(int) +crpGetPropertyA( + CrpHandle hReport, + LPCSTR lpszTableId, + LPCSTR lpszColumnId, + INT nRowIndex, + __out_ecount_z(pcchBuffSize) LPSTR lpszBuffer, + ULONG cchBuffSize, + __out PULONG pcchCount + ); + +/*! \brief Character set-independent mapping of crpGetPropertyW() and crpGetPropertyA() functions. +* \ingroup CrashRptProbeAPI +*/ + +#ifdef UNICODE +#define crpGetProperty crpGetPropertyW +#else +#define crpGetProperty crpGetPropertyA +#endif //UNICODE + +/*! \ingroup CrashRptProbeAPI +* \brief Extracts a file from the opened error report. +* \return This function returns zero if succeeded. +* +* \param[in] hReport Handle to the opened error report. +* \param[in] lpszFileName The name of the file to extract. +* \param[in] lpszFileSaveAs The resulting name of the extracted file. +* \param[in] bOverwriteExisting Overwrite the destination file if it already exists? +* +* \remarks +* +* Use this function to extract a compressed file from the error report (ZIP) file. +* +* \a lpszFileName parameter should be the name of the file to extract. For more information +* about enumerating file names, see \ref crashrptprobe_api_examples. +* +* \a lpszFileSaveAs defines the name of the file to extract to. +* +* \a bOverwriteExisting flag defines the behavior when the destination file already exists. +* If this parameter is TRUE, the file is overwritten, otherwise the function fails. +* +* If this function fails, use crpGetLastErrorMsg() to retrieve the error message. +* +* \note +* The crpExtractFileW() and crpExtractFileA() are wide character and multibyte +* character versions of crpExtractFile(). +* +* \sa +* crpExtractFileA(), crpExtractFileW(), crpExtractFile() +*/ + +CRASHRPTPROBE_API(int) +crpExtractFileW( + CrpHandle hReport, + LPCWSTR lpszFileName, + LPCWSTR lpszFileSaveAs, + BOOL bOverwriteExisting + ); + +/*! \ingroup CrashRptProbeAPI +* \copydoc crpExtractFileW() +*/ + +CRASHRPTPROBE_API(int) +crpExtractFileA( + CrpHandle hReport, + LPCSTR lpszFileName, + LPCSTR lpszFileSaveAs, + BOOL bOverwriteExisting + ); + +/*! \brief Character set-independent mapping of crpExtractFileW() and crpExtractFileA() functions. +* \ingroup CrashRptProbeAPI +*/ + +#ifdef UNICODE +#define crpExtractFile crpExtractFileW +#else +#define crpExtractFile crpExtractFileA +#endif //UNICODE + +/*! \ingroup CrashRptProbeAPI +* \brief Gets the last CrashRptProbe error message. +* +* \return This function returns length of error message in characters. +* +* \param[out] pszBuffer Pointer to the buffer. +* \param[in] cchBuffSize Size of buffer in characters. +* +* \remarks +* +* This function gets the last CrashRptProbe error message. You can use this function +* to retrieve the text status of the last called CrashRptProbe function. +* +* If buffer is too small for the error message, the message is truncated. +* +* \note +* crpGetLastErrorMsgW() and crpGetLastErrorMsgA() are wide-character and multi-byte character versions +* of crpGetLastErrorMsg(). The crpGetLastErrorMsg() macro defines character set independent mapping. +* +* The following example shows how to use crpGetLastErrorMsg() function. +* +* \code +* +* // .. call some CrashRptProbe function +* +* // Get the status message +* TCHAR szErrorMsg[256]; +* crpGetLastErrorMsg(szErrorMsg, 256); +* \endcode +* +* \sa crpGetLastErrorMsgA(), crpGetLastErrorMsgW(), crpGetLastErrorMsg() +*/ + +CRASHRPTPROBE_API(int) +crpGetLastErrorMsgW( + __out_ecount(cchBuffSize) LPWSTR pszBuffer, + __in UINT cchBuffSize); + +/*! \ingroup CrashRptProbeAPI +* \copydoc crpGetLastErrorMsgW() +* +*/ + +CRASHRPTPROBE_API(int) +crpGetLastErrorMsgA( + __out_ecount(cchBuffSize) LPSTR pszBuffer, + __in UINT cchBuffSize); + +/*! \brief Defines character set-independent mapping for crpGetLastErrorMsgW() and crpGetLastErrorMsgA(). +* \ingroup CrashRptProbeAPI +*/ + +#ifdef UNICODE +#define crpGetLastErrorMsg crpGetLastErrorMsgW +#else +#define crpGetLastErrorMsg crpGetLastErrorMsgA +#endif //UNICODE + + +#endif __CRASHRPT_PROBE_H__ + diff --git a/crashrpt/win64/lib/dll/CrashRpt1500.dll b/crashrpt/win64/lib/dll/CrashRpt1500.dll new file mode 100644 index 0000000..990de5d Binary files /dev/null and b/crashrpt/win64/lib/dll/CrashRpt1500.dll differ diff --git a/crashrpt/win64/lib/dll/CrashRpt1500d.dll b/crashrpt/win64/lib/dll/CrashRpt1500d.dll new file mode 100644 index 0000000..690a860 Binary files /dev/null and b/crashrpt/win64/lib/dll/CrashRpt1500d.dll differ diff --git a/crashrpt/win64/lib/dll/CrashSender1500.exe b/crashrpt/win64/lib/dll/CrashSender1500.exe new file mode 100644 index 0000000..16f25b2 Binary files /dev/null and b/crashrpt/win64/lib/dll/CrashSender1500.exe differ diff --git a/crashrpt/win64/lib/dll/CrashSender1500d.exe b/crashrpt/win64/lib/dll/CrashSender1500d.exe new file mode 100644 index 0000000..2f6bea1 Binary files /dev/null and b/crashrpt/win64/lib/dll/CrashSender1500d.exe differ diff --git a/crashrpt/win64/lib/static/CrashRpt1500.lib b/crashrpt/win64/lib/static/CrashRpt1500.lib new file mode 100644 index 0000000..3341e24 Binary files /dev/null and b/crashrpt/win64/lib/static/CrashRpt1500.lib differ diff --git a/crashrpt/win64/lib/static/CrashRpt1500.pdb b/crashrpt/win64/lib/static/CrashRpt1500.pdb new file mode 100644 index 0000000..cc9e7a7 Binary files /dev/null and b/crashrpt/win64/lib/static/CrashRpt1500.pdb differ diff --git a/crashrpt/win64/lib/static/CrashSender1500.exe b/crashrpt/win64/lib/static/CrashSender1500.exe new file mode 100644 index 0000000..784e294 Binary files /dev/null and b/crashrpt/win64/lib/static/CrashSender1500.exe differ