servhs.cpp

这是和p2p相关的一份源码

// ------------------------------------------------
// File : servhs.cpp
// Date: 4-apr-2002
// Author: giles
// Desc: 
//		Servent handshaking, TODO: should be in its own class
//
// (c) 2002 peercast.org
// ------------------------------------------------
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// ------------------------------------------------


#include <stdlib.h>
#include "servent.h"
#include "servmgr.h"
#include "html.h"
#include "stats.h"
#include "peercast.h"
#include "pcp.h"

// -----------------------------------
static void termArgs(char *str)
{
	if (str)
	{
		int slen = strlen(str);
		for(int i=0; i<slen; i++)
			if (str[i]=='&') str[i] = 0;
	}
}
// -----------------------------------
char *nextCGIarg(char *cp, char *cmd, char *arg)
{
	if (!*cp)
		return NULL;

	// fetch command
	while (*cp)
	{
		char c = *cp++;
		if (c == '=')
			break;
		else
			*cmd++ = c;
	}
	*cmd = 0;

	// fetch arg
	while (*cp)
	{
		char c = *cp++;
		if (c == '&')
			break;
		else
			*arg++ = c;
	}
	*arg = 0;

	return cp;
}
// -----------------------------------
bool getCGIargBOOL(char *a)
{
	return (strcmp(a,"1")==0);
}
// -----------------------------------
int getCGIargINT(char *a)
{
	return atoi(a);
}

// -----------------------------------
void Servent::handshakeHTTP(HTTP &http, bool isHTTP)
{
	char *in = http.cmdLine;

	if (http.isRequest("GET /"))
	{
		char *fn = in+4;

		char *pt = strstr(fn,HTTP_PROTO1);
		if (pt)
			pt[-1] = 0;

		if (strncmp(fn,"/admin?",7)==0)
		{
			if (!isAllowed(ALLOW_HTML))
				throw HTTPException(HTTP_SC_UNAUTHORIZED,401);


			LOG_DEBUG("Admin client");
			handshakeCMD(fn+7);
		}else if (strncmp(fn,"/admin/?",8)==0)
		{
			if (!isAllowed(ALLOW_HTML))
				throw HTTPException(HTTP_SC_UNAUTHORIZED,401);

			LOG_DEBUG("Admin client");
			handshakeCMD(fn+8);

		}else if (strncmp(fn,"/admin.cgi",10)==0)
		{
			if (!isAllowed(ALLOW_BROADCAST))
				throw HTTPException(HTTP_SC_UNAUTHORIZED,401);

			char *pwdArg = getCGIarg(fn,"pass=");
			char *songArg = getCGIarg(fn,"song=");
			char *mountArg = getCGIarg(fn,"mount=");
			char *urlArg = getCGIarg(fn,"url=");

			if (pwdArg && songArg)
			{
				int i;
				int slen = strlen(fn);
				for(i=0; i<slen; i++)
					if (fn[i]=='&') fn[i] = 0;

				Channel *c=NULL;

				for(i=0; i<ChanMgr::MAX_CHANNELS; i++)
				{
					c = &chanMgr->channels[i];
					if ((c->status == Channel::S_BROADCASTING) &&
					   (c->info.contentType == ChanInfo::T_MP3) )
					{
						// if we have a mount point then check for it, otherwise update all channels.
						if (mountArg)
							if (strcmp(c->mount,mountArg))
								c = NULL;

						if (c)
						{
							c->info.track.title.set(songArg,String::T_ESC);

							if (urlArg)
								if (urlArg[0])
									c->info.track.contact.set(urlArg,String::T_ESC);
							LOG_CHANNEL("Ch.%d Shoutcast update: %s",c->index,songArg);
							c->updateMeta();
						}
					}
				}
			}

		}else if (strncmp(fn,"/pls/",5)==0)
		{

			ChanInfo info;
			if (servMgr->getChannel(fn+5,info,isPrivate()))
				handshakePLS(info,false);
			else
				throw HTTPException(HTTP_SC_NOTFOUND,404);

		}else if (strncmp(fn,"/stream/",8)==0)
		{

			triggerChannel(fn+8,ChanInfo::SP_HTTP,isPrivate());

			
		}else if (strncmp(fn,"/channel/",9)==0)
		{

			triggerChannel(fn+9,ChanInfo::SP_PCP,false);

		}else if (strncmp(fn,"/rtsp/",6)==0)
		{

			//handshakeRTSP(fn+6);

		}else if (strcmp(fn,"/")==0)
		{
			if (!isAllowed(ALLOW_HTML))
				throw HTTPException(HTTP_SC_UNAUTHORIZED,401);

			LOG_NETWORK("HTML client");
			handshakeCMD(fn+1);

		}else{

		    while (http.nextHeader())
				LOG_DEBUG("GET: %s",http.cmdLine);

			throw HTTPException(HTTP_SC_BADREQUEST,400);
		}
	}else if (http.isRequest("GIV"))
	{
		HTTP http(*sock);
	
		while (http.nextHeader()) ;

		if (!isAllowed(ALLOW_DATA))
			throw HTTPException(HTTP_SC_UNAUTHORIZED,401);

		GnuID id;
		id.clear();

		char *idstr = strstr(in,"/");
		if (idstr)
			id.fromStr(idstr+1);

		char ipstr[64];
		sock->host.toStr(ipstr);

		if (id.isSet())
		{
			// at the moment we don`t really care where the GIV came from, so just give to chan. no. if its waiting.
			Channel *ch = chanMgr->findChannelByID(id);

			if (!ch)
				throw HTTPException(HTTP_SC_NOTFOUND,404);

			if (!ch->acceptGIV(sock))
				throw HTTPException(HTTP_SC_UNAVAILABLE,503);

		
			LOG_DEBUG("Accepted GIV channel %s from: %s",idstr,ipstr);

			sock=NULL;					// release this servent but dont close socket.	
		}else 
		{
			if (!servMgr->acceptGIV(sock))
				throw HTTPException(HTTP_SC_UNAVAILABLE,503);

			LOG_DEBUG("Accepted GIV PCP from: %s",ipstr);
			sock=NULL;					// release this servent but dont close socket.	
		}

	}else if (http.isRequest(PCX_PCP_CONNECT))
	{
		
		processIncomingPCP(true);

	}else if (http.isRequest("PEERCAST CONNECT") && servMgr->isRoot)
	{
		if (!isAllowed(ALLOW_SERVENT))
			throw HTTPException(HTTP_SC_UNAUTHORIZED,401);
		if (!servMgr->isRoot)
			throw HTTPException(HTTP_SC_UNAVAILABLE,503);

		LOG_DEBUG("PEERCAST client");
		processServent();

	}else if (http.isRequest("SOURCE"))
	{
		if (!isAllowed(ALLOW_BROADCAST))
			throw HTTPException(HTTP_SC_UNAUTHORIZED,401);

		char *mount = NULL;

		char *ps;
		if (ps=strstr(in,"ICE/1.0"))
		{
			mount = in+7;
			*ps = 0;
			LOG_DEBUG("ICE 1.0 client to %s",mount?mount:"unknown");
		}else{
			mount = in+strlen(in);
			while (*--mount)
				if (*mount == '/')
				{
					mount[-1] = 0; // password preceeds
					break;
				}
			strcpy(loginPassword,in+7);
			
			LOG_DEBUG("ICY client to %s",mount?mount:"unknown");
		}

		if (mount)
			strcpy(loginMount,mount);

		handshakeICY(Channel::SRC_ICECAST,isHTTP);
		sock = NULL;	// socket is taken over by channel, so don`t close it

	}else if (http.isRequest(servMgr->password))
	{
		if (!isAllowed(ALLOW_BROADCAST))
			throw HTTPException(HTTP_SC_UNAUTHORIZED,401);

		strcpy(loginPassword,servMgr->password);	// pwd already checked

		sock->writeLine("OK2");
		sock->writeLine("icy-caps:11");
		sock->writeLine("");
		LOG_DEBUG("ShoutCast client");

		handshakeICY(Channel::SRC_SHOUTCAST,isHTTP);
		sock = NULL;	// socket is taken over by channel, so don`t close it

	}else if (http.isRequest("POST"))
	{
		handshakePOST();
	}else
	{
		throw HTTPException(HTTP_SC_BADREQUEST,400);
	}

}
// -----------------------------------
bool Servent::canStream(Channel *ch)
{
	if (ch==NULL)
		return false;

	if (!isPrivate())
	{
		if  (
				servMgr->bitrateFull(ch->getBitrate())
				|| servMgr->streamFull()
				|| !ch->isPlaying()
				|| ch->isFull()
			)
			return false;
	}

	return true;
}
// -----------------------------------
void Servent::handshakeIncoming()
{

	setStatus(S_HANDSHAKE);

	char buf[1024];
	sock->readLine(buf,sizeof(buf));

	char sb[64];
	sock->host.toStr(sb);


	if (stristr(buf,RTSP_PROTO1))
	{
		LOG_DEBUG("RTSP from %s '%s'",sb,buf);
		RTSP rtsp(*sock);
		rtsp.initRequest(buf);
		handshakeRTSP(rtsp);
	}else if (stristr(buf,HTTP_PROTO1))
	{
		LOG_DEBUG("HTTP from %s '%s'",sb,buf);
		HTTP http(*sock);
		http.initRequest(buf);
		handshakeHTTP(http,true);
	}else
	{
		LOG_DEBUG("Connect from %s '%s'",sb,buf);
		HTTP http(*sock);
		http.initRequest(buf);
		handshakeHTTP(http,false);
	}

}
// -----------------------------------
void Servent::triggerChannel(char *str, ChanInfo::PROTOCOL proto,bool relay)	
{
	if (proto == ChanInfo::SP_HTTP)
	{
		// check that this servent can listen
		if (!canPreview())
			throw HTTPException(HTTP_SC_UNAVAILABLE,503);	
	}
	if (!isAllowed(ALLOW_DATA))
		throw HTTPException(HTTP_SC_UNAVAILABLE,503);	

	ChanInfo info;

	servMgr->getChannel(str,info,relay);

	type = T_STREAM;

	outputProtocol = proto;

	processStream(false,info);

}
// -----------------------------------
void writePLSHeader(Stream &s, PlayList::TYPE type)
{
	s.writeLine(HTTP_SC_OK);
	s.writeLine("%s %s",HTTP_HS_SERVER,PCX_AGENT);

	const char *content;
	switch(type)
	{
		case PlayList::T_PLS:
			content = MIME_XM3U;
			break;
		case PlayList::T_ASX:
			content = MIME_ASX;
			break;
		default:
			content = MIME_TEXT;
			break;
	}
	s.writeLine("%s %s",HTTP_HS_CONTENT,content);
    s.writeLine("Content-Disposition: inline");
    s.writeLine("Cache-Control: private" );
	s.writeLine("%s %s",HTTP_HS_CONNECTION,"close");

	s.writeLine("");
}

// -----------------------------------
void Servent::handshakePLS(ChanInfo &info, bool doneHandshake)
{
	char url[256];

	char in[128];

	if (!doneHandshake)
		while (sock->readLine(in,128));


	if (getLocalURL(url))
	{

		PlayList::TYPE type;

		if ((info.contentType == ChanInfo::T_WMA) || (info.contentType == ChanInfo::T_WMV))
			type = PlayList::T_ASX;
		else
			type = PlayList::T_PLS;

		writePLSHeader(*sock,type);

		PlayList *pls;

		pls = new PlayList(type,1);

		pls->addChannel(url,info);

		pls->write(*sock);

		delete pls;
	}
}
// -----------------------------------
void Servent::handshakePLS(ChanHitList **cl, int num, bool doneHandshake)
{
	char url[256];
	char in[128];

	if (!doneHandshake)
		while (sock->readLine(in,128));

	if (getLocalURL(url))
	{
		writePLSHeader(*sock,PlayList::T_SCPLS);

		PlayList *pls;

		pls = new PlayList(PlayList::T_SCPLS,num);

		for(int i=0; i<num; i++)
			pls->addChannel(url,cl[i]->info);

		pls->write(*sock);

		delete pls;
	}
}
// -----------------------------------
bool Servent::getLocalURL(char *str)
{
	if (!sock)
		throw StreamException("Not connected");


	char ipStr[64];

	Host h;
	
	if (sock->host.localIP())
		h = sock->getLocalHost();
	else
		h = servMgr->serverHost;

	h.port = servMgr->serverHost.port;

	h.toStr(ipStr);

	sprintf(str,"http://%s",ipStr);			
	return true;
}

// -----------------------------------
// Warning: testing RTSP/RTP stuff below.
// .. moved over to seperate app now.
// -----------------------------------
void Servent::handshakePOST()
{
	char tmp[1024];
    while (sock->readLine(tmp,sizeof(tmp)))
		LOG_DEBUG("POST: %s",tmp);

	throw HTTPException(HTTP_SC_BADREQUEST,400);
}


// -----------------------------------
void Servent::handshakeRTSP(RTSP &rtsp)
{
	throw HTTPException(HTTP_SC_BADREQUEST,400);
}
// -----------------------------------
void Servent::handshakeCMD(char *cmd)
{
	char tmp[256];
	char result[256];
	char arg[512];
	char curr[256];

	char	jumpStr[128];
	char	*jumpArg=NULL;
	bool	retHTML=true;
	strcpy(result,"OK");

	HTTP http(*sock);

	char user[64],pass[64];

	Cookie cookie;


	user[0] = pass[0] = 0;
    while (http.nextHeader())
	{
		char *arg = http.getArgStr();
		if (!arg)
			continue;

		//LOG_DEBUG("%s",http.cmdLine);