kadmain.cpp

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

}

void CALLBACK myLogHandler(LPCSTR lpMsg)
{
//	cout << lpMsg << endl;
#ifdef DEBUG
	OutputDebugString(lpMsg);
	OutputDebugString("\r\n");
#endif
}


void PublishNextFile()
{
	CSearch* pSearch = NULL;

    m_critical.Lock(); 

	if(!publish_file_list.empty())
	{
		CKadFile& f = publish_file_list.front();
		pSearch = CSearchManager::prepareStoreFile(f);
		publish_file_list.pop_front();
	}
    m_critical.Unlock();

    if (pSearch)
    {
		//if (!PostThreadMessage(CTimer::getThreadID(), WM_KADEMLIA_STARTSEARCH, 0, (LPARAM)pSearch))
        //    CSearchManager::deleteSearch(pSearch);

        // NOTE: because in Timer Thread, we can call directly
        CSearchManager::startSearch(pSearch);

    }

}


void PublishNextKeyword()
{
	CSearch* pSearch = NULL;

    m_critical.Lock(); 

	if(!publish_keyword_list.empty())
	{
		map<CUInt128, FileList>::iterator front = publish_keyword_list.begin();
		pSearch = CSearchManager::prepareStoreKeyword(front->first, front->second);
		publish_keyword_list.erase(front);
	}

    m_critical.Unlock();

    if (pSearch)
    {
		//if (!PostThreadMessage(CTimer::getThreadID(), WM_KADEMLIA_STARTSEARCH, 0, (LPARAM)pSearch))
        //    CSearchManager::deleteSearch(pSearch);

        // NOTE: because in Timer Thread, we can call directly
        CSearchManager::startSearch(pSearch);

    }

}

KADAPI bool FindFile(const unsigned char* fileHash)
{
	if (!CTimer::getThreadID()) return false;

	// only first 16 byte is used
	CUInt128 kadFileID(fileHash);

	uint32 tth[2];
	memcpy(tth, fileHash + 16, 8);
    CSearch* pSearch = CSearchManager::prepareFindFile(KademliaResultFileCallback, kadFileID, tth[0], tth[1]);
    if (pSearch)
    {
        pSearch->setSearchTypes(CSearch::FILE);
		if (!PostThreadMessage(CTimer::getThreadID(), WM_KADEMLIA_STARTSEARCH, 0, (LPARAM)pSearch)){
            CSearchManager::deleteSearch(pSearch);
			return false;
		}
    }

	return true;
}

KADAPI void SetFindFileResultHandler(FileResultHandler callback)
{
	FindFileResultHandler = callback;
}


KADAPI bool PublishKeyword(const unsigned char* keyhash, const struct KadFileInfo* files, int count)
{
	FileList kadFiles;

	if(count == 0){
	    m_critical.Lock();
		bool bRet = (publish_keyword_list.size() > 0);
		m_critical.Unlock();
		return bRet;
	}

	kadFiles.reserve(count);

	for(int i = 0; i < count; i++)
	{
		kadFiles.push_back(CKadFile(files[i].hash, files[i].name, files[i].size, files[i].type));
	}

	CUInt128 keyHash(keyhash);

    m_critical.Lock();
    publish_keyword_list[keyHash] = kadFiles;
    m_critical.Unlock();

	return true;
}

KADAPI bool FindKeyword(const unsigned char* _hash, const char** _keywords, int type, unsigned int minsize, unsigned int maxsize)
{
	if (!CTimer::getThreadID()) return false;

    CUInt128 hash(_hash);
    vector<CString> keywords;

    int idx = 0;

	if(_keywords)
	{
		while(_keywords[idx] != NULL)
		{
			keywords.push_back(_keywords[idx]);
			idx++;
		}
	}

    CSearch* pSearch = CSearchManager::prepareFindKeywords(KademliaResultKeywordCallback, hash, keywords, type, minsize, maxsize);

    if (pSearch)
    {
		if (!PostThreadMessage(CTimer::getThreadID(), WM_KADEMLIA_STARTSEARCH, 0, (LPARAM)pSearch)){
            CSearchManager::deleteSearch(pSearch);
			return false;
		}
    }

	return true;
}

KADAPI void SetFindKeywordResultHandler(KeywordResultHandler callback)
{
	FindKeywordResultHandler = callback;
}

KADAPI void SetPartialRequestHandler(PartialRequestHandler callback)
{
	CKademliaUDPListener::setPacketHandler(callback);
}

KADAPI void SetPartialResponseHandler(PartialResponseHandler callback)
{
	CKademliaUDPListener::setPacketHandler(callback);
}

KADAPI void SetRevConnectRequestHandler(RevConnectRequestHandler callback)
{
	CKademliaUDPListener::setPacketHandler(callback);
}

KADAPI void ResetPublishingQueue()
{
    m_critical.Lock();

	publish_file_list.clear();

	m_critical.Unlock();

}


/*
KADAPI bool RepublishFiles(const unsigned char* fileHashList, int iCount)
{
    m_critical.Lock();

	if(false == publish_file_list.empty() && false == publish_keyword_list.empty()){
		m_critical.Unlock();
        return false;
	}

	for(int i = 0; i < iCount ; i ++)
	{
	    publish_file_list.push_back(CKadFile((const byte*)(fileHashList + i * FILE_HASH_LEN)));
	}
	
	m_critical.Unlock();

	return true;
}
*/

KADAPI void PublishFile(const unsigned char* tth, bool ahead)
{
    m_critical.Lock();
	if(ahead)
	    publish_file_list.push_back(CKadFile(tth));
	else
		publish_file_list.push_front(CKadFile(tth));
    m_critical.Unlock();

}

KADAPI void StopKademlia()
{
	if(pKademlia){
		pKademlia->DisConnect();
		delete pKademlia;
		pKademlia = NULL;
	}
}

KADAPI int StartKademlia(unsigned char* id, unsigned short udp, unsigned short tcp)
{
#ifdef _DEBUG
	CKademlia::setErrorCallback			(myErrHandler);
#endif
	CKademlia::setLogCallback				(myLogHandler);
	CKademlia::setDebugCallback			(myDebugAndLogHandler);
	CKademlia::setSearchAddCallback		(KademliaSearchAddCallback);
	CKademlia::setSearchRemCallback		(KademliaSearchRemCallback);
	CKademlia::setSearchRefCallback		(KademliaSearchRefCallback);
	CKademlia::setContactAddCallback		(KademliaContactAddCallback);
	CKademlia::setContactRemCallback		(KademliaContactRemCallback);
	CKademlia::setContactRefCallback		(KademliaContactRefCallback);
	CKademlia::setRequestTCPCallback		(KademliaRequestTCPCallback);
	CKademlia::setUpdateStatusCallback	(KademliaUpdateStatusCallback);
	CKademlia::setOverheadSendCallback	(KademliaOverheadSendCallback);
	CKademlia::setOverheadRecvCallback	(KademliaOverheadRecvCallback);

	pKademlia = new CKademliaMain();

	if(pKademlia)
		pKademlia->Connect(id, udp, tcp);
	return 0;
}

/**
 * Send a partial request
 */

KADAPI bool SendPartialRequest(unsigned int ip, unsigned short port, const unsigned char* tth, unsigned char cnt, const unsigned short* data, unsigned int extLen, const char* ext)
{
	if (!CTimer::getThreadID()){
		return false;
	}

	CKademliaUDPListener *udpListener = CKademlia::getUDPListener();
	_ASSERT(udpListener);

	CPrefs *prefs = CKademlia::getPrefs();
	_ASSERT(prefs);

	try{
		uint32 lenPacket = FILE_HASH_LEN + 5 + cnt * 4 + extLen;
		byte* packet = new byte[lenPacket];
		CByteIO bio(packet, lenPacket);

		// Write packet info
		bio.writeByte(OP_KADEMLIAHEADER);
		bio.writeByte(KADEMLIA_PARTIAL_REQ);
		bio.writeUInt16(prefs->getTCPPort());
		bio.writeArray(tth, FILE_HASH_LEN);
		bio.writeByte(cnt);
		if(cnt)
			bio.writeArray(data, cnt * sizeof(unsigned short) * 2);

		if(extLen){
			bio.writeUInt32(extLen);
			bio.writeArray(ext, extLen);
		}
		
		udpListener->sendPacket(packet, lenPacket, ip, port);

	}catch(...){
		ASSERT(0);
		return false;
	}

	return true;
}


/**
 * Send a revconnect request
 */

KADAPI bool SendRevConnectRequest(unsigned int targetIp, unsigned short targetUdpPort, unsigned short localTcpPort, const unsigned char* data, unsigned int dataLen)
{
	if (!CTimer::getThreadID()){
		return false;
	}

	CKademliaUDPListener *udpListener = CKademlia::getUDPListener();
	_ASSERT(udpListener);

	CPrefs *prefs = CKademlia::getPrefs();
	_ASSERT(prefs);

	try{
		uint32 lenPacket = dataLen + 4;
		byte* packet = new byte[lenPacket];
		CByteIO bio(packet, lenPacket);

		// Write packet info
		bio.writeByte(OP_KADEMLIAHEADER);
		bio.writeByte(KADEMLIA_REVCONNECT_REQ);
		bio.writeUInt16(localTcpPort);
		prefs->setTCPPort(localTcpPort);
		if(dataLen > 0)
			bio.writeArray(data, dataLen);
		
		udpListener->sendPacket(packet, lenPacket, targetIp, targetUdpPort);

	}catch(...){
		ASSERT(0);
		return false;
	}

	return true;
}


/**
 * Proccess a packet
 */

KADAPI void ProcessPacket(const unsigned char* data, unsigned int dataLen, unsigned int ip, unsigned short port)
{
	if (!CTimer::getThreadID()){
		return;
	}

	CKademliaUDPListener *udpListener = CKademlia::getUDPListener();
	_ASSERT(udpListener);

	try{
		sockaddr_in remote_addr = { 0 };
		remote_addr.sin_addr.S_un.S_addr = ip;
		remote_addr.sin_port = htons(port);

		udpListener->processPacket((unsigned char*)data, dataLen, &remote_addr);
	}catch(...){
		ASSERT(0);
	}
}