#include "epg.h"

#include "common.h"

#include "helper.h"

#include <limits.h>

#include <vdr/eit.h>

#include <vdr/epg.h>

#include <vdr/svdrp.h>

#include <vdr/timers.h>

namespace cDBusEpgHelper

{

enum eMode { dmmAll, dmmPresent, dmmFollowing, dmmAtTime };

static const char *_xmlNodeInfo =

"<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"

" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"

"<node>\n"

" <interface name=\""DBUS_VDR_EPG_INTERFACE"\">\n"

" <method name=\"DisableScanner\">\n"

" <arg name=\"eitdisabletime\" type=\"i\" direction=\"in\"/>\n"

" <arg name=\"replycode\" type=\"i\" direction=\"out\"/>\n"

" <arg name=\"replymessage\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"EnableScanner\">\n"

" <arg name=\"replycode\" type=\"i\" direction=\"out\"/>\n"

" <arg name=\"replymessage\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"ClearEPG\">\n"

" <arg name=\"channel\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"eitdisabletime\" type=\"i\" direction=\"in\"/>\n"

" <arg name=\"replycode\" type=\"i\" direction=\"out\"/>\n"

" <arg name=\"replymessage\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"PutEntry\">\n"

" <arg name=\"entryline\" type=\"as\" direction=\"in\"/>\n"

" <arg name=\"replycode\" type=\"i\" direction=\"out\"/>\n"

" <arg name=\"replymessage\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"PutFile\">\n"

" <arg name=\"filename\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"replycode\" type=\"i\" direction=\"out\"/>\n"

" <arg name=\"replymessage\" type=\"s\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"Now\">\n"

" <arg name=\"channel\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"replycode\" type=\"i\" direction=\"out\"/>\n"

" <arg name=\"replymessage\" type=\"s\" direction=\"out\"/>\n"

" <arg name=\"event_list\" type=\"aa(sv)\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"Next\">\n"

" <arg name=\"channel\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"replycode\" type=\"i\" direction=\"out\"/>\n"

" <arg name=\"replymessage\" type=\"s\" direction=\"out\"/>\n"

" <arg name=\"event_list\" type=\"aa(sv)\" direction=\"out\"/>\n"

" </method>\n"

" <method name=\"At\">\n"

" <arg name=\"channel\" type=\"s\" direction=\"in\"/>\n"

" <arg name=\"time\" type=\"t\" direction=\"in\"/>\n"

" <arg name=\"replycode\" type=\"i\" direction=\"out\"/>\n"

" <arg name=\"replymessage\" type=\"s\" direction=\"out\"/>\n"

" <arg name=\"event_list\" type=\"aa(sv)\" direction=\"out\"/>\n"

" </method>\n"

" </interface>\n"

"</node>\n";

static void DisableScanner(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)

{

#if APIVERSNUM >= 10711

int eitDisableTime = 3600; // one hour should be ok as a default

int s = 0;

g_variant_get(Parameters, "(i)", &s);

if (s > 0)

eitDisableTime = s;

cString replyMessage = cString::sprintf("EIT scanner disabled for %d sseconds", eitDisableTime);

isyslog("dbus2vdr: %s.DisableScanner: %s", DBUS_VDR_EPG_INTERFACE, *replyMessage);

cEitFilter::SetDisableUntil(time(NULL) + eitDisableTime);

cDBusHelper::SendReply(Invocation, 250, *replyMessage);

#else

esyslog("dbus2vdr: %s.DisableScanner: you need at least vdr 1.7.11", DBUS_VDR_EPG_INTERFACE);

cDBusHelper::SendReply(Invocation, 550, "you need at least vdr 1.7.11");

#endif

};

static void EnableScanner(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)

{

#if APIVERSNUM >= 10711

isyslog("dbus2vdr: %s.EnableScanner: EIT scanner enabled", DBUS_VDR_EPG_INTERFACE);

cEitFilter::SetDisableUntil(0);

cDBusHelper::SendReply(Invocation, 250, "EIT scanner enabled");

#else

esyslog("dbus2vdr: %s.EnableScanner: you need at least vdr 1.7.11", DBUS_VDR_EPG_INTERFACE);

cDBusHelper::SendReply(Invocation, 550, "you need at least vdr 1.7.11");

#endif

};

static void ClearEPG(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)

{

const char *channel = NULL;

int timeout = 0;

g_variant_get(Parameters, "(&si)", &channel, &timeout);

int eitDisableTime = 10; // seconds until EIT processing is enabled again after a CLRE command

if (timeout > 0) {

eitDisableTime = timeout;

isyslog("dbus2vdr: %s.ClearEPG: using %d seconds as EIT disable timeout", DBUS_VDR_EPG_INTERFACE, eitDisableTime);

}

if (channel) {

tChannelID ChannelID = tChannelID::InvalidID;

if (isnumber(channel)) {

int o = strtol(channel, NULL, 10);

#if VDRVERSNUM > 20300

LOCK_CHANNELS_READ;

const cChannels *channels = Channels;

#else

cChannels *channels = &Channels;

#endif

if (o >= 1 && o <= channels->MaxNumber())

ChannelID = channels->GetByNumber(o)->GetChannelID();

}

else {

ChannelID = tChannelID::FromString(channel);

if (ChannelID == tChannelID::InvalidID) {

const cChannels *channels = NULL;

#if VDRVERSNUM > 20300

LOCK_CHANNELS_READ;

channels = Channels;

#else

channels = &Channels;

#endif

for (const cChannel *Channel = channels->First(); Channel; Channel = channels->Next(Channel)) {

if (!Channel->GroupSep()) {

if (strcasecmp(Channel->Name(), channel) == 0) {

ChannelID = Channel->GetChannelID();

break;

}

}

}

}

}

if (!(ChannelID == tChannelID::InvalidID)) {

#if VDRVERSNUM > 20300

cStateKey StateKey;

cSchedules *s = cSchedules::GetSchedulesWrite(StateKey, 1000);

#else

cSchedulesLock SchedulesLock(true, 1000);

cSchedules *s = (cSchedules *)cSchedules::Schedules(SchedulesLock);

#endif

if (s) {

cSchedule *Schedule = NULL;

ChannelID.ClrRid();

for (cSchedule *p = s->First(); p; p = s->Next(p)) {

if (p->ChannelID() == ChannelID) {

Schedule = p;

break;

}

}

if (Schedule) {

Schedule->Cleanup(INT_MAX);

#if APIVERSNUM >= 10711

cEitFilter::SetDisableUntil(time(NULL) + eitDisableTime);

#endif

cString replyMessage = cString::sprintf("EPG data of channel \"%s\" cleared", channel);

cDBusHelper::SendReply(Invocation, 250, *replyMessage);

}

else {

cString replyMessage = cString::sprintf("No EPG data found for channel \"%s\"", channel);

cDBusHelper::SendReply(Invocation, 550, *replyMessage);

}

#if VDRVERSNUM > 20300

StateKey.Remove();

#endif

}

else

cDBusHelper::SendReply(Invocation, 451, "Can't get EPG data");

}

else {

cString replyMessage = cString::sprintf("Undefined channel \"%s\"", channel);

cDBusHelper::SendReply(Invocation, 501, *replyMessage);

}

}

else {

#if VDRVERSNUM > 20300

LOCK_TIMERS_WRITE;

LOCK_SCHEDULES_WRITE;

for (cTimer *Timer = Timers->First(); Timer; Timer = Timers->Next(Timer))

Timer->SetEvent(NULL); // processing all timers here (local *and* remote)

for (cSchedule *Schedule = Schedules->First(); Schedule; Schedule = Schedules->Next(Schedule))

Schedule->Cleanup(INT_MAX);

#else

cSchedules::ClearAll();

#endif

cEitFilter::SetDisableUntil(time(NULL) + eitDisableTime);

cDBusHelper::SendReply(Invocation, 250, "EPG data cleared");

}

};

#if VDRVERSNUM > 20300

// copied from svdrp.c, maybe it will be available in future versions?

// --- cPUTEhandler ----------------------------------------------------------

class cPUTEhandler {

private:

FILE *f;

int status;

const char *message;

public:

cPUTEhandler(void);

~cPUTEhandler();

bool Process(const char *s);

int Status(void) { return status; }

const char *Message(void) { return message; }

};

cPUTEhandler::cPUTEhandler(void)

{

if ((f = tmpfile()) != NULL) {

status = 354;

message = "Enter EPG data, end with \".\" on a line by itself";

}

else {

LOG_ERROR;

status = 554;

message = "Error while opening temporary file";

}

}

cPUTEhandler::~cPUTEhandler()

{

if (f)

fclose(f);

}

bool cPUTEhandler::Process(const char *s)

{

if (f) {

if (strcmp(s, ".") != 0) {

fputs(s, f);

fputc('\n', f);

return true;

}

else {

rewind(f);

if (cSchedules::Read(f)) {

cSchedules::Cleanup(true);

status = 250;

message = "EPG data processed";

}

else {

status = 451;

message = "Error while processing EPG data";

}

fclose(f);

f = NULL;

}

}

return false;

}

#endif

static void PutEntry(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)

{

gsize len = 0;

GVariant *array = g_variant_get_child_value(Parameters, 0);

const gchar **line = g_variant_get_strv(array, &len);

if (len < 1) {

g_free(line);

cDBusHelper::SendReply(Invocation, 501, "at least one element must be given");

return;

}

cPUTEhandler *handler = new cPUTEhandler();

if (handler->Status() == 354) {

for (gsize i = 0; i < len; i++) {

d4syslog("dbus2vdr: %s.PutEntry: item = %s", DBUS_VDR_EPG_INTERFACE, line[i]);

d4syslog("dbus2vdr: %s.PutEntry: status = %d, message = %s", DBUS_VDR_EPG_INTERFACE, handler->Status(), handler->Message());

if (!handler->Process(line[i]))

break;

}

d4syslog("dbus2vdr: %s.PutEntry: status = %d, message = %s", DBUS_VDR_EPG_INTERFACE, handler->Status(), handler->Message());

if (handler->Status() == 354)

handler->Process(".");

}

cDBusHelper::SendReply(Invocation, handler->Status(), handler->Message());

delete handler;

g_free(line);

};

static void PutFile(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)

{

const char *filename = NULL;

g_variant_get(Parameters, "(&s)", &filename);

if ((filename != NULL) && (*filename != 0)) {

FILE *f = fopen(filename, "r");

if (f) {

cString message = cString::sprintf("start reading epg data from %s", filename);

cDBusHelper::SendReply(Invocation, 0, *message);

if (cSchedules::Read(f))

cSchedules::Cleanup(true);

fclose(f);

}

else {

esyslog("dbus2vdr: %s.PutFile: error opening %s", DBUS_VDR_EPG_INTERFACE, filename);

cString message = cString::sprintf("error opening %s", filename);

cDBusHelper::SendReply(Invocation, -2, *message);

}

}

else

cDBusHelper::SendReply(Invocation, -1, "no filename");

};

static void sAddEvent(GVariantBuilder *Array, const cEvent &Event)

{

const char *c;

guint32 tu32;

guint64 tu64;

int ti;

gboolean tb;

GVariantBuilder *arr = g_variant_builder_new(G_VARIANT_TYPE("a(sv)"));

cString cid = Event.ChannelID().ToString();

c = *cid;

cDBusHelper::AddKeyValue(arr, "ChannelID", "s", (void**)&c);

tu32 = Event.EventID();

cDBusHelper::AddKeyValue(arr, "EventID", "u", (void**)&tu32);

c = Event.Title();

if (c != NULL)

cDBusHelper::AddKeyValue(arr, "Title", "s", (void**)&c);

c = Event.ShortText();

if (c != NULL)

cDBusHelper::AddKeyValue(arr, "ShortText", "s", (void**)&c);

c = Event.Description();

if (c != NULL)

cDBusHelper::AddKeyValue(arr, "Description", "s", (void**)&c);

tu64 = Event.StartTime();

cDBusHelper::AddKeyValue(arr, "StartTime", "t", (void**)&tu64);

tu64 = Event.EndTime();

cDBusHelper::AddKeyValue(arr, "EndTime", "t", (void**)&tu64);

tu64 = Event.Duration();

cDBusHelper::AddKeyValue(arr, "Duration", "t", (void**)&tu64);

tu64 = Event.Vps();

cDBusHelper::AddKeyValue(arr, "Vps", "t", (void**)&tu64);

ti = Event.RunningStatus();

cDBusHelper::AddKeyValue(arr, "RunningStatus", "i", (void**)&ti);

#if VDRVERSNUM >= 10711

ti = Event.ParentalRating();

cDBusHelper::AddKeyValue(arr, "ParentalRating", "i", (void**)&ti);

tb = Event.HasTimer();

cDBusHelper::AddKeyValue(arr, "HasTimer", "b", (void**)&tb);

for (int i = 0; i < MaxEventContents; i++) {

tu32 = Event.Contents(i);

if (tu32 != 0) {

cDBusHelper::AddKeyValue(arr, *cString::sprintf("ContentID[%d]", i), "u", (void**)&tu32);

c = cEvent::ContentToString(tu32);

cDBusHelper::AddKeyValue(arr, *cString::sprintf("Content[%d]", i), "s", (void**)&c);

}

}

#endif

g_variant_builder_add_value(Array, g_variant_builder_end(arr));

g_variant_builder_unref(arr);

}

#if VDRVERSNUM > 20300

static bool sGetChannel(GVariant *Arg, const char **Input, const cChannels* Channels, const cChannel **Channel)

#else

static bool sGetChannel(GVariant *Arg, const char **Input, cChannels* Channels, const cChannel **Channel)

#endif

{

*Channel = NULL;

*Input = NULL;

if (g_variant_is_of_type(Arg, G_VARIANT_TYPE_STRING)) {

g_variant_get(Arg, "&s", Input);

if (**Input == 0)

return true;

if (isnumber(*Input))

*Channel = Channels->GetByNumber(strtol(*Input, NULL, 10));

else

*Channel = Channels->GetByChannelID(tChannelID::FromString(*Input));

if (*Channel == NULL)

return false;

}

return true;

}

static void sReturnError(GDBusMethodInvocation *Invocation, int ReplyCode, const char *ReplyMessage)

{

GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("(isaa(sv))"));

g_variant_builder_add(builder, "i", ReplyCode);

g_variant_builder_add(builder, "s", ReplyMessage);

GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("aa(sv)"));

GVariantBuilder *innerArray = g_variant_builder_new(G_VARIANT_TYPE("a(sv)"));

g_variant_builder_add_value(array, g_variant_builder_end(innerArray));

g_variant_builder_add_value(builder, g_variant_builder_end(array));

g_dbus_method_invocation_return_value(Invocation, g_variant_builder_end(builder));

g_variant_builder_unref(innerArray);

g_variant_builder_unref(array);

g_variant_builder_unref(builder);

};

static void sGetEntries(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation, eMode mode)

{

#if VDRVERSNUM > 20300

LOCK_CHANNELS_READ;

const cChannels *channels = Channels;

#else

cChannels *channels = &Channels;

#endif

const cChannel *channel = NULL;

guint64 atTime = 0;

GVariant *first = g_variant_get_child_value(Parameters, 0);

const char *c = NULL;

if (!sGetChannel(first, &c, channels, &channel)) {

cString reply = cString::sprintf("channel \"%s\" not defined", c);

esyslog("dbus2vdr: %s.GetEntries: %s", DBUS_VDR_EPG_INTERFACE, *reply);

sReturnError(Invocation, 501, *reply);

g_variant_unref(first);

return;

}

if (mode == dmmAtTime) {

GVariant *second = g_variant_get_child_value(Parameters, 1);

g_variant_get(second, "t", &atTime);

g_variant_unref(second);

if (atTime == 0) {

cString reply = cString::sprintf("missing time");

esyslog("dbus2vdr: %s.GetEntries: %s", DBUS_VDR_EPG_INTERFACE, *reply);

sReturnError(Invocation, 501, *reply);

g_variant_unref(first);

return;

}

}

g_variant_unref(first);

const cSchedules *scheds = NULL;

#if VDRVERSNUM > 20300

cStateKey StateKey;

scheds = cSchedules::GetSchedulesRead(StateKey, 1000);

#else

cSchedulesLock sl(false, 1000);

if (!sl.Locked()) {

sReturnError(Invocation, 550, "got no lock on schedules");

return;

}

scheds = cSchedules::Schedules(sl);

#endif

if (scheds == NULL) {

sReturnError(Invocation, 550, "got no schedules");

return;

}

GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("(isaa(sv))"));

g_variant_builder_add(builder, "i", 250);

g_variant_builder_add(builder, "s", "");

GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("aa(sv)"));

bool next = false;

if (channel == NULL) {

channel = channels->First();

next = true;

}

while (channel) {

const cSchedule *s = scheds->GetSchedule(channel, false);

if (s != NULL) {

const cEvent *e = NULL;

switch (mode) {

case dmmPresent:

e = s->GetPresentEvent();

break;

case dmmFollowing:

e = s->GetFollowingEvent();

break;

case dmmAtTime:

e = s->GetEventAround(atTime);

break;

default:

e = NULL;

break;

}

if (e != NULL)

sAddEvent(array, *e);

}

if (next)

channel = channels->Next(channel);

else

break;

}

#if VDRVERSNUM > 20300

StateKey.Remove();

#endif

g_variant_builder_add_value(builder, g_variant_builder_end(array));

g_dbus_method_invocation_return_value(Invocation, g_variant_builder_end(builder));

g_variant_builder_unref(array);

g_variant_builder_unref(builder);

};

static void Now(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)

{

sGetEntries(Object, Parameters, Invocation, dmmPresent);

};

static void Next(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)

{

sGetEntries(Object, Parameters, Invocation, dmmFollowing);

};

static void At(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)

{

sGetEntries(Object, Parameters, Invocation, dmmAtTime);

};

}

cDBusEpg::cDBusEpg(void)

:cDBusObject("/EPG", cDBusEpgHelper::_xmlNodeInfo)

{

AddMethod("DisableScanner", cDBusEpgHelper::DisableScanner);

AddMethod("EnableScanner", cDBusEpgHelper::EnableScanner);

AddMethod("ClearEPG", cDBusEpgHelper::ClearEPG);

AddMethod("PutEntry", cDBusEpgHelper::PutEntry);

AddMethod("PutFile", cDBusEpgHelper::PutFile);

AddMethod("Now", cDBusEpgHelper::Now);

AddMethod("Next", cDBusEpgHelper::Next);

AddMethod("At", cDBusEpgHelper::At);

}

cDBusEpg::~cDBusEpg(void)

{

}