Ticket #8262: 8262-v1.patch

libs/libmyth/mythcommandlineparser.cpp

@@ -2 +2 @@
 using namespace std;
 
 #include <QFile>
+#include <QSize>
 
 #include "mythcommandlineparser.h"
 #include "exitcodes.h"
@@ -10 +11 @@
 #include "mythverbose.h"
 #include "mythversion.h"
 
-MythCommandLineParser::MythCommandLineParser(int things_to_parse) :
+static bool parse_preview_info(
+    const QString &param,
+    long long     &previewFrameNumber,
+    long long     &previewSeconds,
+    QSize         &previewSize);
+
+MythCommandLineParser::MythCommandLineParser(uint64_t things_to_parse) :
     parseTypes(things_to_parse),
-    display(QString::null), geometry(QString::null),
+    display(), geometry(),
+    logfile(),
+    pidfile(),
+    infile(),
+    outfile(),
+    newverbose(),
+    username(),
+    printexpire(),
+    eventString(),
+    previewSize(0,0),
+    starttime(),
+    chanid(0),
+    previewFrameNumber(-2),
+    previewSeconds(-2),
+    daemonize(false),
+    printsched(false),
+    testsched(false),
+    setverbose(false),
+    resched(false),
+    nosched(false),
+    noupnp(false),
+    nojobqueue(false),
+    nohousekeeper(false),
+    noexpirer(false),
+    clearsettingscache(false),
+    wantupnprebuild(false),
+
     wantsToExit(false)
 {
 }
@@ -95 +128 @@
         }
         return true;
     }
+    else if ((parseTypes & kCLPSetVerbose) &&
+             !strcmp(argv[argpos],"--setverbose"))
+    {
+        setverbose = true;
+        if ((argc - 1) > argpos)
+        {
+            newverbose = argv[argpos+1];
+            ++argpos;
+        }
+        else
+        {
+            cerr << "Missing argument to --setverbose option\n";
+            return BACKEND_EXIT_INVALID_CMDLINE;
+        }
+    }
     else if ((parseTypes & kCLPHelp) &&
              (!strcmp(argv[argpos],"-h") ||
               !strcmp(argv[argpos],"--help") ||
@@ -154 +202 @@
         settingsOverride["RunFrontendInWindow"] = "0";
         return true;
     }
+    else if ((parseTypes & kCLPDaemon) &&
+             (!strcmp(argv[argpos],"-d") ||
+              !strcmp(argv[argpos],"--daemon")))
+    {
+        daemonize = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPPrintSchedule) &&
+             !strcmp(argv[argpos],"--printsched"))
+    {
+        printsched = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPTestSchedule) &&
+             !strcmp(argv[argpos],"--testsched"))
+    {
+        testsched = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPReschedule) &&
+             !strcmp(argv[argpos],"--resched"))
+    {
+        resched = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPNoSchedule) &&
+             !strcmp(argv[argpos],"--nosched"))
+    {
+        nosched = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPNoUPnP) &&
+             !strcmp(argv[argpos],"--noupnp"))
+    {
+        noupnp = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPUPnPRebuild) &&
+             !strcmp(argv[argpos],"--upnprebuild"))
+    {
+        wantupnprebuild = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPNoJobqueue) &&
+             !strcmp(argv[argpos],"--nojobqueue"))
+    {
+        nojobqueue = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPNoHousekeeper) &&
+             !strcmp(argv[argpos],"--nohousekeeper"))
+    {
+        nohousekeeper = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPNoAutoExpire) &&
+             !strcmp(argv[argpos],"--noautoexpire"))
+    {
+        noexpirer = true;
+        return true;
+    }
+    else if ((parseTypes && kCLPClearCache) &&
+             !strcmp(argv[argpos],"--clearcache"))
+    {
+        clearsettingscache = true;
+        return true;
+    }
     else if ((parseTypes & kCLPOverrideSettingsFile) &&
              (!strcmp(argv[argpos],"--override-settings-file")))
     {
@@ -252 +367 @@
             QString tmpArg = argv[argpos+1];
             if (tmpArg.startsWith("-"))
             {
-                cerr << "Invalid or missing argument to "
+                cerr << "Invalid argument to "
                      << "-G/--get-setting option\n";
                 err = true;
                 return true;
@@ -262 +377 @@
         }
         else
         {
-            cerr << "Invalid or missing argument to "
+            cerr << "Missing argument to "
                  << "-G/--get-setting option\n";
             err = true;
             return true;
@@ -271 +386 @@
         ++argpos;
         return true;
     }
+    else if ((parseTypes & kCLPLogFile) &&
+             (!strcmp(argv[argpos],"-l") ||
+              !strcmp(argv[argpos],"--logfile")))
+    {
+        if ((argc - 1) > argpos)
+        {
+            logfile = argv[argpos+1];
+            if (logfile.startsWith("-"))
+            {
+                cerr << "Invalid argument to -l/--logfile option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to -l/--logfile option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPPidFile) &&
+             (!strcmp(argv[argpos],"-p") ||
+              !strcmp(argv[argpos],"--pidfile")))
+    {
+        if ((argc - 1) > argpos)
+        {
+            pidfile = argv[argpos+1];
+            if (pidfile.startsWith("-"))
+            {
+                cerr << "Invalid argument to -p/--pidfile option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to -p/--pidfile option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPInFile) &&
+             !strcmp(argv[argpos],"--infile"))
+    {
+        if ((argc - 1) > argpos)
+        {
+            infile = argv[argpos+1];
+            if (infile.startsWith("-"))
+            {
+                cerr << "Invalid argument to --infile option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to --infile option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPOutFile) &&
+             !strcmp(argv[argpos],"--outfile"))
+    {
+        if ((argc - 1) > argpos)
+        {
+            outfile = argv[argpos+1];
+            if (outfile.startsWith("-"))
+            {
+                cerr << "Invalid argument to --outfile option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to --outfile option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPUsername) &&
+             !strcmp(argv[argpos],"--user"))
+    {
+        if ((argc - 1) > argpos)
+        {
+            username = argv[argpos+1];
+            if (username.startsWith("-"))
+            {
+                cerr << "Invalid argument to --user option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to --user option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPEvent) &&
+             (!strcmp(argv[argpos],"--event")))
+    {
+        if ((argc - 1) > argpos)
+        {
+            eventString = argv[argpos+1];
+            if (eventString.startsWith("-"))
+            {
+                cerr << "Invalid argument to --event option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to --event option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPSystemEvent) &&
+             (!strcmp(argv[argpos],"--systemevent")))
+    {
+        if ((argc - 1) > argpos)
+        {
+            eventString = argv[argpos+1];
+            if (eventString.startsWith("-"))
+            {
+                cerr << "Invalid argument to --systemevent option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to --systemevent option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPChannelId) &&
+             (!strcmp(argv[argpos],"-c") ||
+              !strcmp(argv[argpos],"--chanid")))
+    {
+        if ((argc - 1) > argpos)
+        {
+            chanid = QString(argv[argpos+1]).toUInt();
+            if (!chanid)
+            {
+                cerr << "Invalid argument to -c/--chanid option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to -c/--chanid option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPStartTime) &&
+             (!strcmp(argv[argpos],"-s") ||
+              !strcmp(argv[argpos],"--starttime")))
+    {
+        if ((argc - 1) > argpos)
+        {
+            QString tmp = argv[argpos+1];
+            starttime = QDateTime::fromString(tmp, Qt::ISODate);
+            if (!starttime.isValid())
+            {
+                cerr << "Invalid argument to -s/--starttime option\n";
+                err = true;
+                return true;
+            }
+        }
+        else
+        {
+            cerr << "Missing argument to -s/--starttime option\n";
+            err = true;
+            return true;
+        }
+
+        ++argpos;
+        return true;
+    }
+    else if ((parseTypes & kCLPPrintExpire) &&
+             (!strcmp(argv[argpos],"--printexpire")))
+    {
+        printexpire = "ALL";
+        if (((argc - 1) > argpos) &&
+            QString(argv[argpos+1]).startsWith("-"))
+        {
+            printexpire = argv[argpos+1];
+            ++argpos;
+        }
+        return true;
+    }
+    else if ((parseTypes & kCLPGeneratePreview) &&
+             !strcmp(argv[argpos],"--generate-preview"))
+    {
+        QString tmp;
+        if ((argc - 1) < argpos)
+        {
+            tmp = argv[argpos+1];
+            bool ok = true;
+            if (tmp.left(1) == "-")
+                tmp.left(2).toInt(&ok);
+            if (ok)
+                argpos++;
+            else
+                tmp.clear();
+        }
+
+        if (!parse_preview_info(tmp, previewFrameNumber, previewSeconds,
+                                previewSize))
+        {
+            cerr << "Unable to parse --generate-preview option '"
+                 << tmp.toAscii().constData() << "'" << endl;
+
+            err = true;
+        }
+
+        return true;
+    }
     else
     {
         return PreParse(argc, argv, argpos, err);
@@ -349 +715 @@
 
     return str;
 }
+
+// [WxH] | [WxH@]seconds[S] | [WxH@]frame_numF
+static bool parse_preview_info(
+    const QString &param,
+    long long     &previewFrameNumber,
+    long long     &previewSeconds,
+    QSize         &previewSize)
+{
+    previewFrameNumber = -1;
+    previewSeconds = -1;
+    previewSize = QSize(0,0);
+    if (param.isEmpty())
+        return true;
+
+    int xat = param.indexOf("x", 0, Qt::CaseInsensitive);
+    int aat = param.indexOf("@", 0);
+    if (xat > 0)
+    {
+        QString widthStr  = param.left(xat);
+        QString heightStr;
+        if (aat > xat)
+            heightStr = param.mid(xat + 1, aat - xat - 1);
+        else
+            heightStr = param.mid(xat + 1);
+
+        bool ok1, ok2;
+        previewSize = QSize(widthStr.toInt(&ok1), heightStr.toInt(&ok2));
+        if (!ok1 || !ok2)
+        {
+            VERBOSE(VB_IMPORTANT, QString(
+                        "Error: Failed to parse --generate-preview "
+                        "param '%1'").arg(param));
+        }
+    }
+    if ((xat > 0) && (aat < xat))
+        return true;
+
+    QString lastChar = param.at(param.length() - 1).toLower();
+    QString frameNumStr;
+    QString secsStr;
+    if (lastChar == "f")
+        frameNumStr = param.mid(aat + 1, param.length() - aat - 2);
+    else if (lastChar == "s")
+        secsStr = param.mid(aat + 1, param.length() - aat - 2);
+    else
+        secsStr = param.mid(aat + 1, param.length() - aat - 1);
+
+    bool ok = false;
+    if (!frameNumStr.isEmpty())
+        previewFrameNumber = frameNumStr.toUInt(&ok);
+    else if (!secsStr.isEmpty())
+        previewSeconds = secsStr.toUInt(&ok);
+
+    if (!ok)
+    {
+        VERBOSE(VB_IMPORTANT, QString(
+                    "Error: Failed to parse --generate-preview "
+                    "param '%1'").arg(param));
+    }
+
+    return ok;
+}

libs/libmyth/mythcommandlineparser.h

@@ -1 +1 @@
 // -*- Mode: c++ -*-
 
 #include <QStringList>
+#include <QDateTime>
+#include <QSize>
 #include <QMap>
 
 #include <stdint.h>   // for uint64_t
@@ -8 +10 @@
 #include "mythexp.h"
 
 typedef enum {
-    kCLPOverrideSettingsFile = 0x00000001,
-    kCLPOverrideSettings     = 0x00000002,
-    kCLPWindowed             = 0x00000004,
-    kCLPNoWindowed           = 0x00000008,
-    kCLPGetSettings          = 0x00000010,
-    kCLPQueryVersion         = 0x00000020,
-    kCLPDisplay              = 0x00000040,
-    kCLPGeometry             = 0x00000080,
-    kCLPVerbose              = 0x00000100,
-    kCLPHelp                 = 0x00000200,
-    kCLPExtra                = 0x00000400,
+    kCLPOverrideSettingsFile = 0x0000000001ULL,
+    kCLPOverrideSettings     = 0x0000000002ULL,
+    kCLPWindowed             = 0x0000000004ULL,
+    kCLPNoWindowed           = 0x0000000008ULL,
+    kCLPGetSettings          = 0x0000000010ULL,
+    kCLPQueryVersion         = 0x0000000020ULL,
+    kCLPDisplay              = 0x0000000040ULL,
+    kCLPGeometry             = 0x0000000080ULL,
+    kCLPVerbose              = 0x0000000100ULL,
+    kCLPSetVerbose           = 0x0000000200ULL,
+    kCLPHelp                 = 0x0000000400ULL,
+    kCLPExtra                = 0x0000000800ULL,
+    kCLPDaemon               = 0x0000001000ULL,
+    kCLPPrintSchedule        = 0x0000002000ULL,
+    kCLPTestSchedule         = 0x0000004000ULL,
+    kCLPReschedule           = 0x0000008000ULL,
+    kCLPNoSchedule           = 0x0000010000ULL,
+    kCLPNoUPnP               = 0x0000020000ULL,
+    kCLPUPnPRebuild          = 0x0000040000ULL,
+    kCLPNoJobqueue           = 0x0000080000ULL,
+    kCLPNoHousekeeper        = 0x0000100000ULL,
+    kCLPNoAutoExpire         = 0x0000200000ULL,
+    kCLPClearCache           = 0x0000400000ULL,
+    kCLPLogFile              = 0x0000800000ULL,
+    kCLPPidFile              = 0x0001000000ULL,
+    kCLPInFile               = 0x0002000000ULL,
+    kCLPOutFile              = 0x0004000000ULL,
+    kCLPUsername             = 0x0008000000ULL,
+    kCLPEvent                = 0x0010000000ULL,
+    kCLPSystemEvent          = 0x0020000000ULL,
+    kCLPChannelId            = 0x0040000000ULL,
+    kCLPStartTime            = 0x0080000000ULL,
+    kCLPPrintExpire          = 0x0100000000ULL,
+    kCLPGeneratePreview      = 0x0200000000ULL,
 } ParseType;
 
 class MPUBLIC MythCommandLineParser
 {
   public:
-    MythCommandLineParser(int things_to_parse);
+    MythCommandLineParser(uint64_t things_to_parse);
 
     bool PreParse(int argc, const char * const * argv, int &argpos, bool &err);
     bool Parse(int argc, const char * const * argv, int &argpos, bool &err);
@@ -34 +59 @@
         { return settingsOverride; }
     QStringList GetSettingsQuery(void) const
         { return settingsQuery; }
-    QString GetDisplay(void)  const { return display;     }
-    QString GetGeometry(void) const { return geometry;    }
+    QString GetDisplay(void)        const { return display;     }
+    QString GetGeometry(void)       const { return geometry;    }
+    QString GetLogFilename(void)    const { return logfile;     }
+    QString GetPIDFilename(void)    const { return pidfile;     }
+    QString GetInputFilename(void)  const { return infile;      }
+    QString GetOutputFilename(void) const { return outfile;     }
+    QString GetNewVerbose(void)     const { return newverbose;  }
+    QString GetUsername(void)       const { return username;    }
+    QString GetPrintExpire(void)    const { return printexpire; }
+    QString GetEventString(void)    const { return eventString; }
 
+    QSize     GetPreviewSize(void)        const { return previewSize; }
+    QDateTime GetStartTime(void)          const { return starttime;   }
+    uint      GetChanID(void)             const { return chanid;      }
+    long long GetPreviewFrameNumber(void) const { return  previewFrameNumber; }
+    long long GetPreviewSeconds(void)     const { return previewSeconds; }
+
+    bool IsDaemonizeEnabled(void)   const { return daemonize;   }
+    bool IsPrintScheduleEnabled(void) const { return printsched;  }
+    bool IsTestSchedulerEnabled(void) const { return testsched;   }
+    bool IsSchedulerEnabled(void)   const { return !nosched;    }
+    bool IsUPnPEnabled(void)        const { return !noupnp;     }
+    bool IsJobQueueEnabled(void)    const { return !nojobqueue; }
+    bool IsHouseKeeperEnabled(void) const { return !nohousekeeper; }
+    bool IsAutoExpirerEnabled(void) const { return !noexpirer;  }
+
+    bool SetVerbose(void)           const { return setverbose;  }
+    bool Reschedule(void)           const { return resched;     }
+    bool ClearSettingsCache(void)   const { return clearsettingscache; }
+    bool WantUPnPRebuild(void)      const { return wantupnprebuild; }
+
+    bool    HasInvalidPreviewGenerationParams(void) const
+    {
+        return ((previewFrameNumber >= -1) || previewSeconds >= -1) &&
+            (!chanid || !starttime.isValid()) && infile.isEmpty();
+    }
+
+    bool    HasBackendCommand(void) const
+    {
+        return 
+            !eventString.isEmpty()    || wantupnprebuild       ||
+            setverbose                || clearsettingscache    ||
+            printsched                || testsched             ||
+            resched                   || !printexpire.isEmpty() ||
+            (previewFrameNumber >= -1) || (previewSeconds >= -1);
+    }
+
     bool    WantsToExit(void) const { return wantsToExit; }
 
   private:
-    int                   parseTypes;
+    uint64_t              parseTypes;
 
     QMap<QString,QString> settingsOverride;
     QStringList           settingsQuery;
+
     QString               display;
     QString               geometry;
+    QString               logfile;
+    QString               pidfile;
+    QString               infile;
+    QString               outfile;
+    QString               newverbose;
+    QString               username;
+    QString               printexpire;
+    QString               eventString;
 
+    QSize                 previewSize;
+    QDateTime             starttime;
+
+    uint                  chanid;
+    long long             previewFrameNumber;
+    long long             previewSeconds;
+
+    bool                  daemonize;
+    bool                  printsched;
+    bool                  testsched;
+    bool                  setverbose;
+    bool                  resched;
+    bool                  nosched;
+    bool                  noupnp;
+    bool                  nojobqueue;
+    bool                  nohousekeeper;
+    bool                  noexpirer;
+    bool                  clearsettingscache;
+    bool                  wantupnprebuild;
     bool                  wantsToExit;
 };

libs/libmyth/mythcontext.cpp

@@ -82 +82 @@
     void LoadLogSettings(void);
     void LoadDatabaseSettings(void);
 
-    bool LoadSettingsFile(void);
-    bool WriteSettingsFile(const DatabaseParams &params,
-                           bool overwrite = false);
-    bool FindSettingsProbs(void);
-
     bool    PromptForDatabaseParams(const QString &error);
     QString TestDBconnection(void);
     void    SilenceDBerrors(void);
@@ -514 +509 @@
  */
 void MythContextPrivate::LoadDatabaseSettings(void)
 {
-    if (!LoadSettingsFile())
-    {
-        VERBOSE(VB_IMPORTANT, "Unable to read configuration file mysql.txt");
+    m_database->LoadDatabaseParamsFromDisk(m_DBparams, true);
+    m_database->SetDatabaseParams(m_DBparams);
 
-        // Sensible connection defaults.
-        m_DBparams.dbHostName    = "localhost";
-        m_DBparams.dbHostPing    = true;
-        m_DBparams.dbPort        = 0;
-        m_DBparams.dbUserName    = "mythtv";
-        m_DBparams.dbPassword    = "mythtv";
-        m_DBparams.dbName        = "mythconverg";
-        m_DBparams.dbType        = "QMYSQL3";
-        m_DBparams.localEnabled  = false;
-        m_DBparams.localHostName = "my-unique-identifier-goes-here";
-        m_DBparams.wolEnabled    = false;
-        m_DBparams.wolReconnect  = 0;
-        m_DBparams.wolRetry      = 5;
-        m_DBparams.wolCommand    = "echo 'WOLsqlServerCommand not set'";
-        m_database->SetDatabaseParams(m_DBparams);
-    }
-
-    // Even if we have loaded the settings file, it may be incomplete,
-    // so we check for missing values and warn user
-    FindSettingsProbs();
-
     m_localhostname = m_DBparams.localHostName;
     if (m_localhostname.isEmpty() ||
         m_localhostname == "my-unique-identifier-goes-here")
@@ -559 +532 @@
     m_database->SetLocalHostname(m_localhostname);
 }
 
-/**
- * Load mysql.txt and parse its values into m_DBparams
- */
-bool MythContextPrivate::LoadSettingsFile(void)
-{
-    Settings *oldsettings = m_database->GetOldSettings();
-
-    if (!oldsettings->LoadSettingsFiles("mysql.txt", GetInstallPrefix(),
-                                        GetConfDir()))
-        return false;
-
-    m_DBparams.dbHostName = oldsettings->GetSetting("DBHostName");
-    m_DBparams.dbHostPing = oldsettings->GetSetting("DBHostPing") != "no";
-    m_DBparams.dbPort     = oldsettings->GetNumSetting("DBPort");
-    m_DBparams.dbUserName = oldsettings->GetSetting("DBUserName");
-    m_DBparams.dbPassword = oldsettings->GetSetting("DBPassword");
-    m_DBparams.dbName     = oldsettings->GetSetting("DBName");
-    m_DBparams.dbType     = oldsettings->GetSetting("DBType");
-
-    m_DBparams.localHostName = oldsettings->GetSetting("LocalHostName");
-    m_DBparams.localEnabled  = m_DBparams.localHostName.length() > 0;
-
-    m_DBparams.wolReconnect
-        = oldsettings->GetNumSetting("WOLsqlReconnectWaitTime");
-    m_DBparams.wolEnabled = m_DBparams.wolReconnect > 0;
-
-    m_DBparams.wolRetry   = oldsettings->GetNumSetting("WOLsqlConnectRetry");
-    m_DBparams.wolCommand = oldsettings->GetSetting("WOLsqlCommand");
-    m_database->SetDatabaseParams(m_DBparams);
-
-    return true;
-}
-
-bool MythContextPrivate::WriteSettingsFile(const DatabaseParams &params,
-                                           bool overwrite)
-{
-    QString path = GetConfDir() + "/mysql.txt";
-    QFile   * f  = new QFile(path);
-
-    if (!overwrite && f->exists())
-    {
-        return false;
-    }
-
-    QString dirpath = GetConfDir();
-    QDir createDir(dirpath);
-
-    if (!createDir.exists())
-    {
-        if (!createDir.mkdir(dirpath))
-        {
-            VERBOSE(VB_IMPORTANT, QString("Could not create %1").arg(dirpath));
-            return false;
-        }
-    }
-
-    if (!f->open(QIODevice::WriteOnly))
-    {
-        VERBOSE(VB_IMPORTANT, QString("Could not open settings file %1 "
-                                      "for writing").arg(path));
-        return false;
-    }
-
-    VERBOSE(VB_IMPORTANT, QString("Writing settings file %1").arg(path));
-    QTextStream s(f);
-    s << "DBHostName=" << params.dbHostName << endl;
-
-    s << "\n"
-      << "# By default, Myth tries to ping the DB host to see if it exists.\n"
-      << "# If your DB host or network doesn't accept pings, set this to no:\n"
-      << "#\n";
-
-    if (params.dbHostPing)
-        s << "#DBHostPing=no" << endl << endl;
-    else
-        s << "DBHostPing=no" << endl << endl;
-
-    if (params.dbPort)
-        s << "DBPort=" << params.dbPort << endl;
-
-    s << "DBUserName=" << params.dbUserName << endl
-      << "DBPassword=" << params.dbPassword << endl
-      << "DBName="     << params.dbName     << endl
-      << "DBType="     << params.dbType     << endl
-      << endl
-      << "# Set the following if you want to use something other than this\n"
-      << "# machine's real hostname for identifying settings in the database.\n"
-      << "# This is useful if your hostname changes often, as otherwise you\n"
-      << "# will need to reconfigure mythtv every time.\n"
-      << "# NO TWO HOSTS MAY USE THE SAME VALUE\n"
-      << "#\n";
-
-    if (params.localEnabled)
-        s << "LocalHostName=" << params.localHostName << endl;
-    else
-        s << "#LocalHostName=my-unique-identifier-goes-here\n";
-
-    s << endl
-      << "# If you want your frontend to be able to wake your MySQL server\n"
-      << "# using WakeOnLan, have a look at the following settings:\n"
-      << "#\n"
-      << "#\n"
-      << "# The time the frontend waits (in seconds) between reconnect tries.\n"
-      << "# This should be the rough time your MySQL server needs for startup\n"
-      << "#\n";
-
-    if (params.wolEnabled)
-        s << "WOLsqlReconnectWaitTime=" << params.wolReconnect << endl;
-    else
-        s << "#WOLsqlReconnectWaitTime=0\n";
-
-    s << "#\n"
-      << "#\n"
-      << "# This is the number of retries to wake the MySQL server\n"
-      << "# until the frontend gives up\n"
-      << "#\n";
-
-    if (params.wolEnabled)
-        s << "WOLsqlConnectRetry=" << params.wolRetry << endl;
-    else
-        s << "#WOLsqlConnectRetry=5\n";
-
-    s << "#\n"
-      << "#\n"
-      << "# This is the command executed to wake your MySQL server.\n"
-      << "#\n";
-
-    if (params.wolEnabled)
-        s << "WOLsqlCommand=" << params.wolCommand << endl;
-    else
-        s << "#WOLsqlCommand=echo 'WOLsqlServerCommand not set'\n";
-
-    f->close();
-    return true;
-}
-
-bool MythContextPrivate::FindSettingsProbs(void)
-{
-    bool problems = false;
-
-    if (m_DBparams.dbHostName.isEmpty())
-    {
-        problems = true;
-        VERBOSE(VB_IMPORTANT, "DBHostName is not set in mysql.txt");
-        VERBOSE(VB_IMPORTANT, "Assuming localhost");
-        m_DBparams.dbHostName = "localhost";
-    }
-    if (m_DBparams.dbUserName.isEmpty())
-    {
-        problems = true;
-        VERBOSE(VB_IMPORTANT, "DBUserName is not set in mysql.txt");
-    }
-    if (m_DBparams.dbPassword.isEmpty())
-    {
-        problems = true;
-        VERBOSE(VB_IMPORTANT, "DBPassword is not set in mysql.txt");
-    }
-    if (m_DBparams.dbName.isEmpty())
-    {
-        problems = true;
-        VERBOSE(VB_IMPORTANT, "DBName is not set in mysql.txt");
-    }
-    m_database->SetDatabaseParams(m_DBparams);
-    return problems;
-}
-
 bool MythContextPrivate::PromptForDatabaseParams(const QString &error)
 {
     bool accepted = false;
@@ -1039 +846 @@
     switch (selected)
     {
         case kDialogCodeButton0:
-            WriteSettingsFile(m_DBparams, true);
+            MythDB::SaveDatabaseParamsToDisk(m_DBparams, GetConfDir(), true);
             // User prefers mysql.txt, so throw away default UPnP backend:
             m_XML->SetValue(kDefaultUSN, "");
             m_XML->Save();
@@ -2413 +2220 @@
           params.wolRetry      != cur_params.wolRetry     ||
           params.wolCommand    != cur_params.wolCommand)))
     {
-        ret = d->WriteSettingsFile(params, true);
+        ret = MythDB::SaveDatabaseParamsToDisk(params, GetConfDir(), true);
         if (ret)
         {
             // Save the new settings:

libs/libmythupnp/upnp.h

@@ -125 +125 @@
                  UPnp();
         virtual ~UPnp();
 
-        void SetConfiguration( Configuration *pConfig );
+        static void SetConfiguration( Configuration *pConfig );
 
         bool Initialize( int nServicePort, HttpServer *pHttpServer );
         bool Initialize( QStringList &sIPAddrList, int nServicePort, HttpServer *pHttpServer );

libs/libmythdb/mythdb.cpp

@@ -1 +1 @@
 #include <vector>
 using namespace std;
 
+#include <QReadWriteLock>
+#include <QSqlError>
 #include <QMutex>
-#include <QReadWriteLock>
+#include <QFile>
 #include <QHash>
-#include <QSqlError>
+#include <QDir>
 
 #include "mythdb.h"
 #include "mythdbcon.h"
 #include "mythverbose.h"
 #include "oldsettings.h"
+#include "mythdirs.h"
 
 static MythDB *mythdb = NULL;
 static QMutex dbLock;
@@ -822 +825 @@
     d->useSettingsCache = activate;
     ClearSettingsCache();
 }
+
+bool MythDB::LoadDatabaseParamsFromDisk(
+    DatabaseParams &params, bool sanitize)
+{
+    Settings settings;
+    if (settings.LoadSettingsFiles(
+            "mysql.txt", GetInstallPrefix(), GetConfDir()))
+    {
+        params.dbHostName = settings.GetSetting("DBHostName");
+        params.dbHostPing = settings.GetSetting("DBHostPing") != "no";
+        params.dbPort     = settings.GetNumSetting("DBPort");
+        params.dbUserName = settings.GetSetting("DBUserName");
+        params.dbPassword = settings.GetSetting("DBPassword");
+        params.dbName     = settings.GetSetting("DBName");
+        params.dbType     = settings.GetSetting("DBType");
+
+        params.localHostName = settings.GetSetting("LocalHostName");
+        params.localEnabled  = !params.localHostName.isEmpty();
+
+        params.wolReconnect  =
+            settings.GetNumSetting("WOLsqlReconnectWaitTime");
+        params.wolEnabled = params.wolReconnect > 0;
+
+        params.wolRetry   = settings.GetNumSetting("WOLsqlConnectRetry");
+        params.wolCommand = settings.GetSetting("WOLsqlCommand");
+    }
+    else if (sanitize)
+    {
+        VERBOSE(VB_IMPORTANT, "Unable to read configuration file mysql.txt");
+
+        // Sensible connection defaults.
+        params.dbHostName    = "localhost";
+        params.dbHostPing    = true;
+        params.dbPort        = 0;
+        params.dbUserName    = "mythtv";
+        params.dbPassword    = "mythtv";
+        params.dbName        = "mythconverg";
+        params.dbType        = "QMYSQL3";
+        params.localEnabled  = false;
+        params.localHostName = "my-unique-identifier-goes-here";
+        params.wolEnabled    = false;
+        params.wolReconnect  = 0;
+        params.wolRetry      = 5;
+        params.wolCommand    = "echo 'WOLsqlServerCommand not set'";
+    }
+    else
+    {
+        return false;
+    }
+
+    // Print some warnings if things look fishy..
+
+    if (params.dbHostName.isEmpty())
+    {
+        VERBOSE(VB_IMPORTANT, "DBHostName is not set in mysql.txt");
+        VERBOSE(VB_IMPORTANT, "Assuming localhost");
+    }
+    if (params.dbUserName.isEmpty())
+        VERBOSE(VB_IMPORTANT, "DBUserName is not set in mysql.txt");
+    if (params.dbPassword.isEmpty())
+        VERBOSE(VB_IMPORTANT, "DBPassword is not set in mysql.txt");
+    if (params.dbName.isEmpty())
+        VERBOSE(VB_IMPORTANT, "DBName is not set in mysql.txt");
+
+    // If sanitize set, replace empty dbHostName with "localhost"
+    if (sanitize && params.dbHostName.isEmpty())
+        params.dbHostName = "localhost";
+
+    return true;
+}
+
+bool MythDB::SaveDatabaseParamsToDisk(
+    const DatabaseParams &params, const QString &confdir, bool overwrite)
+{
+    QString path = confdir + "/mysql.txt";
+    QFile   * f  = new QFile(path);
+
+    if (!overwrite && f->exists())
+    {
+        return false;
+    }
+
+    QString dirpath = confdir;
+    QDir createDir(dirpath);
+
+    if (!createDir.exists())
+    {
+        if (!createDir.mkdir(dirpath))
+        {
+            VERBOSE(VB_IMPORTANT, QString("Could not create %1").arg(dirpath));
+            return false;
+        }
+    }
+
+    if (!f->open(QIODevice::WriteOnly))
+    {
+        VERBOSE(VB_IMPORTANT, QString("Could not open settings file %1 "
+                                      "for writing").arg(path));
+        return false;
+    }
+
+    VERBOSE(VB_IMPORTANT, QString("Writing settings file %1").arg(path));
+    QTextStream s(f);
+    s << "DBHostName=" << params.dbHostName << endl;
+
+    s << "\n"
+      << "# By default, Myth tries to ping the DB host to see if it exists.\n"
+      << "# If your DB host or network doesn't accept pings, set this to no:\n"
+      << "#\n";
+
+    if (params.dbHostPing)
+        s << "#DBHostPing=no" << endl << endl;
+    else
+        s << "DBHostPing=no" << endl << endl;
+
+    if (params.dbPort)
+        s << "DBPort=" << params.dbPort << endl;
+
+    s << "DBUserName=" << params.dbUserName << endl
+      << "DBPassword=" << params.dbPassword << endl
+      << "DBName="     << params.dbName     << endl
+      << "DBType="     << params.dbType     << endl
+      << endl
+      << "# Set the following if you want to use something other than this\n"
+      << "# machine's real hostname for identifying settings in the database.\n"
+      << "# This is useful if your hostname changes often, as otherwise you\n"
+      << "# will need to reconfigure mythtv every time.\n"
+      << "# NO TWO HOSTS MAY USE THE SAME VALUE\n"
+      << "#\n";
+
+    if (params.localEnabled)
+        s << "LocalHostName=" << params.localHostName << endl;
+    else
+        s << "#LocalHostName=my-unique-identifier-goes-here\n";
+
+    s << endl
+      << "# If you want your frontend to be able to wake your MySQL server\n"
+      << "# using WakeOnLan, have a look at the following settings:\n"
+      << "#\n"
+      << "#\n"
+      << "# The time the frontend waits (in seconds) between reconnect tries.\n"
+      << "# This should be the rough time your MySQL server needs for startup\n"
+      << "#\n";
+
+    if (params.wolEnabled)
+        s << "WOLsqlReconnectWaitTime=" << params.wolReconnect << endl;
+    else
+        s << "#WOLsqlReconnectWaitTime=0\n";
+
+    s << "#\n"
+      << "#\n"
+      << "# This is the number of retries to wake the MySQL server\n"
+      << "# until the frontend gives up\n"
+      << "#\n";
+
+    if (params.wolEnabled)
+        s << "WOLsqlConnectRetry=" << params.wolRetry << endl;
+    else
+        s << "#WOLsqlConnectRetry=5\n";
+
+    s << "#\n"
+      << "#\n"
+      << "# This is the command executed to wake your MySQL server.\n"
+      << "#\n";
+
+    if (params.wolEnabled)
+        s << "WOLsqlCommand=" << params.wolCommand << endl;
+    else
+        s << "#WOLsqlCommand=echo 'WOLsqlServerCommand not set'\n";
+
+    f->close();
+    return true;
+}

libs/libmythdb/mythdb.h

@@ -75 +75 @@
     static void destroyMythDB();
     static QString toCommaList(const QMap<QString, QVariant> &bindings,
                                uint indent = 0, uint softMaxColumn = 80);
+
+    static bool LoadDatabaseParamsFromDisk(
+        DatabaseParams &params, bool sanitize);
+    static bool SaveDatabaseParamsToDisk(
+        const DatabaseParams &params, const QString &confdir, bool overwrite);
+
   protected:
     MythDB();
    ~MythDB();

programs/mythbackend/backendcontext.h

@@ +1 @@
+#include <QString>
+#include <QMap>
+
+class EncoderLink;
+class AutoExpire;
+class Scheduler;
+class JobQueue;
+class HouseKeeper;
+class MediaServer;
+
+extern QMap<int, EncoderLink *> tvList;
+extern AutoExpire  *expirer;
+extern Scheduler   *sched;
+extern JobQueue    *jobqueue;
+extern HouseKeeper *housekeeping;
+extern MediaServer *g_pUPnp;
+extern QString      pidfile;
+extern QString      logfile;
+
+class BackendContext
+{
+    
+};

programs/mythbackend/mediaserver.cpp

@@ -9 +9 @@
 //////////////////////////////////////////////////////////////////////////////
 
 #include "mediaserver.h"
+#include "httpconfig.h"
 #include "mythxml.h"
 #include "mythdirs.h"
 
@@ -28 +29 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
-MediaServer::MediaServer( bool bIsMaster, bool bDisableUPnp /* = FALSE */ )
+MediaServer::MediaServer(void) :
+    m_pUPnpCDS(NULL), m_pUPnpCMGR(NULL), upnpMedia(NULL),
+    m_sSharePath(GetShareDir())
 {
-    VERBOSE(VB_UPNP, QString("MediaServer::Begin"));
+    VERBOSE(VB_UPNP, "MediaServer:ctor:Begin");
 
     // ----------------------------------------------------------------------
     // Initialize Configuration class (Database for Servers)
@@ -43 +46 @@
     // ----------------------------------------------------------------------
 
     int     nPort = g_pConfig->GetValue( "BackendStatusPort", 6544 );
-    QString sIP   = g_pConfig->GetValue( "BackendServerIP"  , ""   );
 
-    if (sIP.isEmpty())
-    {
-        VERBOSE(VB_IMPORTANT,
-                "MediaServer:: No BackendServerIP Address defined");
-        m_pHttpServer = NULL;
-        return;
-    }
-
-
     m_pHttpServer = new HttpServer();
 
     if (!m_pHttpServer->listen(QHostAddress::Any, nPort))
@@ -65 +58 @@
         return;
     }
 
-    m_sSharePath = GetShareDir();
     m_pHttpServer->m_sSharePath = m_sSharePath;
 
+    m_pHttpServer->RegisterExtension(new HttpConfig());
+
+    VERBOSE(VB_UPNP, "MediaServer:ctor:End");
+}
+
+void MediaServer::Init(bool bIsMaster, bool bDisableUPnp /* = FALSE */)
+{
+    VERBOSE(VB_UPNP, "MediaServer:Init:Begin");
+
+    int     nPort     = g_pConfig->GetValue( "BackendStatusPort", 6544 );
     QString sFileName = g_pConfig->GetValue( "upnpDescXmlPath",
                                                 m_sSharePath );
     QString sDeviceType;
@@ -100 +102 @@
 
     VERBOSE(VB_UPNP, "MediaServer::Registering MythXML Service." );
 
-    m_pHttpServer->RegisterExtension( new MythXML( pMythDevice , m_sSharePath));
+    if (m_pHttpServer)
+        m_pHttpServer->RegisterExtension(
+            new MythXML( pMythDevice , m_sSharePath));
 
+    QString sIP = g_pConfig->GetValue( "BackendServerIP"  , ""   );
+    if (sIP.isEmpty())
+    {
+        VERBOSE(VB_IMPORTANT,
+                "MediaServer:: No BackendServerIP Address defined - "
+                "Disabling UPnP");
+        return;
+    }
+
     if (sIP == "localhost" || sIP.startsWith("127."))
     {
         VERBOSE(VB_IMPORTANT, "MediaServer:: Loopback address specified - "
@@ -189 +202 @@
 
     }
 
-    VERBOSE(VB_UPNP, QString( "MediaServer::End" ));
+    VERBOSE(VB_UPNP, "MediaServer:Init:End");
 }
 
 //////////////////////////////////////////////////////////////////////////////

programs/mythbackend/mythsettings.h

@@ +1 @@
+// -*- Mode: c++ -*-
+
+#ifndef _MYTHSETTINGS_H_
+#define _MYTHSETTINGS_H_
+
+#include <QStringList>
+#include <QMap>
+
+class MythSettingBase
+{
+  public:
+    MythSettingBase() {}
+    virtual ~MythSettingBase() {}
+    virtual QString ToHTML(uint) const { return QString(); }
+};
+typedef QList<MythSettingBase*> MythSettingList;
+
+class MythSettingGroup : public MythSettingBase
+{
+  public:
+    MythSettingGroup(QString hlabel, QString ulabel,
+                     QString script = "") :
+        human_label(hlabel), unique_label(ulabel), ecma_script(script) {}
+
+    QString ToHTML(uint) const;
+
+  public:
+    QString human_label;
+    QString unique_label; ///< div name for stylesheets & javascript
+    MythSettingList settings;
+    QString ecma_script;
+};
+
+class MythSetting : public MythSettingBase
+{
+  public:
+    typedef enum {
+        kFile,
+        kHost,
+        kGlobal,
+        kInvalidSettingType,
+    } SettingType;
+
+    typedef enum {
+        kInteger,
+        kUnsignedInteger,
+        kIntegerRange,
+        kCheckBox,
+        kSelect,   ///< list where only data_list are valid
+        kComboBox, ///< list where user input is allowed
+        kTVFormat,
+        kFrequencyTable,
+        kFloat,
+        kIPAddress,
+        kLocalIPAddress,
+        kString,
+        kTimeOfDay,
+        kOther,
+        kInvalidDataType,
+    } DataType;
+
+    MythSetting(QString _value, QString _default_data, SettingType _stype,
+                QString _label, QString _help_text, DataType _dtype) :
+        value(_value), data(_default_data), default_data(_default_data),
+        stype(_stype), label(_label), help_text(_help_text), dtype(_dtype)
+    {
+    }
+
+    MythSetting(QString _value, QString _default_data, SettingType _stype,
+            QString _label, QString _help_text, DataType _dtype,
+            QStringList _data_list, QStringList _display_list) :
+        value(_value), data(_default_data), default_data(_default_data),
+        stype(_stype), label(_label), help_text(_help_text), dtype(_dtype),
+        data_list(_data_list), display_list(_display_list)
+    {
+    }
+
+    MythSetting(QString _value, QString _default_data, SettingType _stype,
+                QString _label, QString _help_text, DataType _dtype,
+                long long _range_min, long long _range_max) :
+        value(_value), data(_default_data), default_data(_default_data),
+        stype(_stype), label(_label), help_text(_help_text), dtype(_dtype),
+        range_min(_range_min), range_max(_range_max)
+    {
+    }
+
+    MythSetting(QString _value, QString _default_data, SettingType _stype,
+                QString _label, QString _help_text, DataType _dtype,
+                QStringList _data_list, QStringList _display_list,
+                long long _range_min, long long _range_max) :
+        value(_value), data(_default_data), default_data(_default_data),
+        stype(_stype), label(_label), help_text(_help_text), dtype(_dtype),
+        data_list(_data_list), display_list(_display_list),
+        range_min(_range_min), range_max(_range_max)
+    {
+    }
+
+    QString ToHTML(uint) const;
+
+  public:
+    QString value;
+    QString data;
+    QString default_data;
+    SettingType stype;
+    QString label;
+    QString help_text;
+    DataType dtype;
+    QStringList data_list;
+    QStringList display_list;
+    long long range_min;
+    long long range_max;
+};
+
+bool parse_settings(MythSettingList &settings, const QString &filename);
+bool load_settings(MythSettingList &settings, const QString &hostname);
+
+#endif

programs/mythbackend/moc_mainserver.cpp

@@ +1 @@
+/****************************************************************************
+** Meta object code from reading C++ file 'mainserver.h'
+**
+** Created: Sun Mar 28 11:53:36 2010
+**      by: The Qt Meta Object Compiler version 61 (Qt 4.5.2)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#include "mainserver.h"
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#error "The header file 'mainserver.h' doesn't include <QObject>."
+#elif Q_MOC_OUTPUT_REVISION != 61
+#error "This file was generated using the moc from 4.5.2. It"
+#error "cannot be used with the include files from this version of Qt."
+#error "(The moc has changed too much.)"
+#endif
+
+QT_BEGIN_MOC_NAMESPACE
+static const uint qt_meta_data_MainServer[] = {
+
+ // content:
+       2,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       4,   12, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+
+ // slots: signature, parameters, type, tag, flags
+      12,   11,   11,   11, 0x09,
+      31,   11,   11,   11, 0x09,
+      52,   11,   11,   11, 0x09,
+      71,   11,   11,   11, 0x08,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_MainServer[] = {
+    "MainServer\0\0reconnectTimeout()\0"
+    "deferredDeleteSlot()\0autoexpireUpdate()\0"
+    "newConnection(MythSocket*)\0"
+};
+
+const QMetaObject MainServer::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_MainServer,
+      qt_meta_data_MainServer, 0 }
+};
+
+const QMetaObject *MainServer::metaObject() const
+{
+    return &staticMetaObject;
+}
+
+void *MainServer::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_MainServer))
+        return static_cast<void*>(const_cast< MainServer*>(this));
+    if (!strcmp(_clname, "MythSocketCBs"))
+        return static_cast< MythSocketCBs*>(const_cast< MainServer*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int MainServer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QObject::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        switch (_id) {
+        case 0: reconnectTimeout(); break;
+        case 1: deferredDeleteSlot(); break;
+        case 2: autoexpireUpdate(); break;
+        case 3: newConnection((*reinterpret_cast< MythSocket*(*)>(_a[1]))); break;
+        default: ;
+        }
+        _id -= 4;
+    }
+    return _id;
+}
+QT_END_MOC_NAMESPACE

programs/mythbackend/httpconfig.h

@@ +1 @@
+// -*- Mode: c++ -*-
+
+#ifndef _HTTPCONFIG_H_
+#define _HTTPCONFIG_H_
+
+#include "httpserver.h"
+#include "mythsettings.h"
+
+class QTextStream;
+
+class HttpConfig : public HttpServerExtension
+{
+  public:
+    HttpConfig();
+    virtual ~HttpConfig();
+
+    bool ProcessRequest(HttpWorkerThread *pThread, HTTPRequest *pRequest);
+
+  private:
+    void PrintHeader(QTextStream&);
+    void PrintFooter(QTextStream&);
+
+    void ParseDatabaseSettings(void);
+    void ParseGeneralSettings(void);
+
+    bool LoadSettings(MythSettingList&, const QString &hostname);
+    void PrintSettings(QTextStream&, const MythSettingList&);
+
+    MythSettingList database_settings;
+    MythSettingList general_settings;
+};
+
+#endif

programs/mythbackend/main_helpers.h

@@ +1 @@
+// C++ headers
+#include <iostream>
+#include <fstream>
+using namespace std;
+
+class MythCommandLineParser;
+class QString;
+class QSize;
+
+bool setupTVs(bool ismaster, bool &error);
+bool setup_context(const MythCommandLineParser &cmdline);
+void cleanup(void);
+int log_rotate(int report_error);
+void log_rotate_handler(int);
+void upnp_rebuild(int);
+int preview_helper(const QString &chanid, const QString &starttime,
+                   long long previewFrameNumber, long long previewSeconds,
+                   const QSize &previewSize,
+                   const QString &infile, const QString &outfile);
+void showUsage(const MythCommandLineParser &cmdlineparser,
+               const QString &version);
+void setupLogfile(void);
+bool openPidfile(ofstream &pidfs, const QString &pidfilename);
+bool setUser(const QString &username);
+int handle_command(const MythCommandLineParser &cmdline);
+int connect_to_master(void);
+int setup_basics(const MythCommandLineParser &cmdline);
+void print_warnings(const MythCommandLineParser &cmdline);
+int run_backend(const MythCommandLineParser &cmdline);
+
+namespace
+{
+    class CleanupGuard
+    {
+      public:
+        typedef void (*CleanupFunc)();
+
+      public:
+        CleanupGuard(CleanupFunc cleanFunction) :
+            m_cleanFunction(cleanFunction) {}
+
+        ~CleanupGuard()
+        {
+            m_cleanFunction();
+        }
+
+      private:
+        CleanupFunc m_cleanFunction;
+    };
+}
+

programs/mythbackend/moc_scheduler.cpp

@@ +1 @@
+/****************************************************************************
+** Meta object code from reading C++ file 'scheduler.h'
+**
+** Created: Sun Mar 28 11:53:37 2010
+**      by: The Qt Meta Object Compiler version 61 (Qt 4.5.2)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#include "scheduler.h"
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#error "The header file 'scheduler.h' doesn't include <QObject>."
+#elif Q_MOC_OUTPUT_REVISION != 61
+#error "This file was generated using the moc from 4.5.2. It"
+#error "cannot be used with the include files from this version of Qt."
+#error "(The moc has changed too much.)"
+#endif
+
+QT_BEGIN_MOC_NAMESPACE
+static const uint qt_meta_data_Scheduler[] = {
+
+ // content:
+       2,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       0,    0, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_Scheduler[] = {
+    "Scheduler\0"
+};
+
+const QMetaObject Scheduler::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_Scheduler,
+      qt_meta_data_Scheduler, 0 }
+};
+
+const QMetaObject *Scheduler::metaObject() const
+{
+    return &staticMetaObject;
+}
+
+void *Scheduler::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_Scheduler))
+        return static_cast<void*>(const_cast< Scheduler*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int Scheduler::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QObject::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    return _id;
+}
+QT_END_MOC_NAMESPACE

programs/mythbackend/moc_autoexpire.cpp

@@ +1 @@
+/****************************************************************************
+** Meta object code from reading C++ file 'autoexpire.h'
+**
+** Created: Sun Mar 28 11:53:36 2010
+**      by: The Qt Meta Object Compiler version 61 (Qt 4.5.2)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#include "autoexpire.h"
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#error "The header file 'autoexpire.h' doesn't include <QObject>."
+#elif Q_MOC_OUTPUT_REVISION != 61
+#error "This file was generated using the moc from 4.5.2. It"
+#error "cannot be used with the include files from this version of Qt."
+#error "(The moc has changed too much.)"
+#endif
+
+QT_BEGIN_MOC_NAMESPACE
+static const uint qt_meta_data_AutoExpire[] = {
+
+ // content:
+       2,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       0,    0, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_AutoExpire[] = {
+    "AutoExpire\0"
+};
+
+const QMetaObject AutoExpire::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_AutoExpire,
+      qt_meta_data_AutoExpire, 0 }
+};
+
+const QMetaObject *AutoExpire::metaObject() const
+{
+    return &staticMetaObject;
+}
+
+void *AutoExpire::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_AutoExpire))
+        return static_cast<void*>(const_cast< AutoExpire*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int AutoExpire::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QObject::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    return _id;
+}
+QT_END_MOC_NAMESPACE

programs/mythbackend/main.cpp

@@ -1 @@
-// POSIX headers
-#include <sys/time.h>     // for setpriority
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <libgen.h>
-#include <signal.h>
-#include <pwd.h>
 
-#include "mythconfig.h"
-#if CONFIG_DARWIN
-    #include <sys/aio.h>    // O_SYNC
-#endif
 
-// C headers
-#include <cstdlib>
-#include <cerrno>
-
-// C++ headers
-#include <iostream>
-#include <fstream>
-using namespace std;
-
 #ifndef _WIN32
 #include <QCoreApplication>
 #else
@@ -56 +34 @@
 #include "previewgenerator.h"
 #include "mythcommandlineparser.h"
 #include "mythsystemevent.h"
+#include "main_helpers.h"
+#include "backendcontext.h"
 
 #include "mediaserver.h"
 #include "httpstatus.h"
@@ -71 +51 @@
     #define UNUSED_FILENO 3
 #endif
 
-QMap<int, EncoderLink *> tvList;
-AutoExpire  *expirer      = NULL;
-Scheduler   *sched        = NULL;
-JobQueue    *jobqueue     = NULL;
-QString      pidfile;
-HouseKeeper *housekeeping = NULL;
-QString      logfile;
+extern const char *myth_source_version;
+extern const char *myth_source_path;
 
-MediaServer *g_pUPnp      = NULL;
-
-bool setupTVs(bool ismaster, bool &error)
+class MediaServerThread : public QThread
 {
-    error = false;
-    QString localhostname = gContext->GetHostName();
-
-    MSqlQuery query(MSqlQuery::InitCon());
-
-    if (ismaster)
+  public:
+    void run(void)
     {
-        // Hack to make sure recorded.basename gets set if the user
-        // downgrades to a prior version and creates new entries
-        // without it.
-        if (!query.exec("UPDATE recorded SET basename = CONCAT(chanid, '_', "
-                        "DATE_FORMAT(starttime, '%Y%m%d%H%i00'), '_', "
-                        "DATE_FORMAT(endtime, '%Y%m%d%H%i00'), '.nuv') "
-                        "WHERE basename = '';"))
-            MythDB::DBError("Updating record basename",
-                                 query.lastQuery());
-
-        // Hack to make sure record.station gets set if the user
-        // downgrades to a prior version and creates new entries
-        // without it.
-        if (!query.exec("UPDATE channel SET callsign=chanid "
-                        "WHERE callsign IS NULL OR callsign='';"))
-            MythDB::DBError("Updating channel callsign", query.lastQuery());
-
-        if (query.exec("SELECT MIN(chanid) FROM channel;"))
-        {
-            query.first();
-            int min_chanid = query.value(0).toInt();
-            if (!query.exec(QString("UPDATE record SET chanid = %1 "
-                                    "WHERE chanid IS NULL;").arg(min_chanid)))
-                MythDB::DBError("Updating record chanid", query.lastQuery());
-        }
-        else
-            MythDB::DBError("Querying minimum chanid", query.lastQuery());
-
-        MSqlQuery records_without_station(MSqlQuery::InitCon());
-        records_without_station.prepare("SELECT record.chanid,"
-                " channel.callsign FROM record LEFT JOIN channel"
-                " ON record.chanid = channel.chanid WHERE record.station='';");
-        if (records_without_station.exec() && records_without_station.next())
-        {
-            MSqlQuery update_record(MSqlQuery::InitCon());
-            update_record.prepare("UPDATE record SET station = :CALLSIGN"
-                    " WHERE chanid = :CHANID;");
-            do
-            {
-                update_record.bindValue(":CALLSIGN",
-                        records_without_station.value(1));
-                update_record.bindValue(":CHANID",
-                        records_without_station.value(0));
-                if (!update_record.exec())
-                {
-                    MythDB::DBError("Updating record station",
-                            update_record.lastQuery());
-                }
-            } while (records_without_station.next());
-        }
+        g_pUPnp = new MediaServer();
+        exec();
     }
 
-    if (!query.exec(
-            "SELECT cardid, hostname "
-            "FROM capturecard "
-            "ORDER BY cardid"))
+    void BlockUntilReloadNeeded(void)
     {
-        MythDB::DBError("Querying Recorders", query);
-        return false;
+        sleep(60); // TODO
     }
+};
 
-    vector<uint>    cardids;
-    vector<QString> hosts;
-    while (query.next())
-    {
-        uint    cardid = query.value(0).toUInt();
-        QString host   = query.value(1).toString();
-        QString cidmsg = QString("Card %1").arg(cardid);
-
-        if (host.isEmpty())
-        {
-            QString msg = cidmsg + " does not have a hostname defined.\n"
-                "Please run setup and confirm all of the capture cards.\n";
-
-            VERBOSE(VB_IMPORTANT, msg);
-            gContext->LogEntry("mythbackend", LP_CRITICAL,
-                               "Problem with capture cards", msg);
-            continue;
-        }
-
-        cardids.push_back(cardid);
-        hosts.push_back(host);
-    }
-
-    for (uint i = 0; i < cardids.size(); i++)
-    {
-        if (hosts[i] == localhostname)
-            new TVRec(cardids[i]);
-    }
-
-    for (uint i = 0; i < cardids.size(); i++)
-    {
-        uint    cardid = cardids[i];
-        QString host   = hosts[i];
-        QString cidmsg = QString("Card %1").arg(cardid);
-
-        if (!ismaster)
-        {
-            if (host == localhostname)
-            {
-                TVRec *tv = TVRec::GetTVRec(cardid);
-                if (tv->Init())
-                {
-                    EncoderLink *enc = new EncoderLink(cardid, tv);
-                    tvList[cardid] = enc;
-                }
-                else
-                {
-                    gContext->LogEntry("mythbackend", LP_CRITICAL,
-                                       "Problem with capture cards",
-                                       cidmsg + " failed init");
-                    delete tv;
-                    // The master assumes card comes up so we need to
-                    // set error and exit if a non-master card fails.
-                    error = true;
-                }
-            }
-        }
-        else
-        {
-            if (host == localhostname)
-            {
-                TVRec *tv = TVRec::GetTVRec(cardid);
-                if (tv->Init())
-                {
-                    EncoderLink *enc = new EncoderLink(cardid, tv);
-                    tvList[cardid] = enc;
-                }
-                else
-                {
-                    gContext->LogEntry("mythbackend", LP_CRITICAL,
-                                       "Problem with capture cards",
-                                       cidmsg + "failed init");
-                    delete tv;
-                }
-            }
-            else
-            {
-                EncoderLink *enc = new EncoderLink(cardid, NULL, host);
-                tvList[cardid] = enc;
-            }
-        }
-    }
-
-    if (tvList.empty())
-    {
-        VERBOSE(VB_IMPORTANT, LOC_ERR +
-                "No valid capture cards are defined in the database.\n\t\t\t"
-                "Perhaps you should re-read the installation instructions?");
-
-        gContext->LogEntry("mythbackend", LP_CRITICAL,
-                           "No capture cards are defined",
-                           "Please run the setup program.");
-        return false;
-    }
-
-    return true;
-}
-
-void cleanup(void)
-{
-    delete sched;
-    sched = NULL;
-
-    delete g_pUPnp;
-    g_pUPnp = NULL;
-
-    delete gContext;
-    gContext = NULL;
-
-    if (pidfile.size())
-    {
-        unlink(pidfile.toAscii().constData());
-        pidfile.clear();
-    }
-
-    signal(SIGHUP, SIG_DFL);
-    signal(SIGUSR1, SIG_DFL);
-}
-
-int log_rotate(int report_error)
-{
-    /* http://www.gossamer-threads.com/lists/mythtv/dev/110113 */
-
-    int new_logfd = open(logfile.toLocal8Bit().constData(),
-                         O_WRONLY|O_CREAT|O_APPEND|O_SYNC, 0664);
-    if (new_logfd < 0)
-    {
-        // If we can't open the new logfile, send data to /dev/null
-        if (report_error)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    QString("Cannot open logfile '%1'").arg(logfile));
-            return -1;
-        }
-        new_logfd = open("/dev/null", O_WRONLY);
-        if (new_logfd < 0)
-        {
-            // There's not much we can do, so punt.
-            return -1;
-        }
-    }
-    while (dup2(new_logfd, 1) < 0 && errno == EINTR) ;
-    while (dup2(new_logfd, 2) < 0 && errno == EINTR) ;
-    while (close(new_logfd) < 0 && errno == EINTR) ;
-    return 0;
-}
-
-void log_rotate_handler(int)
-{
-    log_rotate(0);
-}
-
-void upnp_rebuild(int)
-{
-    if (gContext->IsMasterHost())
-    {
-        g_pUPnp->RebuildMediaMap();
-    }
-
-}
-
-int preview_helper(const QString &chanid, const QString &starttime,
-                   long long previewFrameNumber, long long previewSeconds,
-                   const QSize &previewSize,
-                   const QString &infile, const QString &outfile)
-{
-    // Lower scheduling priority, to avoid problems with recordings.
-    if (setpriority(PRIO_PROCESS, 0, 9))
-        VERBOSE(VB_GENERAL, "Setting priority failed." + ENO);
-
-    ProgramInfo *pginfo = NULL;
-    if (!chanid.isEmpty() && !starttime.isEmpty())
-    {
-        pginfo = ProgramInfo::GetProgramFromRecorded(chanid, starttime);
-        if (!pginfo)
-        {
-            VERBOSE(VB_IMPORTANT, QString(
-                        "Can not locate recording made on '%1' at '%2'")
-                    .arg(chanid).arg(starttime));
-            return GENERIC_EXIT_NOT_OK;
-        }
-        pginfo->pathname = pginfo->GetPlaybackURL(false, true);
-    }
-    else if (!infile.isEmpty())
-    {
-        pginfo = ProgramInfo::GetProgramFromBasename(infile);
-        if (!pginfo)
-        {
-            if (!QFileInfo(infile).exists())
-            {
-                VERBOSE(VB_IMPORTANT, QString(
-                            "Can not locate recording '%1'").arg(infile));
-                return GENERIC_EXIT_NOT_OK;
-            }
-            else
-            {
-                pginfo = new ProgramInfo();
-                pginfo->isVideo = true;
-
-                QDir d(infile + "/VIDEO_TS");
-                if ((infile.section('.', -1) == "iso") ||
-                    (infile.section('.', -1) == "img") ||
-                    d.exists())
-                {
-                    pginfo->pathname = QString("dvd:%1").arg(infile);
-                }
-                else
-                {
-                    pginfo->pathname = QFileInfo(infile).absoluteFilePath();
-                }
-            }
-
-        }
-        else
-        {
-            pginfo->pathname = pginfo->GetPlaybackURL(false, true);
-        }
-    }
-    else
-    {
-        VERBOSE(VB_IMPORTANT, "Can not locate recording for preview");
-        return GENERIC_EXIT_NOT_OK;
-    }
-
-    PreviewGenerator *previewgen = new PreviewGenerator(
-        pginfo, PreviewGenerator::kLocal);
-
-    if (previewFrameNumber >= 0)
-        previewgen->SetPreviewTimeAsFrameNumber(previewFrameNumber);
-
-    if (previewSeconds >= 0)
-        previewgen->SetPreviewTimeAsSeconds(previewSeconds);
-
-    previewgen->SetOutputSize(previewSize);
-    previewgen->SetOutputFilename(outfile);
-    bool ok = previewgen->RunReal();
-    previewgen->deleteLater();
-
-    delete pginfo;
-
-    return (ok) ? GENERIC_EXIT_OK : GENERIC_EXIT_NOT_OK;
-}
-
-// [WxH] | [WxH@]seconds[S] | [WxH@]frame_numF
-bool parse_preview_info(const QString &param,
-                        long long     &previewFrameNumber,
-                        long long     &previewSeconds,
-                        QSize         &previewSize)
-{
-    previewFrameNumber = -1;
-    previewSeconds = -1;
-    previewSize = QSize(0,0);
-    if (param.isEmpty())
-        return true;
-
-    int xat = param.indexOf("x", 0, Qt::CaseInsensitive);
-    int aat = param.indexOf("@", 0);
-    if (xat > 0)
-    {
-        QString widthStr  = param.left(xat);
-        QString heightStr;
-        if (aat > xat)
-            heightStr = param.mid(xat + 1, aat - xat - 1);
-        else
-            heightStr = param.mid(xat + 1);
-
-        bool ok1, ok2;
-        previewSize = QSize(widthStr.toInt(&ok1), heightStr.toInt(&ok2));
-        if (!ok1 || !ok2)
-        {
-            VERBOSE(VB_IMPORTANT, QString(
-                        "Error: Failed to parse --generate-preview "
-                        "param '%1'").arg(param));
-        }
-    }
-    if ((xat > 0) && (aat < xat))
-        return true;
-
-    QString lastChar = param.at(param.length() - 1).toLower();
-    QString frameNumStr;
-    QString secsStr;
-    if (lastChar == "f")
-        frameNumStr = param.mid(aat + 1, param.length() - aat - 2);
-    else if (lastChar == "s")
-        secsStr = param.mid(aat + 1, param.length() - aat - 2);
-    else
-        secsStr = param.mid(aat + 1, param.length() - aat - 1);
-
-    bool ok = false;
-    if (!frameNumStr.isEmpty())
-        previewFrameNumber = frameNumStr.toUInt(&ok);
-    else if (!secsStr.isEmpty())
-        previewSeconds = secsStr.toUInt(&ok);
-
-    if (!ok)
-    {
-        VERBOSE(VB_IMPORTANT, QString(
-                    "Error: Failed to parse --generate-preview "
-                    "param '%1'").arg(param));
-    }
-
-    return ok;
-}
-
-namespace
-{
-    class CleanupGuard
-    {
-      public:
-        typedef void (*CleanupFunc)();
-
-      public:
-        CleanupGuard(CleanupFunc cleanFunction) :
-            m_cleanFunction(cleanFunction) {}
-
-        ~CleanupGuard()
-        {
-            m_cleanFunction();
-        }
-
-      private:
-        CleanupFunc m_cleanFunction;
-    };
-}
-
-void showUsage(const MythCommandLineParser &cmdlineparser, const QString &version)
-{
-    QString    help  = cmdlineparser.GetHelpString(false);
-    QByteArray ahelp = help.toLocal8Bit();
-
-    cerr << qPrintable(version) << endl <<
-    "Valid options are: " << endl <<
-    "-h or --help                   List valid command line parameters" << endl <<
-    "-l or --logfile filename       Writes STDERR and STDOUT messages to filename" << endl <<
-    "-p or --pidfile filename       Write PID of mythbackend to filename" << endl <<
-    "-d or --daemon                 Runs mythbackend as a daemon" << endl <<
-    "-v or --verbose debug-level    Use '-v help' for level info" << endl <<
-    "--setverbose debug-level       Change debug level of running master backend" << endl <<
-    "--user username                Drop permissions to username after starting"  << endl <<
-
-    "--printexpire                  List of auto-expire programs" << endl <<
-    "--printsched                   Upcoming scheduled programs" << endl <<
-    "--testsched                    Test run scheduler (ignore existing schedule)" << endl <<
-    "--resched                      Force the scheduler to update" << endl <<
-    "--nosched                      Do not perform any scheduling" << endl <<
-    "--noupnp                       Do not enable the UPNP server" << endl <<
-    "--nojobqueue                   Do not start the JobQueue" << endl <<
-    "--nohousekeeper                Do not start the Housekeeper" << endl <<
-    "--noautoexpire                 Do not start the AutoExpire thread" << endl <<
-    "--clearcache                   Clear the settings cache on all myth servers" << endl <<
-    ahelp.constData() <<
-    "--generate-preview             Generate a preview image" << endl <<
-    "--upnprebuild                  Force an update of UPNP media" << endl <<
-    "--infile                       Input file for preview generation" << endl <<
-    "--outfile                      Optional output file for preview generation" << endl <<
-    "--chanid                       Channel ID for preview generation" << endl <<
-    "--starttime                    Recording start time for preview generation" << endl <<
-    "--event EVENTTEXT              Send a backend event test message" << endl <<
-    "--systemevent EVENTTEXT        Send a backend SYSTEM_EVENT test message" << endl
-    << endl;
-
-}
-
 int main(int argc, char **argv)
 {
+    QString binname = basename(argv[0]);
+    QString versionStr = QString("%1 version: %2 [%3] www.mythtv.org")
+        .arg(binname).arg(myth_source_path).arg(myth_source_version);
+
     bool cmdline_err;
     MythCommandLineParser cmdline(
         kCLPOverrideSettingsFile |
         kCLPOverrideSettings     |
-        kCLPQueryVersion);
+        kCLPQueryVersion         |
+        kCLPPrintSchedule        |
+        kCLPTestSchedule         |
+        kCLPReschedule           |
+        kCLPNoSchedule           |
+        kCLPNoUPnP               |
+        kCLPUPnPRebuild          |
+        kCLPNoJobqueue           |
+        kCLPNoHousekeeper        |
+        kCLPNoAutoExpire         |
+        kCLPClearCache           |
+        kCLPVerbose              |
+        kCLPSetVerbose           |
+        kCLPLogFile              |
+        kCLPPidFile              |
+        kCLPInFile               |
+        kCLPOutFile              |
+        kCLPUsername             |
+        kCLPEvent                |
+        kCLPSystemEvent          |
+        kCLPChannelId            |
+        kCLPStartTime            |
+        kCLPPrintExpire          |
+        kCLPGeneratePreview);
 
     for (int argpos = 0; argpos < argc; ++argpos)
     {
@@ -544 +126 @@
     QApplication a(argc, argv);
 #endif
 
-    QString binname = basename(a.argv()[0]);
-    extern const char *myth_source_version;
-    extern const char *myth_source_path;
-    QString versionStr = QString("%1 version: %2 [%3] www.mythtv.org")
-                                 .arg(binname)
-                                 .arg(myth_source_path)
-                                 .arg(myth_source_version);
-
-    long long previewFrameNumber = -2;
-    long long previewSeconds     = -2;
-    QSize previewSize(0,0);
-    QString chanid;
-    QString starttime;
-    QString infile;
-    QString outfile;
-
-    bool daemonize = false;
-    bool printsched = false;
-    bool testsched = false;
-    bool setverbose = false;
-    QString newverbose;
-    QString username;
-    bool resched = false;
-    bool nosched = false;
-    bool noupnp = false;
-    bool nojobqueue = false;
-    bool nohousekeeper = false;
-    bool noexpirer = false;
-    QString printexpire;
-    bool clearsettingscache = false;
-    bool wantupnprebuild = false;
-    QString eventString;
-
     for (int argpos = 1; argpos < a.argc(); ++argpos)
     {
-        if (!strcmp(a.argv()[argpos],"-l") ||
-            !strcmp(a.argv()[argpos],"--logfile"))
+        if (cmdline.Parse(a.argc(), a.argv(), argpos, cmdline_err))
         {
-            if (a.argc() > argpos)
-            {
-                logfile = a.argv()[argpos+1];
-                if (logfile.startsWith("-"))
-                {
-                    cerr << "Invalid or missing argument to -l/--logfile option\n";
-                    return BACKEND_EXIT_INVALID_CMDLINE;
-                }
-                else
-                {
-                    ++argpos;
-                }
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"-p") ||
-                 !strcmp(a.argv()[argpos],"--pidfile"))
-        {
-            if (a.argc() > argpos)
-            {
-                pidfile = a.argv()[argpos+1];
-                if (pidfile.startsWith("-"))
-                {
-                    cerr << "Invalid or missing argument to -p/--pidfile option\n";
-                    return BACKEND_EXIT_INVALID_CMDLINE;
-                }
-                else
-                {
-                   ++argpos;
-                }
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"-d") ||
-                 !strcmp(a.argv()[argpos],"--daemon"))
-        {
-            daemonize = true;
-
-        }
-        else if (!strcmp(a.argv()[argpos],"-v") ||
-                 !strcmp(a.argv()[argpos],"--verbose"))
-        {
-            if (a.argc()-1 > argpos)
-            {
-                if (parse_verbose_arg(a.argv()[argpos+1]) ==
-                        GENERIC_EXIT_INVALID_CMDLINE)
-                    return BACKEND_EXIT_INVALID_CMDLINE;
-
-                ++argpos;
-            }
-            else
-            {
-                cerr << "Missing argument to -v/--verbose option\n";
-                return BACKEND_EXIT_INVALID_CMDLINE;
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"--setverbose"))
-        {
-            setverbose = true;
-            if (a.argc()-1 > argpos)
-            {
-                newverbose = a.argv()[argpos+1];
-                ++argpos;
-            }
-            else
-            {
-                cerr << "Missing argument to --setverbose option\n";
-                return BACKEND_EXIT_INVALID_CMDLINE;
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"--user"))
-        {
-            if (a.argc()-1 > argpos)
-            {
-                username = a.argv()[argpos+1];
-                ++argpos;
-            }
-            else
-            {
-                cerr << "Missing argument to --user option\n";
-                return BACKEND_EXIT_INVALID_CMDLINE;
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"--printsched"))
-        {
-            printsched = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--testsched"))
-        {
-            testsched = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--resched"))
-        {
-            resched = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--nosched"))
-        {
-            nosched = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--noupnp"))
-        {
-            noupnp = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--upnprebuild"))
-        {
-            wantupnprebuild = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--nojobqueue"))
-        {
-            nojobqueue = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--nohousekeeper"))
-        {
-            nohousekeeper = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--noautoexpire"))
-        {
-            noexpirer = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--printexpire"))
-        {
-            printexpire = "ALL";
-            if ((a.argc()-1 > argpos) && a.argv()[argpos+1][0] != '-')
-            {
-                printexpire = a.argv()[argpos+1];
-                ++argpos;
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"--clearcache"))
-        {
-            clearsettingscache = true;
-        }
-        else if (!strcmp(a.argv()[argpos],"--event"))
-        {
-            if ((a.argc()-1 > argpos) && a.argv()[argpos+1][0] != '-')
-            {
-                eventString = a.argv()[argpos+1];
-                ++argpos;
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"--systemevent"))
-        {
-            if ((a.argc()-1 > argpos) && a.argv()[argpos+1][0] != '-')
-            {
-                eventString = QString("SYSTEM_EVENT ") + a.argv()[argpos+1];
-                ++argpos;
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"--generate-preview"))
-        {
-            QString tmp;
-            if ((argpos + 1) < a.argc())
-            {
-                tmp = a.argv()[argpos+1];
-                bool ok = true;
-                if (tmp.left(1) == "-")
-                    tmp.left(2).toInt(&ok);
-                if (ok)
-                    argpos++;
-                else
-                    tmp.clear();
-            }
-
-            if (!parse_preview_info(tmp, previewFrameNumber, previewSeconds,
-                                    previewSize))
-            {
-                VERBOSE(VB_IMPORTANT,
-                        QString("Unable to parse --generate-preview "
-                                "option '%1'").arg(tmp));
-
-                return BACKEND_EXIT_INVALID_CMDLINE;
-            }
-        }
-        else if (!strcmp(a.argv()[argpos],"-c") ||
-                 !strcmp(a.argv()[argpos],"--chanid"))
-        {
-            if (((argpos + 1) >= a.argc()) ||
-                !strncmp(a.argv()[argpos + 1], "-", 1))
-            {
-                VERBOSE(VB_IMPORTANT,
-                        "Missing or invalid parameters for --chanid option");
-
-                return BACKEND_EXIT_INVALID_CMDLINE;
-            }
-
-            chanid = a.argv()[++argpos];
-        }
-        else if (!strcmp(a.argv()[argpos],"-s") ||
-                 !strcmp(a.argv()[argpos],"--starttime"))
-        {
-            if (((argpos + 1) >= a.argc()) ||
-                !strncmp(a.argv()[argpos + 1], "-", 1))
-            {
-                VERBOSE(VB_IMPORTANT,
-                        "Missing or invalid parameters for --starttime option");
-                return BACKEND_EXIT_INVALID_CMDLINE;
-            }
-
-            starttime = a.argv()[++argpos];
-        }
-        else if (!strcmp(a.argv()[argpos],"--infile"))
-        {
-            if (((argpos + 1) >= a.argc()) ||
-                !strncmp(a.argv()[argpos + 1], "-", 1))
-            {
-                VERBOSE(VB_IMPORTANT,
-                        "Missing or invalid parameters for --infile option");
-
-                return BACKEND_EXIT_INVALID_CMDLINE;
-            }
-
-            infile = a.argv()[++argpos];
-        }
-        else if (!strcmp(a.argv()[argpos],"--outfile"))
-        {
-            if (((argpos + 1) >= a.argc()) ||
-                !strncmp(a.argv()[argpos + 1], "-", 1))
-            {
-                VERBOSE(VB_IMPORTANT,
-                        "Missing or invalid parameters for --outfile option");
-
-                return BACKEND_EXIT_INVALID_CMDLINE;
-            }
-
-            outfile = a.argv()[++argpos];
-        }
-        else if (cmdline.Parse(a.argc(), a.argv(), argpos, cmdline_err))
-        {
             if (cmdline_err)
                 return BACKEND_EXIT_INVALID_CMDLINE;
 
@@ -817 +139 @@
         else
         {
             if (!(!strcmp(a.argv()[argpos],"-h") ||
-                !strcmp(a.argv()[argpos],"--help")))
+                  !strcmp(a.argv()[argpos],"--help")))
+            {
                 cerr << "Invalid argument: " << a.argv()[argpos] << endl;
                 showUsage(cmdline, versionStr);
-            return BACKEND_EXIT_INVALID_CMDLINE;
+                return BACKEND_EXIT_INVALID_CMDLINE;
+            }
+            else
+            {
+                showUsage(cmdline, versionStr);
+                return BACKEND_EXIT_OK;
+            }
         }
     }
 
-    if (((previewFrameNumber >= -1) || previewSeconds >= -1) &&
-        (chanid.isEmpty() || starttime.isEmpty()) && infile.isEmpty())
+    if (cmdline.HasInvalidPreviewGenerationParams())
     {
         cerr << "--generate-preview must be accompanied by either " <<endl
              << "\nboth --chanid and --starttime parameters, " << endl
@@ -833 +161 @@
         return BACKEND_EXIT_INVALID_CMDLINE;
     }
 
-    if (!logfile.isEmpty())
-    {
-        if (log_rotate(1) < 0)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_WARN +
-                    "Cannot open logfile; using stdout/stderr instead");
-        }
-        else
-            signal(SIGHUP, &log_rotate_handler);
-    }
+    logfile = cmdline.GetLogFilename();
+    pidfile = cmdline.GetPIDFilename();
 
-    CleanupGuard callCleanup(cleanup);
+    ///////////////////////////////////////////////////////////////////////
 
-    ofstream pidfs;
-    if (pidfile.size())
-    {
-        pidfs.open(pidfile.toAscii().constData());
-        if (!pidfs)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    "Could not open pid file" + ENO);
-            return BACKEND_EXIT_OPENING_PIDFILE_ERROR;
-        }
-    }
+    // Don't listen to console input
+    close(0);
 
-    if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
-        VERBOSE(VB_IMPORTANT, LOC_WARN + "Unable to ignore SIGPIPE");
+    setupLogfile();
 
-    if (daemonize && (daemon(0, 1) < 0))
-    {
-        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to daemonize" + ENO);
-        return BACKEND_EXIT_DAEMONIZING_ERROR;
-    }
+    CleanupGuard callCleanup(cleanup);
 
-    if (!username.isEmpty())
-    {
-        struct passwd *user_info = getpwnam(username.toLocal8Bit().constData());
-        const uid_t user_id = geteuid();
+    int exitCode = setup_basics(cmdline);
+    if (BACKEND_EXIT_OK != exitCode)
+        return exitCode;
 
-        if (user_id && (!user_info || user_id != user_info->pw_uid))
-        {
-            VERBOSE(VB_IMPORTANT,
-                    "You must be running as root to use the --user switch.");
-            return BACKEND_EXIT_PERMISSIONS_ERROR;
-        }
-        else if (user_info && user_id == user_info->pw_uid)
-        {
-            VERBOSE(VB_IMPORTANT,
-                    QString("Already running as '%1'").arg(username));
-        }
-        else if (!user_id && user_info)
-        {
-            if (setenv("HOME", user_info->pw_dir,1) == -1)
-            {
-                VERBOSE(VB_IMPORTANT, "Error setting home directory.");
-                return BACKEND_EXIT_PERMISSIONS_ERROR;
-            }
-            if (setgid(user_info->pw_gid) == -1)
-            {
-                VERBOSE(VB_IMPORTANT, "Error setting effective group.");
-                return BACKEND_EXIT_PERMISSIONS_ERROR;
-            }
-            if (setuid(user_info->pw_uid) == -1)
-            {
-                VERBOSE(VB_IMPORTANT, "Error setting effective user.");
-                return BACKEND_EXIT_PERMISSIONS_ERROR;
-            }
-        }
-        else
-        {
-            VERBOSE(VB_IMPORTANT,
-                    QString("Invalid user '%1' specified with --user")
-                    .arg(username));
-            return BACKEND_EXIT_PERMISSIONS_ERROR;
-        }
-    }
+    VERBOSE(VB_IMPORTANT, versionStr);
 
-    if (pidfs)
+    if (cmdline.HasBackendCommand())
     {
-        pidfs << getpid() << endl;
-        pidfs.close();
+        if (!setup_context(cmdline))
+            return BACKEND_EXIT_NO_MYTHCONTEXT;
+        return handle_command(cmdline);
     }
 
-    VERBOSE(VB_IMPORTANT, versionStr);
-
     gContext = new MythContext(MYTH_BINARY_VERSION);
-    if (!gContext->Init(false))
-    {
-        VERBOSE(VB_IMPORTANT, "Failed to init MythContext, exiting.");
-        return BACKEND_EXIT_NO_MYTHCONTEXT;
-    }
-    gContext->SetBackend(true);
 
-    if (!eventString.isEmpty())
-    {
-        gContext->SetBackend(false);
-        if (gContext->ConnectToMasterServer())
-        {
-            if (eventString.startsWith("SYSTEM_EVENT"))
-                eventString += QString(" SENDER %1")
-                                       .arg(gContext->GetHostName());
+    ///////////////////////////////////////////
 
-            RemoteSendMessage(eventString);
-            return BACKEND_EXIT_OK;
-        }
-        return BACKEND_EXIT_NO_MYTHCONTEXT;
-    }
+    MediaServerThread *mst = new MediaServerThread();
+    mst->start();
+    while (!mst->isRunning())
+        usleep(5000);
+    while (!g_pUPnp)
+        usleep(5000);
 
-    if (wantupnprebuild)
-    {
-        VERBOSE(VB_GENERAL, "Rebuilding UPNP Media Map");
+    ///////////////////////////////////////////
 
-        UPnpMedia *rebuildit = new UPnpMedia(false,false);
-        rebuildit->BuildMediaMap();
-
-        return BACKEND_EXIT_OK;
-    }
-
-    if (setverbose)
+    while (true)
     {
-        gContext->SetBackend(false);
-
-        if (gContext->ConnectToMasterServer())
-        {
-            QString message = "SET_VERBOSE ";
-            message += newverbose;
-
-            RemoteSendMessage(message);
-            VERBOSE(VB_IMPORTANT, QString("Sent '%1' message").arg(message));
-            return BACKEND_EXIT_OK;
-        }
-        else
-        {
-            VERBOSE(VB_IMPORTANT,
-                    "Unable to connect to backend, verbose level unchanged ");
-            return BACKEND_EXIT_NO_CONNECT;
-        }
+        exitCode = run_backend(cmdline);
+        mst->BlockUntilReloadNeeded();
     }
 
-    if (clearsettingscache)
-    {
-        gContext->SetBackend(false);
-
-        if (gContext->ConnectToMasterServer())
-        {
-            RemoteSendMessage("CLEAR_SETTINGS_CACHE");
-            VERBOSE(VB_IMPORTANT, "Sent CLEAR_SETTINGS_CACHE message");
-            return BACKEND_EXIT_OK;
-        }
-        else
-        {
-            VERBOSE(VB_IMPORTANT, "Unable to connect to backend, settings "
-                    "cache will not be cleared.");
-            return BACKEND_EXIT_NO_CONNECT;
-        }
-    }
-
-    QMap<QString,QString> settingsOverride = cmdline.GetSettingsOverride();
-    if (settingsOverride.size())
-    {
-        QMap<QString, QString>::iterator it;
-        for (it = settingsOverride.begin(); it != settingsOverride.end(); ++it)
-        {
-            VERBOSE(VB_IMPORTANT, QString("Setting '%1' being forced to '%2'")
-                                          .arg(it.key()).arg(*it));
-            gContext->OverrideSettingForSession(it.key(), *it);
-        }
-    }
-
-    if (!gContext->IsMasterHost())
-    {
-        MythSocket *tempMonitorConnection = new MythSocket();
-        if (tempMonitorConnection->connect(
-                        gContext->GetSetting("MasterServerIP", "127.0.0.1"),
-                        gContext->GetNumSetting("MasterServerPort", 6543)))
-        {
-            if (!gContext->CheckProtoVersion(tempMonitorConnection))
-            {
-                VERBOSE(VB_IMPORTANT, "Master backend is incompatible with "
-                                      "this backend.\nCannot become a slave.");
-                return BACKEND_EXIT_NO_CONNECT;
-            }
-
-            QStringList tempMonitorDone("DONE");
-
-            QStringList tempMonitorAnnounce("ANN Monitor tzcheck 0");
-            tempMonitorConnection->writeStringList(tempMonitorAnnounce);
-            tempMonitorConnection->readStringList(tempMonitorAnnounce);
-            if (tempMonitorAnnounce.empty() ||
-                tempMonitorAnnounce[0] == "ERROR")
-            {
-                tempMonitorConnection->DownRef();
-                tempMonitorConnection = NULL;
-                if (tempMonitorAnnounce.empty())
-                {
-                    VERBOSE(VB_IMPORTANT, LOC_ERR +
-                            "Failed to open event socket, timeout");
-                }
-                else
-                {
-                    VERBOSE(VB_IMPORTANT, LOC_ERR +
-                            "Failed to open event socket" +
-                        ((tempMonitorAnnounce.size() >= 2) ?
-                         QString(", error was %1").arg(tempMonitorAnnounce[1]) :
-                         QString(", remote error")));
-                }
-            }
-
-            QStringList tzCheck("QUERY_TIME_ZONE");
-            if (tempMonitorConnection)
-            {
-                tempMonitorConnection->writeStringList(tzCheck);
-                tempMonitorConnection->readStringList(tzCheck);
-            }
-            if (tzCheck.size() && !checkTimeZone(tzCheck))
-            {
-                // Check for different time zones, different offsets, different
-                // times
-                VERBOSE(VB_IMPORTANT, "The time and/or time zone settings on "
-                        "this system do not match those in use on the master "
-                        "backend. Please ensure all frontend and backend "
-                        "systems are configured to use the same time zone and "
-                        "have the current time properly set.");
-                VERBOSE(VB_IMPORTANT,
-                        "Unable to run with invalid time settings. Exiting.");
-                tempMonitorConnection->writeStringList(tempMonitorDone);
-                tempMonitorConnection->DownRef();
-                return BACKEND_EXIT_INVALID_TIMEZONE;
-            }
-            else
-            {
-                VERBOSE(VB_IMPORTANT,
-                        QString("Backend is running in %1 time zone.")
-                        .arg(getTimeZoneID()));
-            }
-            if (tempMonitorConnection)
-                tempMonitorConnection->writeStringList(tempMonitorDone);
-        }
-        if (tempMonitorConnection)
-            tempMonitorConnection->DownRef();
-    }
-
-    // Don't allow upgrade for --printsched, --testsched, --resched,
-    // --printexpire, --generate-preview
-    bool allowUpgrade = (!(printsched || testsched || resched)) &&
-                        (printexpire.isEmpty()) &&
-                        ((previewFrameNumber < -1) && (previewSeconds < -1));
-    if (!UpgradeTVDatabaseSchema(allowUpgrade, allowUpgrade))
-    {
-        VERBOSE(VB_IMPORTANT, "Couldn't upgrade database to new schema");
-        return BACKEND_EXIT_DB_OUTOFDATE;
-    }
-
-    close(0);
-
-    if (printsched || testsched)
-    {
-        gContext->SetBackend(false);
-        sched = new Scheduler(false, &tvList);
-        if (!testsched && gContext->ConnectToMasterServer())
-        {
-            cout << "Retrieving Schedule from Master backend.\n";
-            sched->FillRecordListFromMaster();
-        }
-        else
-        {
-            cout << "Calculating Schedule from database.\n" <<
-                    "Inputs, Card IDs, and Conflict info may be invalid "
-                    "if you have multiple tuners.\n";
-            sched->FillRecordListFromDB();
-        }
-
-        print_verbose_messages |= VB_SCHEDULE;
-        sched->PrintList(true);
-        return BACKEND_EXIT_OK;
-    }
-
-    if (resched)
-    {
-        gContext->SetBackend(false);
-
-        bool ok = false;
-        if (gContext->ConnectToMasterServer())
-        {
-            VERBOSE(VB_IMPORTANT, "Connected to master for reschedule");
-            ScheduledRecording::signalChange(-1);
-            ok = true;
-        }
-        else
-            VERBOSE(VB_IMPORTANT, "Cannot connect to master for reschedule");
-
-        return (ok) ? BACKEND_EXIT_OK : BACKEND_EXIT_NO_CONNECT;
-    }
-
-    if (!printexpire.isEmpty())
-    {
-        expirer = new AutoExpire();
-        expirer->PrintExpireList(printexpire);
-        return BACKEND_EXIT_OK;
-    }
-
-    if ((previewFrameNumber >= -1) || (previewSeconds >= -1))
-    {
-        int ret = preview_helper(
-            chanid, starttime,
-            previewFrameNumber, previewSeconds, previewSize,
-            infile, outfile);
-        return ret;
-    }
-
-    MythSystemEventHandler *sysEventHandler = new MythSystemEventHandler();
-
-    int port = gContext->GetNumSetting("BackendServerPort", 6543);
-
-    QString myip = gContext->GetSetting("BackendServerIP");
-    if (myip.isEmpty())
-    {
-        cerr << "No setting found for this machine's BackendServerIP.\n"
-             << "Please run setup on this machine and modify the first page\n"
-             << "of the general settings.\n";
-        delete sysEventHandler;
-        return BACKEND_EXIT_NO_IP_ADDRESS;
-    }
-
-    bool ismaster = gContext->IsMasterHost();
-
-    if (ismaster)
-    {
-        VERBOSE(VB_GENERAL, LOC + "Starting up as the master server.");
-        gContext->LogEntry("mythbackend", LP_INFO,
-                           "MythBackend started as master server", "");
-
-        if (nosched)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_WARN +
-                    "********** The Scheduler has been DISABLED with "
-                    "the --nosched option **********");
-        }
-
-        // kill -USR1 mythbackendpid will force a upnpmedia rebuild
-        signal(SIGUSR1, &upnp_rebuild);
-    }
-    else
-    {
-        VERBOSE(VB_GENERAL, LOC + "Running as a slave backend.");
-        gContext->LogEntry("mythbackend", LP_INFO,
-                           "MythBackend started as a slave backend", "");
-    }
-
-    bool fatal_error = false;
-    bool runsched = setupTVs(ismaster, fatal_error);
-    if (fatal_error)
-    {
-        delete sysEventHandler;
-        return BACKEND_EXIT_CAP_CARD_SETUP_ERROR;
-    }
-
-    if (ismaster && runsched)
-    {
-        sched = new Scheduler(true, &tvList);
-        int err = sched->GetError();
-        if (err)
-        {
-            return err;
-        }
-
-        if (nosched)
-            sched->DisableScheduling();
-    }
-
-    // Get any initial housekeeping done before we fire up anything else
-    if (nohousekeeper)
-    {
-        VERBOSE(VB_IMPORTANT, LOC_WARN +
-                "****** The Housekeeper has been DISABLED with "
-                "the --nohousekeeper option ******");
-    }
-    else
-        housekeeping = new HouseKeeper(true, ismaster, sched);
-
-    if (ismaster)
-    {
-        if (noexpirer)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_WARN +
-                    "********* Auto-Expire has been DISABLED with "
-                    "the --noautoexpire option ********");
-        }
-        else
-            expirer = new AutoExpire(&tvList);
-    }
-
-    if (sched && expirer)
-        sched->SetExpirer(expirer);
-
-    if (nojobqueue)
-    {
-        VERBOSE(VB_IMPORTANT, LOC_WARN +
-                "********* The JobQueue has been DISABLED with "
-                "the --nojobqueue option *********");
-    }
-    else
-        jobqueue = new JobQueue(ismaster);
-
-    // Start UPnP Services
-
-    g_pUPnp = new MediaServer( ismaster, noupnp );
-
-    HttpServer *pHS = g_pUPnp->GetHttpServer();
-    if (pHS)
-    {
-        VERBOSE(VB_IMPORTANT, "Main::Registering HttpStatus Extension");
-
-        pHS->RegisterExtension( new HttpStatus( &tvList, sched,
-                                                expirer, ismaster ));
-    }
-
-    VERBOSE(VB_IMPORTANT, QString("Enabled verbose msgs: %1").arg(verboseString));
-
-    MainServer *mainServer = new MainServer(ismaster, port, &tvList, sched,
-            expirer);
-
-    int exitCode = mainServer->GetExitCode();
-    if (exitCode != BACKEND_EXIT_OK)
-    {
-        VERBOSE(VB_IMPORTANT, "Backend exiting, MainServer initialization "
-                "error.");
-        delete mainServer;
-        return exitCode;
-    }
-
-    StorageGroup::CheckAllStorageGroupDirs();
-
-    if (gContext->IsMasterBackend())
-        SendMythSystemEvent("MASTER_STARTED");
-
-    exitCode = a.exec();
-
-    if (gContext->IsMasterBackend())
-    {
-        SendMythSystemEvent("MASTER_SHUTDOWN");
-        a.processEvents();
-    }
-
-    gContext->LogEntry("mythbackend", LP_INFO, "MythBackend exiting", "");
-
-    delete sysEventHandler;
-    delete mainServer;
-
-    return exitCode ? exitCode : BACKEND_EXIT_OK;
+    return exitCode;
 }
 
 /* vim: set expandtab tabstop=4 shiftwidth=4: */

programs/mythbackend/backendcontext.cpp

@@ +1 @@
+#include "backendcontext.h"
+
+QMap<int, EncoderLink *> tvList;
+AutoExpire  *expirer      = NULL;
+Scheduler   *sched        = NULL;
+JobQueue    *jobqueue     = NULL;
+HouseKeeper *housekeeping = NULL;
+MediaServer *g_pUPnp      = NULL;
+QString      pidfile;
+QString      logfile;

programs/mythbackend/mythsettings.cpp

@@ +1 @@
+#include <QNetworkInterface>
+#include <QDomDocument>
+#include <QFile>
+
+#include "channelsettings.h" // for ChannelTVFormat::GetFormats()
+#include "mythsettings.h"
+#include "frequencies.h"
+#include "mythcontext.h"
+#include "mythdb.h"
+
+static QString indent(uint level)
+{
+    QString ret;
+    for (uint i = 0; i < level; i++)
+        ret += "    ";
+    return ret;
+}
+
+static QString extract_query_list(
+    const MythSettingList &settings, MythSetting::SettingType stype)
+{
+    QString list;
+
+    MythSettingList::const_iterator it = settings.begin();
+    for (; it != settings.end(); ++it)
+    {
+        const MythSettingGroup *group =
+            dynamic_cast<const MythSettingGroup*>(*it);
+        if (group)
+        {
+            list += extract_query_list(group->settings, stype);
+            continue;
+        }
+        const MythSetting *setting = dynamic_cast<const MythSetting*>(*it);
+        if (setting && (setting->stype == stype))
+            list += QString(",'%1'").arg(setting->value);
+    }
+    if (!list.isEmpty() && (list[0] == QChar(',')))
+        list = list.mid(1);
+
+    return list;
+}
+
+static void fill_setting(
+    MythSettingBase *sb, const QMap<QString,QString> &map,
+    MythSetting::SettingType stype)
+{
+    const MythSettingGroup *group =
+        dynamic_cast<const MythSettingGroup*>(sb);
+    if (group)
+    {
+        MythSettingList::const_iterator it = group->settings.begin();
+        for (; it != group->settings.end(); ++it)
+            fill_setting(*it, map, stype);
+        return;
+    }
+
+    MythSetting *setting = dynamic_cast<MythSetting*>(sb);
+    if (setting && (setting->stype == stype))
+    {
+        QMap<QString,QString>::const_iterator it = map.find(setting->value);
+        if (it != map.end())
+            setting->data = *it;
+
+        bool do_option_check = false;
+        if (MythSetting::kLocalIPAddress == setting->dtype)
+        {
+            setting->data_list.clear();
+            setting->display_list.clear();
+            QList<QHostAddress> list = QNetworkInterface::allAddresses();
+            for (uint i = 0; i < (uint)list.size(); i++)
+            {
+                if (list[i].toString().contains(":"))
+                    continue; // ignore IP6 addresses for now
+                setting->data_list.push_back(list[i].toString());
+                setting->display_list.push_back(setting->data_list.back());
+            }
+            if (setting->data_list.isEmpty())
+                setting->data_list.push_back("127.0.0.1");
+            do_option_check = true;
+        }
+        else if (MythSetting::kSelect == setting->dtype)
+        {
+            do_option_check = true;
+        }
+        else if (MythSetting::kTVFormat == setting->dtype)
+        {
+            setting->data_list = setting->display_list =
+                ChannelTVFormat::GetFormats();
+            do_option_check = true;
+        }
+        else if (MythSetting::kFrequencyTable == setting->dtype)
+        {
+            setting->data_list.clear();
+            for (uint i = 0; chanlists[i].name; i++)
+                setting->data_list.push_back(chanlists[i].name);
+            setting->display_list = setting->data_list;
+            do_option_check = true;
+        }
+
+        if (do_option_check)
+        {
+            if (!setting->data_list.empty() &&
+                !setting->data_list.contains(setting->data.toLower(),
+                                             Qt::CaseInsensitive))
+            {
+                bool ok;
+                long long idata = setting->data.toLongLong(&ok);
+                if (ok)
+                {
+                    uint sel = 0;
+                    for (uint i = setting->data_list.size(); i >= 0; i--)
+                    {
+                        if (idata < setting->data_list[i].toLongLong())
+                            break;
+                        sel = i;
+                    }
+                    setting->data = setting->data_list[sel];
+                }
+                else
+                {
+                    setting->data =
+                        (setting->data_list.contains(
+                            setting->default_data, Qt::CaseInsensitive)) ?
+                        setting->default_data : setting->data_list[0];
+                }
+            }
+        }
+    }
+}
+
+static void fill_settings(
+    MythSettingList &settings, MSqlQuery &query, MythSetting::SettingType stype)
+{
+    QMap<QString,QString> map;
+    while (query.next())
+        map[query.value(0).toString()] = query.value(1).toString();
+
+    MythSettingList::const_iterator it = settings.begin();
+    for (; it != settings.end(); ++it)
+        fill_setting(*it, map, stype);
+}
+
+QString MythSettingGroup::ToHTML(uint depth) const
+{
+    QString ret;
+
+    ret = indent(depth) +
+        QString("<div class=\"group\" id=\"%1\">\r\n").arg(unique_label);
+    if (!human_label.isEmpty())
+    {
+        ret += indent(depth+1) + QString("<h%1>%2</h%3>\r\n")
+            .arg(depth+1).arg(human_label).arg(depth+1);
+    }
+
+    MythSettingList::const_iterator it = settings.begin();
+    for (; it != settings.end(); ++it)
+        ret += (*it)->ToHTML(depth+1);
+
+    ret += indent(depth) +"</div>";
+
+    return ret;
+}
+
+QString MythSetting::ToHTML(uint level) const
+{
+    QString ret = indent(level) +
+        QString("<div class=\"setting\" id=\"%1_div\">\r\n").arg(value);
+
+    switch (dtype)
+    {
+        case kInteger:
+        case kUnsignedInteger:
+        case kIntegerRange:
+        case kFloat:
+        case kComboBox:
+        case kIPAddress:
+        case kString:
+        case kTimeOfDay:
+        case kOther:
+            ret += indent(level) +
+                "<div class=\"setting_label\">" + label + "</div>\r\n";
+            ret += indent(level) +
+                QString("<input name=\"%1\" id=\"%2_input\" type=\"text\""
+                        " value=\"%3\"/>\r\n")
+                .arg(value).arg(value).arg(data);
+            ret += indent(level) +
+                QString("<div style=\"display:none;"
+                        "position:absolute;left:-4000px\" "
+                        "id=\"%1_default\">%2</div>\r\n")
+                .arg(value).arg(default_data);
+            break;
+        case kCheckBox:
+            ret += indent(level) +
+                "<div class=\"setting_label\">" + label + "</div>\r\n";
+            ret += indent(level) +
+                QString("<input name=\"%1\" id=\"%2_input\" type=\"checkbox\""
+                        " value=\"1\" %3/>\r\n")
+                .arg(value).arg(value).arg((data.toUInt()) ? "checked" : "");
+            ret += indent(level) +
+                QString("<div style=\"display:none;"
+                        "position:absolute;left:-4000px\" "
+                        "id=\"%1_default\">%2</div>\r\n")
+                .arg(value).arg(default_data);
+            break;
+        case kLocalIPAddress:
+        case kTVFormat:
+        case kFrequencyTable:
+        case kSelect:
+            ret +=  indent(level) +
+                "<div class=\"setting_label\">" + label + "</div>\r\n";
+            ret +=  indent(level) +
+                QString("<select name=\"%1\" id=\"%2_input\">\r\n")
+                .arg(value).arg(value);
+            for (uint i = 0; (i < (uint)data_list.size()) &&
+                     (i < (uint)display_list.size()); i++)
+            {
+                ret += indent(level+1) +
+                    QString("<option value=\"%1\" %2>%3</option>\r\n")
+                    .arg(data_list[i])
+                    .arg((data_list[i].toLower() == data.toLower()) ?
+                         "selected" : "")
+                    .arg(display_list[i]);
+            }
+            ret += indent(level) + "</select>\r\n";
+            ret += indent(level) +
+                QString("<div style=\"display:none;"
+                        "position:absolute;left:-4000px\" "
+                        "id=\"%1_default\">%2</div>\r\n")
+                .arg(value).arg(default_data);
+            break;
+    }
+
+    ret += indent(level) + "</div>\r\n";
+
+    return ret;
+}
+
+MythSetting::SettingType parse_setting_type(const QString &str)
+{
+    QString s = str.toLower();
+    if (s=="file")
+        return MythSetting::kFile;
+    if (s=="host")
+        return MythSetting::kHost;
+    if (s=="global")
+        return MythSetting::kGlobal;
+    return MythSetting::kInvalidSettingType;
+}
+
+MythSetting::DataType parse_data_type(const QString &str)
+{
+    QString s = str.toLower();
+    if (s == "integer")
+        return MythSetting::kInteger;
+    if (s == "unsigned")
+        return MythSetting::kUnsignedInteger;
+    if (s == "integer_range")
+        return MythSetting::kIntegerRange;
+    if (s == "checkbox")
+        return MythSetting::kCheckBox;
+    if (s == "select")
+        return MythSetting::kSelect;
+    if (s == "combobox")
+        return MythSetting::kComboBox;
+    if (s == "tvformat")
+        return MythSetting::kTVFormat;
+    if (s == "frequency_table")
+        return MythSetting::kFrequencyTable;
+    if (s == "float")
+        return MythSetting::kFloat;
+    if (s == "ipaddress")
+        return MythSetting::kIPAddress;
+    if (s == "localipaddress")
+        return MythSetting::kLocalIPAddress;
+    if (s == "string")
+        return MythSetting::kString;
+    if (s == "timeofday")
+        return MythSetting::kTimeOfDay;
+    if (s == "other")
+        return MythSetting::kOther;
+    VERBOSE(VB_IMPORTANT, QString("Unknown type: %1").arg(str));
+    return MythSetting::kInvalidDataType;
+}
+
+bool parse_dom(MythSettingList &settings, const QDomElement &element,
+               const QString &filename)
+{
+#define LOC QString("parse_dom(%1@~%2), error: ") \
+            .arg(filename).arg(e.lineNumber())
+
+    QDomNode n = element.firstChild();
+    while (!n.isNull())
+    {
+        const QDomElement e = n.toElement();
+        if (e.isNull())
+        {
+            n = n.nextSibling();
+            continue;
+        }
+
+        if (e.tagName() == "group")
+        {
+            QString human_label  = e.attribute("human_label");
+            QString unique_label = e.attribute("unique_label");
+            QString ecma_script  = e.attribute("ecma_script");
+
+            MythSettingGroup *g = new MythSettingGroup(
+                human_label, unique_label, ecma_script);
+
+            if (e.hasChildNodes() && !parse_dom(g->settings, e, filename))
+                return false;
+
+            settings.push_back(g);
+        }
+        else if (e.tagName() == "setting")
+        {
+            QMap<QString,QString> m;
+            m["value"]        = e.attribute("value");
+            m["setting_type"] = e.attribute("setting_type");
+            m["label"]        = e.attribute("label");
+            m["help_text"]    = e.attribute("help_text");
+            m["data_type"]    = e.attribute("data_type");
+
+            MythSetting::DataType dtype = parse_data_type(m["data_type"]);
+            if (MythSetting::kInvalidDataType == dtype)
+            {
+                VERBOSE(VB_IMPORTANT, LOC +
+                        "Setting has invalid or missing data_type attribute.");
+                return false;
+            }
+
+            QStringList data_list;
+            QStringList display_list;
+            if ((MythSetting::kComboBox == dtype) ||
+                (MythSetting::kSelect   == dtype))
+            {
+                if (!e.hasChildNodes())
+                {
+                    VERBOSE(VB_IMPORTANT, LOC +
+                            "Setting missing selection items.");
+                    return false;
+                }
+
+                QDomNode n2 = e.firstChild();
+                while (!n2.isNull())
+                {
+                    const QDomElement e2 = n2.toElement();
+                    if (e2.tagName() != "option")
+                    {
+                        VERBOSE(VB_IMPORTANT, LOC +
+                                "Setting selection contains invalid tags.");
+                        return false;
+                    }
+                    QString display = e2.attribute("display");
+                    QString data    = e2.attribute("data");
+                    if (data.isEmpty())
+                    {
+                        VERBOSE(VB_IMPORTANT, LOC +
+                                "Setting selection item missing data.");
+                        return false;
+                    }
+                    display = (display.isEmpty()) ? data : display;
+                    data_list.push_back(data);
+                    display_list.push_back(display);
+
+                    n2 = n2.nextSibling();
+                }
+            }
+
+            if (MythSetting::kIntegerRange == dtype)
+            {
+                m["range_min"] = e.attribute("range_min");
+                m["range_max"] = e.attribute("range_max");
+            }
+
+            QMap<QString,QString>::const_iterator it = m.begin();
+            for (; it != m.end(); ++it)
+            {
+                if ((*it).isEmpty())
+                {
+                    VERBOSE(VB_IMPORTANT, LOC +
+                            QString("Setting has invalid or missing "
+                                    "%1 attribute")
+                            .arg(it.key()));
+                    return false;
+                }
+            }
+
+            m["default_data"] = e.attribute("default_data");
+
+            MythSetting::SettingType stype =
+                parse_setting_type(m["setting_type"]);
+            if (MythSetting::kInvalidSettingType == stype)
+            {
+                VERBOSE(VB_IMPORTANT, LOC +
+                        "Setting has invalid setting_type attribute.");
+                return false;
+            }
+
+            long long range_min = m["range_min"].toLongLong();
+            long long range_max = m["range_max"].toLongLong();
+            if (range_max < range_min)
+            {
+                VERBOSE(VB_IMPORTANT, LOC +
+                        "Setting has invalid range attributes");
+                return false;
+            }
+
+            MythSetting *s = new MythSetting(
+                m["value"], m["default_data"], stype,
+                m["label"], m["help_text"], dtype,
+                data_list, display_list, range_min, range_max);
+
+            settings.push_back(s);
+        }
+        else
+        {
+            VERBOSE(VB_IMPORTANT, LOC +
+                    QString("Unknown element: %1").arg(e.tagName()));
+            return false;
+        }
+        n = n.nextSibling();
+    }
+    return true;
+#undef LOC
+}
+
+bool parse_settings(MythSettingList &settings, const QString &filename)
+{
+    QDomDocument doc;
+    QFile f(filename);
+
+    if (!f.open(QIODevice::ReadOnly))
+    {
+        VERBOSE(VB_IMPORTANT, QString("parse_settings: Can't open: '%1'")
+                .arg(filename));
+        return false;
+    }
+
+    QString errorMsg;
+    int errorLine = 0;
+    int errorColumn = 0;
+
+    if (!doc.setContent(&f, false, &errorMsg, &errorLine, &errorColumn))
+    {
+        VERBOSE(VB_IMPORTANT, QString("parse_settings: ") +
+                QString("Parsing: %1 at line: %2 column: %3")
+                .arg(filename).arg(errorLine).arg(errorColumn) +
+                QString("\n\t\t\t%1").arg(errorMsg));
+        f.close();
+        return false;
+    }
+    f.close();
+
+    settings.clear();
+    return parse_dom(settings, doc.documentElement(), filename);
+}
+
+bool load_settings(MythSettingList &settings, const QString &hostname)
+{
+    MSqlQuery query(MSqlQuery::InitCon());
+
+    QString list = extract_query_list(settings, MythSetting::kFile);
+    if (!list.isEmpty())
+    {
+        DatabaseParams params;
+        bool ok = MythDB::LoadDatabaseParamsFromDisk(params, true);
+        if (!ok)
+            return false;
+
+        QMap<QString,QString> map;
+        map["host"]                = params.dbHostName;
+        map["port"] = QString::number(params.dbPort);
+        map["ping"] = QString::number(params.dbHostPing);
+        map["database"]            = params.dbName;
+        map["user"]                = params.dbUserName;
+        map["password"]            = params.dbPassword;
+        map["uniqueid"]            = params.localHostName;
+        map["wol_enabled"]         =
+            QString::number(params.wolEnabled);
+        map["wol_reconnect_count"] =
+            QString::number(params.wolReconnect);
+        map["wol_retry_count "]    =
+            QString::number(params.wolRetry);
+        map["wol_command"]         = params.wolCommand;
+
+        MythSettingList::const_iterator it = settings.begin();
+        for (; it != settings.end(); ++it)
+            fill_setting(*it, map, MythSetting::kFile);
+    }
+
+    list = extract_query_list(settings, MythSetting::kHost);
+    QString qstr =
+        "SELECT value, data "
+        "FROM settings "
+        "WHERE hostname = '" + hostname + "' AND "
+        "      value in (" + list + ")";
+
+    if (!list.isEmpty())
+    {
+        if (!query.exec(qstr))
+        {
+            MythDB::DBError("HttpConfig::LoadMythSettings() 1", query);
+            return false;
+        }
+        fill_settings(settings, query, MythSetting::kHost);
+    }
+
+    list = extract_query_list(settings, MythSetting::kGlobal);
+    qstr =
+        "SELECT value, data "
+        "FROM settings "
+        "WHERE hostname IS NULL AND "
+        "      value in (" + list + ")";
+    
+    if (!list.isEmpty())
+    {
+        if (!query.exec(qstr))
+        {
+            MythDB::DBError("HttpConfig::LoadMythSettings() 2", query);
+            return false;
+        }
+        fill_settings(settings, query, MythSetting::kGlobal);
+    }
+
+    return true;
+}
+

programs/mythbackend/moc_server.cpp

@@ +1 @@
+/****************************************************************************
+** Meta object code from reading C++ file 'server.h'
+**
+** Created: Sun Mar 28 11:53:37 2010
+**      by: The Qt Meta Object Compiler version 61 (Qt 4.5.2)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#include "server.h"
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#error "The header file 'server.h' doesn't include <QObject>."
+#elif Q_MOC_OUTPUT_REVISION != 61
+#error "This file was generated using the moc from 4.5.2. It"
+#error "cannot be used with the include files from this version of Qt."
+#error "(The moc has changed too much.)"
+#endif
+
+QT_BEGIN_MOC_NAMESPACE
+static const uint qt_meta_data_MythServer[] = {
+
+ // content:
+       2,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       1,   12, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+
+ // signals: signature, parameters, type, tag, flags
+      12,   11,   11,   11, 0x05,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_MythServer[] = {
+    "MythServer\0\0newConnect(MythSocket*)\0"
+};
+
+const QMetaObject MythServer::staticMetaObject = {
+    { &QTcpServer::staticMetaObject, qt_meta_stringdata_MythServer,
+      qt_meta_data_MythServer, 0 }
+};
+
+const QMetaObject *MythServer::metaObject() const
+{
+    return &staticMetaObject;
+}
+
+void *MythServer::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_MythServer))
+        return static_cast<void*>(const_cast< MythServer*>(this));
+    return QTcpServer::qt_metacast(_clname);
+}
+
+int MythServer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QTcpServer::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        switch (_id) {
+        case 0: newConnect((*reinterpret_cast< MythSocket*(*)>(_a[1]))); break;
+        default: ;
+        }
+        _id -= 1;
+    }
+    return _id;
+}
+
+// SIGNAL 0
+void MythServer::newConnect(MythSocket * _t1)
+{
+    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
+    QMetaObject::activate(this, &staticMetaObject, 0, _a);
+}
+QT_END_MOC_NAMESPACE

programs/mythbackend/httpconfig.cpp

@@ +1 @@
+// Qt headers
+#include <QTextStream>
+
+// MythTV headers
+#include "httpconfig.h"
+#include "backendutil.h"
+#include "mythxml.h"
+
+#include "mythcontext.h"
+#include "mythdb.h"
+
+HttpConfig::HttpConfig() : HttpServerExtension("HttpConfig", QString())
+{
+}
+
+HttpConfig::~HttpConfig()
+{
+}
+
+bool HttpConfig::ProcessRequest(HttpWorkerThread*, HTTPRequest *request)
+{
+    if (!request)
+        return false;
+
+    if (request->m_sBaseUrl != "/" && request->m_sBaseUrl != "/config")
+        return false;
+
+    bool handled = false;
+    if ((request->m_sMethod.toLower() == "config") || (NULL == gContext))
+    {
+        PrintHeader(request->m_response);
+        ParseDatabaseSettings();
+        load_settings(database_settings, "");
+        PrintSettings(request->m_response, database_settings);
+        PrintFooter(request->m_response);
+        handled = true;
+    }
+    else if (request->m_sMethod.toLower() == "general")
+    {
+        PrintHeader(request->m_response);
+        parse_settings(general_settings, "/home/danielk/settings.xml");
+        load_settings(general_settings, gContext->GetHostName());
+        PrintSettings(request->m_response, general_settings);
+        PrintFooter(request->m_response);
+        handled = true;
+    }
+    else if (request->m_sMethod.toLower() == "parsed")
+    {
+        PrintHeader(request->m_response);
+        parse_settings(general_settings, "/home/danielk/settings.xml");
+        load_settings(general_settings, gContext->GetHostName());
+        PrintSettings(request->m_response, general_settings);
+        PrintFooter(request->m_response);
+        handled = true;
+    }
+
+    if (handled)
+    {
+        request->m_eResponseType = ResponseTypeHTML;
+        request->m_mapRespHeaders[ "Cache-Control" ] =
+            "no-cache=\"Ext\", max-age = 0";
+    }
+
+    return handled;
+}
+
+void HttpConfig::PrintHeader(QTextStream &os)
+{
+    os.setCodec("UTF-8");
+
+    os << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" "
+       << "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\r\n"
+       << "<html xmlns=\"http://www.w3.org/1999/xhtml\""
+       << " xml:lang=\"en\" lang=\"en\">\r\n"
+       << "<head>\r\n"
+       << "  <meta http-equiv=\"Content-Type\""
+       << "content=\"text/html; charset=UTF-8\" />\r\n"
+       << "  <style type=\"text/css\" title=\"Default\" media=\"all\">\r\n"
+       << "  body {\r\n"
+       << "    background-color:#fff;\r\n"
+       << "    font:11px verdana, arial, helvetica, sans-serif;\r\n"
+       << "    margin:20px;\r\n"
+       << "  }\r\n"
+       << "  h1 {\r\n"
+       << "    font-size:28px;\r\n"
+       << "    font-weight:900;\r\n"
+       << "    color:#ccc;\r\n"
+       << "    letter-spacing:0.5em;\r\n"
+       << "    margin-bottom:30px;\r\n"
+       << "    width:650px;\r\n"
+       << "    text-align:center;\r\n"
+       << "  }\r\n"
+       << "  h2 {\r\n"
+       << "    font-size:18px;\r\n"
+       << "    font-weight:800;\r\n"
+       << "    color:#360;\r\n"
+       << "    border:none;\r\n"
+       << "    letter-spacing:0.3em;\r\n"
+       << "    padding:0px;\r\n"
+       << "    margin-bottom:10px;\r\n"
+       << "    margin-top:0px;\r\n"
+       << "  }\r\n"
+       << "  h3 {\r\n"
+       << "    font-size:14px;\r\n"
+       << "    font-weight:800;\r\n"
+       << "    color:#360;\r\n"
+       << "    border:none;\r\n"
+       << "    letter-spacing:0.3em;\r\n"
+       << "    padding:0px;\r\n"
+       << "    margin-bottom:10px;\r\n"
+       << "    margin-top:0px;\r\n"
+       << "  }\r\n"
+       << "  </style>\r\n"
+       << "  <title>MythTV Config</title>"
+       << "</head>\r\n"
+       << "<body>\r\n\r\n"
+       << "  <h1>MythTV Configuration</h1>\r\n"
+       << "  <form>\r\n";
+}
+
+void HttpConfig::PrintFooter(QTextStream &os)
+{
+    os << "  </form>\r\n"
+       << "\r\n</body>\r\n</html>\r\n";
+}
+
+void HttpConfig::ParseDatabaseSettings(void)
+{
+    database_settings.clear();
+
+    MythSettingGroup *database =
+        new MythSettingGroup(QObject::tr("Database Setup"), "database");
+
+    database->settings.push_back(
+        new MythSetting(
+            "host", "localhost",
+            MythSetting::kFile, QObject::tr("Host"),
+            QObject::tr(
+                "DNS name or IP of server containing database or "
+                "'localhost' which will connect to the server using "
+                "a unix pipe."),
+            MythSetting::kString));
+    
+    database->settings.push_back(
+        new MythSetting(
+            "port", "3306", MythSetting::kFile, QObject::tr("Port"),
+            QObject::tr(
+                "Port on which the remote database server listens."),
+            MythSetting::kIntegerRange, 0, 0xffff));
+
+    database->settings.push_back(
+        new MythSetting(
+            "ping", "1", MythSetting::kFile, QObject::tr("Ping"),
+            QObject::tr("Ping the remote server."),
+            MythSetting::kCheckBox));
+
+    database->settings.push_back(
+        new MythSetting(
+            "database", "mythconverg",
+            MythSetting::kFile, QObject::tr("Database"),
+            QObject::tr("Database containing MythTV tables."),
+            MythSetting::kString));
+
+    database->settings.push_back(
+        new MythSetting(
+            "user", "mythtv",
+            MythSetting::kFile, QObject::tr("User"),
+            QObject::tr("Database user name with read and write "
+                        "access to MythTV tables"),
+            MythSetting::kString));
+
+    database->settings.push_back(
+        new MythSetting(
+            "password", "mythtv",
+            MythSetting::kFile, QObject::tr("Password"),
+            QObject::tr("Password for database user."),
+            MythSetting::kString));
+
+    MythSettingGroup *database_wol =
+        new MythSettingGroup(QObject::tr("Database Wake on LAN"), "database_wol");
+
+    database_wol->settings.push_back(
+        new MythSetting(
+            "wol_enabled", "1", MythSetting::kFile, QObject::tr("Enabled"),
+            "",
+            MythSetting::kCheckBox));
+
+    database_wol->settings.push_back(
+        new MythSetting(
+            "wol_reconnect_count", "0", MythSetting::kFile,
+            QObject::tr("Reconnect Count"),
+            "",
+            MythSetting::kIntegerRange, 0, 10));
+
+    database_wol->settings.push_back(
+        new MythSetting(
+            "wol_retry_count", "5", MythSetting::kFile,
+            QObject::tr("Retry Count"),
+            "",
+            MythSetting::kIntegerRange, 0, 10));
+
+    database_wol->settings.push_back(
+        new MythSetting(
+            "wol_command", "echo 'WOLsqlServerCommand not set'",
+            MythSetting::kFile, QObject::tr("Command"), "",
+            MythSetting::kString));
+
+    database->settings.push_back(database_wol);
+
+    database_settings.push_back(database);
+}
+
+void HttpConfig::PrintSettings(QTextStream &os, const MythSettingList &settings)
+{
+    MythSettingList::const_iterator it = settings.begin();
+    for (; it != settings.end(); ++it)
+        os << (*it)->ToHTML(1);
+}

programs/mythbackend/main_helpers.cpp

@@ +1 @@
+// POSIX headers
+#include <sys/time.h>     // for setpriority
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <libgen.h>
+#include <signal.h>
+#include <pwd.h>
+
+#include "mythconfig.h"
+#if CONFIG_DARWIN
+    #include <sys/aio.h>    // O_SYNC
+#endif
+
+// C headers
+#include <cstdlib>
+#include <cerrno>
+
+#include <QCoreApplication>
+#include <QFileInfo>
+#include <QRegExp>
+#include <QFile>
+#include <QDir>
+#include <QMap>
+
+#include "tv_rec.h"
+#include "scheduledrecording.h"
+#include "autoexpire.h"
+#include "scheduler.h"
+#include "mainserver.h"
+#include "encoderlink.h"
+#include "remoteutil.h"
+#include "housekeeper.h"
+
+#include "mythcontext.h"
+#include "mythverbose.h"
+#include "mythversion.h"
+#include "mythdb.h"
+#include "exitcodes.h"
+#include "compat.h"
+#include "storagegroup.h"
+#include "programinfo.h"
+#include "dbcheck.h"
+#include "jobqueue.h"
+#include "previewgenerator.h"
+#include "mythcommandlineparser.h"
+#include "mythsystemevent.h"
+#include "main_helpers.h"
+#include "backendcontext.h"
+
+#include "mediaserver.h"
+#include "httpstatus.h"
+
+#define LOC      QString("MythBackend: ")
+#define LOC_WARN QString("MythBackend, Warning: ")
+#define LOC_ERR  QString("MythBackend, Error: ")
+
+bool setupTVs(bool ismaster, bool &error)
+{
+    error = false;
+    QString localhostname = gContext->GetHostName();
+
+    MSqlQuery query(MSqlQuery::InitCon());
+
+    if (ismaster)
+    {
+        // Hack to make sure recorded.basename gets set if the user
+        // downgrades to a prior version and creates new entries
+        // without it.
+        if (!query.exec("UPDATE recorded SET basename = CONCAT(chanid, '_', "
+                        "DATE_FORMAT(starttime, '%Y%m%d%H%i00'), '_', "
+                        "DATE_FORMAT(endtime, '%Y%m%d%H%i00'), '.nuv') "
+                        "WHERE basename = '';"))
+            MythDB::DBError("Updating record basename",
+                                 query.lastQuery());
+
+        // Hack to make sure record.station gets set if the user
+        // downgrades to a prior version and creates new entries
+        // without it.
+        if (!query.exec("UPDATE channel SET callsign=chanid "
+                        "WHERE callsign IS NULL OR callsign='';"))
+            MythDB::DBError("Updating channel callsign", query.lastQuery());
+
+        if (query.exec("SELECT MIN(chanid) FROM channel;"))
+        {
+            query.first();
+            int min_chanid = query.value(0).toInt();
+            if (!query.exec(QString("UPDATE record SET chanid = %1 "
+                                    "WHERE chanid IS NULL;").arg(min_chanid)))
+                MythDB::DBError("Updating record chanid", query.lastQuery());
+        }
+        else
+            MythDB::DBError("Querying minimum chanid", query.lastQuery());
+
+        MSqlQuery records_without_station(MSqlQuery::InitCon());
+        records_without_station.prepare("SELECT record.chanid,"
+                " channel.callsign FROM record LEFT JOIN channel"
+                " ON record.chanid = channel.chanid WHERE record.station='';");
+        if (records_without_station.exec() && records_without_station.next())
+        {
+            MSqlQuery update_record(MSqlQuery::InitCon());
+            update_record.prepare("UPDATE record SET station = :CALLSIGN"
+                    " WHERE chanid = :CHANID;");
+            do
+            {
+                update_record.bindValue(":CALLSIGN",
+                        records_without_station.value(1));
+                update_record.bindValue(":CHANID",
+                        records_without_station.value(0));
+                if (!update_record.exec())
+                {
+                    MythDB::DBError("Updating record station",
+                            update_record.lastQuery());
+                }
+            } while (records_without_station.next());
+        }
+    }
+
+    if (!query.exec(
+            "SELECT cardid, hostname "
+            "FROM capturecard "
+            "ORDER BY cardid"))
+    {
+        MythDB::DBError("Querying Recorders", query);
+        return false;
+    }
+
+    vector<uint>    cardids;
+    vector<QString> hosts;
+    while (query.next())
+    {
+        uint    cardid = query.value(0).toUInt();
+        QString host   = query.value(1).toString();
+        QString cidmsg = QString("Card %1").arg(cardid);
+
+        if (host.isEmpty())
+        {
+            QString msg = cidmsg + " does not have a hostname defined.\n"
+                "Please run setup and confirm all of the capture cards.\n";
+
+            VERBOSE(VB_IMPORTANT, msg);
+            gContext->LogEntry("mythbackend", LP_CRITICAL,
+                               "Problem with capture cards", msg);
+            continue;
+        }
+
+        cardids.push_back(cardid);
+        hosts.push_back(host);
+    }
+
+    for (uint i = 0; i < cardids.size(); i++)
+    {
+        if (hosts[i] == localhostname)
+            new TVRec(cardids[i]);
+    }
+
+    for (uint i = 0; i < cardids.size(); i++)
+    {
+        uint    cardid = cardids[i];
+        QString host   = hosts[i];
+        QString cidmsg = QString("Card %1").arg(cardid);
+
+        if (!ismaster)
+        {
+            if (host == localhostname)
+            {
+                TVRec *tv = TVRec::GetTVRec(cardid);
+                if (tv->Init())
+                {
+                    EncoderLink *enc = new EncoderLink(cardid, tv);
+                    tvList[cardid] = enc;
+                }
+                else
+                {
+                    gContext->LogEntry("mythbackend", LP_CRITICAL,
+                                       "Problem with capture cards",
+                                       cidmsg + " failed init");
+                    delete tv;
+                    // The master assumes card comes up so we need to
+                    // set error and exit if a non-master card fails.
+                    error = true;
+                }
+            }
+        }
+        else
+        {
+            if (host == localhostname)
+            {
+                TVRec *tv = TVRec::GetTVRec(cardid);
+                if (tv->Init())
+                {
+                    EncoderLink *enc = new EncoderLink(cardid, tv);
+                    tvList[cardid] = enc;
+                }
+                else
+                {
+                    gContext->LogEntry("mythbackend", LP_CRITICAL,
+                                       "Problem with capture cards",
+                                       cidmsg + "failed init");
+                    delete tv;
+                }
+            }
+            else
+            {
+                EncoderLink *enc = new EncoderLink(cardid, NULL, host);
+                tvList[cardid] = enc;
+            }
+        }
+    }
+
+    if (tvList.empty())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                "No valid capture cards are defined in the database.\n\t\t\t"
+                "Perhaps you should re-read the installation instructions?");
+
+        gContext->LogEntry("mythbackend", LP_CRITICAL,
+                           "No capture cards are defined",
+                           "Please run the setup program.");
+        return false;
+    }
+
+    return true;
+}
+
+bool setup_context(const MythCommandLineParser &cmdline)
+{
+    if (!gContext->Init(false))
+    {
+        VERBOSE(VB_IMPORTANT, "Failed to init MythContext.");
+        delete gContext;
+        gContext = NULL;
+        return false;
+    }
+    gContext->SetBackend(!cmdline.HasBackendCommand());
+
+    QMap<QString,QString> settingsOverride = cmdline.GetSettingsOverride();
+    if (settingsOverride.size())
+    {
+        QMap<QString, QString>::iterator it;
+        for (it = settingsOverride.begin(); it != settingsOverride.end(); ++it)
+        {
+            VERBOSE(VB_IMPORTANT, QString("Setting '%1' being forced to '%2'")
+                    .arg(it.key()).arg(*it));
+            gContext->OverrideSettingForSession(it.key(), *it);
+        }
+    }
+
+    return true;
+}
+
+void cleanup(void)
+{
+    delete sched;
+    sched = NULL;
+
+    delete g_pUPnp;
+    g_pUPnp = NULL;
+
+    delete gContext;
+    gContext = NULL;
+
+    if (pidfile.size())
+    {
+        unlink(pidfile.toAscii().constData());
+        pidfile.clear();
+    }
+
+    signal(SIGHUP, SIG_DFL);
+    signal(SIGUSR1, SIG_DFL);
+}
+
+int log_rotate(int report_error)
+{
+    /* http://www.gossamer-threads.com/lists/mythtv/dev/110113 */
+
+    int new_logfd = open(logfile.toLocal8Bit().constData(),
+                         O_WRONLY|O_CREAT|O_APPEND|O_SYNC, 0664);
+    if (new_logfd < 0)
+    {
+        // If we can't open the new logfile, send data to /dev/null
+        if (report_error)
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR +
+                    QString("Cannot open logfile '%1'").arg(logfile));
+            return -1;
+        }
+        new_logfd = open("/dev/null", O_WRONLY);
+        if (new_logfd < 0)
+        {
+            // There's not much we can do, so punt.
+            return -1;
+        }
+    }
+    while (dup2(new_logfd, 1) < 0 && errno == EINTR) ;
+    while (dup2(new_logfd, 2) < 0 && errno == EINTR) ;
+    while (close(new_logfd) < 0 && errno == EINTR) ;
+    return 0;
+}
+
+void log_rotate_handler(int)
+{
+    log_rotate(0);
+}
+
+void upnp_rebuild(int)
+{
+    if (gContext->IsMasterHost())
+    {
+        g_pUPnp->RebuildMediaMap();
+    }
+
+}
+
+int preview_helper(const QString &chanid, const QString &starttime,
+                   long long previewFrameNumber, long long previewSeconds,
+                   const QSize &previewSize,
+                   const QString &infile, const QString &outfile)
+{
+    // Lower scheduling priority, to avoid problems with recordings.
+    if (setpriority(PRIO_PROCESS, 0, 9))
+        VERBOSE(VB_GENERAL, "Setting priority failed." + ENO);
+
+    ProgramInfo *pginfo = NULL;
+    if (!chanid.isEmpty() && !starttime.isEmpty())
+    {
+        pginfo = ProgramInfo::GetProgramFromRecorded(chanid, starttime);
+        if (!pginfo)
+        {
+            VERBOSE(VB_IMPORTANT, QString(
+                        "Can not locate recording made on '%1' at '%2'")
+                    .arg(chanid).arg(starttime));
+            return GENERIC_EXIT_NOT_OK;
+        }
+        pginfo->pathname = pginfo->GetPlaybackURL(false, true);
+    }
+    else if (!infile.isEmpty())
+    {
+        pginfo = ProgramInfo::GetProgramFromBasename(infile);
+        if (!pginfo)
+        {
+            if (!QFileInfo(infile).exists())
+            {
+                VERBOSE(VB_IMPORTANT, QString(
+                            "Can not locate recording '%1'").arg(infile));
+                return GENERIC_EXIT_NOT_OK;
+            }
+            else
+            {
+                pginfo = new ProgramInfo();
+                pginfo->isVideo = true;
+
+                QDir d(infile + "/VIDEO_TS");
+                if ((infile.section('.', -1) == "iso") ||
+                    (infile.section('.', -1) == "img") ||
+                    d.exists())
+                {
+                    pginfo->pathname = QString("dvd:%1").arg(infile);
+                }
+                else
+                {
+                    pginfo->pathname = QFileInfo(infile).absoluteFilePath();
+                }
+            }
+
+        }
+        else
+        {
+            pginfo->pathname = pginfo->GetPlaybackURL(false, true);
+        }
+    }
+    else
+    {
+        VERBOSE(VB_IMPORTANT, "Can not locate recording for preview");
+        return GENERIC_EXIT_NOT_OK;
+    }
+
+    PreviewGenerator *previewgen = new PreviewGenerator(
+        pginfo, PreviewGenerator::kLocal);
+
+    if (previewFrameNumber >= 0)
+        previewgen->SetPreviewTimeAsFrameNumber(previewFrameNumber);
+
+    if (previewSeconds >= 0)
+        previewgen->SetPreviewTimeAsSeconds(previewSeconds);
+
+    previewgen->SetOutputSize(previewSize);
+    previewgen->SetOutputFilename(outfile);
+    bool ok = previewgen->RunReal();
+    previewgen->deleteLater();
+
+    delete pginfo;
+
+    return (ok) ? GENERIC_EXIT_OK : GENERIC_EXIT_NOT_OK;
+}
+
+void showUsage(const MythCommandLineParser &cmdlineparser, const QString &version)
+{
+    QString    help  = cmdlineparser.GetHelpString(false);
+    QByteArray ahelp = help.toLocal8Bit();
+
+    cerr << qPrintable(version) << endl <<
+    "Valid options are: " << endl <<
+    "-h or --help                   List valid command line parameters" << endl <<
+    "-l or --logfile filename       Writes STDERR and STDOUT messages to filename" << endl <<
+    "-p or --pidfile filename       Write PID of mythbackend to filename" << endl <<
+    "-d or --daemon                 Runs mythbackend as a daemon" << endl <<
+    "-v or --verbose debug-level    Use '-v help' for level info" << endl <<
+    "--setverbose debug-level       Change debug level of running master backend" << endl <<
+    "--user username                Drop permissions to username after starting"  << endl <<
+
+    "--printexpire                  List of auto-expire programs" << endl <<
+    "--printsched                   Upcoming scheduled programs" << endl <<
+    "--testsched                    Test run scheduler (ignore existing schedule)" << endl <<
+    "--resched                      Force the scheduler to update" << endl <<
+    "--nosched                      Do not perform any scheduling" << endl <<
+    "--noupnp                       Do not enable the UPNP server" << endl <<
+    "--nojobqueue                   Do not start the JobQueue" << endl <<
+    "--nohousekeeper                Do not start the Housekeeper" << endl <<
+    "--noautoexpire                 Do not start the AutoExpire thread" << endl <<
+    "--clearcache                   Clear the settings cache on all myth servers" << endl <<
+    ahelp.constData() <<
+    "--generate-preview             Generate a preview image" << endl <<
+    "--upnprebuild                  Force an update of UPNP media" << endl <<
+    "--infile                       Input file for preview generation" << endl <<
+    "--outfile                      Optional output file for preview generation" << endl <<
+    "--chanid                       Channel ID for preview generation" << endl <<
+    "--starttime                    Recording start time for preview generation" << endl <<
+    "--event EVENTTEXT              Send a backend event test message" << endl <<
+    "--systemevent EVENTTEXT        Send a backend SYSTEM_EVENT test message" << endl
+    << endl;
+
+}
+
+void setupLogfile(void)
+{
+    if (!logfile.isEmpty())
+    {
+        if (log_rotate(1) < 0)
+        {
+            VERBOSE(VB_IMPORTANT, LOC_WARN +
+                    "Cannot open logfile; using stdout/stderr instead");
+        }
+        else
+            signal(SIGHUP, &log_rotate_handler);
+    }
+}
+
+bool openPidfile(ofstream &pidfs, const QString &pidfile)
+{
+    if (!pidfile.isEmpty())
+    {
+        pidfs.open(pidfile.toAscii().constData());
+        if (!pidfs)
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR +
+                    "Could not open pid file" + ENO);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool setUser(const QString &username)
+{
+    if (username.isEmpty())
+        return true;
+
+    struct passwd *user_info = getpwnam(username.toLocal8Bit().constData());
+    const uid_t user_id = geteuid();
+
+    if (user_id && (!user_info || user_id != user_info->pw_uid))
+    {
+        VERBOSE(VB_IMPORTANT,
+                "You must be running as root to use the --user switch.");
+        return false;
+    }
+    else if (user_info && user_id == user_info->pw_uid)
+    {
+        VERBOSE(VB_IMPORTANT,
+                QString("Already running as '%1'").arg(username));
+    }
+    else if (!user_id && user_info)
+    {
+        if (setenv("HOME", user_info->pw_dir,1) == -1)
+        {
+            VERBOSE(VB_IMPORTANT, "Error setting home directory.");
+            return false;
+        }
+        if (setgid(user_info->pw_gid) == -1)
+        {
+            VERBOSE(VB_IMPORTANT, "Error setting effective group.");
+            return false;
+        }
+        if (setuid(user_info->pw_uid) == -1)
+        {
+            VERBOSE(VB_IMPORTANT, "Error setting effective user.");
+            return false;
+        }
+    }
+    else
+    {
+        VERBOSE(VB_IMPORTANT,
+                QString("Invalid user '%1' specified with --user")
+                .arg(username));
+        return false;
+    }
+    return true;
+}
+
+int handle_command(const MythCommandLineParser &cmdline)
+{
+    QString eventString = cmdline.GetEventString();
+    if (!eventString.isEmpty())
+    {
+        if (gContext->ConnectToMasterServer())
+        {
+            if (eventString.startsWith("SYSTEM_EVENT"))
+            {
+                eventString += QString(" SENDER %1")
+                    .arg(gContext->GetHostName());
+            }
+
+            RemoteSendMessage(eventString);
+            return BACKEND_EXIT_OK;
+        }
+        return BACKEND_EXIT_NO_MYTHCONTEXT;
+    }
+
+    if (cmdline.WantUPnPRebuild())
+    {
+        VERBOSE(VB_GENERAL, "Rebuilding UPNP Media Map");
+
+        UPnpMedia *rebuildit = new UPnpMedia(false,false);
+        rebuildit->BuildMediaMap();
+
+        return BACKEND_EXIT_OK;
+    }
+
+    if (cmdline.SetVerbose())
+    {
+        if (gContext->ConnectToMasterServer())
+        {
+            QString message = "SET_VERBOSE ";
+            message += cmdline.GetNewVerbose();
+
+            RemoteSendMessage(message);
+            VERBOSE(VB_IMPORTANT, QString("Sent '%1' message").arg(message));
+            return BACKEND_EXIT_OK;
+        }
+        else
+        {
+            VERBOSE(VB_IMPORTANT,
+                    "Unable to connect to backend, verbose level unchanged ");
+            return BACKEND_EXIT_NO_CONNECT;
+        }
+    }
+
+    if (cmdline.ClearSettingsCache())
+    {
+        if (gContext->ConnectToMasterServer())
+        {
+            RemoteSendMessage("CLEAR_SETTINGS_CACHE");
+            VERBOSE(VB_IMPORTANT, "Sent CLEAR_SETTINGS_CACHE message");
+            return BACKEND_EXIT_OK;
+        }
+        else
+        {
+            VERBOSE(VB_IMPORTANT, "Unable to connect to backend, settings "
+                    "cache will not be cleared.");
+            return BACKEND_EXIT_NO_CONNECT;
+        }
+    }
+
+    if (cmdline.IsPrintScheduleEnabled() ||
+        cmdline.IsTestSchedulerEnabled())
+    {
+        sched = new Scheduler(false, &tvList);
+        if (!cmdline.IsTestSchedulerEnabled() &&
+            gContext->ConnectToMasterServer())
+        {
+            cout << "Retrieving Schedule from Master backend.\n";
+            sched->FillRecordListFromMaster();
+        }
+        else
+        {
+            cout << "Calculating Schedule from database.\n" <<
+                    "Inputs, Card IDs, and Conflict info may be invalid "
+                    "if you have multiple tuners.\n";
+            sched->FillRecordListFromDB();
+        }
+
+        print_verbose_messages |= VB_SCHEDULE;
+        sched->PrintList(true);
+        return BACKEND_EXIT_OK;
+    }
+
+    if (cmdline.Reschedule())
+    {
+        bool ok = false;
+        if (gContext->ConnectToMasterServer())
+        {
+            VERBOSE(VB_IMPORTANT, "Connected to master for reschedule");
+            ScheduledRecording::signalChange(-1);
+            ok = true;
+        }
+        else
+            VERBOSE(VB_IMPORTANT, "Cannot connect to master for reschedule");
+
+        return (ok) ? BACKEND_EXIT_OK : BACKEND_EXIT_NO_CONNECT;
+    }
+
+    if (!cmdline.GetPrintExpire().isEmpty())
+    {
+        expirer = new AutoExpire();
+        expirer->PrintExpireList(cmdline.GetPrintExpire());
+        return BACKEND_EXIT_OK;
+    }
+
+    if ((cmdline.GetPreviewFrameNumber() >= -1) ||
+        (cmdline.GetPreviewSeconds() >= -1))
+    {
+        int ret = preview_helper(
+            QString::number(cmdline.GetChanID()),
+            cmdline.GetStartTime().toString(Qt::ISODate),
+            cmdline.GetPreviewFrameNumber(), cmdline.GetPreviewSeconds(),
+            cmdline.GetPreviewSize(),
+            cmdline.GetInputFilename(), cmdline.GetOutputFilename());
+        return ret;
+    }
+
+    // This should never actually be reached..
+    return BACKEND_EXIT_OK;
+}
+
+int connect_to_master(void)
+{
+    MythSocket *tempMonitorConnection = new MythSocket();
+    if (tempMonitorConnection->connect(
+            gContext->GetSetting("MasterServerIP", "127.0.0.1"),
+            gContext->GetNumSetting("MasterServerPort", 6543)))
+    {
+        if (!gContext->CheckProtoVersion(tempMonitorConnection))
+        {
+            VERBOSE(VB_IMPORTANT, "Master backend is incompatible with "
+                    "this backend.\nCannot become a slave.");
+            return BACKEND_EXIT_NO_CONNECT;
+        }
+
+        QStringList tempMonitorDone("DONE");
+
+        QStringList tempMonitorAnnounce("ANN Monitor tzcheck 0");
+        tempMonitorConnection->writeStringList(tempMonitorAnnounce);
+        tempMonitorConnection->readStringList(tempMonitorAnnounce);
+        if (tempMonitorAnnounce.empty() ||
+            tempMonitorAnnounce[0] == "ERROR")
+        {
+            tempMonitorConnection->DownRef();
+            tempMonitorConnection = NULL;
+            if (tempMonitorAnnounce.empty())
+            {
+                VERBOSE(VB_IMPORTANT, LOC_ERR +
+                        "Failed to open event socket, timeout");
+            }
+            else
+            {
+                VERBOSE(VB_IMPORTANT, LOC_ERR +
+                        "Failed to open event socket" +
+                        ((tempMonitorAnnounce.size() >= 2) ?
+                         QString(", error was %1").arg(tempMonitorAnnounce[1]) :
+                         QString(", remote error")));
+            }
+        }
+
+        QStringList tzCheck("QUERY_TIME_ZONE");
+        if (tempMonitorConnection)
+        {
+            tempMonitorConnection->writeStringList(tzCheck);
+            tempMonitorConnection->readStringList(tzCheck);
+        }
+        if (tzCheck.size() && !checkTimeZone(tzCheck))
+        {
+            // Check for different time zones, different offsets, different
+            // times
+            VERBOSE(VB_IMPORTANT, "The time and/or time zone settings on "
+                    "this system do not match those in use on the master "
+                    "backend. Please ensure all frontend and backend "
+                    "systems are configured to use the same time zone and "
+                    "have the current time properly set.");
+            VERBOSE(VB_IMPORTANT,
+                    "Unable to run with invalid time settings. Exiting.");
+            tempMonitorConnection->writeStringList(tempMonitorDone);
+            tempMonitorConnection->DownRef();
+            return BACKEND_EXIT_INVALID_TIMEZONE;
+        }
+        else
+        {
+            VERBOSE(VB_IMPORTANT,
+                    QString("Backend is running in %1 time zone.")
+                    .arg(getTimeZoneID()));
+        }
+        if (tempMonitorConnection)
+            tempMonitorConnection->writeStringList(tempMonitorDone);
+    }
+    if (tempMonitorConnection)
+        tempMonitorConnection->DownRef();
+
+    return BACKEND_EXIT_OK;
+}
+
+int setup_basics(const MythCommandLineParser &cmdline)
+{
+    ofstream pidfs;
+    if (!openPidfile(pidfs, cmdline.GetPIDFilename()))
+        return BACKEND_EXIT_OPENING_PIDFILE_ERROR;
+
+    if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
+        VERBOSE(VB_IMPORTANT, LOC_WARN + "Unable to ignore SIGPIPE");
+
+    if (cmdline.IsDaemonizeEnabled() && (daemon(0, 1) < 0))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to daemonize" + ENO);
+        return BACKEND_EXIT_DAEMONIZING_ERROR;
+    }
+
+    QString username = cmdline.GetUsername();
+    if (!username.isEmpty() && !setUser(username))
+        return BACKEND_EXIT_PERMISSIONS_ERROR;
+
+    if (pidfs)
+    {
+        pidfs << getpid() << endl;
+        pidfs.close();
+    }
+
+    return BACKEND_EXIT_OK;
+}
+
+void print_warnings(const MythCommandLineParser &cmdline)
+{
+    if (!cmdline.IsHouseKeeperEnabled())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                "****** The Housekeeper has been DISABLED with "
+                "the --nohousekeeper option ******");
+    }
+    if (!cmdline.IsSchedulerEnabled())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                "********** The Scheduler has been DISABLED with "
+                "the --nosched option **********");
+    }
+    if (!cmdline.IsAutoExpirerEnabled())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                "********* Auto-Expire has been DISABLED with "
+                "the --noautoexpire option ********");
+    }
+    if (!cmdline.IsJobQueueEnabled())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_WARN +
+                "********* The JobQueue has been DISABLED with "
+                "the --nojobqueue option *********");
+    }
+}
+
+int run_backend(const MythCommandLineParser &cmdline)
+{
+    if (!setup_context(cmdline))
+        return BACKEND_EXIT_NO_MYTHCONTEXT;
+
+    if (!UpgradeTVDatabaseSchema(true, true))
+    {
+        VERBOSE(VB_IMPORTANT, "Couldn't upgrade database to new schema");
+        return BACKEND_EXIT_DB_OUTOFDATE;
+    }
+
+    ///////////////////////////////////////////
+
+    bool ismaster = gContext->IsMasterHost();
+
+    g_pUPnp->Init(ismaster, cmdline.IsUPnPEnabled());
+
+    if (!ismaster)
+    {
+        int ret = connect_to_master();
+        if (BACKEND_EXIT_OK != ret)
+            return ret;
+    }
+
+    QString myip = gContext->GetSetting("BackendServerIP");
+    int     port = gContext->GetNumSetting("BackendServerPort", 6543);
+    if (myip.isEmpty())
+    {
+        cerr << "No setting found for this machine's BackendServerIP.\n"
+             << "Please run setup on this machine and modify the first page\n"
+             << "of the general settings.\n";
+        return BACKEND_EXIT_NO_IP_ADDRESS;
+    }
+
+    MythSystemEventHandler *sysEventHandler = new MythSystemEventHandler();
+
+    if (ismaster)
+    {
+        VERBOSE(VB_GENERAL, LOC + "Starting up as the master server.");
+        gContext->LogEntry("mythbackend", LP_INFO,
+                           "MythBackend started as master server", "");
+    }
+    else
+    {
+        VERBOSE(VB_GENERAL, LOC + "Running as a slave backend.");
+        gContext->LogEntry("mythbackend", LP_INFO,
+                           "MythBackend started as a slave backend", "");
+    }
+
+    bool fatal_error = false;
+    bool runsched = setupTVs(ismaster, fatal_error);
+    if (fatal_error)
+    {
+        delete sysEventHandler;
+        return BACKEND_EXIT_CAP_CARD_SETUP_ERROR;
+    }
+
+    if (ismaster)
+    {
+        if (runsched)
+        {
+            sched = new Scheduler(true, &tvList);
+            int err = sched->GetError();
+            if (err)
+                return err;
+
+            if (!cmdline.IsSchedulerEnabled())
+                sched->DisableScheduling();
+        }
+
+        if (cmdline.IsHouseKeeperEnabled())
+            housekeeping = new HouseKeeper(true, ismaster, sched);
+
+        if (!cmdline.IsAutoExpirerEnabled())
+        {
+            expirer = new AutoExpire(&tvList);
+            if (sched)
+                sched->SetExpirer(expirer);
+        }
+    }
+    else if (cmdline.IsHouseKeeperEnabled())
+    {
+        housekeeping = new HouseKeeper(true, ismaster, NULL);
+    }
+
+    if (cmdline.IsJobQueueEnabled())
+        jobqueue = new JobQueue(ismaster);
+
+    // Setup status server
+    HttpServer *pHS = g_pUPnp->GetHttpServer();
+    if (pHS)
+    {
+        VERBOSE(VB_IMPORTANT, "Main::Registering HttpStatus Extension");
+
+        pHS->RegisterExtension( new HttpStatus( &tvList, sched,
+                                                expirer, ismaster ));
+    }
+
+    if (ismaster)
+    {
+        // kill -USR1 mythbackendpid will force a upnpmedia rebuild
+        signal(SIGUSR1, &upnp_rebuild);
+    }
+
+    VERBOSE(VB_IMPORTANT, QString("Enabled verbose msgs: %1")
+            .arg(verboseString));
+
+    MainServer *mainServer = new MainServer(
+        ismaster, port, &tvList, sched, expirer);
+
+    int exitCode = mainServer->GetExitCode();
+    if (exitCode != BACKEND_EXIT_OK)
+    {
+        VERBOSE(VB_IMPORTANT, "Backend exiting, MainServer initialization "
+                "error.");
+        delete mainServer;
+        return exitCode;
+    }
+
+    StorageGroup::CheckAllStorageGroupDirs();
+
+    if (gContext->IsMasterBackend())
+        SendMythSystemEvent("MASTER_STARTED");
+
+    ///////////////////////////////
+    ///////////////////////////////
+    exitCode = qApp->exec();
+    ///////////////////////////////
+    ///////////////////////////////
+
+    if (gContext->IsMasterBackend())
+    {
+        SendMythSystemEvent("MASTER_SHUTDOWN");
+        qApp->processEvents();
+    }
+
+    gContext->LogEntry("mythbackend", LP_INFO, "MythBackend exiting", "");
+
+    delete sysEventHandler;
+    delete mainServer;
+
+    return exitCode;
+}

programs/mythbackend/mythbackend.pro

@@ -21 +21 @@
 HEADERS += autoexpire.h encoderlink.h filetransfer.h httpstatus.h mainserver.h
 HEADERS += playbacksock.h scheduler.h server.h housekeeper.h backendutil.h
 HEADERS += upnpcdstv.h upnpcdsmusic.h upnpcdsvideo.h mediaserver.h
-HEADERS += mythxml.h upnpmedia.h
+HEADERS += mythxml.h upnpmedia.h main_helpers.h backendcontext.h
+HEADERS += httpconfig.h mythsettings.h
 
 SOURCES += autoexpire.cpp encoderlink.cpp filetransfer.cpp httpstatus.cpp
 SOURCES += main.cpp mainserver.cpp playbacksock.cpp scheduler.cpp server.cpp
 SOURCES += housekeeper.cpp backendutil.cpp
 SOURCES += upnpcdstv.cpp upnpcdsmusic.cpp upnpcdsvideo.cpp mediaserver.cpp
-SOURCES += mythxml.cpp upnpmedia.cpp
+SOURCES += mythxml.cpp upnpmedia.cpp main_helpers.cpp backendcontext.cpp
+SOURCES += httpconfig.cpp mythsettings.cpp
 
 using_oss:DEFINES += USING_OSS
 

programs/mythbackend/mediaserver.h

@@ -39 +39 @@
         QString          m_sSharePath;
 
     public:
-        explicit MediaServer( bool bMaster, bool bDisableUPnp = false );
+        explicit MediaServer();
+        void Init(bool bMaster, bool bDisableUPnp = false);
 
         virtual ~MediaServer();