?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Upstream tarball 9807
[amule.git] / src / ExternalConnector.cpp
blob26b848d1e4c9e211d29d136040b82fc4750ea812
1 //
2 // This file is part of the aMule Project.
3 //
4 // Copyright (c) 2004-2008 aMule Team ( admin@amule.org / http://www.amule.org )
5 //
6 // Any parts of this program derived from the xMule, lMule or eMule project,
7 // or contributed by third-party developers are copyrighted by their
8 // respective authors.
9 //
10 // This program is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU General Public License as published by
12 // the Free Software Foundation; either version 2 of the License, or
13 // (at your option) any later version.
14 //
15 // This program is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU General Public License for more details.
19 //
20 // You should have received a copy of the GNU General Public License
21 // along with this program; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 //
24
25 #include "ExternalConnector.h"
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h" // Needed for VERSION and readline detection
29 #endif
30
31 #include <common/ClientVersion.h>
32 #include <common/Format.h> // Needed for CFormat
33 #include <wx/tokenzr.h> // For wxStringTokenizer
34
35 // For readline
36 #ifdef HAVE_LIBREADLINE
37 #if defined(HAVE_READLINE_READLINE_H)
38 #include <readline/readline.h> // Do_not_auto_remove
39 #elif defined(HAVE_READLINE_H)
40 #include <readline.h> // Do_not_auto_remove
41 #else /* !defined(HAVE_READLINE_H) */
42 extern "C" char *readline (const char*);
43 #endif /* !defined(HAVE_READLINE_H) */
44 #else /* !defined(HAVE_READLINE_READLINE_H) */
45 /* no readline */
46 #endif /* HAVE_LIBREADLINE */
47
48 // For history
49 #ifdef HAVE_READLINE_HISTORY
50 #if defined(HAVE_READLINE_HISTORY_H)
51 #include <readline/history.h> // Do_not_auto_remove
52 #elif defined(HAVE_HISTORY_H)
53 #include <history.h> // Do_not_auto_remove
54 #else /* !defined(HAVE_HISTORY_H) */
55 extern "C" void add_history (const char*);
56 #endif /* defined(HAVE_READLINE_HISTORY_H) */
57 #else
58 /* no history */
59 #endif /* HAVE_READLINE_HISTORY */
60
61
62 #include <ec/cpp/ECFileConfig.h> // Needed for CECFileConfig
63 #include <common/MD5Sum.h>
64
65 #ifdef _MSC_VER // silly warnings about deprecated functions
66 #pragma warning(disable:4996)
67 #endif
68
69 //-------------------------------------------------------------------
70
71 CCommandTree::~CCommandTree()
72 {
73 for (CmdPos_t it = m_subcommands.begin(); it != m_subcommands.end(); ++it) {
74 delete *it;
75 }
76 m_subcommands.clear();
77 }
78
79
80 CCommandTree* CCommandTree::AddCommand(CCommandTree* command)
81 {
82 command->m_parent = this;
83 const wxString& cmd = command->m_command;
84 CmdPos_t it;
85 for (it = m_subcommands.begin(); it != m_subcommands.end(); ++it) {
86 if ((*it)->m_command > cmd) {
87 break;
88 }
89 }
90 m_subcommands.insert(it, command);
91 return command;
92 }
93
94
95 int CCommandTree::FindCommandId(const wxString& command, wxString& args, wxString& cmdstr) const
96 {
97 wxString cmd = command.BeforeFirst(wxT(' ')).Lower();
98 for (CmdPosConst_t it = m_subcommands.begin(); it != m_subcommands.end(); ++it) {
99 if ((*it)->m_command.Lower() == cmd) {
100 args = command.AfterFirst(wxT(' ')).Trim(false);
101 return (*it)->FindCommandId(args, args, cmdstr);
102 }
103 }
104 cmdstr = GetFullCommand().Lower();
105 if (m_params == CMD_PARAM_ALWAYS && args.IsEmpty()) {
106 return CMD_ERR_MUST_HAVE_PARAM;
107 } else if (m_params == CMD_PARAM_NEVER && !args.IsEmpty()) {
108 return CMD_ERR_NO_PARAM;
109 } else {
110 if ((m_cmd_id >= 0) && (m_cmd_id & CMD_DEPRECATED)) {
111 m_app.Show(wxT('\n') + m_verbose + wxT('\n'));
112 return m_cmd_id & ~CMD_DEPRECATED;
113 } else {
114 return m_cmd_id;
115 }
116 }
117 }
118
119
120 wxString CCommandTree::GetFullCommand() const
121 {
122 wxString cmd = m_command;
123
124 const CCommandTree *parent = m_parent;
125 while (parent && parent->m_parent) {
126 cmd = parent->m_command + wxT(" ") + cmd;
127 parent = parent->m_parent;
128 }
129
130 return cmd;
131 }
132
133
134 void CCommandTree::PrintHelpFor(const wxString& command) const
135 {
136 wxString cmd = command.BeforeFirst(wxT(' ')).Lower();
137 if (!cmd.IsEmpty()) {
138 for (CmdPosConst_t it = m_subcommands.begin(); it != m_subcommands.end(); ++it) {
139 if ((*it)->m_command.Lower() == cmd) {
140 (*it)->PrintHelpFor(command.AfterFirst(wxT(' ')).Trim(false));
141 return;
142 }
143 }
144 if (m_parent) {
145 m_app.Show(CFormat(_("Unknown extension '%s' for the '%s' command.\n")) % command % GetFullCommand());
146 } else {
147 m_app.Show(CFormat(_("Unknown command '%s'.\n")) % command);
148 }
149 } else {
150 wxString fullcmd = GetFullCommand();
151 if (!fullcmd.IsEmpty()) {
152 m_app.Show(fullcmd.Upper() + wxT(": ") + wxGetTranslation(m_short) + wxT("\n"));
153 if (!m_verbose.IsEmpty()) {
154 m_app.Show(wxT("\n"));
155 m_app.Show(wxGetTranslation(m_verbose));
156 }
157 }
158 if (m_params == CMD_PARAM_NEVER) {
159 m_app.Show(_("\nThis command cannot have an argument.\n"));
160 } else if (m_params == CMD_PARAM_ALWAYS) {
161 m_app.Show(_("\nThis command must have an argument.\n"));
162 }
163 if (m_cmd_id == CMD_ERR_INCOMPLETE) {
164 m_app.Show(_("\nThis command is incomplete, you must use one of the extensions below.\n"));
165 }
166 if (!m_subcommands.empty()) {
167 CmdPosConst_t it;
168 int maxlen = 0;
169 if (m_parent) {
170 m_app.Show(_("\nAvailable extensions:\n"));
171 } else {
172 m_app.Show(_("Available commands:\n"));
173 }
174 for (it = m_subcommands.begin(); it != m_subcommands.end(); ++it) {
175 if (!((*it)->m_cmd_id >= 0 && (*it)->m_cmd_id & CMD_DEPRECATED) || m_parent) {
176 int len = (*it)->m_command.Length();
177 if (len > maxlen) {
178 maxlen = len;
179 }
180 }
181 }
182 maxlen += 4;
183 for (it = m_subcommands.begin(); it != m_subcommands.end(); ++it) {
184 if (!((*it)->m_cmd_id >= 0 && (*it)->m_cmd_id & CMD_DEPRECATED) || m_parent) {
185 m_app.Show((*it)->m_command + wxString(wxT(' '), maxlen - (*it)->m_command.Length()) + wxGetTranslation((*it)->m_short) + wxT("\n"));
186 }
187 }
188 if (!m_parent) {
189 m_app.Show(CFormat(_("\nAll commands are case insensitive.\nType '%s <command>' to get detailed info on <command>.\n")) % wxT("help"));
190 }
191 }
192 }
193 m_app.Show(wxT("\n"));
194 }
195
196 //-------------------------------------------------------------------
197
198 CaMuleExternalConnector::CaMuleExternalConnector()
199 : m_configFile(NULL),
200 m_port(-1),
201 m_KeepQuiet(false),
202 m_Verbose(false),
203 m_interactive(false),
204 m_commands(*this),
205 m_ECClient(NULL),
206 m_InputLine(NULL),
207 m_NeedsConfigSave(false),
208 m_locale(NULL),
209 m_strFullVersion(NULL),
210 m_strOSDescription(NULL)
211 {
212 SetAppName(wxT("aMule")); // Do not change!
213 }
214
215 CaMuleExternalConnector::~CaMuleExternalConnector()
216 {
217 delete m_configFile;
218 delete m_locale;
219 free(m_strFullVersion);
220 free(m_strOSDescription);
221 }
222
223 void CaMuleExternalConnector::OnInitCommandSet()
224 {
225 m_commands.AddCommand(wxT("Quit"), CMD_ID_QUIT, wxTRANSLATE("Exits from the application."), wxEmptyString);
226 m_commands.AddCommand(wxT("Exit"), CMD_ID_QUIT, wxTRANSLATE("Exits from the application."), wxEmptyString);
227 m_commands.AddCommand(wxT("Help"), CMD_ID_HELP, wxTRANSLATE("Show help."),
228 /* TRANSLATORS:
229 Do not translate the word 'help', it is a command to the program! */
230 wxTRANSLATE("To get help on a command, type 'help <command>'.\nTo get the full command list type 'help'.\n"));
231 }
232
233 void CaMuleExternalConnector::Show(const wxString &s)
234 {
235 if( !m_KeepQuiet ) {
236 printf("%s", (const char *)unicode2char(s));
237 #ifdef __WXMSW__
238 fflush(stdout);
239 #endif
240 }
241 }
242
243 void CaMuleExternalConnector::ShowGreet()
244 {
245 wxString text = GetGreetingTitle();
246 int len = text.Length();
247 Show(wxT('\n') + wxString(wxT('-'), 22 + len) + wxT('\n'));
248 Show(wxT('|') + wxString(wxT(' '), 10) + text + wxString(wxT(' '), 10) + wxT('|') + wxT('\n'));
249 Show(wxString(wxT('-'), 22 + len) + wxT('\n'));
250 // Do not merge the line below, or translators could translate "Help"
251 Show(CFormat(_("\nUse '%s' for command list\n\n")) % wxT("Help"));
252 }
253
254 void CaMuleExternalConnector::Process_Answer(const wxString& answer)
255 {
256 wxStringTokenizer tokens(answer, wxT("\n"));
257 while ( tokens.HasMoreTokens() ) {
258 Show(wxT(" > ") + tokens.GetNextToken() + wxT("\n"));
259 }
260 }
261
262 bool CaMuleExternalConnector::Parse_Command(const wxString& buffer)
263 {
264 wxString cmd;
265 wxStringTokenizer tokens(buffer);
266 while (tokens.HasMoreTokens()) {
267 cmd += tokens.GetNextToken() + wxT(' ');
268 }
269 cmd.Trim(false);
270 cmd.Trim(true);
271 int cmd_ID = GetIDFromString(cmd);
272 if ( cmd_ID >= 0 ) {
273 cmd_ID = ProcessCommand(cmd_ID);
274 }
275 wxString error;
276 switch (cmd_ID) {
277 case CMD_ID_HELP:
278 m_commands.PrintHelpFor(GetCmdArgs());
279 break;
280 case CMD_ERR_SYNTAX:
281 error = _("Syntax error!");
282 break;
283 case CMD_ERR_PROCESS_CMD:
284 Show(_("Error processing command - should never happen! Report bug, please\n"));
285 break;
286 case CMD_ERR_NO_PARAM:
287 error = _("This command should not have any parameters.");
288 break;
289 case CMD_ERR_MUST_HAVE_PARAM:
290 error = _("This command must have a parameter.");
291 break;
292 case CMD_ERR_INVALID_ARG:
293 error = _("Invalid argument.");
294 break;
295 case CMD_ERR_INCOMPLETE:
296 error = _("This is an incomplete command.");
297 break;
298 }
299 if (!error.IsEmpty()) {
300 Show(error + wxT('\n'));
301 wxString helpStr(wxT("help"));
302 if (!GetLastCmdStr().IsEmpty()) {
303 helpStr << wxT(' ') << GetLastCmdStr();
304 }
305 Show(CFormat(_("Type '%s' to get more help.\n")) % helpStr);
306 }
307 return cmd_ID == CMD_ID_QUIT;
308 }
309
310 void CaMuleExternalConnector::GetCommand(const wxString &prompt, char* buffer, size_t buffer_size)
311 {
312 #ifdef HAVE_LIBREADLINE
313 char *text = readline(unicode2char(prompt + wxT("$ ")));
314 if (text && *text &&
315 (m_InputLine == 0 || strcmp(text,m_InputLine) != 0)) {
316 add_history (text);
317 }
318 if (m_InputLine)
319 free(m_InputLine);
320 m_InputLine = text;
321 #else
322 Show(prompt + wxT("$ "));
323 fflush(stdin);
324 fgets(buffer, buffer_size, stdin);
325 const char *text = buffer;
326 #endif /* HAVE_LIBREADLINE */
327 if ( text ) {
328 size_t len = strlen(text);
329 if (len > buffer_size - 2) {
330 len = buffer_size - 2;
331 }
332 strncpy(buffer, text, len);
333 buffer[len] = '\n';
334 buffer[len + 1] = 0;
335 } else {
336 strncpy(buffer, "quit", buffer_size);
337 }
338 }
339
340 void CaMuleExternalConnector::TextShell(const wxString &prompt)
341 {
342 char buffer[256];
343 wxString buf;
344
345 bool The_End = false;
346 do {
347 GetCommand(prompt, buffer, 256);
348 buf = char2unicode(buffer);
349 The_End = Parse_Command(buf);
350 } while ((!The_End) && (m_ECClient->IsSocketConnected()));
351 }
352
353 void CaMuleExternalConnector::ConnectAndRun(const wxString &ProgName, const wxString& ProgVersion)
354 {
355 if (m_NeedsConfigSave) {
356 SaveConfigFile();
357 return;
358 }
359
360 #ifdef SVNDATE
361 Show(CFormat(_("This is %s %s %s\n")) % wxString::FromAscii(m_appname) % wxT(VERSION) % wxT(SVNDATE));
362 #else
363 Show(CFormat(_("This is %s %s\n")) % wxString::FromAscii(m_appname) % wxT(VERSION));
364 #endif
365
366 // HostName, Port and Password
367 if ( m_password.IsEmpty() ) {
368 wxString pass_plain;
369 #ifndef __WXMSW__
370 pass_plain = char2unicode(getpass("Enter password for mule connection: "));
371 #else
372 //#warning This way, pass enter is not hidden on windows. Bad thing.
373 char temp_str[512];
374 fflush(stdin);
375 printf("Enter password for mule connection: \n");
376 fflush(stdout);
377 fgets(temp_str, 512, stdin);
378 temp_str[strlen(temp_str)-1] = '\0';
379 pass_plain = char2unicode(temp_str);
380 #endif
381 wxCHECK2(m_password.Decode(MD5Sum(pass_plain).GetHash()), /* Do nothing. */ );
382 // MD5 hash for an empty string, according to rfc1321.
383 if (m_password.Encode() == wxT("D41D8CD98F00B204E9800998ECF8427E")) {
384 m_password.Clear();
385 }
386
387 // Clear plain-text password
388 pass_plain = wxT("01234567890123456789");
389 }
390
391 if (!m_password.IsEmpty()) {
392
393 // Create the socket
394 Show(_("\nCreating client...\n"));
395 m_ECClient = new CRemoteConnect(NULL);
396
397 // ConnectToCore is blocking since m_ECClient was initialized with NULL
398 if (!m_ECClient->ConnectToCore(m_host, m_port, wxT("foobar"), m_password.Encode(), ProgName, ProgVersion)) {
399 // no connection => close gracefully
400 if (!m_ECClient->GetServerReply().IsEmpty()) {
401 Show(CFormat(wxT("%s\n")) % m_ECClient->GetServerReply());
402 }
403 Show(CFormat(_("Connection Failed. Unable to connect to %s:%d\n")) % m_host % m_port);
404 } else {
405 // Authenticate ourselves
406 // ConnectToCore() already authenticated for us.
407 //m_ECClient->ConnectionEstablished();
408 Show(m_ECClient->GetServerReply()+wxT("\n"));
409 if (m_ECClient->IsSocketConnected()) {
410 if (m_interactive) {
411 ShowGreet();
412 }
413 Pre_Shell();
414 TextShell(ProgName);
415 Post_Shell();
416 if (m_interactive) {
417 Show(CFormat(_("\nOk, exiting %s...\n")) % ProgName);
418 }
419 }
420 }
421 m_ECClient->DestroySocket();
422 } else {
423 Show(_("Cannot connect with an empty password.\nYou must specify a password either in config file\nor on command-line, or enter one when asked.\n\nExiting...\n"));
424 }
425 }
426
427 void CaMuleExternalConnector::OnInitCmdLine(wxCmdLineParser& parser, const char* appname)
428 {
429 m_appname = appname;
430
431 parser.AddSwitch(wxEmptyString, wxT("help"),
432 _("Show this help text."),
433 wxCMD_LINE_PARAM_OPTIONAL);
434 parser.AddOption(wxT("h"), wxT("host"),
435 _("Host where aMule is running. (default: localhost)"),
436 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
437 parser.AddOption(wxT("p"), wxT("port"),
438 _("aMule's port for External Connection. (default: 4712)"),
439 wxCMD_LINE_VAL_NUMBER, wxCMD_LINE_PARAM_OPTIONAL);
440 parser.AddOption(wxT("P"), wxT("password"),
441 _("External Connection password."),
442 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
443 parser.AddOption(wxT("f"), wxT("config-file"),
444 _("Read configuration from file."),
445 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
446 parser.AddSwitch(wxT("q"), wxT("quiet"),
447 _("Do not print any output to stdout."),
448 wxCMD_LINE_PARAM_OPTIONAL);
449 parser.AddSwitch(wxT("v"), wxT("verbose"),
450 _("Be verbose - show also debug messages."),
451 wxCMD_LINE_PARAM_OPTIONAL);
452 parser.AddOption(wxT("l"), wxT("locale"),
453 _("Sets program locale (language)."),
454 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
455 parser.AddSwitch(wxT("w"), wxT("write-config"),
456 _("Write command line options to config file."),
457 wxCMD_LINE_PARAM_OPTIONAL);
458 parser.AddOption(wxEmptyString, wxT("create-config-from"),
459 _("Creates config file based on aMule's config file."),
460 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
461 parser.AddSwitch(wxEmptyString, wxT("version"),
462 _("Print program version."),
463 wxCMD_LINE_PARAM_OPTIONAL);
464 }
465
466 bool CaMuleExternalConnector::OnCmdLineParsed(wxCmdLineParser& parser)
467 {
468 if (parser.Found(wxT("version"))) {
469 printf("%s %s\n", m_appname, (const char *)unicode2char(GetMuleVersion()));
470 return false;
471 }
472
473 if (!parser.Found(wxT("config-file"), &m_configFileName)) {
474 m_configFileName = GetConfigDir() + wxT("remote.conf");
475 }
476
477 wxString aMuleConfigFile;
478 if (parser.Found(wxT("create-config-from"), &aMuleConfigFile)) {
479 aMuleConfigFile = FinalizeFilename(aMuleConfigFile);
480 if (!::wxFileExists(aMuleConfigFile)) {
481 fprintf(stderr, "%s\n", (const char *)unicode2char(wxT("FATAL ERROR: File does not exist: ") + aMuleConfigFile));
482 exit(1);
483 }
484 CECFileConfig aMuleConfig(aMuleConfigFile);
485 LoadAmuleConfig(aMuleConfig);
486 SaveConfigFile();
487 m_configFile->Flush();
488 exit(0);
489 }
490
491 LoadConfigFile();
492
493 if ( !parser.Found(wxT("host"), &m_host) ) {
494 if ( m_host.IsEmpty() ) {
495 m_host = wxT("localhost");
496 }
497 }
498
499 long port;
500 if (parser.Found(wxT("port"), &port)) {
501 m_port = port;
502 }
503
504 wxString pass_plain;
505 if (parser.Found(wxT("password"), &pass_plain)) {
506 if (!pass_plain.IsEmpty()) {
507 m_password.Decode(MD5Sum(pass_plain).GetHash());
508 } else {
509 m_password.Clear();
510 }
511 }
512
513 if (parser.Found(wxT("write-config"))) {
514 m_NeedsConfigSave = true;
515 }
516
517 parser.Found(wxT("locale"), &m_language);
518
519 if (parser.Found(wxT("help"))) {
520 parser.Usage();
521 return false;
522 }
523
524 m_KeepQuiet = parser.Found(wxT("quiet"));
525 m_Verbose = parser.Found(wxT("verbose"));
526
527 return true;
528 }
529
530 void CaMuleExternalConnector::LoadAmuleConfig(CECFileConfig& cfg)
531 {
532 m_host = wxT("localhost");
533 m_port = cfg.Read(wxT("/ExternalConnect/ECPort"), 4712l);
534 cfg.ReadHash(wxT("/ExternalConnect/ECPassword"), &m_password);
535 m_language = cfg.Read(wxT("/eMule/Language"), wxEmptyString);
536 }
537
538
539 void CaMuleExternalConnector::LoadConfigFile()
540 {
541 if (!m_configFile) {
542 m_configFile = new CECFileConfig(m_configFileName);
543 }
544 if (m_configFile) {
545 m_language = m_configFile->Read(wxT("/Locale"), wxEmptyString);
546 m_host = m_configFile->Read(wxT("/EC/Host"), wxEmptyString);
547 m_port = m_configFile->Read(wxT("/EC/Port"), 4712l);
548 m_configFile->ReadHash(wxT("/EC/Password"), &m_password);
549 }
550 }
551
552 void CaMuleExternalConnector::SaveConfigFile()
553 {
554 if (!wxFileName::DirExists(GetConfigDir())) {
555 wxFileName::Mkdir(GetConfigDir());
556 }
557 if (!m_configFile) {
558 m_configFile = new CECFileConfig(m_configFileName);
559 }
560 if (m_configFile) {
561 m_configFile->Write(wxT("/Locale"), m_language);
562 m_configFile->Write(wxT("/EC/Host"), m_host);
563 m_configFile->Write(wxT("/EC/Port"), m_port);
564 m_configFile->WriteHash(wxT("/EC/Password"), m_password);
565 }
566 }
567
568 bool CaMuleExternalConnector::OnInit()
569 {
570 #ifndef __WXMSW__
571 // catch fatal exceptions
572 wxHandleFatalExceptions(true);
573 #endif
574
575 m_strFullVersion = strdup((const char *)unicode2char(GetMuleVersion()));
576 m_strOSDescription = strdup((const char *)unicode2char(wxGetOsDescription()));
577
578 // Handle uncaught exceptions
579 InstallMuleExceptionHandler();
580
581 bool retval = wxApp::OnInit();
582 OnInitCommandSet();
583 InitCustomLanguages();
584 SetLocale(m_language);
585 return retval;
586 }
587
588 wxString CaMuleExternalConnector::SetLocale(const wxString& language)
589 {
590 if (!language.IsEmpty()) {
591 m_language = language;
592 if (m_locale) {
593 delete m_locale;
594 }
595 m_locale = new wxLocale;
596 InitLocale(*m_locale, StrLang2wx(language));
597 }
598
599 return m_locale == NULL ? wxString() : m_locale->GetCanonicalName();
600 }
601
602 #if !wxUSE_GUI && defined(__WXMAC__)
603
604 #include <wx/apptrait.h> // Do_not_auto_remove
605 #include <wx/stdpaths.h> // Do_not_auto_remove
606
607 class CaMuleExternalConnectorTraits : public wxConsoleAppTraits
608 {
609 public:
610 virtual wxStandardPathsBase& GetStandardPaths()
611 {
612 return s_stdPaths;
613 }
614
615 private:
616 static wxStandardPathsCF s_stdPaths;
617 };
618
619 wxStandardPathsCF CaMuleExternalConnectorTraits::s_stdPaths;
620
621 wxAppTraits* CaMuleExternalConnector::CreateTraits()
622 {
623 return new CaMuleExternalConnectorTraits;
624 }
625
626 #endif
627
628 // Gracefully handle fatal exceptions and print backtrace if possible
629 void CaMuleExternalConnector::OnFatalException()
630 {
631 /* Print the backtrace */
632 fprintf(stderr, "\n--------------------------------------------------------------------------------\n");
633 fprintf(stderr, "A fatal error has occurred and %s has crashed.\n", m_appname);
634 fprintf(stderr, "Please assist us in fixing this problem by posting the backtrace below in our\n");
635 fprintf(stderr, "'aMule Crashes' forum and include as much information as possible regarding the\n");
636 fprintf(stderr, "circumstances of this crash. The forum is located here:\n");
637 fprintf(stderr, " http://forum.amule.org/index.php?board=67.0\n");
638 fprintf(stderr, "If possible, please try to generate a real backtrace of this crash:\n");
639 fprintf(stderr, " http://wiki.amule.org/index.php/Backtraces\n\n");
640 fprintf(stderr, "----------------------------=| BACKTRACE FOLLOWS: |=----------------------------\n");
641 fprintf(stderr, "Current version is: %s %s\n", m_appname, m_strFullVersion);
642 fprintf(stderr, "Running on: %s\n\n", m_strOSDescription);
643
644 print_backtrace(1); // 1 == skip this function.
645
646 fprintf(stderr, "\n--------------------------------------------------------------------------------\n");
647 }
648
649 #ifdef __WXDEBUG__
650 void CaMuleExternalConnector::OnAssertFailure(const wxChar *file, int line, const wxChar *func, const wxChar *cond, const wxChar *msg)
651 {
652 #if !defined wxUSE_STACKWALKER || !wxUSE_STACKWALKER
653 wxString errmsg = CFormat( wxT("%s:%s:%d: Assertion '%s' failed. %s") ) % file % func % line % cond % ( msg ? msg : wxT("") );
654
655 fprintf(stderr, "Assertion failed: %s\n", (const char*)unicode2char(errmsg));
656
657 // Skip the function-calls directly related to the assert call.
658 fprintf(stderr, "\nBacktrace follows:\n");
659 print_backtrace(3);
660 fprintf(stderr, "\n");
661 #else
662 wxApp::OnAssertFailure(file, line, func, cond, msg);
663 #endif
664 }
665 #endif
666 // File_checked_for_headers
aMule P2P client