channel.cpp

这是和p2p相关的一份源码

					if (sh)
					{
						if ((c->rhost[0].ip == sh->ip) && c->rhost[1].isValid())
						{
							bestP = c;
							best = *c;
							best.host = best.rhost[1];	// use lan ip
						}
					}else if ((c->firewalled == useFirewalled) && (servMgr->serverHost.ip!=c->rhost[0].ip))
					{
						bestP = c;
						best = *c;
						best.host = best.rhost[0];			// use wan ip
					}
				}else if (!trackersOnly && !c->tracker)
				{
					if (sh)
					{
						if ((c->rhost[0].ip == sh->ip) && c->rhost[1].isValid())
						{
							bestP = c;
							best = *c;
							best.host = best.rhost[1];	// use lan ip
						}
					}else if ((c->firewalled == useFirewalled) && (servMgr->serverHost.ip!=c->rhost[0].ip))
					{
						bestP = c;
						best = *c;
						best.host = best.rhost[0];			// use wan ip
					}
				}
			}
		}
	}


	if (bestP && wait)
	{
		bestP->lastContact = ctime;
	}
	return best;
}


// -----------------------------------
const char *ChanInfo::getTypeStr(TYPE t)
{
	switch (t)
	{
		case T_RAW: return "RAW";

		case T_MP3: return "MP3";
		case T_OGG: return "OGG";
		case T_WMA: return "WMA";

		case T_MOV: return "MOV";
		case T_MPG: return "MPG";
		case T_NSV: return "NSV";
		case T_WMV: return "WMV";

		case T_PLS: return "PLS";
		case T_ASX: return "ASX";

		default: return "UNKNOWN";
	}
}
// -----------------------------------
const char *ChanInfo::getProtocolStr(PROTOCOL t)
{
	switch (t)
	{
		case SP_PEERCAST: return "PEERCAST";
		case SP_HTTP: return "HTTP";
		case SP_FILE: return "FILE";
		case SP_MMS: return "MMS";
		case SP_PCP: return "PCP";
		default: return "UNKNOWN";
	}
}
// -----------------------------------
ChanInfo::PROTOCOL ChanInfo::getProtocolFromStr(const char *str)
{
	if (stricmp(str,"PEERCAST")==0)
		return SP_PEERCAST;
	else if (stricmp(str,"HTTP")==0)
		return SP_HTTP;
	else if (stricmp(str,"FILE")==0)
		return SP_FILE;
	else if (stricmp(str,"MMS")==0)
		return SP_MMS;
	else if (stricmp(str,"PCP")==0)
		return SP_PCP;
	else 
		return SP_UNKNOWN;
}

// -----------------------------------
const char *ChanInfo::getTypeExt(TYPE t)
{
	switch(t)
	{
		case ChanInfo::T_OGG:
			return ".ogg";
		case ChanInfo::T_MP3:
			return ".mp3";
		case ChanInfo::T_MOV:
			return ".mov";
		case ChanInfo::T_NSV:
			return ".nsv";
		case ChanInfo::T_WMV:
			return ".wmv";
		case ChanInfo::T_WMA:
			return ".wma";
		default:
			return "";
	}
}
// -----------------------------------
ChanInfo::TYPE ChanInfo::getTypeFromStr(const char *str)
{
	if (stricmp(str,"MP3")==0)
		return T_MP3;
	else if (stricmp(str,"OGG")==0)
		return T_OGG;
	else if (stricmp(str,"RAW")==0)
		return T_RAW;
	else if (stricmp(str,"NSV")==0)
		return T_NSV;
	else if (stricmp(str,"WMA")==0)
		return T_WMA;
	else if (stricmp(str,"WMV")==0)
		return T_WMV;
	else if (stricmp(str,"PLS")==0)
		return T_PLS;
	else if (stricmp(str,"M3U")==0)
		return T_PLS;
	else if (stricmp(str,"ASX")==0)
		return T_ASX;
	else 
		return T_UNKNOWN;
}
// -----------------------------------
bool	ChanInfo::matchNameID(ChanInfo &inf)
{
	if (inf.id.isSet())
		if (id.isSame(inf.id))
			return true;

	if (!inf.name.isEmpty())
		if (name.contains(inf.name))
			return true;

	return false;
}
// -----------------------------------
bool	ChanInfo::match(ChanInfo &inf)
{
	bool matchAny=true;

	if (inf.status != S_UNKNOWN)
	{
		if (status != inf.status)
			return false;
	}

	if (inf.bitrate != 0)
	{
		if (bitrate == inf.bitrate)
			return true;
		matchAny = false;
	}

	if (inf.id.isSet())
	{
		if (id.isSame(inf.id))
			return true;
		matchAny = false;
	}

	if (inf.contentType != T_UNKNOWN)
	{
		if (contentType == inf.contentType)
			return true;
		matchAny = false;
	}

	if (!inf.name.isEmpty())
	{
		if (name.contains(inf.name))
			return true;
		matchAny = false;
	}

	if (!inf.genre.isEmpty())
	{
		if (genre.contains(inf.genre))
			return true;
		matchAny = false;
	}

	return matchAny;
}

// -----------------------------------
void ChanInfo::update(ChanInfo &info)
{
	// check valid id
	if (!info.id.isSet())
		return;

	// only update from chaninfo that has full name etc..
	if (info.name.isEmpty())
		return;

	// check valid broadcaster key
	if (bcID.isSet())
		if (!bcID.isSame(info.bcID))
			return;


	bitrate = info.bitrate;
	contentType = info.contentType;
	name = info.name;
	track = info.track;
	comment = info.comment;
	genre = info.genre;
	url = info.url;
}
// -----------------------------------
void ChanInfo::initNameID(const char *n)
{
	init();
	id.fromStr(n);
	if (!id.isSet())
		name.set(n);
}

// -----------------------------------
void ChanInfo::init()
{
	status = S_UNKNOWN;
	name.clear();
	bitrate = 0;
	contentType = T_UNKNOWN;
	srcProtocol = SP_UNKNOWN;
	id.clear();
	url.clear();
	genre.clear();
	comment.clear();
	track.clear();
	lastPlayTime = 0;
	numSkips = 0;
	bcID.clear();
}
// -----------------------------------
void ChanInfo::readTrackXML(XML::Node *n)
{
	track.clear();
	readXMLString(track.title,n,"title");
	readXMLString(track.contact,n,"contact");
	readXMLString(track.artist,n,"artist");
	readXMLString(track.album,n,"album");
	readXMLString(track.genre,n,"genre");
}
// -----------------------------------
unsigned int ChanInfo::getUptime()
{
	// calculate uptime and cap if requested by settings.
	unsigned int upt;
	upt = lastPlayTime?(sys->getTime()-lastPlayTime):0;
	if (chanMgr->maxUptime)
		if (upt > chanMgr->maxUptime)
			upt = chanMgr->maxUptime;
	return upt;
}

// ------------------------------------------
void ChanInfo::readTrackAtoms(AtomStream &atom,int numc)
{
	for(int i=0; i<numc; i++)
	{
		int c,d;
		ID4 id = atom.read(c,d);
		if (id == PCP_CHAN_TRACK_TITLE)
		{
			atom.readString(track.title.data,sizeof(track.title.data),d);
		}else if (id == PCP_CHAN_TRACK_CREATOR)
		{
			atom.readString(track.artist.data,sizeof(track.artist.data),d);
		}else if (id == PCP_CHAN_TRACK_URL)
		{
			atom.readString(track.contact.data,sizeof(track.contact.data),d);
		}else if (id == PCP_CHAN_TRACK_ALBUM)
		{
			atom.readString(track.album.data,sizeof(track.album.data),d);
		}else
			atom.skip(c,d);
	}
}
// ------------------------------------------
void ChanInfo::readInfoAtoms(AtomStream &atom,int numc)
{
	for(int i=0; i<numc; i++)
	{
		int c,d;
		ID4 id = atom.read(c,d);
		if (id == PCP_CHAN_INFO_NAME)
		{
			atom.readString(name.data,sizeof(name.data),d);
		}else if (id == PCP_CHAN_INFO_BITRATE)
		{
			bitrate = atom.readInt();
		}else if (id == PCP_CHAN_INFO_GENRE)
		{
			atom.readString(genre.data,sizeof(genre.data),d);
		}else if (id == PCP_CHAN_INFO_URL)
		{
			atom.readString(url.data,sizeof(url.data),d);
		}else if (id == PCP_CHAN_INFO_DESC)
		{
			atom.readString(desc.data,sizeof(desc.data),d);
		}else if (id == PCP_CHAN_INFO_COMMENT)
		{
			atom.readString(comment.data,sizeof(comment.data),d);
		}else if (id == PCP_CHAN_INFO_TYPE)
		{
			char type[16];
			atom.readString(type,sizeof(type),d);
			contentType = ChanInfo::getTypeFromStr(type);
		}else
			atom.skip(c,d);
	}	
}

// -----------------------------------
void ChanInfo::writeInfoAtoms(AtomStream &atom)
{
	atom.writeParent(PCP_CHAN_INFO,7);
		atom.writeString(PCP_CHAN_INFO_NAME,name.cstr());
		atom.writeInt(PCP_CHAN_INFO_BITRATE,bitrate);
		atom.writeString(PCP_CHAN_INFO_GENRE,genre.cstr());
		atom.writeString(PCP_CHAN_INFO_URL,url.cstr());
		atom.writeString(PCP_CHAN_INFO_DESC,desc.cstr());
		atom.writeString(PCP_CHAN_INFO_COMMENT,comment.cstr());
		atom.writeString(PCP_CHAN_INFO_TYPE,getTypeStr(contentType));		

}
// -----------------------------------
void ChanInfo::writeTrackAtoms(AtomStream &atom)
{
	atom.writeParent(PCP_CHAN_TRACK,4);
		atom.writeString(PCP_CHAN_TRACK_TITLE,track.title.cstr());
		atom.writeString(PCP_CHAN_TRACK_CREATOR,track.artist.cstr());
		atom.writeString(PCP_CHAN_TRACK_URL,track.contact.cstr());
		atom.writeString(PCP_CHAN_TRACK_ALBUM,track.album.cstr());
}


// -----------------------------------
XML::Node *ChanInfo::createChannelXML()
{
	char idStr[64];

	String nameHTML = name;
	nameHTML.convertTo(String::T_HTML);
	String urlHTML = url;
	urlHTML.convertTo(String::T_HTML);
	String genreHTML = genre;
	genreHTML.convertTo(String::T_HTML);
	String descHTML = desc;
	descHTML.convertTo(String::T_HTML);
	String commentHTML;
	commentHTML = comment;
	commentHTML.convertTo(String::T_HTML);


	id.toStr(idStr);


	return new XML::Node("channel name=\"%s\" id=\"%s\" bitrate=\"%d\" type=\"%s\" genre=\"%s\" desc=\"%s\" url=\"%s\" uptime=\"%d\" comment=\"%s\" skips=\"%d\"",
		nameHTML.cstr(),
		idStr,
		bitrate,
		getTypeStr(contentType),
		genreHTML.cstr(),
		descHTML.cstr(),
		urlHTML.cstr(),
		getUptime(),
		commentHTML.cstr(),
		numSkips
		);	
}

// -----------------------------------
XML::Node *ChanInfo::createQueryXML()
{
	char buf[512];
	char idStr[64];


	String nameHTML = name;
	nameHTML.convertTo(String::T_HTML);
	String genreHTML = genre;
	genreHTML.convertTo(String::T_HTML);

	buf[0]=0;
	if (!nameHTML.isEmpty())
	{
		strcat(buf," name=\"");
		strcat(buf,nameHTML.cstr());
		strcat(buf,"\"");
	}

	if (!genreHTML.isEmpty())
	{
		strcat(buf," genre=\"");
		strcat(buf,genreHTML.cstr());
		strcat(buf,"\"");
	}

	if (id.isSet())
	{
		id.toStr(idStr);
		strcat(buf," id=\"");
		strcat(buf,idStr);
		strcat(buf,"\"");
	}
		

	return new XML::Node("channel %s",buf);
}

// -----------------------------------
XML::Node *ChanInfo::createRelayChannelXML()
{
	char idStr[64];

	id.toStr(idStr);


	return new XML::Node("channel id=\"%s\" uptime=\"%d\" skips=\"%d\"",
		idStr,
		getUptime(),
		numSkips
		);	
}// -----------------------------------
XML::Node *ChanInfo::createTrackXML()
{
	String titleHTML,contactHTML,albumHTML,genreHTML,artistHTML;
	titleHTML = track.title;
	titleHTML.convertTo(String::T_HTML);
	artistHTML = track.artist;
	artistHTML.convertTo(String::T_HTML);
	albumHTML = track.album;
	albumHTML.convertTo(String::T_HTML);
	genreHTML = track.genre;
	genreHTML.convertTo(String::T_HTML);
	contactHTML = track.contact;
	contactHTML.convertTo(String::T_HTML);


	return new XML::Node("track title=\"%s\" artist=\"%s\" album=\"%s\" genre=\"%s\" contact=\"%s\"",
		titleHTML.cstr(),
		artistHTML.cstr(),
		albumHTML.cstr(),
		genreHTML.cstr(),
		contactHTML.cstr()
		);
}

// -----------------------------------
void ChanInfo::init(XML::Node *n)
{
	init();

	updateFromXML(n);
}
// -----------------------------------
void ChanInfo::updateFromXML(XML::Node *n)
{
	String typeStr,idStr;

	readXMLString(name,n,"name");
	readXMLString(genre,n,"genre");
	readXMLString(url,n,"url");
	readXMLString(desc,n,"desc");


	int br = n->findAttrInt("bitrate");
	if (br)
		bitrate = br;

	readXMLString(typeStr,n,"type");
	if (!typeStr.isEmpty())
		contentType = getTypeFromStr(typeStr.cstr());


	readXMLString(idStr,n,"id");
	if (!idStr.isEmpty())
		id.fromStr(idStr.cstr());

	readXMLString(comment,n,"comment");

	XML::Node *tn = n->findNode("track");
	if (tn)
		readTrackXML(tn);

}

// -----------------------------------
void ChanInfo::init(const char *n, GnuID &cid, TYPE tp, int br)
{
	init();

	name.set(n);
	bitrate = br;
	contentType = tp;
	id = cid;
}

// -----------------------------------
void ChanInfo::init(const char *fn)
{
	init();

	if (fn)
		name.set(fn);
}
// -----------------------------------
void PlayList::readASX(Stream &in)
{
	LOG_DEBUG("Reading ASX");
	XML xml;

	try
	{
		xml.read(in);
	}catch(StreamException &) {} // TODO: eof is NOT handled properly in sockets - always get error at end

	if (xml.root)
	{
		XML::Node *n = xml.root->child;
		while (n)
		{
			if (stricmp("entry",n->getName())==0)
			{
				XML::Node *rf = n->findNode("ref");
				if (rf)
				{
					char *hr = rf->findAttr("href");
					if (hr)
					{
						addURL(hr,"");
						//LOG("asx url %s",hr);
					}

				}
			}
			n=n->sibling;
		}
	}
}
// -----------------------------------
void PlayList::readSCPLS(Stream &in)
{
	char tmp[256];
	while (in.readLine(tmp,sizeof(tmp)))
	{
		if (strnicmp(tmp,"file",4)==0)
		{
			char *p = strstr(tmp,"=");
			if (p)
				addURL(p+1,"");
		}
	}
}
// -----------------------------------
void PlayList::readPLS(Stream &in)
{
	char tmp[256];
	while (in.readLine(tmp,sizeof(tmp)))
	{
		if (tmp[0] != '#')
			addURL(tmp,"");
	}
}
// -----------------------------------
void PlayList::writeSCPLS(Stream &out)
{
	out.writeLine("[playlist]");
	out.writeLine("");
	out.writeLine("NumberOfEntries=%d",numURLs);

	for(int i=0; i<numURLs; i++)
	{
		out.writeLine("File%d=%s",i+1,urls[i].cstr());
		out.writeLine("Title%d=%s",i+1,titles[i].cstr());
		out.writeLine("Length%d=-1",i+1);
	}
	out.writeLine("Version=2");
}
// -----------------------------------
void PlayList::writePLS(Stream &out)
{
	for(int i=0; i<numURLs; i++)
		out.writeLine("%s",urls[i].cstr());
}

// -----------------------------------
void PlayList::writeASX(Stream &out)
{
	out.writeLine("<ASX Version=\"3.0\">");
	for(int i=0; i<numURLs; i++)
	{
		out.writeLine("<ENTRY>");
		out.writeLine("<REF href = \"%s\" />",urls[i].cstr());
		out.writeLine("</ENTRY>");
	}
	out.writeLine("</ASX>");
}


// -------------------------------