BugSplat.h

//
// BugSplat.h
//
// This header file contains the code used to add BugSplat crash reporting to
// native Windows applications.
//
// For more information, see the documentation at https://www.bugsplat.com/docs/platforms/cplusplus
//
// Copyright 2003-2019, BugSplat 
// All rights reserved.
//



#ifndef BUGSPLAT_H
#define BUGSPLAT_H

#ifdef BUGSPLAT_EXPORTS
    #define MDS_EXPORT __declspec(dllexport)
#else
    #define MDS_EXPORT __declspec(dllimport)
#endif

#include <eh.h>
#include <new.h>
#include <signal.h>
#include <Windows.h>


typedef bool (__cdecl *MiniDmpSenderCallback)(UINT nCode, LPVOID lVal1, LPVOID lVal2);

// forward declare internal class
class MiniDumper;

class MDS_EXPORT MiniDmpSender 
{
public:
    MiniDmpSender(__wchar_t const *szDatabase,
                  __wchar_t const *szApp,
                  __wchar_t const *szVersion,
                  __wchar_t const *szAppIdentifier = NULL,
                  DWORD dwFlags = 0x04 /* MDSF_PREVENTHIJACKING */
                  );
    virtual ~MiniDmpSender();
public:
    bool enableExceptionFilter(bool enable = true);

    bool isExceptionFilterEnabled() const;

    // the following typedef is identical to MINIDUMP_TYPE; copied here for convenience
    typedef enum _BS_MINIDUMP_TYPE {
        MiniDumpNormal = 0x00000000,
        MiniDumpWithDataSegs = 0x00000001,
        MiniDumpWithFullMemory = 0x00000002,
        MiniDumpWithHandleData = 0x00000004,
        MiniDumpFilterMemory = 0x00000008,
        MiniDumpScanMemory = 0x00000010,
        MiniDumpWithUnloadedModules = 0x00000020,
        MiniDumpWithIndirectlyReferencedMemory = 0x00000040,
        MiniDumpFilterModulePaths = 0x00000080,
        MiniDumpWithProcessThreadData = 0x00000100,
        MiniDumpWithPrivateReadWriteMemory = 0x00000200,
        MiniDumpWithoutOptionalData = 0x00000400,
        MiniDumpWithFullMemoryInfo = 0x00000800,
        MiniDumpWithThreadInfo = 0x00001000,
        MiniDumpWithCodeSegs = 0x00002000,
        MiniDumpWithoutAuxiliaryState = 0x00004000,
        MiniDumpWithFullAuxiliaryState = 0x00008000,
        MiniDumpWithPrivateWriteCopyMemory = 0x00010000,
        MiniDumpIgnoreInaccessibleMemory = 0x00020000,
        MiniDumpWithTokenInformation = 0x00040000,
        MiniDumpWithModuleHeaders = 0x00080000,
        MiniDumpFilterTriage = 0x00100000,
        MiniDumpWithAvxXStateContext = 0x00200000,
        MiniDumpValidTypeFlags = 0x003fffff,
    } BS_MINIDUMP_TYPE;

    MiniDmpSender::BS_MINIDUMP_TYPE getMiniDumpType() const;

    void setMiniDumpType(MiniDmpSender::BS_MINIDUMP_TYPE eType);

    bool disableNetworkAccess(bool enable = true);
    bool isNetworkAccessDisabled() const;

    bool setFlags( DWORD dwFlags );
    DWORD getFlags() const;

    void resetVersionString(const __wchar_t * wszVersion);

    void resetAppIdentifier(const __wchar_t * wszDescription);

    void setNotes(const __wchar_t* wszNotes);

    void sendAdditionalFile(const __wchar_t * wszPath);

    bool removeAdditionalFile(const __wchar_t * wszPath);

    void setLogFilePath(const __wchar_t * wszPath);
    
    void setUserZipPath(const __wchar_t * wszPath);

    void setResourceDllPath(const __wchar_t * wszPath);

    void setDefaultUserName(const __wchar_t * wszName);

    void setDefaultUserEmail(const __wchar_t * wszEmail);

    void setDefaultUserDescription(const __wchar_t * wszDescription);

    void createReport(EXCEPTION_POINTERS * pExcepInfo);

    void createAsanReport(const char* asanMessage);

    void createReport(const __wchar_t * wszXmlReport);
    
    inline void createReportAndExit() { setFlags(getFlags() | 0x02/*MDSF_FORCEEXIT*/); throw NULL; }

    LONG unhandledExceptionHandler( PEXCEPTION_POINTERS pExceptionInfo );

    void setCallback(MiniDmpSenderCallback fnCallback);

    void getMinidumpPath(__wchar_t * buffer, size_t len);

    int setGuardByteBufferSize(int nbytes);

    LPVOID imp();

private:
    MiniDumper * m_pMiniDumper;
};


// ***************************
// Definitions for the dwFlags parameter of MiniDmpSender constructor and the getFlags/setFlags methods.
// The non-interactive flag is for applications that run unattended or without a user interface.  

#define MDSF_NONINTERACTIVE     0x0001

#define MDSF_FORCEEXIT          0x0002

#define MDSF_PREVENTHIJACKING   0x0004

#define MDSF_DETECTHANGS        0x0008

#define MDSF_USEGUARDMEMORY     0x0010

#define MDSF_CUSTOMEXCEPTIONFILTER 0x0020

#define MDSF_SUSPENDALLTHREADS  0x0800

#define MDSF_LOGCONSOLE         0x1000
#define MDSF_LOGFILE            0x2000
#define MDSF_LOG_VERBOSE        0x4000


#define MDSCB_EXCEPTIONCODE            0x0050

//
// Helper functions used to set CRT state.
//
inline void terminator() { int*z = 0; *z = 13; }
inline void signal_handler(int) { terminator(); }
inline void __cdecl invalid_parameter_handler(const wchar_t *, const wchar_t *, const wchar_t *, unsigned int, uintptr_t)
{
    terminator();
}
inline int memory_depleted(size_t)
{
    terminator();
    return 0;
}

// This call should be made once from your app to enable collection of certain CRT exceptions
inline void SetGlobalCRTExceptionBehavior()
{
    // There is a single set_terminate handler for all dynamically linked DLLs or EXEs; 
    // even if you call set_terminate your handler may be replaced by another, 
    // or you may be replacing a handler set by another DLL or EXE.
    // See https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/set-terminate-crt?view=vs-2019
    set_terminate(&terminator);

    // Because there is only one _purecall_handler for each process, when you call _set_purecall_handler 
    // it immediately impacts all threads. The last caller on any thread sets the handler.
    // See https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/get-purecall-handler-set-purecall-handler?view=vs-2019
    _set_purecall_handler(&terminator);

    // Only one function can be specified as the global invalid argument handler at a time. 
    // See https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/set-invalid-parameter-handler-set-thread-local-invalid-parameter-handler?view=vs-2019
    _set_invalid_parameter_handler(&invalid_parameter_handler);

    // There is a single _set_new_handler handler for all dynamically linked DLLs or executables; 
    // even if you call _set_new_handler your handler might be replaced by another or that you are 
    // replacing a handler set by another DLL or executable.
    // See https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/set-new-handler?view=vs-2019
    _set_new_handler(&memory_depleted);
    _set_new_mode(1);
}


// This call should be made in each thread of your application to enable collection of certain CRT exceptions
inline void SetPerThreadCRTExceptionBehavior()
{
    // Signal handling, required for each thread, at least for SIGABRT
    signal(SIGABRT, signal_handler);
    _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
    

    // In a multithreaded environment, unexpected functions are maintained separately for each thread. 
    // Each new thread needs to install its own unexpected function. Thus, each thread is in charge of 
    // its own unexpected handling.
    // See https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/set-unexpected-crt?view=vs-2019
    set_unexpected(&terminator);
}

#endif //~BUGSPLAT_H