src/SearchList.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 #include "SearchList.h"         // Interface declarations.
  27
  28 #include <protocol/Protocols.h>
  29 #include <protocol/kad/Constants.h>
  30 #include <tags/ClientTags.h>
  31 #include <tags/FileTags.h>
  32
  33 #include "updownclient.h"       // Needed for CUpDownClient
  34 #include "MemFile.h"            // Needed for CMemFile
  35 #include "amule.h"                      // Needed for theApp
  36 #include "ServerConnect.h"      // Needed for theApp->serverconnect
  37 #include "Server.h"                     // Needed for CServer
  38 #include "ServerList.h"         // Needed for theApp->serverlist
  39 #include "Statistics.h"         // Needed for theStats
  40 #include "ObservableQueue.h"// Needed for CQueueObserver
  41 #include <common/Format.h>
  42 #include "Logger.h"                     // Needed for AddLogLineM/...
  43 #include "Packet.h"                     // Needed for CPacket
  44 #include "GuiEvents.h"          // Needed for Notify_*
  45
  46
  47 #ifndef AMULE_DAEMON
  48 #include "amuleDlg.h"           // Needed for CamuleDlg
  49 #include "SearchDlg.h"          // Needed for CSearchDlg
  50 #endif
  51
  52 #include "kademlia/kademlia/Kademlia.h"
  53 #include "kademlia/kademlia/Search.h"
  54
  55 #include "SearchExpr.h"
  56 #include "Scanner.h.in"
  57
  58
  59 extern int yyparse();
  60 extern int yyerror(const char* errstr);
  61 extern int yyerror(wxString errstr);
  62
  63 static wxString s_strCurKadKeyword;
  64
  65 static CSearchExpr _SearchExpr;
  66
  67 wxArrayString _astrParserErrors;
  68
  69
  70 // Helper function for lexer.
  71 void ParsedSearchExpression(const CSearchExpr* pexpr)
  72 {
  73         int iOpAnd = 0;
  74         int iOpOr = 0;
  75         int iOpNot = 0;
  76
  77         for (unsigned int i = 0; i < pexpr->m_aExpr.Count(); i++) {
  78                 wxString str(pexpr->m_aExpr[i]);
  79                 if (str == SEARCHOPTOK_AND) {
  80                         iOpAnd++;
  81                 } else if (str == SEARCHOPTOK_OR) {
  82                         iOpOr++;
  83                 } else if (str == SEARCHOPTOK_NOT) {
  84                         iOpNot++;
  85                 }
  86         }
  87
  88         // this limit (+ the additional operators which will be added later) has to match the limit in 'CreateSearchExpressionTree'
  89         //      +1 Type (Audio, Video)
  90         //      +1 MinSize
  91         //      +1 MaxSize
  92         //      +1 Avail
  93         //      +1 Extension
  94         //      +1 Complete sources
  95         //      +1 Codec
  96         //      +1 Bitrate
  97         //      +1 Length
  98         //      +1 Title
  99         //      +1 Album
 100         //      +1 Artist
 101         // ---------------
 102         //  12
 103         if (iOpAnd + iOpOr + iOpNot > 10) {
 104                 yyerror(wxT("Search expression is too complex"));
 105         }
 106
 107         _SearchExpr.m_aExpr.Empty();
 108
 109         // optimize search expression, if no OR nor NOT specified
 110         if (iOpAnd > 0 && iOpOr == 0 && iOpNot == 0) {
 111                 wxString strAndTerms;
 112                 for (unsigned int i = 0; i < pexpr->m_aExpr.Count(); i++) {
 113                         if (pexpr->m_aExpr[i] != SEARCHOPTOK_AND) {
 114                                 // Minor optimization: Because we added the Kad keyword to the boolean search expression,
 115                                 // we remove it here (and only here) again because we know that the entire search expression
 116                                 // does only contain (implicit) ANDed strings.
 117                                 if (pexpr->m_aExpr[i] != s_strCurKadKeyword) {
 118                                         if (!strAndTerms.IsEmpty()) {
 119                                                 strAndTerms += ' ';
 120                                         }
 121                                         strAndTerms += pexpr->m_aExpr[i];
 122                                 }
 123                         }
 124                 }
 125                 wxASSERT( _SearchExpr.m_aExpr.Count() == 0);
 126                 _SearchExpr.m_aExpr.Add(strAndTerms);
 127         } else {
 128                 if (pexpr->m_aExpr.GetCount() != 1 || pexpr->m_aExpr[0] != s_strCurKadKeyword)
 129                         _SearchExpr.Add(pexpr);
 130         }
 131 }
 132
 133
 134 //! Helper class for packet creation
 135 class CSearchExprTarget
 136 {
 137 public:
 138         CSearchExprTarget(CMemFile* pData, EUtf8Str eStrEncode, bool supports64bit, bool& using64bit)
 139                 : m_data(pData),
 140                   m_eStrEncode(eStrEncode),
 141                   m_supports64bit(supports64bit),
 142                   m_using64bit(using64bit)
 143         {
 144                 m_using64bit = false;
 145         }
 146
 147         void WriteBooleanAND()
 148         {
 149                 m_data->WriteUInt8(0);                          // boolean operator parameter type
 150                 m_data->WriteUInt8(0x00);                       // "AND"
 151         }
 152
 153         void WriteBooleanOR()
 154         {
 155                 m_data->WriteUInt8(0);                          // boolean operator parameter type
 156                 m_data->WriteUInt8(0x01);                       // "OR"
 157         }
 158
 159         void WriteBooleanNOT()
 160         {
 161                 m_data->WriteUInt8(0);                          // boolean operator parameter type
 162                 m_data->WriteUInt8(0x02);                       // "NOT"
 163         }
 164
 165         void WriteMetaDataSearchParam(const wxString& rstrValue)
 166         {
 167                 m_data->WriteUInt8(1);                          // string parameter type
 168                 m_data->WriteString(rstrValue, m_eStrEncode); // string value
 169         }
 170
 171         void WriteMetaDataSearchParam(uint8 uMetaTagID, const wxString& rstrValue)
 172         {
 173                 m_data->WriteUInt8(2);                          // string parameter type
 174                 m_data->WriteString(rstrValue, m_eStrEncode); // string value
 175                 m_data->WriteUInt16(sizeof(uint8));     // meta tag ID length
 176                 m_data->WriteUInt8(uMetaTagID);         // meta tag ID name
 177         }
 178
 179         void WriteMetaDataSearchParamASCII(uint8 uMetaTagID, const wxString& rstrValue)
 180         {
 181                 m_data->WriteUInt8(2);                          // string parameter type
 182                 m_data->WriteString(rstrValue, utf8strNone); // string value
 183                 m_data->WriteUInt16(sizeof(uint8));     // meta tag ID length
 184                 m_data->WriteUInt8(uMetaTagID);         // meta tag ID name
 185         }
 186
 187         void WriteMetaDataSearchParam(const wxString& pszMetaTagID, const wxString& rstrValue)
 188         {
 189                 m_data->WriteUInt8(2);                          // string parameter type
 190                 m_data->WriteString(rstrValue, m_eStrEncode); // string value
 191                 m_data->WriteString(pszMetaTagID);      // meta tag ID
 192         }
 193
 194         void WriteMetaDataSearchParam(uint8_t uMetaTagID, uint8_t uOperator, uint64_t value)
 195         {
 196                 bool largeValue = value > wxULL(0xFFFFFFFF);
 197                 if (largeValue && m_supports64bit) {
 198                         m_using64bit = true;
 199                         m_data->WriteUInt8(8);          // numeric parameter type (int64)
 200                         m_data->WriteUInt64(value);     // numeric value
 201                 } else {
 202                         if (largeValue) {
 203                                 value = 0xFFFFFFFFu;
 204                         }
 205                         m_data->WriteUInt8(3);          // numeric parameter type (int32)
 206                         m_data->WriteUInt32(value);     // numeric value
 207                 }
 208                 m_data->WriteUInt8(uOperator);          // comparison operator
 209                 m_data->WriteUInt16(sizeof(uint8));     // meta tag ID length
 210                 m_data->WriteUInt8(uMetaTagID);         // meta tag ID name
 211         }
 212
 213         void WriteMetaDataSearchParam(const wxString& pszMetaTagID, uint8_t uOperator, uint64_t value)
 214         {
 215                 bool largeValue = value > wxULL(0xFFFFFFFF);
 216                 if (largeValue && m_supports64bit) {
 217                         m_using64bit = true;
 218                         m_data->WriteUInt8(8);          // numeric parameter type (int64)
 219                         m_data->WriteUInt64(value);     // numeric value
 220                 } else {
 221                         if (largeValue) {
 222                                 value = 0xFFFFFFFFu;
 223                         }
 224                         m_data->WriteUInt8(3);          // numeric parameter type (int32)
 225                         m_data->WriteUInt32(value);     // numeric value
 226                 }
 227                 m_data->WriteUInt8(uOperator);          // comparison operator
 228                 m_data->WriteString(pszMetaTagID);      // meta tag ID
 229         }
 230
 231 protected:
 232         CMemFile* m_data;
 233         EUtf8Str m_eStrEncode;
 234         bool m_supports64bit;
 235         bool& m_using64bit;
 236 };
 237
 238
 239
 240
 241 ///////////////////////////////////////////////////////////
 242 // CSearchList
 243
 244 BEGIN_EVENT_TABLE(CSearchList, wxEvtHandler)
 245         EVT_MULE_TIMER(wxID_ANY, CSearchList::OnGlobalSearchTimer)
 246 END_EVENT_TABLE()
 247
 248
 249 CSearchList::CSearchList()
 250         : m_searchTimer(this, 0 /* Timer-id doesn't matter. */ ),
 251           m_searchType(LocalSearch),
 252           m_searchInProgress(false),
 253           m_currentSearch(-1),
 254           m_searchPacket(NULL),
 255           m_64bitSearchPacket(false)
 256 {
 257 }
 258
 259
 260 CSearchList::~CSearchList()
 261 {
 262         StopGlobalSearch();
 263
 264         while (!m_results.empty()) {
 265                 RemoveResults(m_results.begin()->first);
 266         }
 267 }
 268
 269
 270 void CSearchList::RemoveResults(long searchID)
 271 {
 272         // A non-existant search id will just be ignored
 273         Kademlia::CSearchManager::StopSearch(searchID, true);
 274
 275         ResultMap::iterator it = m_results.find(searchID);
 276         if ( it != m_results.end() ) {
 277                 CSearchResultList& list = it->second;
 278
 279                 for (size_t i = 0; i < list.size(); ++i) {
 280                         delete list.at(i);
 281                 }
 282
 283                 m_results.erase( it );
 284         }
 285 }
 286
 287
 288 wxString CSearchList::StartNewSearch(uint32* searchID, SearchType type, const CSearchParams& params)
 289 {
 290         // Check that we can actually perform the specified desired search.
 291         if ((type == KadSearch) && !Kademlia::CKademlia::IsRunning()) {
 292                 return _("Kad search can't be done if Kad is not running");
 293         } else if ((type != KadSearch) && !theApp->IsConnectedED2K()) {
 294                 return _("eD2k search can't be done if eD2k is not connected");
 295         }
 296
 297         if (params.typeText != ED2KFTSTR_PROGRAM) {
 298                 if (params.typeText.CmpNoCase(wxT("Any"))) {
 299                         m_resultType = params.typeText;
 300                 } else {
 301                         m_resultType.Clear();
 302                 }
 303         } else {
 304                 // No check is to be made on returned results if the
 305                 // type is 'Programs', since this returns multiple types.
 306                 m_resultType.Clear();
 307         }
 308
 309         bool supports64bit = type == KadSearch ? true : theApp->serverconnect->GetCurrentServer() != NULL && (theApp->serverconnect->GetCurrentServer()->GetTCPFlags() & SRV_TCPFLG_LARGEFILES);
 310         bool packetUsing64bit;
 311
 312         // This MemFile is automatically free'd
 313         CMemFilePtr data = CreateSearchData(params, type, supports64bit, packetUsing64bit);
 314
 315         if (data.get() == NULL) {
 316                 wxASSERT(_astrParserErrors.Count());
 317                 wxString error;
 318
 319                 for (unsigned int i = 0; i < _astrParserErrors.Count(); ++i) {
 320                         error += _astrParserErrors[i] + wxT("\n");
 321                 }
 322
 323                 return error;
 324         }
 325
 326         m_searchType = type;
 327         if (type == KadSearch) {
 328                 try {
 329                         if (*searchID == 0xffffffff) {
 330                                 Kademlia::CSearchManager::StopSearch(0xffffffff, false);
 331                         }
 332
 333                         // searchstring will get tokenized there
 334                         // The tab must be created with the Kad search ID, so seardhID is updated.
 335                         Kademlia::CSearch* search = Kademlia::CSearchManager::PrepareFindKeywords(
 336                                                                                  params.searchString, data->GetLength(), data->GetRawBuffer(), *searchID);
 337
 338                         *searchID = search->GetSearchID();
 339                 } catch (const wxString& what) {
 340                         AddLogLineM(true, what);
 341                         return _("Unexpected error while attempting Kad search: ") + what;
 342                 }
 343         } else {
 344                 // This is an ed2k search, local or global
 345                 m_currentSearch = *(searchID);
 346                 m_searchInProgress = true;
 347
 348                 CPacket* searchPacket = new CPacket(*data.get(), OP_EDONKEYPROT, OP_SEARCHREQUEST);
 349
 350                 theStats::AddUpOverheadServer(searchPacket->GetPacketSize());
 351                 theApp->serverconnect->SendPacket(searchPacket, (type == LocalSearch));
 352
 353                 if (type == GlobalSearch) {
 354                         m_searchPacket = searchPacket;
 355                         m_64bitSearchPacket = packetUsing64bit;
 356                         m_searchPacket->SetOpCode(OP_GLOBSEARCHREQ); // will be changed later when actually sending the packet!!
 357                 }
 358         }
 359
 360         return wxEmptyString;
 361 }
 362
 363
 364 void CSearchList::LocalSearchEnd()
 365 {
 366         if (m_searchType == GlobalSearch) {
 367                 wxCHECK_RET(m_searchPacket, wxT("Global search, but no packet"));
 368
 369                 // Ensure that every global search starts over.
 370                 theApp->serverlist->RemoveObserver(&m_serverQueue);
 371                 m_searchTimer.Start(750);
 372         } else {
 373                 m_searchInProgress = false;
 374                 Notify_SearchLocalEnd();
 375         }
 376 }
 377
 378
 379 uint32 CSearchList::GetSearchProgress() const
 380 {
 381         if (m_searchInProgress == false) {
 382                 // No search, no progress ;)
 383                 return 0;
 384         }
 385
 386         switch (m_searchType) {
 387                 case LocalSearch:
 388                         return 0xffff;
 389
 390                 case GlobalSearch:
 391                         return 100 - (m_serverQueue.GetRemaining() * 100)
 392                                         / theApp->serverlist->GetServerCount();
 393
 394                 case KadSearch:
 395                         // We cannot measure the progress of Kad searches.
 396                         return 0;
 397
 398                 default:
 399                         wxCHECK(false, 0);
 400         }
 401 }
 402
 403
 404 void CSearchList::OnGlobalSearchTimer(CTimerEvent& WXUNUSED(evt))
 405 {
 406         // Ensure that the server-queue contains the current servers.
 407         if (m_searchPacket == NULL) {
 408                 // This was a pending event, handled after 'Stop' was pressed.
 409                 return;
 410         } else if (!m_serverQueue.IsActive()) {
 411                 theApp->serverlist->AddObserver(&m_serverQueue);
 412         }
 413
 414         // UDP requests must not be sent to this server.
 415         const CServer* localServer = theApp->serverconnect->GetCurrentServer();
 416         if (localServer) {
 417                 uint32 localIP = localServer->GetIP();
 418                 uint16 localPort = localServer->GetPort();
 419                 while (m_serverQueue.GetRemaining()) {
 420                         CServer* server = m_serverQueue.GetNext();
 421
 422                         // Compare against the currently connected server.
 423                         if ((server->GetPort() == localPort) && (server->GetIP() == localIP)) {
 424                                 // We've already requested from the local server.
 425                                 continue;
 426                         } else {
 427                                 if (server->SupportsLargeFilesUDP() && (server->GetUDPFlags() & SRV_UDPFLG_EXT_GETFILES)) {
 428                                         CMemFile data(50);
 429                                         uint32_t tagCount = 1;
 430                                         data.WriteUInt32(tagCount);
 431                                         CTagVarInt flags(CT_SERVER_UDPSEARCH_FLAGS, SRVCAP_UDP_NEWTAGS_LARGEFILES);
 432                                         flags.WriteNewEd2kTag(&data);
 433                                         CPacket *extSearchPacket = new CPacket(OP_GLOBSEARCHREQ3, m_searchPacket->GetPacketSize() + (uint32_t)data.GetLength(), OP_EDONKEYPROT);
 434                                         extSearchPacket->CopyToDataBuffer(0, data.GetRawBuffer(), data.GetLength());
 435                                         extSearchPacket->CopyToDataBuffer(data.GetLength(), m_searchPacket->GetDataBuffer(), m_searchPacket->GetPacketSize());
 436                                         theStats::AddUpOverheadServer(extSearchPacket->GetPacketSize());
 437                                         theApp->serverconnect->SendUDPPacket(extSearchPacket, server, true);
 438                                         AddDebugLogLineM(false, logServerUDP, wxT("Sending OP_GLOBSEARCHREQ3 to server ") + Uint32_16toStringIP_Port(server->GetIP(), server->GetPort()));
 439                                 } else if (server->GetUDPFlags() & SRV_UDPFLG_EXT_GETFILES) {
 440                                         if (!m_64bitSearchPacket || server->SupportsLargeFilesUDP()) {
 441                                                 m_searchPacket->SetOpCode(OP_GLOBSEARCHREQ2);
 442                                                 AddDebugLogLineM(false, logServerUDP, wxT("Sending OP_GLOBSEARCHREQ2 to server ") + Uint32_16toStringIP_Port(server->GetIP(), server->GetPort()));
 443                                                 theStats::AddUpOverheadServer(m_searchPacket->GetPacketSize());
 444                                                 theApp->serverconnect->SendUDPPacket(m_searchPacket, server, false);
 445                                         } else {
 446                                                 AddDebugLogLineM(false, logServerUDP, wxT("Skipped UDP search on server ") + Uint32_16toStringIP_Port(server->GetIP(), server->GetPort()) + wxT(": No large file support"));
 447                                         }
 448                                 } else {
 449                                         if (!m_64bitSearchPacket || server->SupportsLargeFilesUDP()) {
 450                                                 m_searchPacket->SetOpCode(OP_GLOBSEARCHREQ);
 451                                                 AddDebugLogLineM(false, logServerUDP, wxT("Sending OP_GLOBSEARCHREQ to server ") + Uint32_16toStringIP_Port(server->GetIP(), server->GetPort()));
 452                                                 theStats::AddUpOverheadServer(m_searchPacket->GetPacketSize());
 453                                                 theApp->serverconnect->SendUDPPacket(m_searchPacket, server, false);
 454                                         } else {
 455                                                 AddDebugLogLineM(false, logServerUDP, wxT("Skipped UDP search on server ") + Uint32_16toStringIP_Port(server->GetIP(), server->GetPort()) + wxT(": No large file support"));
 456                                         }
 457                                 }
 458                                 CoreNotify_Search_Update_Progress(GetSearchProgress());
 459                                 return;
 460                         }
 461                 }
 462         }
 463         // No more servers left to ask.
 464         StopGlobalSearch();
 465 }
 466
 467
 468 void CSearchList::ProcessSharedFileList(const byte* in_packet, uint32 size,
 469         CUpDownClient* sender, bool *moreResultsAvailable, const wxString& directory)
 470 {
 471         wxCHECK_RET(sender, wxT("No sender in search-results from client."));
 472
 473         long searchID = reinterpret_cast<wxUIntPtr>(sender);
 474
 475 #ifndef AMULE_DAEMON
 476         if (!theApp->amuledlg->m_searchwnd->CheckTabNameExists(sender->GetUserName())) {
 477                 theApp->amuledlg->m_searchwnd->CreateNewTab(sender->GetUserName() + wxT(" (0)"), searchID);
 478         }
 479 #endif
 480
 481         const CMemFile packet(in_packet, size);
 482         uint32 results = packet.ReadUInt32();
 483         bool unicoded = (sender->GetUnicodeSupport() != utf8strNone);
 484         for (unsigned int i = 0; i != results; ++i){
 485                 CSearchFile* toadd = new CSearchFile(packet, unicoded, searchID, 0, 0, directory);
 486                 if (sender){
 487                         toadd->SetClientID(sender->GetUserIDHybrid());
 488                         toadd->SetClientPort(sender->GetUserPort());
 489                 }
 490
 491                 AddToList(toadd, true);
 492         }
 493
 494         if (moreResultsAvailable)
 495                 *moreResultsAvailable = false;
 496
 497         int iAddData = (int)(packet.GetLength() - packet.GetPosition());
 498         if (iAddData == 1) {
 499                 uint8 ucMore = packet.ReadUInt8();
 500                 if (ucMore == 0x00 || ucMore == 0x01){
 501                         if (moreResultsAvailable) {
 502                                 *moreResultsAvailable = (ucMore == 1);
 503                         }
 504                 }
 505         }
 506 }
 507
 508
 509 void CSearchList::ProcessSearchAnswer(const byte* in_packet, uint32 size, bool optUTF8, uint32 WXUNUSED(serverIP), uint16 WXUNUSED(serverPort))
 510 {
 511         CMemFile packet(in_packet,size);
 512
 513         uint32 results = packet.ReadUInt32();
 514         for (unsigned int i = 0; i != results; ++i) {
 515                 AddToList(new CSearchFile(packet, optUTF8, m_currentSearch));
 516         }
 517 }
 518
 519
 520 void CSearchList::ProcessUDPSearchAnswer(const CMemFile& packet, bool optUTF8, uint32 serverIP, uint16 serverPort)
 521 {
 522         AddToList(new CSearchFile(packet, optUTF8, m_currentSearch, serverIP, serverPort));
 523 }
 524
 525
 526 bool CSearchList::AddToList(CSearchFile* toadd, bool clientResponse)
 527 {
 528         const uint64 fileSize = toadd->GetFileSize();
 529         // If filesize is 0, or file is too large for the network, drop it
 530         if ((fileSize == 0) || (fileSize > MAX_FILE_SIZE)) {
 531                 AddDebugLogLineM(false, logSearch,
 532                                 CFormat(wxT("Dropped result with filesize %u: %s"))
 533                                         % fileSize
 534                                         % toadd->GetFileName());
 535
 536                 delete toadd;
 537                 return false;
 538         }
 539
 540         // If the result was not the type the user wanted, drop it.
 541         if ((clientResponse == false) && !m_resultType.IsEmpty()) {
 542                 if (GetFileTypeByName(toadd->GetFileName()) != m_resultType) {
 543                         AddDebugLogLineM( false, logSearch,
 544                                 CFormat( wxT("Dropped result type %s != %s, file %s") )
 545                                         % GetFileTypeByName(toadd->GetFileName())
 546                                         % m_resultType
 547                                         % toadd->GetFileName());
 548
 549                         delete toadd;
 550                         return false;
 551                 }
 552         }
 553
 554
 555         // Get, or implictly create, the map of results for this search
 556         CSearchResultList& results = m_results[toadd->GetSearchID()];
 557
 558         for (size_t i = 0; i < results.size(); ++i) {
 559                 CSearchFile* item = results.at(i);
 560
 561                 if ((toadd->GetFileHash() == item->GetFileHash()) && (toadd->GetFileSize() == item->GetFileSize())) {
 562                         AddDebugLogLineM(false, logSearch, CFormat(wxT("Received duplicate results for '%s' : %s")) % item->GetFileName() % item->GetFileHash().Encode());
 563                         // Add the child, possibly updating the parents filename.
 564                         item->AddChild(toadd);
 565                         Notify_Search_Update_Sources(item);
 566                         return true;
 567                 }
 568         }
 569
 570         AddDebugLogLineM(false, logSearch,
 571                 CFormat(wxT("Added new result '%s' : %s"))
 572                         % toadd->GetFileName() % toadd->GetFileHash().Encode());
 573
 574         // New unique result, simply add and display.
 575         results.push_back(toadd);
 576         Notify_Search_Add_Result(toadd);
 577
 578         return true;
 579 }
 580
 581
 582 const CSearchResultList& CSearchList::GetSearchResults(long searchID) const
 583 {
 584         ResultMap::const_iterator it = m_results.find(searchID);
 585         if (it != m_results.end()) {
 586                 return it->second;
 587         }
 588
 589         // TODO: Should we assert in this case?
 590         static CSearchResultList list;
 591         return list;
 592 }
 593
 594
 595 void CSearchList::AddFileToDownloadByHash(const CMD4Hash& hash, uint8 cat)
 596 {
 597         ResultMap::iterator it = m_results.begin();
 598         for ( ; it != m_results.end(); ++it ) {
 599                 CSearchResultList& list = it->second;
 600
 601                 for ( unsigned int i = 0; i < list.size(); ++i ) {
 602                         if ( list[i]->GetFileHash() == hash ) {
 603                                 CoreNotify_Search_Add_Download( list[i], cat );
 604
 605                                 return;
 606                         }
 607                 }
 608         }
 609 }
 610
 611
 612 void CSearchList::StopGlobalSearch()
 613 {
 614         m_searchTimer.Stop();
 615
 616         m_currentSearch = -1;
 617         delete m_searchPacket;
 618         m_searchPacket = NULL;
 619         m_searchInProgress = false;
 620
 621         CoreNotify_Search_Update_Progress(0xffff);
 622 }
 623
 624
 625 CSearchList::CMemFilePtr CSearchList::CreateSearchData(const CSearchParams& params, SearchType type, bool supports64bit, bool& packetUsing64bit)
 626 {
 627         // Count the number of used parameters
 628         unsigned int parametercount = 0;
 629         if ( !params.typeText.IsEmpty() )       ++parametercount;
 630         if ( params.minSize > 0 )                       ++parametercount;
 631         if ( params.maxSize > 0 )                       ++parametercount;
 632         if ( params.availability > 0 )          ++parametercount;
 633         if ( !params.extension.IsEmpty() )      ++parametercount;
 634
 635         wxString typeText = params.typeText;
 636         if (typeText == ED2KFTSTR_ARCHIVE){
 637                 // eDonkeyHybrid 0.48 uses type "Pro" for archives files
 638                 // www.filedonkey.com uses type "Pro" for archives files
 639                 typeText = ED2KFTSTR_PROGRAM;
 640         } else if (typeText == ED2KFTSTR_CDIMAGE){
 641                 // eDonkeyHybrid 0.48 uses *no* type for iso/nrg/cue/img files
 642                 // www.filedonkey.com uses type "Pro" for CD-image files
 643                 typeText = ED2KFTSTR_PROGRAM;
 644         }
 645
 646         // Must write parametercount - 1 parameter headers
 647         CMemFilePtr data(new CMemFile(100));
 648
 649         _astrParserErrors.Empty();
 650         _SearchExpr.m_aExpr.Empty();
 651
 652         LexInit(params.searchString);
 653         int iParseResult = yyparse();
 654         LexFree();
 655
 656 #ifdef __DEBUG__
 657         printf("Search parsing result for \"%s\": %i\n",
 658                 (const char*)unicode2UTF8(params.searchString),iParseResult);
 659 #endif
 660         if (_astrParserErrors.Count() > 0) {
 661                 for (unsigned int i=0; i < _astrParserErrors.Count(); ++i) {
 662                         printf("Error %u: %s\n",i,(const char*)unicode2UTF8(_astrParserErrors[i]));
 663                 }
 664
 665                 return CMemFilePtr(NULL);
 666         }
 667
 668         if (iParseResult != 0) {
 669                 _astrParserErrors.Add(wxString::Format(wxT("Undefined error %i on search expression"),iParseResult));
 670
 671                 return CMemFilePtr(NULL);
 672         }
 673
 674         #ifdef __DEBUG__
 675         printf("Search expression: ");
 676         for (unsigned int i = 0; i < _SearchExpr.m_aExpr.Count(); i++){
 677                 printf("%s ",(const char*)unicode2char(_SearchExpr.m_aExpr[i]));
 678         }
 679         printf("\nExpression count: %i\n",(int)_SearchExpr.m_aExpr.GetCount());
 680         #endif
 681
 682         parametercount += _SearchExpr.m_aExpr.GetCount();
 683
 684         #ifdef __DEBUG__
 685         printf("Parameters: %i\n",parametercount);
 686         #endif
 687
 688         /* Leave the unicode comment there, please... */
 689         CSearchExprTarget target(data.get(), true /*I assume everyone is unicoded */ ? utf8strRaw : utf8strNone, supports64bit, packetUsing64bit);
 690
 691         unsigned int iParameterCount = 0;
 692         if (_SearchExpr.m_aExpr.GetCount() <= 1) {
 693                 // lugdunummaster requested that searchs without OR or NOT operators,
 694                 // and hence with no more expressions than the string itself, be sent
 695                 // using a series of ANDed terms, intersecting the ANDs on the terms
 696                 // (but prepending them) instead of putting the boolean tree at the start
 697                 // like other searches. This type of search is supposed to take less load
 698                 // on servers. Go figure.
 699                 //
 700                 // input:      "a" AND min=1 AND max=2
 701                 // instead of: AND AND "a" min=1 max=2
 702                 // we use:     AND "a" AND min=1 max=2
 703
 704                 if (_SearchExpr.m_aExpr.GetCount() > 0) {
 705                         if (++iParameterCount < parametercount) {
 706                                 target.WriteBooleanAND();
 707                         }
 708                         target.WriteMetaDataSearchParam(_SearchExpr.m_aExpr[0]);
 709                 }
 710
 711                 if (!typeText.IsEmpty()) {
 712                         if (++iParameterCount < parametercount) {
 713                                 target.WriteBooleanAND();
 714                         }
 715                         // Type is always ascii string
 716                         target.WriteMetaDataSearchParamASCII(FT_FILETYPE, typeText);
 717                 }
 718
 719                 if (params.minSize > 0) {
 720                         if (++iParameterCount < parametercount) {
 721                                 target.WriteBooleanAND();
 722                         }
 723                         target.WriteMetaDataSearchParam(FT_FILESIZE, ED2K_SEARCH_OP_GREATER, params.minSize);
 724                 }
 725
 726                 if (params.maxSize > 0){
 727                         if (++iParameterCount < parametercount) {
 728                                 target.WriteBooleanAND();
 729                         }
 730                         target.WriteMetaDataSearchParam(FT_FILESIZE, ED2K_SEARCH_OP_LESS, params.maxSize);
 731                 }
 732
 733                 if (params.availability > 0){
 734                         if (++iParameterCount < parametercount) {
 735                                 target.WriteBooleanAND();
 736                         }
 737                         target.WriteMetaDataSearchParam(FT_SOURCES, ED2K_SEARCH_OP_GREATER, params.availability);
 738                 }
 739
 740                 if (!params.extension.IsEmpty()){
 741                         if (++iParameterCount < parametercount) {
 742                                 target.WriteBooleanAND();
 743                         }
 744                         target.WriteMetaDataSearchParam(FT_FILEFORMAT, params.extension);
 745                 }
 746
 747                 //#warning TODO - I keep this here, ready if we ever allow such searches...
 748                 #if 0
 749                 if (complete > 0){
 750                         if (++iParameterCount < parametercount) {
 751                                 target.WriteBooleanAND();
 752                         }
 753                         target.WriteMetaDataSearchParam(FT_COMPLETE_SOURCES, ED2K_SEARCH_OP_GREATER, complete);
 754                 }
 755
 756                 if (minBitrate > 0){
 757                         if (++iParameterCount < parametercount) {
 758                                 target.WriteBooleanAND();
 759                         }
 760                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_BITRATE : FT_ED2K_MEDIA_BITRATE, ED2K_SEARCH_OP_GREATER, minBitrate);
 761                 }
 762
 763                 if (minLength > 0){
 764                         if (++iParameterCount < parametercount) {
 765                                 target.WriteBooleanAND();
 766                         }
 767                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_LENGTH : FT_ED2K_MEDIA_LENGTH, ED2K_SEARCH_OP_GREATER, minLength);
 768                 }
 769
 770                 if (!codec.IsEmpty()){
 771                         if (++iParameterCount < parametercount) {
 772                                 target.WriteBooleanAND();
 773                         }
 774                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_CODEC : FT_ED2K_MEDIA_CODEC, codec);
 775                 }
 776
 777                 if (!title.IsEmpty()){
 778                         if (++iParameterCount < parametercount) {
 779                                 target.WriteBooleanAND();
 780                         }
 781                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_TITLE : FT_ED2K_MEDIA_TITLE, title);
 782                 }
 783
 784                 if (!album.IsEmpty()){
 785                         if (++iParameterCount < parametercount) {
 786                                 target.WriteBooleanAND();
 787                         }
 788                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_ALBUM : FT_ED2K_MEDIA_ALBUM, album);
 789                 }
 790
 791                 if (!artist.IsEmpty()){
 792                         if (++iParameterCount < parametercount) {
 793                                 target.WriteBooleanAND();
 794                         }
 795                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_ARTIST : FT_ED2K_MEDIA_ARTIST, artist);
 796                 }
 797                 #endif // 0
 798
 799                 // If this assert fails... we're seriously fucked up
 800
 801                 wxASSERT( iParameterCount == parametercount );
 802
 803         } else {
 804                 if (!params.extension.IsEmpty()) {
 805                         if (++iParameterCount < parametercount) {
 806                                 target.WriteBooleanAND();
 807                         }
 808                 }
 809
 810                 if (params.availability > 0) {
 811                         if (++iParameterCount < parametercount) {
 812                                 target.WriteBooleanAND();
 813                         }
 814                 }
 815
 816                 if (params.maxSize > 0){
 817                         if (++iParameterCount < parametercount) {
 818                                 target.WriteBooleanAND();
 819                         }
 820                 }
 821
 822                 if (params.minSize > 0) {
 823                         if (++iParameterCount < parametercount) {
 824                                 target.WriteBooleanAND();
 825                         }
 826                 }
 827
 828                 if (!typeText.IsEmpty()){
 829                         if (++iParameterCount < parametercount) {
 830                                 target.WriteBooleanAND();
 831                         }
 832                 }
 833
 834                 //#warning TODO - same as above...
 835                 #if 0
 836                 if (complete > 0){
 837                         if (++iParameterCount < parametercount) {
 838                                 target.WriteBooleanAND();
 839                         }
 840                 }
 841
 842                 if (minBitrate > 0){
 843                         if (++iParameterCount < parametercount) {
 844                                 target.WriteBooleanAND();
 845                         }
 846                 }
 847
 848                 if (minLength > 0) {
 849                         if (++iParameterCount < parametercount) {
 850                                 target.WriteBooleanAND();
 851                         }
 852                 }
 853
 854                 if (!codec.IsEmpty()){
 855                         if (++iParameterCount < parametercount) {
 856                                 target.WriteBooleanAND();
 857                         }
 858                 }
 859
 860                 if (!title.IsEmpty()){
 861                         if (++iParameterCount < parametercount) {
 862                                 target.WriteBooleanAND();
 863                         }
 864                 }
 865
 866                 if (!album.IsEmpty()) {
 867                         if (++iParameterCount < parametercount) {
 868                                 target.WriteBooleanAND();
 869                         }
 870                 }
 871
 872                 if (!artist.IsEmpty()) {
 873                         if (++iParameterCount < parametercount) {
 874                                 target.WriteBooleanAND();
 875                         }
 876                 }
 877                 #endif // 0
 878
 879                 // As above, if this fails, we're seriously fucked up.
 880                 wxASSERT( iParameterCount + _SearchExpr.m_aExpr.GetCount() == parametercount );
 881
 882                 for (unsigned int j = 0; j < _SearchExpr.m_aExpr.GetCount(); ++j) {
 883                         if (_SearchExpr.m_aExpr[j] == SEARCHOPTOK_AND) {
 884                                 target.WriteBooleanAND();
 885                         } else if (_SearchExpr.m_aExpr[j] == SEARCHOPTOK_OR) {
 886                                 target.WriteBooleanOR();
 887                         } else if (_SearchExpr.m_aExpr[j] == SEARCHOPTOK_NOT) {
 888                                 target.WriteBooleanNOT();
 889                         } else {
 890                                 target.WriteMetaDataSearchParam(_SearchExpr.m_aExpr[j]);
 891                         }
 892                 }
 893
 894                 if (!params.typeText.IsEmpty()) {
 895                         // Type is always ASCII string
 896                         target.WriteMetaDataSearchParamASCII(FT_FILETYPE, params.typeText);
 897                 }
 898
 899                 if (params.minSize > 0) {
 900                         target.WriteMetaDataSearchParam(FT_FILESIZE, ED2K_SEARCH_OP_GREATER, params.minSize);
 901                 }
 902
 903                 if (params.maxSize > 0) {
 904                         target.WriteMetaDataSearchParam(FT_FILESIZE, ED2K_SEARCH_OP_LESS, params.maxSize);
 905                 }
 906
 907                 if (params.availability > 0) {
 908                         target.WriteMetaDataSearchParam(FT_SOURCES, ED2K_SEARCH_OP_GREATER, params.availability);
 909                 }
 910
 911                 if (!params.extension.IsEmpty()) {
 912                         target.WriteMetaDataSearchParam(FT_FILEFORMAT, params.extension);
 913                 }
 914
 915                 //#warning TODO - third and last warning of the same series.
 916                 #if 0
 917                 if (complete > 0) {
 918                         target.WriteMetaDataSearchParam(FT_COMPLETE_SOURCES, ED2K_SEARCH_OP_GREATER, pParams->uComplete);
 919                 }
 920
 921                 if (minBitrate > 0) {
 922                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_BITRATE : FT_ED2K_MEDIA_BITRATE, ED2K_SEARCH_OP_GREATER, minBitrate);
 923                 }
 924
 925                 if (minLength > 0) {
 926                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_LENGTH : FT_ED2K_MEDIA_LENGTH, ED2K_SEARCH_OP_GREATER, minLength);
 927                 }
 928
 929                 if (!codec.IsEmpty()) {
 930                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_CODEC : FT_ED2K_MEDIA_CODEC, codec);
 931                 }
 932
 933                 if (!title.IsEmpty()) {
 934                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_TITLE : FT_ED2K_MEDIA_TITLE, title);
 935                 }
 936
 937                 if (!album.IsEmpty()) {
 938                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_ALBUM : FT_ED2K_MEDIA_ALBUM, album);
 939                 }
 940
 941                 if (!artist.IsEmpty()) {
 942                         target.WriteMetaDataSearchParam(type == KadSearch ? TAG_MEDIA_ARTIST : FT_ED2K_MEDIA_ARTIST, artist);
 943                 }
 944
 945                 #endif // 0
 946         }
 947
 948         // Packet ready to go.
 949         return data;
 950 }
 951
 952
 953 void CSearchList::KademliaSearchKeyword(uint32_t searchID, const Kademlia::CUInt128 *fileID,
 954         const wxString& name, uint64_t size, const wxString& type, uint32_t kadPublishInfo, const TagPtrList& taglist)
 955 {
 956         EUtf8Str eStrEncode = utf8strRaw;
 957
 958         CMemFile temp(250);
 959         byte fileid[16];
 960         fileID->ToByteArray(fileid);
 961         temp.WriteHash(CMD4Hash(fileid));
 962
 963         temp.WriteUInt32(0);    // client IP
 964         temp.WriteUInt16(0);    // client port
 965
 966         // write tag list
 967         unsigned int uFilePosTagCount = temp.GetPosition();
 968         uint32 tagcount = 0;
 969         temp.WriteUInt32(tagcount); // dummy tag count, will be filled later
 970
 971         // standard tags
 972         CTagString tagName(FT_FILENAME, name);
 973         tagName.WriteTagToFile(&temp, eStrEncode);
 974         tagcount++;
 975
 976         CTagInt64 tagSize(FT_FILESIZE, size);
 977         tagSize.WriteTagToFile(&temp, eStrEncode);
 978         tagcount++;
 979
 980         if (!type.IsEmpty()) {
 981                 CTagString tagType(FT_FILETYPE, type);
 982                 tagType.WriteTagToFile(&temp, eStrEncode);
 983                 tagcount++;
 984         }
 985
 986         // Misc tags (bitrate, etc)
 987         for (TagPtrList::const_iterator it = taglist.begin(); it != taglist.end(); ++it) {
 988                 (*it)->WriteTagToFile(&temp,eStrEncode);
 989                 tagcount++;
 990         }
 991
 992         temp.Seek(uFilePosTagCount, wxFromStart);
 993         temp.WriteUInt32(tagcount);
 994
 995         temp.Seek(0, wxFromStart);
 996
 997         CSearchFile *tempFile = new CSearchFile(temp, (eStrEncode == utf8strRaw), searchID, 0, 0, wxEmptyString, true);
 998         tempFile->SetKadPublishInfo(kadPublishInfo);
 999
1000         AddToList(tempFile);
1001 }
1002
1003 // File_checked_for_headers