[wxWidgets.git] / src / common / debugrpt.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/common/debugrpt.cpp
// Purpose:     wxDebugReport and related classes implementation
// Author:      Vadim Zeitlin
// Modified by:
// Created:     2005-01-17
// RCS-ID:      $Id$
// Copyright:   (c) 2005 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// License:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/log.h"
    #include "wx/intl.h"
    #include "wx/utils.h"
#endif // WX_PRECOMP

#if wxUSE_DEBUGREPORT && wxUSE_XML

#include "wx/debugrpt.h"

#include "wx/ffile.h"
#include "wx/filename.h"
#include "wx/dir.h"
#include "wx/dynlib.h"

#include "wx/xml/xml.h"

#if wxUSE_STACKWALKER
    #include "wx/stackwalk.h"
#endif

#if wxUSE_CRASHREPORT
    #include "wx/msw/crashrpt.h"
#endif

#if wxUSE_ZIPSTREAM
    #include "wx/wfstream.h"
    #include "wx/zipstrm.h"
#endif // wxUSE_ZIPSTREAM

WX_CHECK_BUILD_OPTIONS("wxQA")

// ----------------------------------------------------------------------------
// XmlStackWalker: stack walker specialization which dumps stack in XML
// ----------------------------------------------------------------------------

#if wxUSE_STACKWALKER

class XmlStackWalker : public wxStackWalker
{
public:
    XmlStackWalker(wxXmlNode *nodeStack)
    {
        m_isOk = false;
        m_nodeStack = nodeStack;
    }

    bool IsOk() const { return m_isOk; }

protected:
    virtual void OnStackFrame(const wxStackFrame& frame);

    wxXmlNode *m_nodeStack;
    bool m_isOk;
};

#endif // wxUSE_STACKWALKER

// ----------------------------------------------------------------------------
// local functions
// ----------------------------------------------------------------------------

static inline void
HexProperty(wxXmlNode *node, const wxChar *name, unsigned long value)
{
    node->AddProperty(name, wxString::Format(_T("%08lx"), value));
}

static inline void
NumProperty(wxXmlNode *node, const wxChar *name, unsigned long value)
{
    node->AddProperty(name, wxString::Format(_T("%lu"), value));
}

static inline void
TextElement(wxXmlNode *node, const wxChar *name, const wxString& value)
{
    wxXmlNode *nodeChild = new wxXmlNode(wxXML_ELEMENT_NODE, name);
    node->AddChild(nodeChild);
    nodeChild->AddChild(new wxXmlNode(wxXML_TEXT_NODE, wxEmptyString, value));
}

#if wxUSE_CRASHREPORT && defined(__INTEL__)

static inline void
HexElement(wxXmlNode *node, const wxChar *name, unsigned long value)
{
    TextElement(node, name, wxString::Format(_T("%08lx"), value));
}

#endif // wxUSE_CRASHREPORT

#if wxUSE_STACKWALKER

// ============================================================================
// XmlStackWalker implementation
// ============================================================================

void XmlStackWalker::OnStackFrame(const wxStackFrame& frame)
{
    m_isOk = true;

    wxXmlNode *nodeFrame = new wxXmlNode(wxXML_ELEMENT_NODE, _T("frame"));
    m_nodeStack->AddChild(nodeFrame);

    NumProperty(nodeFrame, _T("level"), frame.GetLevel());
    wxString func = frame.GetName();
    if ( !func.empty() )
    {
        nodeFrame->AddProperty(_T("function"), func);
        HexProperty(nodeFrame, _T("offset"), frame.GetOffset());
    }

    if ( frame.HasSourceLocation() )
    {
        nodeFrame->AddProperty(_T("file"), frame.GetFileName());
        NumProperty(nodeFrame, _T("line"), frame.GetLine());
    }

    const size_t nParams = frame.GetParamCount();
    if ( nParams )
    {
        wxXmlNode *nodeParams = new wxXmlNode(wxXML_ELEMENT_NODE, _T("parameters"));
        nodeFrame->AddChild(nodeParams);

        for ( size_t n = 0; n < nParams; n++ )
        {
            wxXmlNode *
                nodeParam = new wxXmlNode(wxXML_ELEMENT_NODE, _T("parameter"));
            nodeParams->AddChild(nodeParam);

            NumProperty(nodeParam, _T("number"), n);

            wxString type, name, value;
            if ( !frame.GetParam(n, &type, &name, &value) )
                continue;

            if ( !type.empty() )
                TextElement(nodeParam, _T("type"), type);

            if ( !name.empty() )
                TextElement(nodeParam, _T("name"), name);

            if ( !value.empty() )
                TextElement(nodeParam, _T("value"), value);
        }
    }
}

#endif // wxUSE_STACKWALKER

// ============================================================================
// wxDebugReport implementation
// ============================================================================

// ----------------------------------------------------------------------------
// initialization and cleanup
// ----------------------------------------------------------------------------

wxDebugReport::wxDebugReport()
{
    // get a temporary directory name
    wxString appname = GetReportName();

    // we can't use CreateTempFileName() because it creates a file, not a
    // directory, so do our best to create a unique name ourselves
    //
    // of course, this doesn't protect us against malicious users...
    wxFileName fn;
    fn.AssignTempFileName(appname);
    m_dir.Printf(_T("%s%c%s_dbgrpt-%lu-%s"),
                 fn.GetPath().c_str(), wxFILE_SEP_PATH, appname.c_str(),
                 wxGetProcessId(),
                 wxDateTime::Now().Format(_T("%Y%m%dT%H%M%S")).c_str());

    // as we are going to save the process state there use restrictive
    // permissions
    if ( !wxMkdir(m_dir, 0700) )
    {
        wxLogSysError(_("Failed to create directory \"%s\""), m_dir.c_str());
        wxLogError(_("Debug report couldn't be created."));

        Reset();
    }
}

wxDebugReport::~wxDebugReport()
{
    if ( !m_dir.empty() )
    {
        // remove all files in this directory
        wxDir dir(m_dir);
        wxString file;
        for ( bool cont = dir.GetFirst(&file); cont; cont = dir.GetNext(&file) )
        {
            if ( wxRemove(wxFileName(m_dir, file).GetFullPath()) != 0 )
            {
                wxLogSysError(_("Failed to remove debug report file \"%s\""),
                              file.c_str());
                m_dir.clear();
                break;
            }
        }
    }

    if ( !m_dir.empty() )
    {
        // Temp fix: what should this be? eVC++ doesn't like wxRmDir
#ifdef __WXWINCE__
        if ( wxRmdir(m_dir.fn_str()) != 0 )
#else
        if ( wxRmDir(m_dir.fn_str()) != 0 )
#endif
        {
            wxLogSysError(_("Failed to clean up debug report directory \"%s\""),
                          m_dir.c_str());
        }
    }
}

// ----------------------------------------------------------------------------
// various helpers
// ----------------------------------------------------------------------------

wxString wxDebugReport::GetReportName() const
{
    if(wxTheApp)
        return wxTheApp->GetAppName();

    return _T("wx");
}

void
wxDebugReport::AddFile(const wxString& filename, const wxString& description)
{
    wxString name;
    wxFileName fn(filename);
    if ( fn.IsAbsolute() )
    {
        // we need to copy the file to the debug report directory: give it the
        // same name there
        name = fn.GetFullName();
        wxCopyFile(fn.GetFullPath(),
                   wxFileName(GetDirectory(), name).GetFullPath());
    }
    else // file relative to the report directory
    {
        name = filename;

        wxASSERT_MSG( wxFileName(GetDirectory(), name).FileExists(),
                      _T("file should exist in debug report directory") );
    }

    m_files.Add(name);
    m_descriptions.Add(description);
}

bool
wxDebugReport::AddText(const wxString& filename,
                       const wxString& text,
                       const wxString& description)
{
    wxASSERT_MSG( !wxFileName(filename).IsAbsolute(),
                  _T("filename should be relative to debug report directory") );

    wxFileName fn(GetDirectory(), filename);
    wxFFile file(fn.GetFullPath(), _T("w"));
    if ( !file.IsOpened() || !file.Write(text) )
        return false;

    AddFile(filename, description);

    return true;
}

void wxDebugReport::RemoveFile(const wxString& name)
{
    const int n = m_files.Index(name);
    wxCHECK_RET( n != wxNOT_FOUND, _T("No such file in wxDebugReport") );

    m_files.RemoveAt(n);
    m_descriptions.RemoveAt(n);

    wxRemove(wxFileName(GetDirectory(), name).GetFullPath());
}

bool wxDebugReport::GetFile(size_t n, wxString *name, wxString *desc) const
{
    if ( n >= m_files.GetCount() )
        return false;

    if ( name )
        *name = m_files[n];
    if ( desc )
        *desc = m_descriptions[n];

    return true;
}

void wxDebugReport::AddAll(Context context)
{
#if wxUSE_STACKWALKER
    AddContext(context);
#endif // wxUSE_STACKWALKER

#if wxUSE_CRASHREPORT
    AddDump(context);
#endif // wxUSE_CRASHREPORT

#if !wxUSE_STACKWALKER && !wxUSE_CRASHREPORT
    wxUnusedVar(context);
#endif
}

// ----------------------------------------------------------------------------
// adding basic text information about current context
// ----------------------------------------------------------------------------

#if wxUSE_STACKWALKER

bool wxDebugReport::DoAddSystemInfo(wxXmlNode *nodeSystemInfo)
{
    nodeSystemInfo->AddProperty(_T("description"), wxGetOsDescription());

    return true;
}

bool wxDebugReport::DoAddLoadedModules(wxXmlNode *nodeModules)
{
    wxDynamicLibraryDetailsArray modules(wxDynamicLibrary::ListLoaded());
    const size_t count = modules.GetCount();
    if ( !count )
        return false;

    for ( size_t n = 0; n < count; n++ )
    {
        const wxDynamicLibraryDetails& info = modules[n];

        wxXmlNode *nodeModule = new wxXmlNode(wxXML_ELEMENT_NODE, _T("module"));
        nodeModules->AddChild(nodeModule);

        wxString path = info.GetPath();
        if ( path.empty() )
            path = info.GetName();
        if ( !path.empty() )
            nodeModule->AddProperty(_T("path"), path);

        void *addr = NULL;
        size_t len = 0;
        if ( info.GetAddress(&addr, &len) )
        {
            HexProperty(nodeModule, _T("address"), wxPtrToUInt(addr));
            HexProperty(nodeModule, _T("size"), len);
        }

        wxString ver = info.GetVersion();
        if ( !ver.empty() )
        {
            nodeModule->AddProperty(_T("version"), ver);
        }
    }

    return true;
}

bool wxDebugReport::DoAddExceptionInfo(wxXmlNode *nodeContext)
{
#if wxUSE_CRASHREPORT
    wxCrashContext c;
    if ( !c.code )
        return false;

    wxXmlNode *nodeExc = new wxXmlNode(wxXML_ELEMENT_NODE, _T("exception"));
    nodeContext->AddChild(nodeExc);

    HexProperty(nodeExc, _T("code"), c.code);
    nodeExc->AddProperty(_T("name"), c.GetExceptionString());
    HexProperty(nodeExc, _T("address"), wxPtrToUInt(c.addr));

#ifdef __INTEL__
    wxXmlNode *nodeRegs = new wxXmlNode(wxXML_ELEMENT_NODE, _T("registers"));
    nodeContext->AddChild(nodeRegs);
    HexElement(nodeRegs, _T("eax"), c.regs.eax);
    HexElement(nodeRegs, _T("ebx"), c.regs.ebx);
    HexElement(nodeRegs, _T("ecx"), c.regs.edx);
    HexElement(nodeRegs, _T("edx"), c.regs.edx);
    HexElement(nodeRegs, _T("esi"), c.regs.esi);
    HexElement(nodeRegs, _T("edi"), c.regs.edi);

    HexElement(nodeRegs, _T("ebp"), c.regs.ebp);
    HexElement(nodeRegs, _T("esp"), c.regs.esp);
    HexElement(nodeRegs, _T("eip"), c.regs.eip);

    HexElement(nodeRegs, _T("cs"), c.regs.cs);
    HexElement(nodeRegs, _T("ds"), c.regs.ds);
    HexElement(nodeRegs, _T("es"), c.regs.es);
    HexElement(nodeRegs, _T("fs"), c.regs.fs);
    HexElement(nodeRegs, _T("gs"), c.regs.gs);
    HexElement(nodeRegs, _T("ss"), c.regs.ss);

    HexElement(nodeRegs, _T("flags"), c.regs.flags);
#endif // __INTEL__

    return true;
#else // !wxUSE_CRASHREPORT
    wxUnusedVar(nodeContext);

    return false;
#endif // wxUSE_CRASHREPORT/!wxUSE_CRASHREPORT
}

bool wxDebugReport::AddContext(wxDebugReport::Context ctx)
{
    wxCHECK_MSG( IsOk(), false, _T("use IsOk() first") );

    // create XML dump of current context
    wxXmlDocument xmldoc;
    wxXmlNode *nodeRoot = new wxXmlNode(wxXML_ELEMENT_NODE, _T("report"));
    xmldoc.SetRoot(nodeRoot);
    nodeRoot->AddProperty(_T("version"), _T("1.0"));
    nodeRoot->AddProperty(_T("kind"), ctx == Context_Current ? _T("user")
                                                             : _T("exception"));

    // add system information
    wxXmlNode *nodeSystemInfo = new wxXmlNode(wxXML_ELEMENT_NODE, _T("system"));
    if ( DoAddSystemInfo(nodeSystemInfo) )
        nodeRoot->AddChild(nodeSystemInfo);
    else
        delete nodeSystemInfo;

    // add information about the loaded modules
    wxXmlNode *nodeModules = new wxXmlNode(wxXML_ELEMENT_NODE, _T("modules"));
    if ( DoAddLoadedModules(nodeModules) )
        nodeRoot->AddChild(nodeModules);
    else
        delete nodeModules;

    // add CPU context information: this only makes sense for exceptions as our
    // current context is not very interesting otherwise
    if ( ctx == Context_Exception )
    {
        wxXmlNode *nodeContext = new wxXmlNode(wxXML_ELEMENT_NODE, _T("context"));
        if ( DoAddExceptionInfo(nodeContext) )
            nodeRoot->AddChild(nodeContext);
        else
            delete nodeContext;
    }

    // add stack traceback
#if wxUSE_STACKWALKER
    wxXmlNode *nodeStack = new wxXmlNode(wxXML_ELEMENT_NODE, _T("stack"));
    XmlStackWalker sw(nodeStack);
    if ( ctx == Context_Exception )
    {
        sw.WalkFromException();
    }
    else // Context_Current
    {
        sw.Walk();
    }

    if ( sw.IsOk() )
        nodeRoot->AddChild(nodeStack);
    else
        delete nodeStack;
#endif // wxUSE_STACKWALKER

    // finally let the user add any extra information he needs
    DoAddCustomContext(nodeRoot);


    // save the entire context dump in a file
    wxFileName fn(m_dir, GetReportName(), _T("xml"));

    if ( !xmldoc.Save(fn.GetFullPath()) )
        return false;

    AddFile(fn.GetFullName(), _("process context description"));

    return true;
}

#endif // wxUSE_STACKWALKER

// ----------------------------------------------------------------------------
// adding core dump
// ----------------------------------------------------------------------------

#if wxUSE_CRASHREPORT

bool wxDebugReport::AddDump(Context ctx)
{
    wxCHECK_MSG( IsOk(), false, _T("use IsOk() first") );

    wxFileName fn(m_dir, GetReportName(), _T("dmp"));
    wxCrashReport::SetFileName(fn.GetFullPath());

    if ( !(ctx == Context_Exception ? wxCrashReport::Generate()
                                    : wxCrashReport::GenerateNow()) )
            return false;

    AddFile(fn.GetFullName(), _("dump of the process state (binary)"));

    return true;
}

#endif // wxUSE_CRASHREPORT

// ----------------------------------------------------------------------------
// report processing
// ----------------------------------------------------------------------------

bool wxDebugReport::Process()
{
    if ( !GetFilesCount() )
    {
        wxLogError(_("Debug report generation has failed."));

        return false;
    }

    if ( !DoProcess() )
    {
        wxLogError(_("Processing debug report has failed, leaving the files in \"%s\" directory."),
                   GetDirectory().c_str());

        Reset();

        return false;
    }

    return true;
}

bool wxDebugReport::DoProcess()
{
    wxString msg = _("*** A debug report has been generated\n");
    msg += wxString::Format(_("*** It can be found in \"%s\"\n"),
                            GetDirectory().c_str());
    msg += _("*** And includes the following files:\n");

    wxString name, desc;
    const size_t count = GetFilesCount();
    for ( size_t n = 0; n < count; n++ )
    {
        GetFile(n, &name, &desc);
        msg += wxString::Format(_("\t%s: %s\n"), name.c_str(), desc.c_str());
    }

    msg += _("\nPlease send this report to the program maintainer, thank you!\n");

    wxLogMessage(_T("%s"), msg.c_str());

    // we have to do this or the report would be deleted, and we don't even
    // have any way to ask the user if he wants to keep it from here
    Reset();

    return true;
}

// ============================================================================
// wxDebugReport-derived classes
// ============================================================================

#if wxUSE_ZIPSTREAM

// ----------------------------------------------------------------------------
// wxDebugReportCompress
// ----------------------------------------------------------------------------

bool wxDebugReportCompress::DoProcess()
{
    const size_t count = GetFilesCount();
    if ( !count )
        return false;

    // create the streams
    wxFileName fn(GetDirectory(), GetReportName(), _T("zip"));
    wxFFileOutputStream os(fn.GetFullPath(), _T("wb"));
    wxZipOutputStream zos(os, 9);

    // add all files to the ZIP one
    wxString name, desc;
    for ( size_t n = 0; n < count; n++ )
    {
        GetFile(n, &name, &desc);

        wxZipEntry *ze = new wxZipEntry(name);
        ze->SetComment(desc);

        if ( !zos.PutNextEntry(ze) )
            return false;

        wxFileName filename(fn.GetPath(), name);
        wxFFileInputStream is(filename.GetFullPath());
        if ( !is.IsOk() || !zos.Write(is).IsOk() )
            return false;
    }

    if ( !zos.Close() )
        return false;

    m_zipfile = fn.GetFullPath();

    return true;
}

// ----------------------------------------------------------------------------
// wxDebugReportUpload
// ----------------------------------------------------------------------------

wxDebugReportUpload::wxDebugReportUpload(const wxString& url,
                                         const wxString& input,
                                         const wxString& action,
                                         const wxString& curl)
                   : m_uploadURL(url),
                     m_inputField(input),
                     m_curlCmd(curl)
{
    if ( m_uploadURL.Last() != _T('/') )
        m_uploadURL += _T('/');
    m_uploadURL += action;
}

bool wxDebugReportUpload::DoProcess()
{
    if ( !wxDebugReportCompress::DoProcess() )
        return false;


    wxArrayString output, errors;
    int rc = wxExecute(wxString::Format
                       (
                            _T("%s -F %s=@\"%s\" %s"),
                            m_curlCmd.c_str(),
                            m_inputField.c_str(),
                            GetCompressedFileName().c_str(),
                            m_uploadURL.c_str()
                       ),
                       output,
                       errors);
    if ( rc == -1 )
    {
        wxLogError(_("Failed to execute curl, please install it in PATH."));
    }
    else if ( rc != 0 )
    {
        const size_t count = errors.GetCount();
        if ( count )
        {
            for ( size_t n = 0; n < count; n++ )
            {
                wxLogWarning(_T("%s"), errors[n].c_str());
            }
        }

        wxLogError(_("Failed to upload the debug report (error code %d)."), rc);
    }
    else // rc == 0
    {
        if ( OnServerReply(output) )
            return true;
    }

    return false;
}

#endif // wxUSE_ZIPSTREAM

#endif // wxUSE_DEBUGREPORT
Commit	Line	Data
ce4fd7b5 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/debugrpt.cpp
	3	// Purpose: wxDebugReport and related classes implementation
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 2005-01-17
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 2005 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// License: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#include "wx/wxprec.h"
	21
	22	#ifdef __BORLANDC__
	23	#pragma hdrstop
	24	#endif
	25
	26	#ifndef WX_PRECOMP
	27	#include "wx/app.h"
	28	#include "wx/log.h"
	29	#include "wx/intl.h"
2b1d737b	30	#include "wx/utils.h"
ce4fd7b5 VZ	31	#endif // WX_PRECOMP
ce4fd7b5 VZ	32
2cbe2aea	33	#if wxUSE_DEBUGREPORT && wxUSE_XML
ce4fd7b5 VZ	34
	35	#include "wx/debugrpt.h"
	36
a44f14cf	37	#include "wx/ffile.h"
ce4fd7b5 VZ	38	#include "wx/filename.h"
	39	#include "wx/dir.h"
	40	#include "wx/dynlib.h"
	41
	42	#include "wx/xml/xml.h"
	43
	44	#if wxUSE_STACKWALKER
	45	#include "wx/stackwalk.h"
	46	#endif
	47
	48	#if wxUSE_CRASHREPORT
	49	#include "wx/msw/crashrpt.h"
	50	#endif
	51
	52	#if wxUSE_ZIPSTREAM
	53	#include "wx/wfstream.h"
	54	#include "wx/zipstrm.h"
	55	#endif // wxUSE_ZIPSTREAM
	56
61639efb	57	WX_CHECK_BUILD_OPTIONS("wxQA")
ce4fd7b5 VZ	58
	59	// ----------------------------------------------------------------------------
	60	// XmlStackWalker: stack walker specialization which dumps stack in XML
	61	// ----------------------------------------------------------------------------
	62
61639efb VZ	63	#if wxUSE_STACKWALKER
61639efb VZ	64
ce4fd7b5 VZ	65	class XmlStackWalker : public wxStackWalker
	66	{
	67	public:
	68	XmlStackWalker(wxXmlNode *nodeStack)
	69	{
	70	m_isOk = false;
	71	m_nodeStack = nodeStack;
	72	}
	73
	74	bool IsOk() const { return m_isOk; }
	75
	76	protected:
	77	virtual void OnStackFrame(const wxStackFrame& frame);
	78
	79	wxXmlNode *m_nodeStack;
	80	bool m_isOk;
	81	};
	82
	83	#endif // wxUSE_STACKWALKER
	84
	85	// ----------------------------------------------------------------------------
	86	// local functions
	87	// ----------------------------------------------------------------------------
	88
	89	static inline void
	90	HexProperty(wxXmlNode node, const wxChar name, unsigned long value)
	91	{
61ad154c	92	node->AddProperty(name, wxString::Format(_T("%08lx"), value));
ce4fd7b5 VZ	93	}
	94
	95	static inline void
	96	NumProperty(wxXmlNode node, const wxChar name, unsigned long value)
	97	{
	98	node->AddProperty(name, wxString::Format(_T("%lu"), value));
	99	}
	100
	101	static inline void
	102	TextElement(wxXmlNode node, const wxChar name, const wxString& value)
	103	{
	104	wxXmlNode *nodeChild = new wxXmlNode(wxXML_ELEMENT_NODE, name);
	105	node->AddChild(nodeChild);
7a893a31	106	nodeChild->AddChild(new wxXmlNode(wxXML_TEXT_NODE, wxEmptyString, value));
ce4fd7b5 VZ	107	}
ce4fd7b5 VZ	108
17a1ebd1 VZ	109	#if wxUSE_CRASHREPORT && defined(__INTEL__)
17a1ebd1 VZ	110
ce4fd7b5 VZ	111	static inline void
	112	HexElement(wxXmlNode node, const wxChar name, unsigned long value)
	113	{
61ad154c	114	TextElement(node, name, wxString::Format(_T("%08lx"), value));
ce4fd7b5 VZ	115	}
ce4fd7b5 VZ	116
17a1ebd1 VZ	117	#endif // wxUSE_CRASHREPORT
17a1ebd1 VZ	118
ce4fd7b5 VZ	119	#if wxUSE_STACKWALKER
	120
	121	// ============================================================================
	122	// XmlStackWalker implementation
	123	// ============================================================================
	124
	125	void XmlStackWalker::OnStackFrame(const wxStackFrame& frame)
	126	{
	127	m_isOk = true;
	128
	129	wxXmlNode *nodeFrame = new wxXmlNode(wxXML_ELEMENT_NODE, _T("frame"));
	130	m_nodeStack->AddChild(nodeFrame);
	131
	132	NumProperty(nodeFrame, _T("level"), frame.GetLevel());
	133	wxString func = frame.GetName();
	134	if ( !func.empty() )
	135	{
	136	nodeFrame->AddProperty(_T("function"), func);
	137	HexProperty(nodeFrame, _T("offset"), frame.GetOffset());
	138	}
	139
	140	if ( frame.HasSourceLocation() )
	141	{
	142	nodeFrame->AddProperty(_T("file"), frame.GetFileName());
	143	NumProperty(nodeFrame, _T("line"), frame.GetLine());
	144	}
	145
	146	const size_t nParams = frame.GetParamCount();
	147	if ( nParams )
	148	{
	149	wxXmlNode *nodeParams = new wxXmlNode(wxXML_ELEMENT_NODE, _T("parameters"));
	150	nodeFrame->AddChild(nodeParams);
	151
	152	for ( size_t n = 0; n < nParams; n++ )
	153	{
	154	wxXmlNode *
	155	nodeParam = new wxXmlNode(wxXML_ELEMENT_NODE, _T("parameter"));
	156	nodeParams->AddChild(nodeParam);
	157
	158	NumProperty(nodeParam, _T("number"), n);
	159
	160	wxString type, name, value;
	161	if ( !frame.GetParam(n, &type, &name, &value) )
	162	continue;
	163
	164	if ( !type.empty() )
	165	TextElement(nodeParam, _T("type"), type);
	166
	167	if ( !name.empty() )
	168	TextElement(nodeParam, _T("name"), name);
	169
	170	if ( !value.empty() )
	171	TextElement(nodeParam, _T("value"), value);
	172	}
	173	}
	174	}
	175
	176	#endif // wxUSE_STACKWALKER
	177
	178	// ============================================================================
	179	// wxDebugReport implementation
	180	// ============================================================================
	181
	182	// ----------------------------------------------------------------------------
183	// initialization and cleanup
184	// ----------------------------------------------------------------------------
185
186	wxDebugReport::wxDebugReport()
187	{
188	// get a temporary directory name
2cdd63c6	189	wxString appname = GetReportName();
ce4fd7b5 VZ	190
	191	// we can't use CreateTempFileName() because it creates a file, not a
	192	// directory, so do our best to create a unique name ourselves
	193	//
	194	// of course, this doesn't protect us against malicious users...
	195	wxFileName fn;
	196	fn.AssignTempFileName(appname);
	197	m_dir.Printf(_T("%s%c%s_dbgrpt-%lu-%s"),
61ad154c	198	fn.GetPath().c_str(), wxFILE_SEP_PATH, appname.c_str(),
ce4fd7b5 VZ	199	wxGetProcessId(),
	200	wxDateTime::Now().Format(_T("%Y%m%dT%H%M%S")).c_str());
	201
	202	// as we are going to save the process state there use restrictive
	203	// permissions
	204	if ( !wxMkdir(m_dir, 0700) )
	205	{
	206	wxLogSysError(_("Failed to create directory \"%s\""), m_dir.c_str());
	207	wxLogError(_("Debug report couldn't be created."));
	208
	209	Reset();
	210	}
	211	}
	212
	213	wxDebugReport::~wxDebugReport()
	214	{
	215	if ( !m_dir.empty() )
	216	{
	217	// remove all files in this directory
	218	wxDir dir(m_dir);
	219	wxString file;
	220	for ( bool cont = dir.GetFirst(&file); cont; cont = dir.GetNext(&file) )
	221	{
	222	if ( wxRemove(wxFileName(m_dir, file).GetFullPath()) != 0 )
	223	{
	224	wxLogSysError(_("Failed to remove debug report file \"%s\""),
	225	file.c_str());
	226	m_dir.clear();
	227	break;
	228	}
	229	}
	230	}
	231
	232	if ( !m_dir.empty() )
	233	{
9034c590 JS	234	// Temp fix: what should this be? eVC++ doesn't like wxRmDir
	235	#ifdef __WXWINCE__
	236	if ( wxRmdir(m_dir.fn_str()) != 0 )
	237	#else
2cdd63c6	238	if ( wxRmDir(m_dir.fn_str()) != 0 )
9034c590	239	#endif
ce4fd7b5 VZ	240	{
	241	wxLogSysError(_("Failed to clean up debug report directory \"%s\""),
	242	m_dir.c_str());
	243	}
	244	}
	245	}
	246
	247	// ----------------------------------------------------------------------------
	248	// various helpers
	249	// ----------------------------------------------------------------------------
	250
	251	wxString wxDebugReport::GetReportName() const
	252	{
2cdd63c6 WS	253	if(wxTheApp)
	254	return wxTheApp->GetAppName();
	255
	256	return _T("wx");
ce4fd7b5 VZ	257	}
ce4fd7b5 VZ	258
fdc1aa52 VZ	259	void
fdc1aa52 VZ	260	wxDebugReport::AddFile(const wxString& filename, const wxString& description)
ce4fd7b5	261	{
fdc1aa52 VZ	262	wxString name;
	263	wxFileName fn(filename);
	264	if ( fn.IsAbsolute() )
	265	{
	266	// we need to copy the file to the debug report directory: give it the
	267	// same name there
	268	name = fn.GetFullName();
	269	wxCopyFile(fn.GetFullPath(),
	270	wxFileName(GetDirectory(), name).GetFullPath());
	271	}
	272	else // file relative to the report directory
	273	{
	274	name = filename;
	275
	276	wxASSERT_MSG( wxFileName(GetDirectory(), name).FileExists(),
	277	_T("file should exist in debug report directory") );
	278	}
	279
ce4fd7b5 VZ	280	m_files.Add(name);
	281	m_descriptions.Add(description);
	282	}
	283
e18c3e02	284	bool
fdc1aa52	285	wxDebugReport::AddText(const wxString& filename,
e18c3e02 VZ	286	const wxString& text,
	287	const wxString& description)
	288	{
fdc1aa52 VZ	289	wxASSERT_MSG( !wxFileName(filename).IsAbsolute(),
	290	_T("filename should be relative to debug report directory") );
	291
	292	wxFileName fn(GetDirectory(), filename);
e18c3e02 VZ	293	wxFFile file(fn.GetFullPath(), _T("w"));
	294	if ( !file.IsOpened() \|\| !file.Write(text) )
	295	return false;
	296
fdc1aa52	297	AddFile(filename, description);
e18c3e02 VZ	298
	299	return true;
	300	}
	301
ce4fd7b5 VZ	302	void wxDebugReport::RemoveFile(const wxString& name)
	303	{
	304	const int n = m_files.Index(name);
	305	wxCHECK_RET( n != wxNOT_FOUND, _T("No such file in wxDebugReport") );
	306
	307	m_files.RemoveAt(n);
	308	m_descriptions.RemoveAt(n);
	309
	310	wxRemove(wxFileName(GetDirectory(), name).GetFullPath());
	311	}
	312
	313	bool wxDebugReport::GetFile(size_t n, wxString name, wxString desc) const
	314	{
	315	if ( n >= m_files.GetCount() )
	316	return false;
	317
	318	if ( name )
	319	*name = m_files[n];
	320	if ( desc )
	321	*desc = m_descriptions[n];
	322
	323	return true;
	324	}
	325
	326	void wxDebugReport::AddAll(Context context)
	327	{
	328	#if wxUSE_STACKWALKER
	329	AddContext(context);
	330	#endif // wxUSE_STACKWALKER
	331
	332	#if wxUSE_CRASHREPORT
	333	AddDump(context);
	334	#endif // wxUSE_CRASHREPORT
2cdd63c6 WS	335
	336	#if !wxUSE_STACKWALKER && !wxUSE_CRASHREPORT
	337	wxUnusedVar(context);
	338	#endif
ce4fd7b5 VZ	339	}
	340
	341	// ----------------------------------------------------------------------------
	342	// adding basic text information about current context
	343	// ----------------------------------------------------------------------------
	344
	345	#if wxUSE_STACKWALKER
	346
	347	bool wxDebugReport::DoAddSystemInfo(wxXmlNode *nodeSystemInfo)
	348	{
	349	nodeSystemInfo->AddProperty(_T("description"), wxGetOsDescription());
	350
	351	return true;
	352	}
	353
	354	bool wxDebugReport::DoAddLoadedModules(wxXmlNode *nodeModules)
	355	{
	356	wxDynamicLibraryDetailsArray modules(wxDynamicLibrary::ListLoaded());
	357	const size_t count = modules.GetCount();
	358	if ( !count )
	359	return false;
	360
	361	for ( size_t n = 0; n < count; n++ )
	362	{
	363	const wxDynamicLibraryDetails& info = modules[n];
	364
	365	wxXmlNode *nodeModule = new wxXmlNode(wxXML_ELEMENT_NODE, _T("module"));
	366	nodeModules->AddChild(nodeModule);
	367
	368	wxString path = info.GetPath();
	369	if ( path.empty() )
	370	path = info.GetName();
	371	if ( !path.empty() )
	372	nodeModule->AddProperty(_T("path"), path);
	373
d64dc197 WS	374	void *addr = NULL;
d64dc197 WS	375	size_t len = 0;
ce4fd7b5 VZ	376	if ( info.GetAddress(&addr, &len) )
ce4fd7b5 VZ	377	{
17a1ebd1	378	HexProperty(nodeModule, _T("address"), wxPtrToUInt(addr));
ce4fd7b5 VZ	379	HexProperty(nodeModule, _T("size"), len);
	380	}
	381
	382	wxString ver = info.GetVersion();
	383	if ( !ver.empty() )
	384	{
	385	nodeModule->AddProperty(_T("version"), ver);
	386	}
	387	}
	388
	389	return true;
	390	}
	391
	392	bool wxDebugReport::DoAddExceptionInfo(wxXmlNode *nodeContext)
	393	{
	394	#if wxUSE_CRASHREPORT
	395	wxCrashContext c;
	396	if ( !c.code )
	397	return false;
	398
	399	wxXmlNode *nodeExc = new wxXmlNode(wxXML_ELEMENT_NODE, _T("exception"));
	400	nodeContext->AddChild(nodeExc);
	401
	402	HexProperty(nodeExc, _T("code"), c.code);
	403	nodeExc->AddProperty(_T("name"), c.GetExceptionString());
17a1ebd1	404	HexProperty(nodeExc, _T("address"), wxPtrToUInt(c.addr));
ce4fd7b5 VZ	405
	406	#ifdef __INTEL__
	407	wxXmlNode *nodeRegs = new wxXmlNode(wxXML_ELEMENT_NODE, _T("registers"));
	408	nodeContext->AddChild(nodeRegs);
	409	HexElement(nodeRegs, _T("eax"), c.regs.eax);
	410	HexElement(nodeRegs, _T("ebx"), c.regs.ebx);
	411	HexElement(nodeRegs, _T("ecx"), c.regs.edx);
	412	HexElement(nodeRegs, _T("edx"), c.regs.edx);
	413	HexElement(nodeRegs, _T("esi"), c.regs.esi);
	414	HexElement(nodeRegs, _T("edi"), c.regs.edi);
	415
	416	HexElement(nodeRegs, _T("ebp"), c.regs.ebp);
	417	HexElement(nodeRegs, _T("esp"), c.regs.esp);
	418	HexElement(nodeRegs, _T("eip"), c.regs.eip);
	419
	420	HexElement(nodeRegs, _T("cs"), c.regs.cs);
	421	HexElement(nodeRegs, _T("ds"), c.regs.ds);
	422	HexElement(nodeRegs, _T("es"), c.regs.es);
	423	HexElement(nodeRegs, _T("fs"), c.regs.fs);
	424	HexElement(nodeRegs, _T("gs"), c.regs.gs);
	425	HexElement(nodeRegs, _T("ss"), c.regs.ss);
	426
	427	HexElement(nodeRegs, _T("flags"), c.regs.flags);
	428	#endif // __INTEL__
	429
	430	return true;
	431	#else // !wxUSE_CRASHREPORT
	432	wxUnusedVar(nodeContext);
	433
	434	return false;
	435	#endif // wxUSE_CRASHREPORT/!wxUSE_CRASHREPORT
	436	}
	437
	438	bool wxDebugReport::AddContext(wxDebugReport::Context ctx)
	439	{
	440	wxCHECK_MSG( IsOk(), false, _T("use IsOk() first") );
	441
	442	// create XML dump of current context
	443	wxXmlDocument xmldoc;
	444	wxXmlNode *nodeRoot = new wxXmlNode(wxXML_ELEMENT_NODE, _T("report"));
	445	xmldoc.SetRoot(nodeRoot);
	446	nodeRoot->AddProperty(_T("version"), _T("1.0"));
478cde32 VZ	447	nodeRoot->AddProperty(_T("kind"), ctx == Context_Current ? _T("user")
478cde32 VZ	448	: _T("exception"));
ce4fd7b5 VZ	449
	450	// add system information
	451	wxXmlNode *nodeSystemInfo = new wxXmlNode(wxXML_ELEMENT_NODE, _T("system"));
	452	if ( DoAddSystemInfo(nodeSystemInfo) )
	453	nodeRoot->AddChild(nodeSystemInfo);
	454	else
	455	delete nodeSystemInfo;
	456
	457	// add information about the loaded modules
	458	wxXmlNode *nodeModules = new wxXmlNode(wxXML_ELEMENT_NODE, _T("modules"));
	459	if ( DoAddLoadedModules(nodeModules) )
	460	nodeRoot->AddChild(nodeModules);
	461	else
	462	delete nodeModules;
	463
	464	// add CPU context information: this only makes sense for exceptions as our
	465	// current context is not very interesting otherwise
	466	if ( ctx == Context_Exception )
	467	{
	468	wxXmlNode *nodeContext = new wxXmlNode(wxXML_ELEMENT_NODE, _T("context"));
	469	if ( DoAddExceptionInfo(nodeContext) )
	470	nodeRoot->AddChild(nodeContext);
	471	else
	472	delete nodeContext;
	473	}
	474
	475	// add stack traceback
	476	#if wxUSE_STACKWALKER
	477	wxXmlNode *nodeStack = new wxXmlNode(wxXML_ELEMENT_NODE, _T("stack"));
	478	XmlStackWalker sw(nodeStack);
	479	if ( ctx == Context_Exception )
	480	{
	481	sw.WalkFromException();
	482	}
478cde32	483	else // Context_Current
ce4fd7b5 VZ	484	{
	485	sw.Walk();
	486	}
	487
	488	if ( sw.IsOk() )
	489	nodeRoot->AddChild(nodeStack);
	490	else
	491	delete nodeStack;
	492	#endif // wxUSE_STACKWALKER
	493
	494	// finally let the user add any extra information he needs
	495	DoAddCustomContext(nodeRoot);
	496
	497
	498	// save the entire context dump in a file
	499	wxFileName fn(m_dir, GetReportName(), _T("xml"));
	500
	501	if ( !xmldoc.Save(fn.GetFullPath()) )
	502	return false;
	503
	504	AddFile(fn.GetFullName(), _("process context description"));
	505
	506	return true;
	507	}
	508
	509	#endif // wxUSE_STACKWALKER
	510
	511	// ----------------------------------------------------------------------------
	512	// adding core dump
	513	// ----------------------------------------------------------------------------
	514
	515	#if wxUSE_CRASHREPORT
	516
	517	bool wxDebugReport::AddDump(Context ctx)
	518	{
	519	wxCHECK_MSG( IsOk(), false, _T("use IsOk() first") );
	520
	521	wxFileName fn(m_dir, GetReportName(), _T("dmp"));
	522	wxCrashReport::SetFileName(fn.GetFullPath());
	523
	524	if ( !(ctx == Context_Exception ? wxCrashReport::Generate()
	525	: wxCrashReport::GenerateNow()) )
	526	return false;
	527
	528	AddFile(fn.GetFullName(), _("dump of the process state (binary)"));
	529
	530	return true;
	531	}
	532
	533	#endif // wxUSE_CRASHREPORT
	534
	535	// ----------------------------------------------------------------------------
	536	// report processing
	537	// ----------------------------------------------------------------------------
	538
	539	bool wxDebugReport::Process()
	540	{
	541	if ( !GetFilesCount() )
	542	{
	543	wxLogError(_("Debug report generation has failed."));
	544
	545	return false;
	546	}
	547
548	if ( !DoProcess() )
549	{
550	wxLogError(_("Processing debug report has failed, leaving the files in \"%s\" directory."),
551	GetDirectory().c_str());
552
553	Reset();
554
555	return false;
556	}
557
558	return true;
559	}
560
561	bool wxDebugReport::DoProcess()
562	{
563	wxString msg = _("*** A debug report has been generated\n");
564	msg += wxString::Format(_("*** It can be found in \"%s\"\n"),
565	GetDirectory().c_str());
566	msg += _("*** And includes the following files:\n");
567
568	wxString name, desc;
569	const size_t count = GetFilesCount();
570	for ( size_t n = 0; n < count; n++ )
571	{
572	GetFile(n, &name, &desc);
573	msg += wxString::Format(_("\t%s: %s\n"), name.c_str(), desc.c_str());
574	}
575
576	msg += _("\nPlease send this report to the program maintainer, thank you!\n");
577
578	wxLogMessage(_T("%s"), msg.c_str());
579
580	// we have to do this or the report would be deleted, and we don't even
581	// have any way to ask the user if he wants to keep it from here
582	Reset();
583
584	return true;
585	}
586
587	// ============================================================================
588	// wxDebugReport-derived classes
589	// ============================================================================
590
591	#if wxUSE_ZIPSTREAM
592
593	// ----------------------------------------------------------------------------
594	// wxDebugReportCompress
595	// ----------------------------------------------------------------------------
596
597	bool wxDebugReportCompress::DoProcess()
598	{
599	const size_t count = GetFilesCount();
600	if ( !count )
601	return false;
602
603	// create the streams
604	wxFileName fn(GetDirectory(), GetReportName(), _T("zip"));
605	wxFFileOutputStream os(fn.GetFullPath(), _T("wb"));
3b676ed7	606	wxZipOutputStream zos(os, 9);
ce4fd7b5 VZ	607
	608	// add all files to the ZIP one
	609	wxString name, desc;
	610	for ( size_t n = 0; n < count; n++ )
	611	{
	612	GetFile(n, &name, &desc);
	613
	614	wxZipEntry *ze = new wxZipEntry(name);
	615	ze->SetComment(desc);
	616
3b676ed7	617	if ( !zos.PutNextEntry(ze) )
ce4fd7b5 VZ	618	return false;
ce4fd7b5 VZ	619
2cdd63c6 WS	620	wxFileName filename(fn.GetPath(), name);
2cdd63c6 WS	621	wxFFileInputStream is(filename.GetFullPath());
3b676ed7	622	if ( !is.IsOk() \|\| !zos.Write(is).IsOk() )
ce4fd7b5 VZ	623	return false;
	624	}
	625
3b676ed7	626	if ( !zos.Close() )
ce4fd7b5 VZ	627	return false;
	628
	629	m_zipfile = fn.GetFullPath();
	630
	631	return true;
	632	}
	633
	634	// ----------------------------------------------------------------------------
	635	// wxDebugReportUpload
	636	// ----------------------------------------------------------------------------
	637
	638	wxDebugReportUpload::wxDebugReportUpload(const wxString& url,
	639	const wxString& input,
	640	const wxString& action,
	641	const wxString& curl)
	642	: m_uploadURL(url),
	643	m_inputField(input),
	644	m_curlCmd(curl)
	645	{
	646	if ( m_uploadURL.Last() != _T('/') )
	647	m_uploadURL += _T('/');
	648	m_uploadURL += action;
	649	}
	650
	651	bool wxDebugReportUpload::DoProcess()
	652	{
	653	if ( !wxDebugReportCompress::DoProcess() )
	654	return false;
	655
	656
	657	wxArrayString output, errors;
	658	int rc = wxExecute(wxString::Format
	659	(
1152bba2	660	_T("%s -F %s=@\"%s\" %s"),
ce4fd7b5 VZ	661	m_curlCmd.c_str(),
	662	m_inputField.c_str(),
	663	GetCompressedFileName().c_str(),
	664	m_uploadURL.c_str()
	665	),
	666	output,
	667	errors);
	668	if ( rc == -1 )
	669	{
	670	wxLogError(_("Failed to execute curl, please install it in PATH."));
	671	}
	672	else if ( rc != 0 )
	673	{
	674	const size_t count = errors.GetCount();
	675	if ( count )
	676	{
	677	for ( size_t n = 0; n < count; n++ )
	678	{
	679	wxLogWarning(_T("%s"), errors[n].c_str());
	680	}
	681	}
	682
	683	wxLogError(_("Failed to upload the debug report (error code %d)."), rc);
	684	}
	685	else // rc == 0
	686	{
	687	if ( OnServerReply(output) )
	688	return true;
	689	}
	690
	691	return false;
	692	}
	693
	694	#endif // wxUSE_ZIPSTREAM
	695
	696	#endif // wxUSE_DEBUGREPORT