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

1207 lines
48 KiB
C
Raw Normal View History

2000-02-19 13:36:48 +01:00
/*
2000-04-24 09:46:05 +02:00
* vdr.c: Video Disk Recorder main program
2000-02-19 13:36:48 +01:00
*
2006-01-08 11:49:03 +01:00
* Copyright (C) 2000, 2003, 2006 Klaus Schmidinger
2001-08-03 14:18:08 +02:00
*
2000-02-19 13:36:48 +01:00
* 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.
2001-08-03 14:18:08 +02:00
*
2000-02-19 13:36:48 +01:00
* 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.
2001-08-03 14:18:08 +02:00
*
2000-02-19 13:36:48 +01:00
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
* Or, point your browser to http://www.gnu.org/copyleft/gpl.html
2001-08-03 14:18:08 +02:00
*
2000-02-19 13:36:48 +01:00
* The author can be reached at kls@cadsoft.de
*
2003-05-29 12:44:06 +02:00
* The project's page is at http://www.cadsoft.de/vdr
2000-02-19 13:36:48 +01:00
*
2006-04-15 13:56:03 +02:00
* $Id: vdr.c 1.260 2006/04/15 13:51:52 kls Exp $
2000-02-19 13:36:48 +01:00
*/
2000-07-23 15:01:31 +02:00
#include <getopt.h>
#include <grp.h>
#include <locale.h>
#include <pwd.h>
#include <signal.h>
2000-07-23 15:01:31 +02:00
#include <stdlib.h>
#include <sys/capability.h>
#include <sys/prctl.h>
#include <termios.h>
2000-07-23 15:36:43 +02:00
#include <unistd.h>
2002-11-03 11:53:58 +01:00
#include "audio.h"
#include "channels.h"
2000-02-19 13:36:48 +01:00
#include "config.h"
2002-06-22 10:11:59 +02:00
#include "cutter.h"
#include "device.h"
#include "diseqc.h"
#include "dvbdevice.h"
#include "eitscan.h"
#include "epg.h"
2000-11-11 10:39:27 +01:00
#include "i18n.h"
2000-02-19 13:36:48 +01:00
#include "interface.h"
2002-09-29 13:40:45 +02:00
#include "keys.h"
#include "lirc.h"
2000-02-19 13:36:48 +01:00
#include "menu.h"
2004-05-16 10:35:36 +02:00
#include "osdbase.h"
2002-05-09 16:26:56 +02:00
#include "plugin.h"
2002-09-29 13:40:45 +02:00
#include "rcu.h"
#include "recording.h"
2004-05-16 10:35:36 +02:00
#include "skinclassic.h"
#include "skinsttng.h"
#include "sources.h"
2004-05-16 10:35:36 +02:00
#include "themes.h"
#include "timers.h"
2000-02-19 13:36:48 +01:00
#include "tools.h"
#include "transfer.h"
#include "videodir.h"
2000-02-19 13:36:48 +01:00
#define MINCHANNELWAIT 10 // seconds to wait between failed channel switchings
#define ACTIVITYTIMEOUT 60 // seconds before starting housekeeping
#define SHUTDOWNWAIT 300 // seconds to wait in user prompt before automatic shutdown
#define MANUALSTART 600 // seconds the next timer must be in the future to assume manual start
#define CHANNELSAVEDELTA 600 // seconds before saving channels.conf after automatic modifications
#define LASTCAMMENUTIMEOUT 3 // seconds to run the main loop 'fast' after a CAM menu has been closed
// in order to react on a possible new CAM menu as soon as possible
#define DEVICEREADYTIMEOUT 30 // seconds to wait until all devices are ready
#define MENUTIMEOUT 120 // seconds of user inactivity after which an OSD display is closed
#define SHUTDOWNRETRY 300 // seconds before trying again to shut down
#define VPSCHECKDELTA 10 // seconds between checks for timers that have entered the VPS margin
#define VPSDEVICETIMEOUT 8 // seconds before a device used for VPS may be reused
2001-02-11 14:53:44 +01:00
#define EXIT(v) { ExitCode = (v); goto Exit; }
static int Interrupted = 0;
static bool SetUser(const char *UserName)
{
if (UserName) {
struct passwd *user = getpwnam(UserName);
if (!user) {
fprintf(stderr, "vdr: unknown user: '%s'\n", UserName);
return false;
}
if (setgid(user->pw_gid) < 0) {
fprintf(stderr, "vdr: cannot set group id %u: %s\n", (unsigned int)user->pw_gid, strerror(errno));
return false;
}
if (initgroups(user->pw_name, user->pw_gid) < 0) {
fprintf(stderr, "vdr: cannot set supplemental group ids for user %s: %s\n", user->pw_name, strerror(errno));
return false;
}
if (setuid(user->pw_uid) < 0) {
fprintf(stderr, "vdr: cannot set user id %u: %s\n", (unsigned int)user->pw_uid, strerror(errno));
return false;
}
if (prctl(PR_SET_DUMPABLE, 2, 0, 0, 0) < 0) {
fprintf(stderr, "vdr: warning - cannot set dumpable: %s\n", strerror(errno));
// always non-fatal, and will not work with kernel < 2.6.13
}
}
return true;
}
static bool SetCapSysTime(void)
{
// drop all capabilities except cap_sys_time
cap_t caps = cap_from_text("= cap_sys_time=ep");
if (!caps) {
fprintf(stderr, "vdr: cap_from_text failed: %s\n", strerror(errno));
return false;
}
if (cap_set_proc(caps) == -1) {
fprintf(stderr, "vdr: cap_set_proc failed: %s\n", strerror(errno));
cap_free(caps);
return false;
}
cap_free(caps);
return true;
}
static bool SetKeepCaps(bool On)
{
// set keeping capabilities during setuid() on/off
if (prctl(PR_SET_KEEPCAPS, On ? 1 : 0, 0, 0, 0) != 0) {
fprintf(stderr, "vdr: prctl failed\n");
return false;
}
return true;
}
static void SignalHandler(int signum)
{
2001-09-01 09:04:37 +02:00
if (signum != SIGPIPE) {
Interrupted = signum;
2001-09-01 09:04:37 +02:00
Interface->Interrupt();
}
signal(signum, SignalHandler);
}
2001-02-24 16:18:43 +01:00
static void Watchdog(int signum)
{
// Something terrible must have happened that prevented the 'alarm()' from
// being called in time, so let's get out of here:
2002-05-13 16:35:49 +02:00
esyslog("PANIC: watchdog timer expired - exiting!");
2001-02-24 16:18:43 +01:00
exit(1);
}
2000-02-19 13:36:48 +01:00
int main(int argc, char *argv[])
{
// Save terminal settings:
struct termios savedTm;
2003-02-15 15:46:19 +01:00
bool HasStdin = (tcgetpgrp(STDIN_FILENO) == getpid() || getppid() != (pid_t)1) && tcgetattr(STDIN_FILENO, &savedTm) == 0;
// Initiate locale:
setlocale(LC_ALL, "");
2000-07-23 15:01:31 +02:00
// Command line options:
#define DEFAULTSVDRPPORT 2001
2001-02-24 16:18:43 +01:00
#define DEFAULTWATCHDOG 0 // seconds
#define DEFAULTPLUGINDIR PLUGINDIR
#define DEFAULTEPGDATAFILENAME "epg.data"
2000-07-23 15:01:31 +02:00
bool StartedAsRoot = false;
2006-01-13 16:16:32 +01:00
const char *VdrUser = NULL;
2000-07-23 15:01:31 +02:00
int SVDRPport = DEFAULTSVDRPPORT;
2002-11-03 11:53:58 +01:00
const char *AudioCommand = NULL;
const char *ConfigDirectory = NULL;
const char *EpgDataFileName = DEFAULTEPGDATAFILENAME;
2002-05-09 16:26:56 +02:00
bool DisplayHelp = false;
bool DisplayVersion = false;
2000-07-23 15:36:43 +02:00
bool DaemonMode = false;
int SysLogTarget = LOG_USER;
2002-03-08 16:37:42 +01:00
bool MuteAudio = false;
2001-02-24 16:18:43 +01:00
int WatchdogTimeout = DEFAULTWATCHDOG;
2001-09-01 09:04:37 +02:00
const char *Terminal = NULL;
const char *Shutdown = NULL;
bool UseKbd = true;
const char *LircDevice = NULL;
const char *RcuDevice = NULL;
#if !defined(REMOTE_KBD)
UseKbd = false;
#endif
#if defined(REMOTE_LIRC)
LircDevice = LIRC_DEVICE;
#elif defined(REMOTE_RCU)
RcuDevice = RCU_DEVICE;
#endif
#if defined(VFAT)
VfatFileSystem = true;
#endif
2006-01-13 16:16:32 +01:00
#if defined(VDR_USER)
VdrUser = VDR_USER;
#endif
2002-05-09 16:26:56 +02:00
cPluginManager PluginManager(DEFAULTPLUGINDIR);
int ExitCode = 0;
2000-07-23 15:01:31 +02:00
static struct option long_options[] = {
2001-06-24 17:42:19 +02:00
{ "audio", required_argument, NULL, 'a' },
2001-02-24 16:18:43 +01:00
{ "config", required_argument, NULL, 'c' },
{ "daemon", no_argument, NULL, 'd' },
{ "device", required_argument, NULL, 'D' },
2001-08-11 09:38:12 +02:00
{ "epgfile", required_argument, NULL, 'E' },
{ "grab", required_argument, NULL, 'g' },
2001-02-24 16:18:43 +01:00
{ "help", no_argument, NULL, 'h' },
2002-05-09 16:26:56 +02:00
{ "lib", required_argument, NULL, 'L' },
{ "lirc", optional_argument, NULL, 'l' | 0x100 },
2001-02-24 16:18:43 +01:00
{ "log", required_argument, NULL, 'l' },
2002-03-08 16:37:42 +01:00
{ "mute", no_argument, NULL, 'm' },
{ "no-kbd", no_argument, NULL, 'n' | 0x100 },
2002-05-09 16:26:56 +02:00
{ "plugin", required_argument, NULL, 'P' },
2001-02-24 16:18:43 +01:00
{ "port", required_argument, NULL, 'p' },
{ "rcu", optional_argument, NULL, 'r' | 0x100 },
2001-09-22 14:23:55 +02:00
{ "record", required_argument, NULL, 'r' },
2001-09-01 09:04:37 +02:00
{ "shutdown", required_argument, NULL, 's' },
{ "terminal", required_argument, NULL, 't' },
{ "user", required_argument, NULL, 'u' },
2002-03-29 10:10:04 +01:00
{ "version", no_argument, NULL, 'V' },
{ "vfat", no_argument, NULL, 'v' | 0x100 },
2001-02-24 16:18:43 +01:00
{ "video", required_argument, NULL, 'v' },
{ "watchdog", required_argument, NULL, 'w' },
2001-08-11 09:38:12 +02:00
{ NULL }
2000-07-23 15:01:31 +02:00
};
2001-08-03 14:18:08 +02:00
2000-07-23 15:01:31 +02:00
int c;
while ((c = getopt_long(argc, argv, "a:c:dD:E:g:hl:L:mp:P:r:s:t:u:v:Vw:", long_options, NULL)) != -1) {
2000-07-23 15:01:31 +02:00
switch (c) {
2002-11-03 11:53:58 +01:00
case 'a': AudioCommand = optarg;
2001-06-24 17:42:19 +02:00
break;
case 'c': ConfigDirectory = optarg;
break;
2000-07-23 15:36:43 +02:00
case 'd': DaemonMode = true; break;
2001-02-02 15:49:46 +01:00
case 'D': if (isnumber(optarg)) {
int n = atoi(optarg);
if (0 <= n && n < MAXDEVICES) {
cDevice::SetUseDevice(n);
2001-02-02 15:49:46 +01:00
break;
}
}
fprintf(stderr, "vdr: invalid DVB device number: %s\n", optarg);
2001-04-01 11:18:28 +02:00
return 2;
2001-02-02 15:49:46 +01:00
break;
case 'E': EpgDataFileName = (*optarg != '-' ? optarg : NULL);
2001-08-11 09:38:12 +02:00
break;
case 'g': cSVDRP::SetGrabImageDir(*optarg != '-' ? optarg : NULL);
break;
2002-05-09 16:26:56 +02:00
case 'h': DisplayHelp = true;
2000-07-23 15:01:31 +02:00
break;
case 'l': {
char *p = strchr(optarg, '.');
if (p)
*p = 0;
if (isnumber(optarg)) {
int l = atoi(optarg);
if (0 <= l && l <= 3) {
SysLogLevel = l;
if (!p)
break;
if (isnumber(p + 1)) {
int l = atoi(p + 1);
if (0 <= l && l <= 7) {
int targets[] = { LOG_LOCAL0, LOG_LOCAL1, LOG_LOCAL2, LOG_LOCAL3, LOG_LOCAL4, LOG_LOCAL5, LOG_LOCAL6, LOG_LOCAL7 };
SysLogTarget = targets[l];
break;
}
}
}
}
if (p)
*p = '.';
fprintf(stderr, "vdr: invalid log level: %s\n", optarg);
2001-04-01 11:18:28 +02:00
return 2;
}
break;
case 'L': if (access(optarg, R_OK | X_OK) == 0)
PluginManager.SetDirectory(optarg);
else {
fprintf(stderr, "vdr: can't access plugin directory: %s\n", optarg);
return 2;
}
2002-05-09 16:26:56 +02:00
break;
case 'l' | 0x100:
LircDevice = optarg ? : LIRC_DEVICE;
break;
2002-03-08 16:37:42 +01:00
case 'm': MuteAudio = true;
break;
case 'n' | 0x100:
UseKbd = false;
break;
2000-07-23 15:01:31 +02:00
case 'p': if (isnumber(optarg))
SVDRPport = atoi(optarg);
2000-07-23 15:01:31 +02:00
else {
fprintf(stderr, "vdr: invalid port number: %s\n", optarg);
2001-04-01 11:18:28 +02:00
return 2;
2000-07-23 15:01:31 +02:00
}
break;
2002-05-09 16:26:56 +02:00
case 'P': PluginManager.AddPlugin(optarg);
break;
case 'r' | 0x100:
RcuDevice = optarg ? : RCU_DEVICE;
break;
case 'r': cRecordingUserCommand::SetCommand(optarg);
2001-09-22 14:23:55 +02:00
break;
2001-09-01 09:04:37 +02:00
case 's': Shutdown = optarg;
break;
2001-03-31 10:32:58 +02:00
case 't': Terminal = optarg;
if (access(Terminal, R_OK | W_OK) < 0) {
fprintf(stderr, "vdr: can't access terminal: %s\n", Terminal);
return 2;
}
2001-03-31 10:32:58 +02:00
break;
case 'u': if (*optarg)
VdrUser = optarg;
break;
2002-05-09 16:26:56 +02:00
case 'V': DisplayVersion = true;
2002-03-29 10:10:04 +01:00
break;
case 'v' | 0x100:
VfatFileSystem = true;
break;
2000-07-28 13:44:31 +02:00
case 'v': VideoDirectory = optarg;
while (optarg && *optarg && optarg[strlen(optarg) - 1] == '/')
optarg[strlen(optarg) - 1] = 0;
2000-07-28 13:44:31 +02:00
break;
case 'w': if (isnumber(optarg)) { int t = atoi(optarg);
2001-02-24 16:18:43 +01:00
if (t >= 0) {
WatchdogTimeout = t;
break;
}
}
fprintf(stderr, "vdr: invalid watchdog timeout: %s\n", optarg);
2001-04-01 11:18:28 +02:00
return 2;
2001-02-24 16:18:43 +01:00
break;
2001-04-01 11:18:28 +02:00
default: return 2;
2000-07-23 15:01:31 +02:00
}
}
// Set user id in case we were started as root:
if (VdrUser && geteuid() == 0) {
StartedAsRoot = true;
if (strcmp(VdrUser, "root")) {
if (!SetKeepCaps(true))
return 2;
if (!SetUser(VdrUser))
return 2;
if (!SetKeepCaps(false))
return 2;
if (!SetCapSysTime())
return 2;
}
}
2002-05-09 16:26:56 +02:00
// Help and version info:
if (DisplayHelp || DisplayVersion) {
if (!PluginManager.HasPlugins())
PluginManager.AddPlugin("*"); // adds all available plugins
PluginManager.LoadPlugins();
if (DisplayHelp) {
printf("Usage: vdr [OPTIONS]\n\n" // for easier orientation, this is column 80|
" -a CMD, --audio=CMD send Dolby Digital audio to stdin of command CMD\n"
" -c DIR, --config=DIR read config files from DIR (default is to read them\n"
" from the video directory)\n"
" -d, --daemon run in daemon mode\n"
" -D NUM, --device=NUM use only the given DVB device (NUM = 0, 1, 2...)\n"
" there may be several -D options (default: all DVB\n"
" devices will be used)\n"
" -E FILE, --epgfile=FILE write the EPG data into the given FILE (default is\n"
" '%s' in the video directory)\n"
" '-E-' disables this\n"
2002-05-09 16:26:56 +02:00
" if FILE is a directory, the default EPG file will be\n"
" created in that directory\n"
" -g DIR, --grab=DIR write images from the SVDRP command GRAB into the\n"
" given DIR; DIR must be the full path name of an\n"
" existing directory, without any \"..\", double '/'\n"
" or symlinks (default: none, same as -g-)\n"
2002-05-09 16:26:56 +02:00
" -h, --help print this help and exit\n"
" -l LEVEL, --log=LEVEL set log level (default: 3)\n"
" 0 = no logging, 1 = errors only,\n"
" 2 = errors and info, 3 = errors, info and debug\n"
" if logging should be done to LOG_LOCALn instead of\n"
" LOG_USER, add '.n' to LEVEL, as in 3.7 (n=0..7)\n"
2002-05-09 16:26:56 +02:00
" -L DIR, --lib=DIR search for plugins in DIR (default is %s)\n"
" --lirc[=PATH] use a LIRC remote control device, attached to PATH\n"
" (default: %s)\n"
2002-05-09 16:26:56 +02:00
" -m, --mute mute audio of the primary DVB device at startup\n"
" --no-kbd don't use the keyboard as an input device\n"
2002-05-09 16:26:56 +02:00
" -p PORT, --port=PORT use PORT for SVDRP (default: %d)\n"
" 0 turns off SVDRP\n"
" -P OPT, --plugin=OPT load a plugin defined by the given options\n"
" --rcu[=PATH] use a remote control device, attached to PATH\n"
" (default: %s)\n"
2002-05-09 16:26:56 +02:00
" -r CMD, --record=CMD call CMD before and after a recording\n"
" -s CMD, --shutdown=CMD call CMD to shutdown the computer\n"
" -t TTY, --terminal=TTY controlling tty\n"
2006-01-13 16:16:32 +01:00
" -u USER, --user=USER run as user USER; only applicable if started as\n"
" root\n"
2002-05-09 16:26:56 +02:00
" -v DIR, --video=DIR use DIR as video directory (default: %s)\n"
" -V, --version print version information and exit\n"
" --vfat encode special characters in recording names to\n"
" avoid problems with VFAT file systems\n"
2002-05-09 16:26:56 +02:00
" -w SEC, --watchdog=SEC activate the watchdog timer with a timeout of SEC\n"
" seconds (default: %d); '0' disables the watchdog\n"
"\n",
DEFAULTEPGDATAFILENAME,
2002-05-09 16:26:56 +02:00
DEFAULTPLUGINDIR,
LIRC_DEVICE,
2002-05-09 16:26:56 +02:00
DEFAULTSVDRPPORT,
RCU_DEVICE,
2002-05-09 16:26:56 +02:00
VideoDirectory,
DEFAULTWATCHDOG
);
}
if (DisplayVersion)
printf("vdr (%s) - The Video Disk Recorder\n", VDRVERSION);
if (PluginManager.HasPlugins()) {
if (DisplayHelp)
printf("Plugins: vdr -P\"name [OPTIONS]\"\n\n");
for (int i = 0; ; i++) {
cPlugin *p = PluginManager.GetPlugin(i);
if (p) {
const char *help = p->CommandLineHelp();
printf("%s (%s) - %s\n", p->Name(), p->Version(), p->Description());
if (DisplayHelp && help) {
printf("\n");
puts(help);
}
}
else
break;
}
}
return 0;
}
// Check for UTF-8 and exit if present - asprintf() will fail if it encounters 8 bit ASCII codes
char *LangEnv;
if ((LangEnv = getenv("LANG")) != NULL && strcasestr(LangEnv, "utf") ||
(LangEnv = getenv("LC_CTYPE")) != NULL && strcasestr(LangEnv, "utf")) {
fprintf(stderr, "vdr: please turn off UTF-8 before starting VDR\n");
return 2;
}
2000-07-23 15:01:31 +02:00
// Log file:
2001-08-03 14:18:08 +02:00
if (SysLogLevel > 0)
openlog("vdr", LOG_CONS, SysLogTarget); // LOG_PID doesn't work as expected under NPTL
2000-07-23 15:36:43 +02:00
2000-07-28 13:44:31 +02:00
// Check the video directory:
if (!DirectoryOk(VideoDirectory, true)) {
2000-07-28 13:44:31 +02:00
fprintf(stderr, "vdr: can't access video directory %s\n", VideoDirectory);
2001-04-01 11:18:28 +02:00
return 2;
2000-07-28 13:44:31 +02:00
}
2000-07-23 15:36:43 +02:00
// Daemon mode:
if (DaemonMode) {
if (daemon(1, 0) == -1) {
fprintf(stderr, "vdr: %m\n");
2002-05-13 16:35:49 +02:00
esyslog("ERROR: %m");
2001-04-01 11:18:28 +02:00
return 2;
2000-07-23 15:36:43 +02:00
}
}
2001-03-31 10:32:58 +02:00
else if (Terminal) {
// Claim new controlling terminal
stdin = freopen(Terminal, "r", stdin);
stdout = freopen(Terminal, "w", stdout);
stderr = freopen(Terminal, "w", stderr);
HasStdin = true;
2001-03-31 10:32:58 +02:00
}
2002-05-13 16:35:49 +02:00
isyslog("VDR version %s started", VDRVERSION);
2006-01-13 16:16:32 +01:00
if (StartedAsRoot && VdrUser)
isyslog("switched to user '%s'", VdrUser);
if (DaemonMode)
dsyslog("running as daemon (tid=%d)", cThread::ThreadId());
cThread::SetMainThreadId();
2000-02-19 13:36:48 +01:00
// Main program loop variables - need to be here to have them initialized before any EXIT():
cOsdObject *Menu = NULL;
int LastChannel = 0;
int LastTimerChannel = -1;
int PreviousChannel[2] = { 1, 1 };
int PreviousChannelIndex = 0;
time_t LastChannelChanged = time(NULL);
time_t LastActivity = 0;
time_t LastCamMenu = 0;
int MaxLatencyTime = 0;
bool ForceShutdown = false;
bool UserShutdown = false;
bool TimerInVpsMargin = false;
2006-01-06 12:53:28 +01:00
bool IsInfoMenu = false;
2002-05-09 16:26:56 +02:00
// Load plugins:
if (!PluginManager.LoadPlugins(true))
EXIT(2);
2002-05-09 16:26:56 +02:00
2000-07-23 15:01:31 +02:00
// Configuration data:
if (!ConfigDirectory)
ConfigDirectory = VideoDirectory;
cPlugin::SetConfigDirectory(ConfigDirectory);
cThemes::SetThemesDirectory(AddDirectory(ConfigDirectory, "themes"));
Setup.Load(AddDirectory(ConfigDirectory, "setup.conf"));
if (!(Sources.Load(AddDirectory(ConfigDirectory, "sources.conf"), true, true) &&
Diseqcs.Load(AddDirectory(ConfigDirectory, "diseqc.conf"), true, Setup.DiSEqC) &&
Channels.Load(AddDirectory(ConfigDirectory, "channels.conf"), false, true) &&
Timers.Load(AddDirectory(ConfigDirectory, "timers.conf")) &&
Commands.Load(AddDirectory(ConfigDirectory, "commands.conf"), true) &&
RecordingCommands.Load(AddDirectory(ConfigDirectory, "reccmds.conf"), true) &&
SVDRPhosts.Load(AddDirectory(ConfigDirectory, "svdrphosts.conf"), true) &&
Keys.Load(AddDirectory(ConfigDirectory, "remote.conf")) &&
KeyMacros.Load(AddDirectory(ConfigDirectory, "keymacros.conf"), true)
))
EXIT(2);
2000-02-19 13:36:48 +01:00
cFont::SetCode(I18nCharSets()[Setup.OSDLanguage]);
// Recordings:
Recordings.Update();
DeletedRecordings.Update();
// EPG data:
if (EpgDataFileName) {
2004-12-19 16:33:34 +01:00
const char *EpgDirectory = NULL;
if (DirectoryOk(EpgDataFileName)) {
EpgDirectory = EpgDataFileName;
EpgDataFileName = DEFAULTEPGDATAFILENAME;
}
else if (*EpgDataFileName != '/' && *EpgDataFileName != '.')
2004-12-19 16:33:34 +01:00
EpgDirectory = VideoDirectory;
2005-01-14 16:55:28 +01:00
if (EpgDirectory)
cSchedules::SetEpgDataFileName(AddDirectory(EpgDirectory, EpgDataFileName));
else
cSchedules::SetEpgDataFileName(EpgDataFileName);
2004-12-19 16:33:34 +01:00
cSchedules::Read();
}
// DVB interfaces:
cDvbDevice::Initialize();
2003-05-09 15:27:46 +02:00
// Initialize plugins:
2002-05-09 16:26:56 +02:00
2003-05-09 15:27:46 +02:00
if (!PluginManager.InitializePlugins())
EXIT(2);
2002-05-09 16:26:56 +02:00
// Primary device:
cDevice::SetPrimaryDevice(Setup.PrimaryDVB);
if (!cDevice::PrimaryDevice() || !cDevice::PrimaryDevice()->HasDecoder()) {
if (cDevice::PrimaryDevice() && !cDevice::PrimaryDevice()->HasDecoder())
isyslog("device %d has no MPEG decoder", cDevice::PrimaryDevice()->DeviceNumber() + 1);
2003-03-09 14:10:12 +01:00
for (int i = 0; i < cDevice::NumDevices(); i++) {
cDevice *d = cDevice::GetDevice(i);
if (d && d->HasDecoder()) {
isyslog("trying device number %d instead", i + 1);
if (cDevice::SetPrimaryDevice(i + 1)) {
2003-03-09 14:10:12 +01:00
Setup.PrimaryDVB = i + 1;
break;
}
2003-03-09 14:10:12 +01:00
}
}
if (!cDevice::PrimaryDevice()) {
const char *msg = "no primary device found - using first device!";
fprintf(stderr, "vdr: %s\n", msg);
esyslog("ERROR: %s", msg);
if (!cDevice::SetPrimaryDevice(1))
EXIT(2);
if (!cDevice::PrimaryDevice()) {
const char *msg = "no primary device found - giving up!";
fprintf(stderr, "vdr: %s\n", msg);
esyslog("ERROR: %s", msg);
EXIT(2);
}
}
}
2002-09-29 13:40:45 +02:00
// User interface:
Interface = new cInterface(SVDRPport);
// Default skins:
new cSkinClassic;
new cSkinSTTNG;
Skins.SetCurrent(Setup.OSDSkin);
cThemes::Load(Skins.Current()->Name(), Setup.OSDTheme, Skins.Current()->Theme());
// Start plugins:
if (!PluginManager.StartPlugins())
EXIT(2);
// Set skin and theme in case they're implemented by a plugin:
2004-05-16 10:35:36 +02:00
Skins.SetCurrent(Setup.OSDSkin);
cThemes::Load(Skins.Current()->Name(), Setup.OSDTheme, Skins.Current()->Theme());
2002-09-29 13:40:45 +02:00
// Remote Controls:
if (RcuDevice)
new cRcuRemote(RcuDevice);
if (LircDevice)
new cLircRemote(LircDevice);
if (!DaemonMode && HasStdin && UseKbd)
new cKbdRemote;
2002-09-29 13:40:45 +02:00
Interface->LearnKeys();
2002-11-03 11:53:58 +01:00
// External audio:
if (AudioCommand)
new cExternalAudio(AudioCommand);
2002-05-09 16:26:56 +02:00
// Channel:
if (!cDevice::WaitForAllDevicesReady(DEVICEREADYTIMEOUT))
dsyslog("not all devices ready after %d seconds", DEVICEREADYTIMEOUT);
if (Setup.InitialChannel > 0)
Setup.CurrentChannel = Setup.InitialChannel;
if (Setup.InitialVolume >= 0)
Setup.CurrentVolume = Setup.InitialVolume;
Channels.SwitchTo(Setup.CurrentChannel);
2002-03-08 16:37:42 +01:00
if (MuteAudio)
cDevice::PrimaryDevice()->ToggleMute();
2002-03-08 16:37:42 +01:00
else
cDevice::PrimaryDevice()->SetVolume(Setup.CurrentVolume, true);
2000-02-19 13:36:48 +01:00
2000-07-23 15:01:31 +02:00
// Signal handlers:
if (signal(SIGHUP, SignalHandler) == SIG_IGN) signal(SIGHUP, SIG_IGN);
if (signal(SIGINT, SignalHandler) == SIG_IGN) signal(SIGINT, SIG_IGN);
if (signal(SIGTERM, SignalHandler) == SIG_IGN) signal(SIGTERM, SIG_IGN);
if (signal(SIGPIPE, SignalHandler) == SIG_IGN) signal(SIGPIPE, SIG_IGN);
2001-02-24 16:18:43 +01:00
if (WatchdogTimeout > 0)
if (signal(SIGALRM, Watchdog) == SIG_IGN) signal(SIGALRM, SIG_IGN);
2003-05-09 15:27:46 +02:00
// Watchdog:
if (WatchdogTimeout > 0) {
dsyslog("setting watchdog timer to %d seconds", WatchdogTimeout);
alarm(WatchdogTimeout); // Initial watchdog timer start
}
2000-07-23 15:01:31 +02:00
// Main program loop:
2006-01-06 12:53:28 +01:00
#define DELETE_MENU ((IsInfoMenu &= (Menu == NULL)), delete Menu, Menu = NULL)
while (!Interrupted) {
// Handle emergency exits:
if (cThread::EmergencyExit()) {
2002-05-13 16:35:49 +02:00
esyslog("emergency exit requested - shutting down");
break;
}
2004-10-16 09:36:28 +02:00
#ifdef DEBUGRINGBUFFERS
cRingBufferLinear::PrintDebugRBL();
#endif
// Attach launched player control:
cControl::Attach();
// Make sure we have a visible programme in case device usage has changed:
if (!EITScanner.Active() && cDevice::PrimaryDevice()->HasDecoder() && !cDevice::PrimaryDevice()->HasProgramme()) {
static time_t lastTime = 0;
if (time(NULL) - lastTime > MINCHANNELWAIT) {
cChannel *Channel = Channels.GetByNumber(cDevice::CurrentChannel());
if (Channel && (Channel->Vpid() || Channel->Apid(0))) {
if (!Channels.SwitchTo(cDevice::CurrentChannel()) // try to switch to the original channel...
&& !(LastTimerChannel > 0 && Channels.SwitchTo(LastTimerChannel)) // ...or the one used by the last timer...
&& !cDevice::SwitchChannel(1) // ...or the next higher available one...
&& !cDevice::SwitchChannel(-1)) // ...or the next lower available one
2006-01-08 11:44:37 +01:00
;
}
lastTime = time(NULL); // don't do this too often
LastTimerChannel = -1;
}
}
2001-02-24 16:18:43 +01:00
// Restart the Watchdog timer:
if (WatchdogTimeout > 0) {
int LatencyTime = WatchdogTimeout - alarm(WatchdogTimeout);
if (LatencyTime > MaxLatencyTime) {
MaxLatencyTime = LatencyTime;
2002-05-13 16:35:49 +02:00
dsyslog("max. latency time %d seconds", MaxLatencyTime);
2001-02-24 16:18:43 +01:00
}
}
// Handle channel and timer modifications:
if (!Channels.BeingEdited() && !Timers.BeingEdited()) {
int modified = Channels.Modified();
static time_t ChannelSaveTimeout = 0;
static int TimerState = 0;
// Channels and timers need to be stored in a consistent manner,
// therefore if one of them is changed, we save both.
if (modified == CHANNELSMOD_USER || Timers.Modified(TimerState))
ChannelSaveTimeout = 1; // triggers an immediate save
else if (modified && !ChannelSaveTimeout)
ChannelSaveTimeout = time(NULL) + CHANNELSAVEDELTA;
bool timeout = ChannelSaveTimeout == 1 || ChannelSaveTimeout && time(NULL) > ChannelSaveTimeout && !cRecordControls::Active();
if ((modified || timeout) && Channels.Lock(false, 100)) {
if (timeout) {
Channels.Save();
Timers.Save();
ChannelSaveTimeout = 0;
}
for (cChannel *Channel = Channels.First(); Channel; Channel = Channels.Next(Channel)) {
2004-02-08 11:23:29 +01:00
if (Channel->Modification(CHANNELMOD_RETUNE)) {
cRecordControls::ChannelDataModified(Channel);
if (Channel->Number() == cDevice::CurrentChannel()) {
2006-02-04 14:58:24 +01:00
if (!cDevice::PrimaryDevice()->Replaying() || cDevice::PrimaryDevice()->Transferring()) {
if (cDevice::ActualDevice()->ProvidesTransponder(Channel)) { // avoids retune on devices that don't really access the transponder
isyslog("retuning due to modification of channel %d", Channel->Number());
Channels.SwitchTo(Channel->Number());
}
}
}
}
}
Channels.Unlock();
}
}
2000-04-22 13:51:48 +02:00
// Channel display:
if (!EITScanner.Active() && cDevice::CurrentChannel() != LastChannel) {
2000-09-09 14:57:43 +02:00
if (!Menu)
Menu = new cDisplayChannel(cDevice::CurrentChannel(), LastChannel >= 0);
LastChannel = cDevice::CurrentChannel();
LastChannelChanged = time(NULL);
}
if (time(NULL) - LastChannelChanged >= Setup.ZapTimeout && LastChannel != PreviousChannel[PreviousChannelIndex])
PreviousChannel[PreviousChannelIndex ^= 1] = LastChannel;
2000-05-01 16:29:46 +02:00
// Timers and Recordings:
if (!Timers.BeingEdited()) {
// Assign events to timers:
Timers.SetEvents();
// Must do all following calls with the exact same time!
time_t Now = time(NULL);
2004-02-29 14:21:22 +01:00
// Process ongoing recordings:
cRecordControls::Process(Now);
2004-02-29 14:21:22 +01:00
// Start new recordings:
cTimer *Timer = Timers.GetMatch(Now);
2000-04-30 10:22:13 +02:00
if (Timer) {
if (!cRecordControls::Start(Timer))
Timer->SetPending(true);
else
LastTimerChannel = Timer->Channel()->Number();
}
2004-02-29 14:21:22 +01:00
// Make sure VPS timers "see" their channel early enough:
static time_t LastVpsCheck = 0;
if (Now - LastVpsCheck > VPSCHECKDELTA) { // don't do this too often
TimerInVpsMargin = false;
static time_t DeviceUsed[MAXDEVICES] = { 0 };
for (cTimer *Timer = Timers.First(); Timer; Timer = Timers.Next(Timer)) {
if (Timer->HasFlags(tfActive | tfVps) && !Timer->Recording() && Timer->Matches(Now, true, Setup.VpsMargin)) {
2004-02-29 14:21:22 +01:00
Timer->SetInVpsMargin(true);
// Find a device that provides the required transponder:
cDevice *Device = NULL;
for (int i = 0; i < cDevice::NumDevices(); i++) {
cDevice *d = cDevice::GetDevice(i);
if (d && d->ProvidesTransponder(Timer->Channel())) {
if (d->IsTunedToTransponder(Timer->Channel())) {
// if any device is tuned to the transponder, we're done
Device = d;
break;
}
else if (Now - DeviceUsed[d->DeviceNumber()] > VPSDEVICETIMEOUT) {
// only check other devices if they have been left alone for a while
if (d->MaySwitchTransponder())
// this one can be switched without disturbing anything else
Device = d;
else if (!Device && !d->Receiving() && d->ProvidesTransponderExclusively(Timer->Channel()))
// use this one only if no other with less impact can be found
Device = d;
}
}
}
if (!Device) {
cDevice *d = cDevice::ActualDevice();
if (!d->Receiving() && d->ProvidesTransponder(Timer->Channel()) && Now - DeviceUsed[d->DeviceNumber()] > VPSDEVICETIMEOUT)
Device = d; // use the actual device as a last resort
}
// Switch the device to the transponder:
if (Device) {
if (Device == cDevice::ActualDevice() && !Device->IsPrimaryDevice())
cDevice::PrimaryDevice()->StopReplay(); // stop transfer mode
if (!Device->IsTunedToTransponder(Timer->Channel())) {
dsyslog("switching device %d to channel %d", Device->DeviceNumber() + 1, Timer->Channel()->Number());
Device->SwitchChannel(Timer->Channel(), false);
DeviceUsed[Device->DeviceNumber()] = Now;
}
if (cDevice::PrimaryDevice()->HasDecoder() && !cDevice::PrimaryDevice()->HasProgramme()) {
// the previous SwitchChannel() has switched away the current live channel
Channels.SwitchTo(Timer->Channel()->Number()); // avoids toggling between old channel and black screen
Skins.Message(mtInfo, tr("Upcoming VPS recording!"));
}
}
TimerInVpsMargin = true;
2004-02-29 14:21:22 +01:00
}
else
Timer->SetInVpsMargin(false);
2004-02-29 14:21:22 +01:00
}
LastVpsCheck = time(NULL);
}
// Delete expired timers:
Timers.DeleteExpired();
}
if (!Menu && Recordings.NeedsUpdate()) {
Recordings.Update();
DeletedRecordings.Update();
}
// CAM control:
if (!Menu && !cOsd::IsOpen()) {
Menu = CamControl();
if (Menu)
LastCamMenu = 0;
else if (!LastCamMenu)
LastCamMenu = time(NULL);
}
2005-11-27 15:57:03 +01:00
// Queued messages:
if (!Skins.IsOpen())
Skins.ProcessQueuedMessages();
// User Input:
cOsdObject *Interact = Menu ? Menu : cControl::Control();
eKeys key = Interface->GetKey((!Interact || !Interact->NeedsFastResponse()) && time(NULL) - LastCamMenu > LASTCAMMENUTIMEOUT);
2001-09-01 09:04:37 +02:00
if (NORMALKEY(key) != kNone) {
EITScanner.Activity();
2001-09-01 09:04:37 +02:00
LastActivity = time(NULL);
}
// Keys that must work independent of any interactive mode:
switch (key) {
// Menu control:
case kMenu: {
2003-05-02 10:59:07 +02:00
key = kNone; // nobody else needs to see this key
bool WasOpen = Interact != NULL;
bool WasMenu = Interact && Interact->IsMenu();
if (Menu)
2006-01-06 12:53:28 +01:00
DELETE_MENU;
else if (cControl::Control()) {
if (cOsd::IsOpen())
cControl::Control()->Hide();
else
WasOpen = false;
}
if (!WasOpen || !WasMenu && !Setup.MenuButtonCloses)
Menu = new cMenuMain;
}
break;
2006-01-06 12:53:28 +01:00
// Info:
case kInfo: {
bool WasInfoMenu = IsInfoMenu;
DELETE_MENU;
if (!WasInfoMenu) {
IsInfoMenu = true;
if (cControl::Control()) {
cControl::Control()->Hide();
Menu = cControl::Control()->GetInfo();
if (Menu)
Menu->Show();
else
IsInfoMenu = false;
}
else {
cRemote::Put(kOk, true);
cRemote::Put(kSchedule, true);
}
}
}
break;
// Direct main menu functions:
#define DirectMainFunction(function)\
2006-01-06 12:53:28 +01:00
DELETE_MENU;\
2002-10-27 14:32:06 +01:00
if (cControl::Control())\
cControl::Control()->Hide();\
Menu = new cMenuMain(function);\
2003-05-02 10:59:07 +02:00
key = kNone; // nobody else needs to see this key
2002-10-27 14:32:06 +01:00
case kSchedule: DirectMainFunction(osSchedule); break;
case kChannels: DirectMainFunction(osChannels); break;
case kTimers: DirectMainFunction(osTimers); break;
case kRecordings: DirectMainFunction(osRecordings); break;
case kSetup: DirectMainFunction(osSetup); break;
case kCommands: DirectMainFunction(osCommands); break;
2003-05-02 10:59:07 +02:00
case kUser1 ... kUser9: cRemote::PutMacro(key); key = kNone; break;
case k_Plugin: {
2006-01-06 12:53:28 +01:00
DELETE_MENU;
if (cControl::Control())
cControl::Control()->Hide();
cPlugin *plugin = cPluginManager::GetPlugin(cRemote::GetPlugin());
if (plugin) {
Menu = plugin->MainMenuAction();
if (Menu)
Menu->Show();
}
else
esyslog("ERROR: unknown plugin '%s'", cRemote::GetPlugin());
key = kNone; // nobody else needs to see these keys
}
break;
2002-10-27 14:32:06 +01:00
// Channel up/down:
case kChanUp|k_Repeat:
case kChanUp:
case kChanDn|k_Repeat:
case kChanDn:
if (!Interact)
Menu = new cDisplayChannel(NORMALKEY(key));
else if (cDisplayChannel::IsOpen()) {
Interact->ProcessKey(key);
continue;
}
else
cDevice::SwitchChannel(NORMALKEY(key) == kChanUp ? 1 : -1);
key = kNone; // nobody else needs to see these keys
2002-10-27 14:32:06 +01:00
break;
2005-01-02 15:11:44 +01:00
// Volume control:
case kVolUp|k_Repeat:
case kVolUp:
case kVolDn|k_Repeat:
case kVolDn:
case kMute:
2002-03-09 17:11:49 +01:00
if (key == kMute) {
if (!cDevice::PrimaryDevice()->ToggleMute() && !Menu) {
key = kNone; // nobody else needs to see these keys
2002-03-09 17:11:49 +01:00
break; // no need to display "mute off"
}
2002-03-09 17:11:49 +01:00
}
else
cDevice::PrimaryDevice()->SetVolume(NORMALKEY(key) == kVolDn ? -VOLUMEDELTA : VOLUMEDELTA);
2004-05-16 10:35:36 +02:00
if (!Menu && !cOsd::IsOpen())
Menu = cDisplayVolume::Create();
2002-03-09 17:11:49 +01:00
cDisplayVolume::Process(key);
key = kNone; // nobody else needs to see these keys
break;
2005-01-02 15:11:44 +01:00
// Audio track control:
case kAudio:
2005-01-06 14:36:40 +01:00
if (cControl::Control())
cControl::Control()->Hide();
if (!cDisplayTracks::IsOpen()) {
2006-01-06 12:53:28 +01:00
DELETE_MENU;
Menu = cDisplayTracks::Create();
2005-01-06 14:36:40 +01:00
}
2005-01-02 15:11:44 +01:00
else
cDisplayTracks::Process(key);
key = kNone;
break;
2003-04-21 14:57:13 +02:00
// Pausing live video:
case kPause:
if (!cControl::Control()) {
2006-01-06 12:53:28 +01:00
DELETE_MENU;
2003-04-21 14:57:13 +02:00
if (!cRecordControls::PauseLiveVideo())
2004-05-16 10:35:36 +02:00
Skins.Message(mtError, tr("No free DVB device to record!"));
2003-04-21 14:57:13 +02:00
key = kNone; // nobody else needs to see this key
}
break;
// Instant recording:
case kRecord:
if (!cControl::Control()) {
if (cRecordControls::Start())
Skins.Message(mtInfo, tr("Recording started"));
2003-04-21 14:57:13 +02:00
key = kNone; // nobody else needs to see this key
}
break;
// Power off:
2002-05-13 16:35:49 +02:00
case kPower: isyslog("Power button pressed");
2006-01-06 12:53:28 +01:00
DELETE_MENU;
if (!Shutdown) {
2004-05-16 10:35:36 +02:00
Skins.Message(mtError, tr("Can't shutdown - option '-s' not given!"));
break;
}
if (cRecordControls::Active()) {
if (Interface->Confirm(tr("Recording - shut down anyway?")))
ForceShutdown = true;
}
2006-04-15 11:18:36 +02:00
if (cPluginManager::Active(tr("shut down anyway?")))
ForceShutdown = true;
LastActivity = 1; // not 0, see below!
UserShutdown = true;
break;
2002-10-27 14:32:06 +01:00
default: break;
}
2002-10-27 14:32:06 +01:00
Interact = Menu ? Menu : cControl::Control(); // might have been closed in the mean time
if (Interact) {
eOSState state = Interact->ProcessKey(key);
if (state == osUnknown && Interact != cControl::Control()) {
if (ISMODELESSKEY(key) && cControl::Control()) {
state = cControl::Control()->ProcessKey(key);
if (state == osEnd) {
// let's not close a menu when replay ends:
cControl::Shutdown();
continue;
}
}
else if (time(NULL) - LastActivity > MENUTIMEOUT)
state = osEnd;
}
2002-10-27 14:32:06 +01:00
switch (state) {
2006-01-06 12:53:28 +01:00
case osPause: DELETE_MENU;
2003-04-21 14:57:13 +02:00
cControl::Shutdown(); // just in case
if (!cRecordControls::PauseLiveVideo())
2004-05-16 10:35:36 +02:00
Skins.Message(mtError, tr("No free DVB device to record!"));
2003-04-21 14:57:13 +02:00
break;
2006-01-06 12:53:28 +01:00
case osRecord: DELETE_MENU;
2002-10-27 14:32:06 +01:00
if (cRecordControls::Start())
Skins.Message(mtInfo, tr("Recording started"));
2002-10-27 14:32:06 +01:00
break;
case osRecordings:
2006-01-06 12:53:28 +01:00
DELETE_MENU;
2002-10-27 14:32:06 +01:00
cControl::Shutdown();
Menu = new cMenuMain(osRecordings);
2002-10-27 14:32:06 +01:00
break;
2006-01-06 12:53:28 +01:00
case osReplay: DELETE_MENU;
2002-10-27 14:32:06 +01:00
cControl::Shutdown();
cControl::Launch(new cReplayControl);
break;
case osStopReplay:
2006-01-06 12:53:28 +01:00
DELETE_MENU;
2002-10-27 14:32:06 +01:00
cControl::Shutdown();
break;
case osSwitchDvb:
2006-01-06 12:53:28 +01:00
DELETE_MENU;
2002-10-27 14:32:06 +01:00
cControl::Shutdown();
2004-05-16 10:35:36 +02:00
Skins.Message(mtInfo, tr("Switching primary DVB..."));
2002-10-27 14:32:06 +01:00
cDevice::SetPrimaryDevice(Setup.PrimaryDVB);
break;
2006-01-06 12:53:28 +01:00
case osPlugin: DELETE_MENU;
Menu = cMenuMain::PluginOsdObject();
2002-11-24 10:45:39 +01:00
if (Menu)
Menu->Show();
break;
2002-10-27 14:32:06 +01:00
case osBack:
case osEnd: if (Interact == Menu)
2006-01-06 12:53:28 +01:00
DELETE_MENU;
2002-10-27 14:32:06 +01:00
else
cControl::Shutdown();
break;
default: ;
}
}
else {
// Key functions in "normal" viewing mode:
if (key != kNone && KeyMacros.Get(key)) {
cRemote::PutMacro(key);
key = kNone;
}
2002-10-27 14:32:06 +01:00
switch (key) {
// Toggle channels:
2006-04-15 13:56:03 +02:00
case kChanPrev:
2002-10-27 14:32:06 +01:00
case k0: {
if (PreviousChannel[PreviousChannelIndex ^ 1] == LastChannel || LastChannel != PreviousChannel[0] && LastChannel != PreviousChannel[1])
PreviousChannelIndex ^= 1;
Channels.SwitchTo(PreviousChannel[PreviousChannelIndex ^= 1]);
2002-10-27 14:32:06 +01:00
break;
}
// Direct Channel Select:
case k1 ... k9:
2006-04-15 13:46:55 +02:00
// Left/Right rotates through channel groups:
2002-10-27 14:32:06 +01:00
case kLeft|k_Repeat:
case kLeft:
case kRight|k_Repeat:
case kRight:
2006-04-15 13:46:55 +02:00
// Previous/Next rotates through channel groups:
case kPrev|k_Repeat:
case kPrev:
case kNext|k_Repeat:
case kNext:
2002-10-27 14:32:06 +01:00
// Up/Down Channel Select:
case kUp|k_Repeat:
case kUp:
case kDown|k_Repeat:
case kDown:
Menu = new cDisplayChannel(NORMALKEY(key));
2002-10-27 14:32:06 +01:00
break;
// Viewing Control:
case kOk: LastChannel = -1; break; // forces channel display
// Instant resume of the last viewed recording:
case kPlay:
if (cReplayControl::LastReplayed()) {
cControl::Shutdown();
cControl::Launch(new cReplayControl);
}
break;
2002-10-27 14:32:06 +01:00
default: break;
}
}
2000-12-28 12:57:16 +01:00
if (!Menu) {
2004-02-29 14:21:22 +01:00
if (!TimerInVpsMargin)
EITScanner.Process();
2002-06-22 10:11:59 +02:00
if (!cCutter::Active() && cCutter::Ended()) {
if (cCutter::Error())
2004-05-16 10:35:36 +02:00
Skins.Message(mtError, tr("Editing process failed!"));
else
2004-05-16 10:35:36 +02:00
Skins.Message(mtInfo, tr("Editing process finished"));
}
2000-12-28 12:57:16 +01:00
}
2006-04-15 11:18:36 +02:00
if (!Interact && ((!cRecordControls::Active() && !cCutter::Active() && !cPluginManager::Active() && (!Interface->HasSVDRPConnection() || UserShutdown)) || ForceShutdown)) {
2001-09-01 09:04:37 +02:00
time_t Now = time(NULL);
if (Now - LastActivity > ACTIVITYTIMEOUT) {
// Shutdown:
if (Shutdown && (Setup.MinUserInactivity || LastActivity == 1) && Now - LastActivity > Setup.MinUserInactivity * 60) {
2001-09-01 09:04:37 +02:00
cTimer *timer = Timers.GetNextActiveTimer();
2001-09-01 11:44:08 +02:00
time_t Next = timer ? timer->StartTime() : 0;
time_t Delta = timer ? Next - Now : 0;
2001-09-07 15:37:26 +02:00
if (!LastActivity) {
if (!timer || Delta > MANUALSTART) {
2001-09-01 11:44:08 +02:00
// Apparently the user started VDR manually
2002-05-13 16:35:49 +02:00
dsyslog("assuming manual start of VDR");
2001-09-01 11:44:08 +02:00
LastActivity = Now;
2001-09-07 15:37:26 +02:00
continue; // don't run into the actual shutdown procedure below
2001-09-01 11:44:08 +02:00
}
2001-09-07 15:37:26 +02:00
else
LastActivity = 1;
}
if (UserShutdown && Next && Delta <= Setup.MinEventTimeout * 60 && !ForceShutdown) {
char *buf;
2006-03-26 09:27:30 +02:00
asprintf(&buf, tr("Recording in %ld minutes, shut down anyway?"), Delta / 60);
if (Interface->Confirm(buf))
ForceShutdown = true;
else
UserShutdown = false;
free(buf);
}
2001-09-08 13:02:05 +02:00
if (!Next || Delta > Setup.MinEventTimeout * 60 || ForceShutdown) {
ForceShutdown = false;
2001-09-07 15:37:26 +02:00
if (timer)
dsyslog("next timer event at %s", *TimeToString(Next));
2001-09-01 11:44:08 +02:00
if (WatchdogTimeout > 0)
signal(SIGALRM, SIG_IGN);
if (Interface->Confirm(tr("Press any key to cancel shutdown"), UserShutdown ? 5 : SHUTDOWNWAIT, true)) {
cControl::Shutdown();
int Channel = timer ? timer->Channel()->Number() : 0;
const char *File = timer ? timer->File() : "";
if (timer)
Delta = Next - time(NULL); // compensates for Confirm() timeout
2001-09-01 11:44:08 +02:00
char *cmd;
asprintf(&cmd, "%s %ld %ld %d \"%s\" %d", Shutdown, Next, Delta, Channel, *strescape(File, "\"$"), UserShutdown);
2002-05-13 16:35:49 +02:00
isyslog("executing '%s'", cmd);
SystemExec(cmd);
free(cmd);
2006-03-19 13:32:27 +01:00
LastActivity = time(NULL) - Setup.MinUserInactivity * 60 + SHUTDOWNRETRY; // try again later
2001-09-01 11:44:08 +02:00
}
2006-03-19 13:32:27 +01:00
else {
LastActivity = Now;
if (WatchdogTimeout > 0) {
alarm(WatchdogTimeout);
if (signal(SIGALRM, Watchdog) == SIG_IGN)
signal(SIGALRM, SIG_IGN);
}
}
UserShutdown = false;
2001-09-01 11:44:08 +02:00
continue; // skip the rest of the housekeeping for now
2001-09-01 09:04:37 +02:00
}
}
// Disk housekeeping:
2001-02-11 14:53:44 +01:00
RemoveDeletedRecordings();
cSchedules::Cleanup();
// Plugins housekeeping:
PluginManager.Housekeeping();
2001-02-11 14:53:44 +01:00
}
}
}
if (Interrupted)
2002-05-13 16:35:49 +02:00
isyslog("caught signal %d", Interrupted);
Exit:
2005-01-30 14:23:01 +01:00
PluginManager.StopPlugins();
cRecordControls::Shutdown();
2002-06-22 10:11:59 +02:00
cCutter::Stop();
2000-04-30 10:22:13 +02:00
delete Menu;
cControl::Shutdown();
delete Interface;
2004-05-16 10:35:36 +02:00
cOsdProvider::Shutdown();
Remotes.Clear();
2002-11-03 11:53:58 +01:00
Audios.Clear();
2004-05-16 10:35:36 +02:00
Skins.Clear();
if (ExitCode != 2) {
Setup.CurrentChannel = cDevice::CurrentChannel();
Setup.CurrentVolume = cDevice::CurrentVolume();
Setup.Save();
}
cDevice::Shutdown();
PluginManager.Shutdown(true);
cSchedules::Cleanup(true);
ReportEpgBugFixStats();
2001-02-24 16:18:43 +01:00
if (WatchdogTimeout > 0)
2002-05-13 16:35:49 +02:00
dsyslog("max. latency time %d seconds", MaxLatencyTime);
isyslog("exiting");
if (SysLogLevel > 0)
closelog();
if (HasStdin)
tcsetattr(STDIN_FILENO, TCSANOW, &savedTm);
if (cThread::EmergencyExit()) {
2002-05-13 16:35:49 +02:00
esyslog("emergency exit!");
return 1;
}
return ExitCode;
2000-02-19 13:36:48 +01:00
}