src/common/debugrpt.cpp

   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"
  30     #include "wx/utils.h"
  31 #endif // WX_PRECOMP
  32
  33 #if wxUSE_DEBUGREPORT
  34
  35 #include "wx/debugrpt.h"
  36
  37 #include "wx/filename.h"
  38 #include "wx/dir.h"
  39 #include "wx/dynlib.h"
  40
  41 #include "wx/xml/xml.h"
  42
  43 #if wxUSE_STACKWALKER
  44     #include "wx/stackwalk.h"
  45 #endif
  46
  47 #if wxUSE_CRASHREPORT
  48     #include "wx/msw/crashrpt.h"
  49 #endif
  50
  51 #if wxUSE_ZIPSTREAM
  52     #include "wx/wfstream.h"
  53     #include "wx/zipstrm.h"
  54     #include "wx/ptr_scpd.h"
  55 #endif // wxUSE_ZIPSTREAM
  56
  57 WX_CHECK_BUILD_OPTIONS("wxQA")
  58
  59 // ----------------------------------------------------------------------------
  60 // XmlStackWalker: stack walker specialization which dumps stack in XML
  61 // ----------------------------------------------------------------------------
  62
  63 #if wxUSE_STACKWALKER
  64
  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 {
  92     node->AddProperty(name, wxString::Format(_T("%08lx"), value));
  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);
 106     nodeChild->AddChild(new wxXmlNode(wxXML_TEXT_NODE, _T(""), value));
 107 }
 108
 109 static inline void
 110 HexElement(wxXmlNode *node, const wxChar *name, unsigned long value)
 111 {
 112     TextElement(node, name, wxString::Format(_T("%08lx"), value));
 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
 185     wxString appname = GetReportName();
 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"),
 194                  fn.GetPath().c_str(), wxFILE_SEP_PATH, appname.c_str(),
 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     {
 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
 234         if ( wxRmDir(m_dir.fn_str()) != 0 )
 235 #endif
 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 {
 249     if(wxTheApp)
 250         return wxTheApp->GetAppName();
 251
 252     return _T("wx");
 253 }
 254
 255 void
 256 wxDebugReport::AddFile(const wxString& filename, const wxString& description)
 257 {
 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
 276     m_files.Add(name);
 277     m_descriptions.Add(description);
 278 }
 279
 280 bool
 281 wxDebugReport::AddText(const wxString& filename,
 282                        const wxString& text,
 283                        const wxString& description)
 284 {
 285     wxASSERT_MSG( !wxFileName(filename).IsAbsolute(),
 286                   _T("filename should be relative to debug report directory") );
 287
 288     wxFileName fn(GetDirectory(), filename);
 289     wxFFile file(fn.GetFullPath(), _T("w"));
 290     if ( !file.IsOpened() || !file.Write(text) )
 291         return false;
 292
 293     AddFile(filename, description);
 294
 295     return true;
 296 }
 297
 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
 331
 332 #if !wxUSE_STACKWALKER && !wxUSE_CRASHREPORT
 333     wxUnusedVar(context);
 334 #endif
 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
 370         void *addr = NULL;
 371         size_t len = 0;
 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"));
 443     nodeRoot->AddProperty(_T("kind"), ctx == Context_Current ? _T("user")
 444                                                              : _T("exception"));
 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     }
 479     else // Context_Current
 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 // leave the default name wxZipOutputStreamPtr free for users
 590 wxDECLARE_SCOPED_PTR(wxZipOutputStream, wxDbgZipOutputStreamPtr)
 591 wxDEFINE_SCOPED_PTR(wxZipOutputStream, wxDbgZipOutputStreamPtr)
 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"));
 606
 607     // create this one on the heap as a workaround since otherwise the mingw
 608     // 3.2.3 linker cannot find ~wxZipOutputStream() when building a dll
 609     // version of the library.
 610     wxDbgZipOutputStreamPtr zos(new wxZipOutputStream(os, 9));
 611
 612     // add all files to the ZIP one
 613     wxString name, desc;
 614     for ( size_t n = 0; n < count; n++ )
 615     {
 616         GetFile(n, &name, &desc);
 617
 618         wxZipEntry *ze = new wxZipEntry(name);
 619         ze->SetComment(desc);
 620
 621         if ( !zos->PutNextEntry(ze) )
 622             return false;
 623
 624         wxFileName filename(fn.GetPath(), name);
 625         wxFFileInputStream is(filename.GetFullPath());
 626         if ( !is.IsOk() || !zos->Write(is).IsOk() )
 627             return false;
 628     }
 629
 630     if ( !zos->Close() )
 631         return false;
 632
 633     m_zipfile = fn.GetFullPath();
 634
 635     return true;
 636 }
 637
 638 // ----------------------------------------------------------------------------
 639 // wxDebugReportUpload
 640 // ----------------------------------------------------------------------------
 641
 642 wxDebugReportUpload::wxDebugReportUpload(const wxString& url,
 643                                          const wxString& input,
 644                                          const wxString& action,
 645                                          const wxString& curl)
 646                    : m_uploadURL(url),
 647                      m_inputField(input),
 648                      m_curlCmd(curl)
 649 {
 650     if ( m_uploadURL.Last() != _T('/') )
 651         m_uploadURL += _T('/');
 652     m_uploadURL += action;
 653 }
 654
 655 bool wxDebugReportUpload::DoProcess()
 656 {
 657     if ( !wxDebugReportCompress::DoProcess() )
 658         return false;
 659
 660
 661     wxArrayString output, errors;
 662     int rc = wxExecute(wxString::Format
 663                        (
 664                             _T("%s -F %s=@%s %s"),
 665                             m_curlCmd.c_str(),
 666                             m_inputField.c_str(),
 667                             GetCompressedFileName().c_str(),
 668                             m_uploadURL.c_str()
 669                        ),
 670                        output,
 671                        errors);
 672     if ( rc == -1 )
 673     {
 674         wxLogError(_("Failed to execute curl, please install it in PATH."));
 675     }
 676     else if ( rc != 0 )
 677     {
 678         const size_t count = errors.GetCount();
 679         if ( count )
 680         {
 681             for ( size_t n = 0; n < count; n++ )
 682             {
 683                 wxLogWarning(_T("%s"), errors[n].c_str());
 684             }
 685         }
 686
 687         wxLogError(_("Failed to upload the debug report (error code %d)."), rc);
 688     }
 689     else // rc == 0
 690     {
 691         if ( OnServerReply(output) )
 692             return true;
 693     }
 694
 695     return false;
 696 }
 697
 698 #endif // wxUSE_ZIPSTREAM
 699
 700 #endif // wxUSE_DEBUGREPORT
 701