src/OtherFunctions.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   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 // The backtrace functions contain modified code from libYaMa, (c) Venkatesha Murthy G.
  27 // You can check libYaMa at http://personal.pavanashree.org/libyama/
  28
  29 #include <tags/FileTags.h>
  30
  31 #include <wx/filename.h>        // Needed for wxFileName
  32 #include <wx/log.h>             // Needed for wxLogNull
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"             // Needed for a number of defines
  36 #endif
  37
  38 #include <wx/stdpaths.h> // Do_not_auto_remove
  39 #include <common/StringFunctions.h>
  40 #include <common/ClientVersion.h>
  41 #include <common/MD5Sum.h>
  42 #include <common/Path.h>
  43 #include "MD4Hash.h"
  44 #include "Logger.h"
  45
  46 #include "OtherFunctions.h"     // Interface declarations
  47
  48 #include <map>
  49
  50 #ifdef __WXBASE__
  51         #include <cerrno>
  52 #else
  53         #include <wx/utils.h>
  54 #endif
  55
  56
  57 wxString GetMuleVersion()
  58 {
  59         wxString ver(wxT(VERSION));
  60
  61         ver += wxT(" using ");
  62
  63
  64         // Figure out the wx build-type
  65         #ifdef __WXGTK__
  66                 #ifdef __WXGTK20__
  67                         ver += wxT("wxGTK2");
  68                 #else
  69                         ver += wxT("wxGTK1");
  70                 #endif
  71         #elif defined(__WXMAC__)
  72                 ver += wxT("wxMac");
  73         #elif defined(__WXMSW__)
  74                 ver += wxT("wxMSW");
  75         #elif defined(__WXCOCOA__)
  76                 ver += wxT("wxCocoa");
  77         #endif
  78
  79         ver += wxString::Format(wxT(" v%d.%d.%d"), wxMAJOR_VERSION, wxMINOR_VERSION, wxRELEASE_NUMBER );
  80
  81 #if defined(__WXDEBUG__)
  82         ver += wxT(" (Debugging)");
  83 #endif
  84
  85 #ifdef SVNDATE
  86         ver += wxString::Format( wxT(" (Snapshot: %s)"), wxT(SVNDATE));
  87 #endif
  88
  89         return ver;
  90 }
  91
  92
  93 wxString GetFullMuleVersion()
  94 {
  95 #ifdef AMULE_DAEMON
  96         wxString app = wxT("aMuled");
  97 #elif defined(CLIENT_GUI)
  98         wxString app = wxT("Remote aMule-GUI");
  99 #else
 100         wxString app = wxT("aMule");
 101 #endif
 102
 103         return app + wxT(" ") + GetMuleVersion();
 104 }
 105
 106
 107 // Formats a filesize in bytes to make it suitable for displaying
 108 wxString CastItoXBytes( uint64 count )
 109 {
 110
 111         if (count < 1024)
 112                 return wxString::Format( wxT("%.0f "), (float)(uint32)count) + wxPLURAL("byte", "bytes", count) ;
 113         else if (count < 1048576)
 114                 return wxString::Format( wxT("%.0f "), (float)(uint32)count/1024) + _("kB") ;
 115         else if (count < 1073741824)
 116                 return wxString::Format( wxT("%.2f "), (float)(uint32)count/1048576) + _("MB") ;
 117         else if (count < 1099511627776LL)
 118                 return wxString::Format( wxT("%.2f "), (float)((uint32)(count/1024))/1048576) + _("GB") ;
 119         else
 120                 return wxString::Format( wxT("%.3f "), (float)count/1099511627776LL) + _("TB") ;
 121
 122         return _("ERROR");
 123 }
 124
 125
 126 wxString CastItoIShort(uint64 count)
 127 {
 128
 129         if (count < 1000)
 130                 return wxString::Format(wxT("%u"), (uint32)count);
 131         else if (count < 1000000)
 132                 return wxString::Format(wxT("%.0f"),(float)(uint32)count/1000) + _("k") ;
 133         else if (count < 1000000000)
 134                 return wxString::Format(wxT("%.2f"),(float)(uint32)count/1000000) + _("M") ;
 135         else if (count < 1000000000000LL)
 136                 return wxString::Format(wxT("%.2f"),(float)((uint32)(count/1000))/1000000) + _("G") ;
 137         else if (count < 1000000000000000LL)
 138                 return wxString::Format(wxT("%.2f"),(float)count/1000000000000LL) + _("T");
 139
 140         return _("ERROR");
 141 }
 142
 143
 144 wxString CastItoSpeed(uint32 bytes)
 145 {
 146         if (bytes < 1024)
 147                 return wxString::Format(wxT("%u "), bytes) + wxPLURAL("byte/sec", "bytes/sec", bytes);
 148         else if (bytes < 1048576)
 149                 return wxString::Format(wxT("%.2f "), bytes / 1024.0) + _("kB/s");
 150         else
 151                 return wxString::Format(wxT("%.2f "), bytes / 1048576.0) + _("MB/s");
 152 }
 153
 154
 155 // Make a time value in seconds suitable for displaying
 156 wxString CastSecondsToHM(uint64 count, uint16 msecs)
 157 {
 158         if (count < 60) {
 159                 if (!msecs) {
 160                         return wxString::Format(
 161                                 wxT("%02") wxLongLongFmtSpec wxT("u "),
 162                                 count) + _("secs");
 163                 } else {
 164                         return wxString::Format(
 165                                 wxT("%.3f"),
 166                                 (count + ((float)msecs/1000))) + _("secs");
 167                 }
 168         } else if (count < 3600) {
 169                 return wxString::Format(
 170                         wxT("%")
 171                         wxLongLongFmtSpec wxT("u:%02")
 172                         wxLongLongFmtSpec wxT("u "),
 173                         count/60,
 174                         (count % 60)) + _("mins");
 175         } else if (count < 86400) {
 176                 return wxString::Format(
 177                         wxT("%")
 178                         wxLongLongFmtSpec wxT("u:%02")
 179                         wxLongLongFmtSpec wxT("u "),
 180                         count/3600,
 181                         (count % 3600)/60) + _("hours");
 182         } else {
 183                 return wxString::Format(
 184                         wxT("%")
 185                         wxLongLongFmtSpec wxT("u %s %02")
 186                         wxLongLongFmtSpec wxT("u:%02")
 187                         wxLongLongFmtSpec wxT("u "),
 188                         count/86400,
 189                         _("Days"),
 190                         (count % 86400)/3600,
 191                         (count % 3600)/60) + _("hours");
 192         }
 193
 194         return _("ERROR");
 195 }
 196
 197
 198 // Examines a filename and determines the filetype
 199 FileType GetFiletype(const CPath& filename)
 200 {
 201         // FIXME: WTF do we have two such functions in the first place?
 202         switch (GetED2KFileTypeID(filename)) {
 203                 case ED2KFT_AUDIO:      return ftAudio;
 204                 case ED2KFT_VIDEO:      return ftVideo;
 205                 case ED2KFT_IMAGE:      return ftPicture;
 206                 case ED2KFT_PROGRAM:    return ftProgram;
 207                 case ED2KFT_DOCUMENT:   return ftText;
 208                 case ED2KFT_ARCHIVE:    return ftArchive;
 209                 case ED2KFT_CDIMAGE:    return ftCDImage;
 210                 default:                return ftAny;
 211         }
 212 }
 213
 214
 215 // Returns the (translated) description assosiated with a FileType
 216 wxString GetFiletypeDesc(FileType type, bool translated)
 217 {
 218         switch ( type ) {
 219                 case ftVideo:
 220                         if (translated) {
 221                                 return _("Videos");
 222                         } else {
 223                                 return wxT("Videos");
 224                         }
 225                         break;
 226                 case ftAudio:
 227                         if (translated) {
 228                                 return _("Audio");
 229                         } else {
 230                                 return wxT("Audio");
 231                         }
 232                         break;
 233                 case ftArchive:
 234                         if (translated) {
 235                                 return _("Archives");
 236                         } else {
 237                                 return wxT("Archives");
 238                         }
 239                         break;
 240                 case ftCDImage:
 241                         if (translated) {
 242                                 return _("CD-Images");
 243                         } else {
 244                                 return wxT("CD-Images");
 245                         }
 246                         break;
 247                 case ftPicture:
 248                         if (translated) {
 249                                 return _("Pictures");
 250                         } else {
 251                                 return wxT("Pictures");
 252                         }
 253                         break;
 254                 case ftText:
 255                         if (translated) {
 256                                 return _("Texts");
 257                         } else {
 258                                 return wxT("Texts");
 259                         }
 260                         break;
 261                 case ftProgram:
 262                         if (translated) {
 263                                 return _("Programs");
 264                         } else {
 265                                 return wxT("Programs");
 266                         }
 267                         break;
 268                 default:
 269                         if (translated) {
 270                                 return _("Any");
 271                         } else {
 272                                 return wxT("Any");
 273                         }
 274                         break;
 275         }
 276 }
 277
 278 // Returns the Typename, examining the extention of the given filename
 279
 280 wxString GetFiletypeByName(const CPath& filename, bool translated)
 281 {
 282         return GetFiletypeDesc(GetFiletype(filename), translated);
 283 }
 284
 285
 286 // Return the text associated with a rating of a file
 287 wxString GetRateString(uint16 rate)
 288 {
 289         switch ( rate ) {
 290                 case 0: return _("Not rated");
 291                 case 1: return _("Invalid / Corrupt / Fake");
 292                 case 2: return _("Poor");
 293                 case 3: return _("Fair");
 294                 case 4: return _("Good");
 295                 case 5: return _("Excellent");
 296                 default: return _("Not rated");
 297         }
 298 }
 299
 300
 301 /**
 302  * Return the size in bytes of the given size-type
 303  *
 304  * @param type The type (as an int) where: 0 = Byte, 1 = KB, 2 = MB, 3 = GB
 305  *
 306  * @return The amount of Bytes the provided size-type represents
 307  *
 308  * Values over GB aren't handled since the amount of Bytes 1TB represents
 309  * is over the uint32 capacity
 310  */
 311 uint32 GetTypeSize(uint8 type)
 312 {
 313         enum {Bytes, KB, MB, GB};
 314         int size;
 315
 316         switch(type) {
 317                 case Bytes: size = 1; break;
 318                 case KB: size = 1024; break;
 319                 case MB: size = 1048576; break;
 320                 case GB: size = 1073741824; break;
 321                 default: size = -1; break;
 322         }
 323         return size;
 324 }
 325
 326
 327 // Base16 chars for encode an decode functions
 328 static wxChar base16Chars[17] = wxT("0123456789ABCDEF");
 329 static wxChar base32Chars[33] = wxT("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
 330 #define BASE16_LOOKUP_MAX 23
 331 static wxChar base16Lookup[BASE16_LOOKUP_MAX][2] = {
 332         { wxT('0'), 0x0 },
 333         { wxT('1'), 0x1 },
 334         { wxT('2'), 0x2 },
 335         { wxT('3'), 0x3 },
 336         { wxT('4'), 0x4 },
 337         { wxT('5'), 0x5 },
 338         { wxT('6'), 0x6 },
 339         { wxT('7'), 0x7 },
 340         { wxT('8'), 0x8 },
 341         { wxT('9'), 0x9 },
 342         { wxT(':'), 0x9 },
 343         { wxT(';'), 0x9 },
 344         { wxT('<'), 0x9 },
 345         { wxT('='), 0x9 },
 346         { wxT('>'), 0x9 },
 347         { wxT('?'), 0x9 },
 348         { wxT('@'), 0x9 },
 349         { wxT('A'), 0xA },
 350         { wxT('B'), 0xB },
 351         { wxT('C'), 0xC },
 352         { wxT('D'), 0xD },
 353         { wxT('E'), 0xE },
 354         { wxT('F'), 0xF }
 355 };
 356
 357
 358 // Returns a BASE16 encoded byte array
 359 //
 360 // [In]
 361 //   buffer: Pointer to byte array
 362 //   bufLen: Lenght of buffer array
 363 //
 364 // [Return]
 365 //   wxString object with BASE16 encoded byte array
 366 wxString EncodeBase16(const unsigned char* buffer, unsigned int bufLen)
 367 {
 368         wxString Base16Buff;
 369
 370         for(unsigned int i = 0; i < bufLen; ++i) {
 371                 Base16Buff += base16Chars[buffer[i] >> 4];
 372                 Base16Buff += base16Chars[buffer[i] & 0xf];
 373         }
 374
 375         return Base16Buff;
 376 }
 377
 378
 379 // Decodes a BASE16 string into a byte array
 380 //
 381 // [In]
 382 //   base16Buffer: String containing BASE16
 383 //   base16BufLen: Lenght BASE16 coded string's length
 384 //
 385 // [Out]
 386 //   buffer: byte array containing decoded string
 387 unsigned int DecodeBase16(const wxString &base16Buffer, unsigned int base16BufLen, byte *buffer)
 388 {
 389         if (base16BufLen & 1) {
 390                 return 0;
 391         }
 392         unsigned int ret = base16BufLen >> 1;
 393         memset( buffer, 0,  ret);
 394         for(unsigned int i = 0; i < base16BufLen; ++i) {
 395                 int lookup = toupper(base16Buffer[i]) - wxT('0');
 396                 // Check to make sure that the given word falls inside a valid range
 397                 byte word = (lookup < 0 || lookup >= BASE16_LOOKUP_MAX) ?
 398                         0xFF : base16Lookup[lookup][1];
 399                 unsigned idx = i >> 1;
 400                 buffer[idx] = (i & 1) ? // odd or even?
 401                         (buffer[idx] | word) : (word << 4);
 402         }
 403
 404         return ret;
 405 }
 406
 407
 408 // Returns a BASE32 encoded byte array
 409 //
 410 // [In]
 411 //   buffer: Pointer to byte array
 412 //   bufLen: Lenght of buffer array
 413 //
 414 // [Return]
 415 //   wxString object with BASE32 encoded byte array
 416 wxString EncodeBase32(const unsigned char* buffer, unsigned int bufLen)
 417 {
 418         wxString Base32Buff;
 419         unsigned int i, index;
 420         unsigned char word;
 421
 422         for(i = 0, index = 0; i < bufLen;) {
 423                 // Is the current word going to span a byte boundary?
 424                 if (index > 3) {
 425                         word = (buffer[i] & (0xFF >> index));
 426                         index = (index + 5) % 8;
 427                         word <<= index;
 428                         if (i < bufLen - 1) {
 429                                 word |= buffer[i + 1] >> (8 - index);
 430                         }
 431                         ++i;
 432                 } else {
 433                         word = (buffer[i] >> (8 - (index + 5))) & 0x1F;
 434                         index = (index + 5) % 8;
 435                         if (index == 0) {
 436                                 ++i;
 437                         }
 438                 }
 439                 Base32Buff += (char) base32Chars[word];
 440         }
 441
 442         return Base32Buff;
 443 }
 444
 445
 446 // Decodes a BASE32 string into a byte array
 447 //
 448 // [In]
 449 //   base32Buffer: String containing BASE32
 450 //   base32BufLen: Lenght BASE32 coded string's length
 451 //
 452 // [Out]
 453 //   buffer: byte array containing decoded string
 454 // [Return]
 455 //   nDecodeLen:
 456 unsigned int DecodeBase32(const wxString &base32Buffer, unsigned int base32BufLen, unsigned char *buffer)
 457 {
 458         size_t nInputLen = base32Buffer.Length();
 459         uint32 nDecodeLen = (nInputLen * 5) / 8;
 460         if ((nInputLen * 5) % 8 > 0) {
 461                 ++nDecodeLen;
 462         }
 463         if (base32BufLen == 0) {
 464                 return nDecodeLen;
 465         }
 466         if (nDecodeLen > base32BufLen) {
 467                 return 0;
 468         }
 469
 470         uint32 nBits = 0;
 471         int nCount = 0;
 472         for (size_t i = 0; i < nInputLen; ++i)
 473         {
 474                 if (base32Buffer[i] >= wxT('A') && base32Buffer[i] <= wxT('Z')) {
 475                         nBits |= ( base32Buffer[i] - wxT('A') );
 476                 }
 477                 else if (base32Buffer[i] >= wxT('a') && base32Buffer[i] <= wxT('z')) {
 478                         nBits |= ( base32Buffer[i] - wxT('a') );
 479                 }
 480                 else if (base32Buffer[i] >= wxT('2') && base32Buffer[i] <= wxT('7')) {
 481                         nBits |= ( base32Buffer[i] - wxT('2') + 26 );
 482                 } else {
 483                         return 0;
 484                 }
 485                 nCount += 5;
 486                 if (nCount >= 8)
 487                 {
 488                         *buffer++ = (byte)( nBits >> (nCount - 8) );
 489                         nCount -= 8;
 490                 }
 491                 nBits <<= 5;
 492         }
 493
 494         return nDecodeLen;
 495 }
 496
 497
 498 /*
 499  * base64.c
 500  *
 501  * Base64 encoding/decoding command line filter
 502  *
 503  * Copyright (c) 2002 Matthias Gaertner 29.06.2002
 504  * Adapted by (C) 2005-2008 Phoenix to use wxWidgets.
 505  *
 506  */
 507 static const wxString to_b64(
 508         /*   0000000000111111111122222222223333333333444444444455555555556666 */
 509         /*   0123456789012345678901234567890123456789012345678901234567890123 */
 510         wxT("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"));
 511
 512
 513 /* Option variables */
 514 static bool g_fUseCRLF = false;
 515 static unsigned int g_nCharsPerLine = 72;
 516 static wxString strHeaderLine;
 517
 518
 519 wxString EncodeBase64(const char *pbBufferIn, unsigned int bufLen)
 520 {
 521         wxString pbBufferOut;
 522         wxString strHeader;
 523
 524         if( !strHeaderLine.IsEmpty() ) {
 525                 strHeader = wxT("-----BEGIN ") + strHeaderLine + wxT("-----");
 526                 if( g_fUseCRLF ) {
 527                         strHeader += wxT("\r");
 528                 }
 529                 strHeader += wxT("\n");
 530         }
 531
 532         unsigned long nDiv = ((unsigned long)bufLen) / 3;
 533         unsigned long nRem = ((unsigned long)bufLen) % 3;
 534         unsigned int NewLineSize = g_fUseCRLF ? 2 : 1;
 535
 536         // Allocate enough space in the output buffer to speed up things
 537         pbBufferOut.Alloc(
 538                 strHeader.Len() * 2 +           // header/footer
 539                 (bufLen * 4) / 3 + 1 +          // Number of codes
 540                 nDiv           * NewLineSize +  // Number of new lines
 541                 (nRem ? 1 : 0) * NewLineSize ); // Last line
 542         pbBufferOut = strHeader;
 543
 544         unsigned long nChars = 0;
 545         const unsigned char *pIn = (unsigned char*)pbBufferIn;
 546         while( nDiv > 0 ) {
 547                 pbBufferOut += to_b64[ (pIn[0] >> 2) & 0x3f];
 548                 pbBufferOut += to_b64[((pIn[0] << 4) & 0x30) | ((pIn[1] >> 4) & 0xf)];
 549                 pbBufferOut += to_b64[((pIn[1] << 2) & 0x3c) | ((pIn[2] >> 6) & 0x3)];
 550                 pbBufferOut += to_b64[  pIn[2] & 0x3f];
 551                 pIn += 3;
 552                 nDiv--;
 553                 nChars += 4;
 554                 if( nChars >= g_nCharsPerLine && g_nCharsPerLine != 0 ) {
 555                         nChars = 0;
 556                         if( g_fUseCRLF ) {
 557                                 pbBufferOut += wxT("\r");
 558                         }
 559                         pbBufferOut += wxT("\n");
 560                 }
 561         }
 562         switch( nRem ) {
 563         case 2:
 564                 pbBufferOut += to_b64[ (pIn[0] >> 2) & 0x3f];
 565                 pbBufferOut += to_b64[((pIn[0] << 4) & 0x30) | ((pIn[1] >> 4) & 0xf)];
 566                 pbBufferOut += to_b64[ (pIn[1] << 2) & 0x3c];
 567                 pbBufferOut += wxT("=");
 568                 nChars += 4;
 569                 if( nChars >= g_nCharsPerLine && g_nCharsPerLine != 0 ) {
 570                         nChars = 0;
 571                         if( g_fUseCRLF ) {
 572                                 pbBufferOut += wxT("\r");
 573                         }
 574                         pbBufferOut += wxT("\n");
 575                 }
 576                 break;
 577         case 1:
 578                 pbBufferOut += to_b64[ (pIn[0] >> 2) & 0x3f];
 579                 pbBufferOut += to_b64[ (pIn[0] << 4) & 0x30];
 580                 pbBufferOut += wxT("=");
 581                 pbBufferOut += wxT("=");
 582                 nChars += 4;
 583                 if( nChars >= g_nCharsPerLine && g_nCharsPerLine != 0 ) {
 584                         nChars = 0;
 585                         if( g_fUseCRLF ) {
 586                                 pbBufferOut += wxT("\r");
 587                         }
 588                         pbBufferOut += wxT("\n");
 589                 }
 590                 break;
 591         }
 592
 593         if( nRem > 0 ) {
 594                 if( nChars > 0 ) {
 595                         if( g_fUseCRLF ) {
 596                                 pbBufferOut += wxT("\r");
 597                         }
 598                         pbBufferOut += wxT("\n");
 599                 }
 600         }
 601
 602         if( !strHeaderLine.IsEmpty() ) {
 603                 pbBufferOut = wxT("-----END ") + strHeaderLine + wxT("-----");
 604                 if( g_fUseCRLF ) {
 605                         pbBufferOut += wxT("\r");
 606                 }
 607                 pbBufferOut += wxT("\n");
 608         }
 609
 610         return pbBufferOut;
 611 }
 612
 613
 614 unsigned int DecodeBase64(const wxString &base64Buffer, unsigned int base64BufLen, unsigned char *buffer)
 615 {
 616         int z = 0;  // 0 Normal, 1 skip MIME separator (---) to end of line
 617         unsigned int nData = 0;
 618         unsigned int i = 0;
 619
 620         if (base64BufLen == 0) {
 621                 *buffer = 0;
 622                 nData = 1;
 623         }
 624
 625         for(unsigned int j = 0; j < base64BufLen; ++j) {
 626                 wxChar c = base64Buffer[j];
 627                 wxChar bits = wxT('z');
 628                 if( z > 0 ) {
 629                         if(c == wxT('\n')) {
 630                                 z = 0;
 631                         }
 632                 }
 633                 else if(c >= wxT('A') && c <= wxT('Z')) {
 634                         bits = c - wxT('A');
 635                 }
 636                 else if(c >= wxT('a') && c <= wxT('z')) {
 637                         bits = c - wxT('a') + (wxChar)26;
 638                 }
 639                 else if(c >= wxT('0') && c <= wxT('9')) {
 640                         bits = c - wxT('0') + (wxChar)52;
 641                 }
 642                 else if(c == wxT('+')) {
 643                         bits = (wxChar)62;
 644                 }
 645                 else if(c == wxT('/')) {
 646                         bits = (wxChar)63;
 647                 }
 648                 else if(c == wxT('-')) {
 649                         z = 1;
 650                 }
 651                 else if(c == wxT('=')) {
 652                         break;
 653                 } else {
 654                         bits = wxT('y');
 655                 }
 656
 657                 // Skips anything that was not recognized
 658                 // as a base64 valid char ('y' or 'z')
 659                 if (bits < (wxChar)64) {
 660                         switch (nData++) {
 661                         case 0:
 662                                 buffer[i+0] = (bits << 2) & 0xfc;
 663                                 break;
 664                         case 1:
 665                                 buffer[i+0] |= (bits >> 4) & 0x03;
 666                                 buffer[i+1] = (bits << 4) & 0xf0;
 667                                 break;
 668                         case 2:
 669                                 buffer[i+1] |= (bits >> 2) & 0x0f;
 670                                 buffer[i+2] = (bits << 6) & 0xc0;
 671                                 break;
 672                         case 3:
 673                                 buffer[i+2] |= bits & 0x3f;
 674                                 break;
 675                         }
 676                         if (nData == 4) {
 677                                 nData = 0;
 678                                 i += 3;
 679                         }
 680                 }
 681         }
 682         if (nData == 1) {
 683                 // Syntax error or buffer was empty
 684                 *buffer = 0;
 685                 nData = 0;
 686                 i = 0;
 687         } else {
 688                 buffer[i+nData] = 0;
 689         }
 690
 691         return i + nData;
 692 }
 693
 694
 695 // Returns the text assosiated with a category type
 696 wxString GetCatTitle(int catid)
 697 {
 698         switch (catid) {
 699                 case 0:  return _("all");
 700                 case 1:  return _("all others");
 701                 case 2:  return _("Incomplete");
 702                 case 3:  return _("Completed");
 703                 case 4:  return _("Waiting");
 704                 case 5:  return _("Downloading");
 705                 case 6:  return _("Erroneous");
 706                 case 7:  return _("Paused");
 707                 case 8:  return _("Stopped");
 708                 case 9:  return _("Video");
 709                 case 10: return _("Audio");
 710                 case 11: return _("Archive");
 711                 case 12: return _("CD-Images");
 712                 case 13: return _("Pictures");
 713                 case 14: return _("Text");
 714                 case 15: return _("Active");
 715                 default: return wxT("?");
 716         }
 717 }
 718
 719
 720 typedef std::map<wxString, EED2KFileTypeClass> SED2KFileTypeMap;
 721 typedef SED2KFileTypeMap::value_type SED2KFileTypeMapElement;
 722 static SED2KFileTypeMap ED2KFileTypesMap;
 723
 724
 725 class CED2KFileTypes{
 726 public:
 727         CED2KFileTypes()
 728         {
 729                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".669"),   ED2KFT_AUDIO));
 730                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".aac"),   ED2KFT_AUDIO));
 731                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".aif"),   ED2KFT_AUDIO));
 732                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".aiff"),  ED2KFT_AUDIO));
 733                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".amf"),   ED2KFT_AUDIO));
 734                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ams"),   ED2KFT_AUDIO));
 735                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ape"),   ED2KFT_AUDIO));
 736                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".au"),    ED2KFT_AUDIO));
 737                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".dbm"),   ED2KFT_AUDIO));
 738                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".dmf"),   ED2KFT_AUDIO));
 739                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".dsm"),   ED2KFT_AUDIO));
 740                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".far"),   ED2KFT_AUDIO));
 741                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".flac"),  ED2KFT_AUDIO));
 742                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".it"),    ED2KFT_AUDIO));
 743                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mdl"),   ED2KFT_AUDIO));
 744                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".med"),   ED2KFT_AUDIO));
 745                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mid"),   ED2KFT_AUDIO));
 746                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".midi"),  ED2KFT_AUDIO));
 747                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mod"),   ED2KFT_AUDIO));
 748                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mol"),   ED2KFT_AUDIO));
 749                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mp1"),   ED2KFT_AUDIO));
 750                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mp2"),   ED2KFT_AUDIO));
 751                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mp3"),   ED2KFT_AUDIO));
 752                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mp4"),   ED2KFT_AUDIO));
 753                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpa"),   ED2KFT_AUDIO));
 754                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpc"),   ED2KFT_AUDIO));
 755                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpp"),   ED2KFT_AUDIO));
 756                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mtm"),   ED2KFT_AUDIO));
 757                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".nst"),   ED2KFT_AUDIO));
 758                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ogg"),   ED2KFT_AUDIO));
 759                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".okt"),   ED2KFT_AUDIO));
 760                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".psm"),   ED2KFT_AUDIO));
 761                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ptm"),   ED2KFT_AUDIO));
 762                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ra"),    ED2KFT_AUDIO));
 763                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".rmi"),   ED2KFT_AUDIO));
 764                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".s3m"),   ED2KFT_AUDIO));
 765                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".stm"),   ED2KFT_AUDIO));
 766                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ult"),   ED2KFT_AUDIO));
 767                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".umx"),   ED2KFT_AUDIO));
 768                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".wav"),   ED2KFT_AUDIO));
 769                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".wma"),   ED2KFT_AUDIO));
 770                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".wow"),   ED2KFT_AUDIO));
 771                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".xm"),    ED2KFT_AUDIO));
 772
 773                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".asf"),   ED2KFT_VIDEO));
 774                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".avi"),   ED2KFT_VIDEO));
 775                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".divx"),  ED2KFT_VIDEO));
 776                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".m1v"),   ED2KFT_VIDEO));
 777                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".m2v"),   ED2KFT_VIDEO));
 778                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mkv"),   ED2KFT_VIDEO));
 779                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mov"),   ED2KFT_VIDEO));
 780                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mp1v"),  ED2KFT_VIDEO));
 781                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mp2v"),  ED2KFT_VIDEO));
 782                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpe"),   ED2KFT_VIDEO));
 783                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpeg"),  ED2KFT_VIDEO));
 784                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpg"),   ED2KFT_VIDEO));
 785                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mps"),   ED2KFT_VIDEO));
 786                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpv"),   ED2KFT_VIDEO));
 787                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpv1"),  ED2KFT_VIDEO));
 788                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mpv2"),  ED2KFT_VIDEO));
 789                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ogm"),   ED2KFT_VIDEO));
 790                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".qt"),    ED2KFT_VIDEO));
 791                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ram"),   ED2KFT_VIDEO));
 792                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".rm"),    ED2KFT_VIDEO));
 793                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".rv"),    ED2KFT_VIDEO));
 794                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".rv9"),   ED2KFT_VIDEO));
 795                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ts"),    ED2KFT_VIDEO));
 796                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".vivo"),  ED2KFT_VIDEO));
 797                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".vob"),   ED2KFT_VIDEO));
 798                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".wmv"),   ED2KFT_VIDEO));
 799                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".xvid"),  ED2KFT_VIDEO));
 800
 801                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".bmp"),   ED2KFT_IMAGE));
 802                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".dcx"),   ED2KFT_IMAGE));
 803                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".emf"),   ED2KFT_IMAGE));
 804                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".gif"),   ED2KFT_IMAGE));
 805                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ico"),   ED2KFT_IMAGE));
 806                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".jpeg"),  ED2KFT_IMAGE));
 807                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".jpg"),   ED2KFT_IMAGE));
 808                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".pct"),   ED2KFT_IMAGE));
 809                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".pcx"),   ED2KFT_IMAGE));
 810                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".pic"),   ED2KFT_IMAGE));
 811                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".pict"),  ED2KFT_IMAGE));
 812                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".png"),   ED2KFT_IMAGE));
 813                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".psd"),   ED2KFT_IMAGE));
 814                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".psp"),   ED2KFT_IMAGE));
 815                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".tga"),   ED2KFT_IMAGE));
 816                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".tif"),   ED2KFT_IMAGE));
 817                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".tiff"),  ED2KFT_IMAGE));
 818                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".wmf"),   ED2KFT_IMAGE));
 819                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".xif"),   ED2KFT_IMAGE));
 820
 821                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".7z"),    ED2KFT_ARCHIVE));
 822                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ace"),   ED2KFT_ARCHIVE));
 823                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".arj"),   ED2KFT_ARCHIVE));
 824                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".bz2"),   ED2KFT_ARCHIVE));
 825                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".cab"),   ED2KFT_ARCHIVE));
 826                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".gz"),    ED2KFT_ARCHIVE));
 827                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".hqx"),   ED2KFT_ARCHIVE));
 828                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".lha"),   ED2KFT_ARCHIVE));
 829                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".msi"),   ED2KFT_ARCHIVE));
 830                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".rar"),   ED2KFT_ARCHIVE));
 831                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".sea"),   ED2KFT_ARCHIVE));
 832                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".sit"),   ED2KFT_ARCHIVE));
 833                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".tar"),   ED2KFT_ARCHIVE));
 834                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".tgz"),   ED2KFT_ARCHIVE));
 835                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".uc2"),   ED2KFT_ARCHIVE));
 836                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".zip"),   ED2KFT_ARCHIVE));
 837
 838                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".bat"),   ED2KFT_PROGRAM));
 839                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".cmd"),   ED2KFT_PROGRAM));
 840                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".com"),   ED2KFT_PROGRAM));
 841                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".exe"),   ED2KFT_PROGRAM));
 842
 843                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".bin"),   ED2KFT_CDIMAGE));
 844                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".bwa"),   ED2KFT_CDIMAGE));
 845                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".bwi"),   ED2KFT_CDIMAGE));
 846                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".bws"),   ED2KFT_CDIMAGE));
 847                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".bwt"),   ED2KFT_CDIMAGE));
 848                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ccd"),   ED2KFT_CDIMAGE));
 849                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".cue"),   ED2KFT_CDIMAGE));
 850                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".dmg"),   ED2KFT_CDIMAGE));
 851                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".dmz"),   ED2KFT_CDIMAGE));
 852                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".img"),   ED2KFT_CDIMAGE));
 853                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".iso"),   ED2KFT_CDIMAGE));
 854                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mdf"),   ED2KFT_CDIMAGE));
 855                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".mds"),   ED2KFT_CDIMAGE));
 856                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".nrg"),   ED2KFT_CDIMAGE));
 857                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".sub"),   ED2KFT_CDIMAGE));
 858                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".toast"), ED2KFT_CDIMAGE));
 859
 860                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".chm"),   ED2KFT_DOCUMENT));
 861                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".css"),   ED2KFT_DOCUMENT));
 862                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".diz"),   ED2KFT_DOCUMENT));
 863                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".doc"),   ED2KFT_DOCUMENT));
 864                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".dot"),   ED2KFT_DOCUMENT));
 865                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".hlp"),   ED2KFT_DOCUMENT));
 866                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".htm"),   ED2KFT_DOCUMENT));
 867                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".html"),  ED2KFT_DOCUMENT));
 868                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".nfo"),   ED2KFT_DOCUMENT));
 869                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".pdf"),   ED2KFT_DOCUMENT));
 870                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".pps"),   ED2KFT_DOCUMENT));
 871                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ppt"),   ED2KFT_DOCUMENT));
 872                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".ps"),    ED2KFT_DOCUMENT));
 873                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".rtf"),   ED2KFT_DOCUMENT));
 874                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".wri"),   ED2KFT_DOCUMENT));
 875                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".txt"),   ED2KFT_DOCUMENT));
 876                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".xls"),   ED2KFT_DOCUMENT));
 877                 ED2KFileTypesMap.insert(SED2KFileTypeMapElement(wxT(".xlt"),   ED2KFT_DOCUMENT));
 878         }
 879 };
 880
 881
 882 // get the list initialized *before* any code is accessing it
 883 CED2KFileTypes theED2KFileTypes;
 884
 885 EED2KFileType GetED2KFileTypeID(const CPath& fileName)
 886 {
 887         const wxString ext = fileName.GetExt().Lower();
 888         if (ext.IsEmpty()) {
 889                 return ED2KFT_ANY;
 890         }
 891
 892         SED2KFileTypeMap::iterator it = ED2KFileTypesMap.find(wxT(".") + ext);
 893         if (it != ED2KFileTypesMap.end()) {
 894                 return it->second.GetType();
 895         } else {
 896                 return ED2KFT_ANY;
 897         }
 898 }
 899
 900
 901 // Retuns the ed2k file type term which is to be used in server searches
 902 wxString GetED2KFileTypeSearchTerm(EED2KFileType iFileID)
 903 {
 904         if (iFileID == ED2KFT_AUDIO)            return ED2KFTSTR_AUDIO;
 905         if (iFileID == ED2KFT_VIDEO)            return ED2KFTSTR_VIDEO;
 906         if (iFileID == ED2KFT_IMAGE)            return ED2KFTSTR_IMAGE;
 907         if (iFileID == ED2KFT_DOCUMENT)         return ED2KFTSTR_DOCUMENT;
 908         if (iFileID == ED2KFT_PROGRAM)          return ED2KFTSTR_PROGRAM;
 909         // NOTE: Archives and CD-Images are published with file type "Pro"
 910         if (iFileID == ED2KFT_ARCHIVE)          return ED2KFTSTR_PROGRAM;
 911         if (iFileID == ED2KFT_CDIMAGE)          return ED2KFTSTR_PROGRAM;
 912
 913         return wxEmptyString;
 914 }
 915
 916
 917 // Returns a file type which is used eMule internally only, examining the extention of the given filename
 918 wxString GetFileTypeByName(const CPath& fileName)
 919 {
 920         EED2KFileType iFileType = GetED2KFileTypeID(fileName);
 921         switch (iFileType) {
 922                 case ED2KFT_AUDIO:      return ED2KFTSTR_AUDIO;
 923                 case ED2KFT_VIDEO:      return ED2KFTSTR_VIDEO;
 924                 case ED2KFT_IMAGE:      return ED2KFTSTR_IMAGE;
 925                 case ED2KFT_DOCUMENT:   return ED2KFTSTR_DOCUMENT;
 926                 case ED2KFT_PROGRAM:    return ED2KFTSTR_PROGRAM;
 927                 case ED2KFT_ARCHIVE:    return ED2KFTSTR_ARCHIVE;
 928                 case ED2KFT_CDIMAGE:    return ED2KFTSTR_CDIMAGE;
 929                 default:                return wxEmptyString;
 930         }
 931 }
 932
 933
 934 // Retuns the ed2k file type integer ID which is to be used for publishing+searching
 935 EED2KFileType GetED2KFileTypeSearchID(EED2KFileType iFileID)
 936 {
 937         switch (iFileID) {
 938                 case ED2KFT_AUDIO:      return ED2KFT_AUDIO;
 939                 case ED2KFT_VIDEO:      return ED2KFT_VIDEO;
 940                 case ED2KFT_IMAGE:      return ED2KFT_IMAGE;
 941                 case ED2KFT_DOCUMENT:   return ED2KFT_DOCUMENT;
 942                 case ED2KFT_PROGRAM:    return ED2KFT_PROGRAM;
 943                 // NOTE: Archives and CD-Images are published+searched with file type "Pro"
 944                 // NOTE: If this gets changed, the function 'GetED2KFileTypeSearchTerm' also needs to get updated!
 945                 case ED2KFT_ARCHIVE:    return ED2KFT_PROGRAM;
 946                 case ED2KFT_CDIMAGE:    return ED2KFT_PROGRAM;
 947                 default:                return  ED2KFT_ANY;
 948         }
 949 }
 950
 951
 952 /**
 953  * Dumps a buffer to a wxString
 954  */
 955 wxString DumpMemToStr(const void *buff, int n, const wxString& msg, bool ok)
 956 {
 957         const unsigned char *p = (const unsigned char *)buff;
 958         int lines = (n + 15)/ 16;
 959
 960         wxString result;
 961         // Allocate aproximetly what is needed
 962         result.Alloc( ( lines + 1 ) * 80 );
 963         if ( !msg.IsEmpty() ) {
 964                 result += msg + wxT(" - ok=") + ( ok ? wxT("true, ") : wxT("false, ") );
 965         }
 966
 967         result += wxString::Format( wxT("%d bytes\n"), n );
 968         for ( int i = 0; i < lines; ++i) {
 969                 // Show address
 970                 result += wxString::Format( wxT("%08x  "), i * 16 );
 971
 972                 // Show two columns of hex-values
 973                 for ( int j = 0; j < 2; ++j) {
 974                         for ( int k = 0; k < 8; ++k) {
 975                                 int pos = 16 * i + 8 * j + k;
 976
 977                                 if ( pos < n ) {
 978                                         result += wxString::Format( wxT("%02x "), p[pos] );
 979                                 } else {
 980                                         result += wxT("   ");
 981                                 }
 982                         }
 983                         result += wxT(" ");
 984                 }
 985                 result += wxT("|");
 986                 // Show a column of ascii-values
 987                 for ( int k = 0; k < 16; ++k) {
 988                         int pos = 16 * i + k;
 989
 990                         if ( pos < n ) {
 991                                 if ( isspace( p[pos] ) ) {
 992                                         result += wxT(" ");
 993                                 } else if ( !isgraph( p[pos] ) ) {
 994                                         result += wxT(".");
 995                                 } else {
 996                                         result += (wxChar)p[pos];
 997                                 }
 998                         } else {
 999                                 result += wxT(" ");
1000                         }
1001                 }
1002                 result += wxT("|\n");
1003         }
1004         result.Shrink();
1005
1006         return result;
1007 }
1008
1009
1010 /**
1011  * Dumps a buffer to stdout
1012  */
1013 void DumpMem(const void *buff, int n, const wxString& msg, bool ok)
1014 {
1015         printf("%s\n", (const char*)unicode2char(DumpMemToStr( buff, n, msg, ok )) );
1016 }
1017
1018
1019 //
1020 // Dump mem in dword format
1021 void DumpMem_DW(const uint32 *ptr, int count)
1022 {
1023         for(int i = 0; i < count; i++) {
1024                 printf("%08x ", ptr[i]);
1025                 if ( (i % 4) == 3) printf("\n");
1026         }
1027         printf("\n");
1028 }
1029
1030
1031 wxString GetConfigDir()
1032 {
1033         // Cache the path.
1034         static wxString configPath;
1035
1036         if (configPath.IsEmpty()) {
1037 #ifndef EC_REMOTE
1038                 // "Portable aMule" - Use aMule from an external USB drive
1039                 // Check for ./config/amule.conf and use this configuration if found
1040                 const wxString configDir = JoinPaths(wxFileName::GetCwd(), wxT("config"));
1041                 const wxString configFile = JoinPaths(configDir, wxT("amule.conf"));
1042
1043                 if (CPath::DirExists(configDir) && CPath::FileExists(configFile)) {
1044                         AddLogLineM(true, CFormat(wxT("Using configDir: %s")) % configDir);
1045
1046                         configPath = configDir;
1047                 } else {
1048                         configPath = wxStandardPaths::Get().GetUserDataDir();
1049                 }
1050 #else
1051                 configPath = wxStandardPaths::Get().GetUserDataDir();
1052 #endif
1053
1054                 configPath += wxFileName::GetPathSeparator();
1055         }
1056
1057         return configPath;
1058 }
1059
1060
1061 void InitCustomLanguages()
1062 {
1063         wxLanguageInfo CustomLanguage;
1064         CustomLanguage.Language = wxLANGUAGE_ITALIAN_NAPOLITAN;
1065         CustomLanguage.CanonicalName = wxT("it_NA");
1066         CustomLanguage.Description = wxT("sNeo's Custom Napolitan Language");
1067         wxLocale::AddLanguage(CustomLanguage);
1068 }
1069
1070
1071 void InitLocale(wxLocale& locale, int language)
1072 {
1073         int language_flags = 0;
1074         if (language != wxLANGUAGE_CUSTOM && language != wxLANGUAGE_ITALIAN_NAPOLITAN) {
1075                 language_flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING;
1076         }
1077
1078         locale.Init(language,language_flags);
1079
1080         if (language != wxLANGUAGE_CUSTOM) {
1081
1082 #if defined(__WXMAC__) || defined(__WXMSW__)
1083                 locale.AddCatalogLookupPathPrefix(JoinPaths(wxStandardPaths::Get().GetDataDir(), wxT("locale")));
1084 #endif
1085                 locale.AddCatalog(wxT(PACKAGE));
1086
1087         } else {
1088                 locale.AddCatalogLookupPathPrefix(GetConfigDir());
1089                 locale.AddCatalog(wxT("custom"));
1090         }
1091 }
1092
1093
1094 int StrLang2wx(const wxString& language)
1095 {
1096         // get rid of possible encoding and modifier
1097         wxString lang(language.BeforeFirst('.').BeforeFirst('@'));
1098
1099         if (!lang.IsEmpty()) {
1100                 const wxLanguageInfo *lng = wxLocale::FindLanguageInfo(lang);
1101                 if (lng) {
1102                         return lng->Language;
1103                 } else {
1104                         return wxLANGUAGE_DEFAULT;
1105                 }
1106         } else {
1107                 return wxLANGUAGE_DEFAULT;
1108         }
1109 }
1110
1111
1112 wxString wxLang2Str(const int lang)
1113 {
1114         if (lang != wxLANGUAGE_DEFAULT) {
1115                 const wxLanguageInfo *lng = wxLocale::GetLanguageInfo(lang);
1116                 if (lng) {
1117                         return lng->CanonicalName;
1118                 } else {
1119                         return wxEmptyString;
1120                 }
1121         } else {
1122                 return wxEmptyString;
1123         }
1124 }
1125
1126 wxString GetPassword() {
1127 wxString pass_plain;
1128 CMD4Hash password;
1129                 #ifndef __WXMSW__
1130                         pass_plain = char2unicode(getpass("Enter password for mule connection: "));
1131                 #else
1132                         //#warning This way, pass enter is not hidden on windows. Bad thing.
1133                         char temp_str[512];
1134                         fflush(stdin);
1135                         printf("Enter password for mule connection: \n");
1136                         fflush(stdout);
1137                         fgets(temp_str, 512, stdin);
1138                         temp_str[strlen(temp_str)-1] = '\0';
1139                         pass_plain = char2unicode(temp_str);
1140                 #endif
1141                 wxCHECK2(password.Decode(MD5Sum(pass_plain).GetHash()), /* Do nothing. */ );
1142                 // MD5 hash for an empty string, according to rfc1321.
1143                 if (password.Encode() == wxT("D41D8CD98F00B204E9800998ECF8427E")) {
1144                         printf("No empty password allowed.\n");
1145                         return GetPassword();
1146                 }
1147
1148
1149 return password.Encode();
1150 }
1151
1152 // File_checked_for_headers