search.cpp

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

	{
		case FILE:
//			m_searchType = 1;
			processResultFile(target, fromIP, fromPort, answer, info);
			break;
		case KEYWORD:
//			m_searchType = 2;
			processResultKeyword(target, fromIP, fromPort, answer, info);
			break;
	}
	Kademlia::CKademlia::reportSearchRef(this);
}

void CSearch::processResultFile(const CUInt128 &target, uint32 fromIP, uint16 fromPort, const CUInt128 &answer, TagList *info)
{
	CString temp;
	uint8  type = 0;
	uint32 ip = 0;
	uint16 tcp = 0;
	uint16 udp = 0;
	uint32 serverip = 0;
	uint16 serverport = 0;
	CTag *tag;
	TagList::const_iterator it;
	uint32 _tth[2];

	for (it = info->begin(); it != info->end(); it++)
	{
		tag = *it;
		unsigned char name = tag->m_name[0];
		switch(name)
		{
			case FT_SOURCETYPE:
				type		= tag->GetInt();
				break;

			case FT_SOURCEIP:
				ip			= tag->GetInt();
				break;

			case FT_SOURCEPORT:
				tcp			= tag->GetInt();
				break;

			case FT_SOURCEUPORT:
				udp			= tag->GetInt();
				break;

			case FT_TTH_TAIL_1:
				_tth[0]	= tag->GetInt();
				break;

			case FT_TTH_TAIL_2:
				_tth[1]	= tag->GetInt();
				break;

			default:
				break;
		}

		delete tag;
	}
	delete info;

	// filter myself
	CPrefs *prefs = CKademlia::getPrefs();
	ASSERT(prefs != NULL); 
	CUInt128 me;
	prefs->getClientID(&me);
	if(answer == me) return;

	if (m_callbackID && type && ip && tcp && _tth[0] == tth[0] && _tth[1] == tth[1])
	{
		m_count++;
		//(*m_callbackID)(m_searchID, answer, type, ip, tcp, udp, serverip, serverport);
		(*m_callbackID)(target, answer, type, ip, tcp, udp, serverip, serverport, tth[0], tth[1]);
	}
}

void CSearch::processResultKeyword(const CUInt128 &target, uint32 fromIP, uint16 fromPort, const CUInt128 &answer, TagList *info)
{
	bool interested = false;
	CString name = "";
	uint32 size = 0;
	CString type = "";
	CString format = "";
	CString artist = "";
	CString album = "";
	CString title = "";
	uint32 length = 0;
	CString codec;
	uint32 bitrate = 0;
	uint32 availability = 0;
    uint32 ip = 0;
    uint16 tcp = 0;
	uint32 tth1 = 0;
	uint32 tth2 = 0;

	CTag *tag;
	TagList::const_iterator it;
	for (it = info->begin(); it != info->end(); it++)
	{
		tag = *it;

		if (!tag->m_name.Compare(TAG_NAME))
		{
			name			= tag->GetStr();
			if( name != "" )
			{
				interested = true;
			}
		}
		else if (!tag->m_name.Compare(TAG_SIZE))
			size			= tag->GetInt();
		else if (!tag->m_name.Compare(TAG_TYPE))
			type			= tag->GetStr();
		else if (!tag->m_name.Compare(TAG_FORMAT))
			format			= tag->GetStr();
		else if (!tag->m_name.CompareNoCase(TAG_MEDIA_ARTIST))
			artist			= tag->GetStr();
		else if (!tag->m_name.CompareNoCase(TAG_MEDIA_ALBUM))
			album			= tag->GetStr();
		else if (!tag->m_name.CompareNoCase(TAG_MEDIA_TITLE))
			title			= tag->GetStr();
		else if (!tag->m_name.CompareNoCase(TAG_MEDIA_LENGTH))
			length			= tag->GetInt();
		else if (!tag->m_name.CompareNoCase(TAG_MEDIA_BITRATE))
			bitrate			= tag->GetInt();
		else if (!tag->m_name.CompareNoCase(TAG_MEDIA_CODEC))
			codec			= tag->GetStr();
		else if (!tag->m_name.CompareNoCase(TAG_AVAILABILITY))
			availability	= tag->GetInt();
        else if (!tag->m_name.Compare(TAG_SOURCEIP))
            ip				= tag->GetInt();
        else if (!tag->m_name.Compare(TAG_SOURCEPORT))
            tcp				= tag->GetInt();
        else if (!tag->m_name.Compare(TAG_TTH_TAIL_1))
            tth1			= tag->GetInt();
        else if (!tag->m_name.Compare(TAG_TTH_TAIL_2))
            tth2			= tag->GetInt();
		delete tag;
	}
	delete info;

#ifdef _DEBUG
	CKademlia::debugMsg("Process keyword search result: (%u:%u) %s", ip, tcp, name);
#endif

	if( !interested ){
#ifdef _DEBUG
	CKademlia::debugMsg("Drop because no name.");
#endif
		return;
	}

    if(ip == 0 || tcp == 0)
    {
#ifdef _DEBUG
	CKademlia::debugMsg("Drop because no ip.");
#endif
        return;
    }

	// Check that it matches original criteria
	//WordList testWords;
	//CSearchManager::getWords(name.GetBuffer(0), &testWords);
	
	WordList::const_iterator mine;
	WordList::const_iterator test;
	CString keyword;
	for (mine = m_words.begin(); mine != m_words.end(); mine++)
	{
		keyword = *mine;
		if (keyword.GetAt(0) == '-')
		{
			if (type.CompareNoCase(keyword.GetBuffer(0) + 1))
			{
				interested = false;
				break;
			}
		}
		else
		{
			CString testName(name);
			keyword.MakeLower();
			testName.MakeLower();

			interested = (testName.Find(keyword) >= 0);
/*
			interested = false;
			for (test = testWords.begin(); test != testWords.end(); test++)
			{
				if (!keyword.CompareNoCase(*test))
				{
					interested = true;
					break;
				}

			}
*/
		}
		if (!interested){
#ifdef _DEBUG
			CKademlia::debugMsg("Drop because keyword not matched.");
#endif

			return;

		}
	}

    // put it into results
    if(interested)
    {
        if(m_results.count(ip) > 0)
        {
            if(m_results[ip].count(answer) > 0) // This result already there, so drop it.
			{
#ifdef _DEBUG
				CKademlia::debugMsg("Drop because result already there.");
#endif
                return;
        
			}
		}
        // Add a result to `results`
        m_results[ip].insert(answer);
    }
	if (interested && m_callbackKeyword)
	{
		m_count++;
		(*m_callbackKeyword)(m_searchID, answer, name.GetBuffer(0), size, type.GetBuffer(0), ip, tcp, tth1, tth2);
/*
		if (format.GetLength() == 0)
		{
			(*m_callbackKeyword)(m_searchID, answer, name.GetBuffer(0), size, type.GetBuffer(0), 0);
		}
		else if (length != 0 || !codec.IsEmpty() || bitrate != 0)
		{
			(*m_callbackKeyword)(m_searchID, answer, name.GetBuffer(0), size, type.GetBuffer(0), 8, 
					2, TAG_FORMAT, format.GetBuffer(0), 
					2, TAG_MEDIA_ARTIST, artist, 
					2, TAG_MEDIA_ALBUM, album, 
					2, TAG_MEDIA_TITLE, title, 
					3, TAG_MEDIA_LENGTH, length, 
					3, TAG_MEDIA_BITRATE, bitrate, 
					2, TAG_MEDIA_CODEC, codec, 
					3, TAG_AVAILABILITY, availability);
		}
		else if ((!type.Compare("Image")) && (artist.GetLength() > 0))
		{
			(*m_callbackKeyword)(m_searchID, answer, name.GetBuffer(0), size, type.GetBuffer(0), 3, 
					2, TAG_FORMAT, format.GetBuffer(0), 
					2, TAG_MEDIA_ARTIST, artist, 
					3, TAG_AVAILABILITY, availability);
		}
		else
		{
			(*m_callbackKeyword)(m_searchID, answer, name.GetBuffer(0), size, type.GetBuffer(0), 2, 
					2, TAG_FORMAT, format.GetBuffer(0), 
					3, TAG_AVAILABILITY, availability);
		}
*/
	}
}

void CSearch::sendFindValue(const CUInt128 &target, const CUInt128 &check, uint32 ip, uint16 port)
{
	try
	{
		byte packet[35];
		CByteIO bio(packet, 35);
		bio.writeByte(OP_KADEMLIAHEADER);
		bio.writeByte(KADEMLIA_REQ);
		switch(m_type){
			case NODE:
			case NODECOMPLETE:
				bio.writeByte(KADEMLIA_FIND_NODE);
				break;
			case FILE:
			case KEYWORD:
				bio.writeByte(KADEMLIA_FIND_VALUE);
				break;
			case STOREFILE:
			case STOREKEYWORD:
				bio.writeByte(KADEMLIA_STORE);
				break;
		}
		bio.writeUInt128(target);
		bio.writeUInt128(check);
//		CKademlia::debugMsg("Sent UDP OpCode KADEMLIA_REQUEST(%u)", ip);
		CKademliaUDPListener *udpListner = CKademlia::getUDPListener();
		ASSERT(udpListner != NULL); 
		udpListner->sendPacket(packet, 35, ip, port);
	} catch (...) {}
}