src/TextClient.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2011 Angel Vidal ( kry@amule.org )
   5 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26
  27 #ifdef HAVE_CONFIG_H
  28         #include "config.h"             // Needed for VERSION
  29 #else
  30         #include <common/ClientVersion.h>
  31 #endif
  32
  33
  34 #include "TextClient.h"
  35
  36 #ifndef __WINDOWS__
  37         #include <unistd.h> // Do_not_auto_remove
  38 #endif
  39
  40
  41 //-------------------------------------------------------------------
  42
  43
  44 //-------------------------------------------------------------------
  45
  46 #include <ec/cpp/ECSpecialTags.h>
  47
  48 #include <wx/tokenzr.h>
  49
  50 #include <common/Format.h>              // Needed for CFormat
  51 #include "OtherFunctions.h"
  52 #include "Constants.h"                  // Needed for Priority Levels
  53 #include "DataToText.h"                 // Needed for PriorityToStr
  54 #include "MuleVersion.h"                // Needed for GetMuleVersion()
  55
  56 //-------------------------------------------------------------------
  57
  58 enum {
  59         CMD_ID_STATUS,
  60         CMD_ID_RESUME,
  61         CMD_ID_PAUSE,
  62         CMD_ID_PRIORITY_LOW,
  63         CMD_ID_PRIORITY_NORMAL,
  64         CMD_ID_PRIORITY_HIGH,
  65         CMD_ID_PRIORITY_AUTO,
  66         CMD_ID_CANCEL,
  67         CMD_ID_CONNECT,
  68         CMD_ID_CONNECT_ED2K,
  69         CMD_ID_CONNECT_KAD,
  70         CMD_ID_DISCONNECT,
  71         CMD_ID_DISCONNECT_ED2K,
  72         CMD_ID_DISCONNECT_KAD,
  73         CMD_ID_RELOAD_SHARED,
  74         CMD_ID_RELOAD_IPFILTER_LOCAL,
  75         CMD_ID_RELOAD_IPFILTER_NET,
  76         CMD_ID_SET_IPFILTER_ON,
  77         CMD_ID_SET_IPFILTER_OFF,
  78         CMD_ID_SET_IPFILTER_CLIENTS_ON,
  79         CMD_ID_SET_IPFILTER_CLIENTS_OFF,
  80         CMD_ID_SET_IPFILTER_SERVERS_ON,
  81         CMD_ID_SET_IPFILTER_SERVERS_OFF,
  82         CMD_ID_SET_IPFILTER_LEVEL,
  83         CMD_ID_GET_IPFILTER,
  84         CMD_ID_GET_IPFILTER_STATE,
  85         CMD_ID_GET_IPFILTER_STATE_CLIENTS,
  86         CMD_ID_GET_IPFILTER_STATE_SERVERS,
  87         CMD_ID_GET_IPFILTER_LEVEL,
  88         CMD_ID_SHOW_UL,
  89         CMD_ID_SHOW_DL,
  90         CMD_ID_SHOW_LOG,
  91         CMD_ID_SHOW_SERVERS,
  92         CMD_ID_SHOW_SHARED,
  93         CMD_ID_RESET_LOG,
  94         CMD_ID_SHUTDOWN,
  95         CMD_ID_ADDLINK,
  96         CMD_ID_SET_BWLIMIT_UP,
  97         CMD_ID_SET_BWLIMIT_DOWN,
  98         CMD_ID_GET_BWLIMITS,
  99         CMD_ID_STATTREE,
 100         CMD_ID_SEARCH,
 101         CMD_ID_SEARCH_GLOBAL,
 102         CMD_ID_SEARCH_LOCAL,
 103         CMD_ID_SEARCH_KAD,
 104         CMD_ID_SEARCH_RESULTS,
 105         CMD_ID_SEARCH_PROGRESS,
 106         CMD_ID_DOWNLOAD,
 107         // IDs for deprecated commands
 108         CMD_ID_SET_IPFILTER
 109
 110 };
 111
 112 // method to create a SearchFile
 113 SearchFile::SearchFile(const CEC_SearchFile_Tag *tag)
 114 {
 115         nHash = tag->FileHash();
 116         sHash = nHash.Encode();
 117         sFileName = tag->FileName();
 118         lFileSize = tag->SizeFull();
 119         lSourceCount = tag->SourceCount();
 120         bPresent = tag->AlreadyHave();
 121 }
 122
 123 //-------------------------------------------------------------------
 124 IMPLEMENT_APP (CamulecmdApp)
 125 //-------------------------------------------------------------------
 126
 127 void CamulecmdApp::OnInitCmdLine(wxCmdLineParser& parser)
 128 {
 129         CaMuleExternalConnector::OnInitCmdLine(parser, "amulecmd");
 130         parser.AddOption(wxT("c"), wxT("command"),
 131                 _("Execute <str> and exit."),
 132                 wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
 133 }
 134
 135 bool CamulecmdApp::OnCmdLineParsed(wxCmdLineParser& parser)
 136 {
 137         m_HasCmdOnCmdLine = parser.Found(wxT("command"), &m_CmdString);
 138         if (m_CmdString.Lower().StartsWith(wxT("help")))
 139         {
 140                 OnInitCommandSet();
 141                 printf("%s %s\n", m_appname, (const char *)unicode2char(GetMuleVersion()));
 142                 Parse_Command(m_CmdString);
 143                 exit(0);
 144         }
 145         m_interactive = !m_HasCmdOnCmdLine;
 146         return CaMuleExternalConnector::OnCmdLineParsed(parser);
 147 }
 148
 149 void CamulecmdApp::TextShell(const wxString& prompt)
 150 {
 151         if (m_HasCmdOnCmdLine)
 152                 Parse_Command(m_CmdString);
 153         else
 154                 CaMuleExternalConnector::TextShell(prompt);
 155 }
 156
 157 int CamulecmdApp::ProcessCommand(int CmdId)
 158 {
 159         wxString args = GetCmdArgs();
 160         CECPacket *request = 0;
 161         std::list<CECPacket *> request_list;
 162         int tmp_int = 0;
 163         EC_SEARCH_TYPE search_type = EC_SEARCH_KAD;
 164
 165         // Implementation of the deprecated command 'SetIPFilter'.
 166         if (CmdId == CMD_ID_SET_IPFILTER) {
 167                 if ( ! args.IsEmpty() ) {
 168                         if (args.IsSameAs(wxT("ON"), false)) {
 169                                 CmdId = CMD_ID_SET_IPFILTER_ON;
 170                         } else if (args.IsSameAs(wxT("OFF"), false)) {
 171                                 CmdId = CMD_ID_SET_IPFILTER_OFF;
 172                         } else {
 173                                 return CMD_ERR_INVALID_ARG;
 174                         }
 175                 } else {
 176                         CmdId = CMD_ID_GET_IPFILTER_STATE;
 177                 }
 178         }
 179
 180         switch (CmdId) {
 181                 case CMD_ID_STATUS:
 182                         request_list.push_back(new CECPacket(EC_OP_STAT_REQ, EC_DETAIL_CMD));
 183                         break;
 184
 185                 case CMD_ID_SHUTDOWN:
 186                         request_list.push_back(new CECPacket(EC_OP_SHUTDOWN));
 187                         break;
 188
 189                 case CMD_ID_CONNECT:
 190                         if ( !args.IsEmpty() ) {
 191                                 unsigned int ip[4];
 192                                 unsigned int port;
 193                                 // Not much we can do against this unicode2char.
 194                                 int result = sscanf(unicode2char(args), "%3d.%3d.%3d.%3d:%5d", &ip[0], &ip[1], &ip[2], &ip[3], &port);
 195                                 if (result != 5) {
 196                                         // Try to resolve DNS -- good for dynamic IP servers
 197                                         wxString serverName(args.BeforeFirst(wxT(':')));
 198                                         long lPort;
 199                                         bool ok = args.AfterFirst(wxT(':')).ToLong(&lPort);
 200                                         port = (unsigned int)lPort;
 201                                         amuleIPV4Address a;
 202                                         a.Hostname(serverName);
 203                                         a.Service(port);
 204                                         result = sscanf(unicode2char(a.IPAddress()), "%3d.%3d.%3d.%3d", &ip[0], &ip[1], &ip[2], &ip[3]);
 205                                         if (serverName.IsEmpty() || !ok || (result != 4)) {
 206                                                 Show(_("Invalid IP format. Use xxx.xxx.xxx.xxx:xxxx\n"));
 207                                                 return 0;
 208                                         }
 209                                 }
 210                                 EC_IPv4_t addr;
 211                                 addr.m_ip[0] = ip[0];
 212                                 addr.m_ip[1] = ip[1];
 213                                 addr.m_ip[2] = ip[2];
 214                                 addr.m_ip[3] = ip[3];
 215                                 addr.m_port = port;
 216                                 request = new CECPacket(EC_OP_SERVER_CONNECT);
 217                                 request->AddTag(CECTag(EC_TAG_SERVER, addr));
 218                                 request_list.push_back(request);
 219                         } else {
 220                                 request_list.push_back(new CECPacket(EC_OP_CONNECT));
 221                         }
 222                         break;
 223
 224                 case CMD_ID_CONNECT_ED2K:
 225                         request_list.push_back(new CECPacket(EC_OP_SERVER_CONNECT));
 226                         break;
 227
 228                 case CMD_ID_CONNECT_KAD:
 229                         request_list.push_back(new CECPacket(EC_OP_KAD_START));
 230                         break;
 231
 232                 case CMD_ID_DISCONNECT:
 233                         request_list.push_back(new CECPacket(EC_OP_DISCONNECT));
 234                         break;
 235
 236                 case CMD_ID_DISCONNECT_ED2K:
 237                         request_list.push_back(new CECPacket(EC_OP_SERVER_DISCONNECT));
 238                         break;
 239
 240                 case CMD_ID_DISCONNECT_KAD:
 241                         request_list.push_back(new CECPacket(EC_OP_KAD_STOP));
 242                         break;
 243
 244                 case CMD_ID_RELOAD_SHARED:
 245                         request_list.push_back(new CECPacket(EC_OP_SHAREDFILES_RELOAD));
 246                         break;
 247
 248                 case CMD_ID_RELOAD_IPFILTER_LOCAL:
 249                         request_list.push_back(new CECPacket(EC_OP_IPFILTER_RELOAD));
 250                         break;
 251
 252                 case CMD_ID_RELOAD_IPFILTER_NET:
 253                         request = new CECPacket(EC_OP_IPFILTER_UPDATE);
 254                         request->AddTag(EC_TAG_STRING, args);
 255                         request_list.push_back(request);
 256                         break;
 257
 258                 case CMD_ID_SET_IPFILTER_ON:
 259                 case CMD_ID_SET_IPFILTER_CLIENTS_ON:
 260                 case CMD_ID_SET_IPFILTER_SERVERS_ON:
 261                         tmp_int = 1;
 262                 case CMD_ID_SET_IPFILTER_OFF:
 263                 case CMD_ID_SET_IPFILTER_CLIENTS_OFF:
 264                 case CMD_ID_SET_IPFILTER_SERVERS_OFF:
 265                         {
 266                                 if (CmdId == CMD_ID_SET_IPFILTER_CLIENTS_ON || CmdId == CMD_ID_SET_IPFILTER_CLIENTS_OFF) {
 267                                         CmdId = CMD_ID_GET_IPFILTER_STATE_CLIENTS;
 268                                 } else if (CmdId == CMD_ID_SET_IPFILTER_SERVERS_ON || CmdId == CMD_ID_SET_IPFILTER_SERVERS_OFF) {
 269                                         CmdId = CMD_ID_GET_IPFILTER_STATE_SERVERS;
 270                                 } else {
 271                                         CmdId = CMD_ID_GET_IPFILTER_STATE;
 272                                 }
 273
 274                                 request = new CECPacket(EC_OP_SET_PREFERENCES);
 275                                 CECEmptyTag prefs(EC_TAG_PREFS_SECURITY);
 276                                 if (CmdId != CMD_ID_GET_IPFILTER_STATE_SERVERS) {
 277                                         prefs.AddTag(CECTag(EC_TAG_IPFILTER_CLIENTS, (uint8)tmp_int));
 278                                 }
 279                                 if (CmdId != CMD_ID_GET_IPFILTER_STATE_CLIENTS) {
 280                                         prefs.AddTag(CECTag(EC_TAG_IPFILTER_SERVERS, (uint8)tmp_int));
 281                                 }
 282                                 request->AddTag(prefs);
 283                                 request_list.push_back(request);
 284                         }
 285                 case CMD_ID_GET_IPFILTER:
 286                 case CMD_ID_GET_IPFILTER_STATE:
 287                 case CMD_ID_GET_IPFILTER_STATE_CLIENTS:
 288                 case CMD_ID_GET_IPFILTER_STATE_SERVERS:
 289                         request = new CECPacket(EC_OP_GET_PREFERENCES);
 290                         request->AddTag(CECTag(EC_TAG_SELECT_PREFS, (uint32)EC_PREFS_SECURITY));
 291                         request_list.push_back(request);
 292                         break;
 293
 294                 case CMD_ID_SET_IPFILTER_LEVEL:
 295                         if (!args.IsEmpty()) // This 'if' must stay as long as we support the deprecated 'IPLevel' command.
 296                         {
 297                                 unsigned long int level = 0;
 298                                 if (args.ToULong(&level) == true && level < 256) {
 299                                         request = new CECPacket(EC_OP_SET_PREFERENCES);
 300                                         CECEmptyTag prefs(EC_TAG_PREFS_SECURITY);
 301                                         prefs.AddTag(CECTag(EC_TAG_IPFILTER_LEVEL, (uint8)level));
 302                                         request->AddTag(prefs);
 303                                         request_list.push_back(request);
 304                                 } else {
 305                                         return CMD_ERR_INVALID_ARG;
 306                                 }
 307                         }
 308                         CmdId = CMD_ID_GET_IPFILTER_LEVEL;
 309                 case CMD_ID_GET_IPFILTER_LEVEL:
 310                         request = new CECPacket(EC_OP_GET_PREFERENCES);
 311                         request->AddTag(CECTag(EC_TAG_SELECT_PREFS, (uint32)EC_PREFS_SECURITY));
 312                         request_list.push_back(request);
 313                         break;
 314
 315                 case CMD_ID_PAUSE:
 316                 case CMD_ID_CANCEL:
 317                 case CMD_ID_RESUME:
 318                 {
 319                         if ( args.IsEmpty() ) {
 320                                 Show(_("This command requires an argument. Valid arguments: 'all', filename, or a number.\n"));
 321                                 return 0;
 322                         } else {
 323                                 wxStringTokenizer argsTokenizer(args);
 324                                 wxString token;
 325                                 CMD4Hash hash;
 326
 327                                 // Grab the entire dl queue right away
 328                                 CECPacket request_all(EC_OP_GET_DLOAD_QUEUE, EC_DETAIL_CMD);
 329                                 const CECPacket *reply_all = SendRecvMsg_v2(&request_all);
 330
 331                                 if (reply_all) {
 332                                         switch(CmdId) {
 333                                                 case CMD_ID_PAUSE:
 334                                                                 request = new CECPacket(EC_OP_PARTFILE_PAUSE); break;
 335                                                 case CMD_ID_CANCEL:
 336                                                                 request = new CECPacket(EC_OP_PARTFILE_DELETE); break;
 337                                                 case CMD_ID_RESUME:
 338                                                                 request = new CECPacket(EC_OP_PARTFILE_RESUME); break;
 339                                                 default: wxFAIL;
 340                                         }
 341
 342                                         // We loop through all the arguments
 343                                         while(argsTokenizer.HasMoreTokens()) {
 344                                                 token=argsTokenizer.GetNextToken();
 345
 346                                                 // If the user requested all, then we select all files and exit the loop
 347                                                 // since there is little point to add anything more to "everything"
 348                                                 if( token == wxT("all") ) {
 349                                                         for (CECPacket::const_iterator it = reply_all->begin(); it != reply_all->end(); ++it) {
 350                                                                 const CEC_PartFile_Tag *tag = static_cast<const CEC_PartFile_Tag *>(&*it);
 351                                                                 request->AddTag(CECTag(EC_TAG_PARTFILE, tag->FileHash()));
 352                                                         }
 353                                                         break;
 354                                                 } else if ( hash.Decode(token.Trim(false).Trim(true)) ) {
 355                                                         if ( !hash.IsEmpty() ) {
 356                                                                 Show(_("Processing by hash: "+token+wxT("\n")));
 357                                                                 request->AddTag(CECTag(EC_TAG_PARTFILE, hash));
 358                                                         }
 359                                                 } else {
 360                                                          // Go through the dl queue and look at each filename
 361                                                         for (CECPacket::const_iterator it = reply_all->begin(); it != reply_all->end(); ++it) {
 362                                                                 const CEC_PartFile_Tag *tag = static_cast<const CEC_PartFile_Tag *>(&*it);
 363                                                                 wxString partmetname = tag->PartMetName();
 364
 365                                                                 // We check for filename, XXX.pat.met, XXX.part, XXX
 366                                                                 if( tag->FileName() == token ||
 367                                                                         partmetname == token ||
 368                                                                         partmetname.Truncate(partmetname.Len()-4) == token ||
 369                                                                         partmetname.Truncate(partmetname.Len()-5) == token) {
 370                                                                         Show(_("Processing by filename: "+token+wxT("\n")));
 371                                                                         request->AddTag(CECTag(EC_TAG_PARTFILE, tag->FileHash()));
 372                                                                 }
 373                                                         }
 374                                                 } // End of filename check else
 375                                         } // End of argument token loop
 376
 377                                 request_list.push_back(request);
 378
 379                                 delete reply_all;
 380
 381                                 } // End of dl queue processing
 382
 383                         } // end of command processing
 384                         break;
 385                 }
 386
 387                 case CMD_ID_PRIORITY_LOW:
 388                 case CMD_ID_PRIORITY_NORMAL:
 389                 case CMD_ID_PRIORITY_HIGH:
 390                 case CMD_ID_PRIORITY_AUTO:
 391                         if ( args.IsEmpty() ) {
 392                                 Show(_("This command requires an argument. Valid arguments: a file hash.\n"));
 393                                 return 0;
 394                         } else {
 395                                 CMD4Hash hash;
 396                                 if (hash.Decode(args.Trim(false).Trim(true))) {
 397                                         if (!hash.IsEmpty()) {
 398                                                 request = new CECPacket(EC_OP_PARTFILE_PRIO_SET);
 399                                                 CECTag hashtag(EC_TAG_PARTFILE, hash);
 400                                                 switch(CmdId) {
 401                                                         case CMD_ID_PRIORITY_LOW:
 402                                                                 hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, (uint8)PR_LOW));
 403                                                                 break;
 404                                                         case CMD_ID_PRIORITY_NORMAL:
 405                                                                 hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, (uint8)PR_NORMAL));
 406                                                                 break;
 407                                                         case CMD_ID_PRIORITY_HIGH:
 408                                                                 hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, (uint8)PR_HIGH));
 409                                                                 break;
 410                                                         case CMD_ID_PRIORITY_AUTO:
 411                                                                 hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, (uint8)PR_AUTO));
 412                                                                 break;
 413                                                         default: wxFAIL;
 414                                                 }
 415                                                 request->AddTag(hashtag);
 416                                                 request_list.push_back(request);
 417                                         } else {
 418                                                 Show(_("Not a valid number\n"));
 419                                                 return 0;
 420                                         }
 421                                 } else {
 422                                                 Show(_("Not a valid hash (length should be exactly 32 chars)\n"));
 423                                                 return 0;
 424                                 }
 425                         }
 426                         break;
 427
 428                 case CMD_ID_SHOW_UL:
 429                         request_list.push_back(new CECPacket(EC_OP_GET_ULOAD_QUEUE));
 430                         break;
 431
 432                 case CMD_ID_SHOW_DL:
 433                         request_list.push_back(new CECPacket(EC_OP_GET_DLOAD_QUEUE));
 434                         break;
 435
 436                 case CMD_ID_SHOW_LOG:
 437                         request_list.push_back(new CECPacket(EC_OP_GET_LOG));
 438                         break;
 439
 440                 case CMD_ID_SHOW_SERVERS:
 441                         request_list.push_back(new CECPacket(EC_OP_GET_SERVER_LIST, EC_DETAIL_CMD));
 442                         break;
 443
 444                 case CMD_ID_SHOW_SHARED:
 445                         request_list.push_back(new CECPacket(EC_OP_GET_SHARED_FILES));
 446                         break;
 447
 448                 case CMD_ID_RESET_LOG:
 449                         request_list.push_back(new CECPacket(EC_OP_RESET_LOG));
 450                         break;
 451
 452                 case CMD_ID_ADDLINK:
 453                         if (args.StartsWith(wxT("ed2k://"))) {
 454                                 //aMule doesn't like AICH links without |/| in front of h=
 455                                 if (args.Find(wxT("|h=")) > -1 && args.Find(wxT("|/|h=")) == -1) {
 456                                         args.Replace(wxT("|h="),wxT("|/|h="));
 457                                 }
 458                                 // repair links where | is replaced with %7C (Firefox)
 459                                 if (args.StartsWith(wxT("ed2k://%7C"))) {
 460                                         args.Replace(wxT("%7C"),wxT("|"));
 461                                 }
 462                         }
 463                         request = new CECPacket(EC_OP_ADD_LINK);
 464                         request->AddTag(CECTag(EC_TAG_STRING, args));
 465                         request_list.push_back(request);
 466                         break;
 467
 468                 case CMD_ID_SET_BWLIMIT_UP:
 469                         tmp_int = EC_TAG_CONN_MAX_UL - EC_TAG_CONN_MAX_DL;
 470                 case CMD_ID_SET_BWLIMIT_DOWN:
 471                         tmp_int += EC_TAG_CONN_MAX_DL;
 472                         {
 473                                 unsigned long int limit;
 474                                 if (args.ToULong(&limit)) {
 475                                         request = new CECPacket(EC_OP_SET_PREFERENCES);
 476                                         CECEmptyTag prefs(EC_TAG_PREFS_CONNECTIONS);
 477                                         prefs.AddTag(CECTag(tmp_int, (uint16)limit));
 478                                         request->AddTag(prefs);
 479                                         request_list.push_back(request);
 480                                 } else {
 481                                         return CMD_ERR_INVALID_ARG;
 482                                 }
 483                         }
 484                 case CMD_ID_GET_BWLIMITS:
 485                         request = new CECPacket(EC_OP_GET_PREFERENCES);
 486                         request->AddTag(CECTag(EC_TAG_SELECT_PREFS, (uint32)EC_PREFS_CONNECTIONS));
 487                         request_list.push_back(request);
 488                         break;
 489
 490                 case CMD_ID_STATTREE:
 491                         request = new CECPacket(EC_OP_GET_STATSTREE);
 492                         if (!args.IsEmpty()) {
 493                                 unsigned long int max_versions;
 494                                 if (args.ToULong(&max_versions)) {
 495                                         if (max_versions < 256) {
 496                                                 request->AddTag(CECTag(EC_TAG_STATTREE_CAPPING, (uint8)max_versions));
 497                                         } else {
 498                                                 delete request;
 499                                                 return CMD_ERR_INVALID_ARG;
 500                                         }
 501                                 } else {
 502                                         delete request;
 503                                         return CMD_ERR_INVALID_ARG;
 504                                 }
 505                         }
 506                         request_list.push_back(request);
 507                         break;
 508                 case CMD_ID_SEARCH_GLOBAL:
 509                         search_type = EC_SEARCH_GLOBAL;
 510                 case CMD_ID_SEARCH_LOCAL:
 511                         if (search_type != EC_SEARCH_GLOBAL){
 512                                 search_type = EC_SEARCH_LOCAL;
 513                         }
 514                 case CMD_ID_SEARCH_KAD:
 515                         if (search_type != EC_SEARCH_GLOBAL && search_type != EC_SEARCH_LOCAL){
 516                                 search_type = EC_SEARCH_KAD;
 517                         }
 518                         if (!args.IsEmpty())
 519                         {
 520                                 wxString search = args;
 521                                 wxString type;
 522                                 wxString extention;
 523                                 uint32 avail = 0;
 524                                 uint32 min_size = 0;
 525                                 uint32 max_size = 0;
 526
 527                                 request = new CECPacket(EC_OP_SEARCH_START);
 528                                 request->AddTag(CEC_Search_Tag (search, search_type, type, extention, avail, min_size, max_size));
 529                                 request_list.push_back(request);
 530                         }
 531                         break;
 532                 case CMD_ID_SEARCH:
 533                         /* TRANSLATORS:
 534                            'help search' is a command to the program, do not translate it. */
 535                         Show(_("No search type defined.\nType 'help search' to get more help.\n"));
 536                         break;
 537
 538
 539                 case CMD_ID_SEARCH_RESULTS:
 540                         request_list.push_back(new CECPacket(EC_OP_SEARCH_RESULTS, EC_DETAIL_FULL));
 541                         break;
 542
 543                 case CMD_ID_SEARCH_PROGRESS:
 544                         request_list.push_back(new CECPacket(EC_OP_SEARCH_PROGRESS));
 545                         break;
 546
 547                 case CMD_ID_DOWNLOAD:
 548                         if (!args.IsEmpty())
 549                         {
 550                                 unsigned long int id = 0;
 551                                 if (args.ToULong(&id) == true && id < m_Results_map.size()) {
 552
 553                                         SearchFile* file = m_Results_map[id];
 554                                         Show(CFormat(_("Download File: %lu %s\n")) % id % file->sFileName);
 555                                         request = new CECPacket(EC_OP_DOWNLOAD_SEARCH_RESULT);
 556                                         // get with id the hash and category=0
 557                                         uint32 category = 0;
 558                                         CECTag hashtag(EC_TAG_PARTFILE, file->nHash);
 559                                         hashtag.AddTag(CECTag(EC_TAG_PARTFILE_CAT, category));
 560                                         request->AddTag(hashtag);
 561                                         request_list.push_back(request);
 562                                 } else {
 563                                         return CMD_ERR_INVALID_ARG;
 564                                 }
 565                         }
 566                         break;
 567
 568                 default:
 569                         return CMD_ERR_PROCESS_CMD;
 570         }
 571
 572         m_last_cmd_id = CmdId;
 573
 574         if ( ! request_list.empty() ) {
 575                 std::list<CECPacket *>::iterator it = request_list.begin();
 576                 while ( it != request_list.end() ) {
 577                         CECPacket *curr = *it++;
 578                         if (curr->GetOpCode() == EC_OP_SHUTDOWN) {
 579                                 SendPacket(curr);
 580                                 delete curr;
 581                                 return CMD_ID_QUIT;
 582                         }
 583                         const CECPacket *reply = SendRecvMsg_v2(curr);
 584                         delete curr;
 585                         if ( reply ) {
 586                                 Process_Answer_v2(reply);
 587                                 delete reply;
 588                         }
 589                 }
 590                 request_list.resize(0);
 591         }
 592
 593         return CMD_OK;
 594 }
 595
 596  /*
 597  * Method to show the results in the console
 598  */
 599 void CamulecmdApp::ShowResults(CResultMap results_map)
 600 {
 601         unsigned int name_max = 80;
 602         unsigned int mb_max = 5;
 603         unsigned int nr_max = 5;
 604         unsigned long int id = 0;
 605         wxString output, name, sources, mb , kb;
 606
 607         printf("Nr.    Filename:                                                                        Size(MB):  Sources: \n");
 608         printf("-----------------------------------------------------------------------------------------------------------\n");
 609
 610         for( std::map<unsigned long int,SearchFile*>::iterator iter = results_map.begin(); iter != results_map.end(); ++iter ) {
 611                 id = (*iter).first;
 612                 SearchFile* file = (*iter).second;
 613
 614                 output.Printf(wxT("%i.      "), id);
 615                 output = output.SubString(0, nr_max).Append(file->sFileName).Append(' ', name_max);
 616                 mb.Printf(wxT("     %d"), file->lFileSize/1024/1024);
 617                 kb.Printf(wxT(".%d"), file->lFileSize/1024%1024);
 618                 output = output.SubString(0, nr_max + name_max + mb_max - mb.Length() ).Append(mb).Append(kb);
 619                 printf("%s     %ld\n",(const char*)unicode2char(output), file->lSourceCount );
 620         }
 621 }
 622
 623
 624 // Formats a statistics (sub)tree to text
 625 wxString StatTree2Text(const CEC_StatTree_Node_Tag *tree, int depth)
 626 {
 627         if (!tree) {
 628                 return wxEmptyString;
 629         }
 630         wxString result = wxString(wxChar(' '), depth) + tree->GetDisplayString() + wxT("\n");
 631         for (CECTag::const_iterator it = tree->begin(); it != tree->end(); ++it) {
 632                 const CEC_StatTree_Node_Tag *tmp = static_cast<const CEC_StatTree_Node_Tag*>(&*it);
 633                 if (tmp->GetTagName() == EC_TAG_STATTREE_NODE) {
 634                         result += StatTree2Text(tmp, depth + 1);
 635                 }
 636         }
 637         return result;
 638 }
 639
 640 /*
 641  * Format EC packet into text form for output to console
 642  */
 643 void CamulecmdApp::Process_Answer_v2(const CECPacket *response)
 644 {
 645         wxString s;
 646         wxString msgFailedUnknown(_("Request failed with an unknown error."));
 647         wxASSERT(response);
 648         switch (response->GetOpCode()) {
 649                 case EC_OP_NOOP:
 650                         s << _("Operation was successful.");
 651                         break;
 652                 case EC_OP_FAILED:
 653                         {
 654                                 const CECTag *tag = response->GetFirstTagSafe();
 655                                 if (tag->IsString()) {
 656                                         s <<    CFormat(_("Request failed with the following error: %s")) % wxGetTranslation(tag->GetStringData());
 657                                 } else {
 658                                         s << msgFailedUnknown;
 659                                 }
 660                         }
 661                         break;
 662                 case EC_OP_SET_PREFERENCES:
 663                         {
 664                                 const CECTag *tab = response->GetTagByNameSafe(EC_TAG_PREFS_SECURITY);
 665                                 const CECTag *ipfilterLevel = tab->GetTagByName(EC_TAG_IPFILTER_LEVEL);
 666                                 if (ipfilterLevel) {
 667                                         if (m_last_cmd_id == CMD_ID_GET_IPFILTER ||
 668                                             m_last_cmd_id == CMD_ID_GET_IPFILTER_STATE ||
 669                                             m_last_cmd_id == CMD_ID_GET_IPFILTER_STATE_CLIENTS) {
 670                                                 s += CFormat(_("IP filtering for clients is %s.\n"))
 671                                                                 % ((tab->GetTagByName(EC_TAG_IPFILTER_CLIENTS) == NULL) ? _("OFF") : _("ON"));
 672                                         }
 673                                         if (m_last_cmd_id == CMD_ID_GET_IPFILTER ||
 674                                             m_last_cmd_id == CMD_ID_GET_IPFILTER_STATE ||
 675                                             m_last_cmd_id == CMD_ID_GET_IPFILTER_STATE_SERVERS) {
 676                                                 s += CFormat(_("IP filtering for servers is %s.\n"))
 677                                                                 % ((tab->GetTagByName(EC_TAG_IPFILTER_SERVERS) == NULL) ? _("OFF") : _("ON"));
 678                                         }
 679                                         if (m_last_cmd_id == CMD_ID_GET_IPFILTER ||
 680                                             m_last_cmd_id == CMD_ID_GET_IPFILTER_LEVEL) {
 681                                                 s << CFormat(_("Current IPFilter Level is %d.\n")) % ipfilterLevel->GetInt();
 682                                         }
 683                                 }
 684                                 tab = response->GetTagByNameSafe(EC_TAG_PREFS_CONNECTIONS);
 685                                 const CECTag *connMaxUL = tab->GetTagByName(EC_TAG_CONN_MAX_UL);
 686                                 const CECTag *connMaxDL = tab->GetTagByName(EC_TAG_CONN_MAX_DL);
 687                                 if (connMaxUL && connMaxDL) {
 688                                         s << CFormat(_("Bandwidth limits: Up: %u kB/s, Down: %u kB/s.\n"))
 689                                                 % connMaxUL->GetInt() % connMaxDL->GetInt();
 690                                 }
 691                         }
 692                         break;
 693                 case EC_OP_STRINGS:
 694                         for (CECPacket::const_iterator it = response->begin(); it != response->end(); ++it) {
 695                                 const CECTag &tag = *it;
 696                                 s << tag.GetStringData() << wxT("\n");
 697                         }
 698                         break;
 699                 case EC_OP_STATS: {
 700                         const CEC_ConnState_Tag *connState = static_cast<const CEC_ConnState_Tag*>(response->GetTagByName(EC_TAG_CONNSTATE));
 701                         if (connState) {
 702                                 s << _("eD2k") << wxT(": ");
 703                                 if (connState->IsConnectedED2K()) {
 704                                         const CECTag *server = connState->GetTagByName(EC_TAG_SERVER);
 705                                         const CECTag *serverName = server ? server->GetTagByName(EC_TAG_SERVER_NAME) : NULL;
 706                                         if (server && serverName) {
 707                                                 s << CFormat(_("Connected to %s %s %s")) %
 708                                                  serverName->GetStringData() %
 709                                                  server->GetIPv4Data().StringIP() %
 710                                                  (connState->HasLowID() ? _("with LowID") : _("with HighID"));
 711                                         }
 712                                 } else if (connState->IsConnectingED2K()) {
 713                                         s << _("Now connecting");
 714                                 } else {
 715                                         s << _("Not connected");
 716                                 }
 717                                 s << wxT('\n') << _("Kad") << wxT(": ");
 718                                 if (connState->IsKadRunning()) {
 719                                         if (connState->IsConnectedKademlia()) {
 720                                                 s << _("Connected") << wxT(" (");
 721                                                 if (connState->IsKadFirewalled()) {
 722                                                         s << _("firewalled");
 723                                                 } else {
 724                                                         s << _("ok");
 725                                                 }
 726                                                 s << wxT(')');
 727                                         } else {
 728                                                 s << _("Not connected");
 729                                         }
 730                                 } else {
 731                                         s << _("Not running");
 732                                 }
 733                                 s << wxT('\n');
 734                         }
 735                         const CECTag *tmpTag;
 736                         if ((tmpTag = response->GetTagByName(EC_TAG_STATS_DL_SPEED)) != 0) {
 737                                 s <<    CFormat(_("\nDownload:\t%s")) % CastItoSpeed(tmpTag->GetInt());
 738                         }
 739                         if ((tmpTag = response->GetTagByName(EC_TAG_STATS_UL_SPEED)) != 0) {
 740                                 s <<    CFormat(_("\nUpload:\t%s")) % CastItoSpeed(tmpTag->GetInt());
 741                         }
 742                         if ((tmpTag = response->GetTagByName(EC_TAG_STATS_UL_QUEUE_LEN)) != 0) {
 743                                 s <<    CFormat(_("\nClients in queue:\t%d\n")) % tmpTag->GetInt();
 744                         }
 745                         if ((tmpTag = response->GetTagByName(EC_TAG_STATS_TOTAL_SRC_COUNT)) != 0) {
 746                                 s <<    CFormat(_("\nTotal sources:\t%d\n")) % tmpTag->GetInt();
 747                         }
 748                         break;
 749                 }
 750                 case EC_OP_DLOAD_QUEUE:
 751                         for (CECPacket::const_iterator it = response->begin(); it != response->end(); ++it) {
 752                                 const CEC_PartFile_Tag *tag = static_cast<const CEC_PartFile_Tag *>(&*it);
 753                                 uint64 filesize, donesize;
 754                                 filesize = tag->SizeFull();
 755                                 donesize = tag->SizeDone();
 756                                 s <<    tag->FileHashString() << wxT(" ") <<
 757                                         tag->FileName() <<
 758                                         (CFormat(wxT("\n\t [%.1f%%] %4i/%4i "))
 759                                                 % ((float)donesize / ((float)filesize)*100.0)
 760                                                 % ((int)tag->SourceCount() - (int)tag->SourceNotCurrCount())
 761                                                 % (int)tag->SourceCount()) <<
 762                                         ((int)tag->SourceCountA4AF() ? wxString(CFormat(wxT("+%2.2i ")) % (int)tag->SourceCountA4AF()) : wxString(wxT("    "))) <<
 763                                         ((int)tag->SourceXferCount() ? wxString(CFormat(wxT("(%2.2i) - ")) % (int)tag->SourceXferCount()) : wxString(wxT("     - "))) <<
 764                                         tag->GetFileStatusString();
 765                                 s << wxT(" - ") << tag->PartMetName();
 766                                 if (tag->DownPrio() < 10) {
 767                                         s << wxT(" - ") << PriorityToStr((int)tag->DownPrio(), 0);
 768                                 } else {
 769                                         s << wxT(" - ") << PriorityToStr((tag->DownPrio() - 10), 1);
 770                                 }
 771                                 if ( tag->SourceXferCount() > 0) {
 772                                         s << wxT(" - ") + CastItoSpeed(tag->Speed());
 773                                 }
 774                                 s << wxT("\n");
 775                         }
 776                         break;
 777                 case EC_OP_ULOAD_QUEUE:
 778                         for (CECPacket::const_iterator it = response->begin(); it != response->end(); ++it) {
 779                                 const CECTag *tag = & *it;
 780                                 const CECTag *clientName = tag->GetTagByName(EC_TAG_CLIENT_NAME);
 781                                 const CECTag *partfileName = tag->GetTagByName(EC_TAG_PARTFILE_NAME);
 782                                 const CECTag *partfileSizeXfer = tag->GetTagByName(EC_TAG_PARTFILE_SIZE_XFER);
 783                                 const CECTag *partfileSpeed = tag->GetTagByName(EC_TAG_CLIENT_UP_SPEED);
 784                                 if (clientName && partfileName && partfileSizeXfer && partfileSpeed) {
 785                                         s <<    wxT("\n") <<
 786                                                 CFormat(wxT("%10u ")) % tag->GetInt() <<
 787                                                 clientName->GetStringData() << wxT(" ") <<
 788                                                 partfileName->GetStringData() << wxT(" ") <<
 789                                                 CastItoXBytes(partfileSizeXfer->GetInt()) << wxT(" ") <<
 790                                                 CastItoSpeed(partfileSpeed->GetInt());
 791                                 }
 792                         }
 793                         break;
 794                 case EC_OP_LOG:
 795                         for (CECPacket::const_iterator it = response->begin(); it != response->end(); ++it) {
 796                                 const CECTag &tag = *it;
 797                                 s << tag.GetStringData() << wxT("\n");
 798                         }
 799                         break;
 800                 case EC_OP_SERVER_LIST:
 801                         for (CECPacket::const_iterator it = response->begin(); it != response->end(); ++it) {
 802                                 const CECTag &tag = *it;
 803                                 const CECTag *serverName = tag.GetTagByName(EC_TAG_SERVER_NAME);
 804                                 if (serverName) {
 805                                         wxString ip = tag.GetIPv4Data().StringIP();
 806                                         ip.Append(' ', 24 - ip.Length());
 807                                         s << ip << serverName->GetStringData() << wxT("\n");
 808                                 }
 809                         }
 810                         break;
 811
 812                 case EC_OP_SHARED_FILES:
 813                         for (CECPacket::const_iterator it = response->begin(); it != response->end(); ++it) {
 814                                 const CEC_SharedFile_Tag *tag = static_cast<const CEC_SharedFile_Tag *>(&*it);
 815                                 s << tag->FileHashString() << wxT(" ");
 816                                 wxString filePath = tag->FilePath();
 817                                 bool ispartfile = true;
 818                                 if (filePath.EndsWith(wxT(".part"))) {
 819                                         for (unsigned i = 0; i < filePath.Length() - 5; i++) {
 820                                                 if (filePath[i] < wxT('0') || filePath[i] > wxT('9')) {
 821                                                         ispartfile = false;
 822                                                         break;
 823                                                 }
 824                                         }
 825                                 } else {
 826                                         ispartfile = false;
 827                                 }
 828                                 if (ispartfile) {
 829                                         s << _("[PartFile]") << wxT(" ");
 830                                 } else {
 831                                         s << filePath
 832 #ifdef __WINDOWS__
 833                                           << wxT('\\');
 834 #else
 835                                           << wxT('/');
 836 #endif
 837                                 }
 838                                 s << tag->FileName()
 839                                   << wxT("\n\t") << PriorityToStr(tag->UpPrio() % 10, tag->UpPrio() >= 10) << wxT(" - ") << CFormat(wxT("%i(%i) / %i(%i) - %s (%s) - %.2f\n"))
 840                                         % tag->GetRequests() % tag->GetAllRequests()
 841                                         % tag->GetAccepts() % tag->GetAllAccepts()
 842                                         % CastItoXBytes(tag->GetXferred()) % CastItoXBytes(tag->GetAllXferred())
 843                                         % (static_cast<float>(tag->GetAllXferred()) / static_cast<float>(tag->SizeFull()));
 844                         }
 845                         break;
 846
 847                 case EC_OP_STATSTREE:
 848                         s << StatTree2Text(static_cast<const CEC_StatTree_Node_Tag*>(response->GetTagByName(EC_TAG_STATTREE_NODE)), 0);
 849                         break;
 850
 851                 case EC_OP_SEARCH_RESULTS:
 852                 {
 853                         int i = 0;
 854                         m_Results_map.clear();
 855                         s += CFormat(_("Number of search results: %i\n")) % response->GetTagCount();
 856                         for (CECPacket::const_iterator it = response->begin(); it != response->end(); ++it) {
 857                                 const CEC_SearchFile_Tag *tag = static_cast<const CEC_SearchFile_Tag *>(&*it);
 858                                 //printf("Tag FileName: %s \n",(const char*)unicode2char(tag->FileName()));
 859                                 m_Results_map[i++] = new SearchFile(tag);
 860                         }
 861                         ShowResults(m_Results_map);
 862                         break;
 863                 }
 864                 case EC_OP_SEARCH_PROGRESS:
 865                 {
 866                         const CECTag *tab = response->GetTagByNameSafe(EC_TAG_SEARCH_STATUS);
 867                         uint32 progress = tab->GetInt();
 868                         if (progress <= 100) {
 869                                 s += CFormat(_("Search progress: %u %% \n")) % progress;
 870                         } else {
 871                                 s += _("Search progress not available");
 872                         }
 873                         break;
 874                 }
 875                 default:
 876                         s += CFormat(_("Received an unknown reply from the server, OpCode = %#x.")) % response->GetOpCode();
 877         }
 878         Process_Answer(s);
 879 }
 880
 881 void CamulecmdApp::OnInitCommandSet()
 882 {
 883         CCommandTree *tmp;
 884         CCommandTree *tmp2;
 885         CCommandTree *tmp3;
 886
 887         CaMuleExternalConnector::OnInitCommandSet();
 888
 889         m_commands.AddCommand(wxT("Status"), CMD_ID_STATUS, wxTRANSLATE("Show short status information."),
 890                               wxTRANSLATE("Show connection status, current up/download speeds, etc.\n"), CMD_PARAM_NEVER);
 891
 892         m_commands.AddCommand(wxT("Statistics"), CMD_ID_STATTREE, wxTRANSLATE("Show full statistics tree."),
 893                               wxTRANSLATE("Optionally, a number in the range 0-255 can be passed as an argument to this\ncommand, which tells how many entries of the client version subtrees should be\nshown. Passing 0 or omitting it means 'unlimited'.\n\nExample: 'statistics 5' will show only the top 5 versions for each client type.\n"));
 894
 895         m_commands.AddCommand(wxT("Shutdown"), CMD_ID_SHUTDOWN, wxTRANSLATE("Shut down aMule."),
 896                               wxTRANSLATE("Shut down the remote running core (amule/amuled).\nThis will also shut down the text client, since it is unusable without a\nrunning core.\n"), CMD_PARAM_NEVER);
 897
 898         tmp = m_commands.AddCommand(wxT("Reload"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Reload the given object."), wxEmptyString, CMD_PARAM_NEVER);
 899         tmp->AddCommand(wxT("Shared"), CMD_ID_RELOAD_SHARED, wxTRANSLATE("Reload shared files list."), wxEmptyString, CMD_PARAM_NEVER);
 900
 901         tmp2 = tmp->AddCommand(wxT("IPFilter"), CMD_ID_RELOAD_IPFILTER_LOCAL, wxTRANSLATE("Reload IP filtering table."), wxEmptyString, CMD_PARAM_OPTIONAL);
 902         tmp2->AddCommand(wxT("File"), CMD_ID_RELOAD_IPFILTER_LOCAL, wxTRANSLATE("Reload current IP filtering table."), wxEmptyString, CMD_PARAM_NEVER);
 903         tmp2->AddCommand(wxT("Net"), CMD_ID_RELOAD_IPFILTER_NET, wxTRANSLATE("Update IP filtering table from URL."),
 904                                         wxTRANSLATE("If URL is omitted the URL from the preferences is used."), CMD_PARAM_OPTIONAL);
 905
 906         tmp = m_commands.AddCommand(wxT("Connect"), CMD_ID_CONNECT, wxTRANSLATE("Connect to the network."),
 907                                     wxTRANSLATE("This will connect to all networks that are enabled in Preferences.\nYou may also optionally specify a server address in IP:Port form, to connect to\nthat server only. The IP must be a dotted decimal IPv4 address,\nor a resolvable DNS name."), CMD_PARAM_OPTIONAL);
 908         tmp->AddCommand(wxT("ED2K"), CMD_ID_CONNECT_ED2K, wxTRANSLATE("Connect to eD2k only."), wxEmptyString, CMD_PARAM_NEVER);
 909         tmp->AddCommand(wxT("Kad"), CMD_ID_CONNECT_KAD, wxTRANSLATE("Connect to Kad only."), wxEmptyString, CMD_PARAM_NEVER);
 910
 911         tmp = m_commands.AddCommand(wxT("Disconnect"), CMD_ID_DISCONNECT, wxTRANSLATE("Disconnect from the network."),
 912                                     wxTRANSLATE("This will disconnect from all networks that are currently connected.\n"), CMD_PARAM_NEVER);
 913         tmp->AddCommand(wxT("ED2K"), CMD_ID_DISCONNECT_ED2K, wxTRANSLATE("Disconnect from eD2k only."), wxEmptyString, CMD_PARAM_NEVER);
 914         tmp->AddCommand(wxT("Kad"), CMD_ID_DISCONNECT_KAD, wxTRANSLATE("Disconnect from Kad only."), wxEmptyString, CMD_PARAM_NEVER);
 915
 916         m_commands.AddCommand(wxT("Add"), CMD_ID_ADDLINK, wxTRANSLATE("Add an eD2k or magnet link to core."),
 917                               wxTRANSLATE("The eD2k link to be added can be:\n*) a file link (ed2k://|file|...), it will be added to the download queue,\n*) a server link (ed2k://|server|...), it will be added to the server list,\n*) or a serverlist link, in which case all servers in the list will be added to the\n   server list.\n\nThe magnet link must contain the eD2k hash and file length.\n"), CMD_PARAM_ALWAYS);
 918
 919         tmp = m_commands.AddCommand(wxT("Set"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Set a preference value."),
 920                                     wxEmptyString, CMD_PARAM_NEVER);
 921
 922         tmp2 = tmp->AddCommand(wxT("IPFilter"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Set IP filtering preferences."), wxEmptyString, CMD_PARAM_NEVER);
 923         tmp2->AddCommand(wxT("On"), CMD_ID_SET_IPFILTER_ON, wxTRANSLATE("Turn IP filtering on for both clients and servers."), wxEmptyString, CMD_PARAM_NEVER);
 924         tmp2->AddCommand(wxT("Off"), CMD_ID_SET_IPFILTER_OFF, wxTRANSLATE("Turn IP filtering off for both clients and servers."), wxEmptyString, CMD_PARAM_NEVER);
 925         tmp3 = tmp2->AddCommand(wxT("Clients"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Enable/Disable IP filtering for clients."), wxEmptyString, CMD_PARAM_NEVER);
 926         tmp3->AddCommand(wxT("On"), CMD_ID_SET_IPFILTER_CLIENTS_ON, wxTRANSLATE("Turn IP filtering on for clients."), wxEmptyString, CMD_PARAM_NEVER);
 927         tmp3->AddCommand(wxT("Off"), CMD_ID_SET_IPFILTER_CLIENTS_OFF, wxTRANSLATE("Turn IP filtering off for clients."), wxEmptyString, CMD_PARAM_NEVER);
 928         tmp3 = tmp2->AddCommand(wxT("Servers"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Enable/Disable IP filtering for servers."), wxEmptyString, CMD_PARAM_NEVER);
 929         tmp3->AddCommand(wxT("On"), CMD_ID_SET_IPFILTER_SERVERS_ON, wxTRANSLATE("Turn IP filtering on for servers."), wxEmptyString, CMD_PARAM_NEVER);
 930         tmp3->AddCommand(wxT("Off"), CMD_ID_SET_IPFILTER_SERVERS_OFF, wxTRANSLATE("Turn IP filtering off for servers."), wxEmptyString, CMD_PARAM_NEVER);
 931         tmp2->AddCommand(wxT("Level"), CMD_ID_SET_IPFILTER_LEVEL, wxTRANSLATE("Select IP filtering level."),
 932                          wxTRANSLATE("Valid filtering levels are in the range 0-255, and it's default (initial)\nvalue is 127.\n"), CMD_PARAM_ALWAYS);
 933
 934         tmp2 = tmp->AddCommand(wxT("BwLimit"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Set bandwidth limits."),
 935                                wxTRANSLATE("The value given to these commands has to be in kilobytes/sec.\n"), CMD_PARAM_NEVER);
 936         tmp2->AddCommand(wxT("Up"), CMD_ID_SET_BWLIMIT_UP, wxTRANSLATE("Set upload bandwidth limit."),
 937                          wxTRANSLATE("The given value must be in kilobytes/sec.\n"), CMD_PARAM_ALWAYS);
 938         tmp2->AddCommand(wxT("Down"), CMD_ID_SET_BWLIMIT_DOWN, wxTRANSLATE("Set download bandwidth limit."),
 939                          wxTRANSLATE("The given value must be in kilobytes/sec.\n"), CMD_PARAM_ALWAYS);
 940
 941         tmp = m_commands.AddCommand(wxT("Get"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Get and display a preference value."),
 942                                     wxEmptyString, CMD_PARAM_NEVER);
 943
 944         tmp2 = tmp->AddCommand(wxT("IPFilter"), CMD_ID_GET_IPFILTER, wxTRANSLATE("Get IP filtering preferences."), wxEmptyString, CMD_PARAM_NEVER);
 945         tmp3 = tmp2->AddCommand(wxT("State"), CMD_ID_GET_IPFILTER_STATE, wxTRANSLATE("Get IP filtering state for both clients and servers."), wxEmptyString, CMD_PARAM_NEVER);
 946         tmp3->AddCommand(wxT("Clients"), CMD_ID_GET_IPFILTER_STATE_CLIENTS, wxTRANSLATE("Get IP filtering state for clients only."), wxEmptyString, CMD_PARAM_NEVER);
 947         tmp3->AddCommand(wxT("Servers"), CMD_ID_GET_IPFILTER_STATE_SERVERS, wxTRANSLATE("Get IP filtering state for servers only."), wxEmptyString, CMD_PARAM_NEVER);
 948         tmp2->AddCommand(wxT("Level"), CMD_ID_GET_IPFILTER_LEVEL, wxTRANSLATE("Get IP filtering level."), wxEmptyString, CMD_PARAM_NEVER);
 949
 950         tmp->AddCommand(wxT("BwLimits"), CMD_ID_GET_BWLIMITS, wxTRANSLATE("Get bandwidth limits."), wxEmptyString, CMD_PARAM_NEVER);
 951
 952         tmp = m_commands.AddCommand(wxT("Search"), CMD_ID_SEARCH, wxTRANSLATE("Execute a search."),
 953                               wxTRANSLATE("A search type has to be specified by giving the type:\n    GLOBAL\n    LOCAL\n    KAD\nExample: 'search kad file' will execute a kad search for \"file\".\n"), CMD_PARAM_ALWAYS);
 954         tmp->AddCommand(wxT("global"), CMD_ID_SEARCH_GLOBAL, wxTRANSLATE("Execute a global search."), wxEmptyString, CMD_PARAM_ALWAYS);
 955         tmp->AddCommand(wxT("local"), CMD_ID_SEARCH_LOCAL, wxTRANSLATE("Execute a local search"), wxEmptyString, CMD_PARAM_ALWAYS);
 956         tmp->AddCommand(wxT("kad"), CMD_ID_SEARCH_KAD, wxTRANSLATE("Execute a kad search"), wxEmptyString, CMD_PARAM_ALWAYS);
 957
 958         m_commands.AddCommand(wxT("Results"), CMD_ID_SEARCH_RESULTS, wxTRANSLATE("Show the results of the last search."),
 959                               wxTRANSLATE("Return the results of the previous search.\n"), CMD_PARAM_NEVER);
 960
 961         m_commands.AddCommand(wxT("Progress"), CMD_ID_SEARCH_PROGRESS, wxTRANSLATE("Show the progress of a search."),
 962                               wxTRANSLATE("Show the progress of a search.\n"), CMD_PARAM_NEVER);
 963
 964         m_commands.AddCommand(wxT("Download"), CMD_ID_DOWNLOAD, wxTRANSLATE("Start downloading a file"),
 965                               wxTRANSLATE("The number of a file from the last search has to be given.\nExample: 'download 12' will start to download the file with the number 12 of the previous search.\n"), CMD_PARAM_ALWAYS);
 966
 967
 968         //
 969         // TODO: These commands below need implementation and/or rewrite!
 970         //
 971
 972         m_commands.AddCommand(wxT("Pause"), CMD_ID_PAUSE, wxTRANSLATE("Pause download."),
 973                               wxEmptyString, CMD_PARAM_ALWAYS);
 974
 975         m_commands.AddCommand(wxT("Resume"), CMD_ID_RESUME, wxTRANSLATE("Resume download."),
 976                               wxEmptyString, CMD_PARAM_ALWAYS);
 977
 978         m_commands.AddCommand(wxT("Cancel"), CMD_ID_CANCEL, wxTRANSLATE("Cancel download."),
 979                               wxEmptyString, CMD_PARAM_ALWAYS);
 980
 981         tmp = m_commands.AddCommand(wxT("Priority"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Set download priority."),
 982                                     wxTRANSLATE("Set priority of a download to Low, Normal, High or Auto.\n"), CMD_PARAM_ALWAYS);
 983         tmp->AddCommand(wxT("Low"), CMD_ID_PRIORITY_LOW, wxTRANSLATE("Set priority to low."), wxEmptyString, CMD_PARAM_ALWAYS);
 984         tmp->AddCommand(wxT("Normal"), CMD_ID_PRIORITY_NORMAL, wxTRANSLATE("Set priority to normal."), wxEmptyString, CMD_PARAM_ALWAYS);
 985         tmp->AddCommand(wxT("High"), CMD_ID_PRIORITY_HIGH, wxTRANSLATE("Set priority to high."), wxEmptyString, CMD_PARAM_ALWAYS);
 986         tmp->AddCommand(wxT("Auto"), CMD_ID_PRIORITY_AUTO, wxTRANSLATE("Set priority to auto."), wxEmptyString, CMD_PARAM_ALWAYS);
 987
 988         tmp = m_commands.AddCommand(wxT("Show"), CMD_ERR_INCOMPLETE, wxTRANSLATE("Show queues/lists."),
 989                                     wxTRANSLATE("Show upload/download queue, server list or shared files list.\n"), CMD_PARAM_ALWAYS);
 990         tmp->AddCommand(wxT("UL"), CMD_ID_SHOW_UL, wxTRANSLATE("Show upload queue."), wxEmptyString, CMD_PARAM_NEVER);
 991         tmp->AddCommand(wxT("DL"), CMD_ID_SHOW_DL, wxTRANSLATE("Show download queue."), wxEmptyString, CMD_PARAM_NEVER);
 992         tmp->AddCommand(wxT("Log"), CMD_ID_SHOW_LOG, wxTRANSLATE("Show log."), wxEmptyString, CMD_PARAM_NEVER);
 993         tmp->AddCommand(wxT("Servers"), CMD_ID_SHOW_SERVERS, wxTRANSLATE("Show servers list."), wxEmptyString, CMD_PARAM_NEVER);
 994         tmp->AddCommand(wxT("Shared"), CMD_ID_SHOW_SHARED, wxTRANSLATE("Show shared files list."), wxEmptyString, CMD_PARAM_NEVER);
 995
 996         m_commands.AddCommand(wxT("Reset"), CMD_ID_RESET_LOG, wxTRANSLATE("Reset log."), wxEmptyString, CMD_PARAM_NEVER);
 997
 998         //
 999         // Deprecated commands, kept for backwards compatibility only.
1000         //
1001
1002 #define DEPRECATED(OLDCMD, ID, NEWCMD, PARAM) \
1003         m_commands.AddCommand(wxT(OLDCMD), CMD_ID_##ID | CMD_DEPRECATED, CFormat(wxTRANSLATE("Deprecated command, use '%s' instead.")) % wxT(NEWCMD), \
1004                               CFormat(wxTRANSLATE("This is a deprecated command, and may be removed in the future.\nUse '%s' instead.\n")) % wxT(NEWCMD), CMD_PARAM_##PARAM)
1005
1006         DEPRECATED("Stats", STATUS, "Status", NEVER);
1007         DEPRECATED("SetIPFilter", SET_IPFILTER, "Set IPFilter", OPTIONAL);
1008         DEPRECATED("GetIPLevel", GET_IPFILTER_LEVEL, "Get IPFilter Level", NEVER);
1009         DEPRECATED("SetIPLevel", SET_IPFILTER_LEVEL, "Set IPFilter Level", ALWAYS);
1010         DEPRECATED("IPLevel", SET_IPFILTER_LEVEL, "Get/Set IPFilter Level", OPTIONAL);
1011         DEPRECATED("Servers", SHOW_SERVERS, "Show Servers", NEVER);
1012         DEPRECATED("GetBWLimits", GET_BWLIMITS, "Get BwLimits", NEVER);
1013         DEPRECATED("SetUpBWLimit", SET_BWLIMIT_UP, "Set BwLimit Up", ALWAYS);
1014         DEPRECATED("SetDownBWLimit", SET_BWLIMIT_DOWN, "Set BwLimit Down", ALWAYS);
1015 }
1016
1017 int CamulecmdApp::OnRun()
1018 {
1019         ConnectAndRun(wxT("aMulecmd"), wxT(VERSION));
1020         return 0;
1021 }
1022
1023 // Dummy functions for EC logging
1024 bool ECLogIsEnabled()
1025 {
1026         return false;
1027 }
1028
1029 void DoECLogLine(const wxString &)
1030 {
1031 }
1032
1033
1034 namespace MuleNotify
1035 {
1036         void HandleNotification(const class CMuleNotiferBase&) {}
1037         void HandleNotificationAlways(const class CMuleNotiferBase&) {}
1038 }
1039
1040 // File_checked_for_headers