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