1
0
mirror of https://github.com/VDR4Arch/vdr.git synced 2023-10-10 13:36:52 +02:00
vdr/config.h

348 lines
8.6 KiB
C
Raw Normal View History

2000-02-19 13:36:48 +01:00
/*
* config.h: 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.
*
2002-09-29 13:40:45 +02:00
* $Id: config.h 1.129 2002/09/29 10:42:17 kls Exp $
2000-02-19 13:36:48 +01:00
*/
#ifndef __CONFIG_H
#define __CONFIG_H
2002-02-02 17:20:54 +01:00
#include <arpa/inet.h>
2000-02-19 13:36:48 +01:00
#include <stdio.h>
#include <stdlib.h>
2000-02-19 13:36:48 +01:00
#include <string.h>
#include <time.h>
2000-12-28 12:57:16 +01:00
#include <unistd.h>
#include "device.h"
2000-10-29 13:17:22 +01:00
#include "eit.h"
2000-02-19 13:36:48 +01:00
#include "tools.h"
#define VDRVERSION "1.1.11"
2000-07-29 18:19:49 +02:00
#define MAXPRIORITY 99
#define MAXLIFETIME 99
#define MINOSDWIDTH 40
#define MAXOSDWIDTH 56
#define MINOSDHEIGHT 12
#define MAXOSDHEIGHT 21
2002-02-03 15:55:04 +01:00
#define MaxFileName 256
2002-03-10 12:45:58 +01:00
#define ISTRANSPONDER(f1, f2) (abs((f1) - (f2)) < 4)
2000-02-19 13:36:48 +01:00
class cChannel : public cListObject {
2000-07-23 15:01:31 +02:00
private:
static char *buffer;
static const char *ToText(cChannel *Channel);
2000-02-19 13:36:48 +01:00
public:
enum { MaxChannelName = 32 }; // 31 chars + terminating 0!
char name[MaxChannelName];
int frequency; // MHz
char polarization;
int diseqc;
int srate;
int vpid;
2001-06-03 13:07:20 +02:00
int apid1, apid2;
2001-06-24 17:42:19 +02:00
int dpid1, dpid2;
2001-02-03 16:28:03 +01:00
int tpid;
int ca;
int pnr;
2000-09-09 14:57:43 +02:00
int number; // Sequence number assigned on load
bool groupSep;
2000-02-19 13:36:48 +01:00
cChannel(void);
cChannel(const cChannel *Channel);
2000-07-23 15:01:31 +02:00
const char *ToText(void);
bool Parse(const char *s);
2000-02-19 13:36:48 +01:00
bool Save(FILE *f);
};
enum eTimerActive { taInactive = 0,
taActive = 1,
taInstant = 2,
taActInst = (taActive | taInstant)
};
2000-02-19 13:36:48 +01:00
class cTimer : public cListObject {
private:
time_t startTime, stopTime;
2000-07-23 15:01:31 +02:00
static char *buffer;
static const char *ToText(cTimer *Timer);
2000-02-19 13:36:48 +01:00
public:
bool recording, pending;
2000-02-19 13:36:48 +01:00
int active;
int channel;
int day;
int start;
int stop;
//TODO VPS???
int priority;
int lifetime;
char file[MaxFileName];
time_t firstday;
2000-07-24 16:43:04 +02:00
char *summary;
cTimer(bool Instant = false);
2000-10-29 13:17:22 +01:00
cTimer(const cEventInfo *EventInfo);
2000-11-11 16:38:41 +01:00
virtual ~cTimer();
2000-07-24 16:43:04 +02:00
cTimer& operator= (const cTimer &Timer);
2002-05-09 16:26:56 +02:00
virtual bool operator< (const cListObject &ListObject);
2000-07-23 15:01:31 +02:00
const char *ToText(void);
bool Parse(const char *s);
2000-02-19 13:36:48 +01:00
bool Save(FILE *f);
bool IsSingleEvent(void);
2001-08-26 14:17:20 +02:00
int GetMDay(time_t t);
int GetWDay(time_t t);
bool DayMatches(time_t t);
static time_t IncDay(time_t t, int Days);
static time_t SetTime(time_t t, int SecondsFromMidnight);
2002-02-03 15:55:04 +01:00
char *SetFile(const char *File);
bool Matches(time_t t = 0);
time_t StartTime(void);
time_t StopTime(void);
void SetRecording(bool Recording);
void SetPending(bool Pending);
void Skip(void);
const char *PrintFirstDay(void);
2000-02-19 13:36:48 +01:00
static int TimeToInt(int t);
static int ParseDay(const char *s, time_t *FirstDay = NULL);
static const char *PrintDay(int d, time_t FirstDay = 0);
2000-02-19 13:36:48 +01:00
};
2000-11-11 16:38:41 +01:00
class cCommand : public cListObject {
private:
char *title;
char *command;
static char *result;
public:
cCommand(void);
virtual ~cCommand();
bool Parse(const char *s);
const char *Title(void) { return title; }
const char *Execute(void);
};
typedef uint32_t in_addr_t; //XXX from /usr/include/netinet/in.h (apparently this is not defined on systems with glibc < 2.2)
2002-02-02 17:20:54 +01:00
class cSVDRPhost : public cListObject {
private:
struct in_addr addr;
in_addr_t mask;
public:
cSVDRPhost(void);
bool Parse(const char *s);
bool Accepts(in_addr_t Address);
};
#define CACONFBASE 100
class cCaDefinition : public cListObject {
private:
int number;
char *description;
public:
cCaDefinition(void);
~cCaDefinition();
bool Parse(const char *s);
int Number(void) const { return number; }
const char *Description(void) const { return description; }
};
2000-02-19 13:36:48 +01:00
template<class T> class cConfig : public cList<T> {
private:
char *fileName;
2002-09-29 13:40:45 +02:00
bool allowComments;
2000-02-19 13:36:48 +01:00
void Clear(void)
{
free(fileName);
fileName = NULL;
2000-02-19 13:36:48 +01:00
cList<T>::Clear();
}
public:
2000-12-28 12:57:16 +01:00
cConfig(void) { fileName = NULL; }
virtual ~cConfig() { free(fileName); }
2002-05-09 16:26:56 +02:00
const char *FileName(void) { return fileName; }
2002-09-29 13:40:45 +02:00
bool Load(const char *FileName = NULL, bool AllowComments = false)
2000-02-19 13:36:48 +01:00
{
Clear();
2002-09-29 13:40:45 +02:00
if (FileName) {
free(fileName);
fileName = strdup(FileName);
allowComments = AllowComments;
}
2000-12-28 12:57:16 +01:00
bool result = false;
2002-09-29 13:40:45 +02:00
if (fileName && access(fileName, F_OK) == 0) {
isyslog("loading %s", fileName);
2000-12-28 12:57:16 +01:00
FILE *f = fopen(fileName, "r");
if (f) {
int line = 0;
char buffer[MAXPARSEBUFFER];
2000-12-28 12:57:16 +01:00
result = true;
while (fgets(buffer, sizeof(buffer), f) > 0) {
line++;
2002-09-29 13:40:45 +02:00
if (allowComments) {
char *p = strchr(buffer, '#');
if (p)
*p = 0;
}
2002-09-29 13:40:45 +02:00
stripspace(buffer);
if (!isempty(buffer)) {
T *l = new T;
if (l->Parse(buffer))
Add(l);
else {
2002-05-13 16:35:49 +02:00
esyslog("error in %s, line %d\n", fileName, line);
delete l;
result = false;
break;
}
2000-12-28 12:57:16 +01:00
}
2000-02-19 13:36:48 +01:00
}
2000-12-28 12:57:16 +01:00
fclose(f);
}
else
LOG_ERROR_STR(fileName);
2000-02-19 13:36:48 +01:00
}
return result;
}
bool Save(void)
{
bool result = true;
T *l = (T *)First();
cSafeFile f(fileName);
if (f.Open()) {
2000-02-19 13:36:48 +01:00
while (l) {
if (!l->Save(f)) {
result = false;
break;
}
l = (T *)l->Next();
}
if (!f.Close())
result = false;
2000-02-19 13:36:48 +01:00
}
else
2000-02-19 13:36:48 +01:00
result = false;
return result;
}
};
2000-09-09 14:57:43 +02:00
class cChannels : public cConfig<cChannel> {
protected:
int maxNumber;
public:
cChannels(void) { maxNumber = 0; }
virtual bool Load(const char *FileName, bool AllowComments = false);
2000-09-09 14:57:43 +02:00
int GetNextGroup(int Idx); // Get next channel group
int GetPrevGroup(int Idx); // Get previous channel group
int GetNextNormal(int Idx); // Get next normal channel (not group)
void ReNumber(void); // Recalculate 'number' based on channel type
cChannel *GetByNumber(int Number);
2000-10-29 13:17:22 +01:00
cChannel *GetByServiceID(unsigned short ServiceId);
2000-09-09 14:57:43 +02:00
const char *GetChannelNameByNumber(int Number);
bool SwitchTo(int Number);
2000-09-09 14:57:43 +02:00
int MaxNumber(void) { return maxNumber; }
};
2000-08-06 12:56:49 +02:00
class cTimers : public cConfig<cTimer> {
public:
cTimer *GetTimer(cTimer *Timer);
cTimer *GetMatch(time_t t);
2001-08-26 15:02:00 +02:00
cTimer *GetNextActiveTimer(void);
2000-08-06 12:56:49 +02:00
};
2000-02-19 13:36:48 +01:00
2000-11-11 16:38:41 +01:00
class cCommands : public cConfig<cCommand> {};
2002-02-02 17:20:54 +01:00
class cSVDRPhosts : public cConfig<cSVDRPhost> {
public:
bool Acceptable(in_addr_t Address);
};
class cCaDefinitions : public cConfig<cCaDefinition> {
public:
const cCaDefinition *Get(int Number);
};
2000-02-19 13:36:48 +01:00
extern cChannels Channels;
extern cTimers Timers;
2000-11-11 16:38:41 +01:00
extern cCommands Commands;
2002-02-02 17:20:54 +01:00
extern cSVDRPhosts SVDRPhosts;
extern cCaDefinitions CaDefinitions;
2000-02-19 13:36:48 +01:00
2002-05-09 16:26:56 +02:00
class cSetupLine : public cListObject {
2000-09-10 10:51:58 +02:00
private:
2002-05-09 16:26:56 +02:00
char *plugin;
char *name;
char *value;
public:
cSetupLine(void);
cSetupLine(const char *Name, const char *Value, const char *Plugin = NULL);
virtual ~cSetupLine();
virtual bool operator< (const cListObject &ListObject);
const char *Plugin(void) { return plugin; }
const char *Name(void) { return name; }
const char *Value(void) { return value; }
2000-09-10 10:51:58 +02:00
bool Parse(char *s);
2002-05-09 16:26:56 +02:00
bool Save(FILE *f);
};
class cSetup : public cConfig<cSetupLine> {
friend class cPlugin; // needs to be able to call Store()
private:
void StoreCaCaps(const char *Name);
bool ParseCaCaps(const char *Value);
bool Parse(const char *Name, const char *Value);
cSetupLine *Get(const char *Name, const char *Plugin = NULL);
void Store(const char *Name, const char *Value, const char *Plugin = NULL);
void Store(const char *Name, int Value, const char *Plugin = NULL);
2000-09-10 10:51:58 +02:00
public:
// Also adjust cMenuSetup (menu.c) when adding parameters here!
2002-05-09 16:26:56 +02:00
int __BeginData__;
2000-11-11 10:39:27 +01:00
int OSDLanguage;
2000-09-10 10:51:58 +02:00
int PrimaryDVB;
int ShowInfoOnChSwitch;
int MenuScrollPage;
int MarkInstantRecord;
2002-02-03 15:55:04 +01:00
char NameInstantRecord[MaxFileName];
int InstantRecordTime;
int LnbSLOF;
2000-10-08 16:18:23 +02:00
int LnbFrequLo;
int LnbFrequHi;
int DiSEqC;
2000-10-29 13:17:22 +01:00
int SetSystemTime;
int TimeTransponder;
2000-10-29 13:17:22 +01:00
int MarginStart, MarginStop;
int EPGScanTimeout;
2001-08-17 13:19:10 +02:00
int EPGBugfixLevel;
int SVDRPTimeout;
2001-08-26 14:17:20 +02:00
int SortTimers;
int PrimaryLimit;
int DefaultPriority, DefaultLifetime;
int UseSubtitle;
int RecordingDirs;
2001-06-16 14:31:14 +02:00
int VideoFormat;
2002-02-24 11:55:24 +01:00
int RecordDolbyDigital;
int ChannelInfoPos;
int OSDwidth, OSDheight;
2001-09-01 15:23:27 +02:00
int OSDMessageTime;
2001-08-25 13:52:38 +02:00
int MaxVideoFileSize;
2001-09-30 11:31:43 +02:00
int SplitEditedFiles;
2001-09-01 09:04:37 +02:00
int MinEventTimeout, MinUserInactivity;
2001-09-09 12:52:41 +02:00
int MultiSpeedMode;
2001-09-14 14:06:43 +02:00
int ShowReplayMode;
int CaCaps[MAXDEVICES][MAXCACAPS];
int CurrentChannel;
2001-09-22 13:41:49 +02:00
int CurrentVolume;
2002-05-09 16:26:56 +02:00
int __EndData__;
2000-09-10 10:51:58 +02:00
cSetup(void);
2002-05-09 16:26:56 +02:00
cSetup& operator= (const cSetup &s);
2000-09-10 10:51:58 +02:00
bool Load(const char *FileName);
2002-05-09 16:26:56 +02:00
bool Save(void);
2000-09-10 10:51:58 +02:00
};
extern cSetup Setup;
2000-02-19 13:36:48 +01:00
#endif //__CONFIG_H