[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));
}

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

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