2000-02-19 13:36:48 +01:00
|
|
|
/*
|
|
|
|
* config.c: Configuration file handling
|
|
|
|
*
|
2000-04-24 09:46:05 +02:00
|
|
|
* See the main source file 'vdr.c' for copyright information and
|
2000-02-19 13:36:48 +01:00
|
|
|
* how to reach the author.
|
|
|
|
*
|
2004-01-09 15:53:59 +01:00
|
|
|
* $Id: config.c 1.119 2004/01/06 17:09:54 kls Exp $
|
2000-02-19 13:36:48 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <stdlib.h>
|
2000-11-11 10:39:27 +01:00
|
|
|
#include "i18n.h"
|
2000-02-19 13:36:48 +01:00
|
|
|
#include "interface.h"
|
2002-05-09 16:26:56 +02:00
|
|
|
#include "plugin.h"
|
2002-06-16 12:57:31 +02:00
|
|
|
#include "recording.h"
|
2000-02-19 13:36:48 +01:00
|
|
|
|
2001-10-20 13:09:38 +02:00
|
|
|
// IMPORTANT NOTE: in the 'sscanf()' calls there is a blank after the '%d'
|
|
|
|
// format characters in order to allow any number of blanks after a numeric
|
|
|
|
// value!
|
|
|
|
|
2000-11-11 16:38:41 +01:00
|
|
|
// --- cCommand -------------------------------------------------------------
|
|
|
|
|
|
|
|
char *cCommand::result = NULL;
|
|
|
|
|
|
|
|
cCommand::cCommand(void)
|
|
|
|
{
|
|
|
|
title = command = NULL;
|
2002-10-13 09:03:53 +02:00
|
|
|
confirm = false;
|
2000-11-11 16:38:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
cCommand::~cCommand()
|
|
|
|
{
|
2002-08-11 13:32:23 +02:00
|
|
|
free(title);
|
|
|
|
free(command);
|
2000-11-11 16:38:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool cCommand::Parse(const char *s)
|
|
|
|
{
|
|
|
|
const char *p = strchr(s, ':');
|
|
|
|
if (p) {
|
|
|
|
int l = p - s;
|
|
|
|
if (l > 0) {
|
2002-10-13 09:03:53 +02:00
|
|
|
title = MALLOC(char, l + 1);
|
|
|
|
stripspace(strn0cpy(title, s, l + 1));
|
2000-11-11 16:38:41 +01:00
|
|
|
if (!isempty(title)) {
|
2002-10-13 09:03:53 +02:00
|
|
|
int l = strlen(title);
|
|
|
|
if (l > 1 && title[l - 1] == '?') {
|
|
|
|
confirm = true;
|
|
|
|
title[l - 1] = 0;
|
|
|
|
}
|
2000-11-11 16:38:41 +01:00
|
|
|
command = stripspace(strdup(skipspace(p + 1)));
|
|
|
|
return !isempty(command);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2002-10-13 12:14:49 +02:00
|
|
|
const char *cCommand::Execute(const char *Parameters)
|
2000-11-11 16:38:41 +01:00
|
|
|
{
|
2002-08-11 13:32:23 +02:00
|
|
|
free(result);
|
2000-11-11 16:38:41 +01:00
|
|
|
result = NULL;
|
2002-10-13 12:14:49 +02:00
|
|
|
char *cmdbuf = NULL;
|
|
|
|
if (Parameters)
|
|
|
|
asprintf(&cmdbuf, "%s %s", command, Parameters);
|
|
|
|
const char *cmd = cmdbuf ? cmdbuf : command;
|
|
|
|
dsyslog("executing command '%s'", cmd);
|
|
|
|
FILE *p = popen(cmd, "r");
|
2000-11-11 16:38:41 +01:00
|
|
|
if (p) {
|
|
|
|
int l = 0;
|
|
|
|
int c;
|
|
|
|
while ((c = fgetc(p)) != EOF) {
|
|
|
|
if (l % 20 == 0)
|
|
|
|
result = (char *)realloc(result, l + 21);
|
|
|
|
result[l++] = c;
|
|
|
|
}
|
|
|
|
if (result)
|
|
|
|
result[l] = 0;
|
|
|
|
pclose(p);
|
|
|
|
}
|
|
|
|
else
|
2002-10-13 12:14:49 +02:00
|
|
|
esyslog("ERROR: can't open pipe for command '%s'", cmd);
|
|
|
|
free(cmdbuf);
|
2000-11-11 16:38:41 +01:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2002-02-02 17:20:54 +01:00
|
|
|
// -- cSVDRPhost -------------------------------------------------------------
|
|
|
|
|
|
|
|
cSVDRPhost::cSVDRPhost(void)
|
|
|
|
{
|
|
|
|
addr.s_addr = 0;
|
|
|
|
mask = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cSVDRPhost::Parse(const char *s)
|
|
|
|
{
|
|
|
|
mask = 0xFFFFFFFF;
|
|
|
|
const char *p = strchr(s, '/');
|
|
|
|
if (p) {
|
|
|
|
char *error = NULL;
|
|
|
|
int m = strtoul(p + 1, &error, 10);
|
2002-09-29 13:40:45 +02:00
|
|
|
if (error && *error && !isspace(*error) || m > 32)
|
2002-02-02 17:20:54 +01:00
|
|
|
return false;
|
|
|
|
*(char *)p = 0; // yes, we know it's 'const' - will be restored!
|
|
|
|
if (m == 0)
|
|
|
|
mask = 0;
|
|
|
|
else
|
|
|
|
mask >>= (32 - m);
|
|
|
|
}
|
|
|
|
int result = inet_aton(s, &addr);
|
|
|
|
if (p)
|
|
|
|
*(char *)p = '/'; // there it is again
|
|
|
|
return result != 0 && (mask != 0 || addr.s_addr == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cSVDRPhost::Accepts(in_addr_t Address)
|
|
|
|
{
|
|
|
|
return (Address & mask) == addr.s_addr;
|
|
|
|
}
|
|
|
|
|
2002-03-03 16:12:29 +01:00
|
|
|
// -- cCaDefinition ----------------------------------------------------------
|
|
|
|
|
|
|
|
cCaDefinition::cCaDefinition(void)
|
|
|
|
{
|
|
|
|
number = 0;
|
|
|
|
description = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cCaDefinition::~cCaDefinition()
|
|
|
|
{
|
2002-08-11 13:32:23 +02:00
|
|
|
free(description);
|
2002-03-03 16:12:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool cCaDefinition::Parse(const char *s)
|
|
|
|
{
|
|
|
|
return 2 == sscanf(s, "%d %a[^\n]", &number, &description) && description && *description;
|
|
|
|
}
|
|
|
|
|
2000-11-11 16:38:41 +01:00
|
|
|
// -- cCommands --------------------------------------------------------------
|
|
|
|
|
|
|
|
cCommands Commands;
|
2002-10-13 12:14:49 +02:00
|
|
|
cCommands RecordingCommands;
|
2000-11-11 16:38:41 +01:00
|
|
|
|
2002-02-02 17:20:54 +01:00
|
|
|
// -- cSVDRPhosts ------------------------------------------------------------
|
|
|
|
|
|
|
|
cSVDRPhosts SVDRPhosts;
|
|
|
|
|
|
|
|
bool cSVDRPhosts::Acceptable(in_addr_t Address)
|
|
|
|
{
|
|
|
|
cSVDRPhost *h = First();
|
|
|
|
while (h) {
|
|
|
|
if (h->Accepts(Address))
|
|
|
|
return true;
|
|
|
|
h = (cSVDRPhost *)h->Next();
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2002-03-03 16:12:29 +01:00
|
|
|
// -- cCaDefinitions ---------------------------------------------------------
|
|
|
|
|
|
|
|
cCaDefinitions CaDefinitions;
|
|
|
|
|
|
|
|
const cCaDefinition *cCaDefinitions::Get(int Number)
|
|
|
|
{
|
|
|
|
cCaDefinition *p = First();
|
|
|
|
while (p) {
|
|
|
|
if (p->Number() == Number)
|
|
|
|
return p;
|
|
|
|
p = (cCaDefinition *)p->Next();
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2002-05-09 16:26:56 +02:00
|
|
|
// -- cSetupLine -------------------------------------------------------------
|
|
|
|
|
|
|
|
cSetupLine::cSetupLine(void)
|
|
|
|
{
|
|
|
|
plugin = name = value = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cSetupLine::cSetupLine(const char *Name, const char *Value, const char *Plugin)
|
|
|
|
{
|
|
|
|
name = strdup(Name);
|
|
|
|
value = strdup(Value);
|
|
|
|
plugin = Plugin ? strdup(Plugin) : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cSetupLine::~cSetupLine()
|
|
|
|
{
|
2002-08-11 13:32:23 +02:00
|
|
|
free(plugin);
|
|
|
|
free(name);
|
|
|
|
free(value);
|
2002-05-09 16:26:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool cSetupLine::operator< (const cListObject &ListObject)
|
|
|
|
{
|
|
|
|
const cSetupLine *sl = (cSetupLine *)&ListObject;
|
|
|
|
if (!plugin && !sl->plugin)
|
2002-09-04 17:26:02 +02:00
|
|
|
return strcasecmp(name, sl->name) < 0;
|
2002-05-09 16:26:56 +02:00
|
|
|
if (!plugin)
|
|
|
|
return true;
|
|
|
|
if (!sl->plugin)
|
|
|
|
return false;
|
|
|
|
int result = strcasecmp(plugin, sl->plugin);
|
|
|
|
if (result == 0)
|
|
|
|
result = strcasecmp(name, sl->name);
|
|
|
|
return result < 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cSetupLine::Parse(char *s)
|
|
|
|
{
|
|
|
|
char *p = strchr(s, '=');
|
|
|
|
if (p) {
|
|
|
|
*p = 0;
|
|
|
|
char *Name = compactspace(s);
|
|
|
|
char *Value = compactspace(p + 1);
|
2003-08-24 11:01:42 +02:00
|
|
|
if (*Name) { // value may be an empty string
|
2002-05-09 16:26:56 +02:00
|
|
|
p = strchr(Name, '.');
|
|
|
|
if (p) {
|
|
|
|
*p = 0;
|
|
|
|
char *Plugin = compactspace(Name);
|
|
|
|
Name = compactspace(p + 1);
|
|
|
|
if (!(*Plugin && *Name))
|
|
|
|
return false;
|
|
|
|
plugin = strdup(Plugin);
|
|
|
|
}
|
|
|
|
name = strdup(Name);
|
|
|
|
value = strdup(Value);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cSetupLine::Save(FILE *f)
|
|
|
|
{
|
|
|
|
return fprintf(f, "%s%s%s = %s\n", plugin ? plugin : "", plugin ? "." : "", name, value) > 0;
|
|
|
|
}
|
|
|
|
|
2000-09-10 10:51:58 +02:00
|
|
|
// -- cSetup -----------------------------------------------------------------
|
|
|
|
|
|
|
|
cSetup Setup;
|
|
|
|
|
|
|
|
cSetup::cSetup(void)
|
|
|
|
{
|
2000-11-11 10:39:27 +01:00
|
|
|
OSDLanguage = 0;
|
2000-09-10 10:51:58 +02:00
|
|
|
PrimaryDVB = 1;
|
|
|
|
ShowInfoOnChSwitch = 1;
|
|
|
|
MenuScrollPage = 1;
|
2000-10-08 13:08:13 +02:00
|
|
|
MarkInstantRecord = 1;
|
2002-02-10 11:40:29 +01:00
|
|
|
strcpy(NameInstantRecord, "TITLE EPISODE");
|
2002-04-26 13:43:46 +02:00
|
|
|
InstantRecordTime = 180;
|
2001-06-02 10:47:40 +02:00
|
|
|
LnbSLOF = 11700;
|
2000-10-08 16:18:23 +02:00
|
|
|
LnbFrequLo = 9750;
|
|
|
|
LnbFrequHi = 10600;
|
2001-08-11 08:44:48 +02:00
|
|
|
DiSEqC = 0;
|
2000-10-29 13:17:22 +01:00
|
|
|
SetSystemTime = 0;
|
2002-03-17 14:24:11 +01:00
|
|
|
TimeTransponder = 0;
|
2000-10-29 13:17:22 +01:00
|
|
|
MarginStart = 2;
|
|
|
|
MarginStop = 10;
|
2004-01-09 15:53:59 +01:00
|
|
|
EPGLanguages[0] = -1;
|
2000-11-18 13:57:32 +01:00
|
|
|
EPGScanTimeout = 5;
|
2001-08-17 13:19:10 +02:00
|
|
|
EPGBugfixLevel = 2;
|
2001-02-18 14:18:13 +01:00
|
|
|
SVDRPTimeout = 300;
|
2003-08-17 08:58:02 +02:00
|
|
|
ZapTimeout = 3;
|
2001-08-26 14:17:20 +02:00
|
|
|
SortTimers = 1;
|
2001-02-24 14:03:39 +01:00
|
|
|
PrimaryLimit = 0;
|
2001-06-02 10:47:40 +02:00
|
|
|
DefaultPriority = 50;
|
2003-10-17 14:14:46 +02:00
|
|
|
DefaultLifetime = 99;
|
2003-05-11 14:10:00 +02:00
|
|
|
PausePriority = 10;
|
|
|
|
PauseLifetime = 1;
|
2001-09-02 15:21:54 +02:00
|
|
|
UseSubtitle = 1;
|
2002-01-20 14:05:28 +01:00
|
|
|
RecordingDirs = 1;
|
2002-08-04 14:57:29 +02:00
|
|
|
VideoFormat = 0;
|
2004-01-05 12:08:09 +01:00
|
|
|
UpdateChannels = 3;
|
2002-02-24 11:55:24 +01:00
|
|
|
RecordDolbyDigital = 1;
|
2001-07-27 10:59:50 +02:00
|
|
|
ChannelInfoPos = 0;
|
2001-07-27 11:51:42 +02:00
|
|
|
OSDwidth = 52;
|
|
|
|
OSDheight = 18;
|
2001-09-01 15:23:27 +02:00
|
|
|
OSDMessageTime = 1;
|
2001-08-25 13:52:38 +02:00
|
|
|
MaxVideoFileSize = MAXVIDEOFILESIZE;
|
2001-09-30 11:31:43 +02:00
|
|
|
SplitEditedFiles = 0;
|
2001-09-07 15:37:26 +02:00
|
|
|
MinEventTimeout = 30;
|
2001-09-01 09:04:37 +02:00
|
|
|
MinUserInactivity = 120;
|
2001-09-09 12:52:41 +02:00
|
|
|
MultiSpeedMode = 0;
|
2001-09-14 14:06:43 +02:00
|
|
|
ShowReplayMode = 0;
|
2003-04-12 10:06:21 +02:00
|
|
|
ResumeID = 0;
|
2002-03-03 16:12:29 +01:00
|
|
|
memset(CaCaps, sizeof(CaCaps), 0);
|
2001-01-14 15:29:51 +01:00
|
|
|
CurrentChannel = -1;
|
2001-09-22 13:41:49 +02:00
|
|
|
CurrentVolume = MAXVOLUME;
|
2000-09-10 10:51:58 +02:00
|
|
|
}
|
|
|
|
|
2002-05-09 16:26:56 +02:00
|
|
|
cSetup& cSetup::operator= (const cSetup &s)
|
|
|
|
{
|
|
|
|
memcpy(&__BeginData__, &s.__BeginData__, (char *)&s.__EndData__ - (char *)&s.__BeginData__);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
cSetupLine *cSetup::Get(const char *Name, const char *Plugin)
|
|
|
|
{
|
|
|
|
for (cSetupLine *l = First(); l; l = Next(l)) {
|
|
|
|
if ((l->Plugin() == NULL) == (Plugin == NULL)) {
|
|
|
|
if ((!Plugin || strcasecmp(l->Plugin(), Plugin) == 0) && strcasecmp(l->Name(), Name) == 0)
|
|
|
|
return l;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2002-10-19 11:34:48 +02:00
|
|
|
void cSetup::Store(const char *Name, const char *Value, const char *Plugin, bool AllowMultiple)
|
2002-05-09 16:26:56 +02:00
|
|
|
{
|
|
|
|
if (Name && *Name) {
|
|
|
|
cSetupLine *l = Get(Name, Plugin);
|
2002-10-19 11:34:48 +02:00
|
|
|
if (l && !AllowMultiple)
|
2002-05-09 16:26:56 +02:00
|
|
|
Del(l);
|
|
|
|
if (Value)
|
|
|
|
Add(new cSetupLine(Name, Value, Plugin));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cSetup::Store(const char *Name, int Value, const char *Plugin)
|
|
|
|
{
|
|
|
|
char *buffer = NULL;
|
|
|
|
asprintf(&buffer, "%d", Value);
|
|
|
|
Store(Name, buffer, Plugin);
|
2002-08-11 13:32:23 +02:00
|
|
|
free(buffer);
|
2002-05-09 16:26:56 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool cSetup::Load(const char *FileName)
|
|
|
|
{
|
|
|
|
if (cConfig<cSetupLine>::Load(FileName, true)) {
|
|
|
|
bool result = true;
|
|
|
|
for (cSetupLine *l = First(); l; l = Next(l)) {
|
2002-05-11 13:44:58 +02:00
|
|
|
bool error = false;
|
2002-05-09 16:26:56 +02:00
|
|
|
if (l->Plugin()) {
|
|
|
|
cPlugin *p = cPluginManager::GetPlugin(l->Plugin());
|
|
|
|
if (p && !p->SetupParse(l->Name(), l->Value()))
|
2002-05-11 13:44:58 +02:00
|
|
|
error = true;
|
2002-05-09 16:26:56 +02:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (!Parse(l->Name(), l->Value()))
|
2002-05-11 13:44:58 +02:00
|
|
|
error = true;
|
|
|
|
}
|
|
|
|
if (error) {
|
2002-05-13 16:35:49 +02:00
|
|
|
esyslog("ERROR: unknown config parameter: %s%s%s = %s", l->Plugin() ? l->Plugin() : "", l->Plugin() ? "." : "", l->Name(), l->Value());
|
2002-05-11 13:44:58 +02:00
|
|
|
result = false;
|
2002-05-09 16:26:56 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void cSetup::StoreCaCaps(const char *Name)
|
2002-03-03 16:12:29 +01:00
|
|
|
{
|
2002-10-19 11:34:48 +02:00
|
|
|
cSetupLine *l;
|
|
|
|
while ((l = Get(Name)) != NULL)
|
|
|
|
Del(l);
|
2002-06-16 12:57:31 +02:00
|
|
|
for (int d = 0; d < MAXDEVICES; d++) {
|
2002-05-09 16:26:56 +02:00
|
|
|
char buffer[MAXPARSEBUFFER];
|
|
|
|
char *q = buffer;
|
|
|
|
*buffer = 0;
|
2002-03-08 15:06:37 +01:00
|
|
|
for (int i = 0; i < MAXCACAPS; i++) {
|
|
|
|
if (CaCaps[d][i]) {
|
2002-05-09 16:26:56 +02:00
|
|
|
if (!*buffer)
|
|
|
|
q += snprintf(buffer, sizeof(buffer), "%d", d + 1);
|
|
|
|
q += snprintf(q, sizeof(buffer) - (q - buffer), " %d", CaCaps[d][i]);
|
2002-03-08 15:06:37 +01:00
|
|
|
}
|
|
|
|
}
|
2002-05-09 16:26:56 +02:00
|
|
|
if (*buffer)
|
2002-10-19 11:34:48 +02:00
|
|
|
Store(Name, buffer, NULL, true);
|
2002-03-03 16:12:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cSetup::ParseCaCaps(const char *Value)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int d = strtol(Value, &p, 10);
|
2002-06-16 12:57:31 +02:00
|
|
|
if (d > 0 && d <= MAXDEVICES) {
|
2002-03-03 16:12:29 +01:00
|
|
|
d--;
|
|
|
|
int i = 0;
|
|
|
|
while (p != Value && p && *p) {
|
|
|
|
if (i < MAXCACAPS) {
|
|
|
|
int c = strtol(p, &p, 10);
|
|
|
|
if (c > 0)
|
|
|
|
CaCaps[d][i++] = c;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2004-01-09 15:53:59 +01:00
|
|
|
void cSetup::StoreLanguages(const char *Name, int *Values)
|
|
|
|
{
|
|
|
|
char buffer[I18nNumLanguages * 4];
|
|
|
|
char *q = buffer;
|
|
|
|
for (int i = 0; i < I18nNumLanguages; i++) {
|
|
|
|
if (Values[i] < 0)
|
|
|
|
break;
|
|
|
|
const char *s = I18nLanguageAbbreviation(Values[i]);
|
|
|
|
if (s) {
|
|
|
|
if (q > buffer)
|
|
|
|
*q++ = ' ';
|
|
|
|
strncpy(q, s, 3);
|
|
|
|
q += 3;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*q = 0;
|
|
|
|
Store(Name, buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cSetup::ParseLanguages(const char *Value, int *Values)
|
|
|
|
{
|
|
|
|
int n = 0;
|
|
|
|
while (Value && *Value && n < I18nNumLanguages) {
|
|
|
|
int i = I18nLanguageIndex(Value);
|
|
|
|
if (i >= 0)
|
|
|
|
Values[n++] = i;
|
|
|
|
if ((Value = strchr(Value, ' ')) != NULL)
|
|
|
|
Value++;
|
|
|
|
}
|
|
|
|
Values[n] = -1;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2002-05-09 16:26:56 +02:00
|
|
|
bool cSetup::Parse(const char *Name, const char *Value)
|
|
|
|
{
|
|
|
|
if (!strcasecmp(Name, "OSDLanguage")) OSDLanguage = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "PrimaryDVB")) PrimaryDVB = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "ShowInfoOnChSwitch")) ShowInfoOnChSwitch = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "MenuScrollPage")) MenuScrollPage = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "MarkInstantRecord")) MarkInstantRecord = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "NameInstantRecord")) strn0cpy(NameInstantRecord, Value, MaxFileName);
|
|
|
|
else if (!strcasecmp(Name, "InstantRecordTime")) InstantRecordTime = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "LnbSLOF")) LnbSLOF = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "LnbFrequLo")) LnbFrequLo = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "LnbFrequHi")) LnbFrequHi = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "DiSEqC")) DiSEqC = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "SetSystemTime")) SetSystemTime = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "TimeTransponder")) TimeTransponder = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "MarginStart")) MarginStart = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "MarginStop")) MarginStop = atoi(Value);
|
2004-01-09 15:53:59 +01:00
|
|
|
else if (!strcasecmp(Name, "EPGLanguages")) return ParseLanguages(Value, EPGLanguages);
|
2002-05-09 16:26:56 +02:00
|
|
|
else if (!strcasecmp(Name, "EPGScanTimeout")) EPGScanTimeout = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "EPGBugfixLevel")) EPGBugfixLevel = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "SVDRPTimeout")) SVDRPTimeout = atoi(Value);
|
2003-08-17 08:58:02 +02:00
|
|
|
else if (!strcasecmp(Name, "ZapTimeout")) ZapTimeout = atoi(Value);
|
2002-05-09 16:26:56 +02:00
|
|
|
else if (!strcasecmp(Name, "SortTimers")) SortTimers = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "PrimaryLimit")) PrimaryLimit = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "DefaultPriority")) DefaultPriority = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "DefaultLifetime")) DefaultLifetime = atoi(Value);
|
2003-05-11 14:10:00 +02:00
|
|
|
else if (!strcasecmp(Name, "PausePriority")) PausePriority = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "PauseLifetime")) PauseLifetime = atoi(Value);
|
2002-05-09 16:26:56 +02:00
|
|
|
else if (!strcasecmp(Name, "UseSubtitle")) UseSubtitle = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "RecordingDirs")) RecordingDirs = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "VideoFormat")) VideoFormat = atoi(Value);
|
2004-01-05 12:08:09 +01:00
|
|
|
else if (!strcasecmp(Name, "UpdateChannels")) UpdateChannels = atoi(Value);
|
2002-05-09 16:26:56 +02:00
|
|
|
else if (!strcasecmp(Name, "RecordDolbyDigital")) RecordDolbyDigital = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "ChannelInfoPos")) ChannelInfoPos = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "OSDwidth")) OSDwidth = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "OSDheight")) OSDheight = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "OSDMessageTime")) OSDMessageTime = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "MaxVideoFileSize")) MaxVideoFileSize = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "SplitEditedFiles")) SplitEditedFiles = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "MinEventTimeout")) MinEventTimeout = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "MinUserInactivity")) MinUserInactivity = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "MultiSpeedMode")) MultiSpeedMode = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "ShowReplayMode")) ShowReplayMode = atoi(Value);
|
2003-04-12 10:06:21 +02:00
|
|
|
else if (!strcasecmp(Name, "ResumeID")) ResumeID = atoi(Value);
|
2002-05-09 16:26:56 +02:00
|
|
|
else if (!strcasecmp(Name, "CaCaps")) return ParseCaCaps(Value);
|
|
|
|
else if (!strcasecmp(Name, "CurrentChannel")) CurrentChannel = atoi(Value);
|
|
|
|
else if (!strcasecmp(Name, "CurrentVolume")) CurrentVolume = atoi(Value);
|
2000-09-10 10:51:58 +02:00
|
|
|
else
|
2002-05-09 16:26:56 +02:00
|
|
|
return false;
|
|
|
|
return true;
|
2000-09-10 10:51:58 +02:00
|
|
|
}
|
|
|
|
|
2002-05-09 16:26:56 +02:00
|
|
|
bool cSetup::Save(void)
|
|
|
|
{
|
|
|
|
Store("OSDLanguage", OSDLanguage);
|
|
|
|
Store("PrimaryDVB", PrimaryDVB);
|
|
|
|
Store("ShowInfoOnChSwitch", ShowInfoOnChSwitch);
|
|
|
|
Store("MenuScrollPage", MenuScrollPage);
|
|
|
|
Store("MarkInstantRecord", MarkInstantRecord);
|
|
|
|
Store("NameInstantRecord", NameInstantRecord);
|
|
|
|
Store("InstantRecordTime", InstantRecordTime);
|
|
|
|
Store("LnbSLOF", LnbSLOF);
|
|
|
|
Store("LnbFrequLo", LnbFrequLo);
|
|
|
|
Store("LnbFrequHi", LnbFrequHi);
|
|
|
|
Store("DiSEqC", DiSEqC);
|
|
|
|
Store("SetSystemTime", SetSystemTime);
|
|
|
|
Store("TimeTransponder", TimeTransponder);
|
|
|
|
Store("MarginStart", MarginStart);
|
|
|
|
Store("MarginStop", MarginStop);
|
2004-01-09 15:53:59 +01:00
|
|
|
StoreLanguages("EPGLanguages", EPGLanguages);
|
2002-05-09 16:26:56 +02:00
|
|
|
Store("EPGScanTimeout", EPGScanTimeout);
|
|
|
|
Store("EPGBugfixLevel", EPGBugfixLevel);
|
|
|
|
Store("SVDRPTimeout", SVDRPTimeout);
|
2003-08-17 08:58:02 +02:00
|
|
|
Store("ZapTimeout", ZapTimeout);
|
2002-05-09 16:26:56 +02:00
|
|
|
Store("SortTimers", SortTimers);
|
|
|
|
Store("PrimaryLimit", PrimaryLimit);
|
|
|
|
Store("DefaultPriority", DefaultPriority);
|
|
|
|
Store("DefaultLifetime", DefaultLifetime);
|
2003-05-11 14:10:00 +02:00
|
|
|
Store("PausePriority", PausePriority);
|
|
|
|
Store("PauseLifetime", PauseLifetime);
|
2002-05-09 16:26:56 +02:00
|
|
|
Store("UseSubtitle", UseSubtitle);
|
|
|
|
Store("RecordingDirs", RecordingDirs);
|
|
|
|
Store("VideoFormat", VideoFormat);
|
2004-01-05 12:08:09 +01:00
|
|
|
Store("UpdateChannels", UpdateChannels);
|
2002-05-09 16:26:56 +02:00
|
|
|
Store("RecordDolbyDigital", RecordDolbyDigital);
|
|
|
|
Store("ChannelInfoPos", ChannelInfoPos);
|
|
|
|
Store("OSDwidth", OSDwidth);
|
|
|
|
Store("OSDheight", OSDheight);
|
|
|
|
Store("OSDMessageTime", OSDMessageTime);
|
|
|
|
Store("MaxVideoFileSize", MaxVideoFileSize);
|
|
|
|
Store("SplitEditedFiles", SplitEditedFiles);
|
|
|
|
Store("MinEventTimeout", MinEventTimeout);
|
|
|
|
Store("MinUserInactivity", MinUserInactivity);
|
|
|
|
Store("MultiSpeedMode", MultiSpeedMode);
|
|
|
|
Store("ShowReplayMode", ShowReplayMode);
|
2003-04-12 10:06:21 +02:00
|
|
|
Store("ResumeID", ResumeID);
|
2002-05-09 16:26:56 +02:00
|
|
|
StoreCaCaps("CaCaps");
|
|
|
|
Store("CurrentChannel", CurrentChannel);
|
|
|
|
Store("CurrentVolume", CurrentVolume);
|
|
|
|
|
|
|
|
Sort();
|
|
|
|
|
|
|
|
if (cConfig<cSetupLine>::Save()) {
|
2002-05-13 16:35:49 +02:00
|
|
|
isyslog("saved setup to %s", FileName());
|
2002-05-09 16:26:56 +02:00
|
|
|
return true;
|
2000-09-10 10:51:58 +02:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|