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 #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         m_appname =
 214                 // Find out Application Name
 215 #ifdef WEBSERVERDIR
 216                 "amuleweb"
 217 #else
 218                 "amulecmd"
 219 #endif
 220                 ;
 221 }
 222
 223 CaMuleExternalConnector::~CaMuleExternalConnector()
 224 {
 225         delete m_configFile;
 226         delete m_locale;
 227         free(m_strFullVersion);
 228         free(m_strOSDescription);
 229 }
 230
 231 void CaMuleExternalConnector::OnInitCommandSet()
 232 {
 233         m_commands.AddCommand(wxT("Quit"), CMD_ID_QUIT, wxTRANSLATE("Exits from the application."), wxEmptyString);
 234         m_commands.AddCommand(wxT("Exit"), CMD_ID_QUIT, wxTRANSLATE("Exits from the application."), wxEmptyString);
 235         m_commands.AddCommand(wxT("Help"), CMD_ID_HELP, wxTRANSLATE("Show help."),
 236                               /* TRANSLATORS:
 237                                  Do not translate the word 'help', it is a command to the program! */
 238                               wxTRANSLATE("To get help on a command, type 'help <command>'.\nTo get the full command list type 'help'.\n"));
 239 }
 240
 241 void CaMuleExternalConnector::Show(const wxString &s)
 242 {
 243         if( !m_KeepQuiet ) {
 244                 printf("%s", (const char *)unicode2char(s));
 245 #ifdef __WXMSW__
 246                 fflush(stdout);
 247 #endif
 248         }
 249 }
 250
 251 void CaMuleExternalConnector::ShowGreet()
 252 {
 253         wxString text = GetGreetingTitle();
 254         int len = text.Length();
 255         Show(wxT('\n') + wxString(wxT('-'), 22 + len) + wxT('\n'));
 256         Show(wxT('|') + wxString(wxT(' '), 10) + text + wxString(wxT(' '), 10) + wxT('|') + wxT('\n'));
 257         Show(wxString(wxT('-'), 22 + len) + wxT('\n'));
 258         // Do not merge the line below, or translators could translate "Help"
 259         Show(CFormat(_("\nUse '%s' for command list\n\n")) % wxT("Help"));
 260 }
 261
 262 void CaMuleExternalConnector::Process_Answer(const wxString& answer)
 263 {
 264         wxStringTokenizer tokens(answer, wxT("\n"));
 265         while ( tokens.HasMoreTokens() ) {
 266                 Show(wxT(" > ") + tokens.GetNextToken() + wxT("\n"));
 267         }
 268 }
 269
 270 bool CaMuleExternalConnector::Parse_Command(const wxString& buffer)
 271 {
 272         wxString cmd;
 273         wxStringTokenizer tokens(buffer);
 274         while (tokens.HasMoreTokens()) {
 275                 cmd += tokens.GetNextToken() + wxT(' ');
 276         }
 277         cmd.Trim(false);
 278         cmd.Trim(true);
 279         int cmd_ID = GetIDFromString(cmd);
 280         if ( cmd_ID >= 0 ) {
 281                 cmd_ID = ProcessCommand(cmd_ID);
 282         }
 283         wxString error;
 284         switch (cmd_ID) {
 285                 case CMD_ID_HELP:
 286                         m_commands.PrintHelpFor(GetCmdArgs());
 287                         break;
 288                 case CMD_ERR_SYNTAX:
 289                         error = _("Syntax error!");
 290                         break;
 291                 case CMD_ERR_PROCESS_CMD:
 292                         Show(_("Error processing command - should never happen! Report bug, please\n"));
 293                         break;
 294                 case CMD_ERR_NO_PARAM:
 295                         error = _("This command should not have any parameters.");
 296                         break;
 297                 case CMD_ERR_MUST_HAVE_PARAM:
 298                         error = _("This command must have a parameter.");
 299                         break;
 300                 case CMD_ERR_INVALID_ARG:
 301                         error = _("Invalid argument.");
 302                         break;
 303                 case CMD_ERR_INCOMPLETE:
 304                         error = _("This is an incomplete command.");
 305                         break;
 306         }
 307         if (!error.IsEmpty()) {
 308                 Show(error + wxT('\n'));
 309                 wxString helpStr(wxT("help"));
 310                 if (!GetLastCmdStr().IsEmpty()) {
 311                         helpStr << wxT(' ') << GetLastCmdStr();
 312                 }
 313                 Show(CFormat(_("Type '%s' to get more help.\n")) % helpStr);
 314         }
 315         return cmd_ID == CMD_ID_QUIT;
 316 }
 317
 318 void CaMuleExternalConnector::GetCommand(const wxString &prompt, char* buffer, size_t buffer_size)
 319 {
 320 #ifdef HAVE_LIBREADLINE
 321                 char *text = readline(unicode2char(prompt + wxT("$ ")));
 322                 if (text && *text &&
 323                     (m_InputLine == 0 || strcmp(text,m_InputLine) != 0)) {
 324                   add_history (text);
 325                 }
 326                 if (m_InputLine)
 327                   free(m_InputLine);
 328                 m_InputLine = text;
 329 #else
 330                 Show(prompt + wxT("$ "));
 331                 fflush(stdin);
 332                 fgets(buffer, buffer_size, stdin);
 333                 const char *text = buffer;
 334 #endif /* HAVE_LIBREADLINE */
 335                 if ( text ) {
 336                         size_t len = strlen(text);
 337                         if (len > buffer_size - 2) {
 338                                 len = buffer_size - 2;
 339                         }
 340                         strncpy(buffer, text, len);
 341                         buffer[len] = '\n';
 342                         buffer[len + 1] = 0;
 343                 } else {
 344                         strncpy(buffer, "quit", buffer_size);
 345                 }
 346 }
 347
 348 void CaMuleExternalConnector::TextShell(const wxString &prompt)
 349 {
 350         char buffer[256];
 351         wxString buf;
 352
 353         bool The_End = false;
 354         do {
 355                 GetCommand(prompt, buffer, 256);
 356                 buf = char2unicode(buffer);
 357                 The_End = Parse_Command(buf);
 358         } while ((!The_End) && (m_ECClient->IsSocketConnected()));
 359 }
 360
 361 void CaMuleExternalConnector::ConnectAndRun(const wxString &ProgName, const wxString& ProgVersion)
 362 {
 363         if (m_NeedsConfigSave) {
 364                 SaveConfigFile();
 365                 return;
 366         }
 367
 368         #ifdef SVNDATE
 369                 Show(CFormat(_("This is %s %s %s\n")) % wxString::FromAscii(m_appname) % wxT(VERSION) % wxT(SVNDATE));
 370         #else
 371                 Show(CFormat(_("This is %s %s\n")) % wxString::FromAscii(m_appname) % wxT(VERSION));
 372         #endif
 373
 374         // HostName, Port and Password
 375         if ( m_password.IsEmpty() ) {
 376                 wxString pass_plain;
 377                 #ifndef __WXMSW__
 378                         pass_plain = char2unicode(getpass("Enter password for mule connection: "));
 379                 #else
 380                         //#warning This way, pass enter is not hidden on windows. Bad thing.
 381                         char temp_str[512];
 382                         fflush(stdin);
 383                         printf("Enter password for mule connection: \n");
 384                         fflush(stdout);
 385                         fgets(temp_str, 512, stdin);
 386                         temp_str[strlen(temp_str)-1] = '\0';
 387                         pass_plain = char2unicode(temp_str);
 388                 #endif
 389                 wxCHECK2(m_password.Decode(MD5Sum(pass_plain).GetHash()), /* Do nothing. */ );
 390                 // MD5 hash for an empty string, according to rfc1321.
 391                 if (m_password.Encode() == wxT("D41D8CD98F00B204E9800998ECF8427E")) {
 392                         m_password.Clear();
 393                 }
 394
 395                 // Clear plain-text password
 396                 pass_plain              = wxT("01234567890123456789");
 397         }
 398
 399         if (!m_password.IsEmpty()) {
 400
 401                 // Create the socket
 402                 Show(_("\nCreating client...\n"));
 403                 m_ECClient = new CRemoteConnect(NULL);
 404
 405                 // ConnectToCore is blocking since m_ECClient was initialized with NULL
 406                 if (!m_ECClient->ConnectToCore(m_host, m_port, wxT("foobar"), m_password.Encode(), ProgName, ProgVersion)) {
 407                         // no connection => close gracefully
 408                         Show(CFormat(_("Connection Failed. Unable to connect to %s:%d\n")) % m_host % m_port);
 409                 } else {
 410                         // Authenticate ourselves
 411                         // ConnectToCore() already authenticated for us.
 412                         //m_ECClient->ConnectionEstablished();
 413                         Show(m_ECClient->GetServerReply()+wxT("\n"));
 414                         if (m_ECClient->IsSocketConnected()) {
 415                                 if (m_interactive) {
 416                                         ShowGreet();
 417                                 }
 418                                 Pre_Shell();
 419                                 TextShell(ProgName);
 420                                 Post_Shell();
 421                                 if (m_interactive) {
 422                                         Show(CFormat(_("\nOk, exiting %s...\n")) % ProgName);
 423                                 }
 424                         }
 425                 }
 426                 m_ECClient->DestroySocket();
 427         } else {
 428                 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"));
 429         }
 430 }
 431
 432 void CaMuleExternalConnector::OnInitCmdLine(wxCmdLineParser& parser)
 433 {
 434         parser.AddSwitch(wxEmptyString, wxT("help"),
 435                 _("Show this help text."),
 436                 wxCMD_LINE_PARAM_OPTIONAL);
 437         parser.AddOption(wxT("h"), wxT("host"),
 438                 _("Host where aMule is running. (default: localhost)"),
 439                 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
 440         parser.AddOption(wxT("p"), wxT("port"),
 441                 _("aMule's port for External Connection. (default: 4712)"),
 442                 wxCMD_LINE_VAL_NUMBER, wxCMD_LINE_PARAM_OPTIONAL);
 443         parser.AddOption(wxT("P"), wxT("password"),
 444                 _("External Connection password."),
 445                 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
 446         parser.AddOption(wxT("f"), wxT("config-file"),
 447                 _("Read configuration from file."),
 448                 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
 449         parser.AddSwitch(wxT("q"), wxT("quiet"),
 450                 _("Do not print any output to stdout."),
 451                 wxCMD_LINE_PARAM_OPTIONAL);
 452         parser.AddSwitch(wxT("v"), wxT("verbose"),
 453                 _("Be verbose - show also debug messages."),
 454                 wxCMD_LINE_PARAM_OPTIONAL);
 455         parser.AddOption(wxT("l"), wxT("locale"),
 456                 _("Sets program locale (language)."),
 457                 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
 458         parser.AddSwitch(wxT("w"), wxT("write-config"),
 459                 _("Write command line options to config file."),
 460                 wxCMD_LINE_PARAM_OPTIONAL);
 461         parser.AddOption(wxEmptyString, wxT("create-config-from"),
 462                 _("Creates config file based on aMule's config file."),
 463                 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
 464         parser.AddSwitch(wxEmptyString, wxT("version"),
 465                 _("Print program version."),
 466                 wxCMD_LINE_PARAM_OPTIONAL);
 467 }
 468
 469 bool CaMuleExternalConnector::OnCmdLineParsed(wxCmdLineParser& parser)
 470 {
 471         if (parser.Found(wxT("version"))) {
 472                 printf("%s %s\n", m_appname, (const char *)unicode2char(GetMuleVersion()));
 473                 return false;
 474         }
 475
 476         if (!parser.Found(wxT("config-file"), &m_configFileName)) {
 477                 m_configFileName = GetConfigDir() + wxT("remote.conf");
 478         }
 479
 480         wxString aMuleConfigFile;
 481         if (parser.Found(wxT("create-config-from"), &aMuleConfigFile)) {
 482                 aMuleConfigFile = FinalizeFilename(aMuleConfigFile);
 483                 if (!::wxFileExists(aMuleConfigFile)) {
 484                         fprintf(stderr, "%s\n", (const char *)unicode2char(wxT("FATAL ERROR: File does not exist: ") + aMuleConfigFile));
 485                         exit(1);
 486                 }
 487                 CECFileConfig aMuleConfig(aMuleConfigFile);
 488                 LoadAmuleConfig(aMuleConfig);
 489                 SaveConfigFile();
 490                 m_configFile->Flush();
 491                 exit(0);
 492         }
 493
 494         LoadConfigFile();
 495
 496         if ( !parser.Found(wxT("host"), &m_host) ) {
 497                 if ( m_host.IsEmpty() ) {
 498                         m_host = wxT("localhost");
 499                 }
 500         }
 501
 502         long port;
 503         if (!parser.Found(wxT("port"), &port)) {
 504                 if (m_port == -1) {
 505                         m_port = 4712;
 506                 }
 507         } else {
 508                 m_port = port;
 509         }
 510
 511         wxString pass_plain;
 512         if (parser.Found(wxT("password"), &pass_plain)) {
 513                 if (!pass_plain.IsEmpty()) {
 514                         m_password.Decode(MD5Sum(pass_plain).GetHash());
 515                 } else {
 516                         m_password.Clear();
 517                 }
 518         }
 519
 520         if (parser.Found(wxT("write-config"))) {
 521                 m_NeedsConfigSave = true;
 522         }
 523
 524         parser.Found(wxT("locale"), &m_language);
 525
 526         if (parser.Found(wxT("help"))) {
 527                 parser.Usage();
 528                 return false;
 529         }
 530
 531         m_KeepQuiet = parser.Found(wxT("quiet"));
 532         m_Verbose = parser.Found(wxT("verbose"));
 533
 534         return true;
 535 }
 536
 537 void CaMuleExternalConnector::LoadAmuleConfig(CECFileConfig& cfg)
 538 {
 539         m_host = wxT("localhost");
 540         m_port = cfg.Read(wxT("/ExternalConnect/ECPort"), -1l);
 541         cfg.ReadHash(wxT("/ExternalConnect/ECPassword"), &m_password);
 542         m_language = cfg.Read(wxT("/eMule/Language"), wxEmptyString);
 543 }
 544
 545
 546 void CaMuleExternalConnector::LoadConfigFile()
 547 {
 548         if (!m_configFile) {
 549                 m_configFile = new CECFileConfig(m_configFileName);
 550         }
 551         if (m_configFile) {
 552                 m_language = m_configFile->Read(wxT("/Locale"), wxEmptyString);
 553                 m_host = m_configFile->Read(wxT("/EC/Host"), wxEmptyString);
 554                 m_port = m_configFile->Read(wxT("/EC/Port"), -1l);
 555                 m_configFile->ReadHash(wxT("/EC/Password"), &m_password);
 556         }
 557 }
 558
 559 void CaMuleExternalConnector::SaveConfigFile()
 560 {
 561         if (!wxFileName::DirExists(GetConfigDir())) {
 562                 wxFileName::Mkdir(GetConfigDir());
 563         }
 564         if (!m_configFile) {
 565                 m_configFile = new CECFileConfig(m_configFileName);
 566         }
 567         if (m_configFile) {
 568                 m_configFile->Write(wxT("/Locale"), m_language);
 569                 m_configFile->Write(wxT("/EC/Host"), m_host);
 570                 m_configFile->Write(wxT("/EC/Port"), m_port);
 571                 m_configFile->WriteHash(wxT("/EC/Password"), m_password);
 572         }
 573 }
 574
 575 bool CaMuleExternalConnector::OnInit()
 576 {
 577 #ifndef __WXMSW__
 578         // catch fatal exceptions
 579         wxHandleFatalExceptions(true);
 580 #endif
 581
 582         m_strFullVersion = strdup((const char *)unicode2char(GetMuleVersion()));
 583         m_strOSDescription = strdup((const char *)unicode2char(wxGetOsDescription()));
 584
 585         // Handle uncaught exceptions
 586         InstallMuleExceptionHandler();
 587
 588         bool retval = wxApp::OnInit();
 589         OnInitCommandSet();
 590         InitCustomLanguages();
 591         SetLocale(m_language);
 592         return retval;
 593 }
 594
 595 wxString CaMuleExternalConnector::SetLocale(const wxString& language)
 596 {
 597         if (!language.IsEmpty()) {
 598                 m_language = language;
 599                 if (m_locale) {
 600                         delete m_locale;
 601                 }
 602                 m_locale = new wxLocale;
 603                 InitLocale(*m_locale, StrLang2wx(language));
 604         }
 605
 606         return m_locale == NULL ? wxString() : m_locale->GetCanonicalName();
 607 }
 608
 609 #if !wxUSE_GUI && defined(__WXMAC__)
 610
 611 #include <wx/apptrait.h> // Do_not_auto_remove
 612 #include <wx/stdpaths.h> // Do_not_auto_remove
 613
 614 class CaMuleExternalConnectorTraits : public wxConsoleAppTraits
 615 {
 616 public:
 617         virtual wxStandardPathsBase& GetStandardPaths()
 618         {
 619                 return s_stdPaths;
 620         }
 621
 622 private:
 623         static wxStandardPathsCF s_stdPaths;
 624 };
 625
 626 wxStandardPathsCF CaMuleExternalConnectorTraits::s_stdPaths;
 627
 628 wxAppTraits* CaMuleExternalConnector::CreateTraits()
 629 {
 630         return new CaMuleExternalConnectorTraits;
 631 }
 632
 633 #endif
 634
 635 // Gracefully handle fatal exceptions and print backtrace if possible
 636 void CaMuleExternalConnector::OnFatalException()
 637 {
 638         /* Print the backtrace */
 639         fprintf(stderr, "\n--------------------------------------------------------------------------------\n");
 640         fprintf(stderr, "A fatal error has occurred and %s has crashed.\n", m_appname);
 641         fprintf(stderr, "Please assist us in fixing this problem by posting the backtrace below in our\n");
 642         fprintf(stderr, "'aMule Crashes' forum and include as much information as possible regarding the\n");
 643         fprintf(stderr, "circumstances of this crash. The forum is located here:\n");
 644         fprintf(stderr, "    http://forum.amule.org/index.php?board=67.0\n");
 645         fprintf(stderr, "If possible, please try to generate a real backtrace of this crash:\n");
 646         fprintf(stderr, "    http://www.amule.org/wiki/index.php/Backtraces\n\n");
 647         fprintf(stderr, "----------------------------=| BACKTRACE FOLLOWS: |=----------------------------\n");
 648         fprintf(stderr, "Current version is: %s %s\n", m_appname, m_strFullVersion);
 649         fprintf(stderr, "Running on: %s\n\n", m_strOSDescription);
 650
 651         print_backtrace(1); // 1 == skip this function.
 652
 653         fprintf(stderr, "\n--------------------------------------------------------------------------------\n");
 654 }
 655
 656 #ifdef __WXDEBUG__
 657 void CaMuleExternalConnector::OnAssertFailure(const wxChar *file, int line, const wxChar *func, const wxChar *cond, const wxChar *msg)
 658 {
 659 #if !defined wxUSE_STACKWALKER || !wxUSE_STACKWALKER
 660         wxString errmsg = CFormat( wxT("%s:%s:%d: Assertion '%s' failed. %s") ) % file % func % line % cond % ( msg ? msg : wxT("") );
 661
 662         fprintf(stderr, "Assertion failed: %s\n", (const char*)unicode2char(errmsg));
 663
 664         // Skip the function-calls directly related to the assert call.
 665         fprintf(stderr, "\nBacktrace follows:\n");
 666         print_backtrace(3);
 667         fprintf(stderr, "\n");
 668 #else
 669         wxApp::OnAssertFailure(file, line, func, cond, msg);
 670 #endif
 671 }
 672 #endif
 673 // File_checked_for_headers