CrashRpt.h

Go to the documentation of this file.

// Copyright (c) 2018, Idol Software, Inc.
// All rights reserved.
//
// This file is part of Doctor Dump SDK.
// 
// Redistribution and use in source and binary forms without modification, are permitted provided that the following conditions are met:
// 
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer
//    in the documentation and/or other materials provided with the distribution.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
// USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Project web site https://drdump.com

#ifndef __CRASH_RPT_H__
#define __CRASH_RPT_H__

#include <windows.h>
#include <signal.h>
#include <stdlib.h>
#include <exception>

#if !(defined CRASHRPT_ENABLE_RELEASE_ASSERTS)
#   define CRASHRPT_ENABLE_RELEASE_ASSERTS 1
#   undef CRASHRPT_ENABLE_RELEASE_ASSERTS // this is to make doxygen document CRASHRPT_ENABLE_RELEASE_ASSERTS macro
#elif CRASHRPT_ENABLE_RELEASE_ASSERTS == 1
#   include <assert.h>
#       ifndef _DEBUG
#           undef assert
#           define assert(expr) ((void) (!(expr) && (crash_rpt::SkipDoctorDump_ReportAssertionViolation<__COUNTER__>(__FUNCTION__ ": "#expr " is false" ), true)))
#       endif // !_DEBUG
#endif // CRASHRPT_ENABLE_RELEASE_ASSERTS

namespace crash_rpt {

namespace {

    // This template should be in anonymous namespace since __COUNTER__ is unique only for a single translation unit (as anonymous namespace items)
    template<unsigned uniqueAssertId>
    __forceinline static void SkipDoctorDump_ReportAssertionViolation(LPCSTR dumpGroup)
    {
        static LONG volatile isAlreadyReported = FALSE;
        if (TRUE == InterlockedCompareExchange(&isAlreadyReported, TRUE, FALSE))
            return;
        ::RaiseException(CrashRpt::ExceptionAssertionViolated, 0, 1, reinterpret_cast<ULONG_PTR*>(&dumpGroup));
    }

} // namespace {

struct ExceptionInfo
{
    DWORD   ExceptionInfoSize;          
    BOOL    FromSendReport;             
    PEXCEPTION_POINTERS ExceptionPointers; 
    DWORD   ThreadId;                   
};

enum CrashProcessingCallbackStage
{
    BeforeSendReport,                   
    AfterSendReport                     
};

enum CrashProcessingCallbackResult
{
    DoDefaultActions,                   
    SkipSendReportReturnDefaultResult,  
    ContinueExecution,                  
    ContinueSearch,                     
    ExecuteHandler                      
};

typedef CrashProcessingCallbackResult (CALLBACK *PFNCRASHPROCESSINGCALLBACK)(
    CrashProcessingCallbackStage stage, 
    ExceptionInfo* exceptionInfo,       
    LPVOID  userData                    
    );


namespace custom_data_collection {

    enum Result
    {
        ShowUploadConfirmDialog,    
        DoUpload,                   
        CancelUpload,               
    };

    struct ExceptionInfo
    {
        DWORD   ExceptionInfoSize;  
        LPBYTE  UserData;           
        DWORD   UserDataSize;       
        HANDLE  Process;            
        DWORD   ProcessId;          
        LPVOID  ExceptInfo;         
        BOOL    WasAssert;          
        LPCSTR  DumpGroup;          
        int     DumpID;             
        int     DumpGroupID;        
        int     ProblemID;          
    };

    struct IDataBag
    {
        virtual bool AddFileToReport(
            LPCWSTR path,                       
            LPCWSTR reportFileName /* = NULL */ 
        ) = 0;

        virtual bool RemoveFileFromReport(
            LPCWSTR path                        
        ) = 0;

        virtual bool AddUserInfoToReport(
            LPCWSTR key,                        
            LPCWSTR value                       
        ) = 0;

        virtual bool RemoveUserInfoFromReport(
            LPCWSTR key                        
        ) = 0;
    };

    typedef Result (CALLBACK *PFNCUSTOMDATACOLLECTIONCALLBACK)(
        const ExceptionInfo& exceptionInfo,     
        IDataBag* dataBag                       
        );

    struct Settings
    {
        DWORD   SettingsSize;                   
        LPCWSTR CollectionLibraryPath;          
        LPCSTR  CollectionFunctionName;         
        LPBYTE  UserData;                       
        DWORD   UserDataSize;                   
    };

} // namespace custom_data_collection

namespace crt_error_handlers {

    typedef void(__cdecl *_crt_signal_t)(int);
    typedef _crt_signal_t(__cdecl *pfn_signal)(int sig, _crt_signal_t func);
    typedef void(__cdecl* terminate_function)();
    typedef terminate_function(__cdecl *pfn_set_terminate)(terminate_function);
    typedef void(__cdecl* _invalid_parameter_handler)(wchar_t const*, wchar_t const*, wchar_t const*, unsigned int, uintptr_t);
    typedef _invalid_parameter_handler(__cdecl *pfn_set_invalid_parameter_handler)(_invalid_parameter_handler);
    typedef void(__cdecl* _purecall_handler)(void);
    typedef _purecall_handler(__cdecl *pfn_set_purecall_handler)(_purecall_handler);

    struct Settings
    {
        DWORD                               SettingsSize;               
        pfn_signal                          Signal;                     
        pfn_set_terminate                   SetTerminate;               
        pfn_set_invalid_parameter_handler   SetInvalidParameterHandler; 
        pfn_set_purecall_handler            SetPureCallHandler;         
    };

} // namespace crt_error_handlers

struct ApplicationInfo
{
    DWORD   ApplicationInfoSize;        
    LPCSTR  ApplicationGUID;            
    LPCSTR  Prefix;                     
    LPCWSTR AppName;                    
    LPCWSTR Company;                    
    USHORT  V[4];                       
    USHORT  Hotfix;                     
    LPCWSTR PrivacyPolicyUrl;           
};

struct HandlerSettings
{
    DWORD   HandlerSettingsSize;        
    BOOL    LeaveDumpFilesInTempFolder; 
    BOOL    OpenProblemInBrowser;       
    BOOL    UseWER;                     
    DWORD   SubmitterID;                
    BOOL    SendAdditionalDataWithoutApproval; 
    BOOL    OverrideDefaultFullDumpType;
    DWORD   FullDumpType;               
    LPCWSTR LangFilePath;               
    LPCWSTR SendRptPath;                
    LPCWSTR DbgHelpPath;                
    PFNCRASHPROCESSINGCALLBACK CrashProcessingCallback; 
    LPVOID CrashProcessingCallbackUserData; 
    custom_data_collection::Settings* CustomDataCollectionSettings;
    crt_error_handlers::Settings* CrtErrorHandlersSettings;
};

class CrashRpt
{
public:

    CrashRpt(
        LPCSTR  applicationGUID,            
        LPCWSTR appName,                    
        LPCWSTR company                     
        ) throw()
    {
        if (!LoadDll())
            return;

        InitCrashRpt(applicationGUID, NULL, appName, company, TRUE);
    }

    CrashRpt(
        LPCSTR  applicationGUID,            
        LPCSTR  prefix,                     
        LPCWSTR appName,                    
        LPCWSTR company,                    
        BOOL    ownProcess = TRUE           
        ) throw()
    {
        if (!LoadDll())
            return;

        InitCrashRpt(applicationGUID, prefix, appName, company, ownProcess);
    }

    CrashRpt(
        LPCWSTR crashrptPath,               
        LPCSTR  applicationGUID,            
        LPCSTR  prefix,                     
        LPCWSTR appName,                    
        LPCWSTR company,                    
        BOOL    ownProcess = TRUE           
        ) throw()
    {
        if (!LoadDll(crashrptPath))
            return;

        InitCrashRpt(applicationGUID, prefix, appName, company, ownProcess);
    }

    CrashRpt(
        ApplicationInfo* applicationInfo,   
        HandlerSettings* handlerSettings,   
        BOOL    ownProcess = TRUE           
        ) throw()
    {
        if (!LoadDll())
            return;

        InitCrashRpt(applicationInfo, handlerSettings, ownProcess);
    }

    CrashRpt(
        LPCWSTR crashrptPath,               
        ApplicationInfo* applicationInfo,   
        HandlerSettings* handlerSettings,   
        BOOL    ownProcess = TRUE           
        ) throw()
    {
        if (!LoadDll(crashrptPath))
            return;

        InitCrashRpt(applicationInfo, handlerSettings, ownProcess);
    }


    CrashRpt(
        LPCWSTR crashrptPath = NULL         
        ) throw()
    {
        LoadDll(crashrptPath);
    }

    ~CrashRpt()
    {
        if (!m_IsReadyToExit)
            return;

        // If crash has happen not in main thread we should wait here until report will be sent
        // or else program will be terminated after return from main() and report sending will be halted.
        while (!m_IsReadyToExit())
            ::Sleep(100);

#if _WIN32_WINNT >= 0x0501 /*_WIN32_WINNT_WINXP*/
        if (m_bSkipAssertsAdded)
            RemoveVectoredExceptionHandler(SkipAsserts);
#endif
    }

    bool IsCrashHandlingEnabled() const
    {
        return m_bWorking;
    }

    bool InitCrashRpt(
        ApplicationInfo* applicationInfo,   
        HandlerSettings* handlerSettings,   
        BOOL    ownProcess = TRUE           
        ) throw()
    {
        if (!m_InitCrashRpt)
            return false;

        crt_error_handlers::Settings crtErrorHandlersSettings;
        memset(&crtErrorHandlersSettings, 0, sizeof(crtErrorHandlersSettings));
        crtErrorHandlersSettings.SettingsSize = sizeof(crtErrorHandlersSettings);
        crtErrorHandlersSettings.Signal = signal;
        crtErrorHandlersSettings.SetTerminate = set_terminate;
#if defined(_MSC_VER)
        crtErrorHandlersSettings.SetInvalidParameterHandler = _set_invalid_parameter_handler;
        crtErrorHandlersSettings.SetPureCallHandler = _set_purecall_handler;
#endif

        HandlerSettings defHandlerSettings;
        memset(&defHandlerSettings, 0, sizeof(defHandlerSettings));
        defHandlerSettings.HandlerSettingsSize = sizeof(defHandlerSettings);
        defHandlerSettings.OpenProblemInBrowser = TRUE;
        defHandlerSettings.CrtErrorHandlersSettings = &crtErrorHandlersSettings;

        if (handlerSettings == NULL)
        {
            handlerSettings = &defHandlerSettings;
        }
        else if (handlerSettings->CrtErrorHandlersSettings == NULL)
        {
            handlerSettings->CrtErrorHandlersSettings = &crtErrorHandlersSettings;
        }

        m_bWorking = m_InitCrashRpt(applicationInfo, handlerSettings, ownProcess) != FALSE;

        return m_bWorking;
    }

    bool InitCrashRpt(
        LPCSTR  applicationGUID,            
        LPCSTR  prefix,                     
        LPCWSTR appName,                    
        LPCWSTR company,                    
        BOOL    ownProcess = TRUE           
        ) throw()
    {
        if (!m_GetVersionFromApp)
            return false;

        ApplicationInfo appInfo;
        memset(&appInfo, 0, sizeof(appInfo));
        appInfo.ApplicationInfoSize = sizeof(appInfo);
        appInfo.ApplicationGUID = applicationGUID;
        appInfo.Prefix = prefix;
        appInfo.AppName = appName;
        appInfo.Company = company;
        if (!m_GetVersionFromApp(&appInfo))
            appInfo.V[0] = 1;

        return InitCrashRpt(&appInfo, NULL, ownProcess);
    }

    bool SetCustomInfo(
        LPCWSTR text                        
        )
    {
        if (!m_SetCustomInfo)
            return false;
        m_SetCustomInfo(text);
        return true;
    }

    bool AddUserInfoToReport(
        LPCWSTR key,                        
        LPCWSTR value                       
        ) throw()
    {
        if (!m_AddUserInfoToReport)
            return false;
        m_AddUserInfoToReport(key, value);
        return true;
    }

    bool RemoveUserInfoFromReport(
        LPCWSTR key                        
        )
    {
        if (!m_RemoveUserInfoFromReport)
            return false;
        m_RemoveUserInfoFromReport(key);
        return true;
    }

    bool AddFileToReport(
        LPCWSTR path,                       
        LPCWSTR reportFileName /* = NULL */ 
        ) throw()
    {
        if (!m_AddFileToReport)
            return false;
        m_AddFileToReport(path, reportFileName);
        return true;
    }

    bool RemoveFileFromReport(
        LPCWSTR path    
        ) throw()
    {
        if (!m_RemoveFileFromReport)
            return false;
        m_RemoveFileFromReport(path);
        return true;
    }

    bool GetVersionFromApp(
        ApplicationInfo* appInfo 
        ) throw()
    {
        if (!m_GetVersionFromApp)
            return false;
        return m_GetVersionFromApp(appInfo) != FALSE;
    }

    bool GetVersionFromFile(
        LPCWSTR path,               
        ApplicationInfo* appInfo    
        ) throw()
    {
        if (!m_GetVersionFromFile)
            return false;
        return m_GetVersionFromFile(path, appInfo) != FALSE;
    }

    LONG SendReport(
        EXCEPTION_POINTERS* exceptionPointers   
        )
    {
        if (!m_SendReport)
        {
            // There is no crash handler but asserts should not crash application anyway, so let's continue
            if (exceptionPointers->ExceptionRecord->ExceptionCode == ExceptionAssertionViolated)
                return EXCEPTION_CONTINUE_EXECUTION;
            return EXCEPTION_CONTINUE_SEARCH;
        }
        return m_SendReport(exceptionPointers);
    }

    static const DWORD ExceptionAssertionViolated = ((DWORD)0xCCE17000);

    static const DWORD ExceptionCppTerminate = ((DWORD)0xCCE17001);

    static const DWORD ExceptionPureCall = ((DWORD)0xCCE17002);

    static const DWORD ExceptionInvalidParameter = ((DWORD)0xCCE17003);

    void SkipDoctorDump_SendAssertionViolated(
        LPCSTR dumpGroup = NULL     
        ) const
    {
        if (!m_bWorking)
            return;
        if (dumpGroup)
            ::RaiseException(CrashRpt::ExceptionAssertionViolated, 0, 1, reinterpret_cast<ULONG_PTR*>(&dumpGroup));
        else
            ::RaiseException(CrashRpt::ExceptionAssertionViolated, 0, 0, NULL);
    }

private:
    bool LoadDll(LPCWSTR crashrptPath = NULL) throw()
    {
        m_bLoaded = false;
        m_bWorking = false;
        m_bSkipAssertsAdded = false;
        m_InitCrashRpt = NULL;
        m_SendReport = NULL;
        m_IsReadyToExit = NULL;
        m_SetCustomInfo = NULL;
        m_AddUserInfoToReport = NULL;
        m_RemoveUserInfoFromReport = NULL;
        m_AddFileToReport = NULL;
        m_RemoveFileFromReport = NULL;
        m_GetVersionFromApp = NULL;
        m_GetVersionFromFile = NULL;

        // hCrashrptDll should not be unloaded, crash may appear even after return from main().
        // So hCrashrptDll is not saved after construction.
        HMODULE hCrashrptDll = ::LoadLibraryW(crashrptPath ? crashrptPath : L"crashrpt.dll");
        if (hCrashrptDll != NULL)
        {
            m_InitCrashRpt = (pfnInitCrashRpt) GetProcAddress(hCrashrptDll, "InitCrashRpt");
            m_SendReport = (pfnSendReport) GetProcAddress(hCrashrptDll, "SendReport");
            m_IsReadyToExit = (pfnIsReadyToExit) GetProcAddress(hCrashrptDll, "IsReadyToExit");
            m_SetCustomInfo = (pfnSetCustomInfo) GetProcAddress(hCrashrptDll, "SetCustomInfo");
            m_AddUserInfoToReport = (pfnAddUserInfoToReport) GetProcAddress(hCrashrptDll, "AddUserInfoToReport");
            m_RemoveUserInfoFromReport = (pfnRemoveUserInfoFromReport) GetProcAddress(hCrashrptDll, "RemoveUserInfoFromReport");
            m_AddFileToReport = (pfnAddFileToReport) GetProcAddress(hCrashrptDll, "AddFileToReport");
            m_RemoveFileFromReport = (pfnRemoveFileFromReport) GetProcAddress(hCrashrptDll, "RemoveFileFromReport");
            m_GetVersionFromApp = (pfnGetVersionFromApp) GetProcAddress(hCrashrptDll, "GetVersionFromApp");
            m_GetVersionFromFile = (pfnGetVersionFromFile) GetProcAddress(hCrashrptDll, "GetVersionFromFile");

            m_bLoaded = m_InitCrashRpt
                && m_SendReport
                && m_IsReadyToExit
                && m_SetCustomInfo
                && m_AddUserInfoToReport
                && m_RemoveUserInfoFromReport
                && m_AddFileToReport
                && m_RemoveFileFromReport
                && m_GetVersionFromApp
                && m_GetVersionFromFile;
        }

#if _WIN32_WINNT >= 0x0501 /*_WIN32_WINNT_WINXP*/
        // if no crash processing was started, we need to ignore ExceptionAssertionViolated exceptions.
        if (!m_bLoaded)
        {
            ::AddVectoredExceptionHandler(TRUE, SkipAsserts);
            m_bSkipAssertsAdded = true;
        }
#endif

        return m_bLoaded;
    }

    static LONG CALLBACK SkipAsserts(EXCEPTION_POINTERS* pExceptionInfo)
    {
        if (pExceptionInfo->ExceptionRecord->ExceptionCode == ExceptionAssertionViolated)
            return EXCEPTION_CONTINUE_EXECUTION;
        return EXCEPTION_CONTINUE_SEARCH;
    }

    bool m_bLoaded;
    bool m_bWorking;
    bool m_bSkipAssertsAdded;

    typedef BOOL (__cdecl *pfnInitCrashRpt)(ApplicationInfo* applicationInfo, HandlerSettings* handlerSettings, BOOL ownProcess);
    typedef LONG (__cdecl *pfnSendReport)(EXCEPTION_POINTERS* exceptionPointers);
    typedef BOOL (__cdecl *pfnIsReadyToExit)();
    typedef void (__cdecl *pfnSetCustomInfo)(LPCWSTR text);
    typedef void (__cdecl *pfnAddUserInfoToReport)(LPCWSTR key, LPCWSTR value);
    typedef void (__cdecl *pfnRemoveUserInfoFromReport)(LPCWSTR key);
    typedef void (__cdecl *pfnAddFileToReport)(LPCWSTR path, LPCWSTR reportFileName /* = NULL */);
    typedef void (__cdecl *pfnRemoveFileFromReport)(LPCWSTR path);
    typedef BOOL (__cdecl *pfnGetVersionFromApp)(ApplicationInfo* appInfo);
    typedef BOOL (__cdecl *pfnGetVersionFromFile)(LPCWSTR path, ApplicationInfo* appInfo);

    pfnInitCrashRpt m_InitCrashRpt;
    pfnSendReport m_SendReport;
    pfnIsReadyToExit m_IsReadyToExit;
    pfnSetCustomInfo m_SetCustomInfo;
    pfnAddUserInfoToReport m_AddUserInfoToReport;
    pfnRemoveUserInfoFromReport m_RemoveUserInfoFromReport;
    pfnAddFileToReport m_AddFileToReport;
    pfnRemoveFileFromReport m_RemoveFileFromReport;
    pfnGetVersionFromApp m_GetVersionFromApp;
    pfnGetVersionFromFile m_GetVersionFromFile;
};

} // namespace crash_rpt

#endif // __CRASH_RPT_H__