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