Ticket #5319: mythtv-5319-add_query_timezone_to_protocol-20080510.patch

libs/libmyth/util.h

@@ -47 +47 @@
 
 MPUBLIC QDateTime mythCurrentDateTime();
 MPUBLIC int calc_utc_offset(void);
+MPUBLIC QString format_utc_offset(void);
+MPUBLIC QString getTimeZoneID(void);
 
 // This is necessary for GCC 3.3, which has llabs(long long)
 // but not abs(long long) or std::llabs(long long)

libs/libmyth/util.cpp

@@ -10 +10 @@
 #include <unistd.h>
 #include <stdlib.h>
 #include <fcntl.h>
+#include <time.h>
 
 // System specific C headers
 #include "compat.h"
@@ -44 +45 @@
 #include <qfile.h>
 #include <Q3CString>
 #include <Q3DeepCopy>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
 
 // Myth headers
 #include "mythconfig.h"
@@ -95 +99 @@
     return utc_offset;
 }
 
+QString format_utc_offset(void)
+{
+    char offset[32];
+    int offset_total_seconds, offset_hours, offset_minutes;
+    QString offset_string("UNDEF");
+
+    offset_total_seconds = calc_utc_offset();
+
+    offset_hours = offset_total_seconds / 3600;
+    offset_minutes = abs((offset_total_seconds % 3600) / 60);
+
+    if (sprintf(offset, "%.2i:%.2i", offset_hours, offset_minutes) > 0)
+        offset_string = offset;
+
+    return offset_string;
+}
+
+#ifndef USING_MINGW
+/* Helper function for getSystemTimeZoneID() that compares the
+   zoneinfo_file_path (regular) file with files in the zoneinfo_dir_path until
+   it finds a match.  The matching file's name is used to determine the time
+   zone ID. */
+static QString findZoneinfoFile(QString zoneinfo_file_path,
+                                QString zoneinfo_dir_path)
+{
+    QString zone_id("UNDEF");
+    QDir zoneinfo_dir(zoneinfo_dir_path);
+    QFileInfoList dirlist = zoneinfo_dir.entryInfoList();
+    QFileInfo info;
+    QString basename;
+    QFile zoneinfo_file(zoneinfo_file_path);
+    qint64 zoneinfo_file_size = zoneinfo_file.size();
+
+    for (QFileInfoList::const_iterator it = dirlist.begin();
+         it != dirlist.end(); it++)
+    {
+        info = *it;
+         // Skip '.' and '..' and other files starting with "." and
+         // skip localtime (which is often a link to zoneinfo_file_path)
+        basename = info.baseName();
+        if (basename.isEmpty() || (basename == "localtime")) {
+            continue;
+        }
+        if (info.isDir())
+        {
+            zone_id = findZoneinfoFile(zoneinfo_file_path,
+                                       info.absoluteFilePath());
+            if (zone_id != "UNDEF")
+                return zone_id;
+        }
+        else if (info.isFile() && (info.size() == zoneinfo_file_size) &&
+                 info.isReadable())
+        {
+            // sanity check - zoneinfo files should typically be less than
+            // about 4kB, but leave room for growth
+            if (zoneinfo_file_size > 200 * 1024)
+                continue;
+            QFile this_file(info.absoluteFilePath());
+            QByteArray zoneinfo_file_data;
+            zoneinfo_file_data.resize(zoneinfo_file_size);
+            QByteArray this_file_data;
+            this_file_data.resize(zoneinfo_file_size);
+            if (zoneinfo_file.open(QIODevice::ReadOnly))
+            {
+                QDataStream in(&zoneinfo_file);
+                if (in.readRawData(zoneinfo_file_data.data(),
+                                   zoneinfo_file_size) != zoneinfo_file_size)
+                {
+                    zoneinfo_file.close();
+                    return zone_id;
+                }
+                zoneinfo_file.close();
+            }
+            if (this_file.open(QIODevice::ReadOnly))
+            {
+                QDataStream in(&this_file);
+                if (in.readRawData(this_file_data.data(),
+                                   zoneinfo_file_size) != zoneinfo_file_size)
+                {
+                    this_file.close();
+                    return zone_id;
+                }
+                this_file.close();
+            }
+            if (zoneinfo_file_data == this_file_data)
+            {
+                zone_id = info.absoluteFilePath();
+                break;
+            }
+        }
+    }
+    return zone_id;
+}
+#endif
+
+/* Helper function for getTimeZoneID() that provides an unprocessed time zone
+   id obtained using system-dependent means of identifying the system's time
+   zone. */
+static QString getSystemTimeZoneID(void)
+{
+    QString zone_id("UNDEF");
+#ifndef USING_MINGW
+    // Try to determine the time zone information by inspecting the system
+    // configuration
+    bool found = false;
+    QString time_zone_file_path("/etc/timezone");
+    QString clock_file_path("/etc/sysconfig/clock");
+    QString zoneinfo_file_path("/etc/localtime");
+    QString zoneinfo_dir_path("/usr/share/zoneinfo");
+
+    // First, check time_zone_file_path (used by Debian-based systems)
+    QFile time_zone_file(time_zone_file_path);
+    QFileInfo info(time_zone_file);
+    if (info.exists() && info.isFile() && info.isReadable())
+    {
+        if (time_zone_file.open(QIODevice::ReadOnly | QIODevice::Text))
+        {
+            QString line;
+            QTextStream in(&time_zone_file);
+            while (!in.atEnd())
+            {
+                line = in.readLine();
+                line = line.trimmed();
+                if (!line.startsWith("#"))
+                {
+                    zone_id = line;
+                    found = true;
+                    break;
+                }
+            }
+            time_zone_file.close();
+            if (found)
+                return zone_id;
+        }
+    }
+
+    // Next, look for the ZONE entry in clock_file_path (used by Red Hat-based
+    // systems)
+    QFile clock_file(clock_file_path);
+    info.setFile(clock_file);
+    if (info.exists() && info.isFile() && info.isReadable())
+    {
+        if (clock_file.open(QIODevice::ReadOnly | QIODevice::Text))
+        {
+            QString line;
+            QTextStream in(&clock_file);
+            // Handle whitespace and quotes
+            QRegExp re("^ZONE\\s*=\\s*(?:'|\")?(.+)$");
+            re.setPatternSyntax(QRegExp::RegExp2);
+            while (!in.atEnd())
+            {
+                line = in.readLine();
+                if (re.indexIn(line) != -1)
+                {
+                    zone_id = re.cap(1);
+                    found = true;
+                    break;
+                }
+            }
+            clock_file.close();
+            if (found)
+                return zone_id;
+        }
+    }
+
+    // Next check zoneinfo_file_path
+    QFile zoneinfo_file(zoneinfo_file_path);
+    info.setFile(zoneinfo_file);
+
+    if (info.exists() && info.isFile())
+    {
+        QString tz;
+        if (info.isSymLink())
+        {
+            // The symlink refers to a file whose name contains the zone ID
+            tz = info.symLinkTarget();
+        }
+        else
+        {
+            // The zoneinfo_file is a copy of the file in the
+            // zoneinfo_dir_path, so search for the same file in
+            // zoneinfo_dir_path
+            tz = findZoneinfoFile(zoneinfo_file_path, zoneinfo_dir_path);
+        }
+        if (tz != "UNDEF")
+        {
+            int pos = 0;
+            // Get the zone ID from the filename
+            // Look for the basename of zoneinfo_dir_path in case it's a
+            // relative link
+            QString zoneinfo_dirname = zoneinfo_dir_path.section('/', -1);
+            if ((pos = tz.indexOf(zoneinfo_dirname)) != -1)
+            {
+                zone_id = tz.right(tz.size() - (pos + 1) -
+                                   zoneinfo_dirname.size());
+            }
+        }
+        else
+        {
+            // If we still haven't found a time zone, try localtime_r() to at
+            // least get the zone name/abbreviation (as opposed to the
+            // identifier for the set of rules governing the zone)
+            char name[64];
+            time_t t;
+            struct tm *result = (struct tm *)malloc(sizeof(*result));
+
+            t = time(NULL);
+            localtime_r(&t, result);
+
+            if (result != NULL)
+            {
+                if (strftime(name, sizeof(name), "%Z", result) > 0)
+                    zone_id = name;
+                free(result);
+            }
+        }
+    }
+
+#endif
+    return zone_id;
+}
+
+/** \fn getTimeZoneID()
+ *  \brief Returns the zoneinfo time zone ID or as much time zone information
+ *         as possible
+ */
+QString getTimeZoneID(void)
+{
+    QString zone_id("UNDEF");
+#ifndef USING_MINGW
+    // First, try the TZ environment variable to check for environment-specific
+    // overrides
+    QString tz = getenv("TZ");
+    if (tz.isEmpty())
+    {
+        // No TZ, so attempt to determine the system-configured time zone ID
+        tz = getSystemTimeZoneID();
+    }
+
+    if (!tz.isEmpty())
+    {
+        zone_id = tz;
+        if (zone_id.startsWith("\"") || zone_id.startsWith("'"))
+                zone_id.remove(0, 1);
+        if (zone_id.endsWith("\"") || zone_id.endsWith("'"))
+                zone_id.chop(1);
+        if (zone_id.startsWith(":"))
+            zone_id.remove(0, 1);
+        // the "posix/" subdirectory typically contains the same files as the
+        // "zoneinfo/" parent directory, but are not typically what are in use
+        if (zone_id.startsWith("posix/"))
+            zone_id.remove(0, 6);
+    }
+
+#endif
+    return zone_id;
+}
+
 /** \fn encodeLongLong(QStringList&,long long)
  *  \brief Encodes a long for streaming in the MythTV protocol.
  *

programs/mythbackend/mainserver.h

@@ -135 +135 @@
     void HandleQueryLoad(PlaybackSock *pbs);
     void HandleQueryUptime(PlaybackSock *pbs);
     void HandleQueryMemStats(PlaybackSock *pbs);
+    void HandleQueryTimeZone(PlaybackSock *pbs);
     void HandleBlockShutdown(bool blockShutdown, PlaybackSock *pbs);
     
     void SendResponse(MythSocket *pbs, QStringList &commands);

programs/mythbackend/mainserver.cpp

@@ -374 +374 @@
     {
         HandleQueryMemStats(pbs);
     }
+    else if (command == "QUERY_TIME_ZONE")
+    {
+        HandleQueryTimeZone(pbs);
+    }
     else if (command == "QUERY_CHECKFILE")
     {
         HandleQueryCheckFile(listline, pbs);
@@ -2310 +2314 @@
 
 /**
  * \addtogroup myth_network_protocol
+ * \par        QUERY_TIME_ZONE
+ * Returns time zone ID, current offset, current time
+ */
+void MainServer::HandleQueryTimeZone(PlaybackSock *pbs)
+{
+    MythSocket *pbssock = pbs->getSocket();
+    QStringList strlist;
+    strlist << getTimeZoneID() << format_utc_offset()
+            << mythCurrentDateTime().toString(Qt::ISODate);
+
+    SendResponse(pbssock, strlist);
+}
+
+/**
+ * \addtogroup myth_network_protocol
  * \par        QUERY_CHECKFILE \e checkslaves \e programinfo
  */
 void MainServer::HandleQueryCheckFile(QStringList &slist, PlaybackSock *pbs)