src/ExternalConnector.cpp

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