yWeb 2.8.a.3 Alpha-Version

git-svn-id: file:///home/bas/coolstream_public_svn/THIRDPARTY/applications/neutrino-experimental@407 e54a6e83-5905-42d5-8d5c-058d10e6a962

src/nhttpd/tuxboxapi/coolstream/Makefile.am

@@ -0,0 +1,20 @@
+AM_CPPFLAGS = -fno-rtti -fno-exceptions
+
+INCLUDES = \
+	-I$(top_srcdir)/lib \
+	-I$(top_srcdir)/src/zapit/include \
+	-I$(top_srcdir)/src \
+	-I$(top_srcdir)/src/nhttpd \
+	-I$(top_srcdir)/src/nhttpd/yhttpd_core \
+	-I$(top_srcdir)/src/nhttpd/yhttpd_mods \
+	-I$(top_srcdir)/lib/connection \
+	-I$(top_srcdir)/lib/libeventserver \
+	-I$(top_srcdir)/lib/libconfigfile \
+	-I$(top_srcdir)/lib/xmltree \
+	@FREETYPE_CFLAGS@
+
+noinst_LIBRARIES = libnhttpd_tuxboxapi.a
+
+libnhttpd_tuxboxapi_a_SOURCES = \
+	neutrinoapi.cpp neutrinoyparser.cpp controlapi.cpp
+	

src/nhttpd/tuxboxapi/coolstream/controlapi.h

@@ -0,0 +1,114 @@
+//=============================================================================
+// NHTTPD
+// Neutrino ControlAPI
+//=============================================================================
+#ifndef __nhttpd_neutrinocontrolapi_hpp__
+#define __nhttpd_neutrinocontrolapi_hpp__
+// C++
+#include <string>
+// yhttpd
+#include "yhook.h"
+
+// forward declaration
+class CNeutrinoAPI;
+
+//-----------------------------------------------------------------------------
+class CControlAPI : public Cyhook
+{
+private:
+	// Dispatcher Array
+	typedef void (CControlAPI::*TyFunc)(CyhookHandler *hh);
+	typedef struct
+	{
+		const char *func_name;
+		TyFunc pfunc;
+		const char *mime_type;
+	} TyCgiCall;
+	const static TyCgiCall yCgiCallList[];
+
+	int rc_send(int ev, unsigned int code, unsigned int value);
+
+	// send functions for ExecuteCGI (controld api)
+	void SendEventList(CyhookHandler *hh,t_channel_id channel_id);
+	void SendcurrentVAPid(CyhookHandler *hh);
+	void SendAllCurrentVAPid(CyhookHandler *hh);
+	void SendStreamInfo(CyhookHandler *hh);
+	void SendBouquets(CyhookHandler *hh);
+	void SendBouquet(CyhookHandler *hh,int BouquetNr);
+	void SendChannelList(CyhookHandler *hh);
+	void SendTimers(CyhookHandler *hh);
+
+	// subs
+	friend class CNeutrinoWebserver; // for timer /fb/ compatibility
+	void doModifyTimer(CyhookHandler *hh);
+	void doNewTimer(CyhookHandler *hh);
+
+	//yweb
+	void YWeb_SendVideoStreamingPids(CyhookHandler *hh, int apid_no);
+	void YWeb_SendRadioStreamingPid(CyhookHandler *hh);
+	void compatibility_Timer(CyhookHandler *hh);
+	std::string YexecuteScript(CyhookHandler *hh, std::string cmd);
+
+	// CGI functions for ExecuteCGI
+	void TimerCGI(CyhookHandler *hh);
+	void SetModeCGI(CyhookHandler *hh);
+	void GetModeCGI(CyhookHandler *hh);
+	void ExecCGI(CyhookHandler *hh);
+	void SystemCGI(CyhookHandler *hh);
+	void StandbyCGI(CyhookHandler *hh);
+	void EsoundCGI(CyhookHandler *hh);
+	void RCCGI(CyhookHandler *hh);
+	void GetDateCGI(CyhookHandler *hh);
+	void GetTimeCGI(CyhookHandler *hh);
+	void GetServicesxmlCGI(CyhookHandler *hh);
+	void GetBouquetsxmlCGI(CyhookHandler *hh);
+	void GetChannel_IDCGI(CyhookHandler *hh);
+	void MessageCGI(CyhookHandler *hh);
+	void InfoCGI(CyhookHandler *hh);
+	void ShutdownCGI(CyhookHandler *hh);
+	void VolumeCGI(CyhookHandler *hh);
+	void ChannellistCGI(CyhookHandler *hh);
+	void GetBouquetCGI(CyhookHandler *hh);
+	void GetBouquetsCGI(CyhookHandler *hh);
+	void EpgCGI(CyhookHandler *hh);
+	void VersionCGI(CyhookHandler *hh);
+	void ZaptoCGI(CyhookHandler *hh);
+	void StartPluginCGI(CyhookHandler *hh);
+	void LCDAction(CyhookHandler *hh);
+	void YWebCGI(CyhookHandler *hh);
+	void RebootCGI(CyhookHandler *hh);
+	void RCEmCGI(CyhookHandler *hh);
+	void VideoFormatCGI(CyhookHandler *hh);
+	void VideoOutputCGI(CyhookHandler *hh);
+	void VCROutputCGI(CyhookHandler *hh);
+	void ScartModeCGI(CyhookHandler *hh);
+	void setBouquetCGI(CyhookHandler *hh);
+	void saveBouquetCGI(CyhookHandler *hh);
+	void moveBouquetCGI(CyhookHandler *hh);
+	void deleteBouquetCGI(CyhookHandler *hh);
+	void addBouquetCGI(CyhookHandler *hh);
+	void renameBouquetCGI(CyhookHandler *hh);
+	void changeBouquetCGI(CyhookHandler *hh);
+	void updateBouquetCGI(CyhookHandler *hh);
+	void build_live_url(CyhookHandler *hh);
+
+protected:
+	static const unsigned int PLUGIN_DIR_COUNT = 5;
+	static std::string PLUGIN_DIRS[PLUGIN_DIR_COUNT];
+	CNeutrinoAPI	*NeutrinoAPI;
+
+	void init(CyhookHandler *hh);
+	void Execute(CyhookHandler *hh);
+
+public:
+	// constructor & deconstructor
+	CControlAPI(CNeutrinoAPI *_NeutrinoAPI);
+
+	// virtual functions for HookHandler/Hook
+	virtual std::string getHookName(void) {return std::string("mod_ControlAPI");}
+	virtual std::string 	getHookVersion(void) {return std::string("$Revision: 1.1.2.2 $");}
+	virtual THandleStatus Hook_SendResponse(CyhookHandler *hh);
+	virtual THandleStatus Hook_PrepareResponse(CyhookHandler *hh);
+};
+
+#endif /* __nhttpd_neutrinocontrolapi_hpp__ */

src/nhttpd/tuxboxapi/coolstream/neutrinoapi.cpp

@@ -0,0 +1,386 @@
+//=============================================================================
+// NHTTPD
+// NeutrionAPI
+//
+// Aggregates: NeutrinoYParser, NeutrinoControlAPI
+// Defines Interfaces to:CControldClient, CSectionsdClient, CZapitClient,
+//			CTimerdClient,CLCDAPI
+// Place for common used Neutrino-functions used by NeutrinoYParser, NeutrinoControlAPI
+//=============================================================================
+
+// C
+#include <cstdlib>
+#include <cstring>
+
+// C++
+#include <string>
+#include <fstream>
+#include <map>
+
+// tuxbox
+#include <neutrinoMessages.h>
+
+#include <zapit/client/zapitclient.h>
+#include <zapit/channel.h>
+#include <zapit/bouquets.h>
+extern tallchans allchans;
+extern CBouquetManager *g_bouquetManager;
+
+// yhttpd
+#include "ylogging.h"
+
+// nhttpd
+#include "neutrinoapi.h"
+
+void sectionsd_getChannelEvents(CChannelEventList &eList, const bool tv_mode = true, t_channel_id *chidlist = NULL, int clen = 0);
+
+//=============================================================================
+// No Class Helpers
+//=============================================================================
+
+static std::map<std::string, std::string> iso639;
+#ifndef initialize_iso639_map
+bool _initialize_iso639_map(void)
+{
+	std::string s, t, u, v;
+	std::ifstream in("/share/iso-codes/iso-639.tab");
+	if (in.is_open())
+	{
+		while (in.peek() == '#')
+			getline(in, s);
+		while (in >> s >> t >> u >> std::ws)
+		{
+			getline(in, v);
+			iso639[s] = v;
+			if (s != t)
+				iso639[t] = v;
+		}
+		in.close();
+		return true;
+	}
+ 	else
+		return false;
+}
+#endif
+//-----------------------------------------------------------------------------
+const char * _getISO639Description(const char * const iso)
+{
+	std::map<std::string, std::string>::const_iterator it = iso639.find(std::string(iso));
+	if (it == iso639.end())
+		return iso;
+	else
+		return it->second.c_str();
+}
+
+//=============================================================================
+// Initialization of static variables
+//=============================================================================
+std::string CNeutrinoAPI::Dbox_Hersteller[4]	= {"none", "Nokia", "Philips", "Sagem"};
+std::string CNeutrinoAPI::videooutput_names[5]	= {"CVBS", "RGB with CVBS", "S-Video", "YUV with VBS", "YUV with CVBS"};
+std::string CNeutrinoAPI::videoformat_names[4]	= {"automatic", "16:9", "4:3 (LB)", "4:3 (PS)"};
+std::string CNeutrinoAPI::audiotype_names[5] 	= {"none", "single channel","dual channel","joint stereo","stereo"};
+
+//=============================================================================
+// Constructor & Destructor
+//=============================================================================
+CNeutrinoAPI::CNeutrinoAPI()
+{
+	Sectionsd = new CSectionsdClient();
+	Zapit = new CZapitClient();
+	Timerd = new CTimerdClient();
+
+	NeutrinoYParser = new CNeutrinoYParser(this);
+	ControlAPI = new CControlAPI(this);
+
+	UpdateBouquets();
+
+	EventServer = new CEventServer;
+	EventServer->registerEvent2( NeutrinoMessages::SHUTDOWN, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::STANDBY_ON, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::STANDBY_OFF, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::STANDBY_TOGGLE, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::EVT_POPUP, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::EVT_EXTMSG, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::CHANGEMODE, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::EVT_START_PLUGIN, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::LOCK_RC, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+	EventServer->registerEvent2( NeutrinoMessages::UNLOCK_RC, CEventServer::INITID_HTTPD, "/tmp/neutrino.sock");
+}
+//-------------------------------------------------------------------------
+
+CNeutrinoAPI::~CNeutrinoAPI(void)
+{
+	if (NeutrinoYParser)
+		delete NeutrinoYParser;
+	if (ControlAPI)
+		delete ControlAPI;
+	if (Sectionsd)
+		delete Sectionsd;
+	if (Zapit)
+		delete Zapit;
+	if (Timerd)
+		delete Timerd;
+	if (EventServer)
+		delete EventServer;
+}
+
+//-------------------------------------------------------------------------
+
+void CNeutrinoAPI::UpdateBouquets(void)
+{
+#if 0 //FIXME
+	BouquetList.clear();
+	Zapit->getBouquets(BouquetList, true, true);
+	for (unsigned int i = 1; i <= BouquetList.size(); i++)
+		UpdateBouquet(i);
+
+	UpdateChannelList();
+#endif
+}
+
+//-------------------------------------------------------------------------
+void CNeutrinoAPI::ZapTo(const char * const target)
+{
+	t_channel_id channel_id;
+
+	sscanf(target,
+		SCANF_CHANNEL_ID_TYPE,
+		&channel_id);
+
+	ZapToChannelId(channel_id);
+}
+//-------------------------------------------------------------------------
+void CNeutrinoAPI::ZapToChannelId(t_channel_id channel_id)
+{
+	if (channel_id == Zapit->getCurrentServiceID())
+	{
+		//printf("Kanal ist aktuell\n");
+		return;
+	}
+
+	if (Zapit->zapTo_serviceID(channel_id) != CZapitClient::ZAP_INVALID_PARAM)
+		Sectionsd->setServiceChanged(channel_id&0xFFFFFFFFFFFFULL, false);
+}
+//-------------------------------------------------------------------------
+
+void CNeutrinoAPI::ZapToSubService(const char * const target)
+{
+	t_channel_id channel_id;
+
+	sscanf(target,
+		SCANF_CHANNEL_ID_TYPE,
+		&channel_id);
+
+	if (Zapit->zapTo_subServiceID(channel_id) != CZapitClient::ZAP_INVALID_PARAM)
+		Sectionsd->setServiceChanged(channel_id&0xFFFFFFFFFFFFULL, false);
+}
+//-------------------------------------------------------------------------
+t_channel_id CNeutrinoAPI::ChannelNameToChannelId(std::string search_channel_name)
+{
+//FIXME depending on mode missing
+	//int mode = Zapit->getMode();
+	t_channel_id channel_id = (t_channel_id)-1;
+	CStringArray channel_names = ySplitStringVector(search_channel_name, ",");
+	for (tallchans_iterator it = allchans.begin(); it != allchans.end(); it++) {
+		std::string channel_name = it->second.getName();
+		for(unsigned int j=0;j<channel_names.size();j++)
+		{
+			if(channel_names[j].length() == channel_name.length() &&
+				equal(channel_names[j].begin(), channel_names[j].end(),
+				channel_name.begin(), nocase_compare)) //case insensitive  compare
+			{
+				channel_id = it->second.channel_id;
+				break;
+			}
+		}
+	}
+	return channel_id;
+}
+
+//-------------------------------------------------------------------------
+// Get functions
+//-------------------------------------------------------------------------
+
+bool CNeutrinoAPI::GetStreamInfo(int bitInfo[10])
+{
+	char *key, *tmpptr, buf[100];
+	long value;
+	int pos = 0;
+
+	memset(bitInfo, 0, sizeof(bitInfo));
+
+	FILE *fd = fopen("/proc/bus/bitstream", "rt");
+
+	if (fd == NULL)
+	{
+		dprintf("error while opening proc-bitstream\n" );
+		return false;
+	}
+
+	fgets(buf,35,fd);//dummy
+	while(!feof(fd))
+	{
+		if(fgets(buf,35,fd)!=NULL)
+		{
+			buf[strlen(buf)-1]=0;
+			tmpptr=buf;
+			key=strsep(&tmpptr,":");
+			value=strtoul(tmpptr,NULL,0);
+			bitInfo[pos]= value;
+			pos++;
+		}
+	}
+	fclose(fd);
+
+	return true;
+}
+
+//-------------------------------------------------------------------------
+
+bool CNeutrinoAPI::GetChannelEvents(void)
+{
+	sectionsd_getChannelEvents(eList);
+	CChannelEventList::iterator eventIterator;
+
+	ChannelListEvents.clear();
+
+	if (eList.begin() == eList.end())
+		return false;
+
+	for (eventIterator = eList.begin(); eventIterator != eList.end(); eventIterator++)
+		ChannelListEvents[(*eventIterator).get_channel_id()] = &(*eventIterator);
+
+	return true;
+}
+
+//-------------------------------------------------------------------------
+
+std::string CNeutrinoAPI::GetServiceName(t_channel_id channel_id)
+{
+	tallchans_iterator it = allchans.find(channel_id);
+	if (it != allchans.end())
+		it->second.getName();
+	return "";
+}
+
+//-------------------------------------------------------------------------
+
+CZapitClient::BouquetChannelList *CNeutrinoAPI::GetBouquet(unsigned int, int)
+{
+	//FIXME
+	printf("CNeutrinoAPI::GetChannelList still used !\n");
+	return NULL;
+}
+
+//-------------------------------------------------------------------------
+
+CZapitClient::BouquetChannelList *CNeutrinoAPI::GetChannelList(int)
+{
+//FIXME
+	printf("CNeutrinoAPI::GetChannelList still used !\n");
+	return NULL;
+}
+
+//-------------------------------------------------------------------------
+void CNeutrinoAPI::UpdateBouquet(unsigned int)
+{
+	//FIXME
+}
+
+//-------------------------------------------------------------------------
+void CNeutrinoAPI::UpdateChannelList(void)
+{
+	//FIXME
+}
+
+//-------------------------------------------------------------------------
+
+std::string CNeutrinoAPI::timerEventType2Str(CTimerd::CTimerEventTypes type)
+{
+	std::string result;
+	switch (type) {
+	case CTimerd::TIMER_SHUTDOWN:
+		result = "Shutdown";
+		break;
+	case CTimerd::TIMER_NEXTPROGRAM:
+		result = "Next program";
+		break;
+	case CTimerd::TIMER_ZAPTO:
+		result = "Zap to";
+		break;
+	case CTimerd::TIMER_STANDBY:
+		result = "Standby";
+		break;
+	case CTimerd::TIMER_RECORD:
+		result = "Record";
+		break;
+	case CTimerd::TIMER_REMIND:
+		result = "Reminder";
+		break;
+	case CTimerd::TIMER_EXEC_PLUGIN:
+		result = "Execute plugin";
+		break;
+	case CTimerd::TIMER_SLEEPTIMER:
+		result = "Sleeptimer";
+		break;
+	default:
+		result = "Unknown";
+		break;
+	}
+	return result;
+}
+
+//-------------------------------------------------------------------------
+
+std::string CNeutrinoAPI::timerEventRepeat2Str(CTimerd::CTimerEventRepeat rep)
+{
+	std::string result;
+	switch (rep) {
+	case CTimerd::TIMERREPEAT_ONCE:
+		result = "once";
+		break;
+	case CTimerd::TIMERREPEAT_DAILY:
+		result = "daily";
+		break;
+	case CTimerd::TIMERREPEAT_WEEKLY:
+		result = "weekly";
+		break;
+	case CTimerd::TIMERREPEAT_BIWEEKLY:
+		result = "2-weekly";
+		break;
+	case CTimerd::TIMERREPEAT_FOURWEEKLY:
+		result = "4-weekly";
+		break;
+	case CTimerd::TIMERREPEAT_MONTHLY:
+		result = "monthly";
+		break;
+	case CTimerd::TIMERREPEAT_BYEVENTDESCRIPTION:
+		result = "event";
+		break;
+	case CTimerd::TIMERREPEAT_WEEKDAYS:
+		result = "weekdays";
+		break;
+	default:
+		if (rep > CTimerd::TIMERREPEAT_WEEKDAYS)
+		{
+			if (rep & 0x0200)
+				result += "Mo ";
+			if (rep & 0x0400)
+				result += "Tu ";
+			if (rep & 0x0800)
+				result += "We ";
+			if (rep & 0x1000)
+				result += "Th ";
+			if (rep & 0x2000)
+				result += "Fr ";
+			if (rep & 0x4000)
+				result += "Sa ";
+			if (rep & 0x8000)
+				result += "Su ";
+		}
+		else
+			result = "Unknown";
+	}
+	return result;
+}
+

src/nhttpd/tuxboxapi/coolstream/neutrinoapi.h

@@ -0,0 +1,84 @@
+#ifndef __nhttpd_neutrinoapi_h__
+#define __nhttpd_neutrinoapi_h__
+
+// c++
+#include <map>
+#include <string>
+
+// tuxbox
+#include <eventserver.h>
+#include <sectionsdclient/sectionsdclient.h>
+#include <timerdclient/timerdclient.h>
+#include <zapit/client/zapitclient.h>
+
+// nhttpd
+#include "helper.h"
+#include "neutrinoyparser.h"
+#include "controlapi.h"
+
+//-------------------------------------------------------------------------
+// No Class Helpers
+const char * _getISO639Description(const char * const iso);
+bool _initialize_iso639_map(void);
+
+//-------------------------------------------------------------------------
+class CNeutrinoAPI
+{
+	// Clientlibs
+	CSectionsdClient	*Sectionsd;
+	CZapitClient		*Zapit;
+	CTimerdClient		*Timerd;
+	CEventServer		*EventServer;
+
+	// complete channellists
+	CZapitClient::BouquetChannelList RadioChannelList,TVChannelList;
+	// events of actual channel
+	std::map<unsigned, CChannelEvent *> ChannelListEvents;
+	// List of available tv bouquets
+	std::map<int, CZapitClient::BouquetChannelList> TVBouquetsList;
+	// List of available radio bouquets
+	std::map<int, CZapitClient::BouquetChannelList> RadioBouquetsList;
+	// List of bouquets
+	CZapitClient::BouquetList BouquetList;
+
+	//bool standby_mode;
+
+	// some constants
+	static std::string Dbox_Hersteller[4];
+	static std::string videooutput_names[5];
+	static std::string videoformat_names[4];
+	static std::string audiotype_names[5];
+
+	// get functions to collect data
+	bool GetChannelEvents(void);
+	bool GetStreamInfo(int bitinfo[10]);
+	std::string GetServiceName(t_channel_id channel_id);
+	CZapitClient::BouquetChannelList *GetBouquet(unsigned int BouquetNr, int Mode);
+	CZapitClient::BouquetChannelList *GetChannelList(int Mode);
+
+	// support functions
+	void ZapTo          (const char * const target);
+	void ZapToSubService(const char * const target);
+	void ZapToChannelId (t_channel_id channel_id);
+	t_channel_id ChannelNameToChannelId(std::string search_channel_name);
+
+	void UpdateBouquet(unsigned int BouquetNr);
+	void UpdateChannelList(void);
+	void UpdateBouquets(void);
+
+	std::string timerEventType2Str(CTimerd::CTimerEventTypes type);
+	std::string timerEventRepeat2Str(CTimerd::CTimerEventRepeat rep);
+
+public:
+	CNeutrinoAPI();
+	~CNeutrinoAPI(void);
+
+	CChannelEventList	eList;
+	CNeutrinoYParser	*NeutrinoYParser;
+	CControlAPI		*ControlAPI;
+
+	friend class CNeutrinoYParser; // Backreference
+	friend class CControlAPI;
+};
+
+#endif /*__nhttpd_neutrinoapi_h__*/

src/nhttpd/tuxboxapi/coolstream/neutrinoyparser.h

@@ -0,0 +1,70 @@
+//=============================================================================
+// NHTTPD
+// Neutrino yParser Extenstion
+//=============================================================================
+
+#ifndef __nhttpd_neutrinoyparser_h__
+#define __nhttpd_neutrinoyparser_h__
+
+// c++
+#include <string>
+// yhttpd
+#include "yhttpd.h"
+#include "ytypes_globals.h"
+#include "mod_yparser.h"
+
+// forward declaration
+class CNeutrinoAPI;
+//-----------------------------------------------------------------------------
+class CNeutrinoYParser : public CyParser
+{
+private:
+	// yParser funcs for Tuxbox
+	typedef std::string (CNeutrinoYParser::*TyFunc)(CyhookHandler *hh, std::string para);
+	typedef struct
+	{
+		const char *func_name;
+		TyFunc pfunc;
+	} TyFuncCall;
+	const static TyFuncCall yFuncCallList[];
+
+	// func TUXBOX
+	std::string func_mount_get_list(CyhookHandler *hh, std::string para);
+	std::string func_mount_set_values(CyhookHandler *hh, std::string para);
+	std::string func_get_bouquets_as_dropdown(CyhookHandler *hh, std::string para);
+	std::string func_get_bouquets_as_templatelist(CyhookHandler *hh, std::string para);
+	std::string func_get_actual_bouquet_number(CyhookHandler *hh, std::string para);
+	std::string func_get_channels_as_dropdown(CyhookHandler *hh, std::string para);
+	std::string func_get_actual_channel_id(CyhookHandler *hh, std::string para);
+	std::string func_get_bouquets_with_epg(CyhookHandler *hh, std::string para);
+	std::string func_get_mode(CyhookHandler *hh, std::string para);
+	std::string func_get_video_pids(CyhookHandler *hh, std::string para);
+	std::string func_get_radio_pid(CyhookHandler *hh, std::string para);
+	std::string func_get_audio_pids_as_dropdown(CyhookHandler *hh, std::string para);
+	std::string func_unmount_get_list(CyhookHandler *hh, std::string para);
+	std::string func_get_partition_list(CyhookHandler *hh, std::string para);
+	std::string func_get_boxtype(CyhookHandler *hh, std::string para);
+	std::string func_get_current_stream_info(CyhookHandler *hh, std::string para);
+	std::string func_get_timer_list(CyhookHandler *hh, std::string para);
+	std::string func_set_timer_form(CyhookHandler *hh, std::string para);
+	std::string func_bouquet_editor_main(CyhookHandler *hh, std::string para);
+	std::string func_set_bouquet_edit_form(CyhookHandler *hh, std::string para);
+
+protected:
+	CNeutrinoAPI	*NeutrinoAPI;
+
+public:
+	// constructor & deconstructor
+	CNeutrinoYParser(CNeutrinoAPI	*_NeutrinoAPI);
+	virtual ~CNeutrinoYParser(void);
+
+	// virtual functions for BaseClass
+	virtual std::string 	YWeb_cgi_func(CyhookHandler *hh, std::string ycmd);
+	// virtual functions for HookHandler/Hook
+	virtual std::string 	getHookName(void) {return std::string("mod_NeutrinoYParser-Coolstream");}
+	virtual std::string 	getHookVersion(void) {return std::string("$Revision: 1.1.2.1 $");}
+	virtual THandleStatus	Hook_SendResponse(CyhookHandler *hh);
+	virtual THandleStatus 	Hook_ReadConfig(CConfigFile *Config, CStringList &ConfigList);
+};
+
+#endif /*__nhttpd_neutrinoyparser_h__*/