servmgr.cpp

这是和p2p相关的一份源码

				}

		for(i=0; i<ServMgr::MAX_HOSTCACHE; i++)
		{
			if (servMgr->hostCache[i].isValid())
			{
				servMgr->hostCache[i].toStr(str);
				iniFile.writeLine(str);
			}
		}
		iniFile.writeLine("[End]");


		iniFile.close();
	}
}
// --------------------------------------------------
unsigned int readServerSettings(IniFile &iniFile, unsigned int a)
{
	while (iniFile.readNext())
	{
		if (iniFile.isName("[End]"))
			break;
		else if (iniFile.isName("allowHTML"))
			a = iniFile.getBoolValue()?a|Servent::ALLOW_HTML:a&~Servent::ALLOW_HTML;
		else if (iniFile.isName("allowData"))
			a = iniFile.getBoolValue()?a|Servent::ALLOW_DATA:a&~Servent::ALLOW_DATA;
		else if (iniFile.isName("allowServent"))
			a = iniFile.getBoolValue()?a|Servent::ALLOW_SERVENT:a&~Servent::ALLOW_SERVENT;
		else if (iniFile.isName("allowBroadcast"))
			a = iniFile.getBoolValue()?a|Servent::ALLOW_BROADCAST:a&~Servent::ALLOW_BROADCAST;
	}
	return a;
}
// --------------------------------------------------
void readFilterSettings(IniFile &iniFile, ServFilter &sv)
{
	sv.flags = 0;
	sv.host.init();

	while (iniFile.readNext())
	{
		if (iniFile.isName("[End]"))
			break;
		else if (iniFile.isName("ip"))
			sv.host.fromStr(iniFile.getStrValue());
		else if (iniFile.isName("private"))
			sv.flags |= iniFile.getBoolValue()?ServFilter::F_PRIVATE:0;
		else if (iniFile.isName("ban"))
			sv.flags |= iniFile.getBoolValue()?ServFilter::F_BAN:0;
		else if (iniFile.isName("allow"))
			sv.flags |= iniFile.getBoolValue()?ServFilter::F_ALLOW:0;
	}
}
// --------------------------------------------------
void ServMgr::loadSettings(const char *fn)
{
	IniFile iniFile;

	if (!iniFile.openReadOnly(fn))
		saveSettings(fn);


	servMgr->numFilters = 0;
	showLog = 0;

	if (iniFile.openReadOnly(fn))
	{
		while (iniFile.readNext())
		{
			// server settings
			if (iniFile.isName("serverPort"))
				servMgr->serverHost.port = iniFile.getIntValue();
			else if (iniFile.isName("autoServe"))
				servMgr->autoServe = iniFile.getBoolValue();
			else if (iniFile.isName("autoConnect"))
				servMgr->autoConnect = iniFile.getBoolValue();
			else if (iniFile.isName("icyPassword"))
				strcpy(servMgr->password,iniFile.getStrValue());
			else if (iniFile.isName("forceIP"))
			{
				strcpy(servMgr->forceIP,iniFile.getStrValue());
				if (strlen(servMgr->forceIP))
					servMgr->serverHost.ip = ClientSocket::getIP(servMgr->forceIP);
			}
			else if (iniFile.isName("isRoot"))
				servMgr->isRoot = iniFile.getBoolValue();
			else if (iniFile.isName("broadcastID"))
				chanMgr->broadcastID.fromStr(iniFile.getStrValue());
			else if (iniFile.isName("maxBitrate"))
				servMgr->maxBitrate = iniFile.getIntValue();
			else if (iniFile.isName("maxStreams"))
				servMgr->maxStreams = iniFile.getIntValue();
			else if (iniFile.isName("maxStreamsPerChannel"))
				chanMgr->maxStreamsPerChannel = iniFile.getIntValue();
			else if (iniFile.isName("maxIncoming"))
				servMgr->maxIncoming = iniFile.getIntValue();
			else if (iniFile.isName("maxOutgoing"))
				servMgr->maxOutgoing = iniFile.getIntValue();
			else if (iniFile.isName("maxTryout"))
				servMgr->maxTryout = iniFile.getIntValue();
			else if (iniFile.isName("minConnected"))
				servMgr->minConnected = iniFile.getIntValue();
			else if (iniFile.isName("serventBandwidth"))
				servMgr->serventBandwidth = iniFile.getIntValue();
			else if (iniFile.isName("firewallTimeout"))
				firewallTimeout = iniFile.getIntValue();
			else if (iniFile.isName("forceNormal"))
				forceNormal = iniFile.getBoolValue();
			else if (iniFile.isName("broadcastMsgInterval"))
				chanMgr->broadcastMsgInterval = iniFile.getIntValue();
			else if (iniFile.isName("broadcastMsg"))
				chanMgr->broadcastMsg.set(iniFile.getStrValue(),String::T_ASCII);
			else if (iniFile.isName("icyMetaInterval"))
				chanMgr->icyMetaInterval = iniFile.getIntValue();
			else if (iniFile.isName("rootMsg"))
				rootMsg.set(iniFile.getStrValue());
			else if (iniFile.isName("network"))
				network.set(iniFile.getStrValue());
			else if (iniFile.isName("authType"))
			{
				char *t = iniFile.getStrValue();
				if (stricmp(t,"cookie")==0)
					servMgr->authType = ServMgr::AUTH_COOKIE;
				else if (stricmp(t,"http-basic")==0)
					servMgr->authType = ServMgr::AUTH_HTTPBASIC;
			}else if (iniFile.isName("cookiesExpire"))
			{
				char *t = iniFile.getStrValue();
				if (stricmp(t,"never")==0)
					servMgr->cookieList.neverExpire = true;
				else if (stricmp(t,"session")==0)
					servMgr->cookieList.neverExpire = false;

			// client settings
			}else if (iniFile.isName("lookupHost"))
				strcpy(servMgr->connectHost,iniFile.getStrValue());
			else if (iniFile.isName("deadHitAge"))
				chanMgr->deadHitAge = iniFile.getIntValue();
			else if (iniFile.isName("tryoutDelay"))
				servMgr->tryoutDelay = iniFile.getIntValue();
			else if (iniFile.isName("refreshHTML"))
				refreshHTML = iniFile.getIntValue();
			else if (iniFile.isName("relayBroadcast"))
				servMgr->relayBroadcast = iniFile.getIntValue();
			else if (iniFile.isName("broadcastTTL"))
				chanMgr->broadcastTTL = iniFile.getIntValue();
			else if (iniFile.isName("pushTimeout"))
				chanMgr->pushTimeout = iniFile.getIntValue();
			else if (iniFile.isName("pushTries"))
				chanMgr->pushTries = iniFile.getIntValue();
			else if (iniFile.isName("maxPushHops"))
				chanMgr->maxPushHops = iniFile.getIntValue();

			// debug
			else if (iniFile.isName("logDebug"))
				showLog |= iniFile.getBoolValue() ? 1<<LogBuffer::T_DEBUG:0;
			else if (iniFile.isName("logErrors"))
				showLog |= iniFile.getBoolValue() ? 1<<LogBuffer::T_ERROR:0;
			else if (iniFile.isName("logNetwork"))
				showLog |= iniFile.getBoolValue() ? 1<<LogBuffer::T_NETWORK:0;
			else if (iniFile.isName("logChannel"))
				showLog |= iniFile.getBoolValue() ? 1<<LogBuffer::T_CHANNEL:0;
			else if (iniFile.isName("pauseLog"))
				pauseLog = iniFile.getBoolValue();
			else if (iniFile.isName("idleSleepTime"))
				sys->idleSleepTime = iniFile.getIntValue();
			else if (iniFile.isName("[Server1]"))
				allowServer1 = readServerSettings(iniFile,allowServer1);
			else if (iniFile.isName("[Server2]"))
				allowServer2 = readServerSettings(iniFile,allowServer2);
			else if (iniFile.isName("[Filter]"))
			{
				readFilterSettings(iniFile,filters[numFilters]);

				if (numFilters < (MAX_FILTERS-1))
					numFilters++;
			}
			else if (iniFile.isName("[Notify]"))
			{
				notifyMask = NT_UPGRADE;
				while (iniFile.readNext())
				{
					if (iniFile.isName("[End]"))
						break;
					else if (iniFile.isName("PeerCast"))
						notifyMask |= iniFile.getBoolValue()?NT_PEERCAST:0;
					else if (iniFile.isName("Broadcasters"))
						notifyMask |= iniFile.getBoolValue()?NT_BROADCASTERS:0;
					else if (iniFile.isName("TrackInfo"))
						notifyMask |= iniFile.getBoolValue()?NT_TRACKINFO:0;
				}

			}
			else if (iniFile.isName("[RelayChannel]"))
			{
				ChanInfo info;
				bool stayConnected=false;
				String sourceURL;
				while (iniFile.readNext())
				{
					if (iniFile.isName("[End]"))
						break;
					else if (iniFile.isName("name"))
						info.name.set(iniFile.getStrValue());
					else if (iniFile.isName("id"))
						info.id.fromStr(iniFile.getStrValue());
					else if (iniFile.isName("type"))
						info.contentType = ChanInfo::getTypeFromStr(iniFile.getStrValue());
					else if (iniFile.isName("stayConnected"))
						stayConnected = iniFile.getBoolValue();
					else if (iniFile.isName("sourceURL"))
						sourceURL.set(iniFile.getStrValue());
					else if (iniFile.isName("genre"))
						info.genre.set(iniFile.getStrValue());
					else if (iniFile.isName("contactURL"))
						info.url.set(iniFile.getStrValue());

				}
				if (sourceURL.isEmpty())
				{
					chanMgr->createRelay(info,stayConnected);
				}else
				{
					Channel *c = chanMgr->createChannel(info,NULL);
					if (c)
						c->startURL(sourceURL.cstr());
				}
			}


			// host cache
			else if (iniFile.isName("[HostCache]"))
			{
				while (iniFile.readNext())
				{
					if (iniFile.isName("[End]"))
						break;
					Host h;
					h.fromStr(iniFile.getName());
					if (h.isValid())
					{
						char tt[64];
						h.toStr(tt);
						servMgr->addHost(h);
					}
					
				}

				// reset read ptr to get last connected nodes first
				servMgr->readHostPtr = 0;
			}


		}
	}

	if (!numFilters)
		setFilterDefaults();

}
// --------------------------------------------------
int ServMgr::findChannel(ChanInfo &info)
{
	char idStr[64];
	info.id.toStr(idStr);
	LOG_NETWORK("Querying network: %s %s",info.name.cstr(),idStr);
	GnuPacket pack;

	XML xml;
	XML::Node *n = info.createQueryXML();
	xml.setRoot(n);
	pack.initFind(NULL,&xml);

	addReplyID(pack.id);
	int cnt = broadcast(pack,NULL);

	return cnt;
}

// --------------------------------------------------
bool ServMgr::start()
{
	static ThreadInfo serverThread,clientThread,idleThread;

	serverThread.func = ServMgr::serverProc;
	if (!sys->startThread(&serverThread))
		return false;

	clientThread.func = ServMgr::clientProc;
	if (!sys->startThread(&clientThread))
		return false;

	idleThread.func = ServMgr::idleProc;
	if (!sys->startThread(&idleThread))
		return false;

	return true;
}
// --------------------------------------------------
int ServMgr::clientProc(ThreadInfo *thread)
{

	thread->lock();

	while(thread->active)
	{
		if (servMgr->autoConnect)
		{
			if ((servMgr->needConnections() && !servMgr->outFull()) || servMgr->forceLookup )
			{
				if (servMgr->needHosts() || servMgr->forceLookup)
				{
					char host[128];
					strcpy(host,servMgr->connectHost);
					int port = 7144;
					char *pp = strstr(host,":");
					if (pp)
					{
						port = atoi(pp+1);
						pp[0] = 0;
					}

					int ip = ClientSocket::getIP(host);

					if (!servMgr->findServent(ip,port))
					{
						Servent *sv = servMgr->allocServent();
						if (sv)
						{
							LOG_DEBUG("Lookup: %s:%d",host,port);
							sv->initOutgoing(host,port,Servent::T_LOOKUP);
							servMgr->forceLookup = false;
						}
					}
				}

				for(int i=0; i<MAX_TRYOUT; i++)
				{
					if (servMgr->outFull())
						break;
					if (servMgr->tryFull())
						break;

					Host h = servMgr->getHost();

					Host lh(ClientSocket::getIP(NULL),0);
					if (lh.globalIP() && !h.globalIP())
						h.ip = 0;

					if (h.ip) 
						if (!servMgr->findServent(h.ip,h.port))
						{
							char hostName[64];
							h.IPtoStr(hostName);
							Servent *sv = servMgr->allocServent();
							if (sv)
								sv->initOutgoing(hostName,h.port,Servent::T_OUTGOING);
							else
								break;
						}
					sys->sleep(servMgr->tryoutDelay);
				}
			}
		}else{
			for(int i=0; i<ServMgr::MAX_SERVENTS; i++)
			{
				Servent *s = &servMgr->servents[i];
				if (s->type == Servent::T_OUTGOING) 
					s->thread.active = false;

			}
		}
		sys->sleepIdle();
	}
	thread->unlock();
	return 0;
}
// --------------------------------------------------
int ServMgr::idleProc(ThreadInfo *thread)
{

	thread->lock();

	unsigned int lastPasvFind=0;
	unsigned int lastBroadcast=0;


	// nothing much to do for the first couple of seconds, so just hang around.
	sys->sleep(2000);	

	unsigned int lastBWcheck=0;
	unsigned int bytesIn=0,bytesOut=0;

	while(thread->active)
	{
		stats.update();


		if (servMgr->relayBroadcast)
			if ((sys->getTime()-lastBroadcast) > servMgr->relayBroadcast)
			{
				chanMgr->broadcastRelays(chanMgr->broadcastTTL,NULL);
				lastBroadcast = sys->getTime();
			}

#if 0
		if (servMgr->passiveSearch)
			if ((sys->getTime()-lastPasvFind) > servMgr->passiveSearch)
			{
				LOG_DEBUG("Passive find");
				GnuPacket pack;
				pack.initFind("",NULL);
				servMgr->addActiveID(pack.id);
				servMgr->broadcast(pack,NULL);
				lastPasvFind = sys->getTime();
			}
#endif

#if 0
		if (chanMgr->searchActive)
		{
			if ((sys->getTime()-chanMgr->lastSearch) > 15)		
			{
				if (chanMgr->numFinds >= 2)
					chanMgr->searchActive = false;
				else
				{
					if (servMgr->findChannel(chanMgr->searchInfo))
					{
						LOG_DEBUG("Auto find: %d",chanMgr->numFinds);
						chanMgr->lastSearch = sys->getTime();
						chanMgr->numFinds++;
					}
				}
			}
		}
#endif
		// clear dead hits

		chanMgr->clearDeadHits();

		// kill old idle channels
		{
			int cnt=0;
			Channel *oldest=NULL;
			unsigned int last = (unsigned int )-1;
			for(int i=0; i<ChanMgr::MAX_CHANNELS; i++)
			{
				Channel *c = &chanMgr->channels[i];
				if (c->isIdle())
				{
					cnt++;
					if (c->lastIdleTime < last)
					{
						oldest = c;
						last = c->lastIdleTime;
					}
				}
			}
			if (cnt > ChanMgr::MAX_IDLE)
				if (oldest)
					oldest->thread.active = false;
		}


		//if (!servMgr->isRelay)
		{
			// check for too many connections 
			bool killIn = servMgr->inOver();
			bool killOut = servMgr->outOver();
			for(int i=0; i<ServMgr::MAX_SERVENTS; i++)
			{
				Servent *s = &servMgr->servents[i];
				if (s->status == Servent::S_CONNECTED)
				{
					if ( (killOut && (s->type == Servent::T_OUTGOING)) ||
						 (killIn && (s->type == Servent::T_INCOMING)) )
					{
						s->thread.active = false;
						break;
					}
				}

			}
		}

		if (servMgr->shutdownTimer)
		{
			if (--servMgr->shutdownTimer <= 0)
			{
				debugtest = 1;
				peercastInst->saveSettings();
				sys->exit();
			}
		}



		sys->sleep(500);
	}

	thread->unlock();
	return 0;
}

// --------------------------------------------------
int ServMgr::serverProc(ThreadInfo *thread)
{
	thread->lock();

	Servent *serv = servMgr->allocServent();
	serv->permAlloc = true;

	Servent *serv2 = servMgr->allocServent();
	serv2->permAlloc = true;

	unsigned int lastLookupTime=0;


	while (thread->active)
	{
		if (servMgr->restartServer)
		{
			serv->abort();		// force close

			serv2->abort();		// force close

			servMgr->restartServer = false;
		}

		if (servMgr->autoServe)
		{
			serv->allow = servMgr->allowServer1;
			serv2->allow = servMgr->allowServer2;

			if ((serv->lastConnect) && ((sys->getTime()-serv->lastConnect) > servMgr->firewallTimeout))
			{
				if (servMgr->getFirewall()==ServMgr::FW_UNKNOWN)
				{
					LOG_DEBUG("Server has had no incoming connections");
					servMgr->setFirewall(ServMgr::FW_ON);
				}
			}


			// force lookup every 24 hours to check for new messages
			if ((sys->getTime()-lastLookupTime) > 60*60*24)
			{
				servMgr->forceLookup = true;
				lastLookupTime = sys->getTime();
			}


			if ((serv->status == Servent::S_NONE) || (serv2->status == Servent::S_NONE))
			{
				LOG_DEBUG("Starting servers");
				servMgr->forceLookup = true;

				//if (servMgr->serverHost.ip != 0)
				{

					if (servMgr->forceNormal)
						servMgr->setFirewall(ServMgr::FW_OFF);
					else
						servMgr->setFirewall(ServMgr::FW_UNKNOWN);

					Host h = servMgr->serverHost;

					if (serv->status == Servent::S_NONE)
						serv->initServer(h);

					h.port++;
					if (serv2->status == Servent::S_NONE)
						serv2->initServer(h);


				}
			}
		}else{
			// stop server
			serv->abort();		// force close
			serv2->abort();		// force close

			// cancel incoming connectuions
			for(int i=0; i<ServMgr::MAX_SERVENTS; i++)
			{
				Servent *s = &servMgr->servents[i];
				if (s->type == Servent::T_INCOMING)
					s->thread.active = false;
			}

			servMgr->setFirewall(ServMgr::FW_ON);
		}
			
		sys->sleepIdle();

	}

	thread->unlock();
	return 0;
}