searchmanager.cpp

Kademlia---第第3代P2P原代码

		s->m_searchTerms = NULL;
		s->m_lenSearchTerms = 0;
		s->m_searchID = 0;
		m_searches[s->m_target] = s;
		s->go();
	} catch (...) {}
	return;
}

bool CSearchManager::alreadySearchingFor(const CUInt128 &target)
{
	bool retVal = false;
	m_critical.Lock();
	try
	{
		retVal = (m_searches.count(target) > 0);
	} catch (...) {}
	m_critical.Unlock();
	return retVal;
}

void CSearchManager::getWords(LPCSTR str, WordList *words)
{
	LPSTR s = (LPSTR)str;
	int len;
	CString word;
	while (strlen(s) > 0)
	{
		len = (int)strcspn(s, " ()[]{}<>,._-!?");
		if (len > 2)
		{
			word = s;
			word.Truncate(len);
			word.MakeLower();
			words->push_back(word);
		}
//		else if ((len == 0) && (s[0] == '-'))
//		{
//			len = (int)strcspn(s, " ");
//			if ((!strnicmp(s, SEARCH_IMAGE, len))
//			||  (!strnicmp(s, SEARCH_AUDIO, len))
//			||  (!strnicmp(s, SEARCH_VIDEO, len))
//			||  (!strnicmp(s, SEARCH_DOC  , len))
//			||  (!strnicmp(s, SEARCH_PRO  , len)))
//			{
//				word = s;
//				word.Truncate(len);
//				word.MakeLower();
//				words->push_back(word);
///			}
//			else 
//				len = 0;
//		}
		if (len < (int)strlen(s))
			len++;
		s += len;
	}
	if(words->size() > 1 && len == 3)
	{
		words->pop_back();
	}
}

// This may not be used and needs removed.
void CSearchManager::getWordsValid(LPCSTR str, WordList *words)
{
	LPSTR s = (LPSTR)str;
	int len;
	CString word;
	while (strlen(s) > 0)
	{
		len = (int)strcspn(s, " ()[]{}<>,._-!?");
		if (len > 2)
		{
			word = s;
			word.Truncate(len);
			word.MakeLower();
			words->push_back(word);
		}
		if (len < (int)strlen(s))
			len++;
		s += len;
	}
	if(words->size() > 1 && len == 3)
	{
		words->pop_back();
	}
}

void CSearchManager::jumpStart(void)
{
	time_t now = time(NULL);
	m_critical.Lock();
	try
	{
		SearchMap::iterator it = m_searches.begin(); 
		while (it != m_searches.end())
		{
			switch(it->second->getSearchTypes()){
				case CSearch::FILE:
				{
					if ((it->second->m_created + SEARCHFILE_LIFETIME < now)||(it->second->getCount() > SEARCHFILE_TOTAL))
					{
						delete it->second;
						it = m_searches.erase(it);
					}
					else
					{
						it->second->jumpStart();
						it++;
					}
					break;
				}
				case CSearch::KEYWORD:
				{
					if ((it->second->m_created + SEARCHKEYWORD_LIFETIME < now) ||(it->second->getCount() > SEARCHKEYWORD_TOTAL))
					{
						delete it->second;
						it = m_searches.erase(it);
					}
					else
					{
						it->second->jumpStart();
						it++;
					}
					break;
				}
				case CSearch::NODE:
				{
					if (it->second->m_created + SEARCHNODE_LIFETIME < now)
					{
						delete it->second;
						it = m_searches.erase(it);
					}
					else
					{
						it->second->jumpStart();
						it++;
					}
					break;
				}
				case CSearch::NODECOMPLETE:
				{
					if (it->second->m_created + SEARCHNODE_LIFETIME < now)
					{
						delete it->second;
						it = m_searches.erase(it);
					}
					else if ((it->second->m_created + SEARCHNODECOMP_LIFETIME < now) && (it->second->getCount() > SEARCHNODECOMP_TOTAL))
					{
						delete it->second;
						it = m_searches.erase(it);
					}
					else
					{
						it->second->jumpStart();
						it++;
					}
					break;
				}
				case CSearch::STOREFILE:
				{
					if ((it->second->m_created + SEARCHSTOREFILE_LIFETIME < now)||(it->second->getCount() > SEARCHSTOREFILE_TOTAL))
					{

						CKademlia::debugMsg("Publish stopped time cost %d, nodes:%d", now - it->second->m_created, it->second->getCount());

						delete it->second;
						it = m_searches.erase(it);
					}
					else
					{
						it->second->jumpStart();
						it++;
					}
					break;
				}
				case CSearch::STOREKEYWORD:
				{
					if ((it->second->m_created + SEARCHSTOREKEYWORD_LIFETIME < now)||(it->second->getCount() > SEARCHSTOREKEYWORD_TOTAL))
					{
						delete it->second;
						it = m_searches.erase(it);
					}
					else
					{
						it->second->jumpStart();
						it++;
					}
					break;
				}
				default:
				{
					if (it->second->m_created + SEARCH_LIFETIME < now)
					{
						delete it->second;
						it = m_searches.erase(it);
					}
					else
					{
						it->second->jumpStart();
						it++;
					}
					break;
				}
			}
		}
	} catch (...) {}
	m_critical.Unlock();
}

void CSearchManager::updateStats(void)
{
	uint8 m_totalFile = 0;
	uint8 m_totalStoreSrc = 0;
	uint8 m_totalStoreKey = 0;
	m_critical.Lock();
	try
	{
		SearchMap::iterator it = m_searches.begin(); 
		while (it != m_searches.end())
		{
			switch(it->second->getSearchTypes()){
				case CSearch::FILE:
				{
					m_totalFile++;
					it++;
					break;
				}
				case CSearch::STOREFILE:
				{
					m_totalStoreSrc++;
					it++;
					break;
				}
				case CSearch::STOREKEYWORD:
				{
					m_totalStoreKey++;
					it++;
					break;
				}
				default:
					it++;
					break;
			}
		}
	} catch (...) {}
	m_critical.Unlock();
	CPrefs *prefs = CKademlia::getPrefs();
	if(prefs != NULL)
	{
		prefs->setTotalFile(m_totalFile);
		prefs->setTotalStoreSrc(m_totalStoreSrc);
		prefs->setTotalStoreKey(m_totalStoreKey);
	}
}

void CSearchManager::processPublishResult(const CUInt128 &target)
{
	CSearch *s = NULL;
	m_critical.Lock();
	try
	{
		SearchMap::const_iterator it = m_searches.find(target);
		if (it != m_searches.end())
			s = it->second;
	} catch (...) {}
	m_critical.Unlock();

	if (s == NULL)
		return;
	s->m_count++;
}


void CSearchManager::processResponse(const CUInt128 &target, uint32 fromIP, uint16 fromPort, ContactList *results)
{
	CSearch *s = NULL;
	m_critical.Lock();
	try
	{
		SearchMap::const_iterator it = m_searches.find(target);
		if (it != m_searches.end())
			s = it->second;
	} catch (...) {}
	m_critical.Unlock();

	if (s == NULL)
	{
		ContactList::const_iterator it2;
		for (it2 = results->begin(); it2 != results->end(); it2++)
			delete (*it2);
		delete results;
		return;
	}
	else
		s->processResponse(target, fromIP, fromPort, results);
}

void CSearchManager::processResult(const CUInt128 &target, uint32 fromIP, uint16 fromPort, const CUInt128 &answer, TagList *info)
{
	CSearch *s = NULL;
	m_critical.Lock();
	try
	{
		SearchMap::const_iterator it = m_searches.find(target);
		if (it != m_searches.end())
			s = it->second;
	} catch (...) {}
	m_critical.Unlock();

	if (s == NULL)
	{
		TagList::const_iterator it;
		for (it = info->begin(); it != info->end(); it++)
			delete *it;
		delete info;
	}
	else
		s->processResult(target, fromIP, fromPort, answer, info);
}


// prepare file publish packet
CSearch* CSearchManager::prepareStoreFile(const CKadFile& file)
{
    CSearch *s = new CSearch;
    try
    {
        s->m_type = CSearch::STOREFILE;
        s->m_target = file.hash ;
        s->m_callbackID = NULL;

        // Write complete packet
        s->m_searchTerms = new byte[1024];
        CByteIO bio(s->m_searchTerms, 1024);
        bio.writeByte(OP_KADEMLIAHEADER);
        bio.writeByte(KADEMLIA_PUBLISH_REQ);
        bio.writeUInt128(s->m_target);
        bio.writeUInt16(1);

		CUInt128 id;
		CPrefs *prefs = CKademlia::getPrefs();
		ASSERT(prefs != NULL); 
		prefs->getClientID(&id);
        bio.writeUInt128(id);

        TagList taglist;
        taglist.push_back(new CTagUInt8(TAG_SOURCETYPE, 1));
        taglist.push_back(new CTagUInt16(TAG_SOURCEPORT, prefs->getTCPPort()));
        taglist.push_back(new CTagUInt32(TAG_TTH_TAIL_1, file.tth[0] ));
        taglist.push_back(new CTagUInt32(TAG_TTH_TAIL_2, file.tth[1] ));

        if(false == file.name.IsEmpty() && file.size > 0)
        {
            taglist.push_back(new CTagStr(TAG_NAME, file.name));
            taglist.push_back(new CTagUInt(TAG_SIZE, file.size));
        }

        bio.writeTagList(taglist);

        TagList::const_iterator it;
        for (it = taglist.begin(); it != taglist.end(); it++)
            delete *it;
        taglist.clear();

        s->m_lenSearchTerms = 1024 - bio.getAvailable();

        // NOTE: the following line does only work because this function is (currently) invoked from emule thread only!
        // If that function once gets called from a different thread, the handling with 'm_nextID' has to by synchronized.
        s->m_searchID = ++m_nextID;

    } catch (...) {
        delete s;
        s = NULL;
    }
    return s;
}


// prepare keyword publish packet
CSearch* CSearchManager::prepareStoreKeyword(const CUInt128 &id, const FileList& files)
{
    CSearch *s = new CSearch;
    try
    {
        s->m_type = CSearch::STOREKEYWORD;
        s->m_target = id;
        s->m_callbackID = NULL;

        // Write complete packet
        s->m_searchTerms = new byte[4096];
        CByteIO bio(s->m_searchTerms, 4096);
        bio.writeByte(OP_KADEMLIAHEADER);
        bio.writeByte(KADEMLIA_PUBLISH_REQ);
        bio.writeUInt128(s->m_target);

        bio.writeUInt16((uint16)files.size());


		CPrefs *prefs = CKademlia::getPrefs();
		ASSERT(prefs != NULL); 

        TagList taglist;
        for(FileList::const_iterator i = files.begin(); i != files.end(); i++)
        {
            bio.writeUInt128(i->hash);

			taglist.push_back(new CTagUInt16(TAG_SOURCEPORT, prefs->getTCPPort())); // TODO : NEED REMOVE
            taglist.push_back(new CTagStr(TAG_NAME, i->name));
            taglist.push_back(new CTagUInt(TAG_SIZE, i->size));
			taglist.push_back(new CTagUInt32(TAG_TTH_TAIL_1, i->tth[0] ));
			taglist.push_back(new CTagUInt32(TAG_TTH_TAIL_2, i->tth[1] ));

			if(i->type){
				char buf[32];
				wsprintf(buf, "FT%d", i->type);		// FT = File Type	
				taglist.push_back(new CTagStr(TAG_TYPE, buf));
			}
			bio.writeTagList(taglist);

            TagList::const_iterator it;
            for (it = taglist.begin(); it != taglist.end(); it++)
                delete *it;
            taglist.clear();
        }

        s->m_lenSearchTerms = 4096 - bio.getAvailable();

		//CMiscUtils::debugHexDump(s->m_searchTerms, s->m_lenSearchTerms);

		// NOTE: the following line does only work because this function is (currently) invoked from emule thread only!
        // If that function once gets called from a different thread, the handling with 'm_nextID' has to by synchronized.
        s->m_searchID = ++m_nextID;

    } catch (...) {
        delete s;
        s = NULL;
    }
    return s;
}