Set the TZ env to get the UTC-ms since epoch.

runtime/vm/os_linux.cc

Index: runtime/vm/os_linux.cc
diff --git a/runtime/vm/os_linux.cc b/runtime/vm/os_linux.cc
index 52bdaf7b538f92e3abf87cdd86acc0d4a8f692ca..e119648aee506b53b0f66923a1f890e8408da0f9 100644
--- a/runtime/vm/os_linux.cc
+++ b/runtime/vm/os_linux.cc
@@ -14,9 +14,12 @@
 
 #include "platform/utils.h"
 #include "vm/isolate.h"
+#include "vm/thread.h"
 
 namespace dart {
 
+static Mutex timezone_mutex;
+
 bool OS::BreakDownSecondsSinceEpoch(time_t seconds_since_epoch,
                                     bool in_utc,
                                     BrokenDownDate* result) {
@@ -25,7 +28,10 @@ bool OS::BreakDownSecondsSinceEpoch(time_t seconds_since_epoch,
   if (in_utc) {
     error_code = gmtime_r(&seconds_since_epoch, &tm_result);
   } else {
-    // TODO(floitsch): we should be able to call tzset only once during
+    MutexLocker ml(&timezone_mutex);
+    // TODO(floitsch): we should not need the tzset. According to the man-page
+    // the function already acts as if it invoked tzset. In any case we
+    // shouldn't need to invoke it every time, but only once during
     // initialization.
     tzset();  // Make sure the libc knows about the local zone.
     error_code = localtime_r(&seconds_since_epoch, &tm_result);
@@ -42,6 +48,8 @@ bool OS::BreakDownSecondsSinceEpoch(time_t seconds_since_epoch,
 
 bool OS::BrokenDownToSecondsSinceEpoch(
     const BrokenDownDate& broken_down, bool in_utc, time_t* result) {
+  // Changing the timezone environment is not thread-safe.
+  MutexLocker ml(&timezone_mutex);

[Ivan Posva, 2012/04/03 23:03:52]

You might be protecting against other Dart VM based code killing your TZ
environment variable, but how to you intend to protect against the embedder
calling these functions at the same time? You only think you are safe here, but
are not.

[floitsch, 2012/04/04 08:27:43]

I never thought I would be safe against the embedder. Afaik you cannot be safe.
If the embedder is changing the TZ variable then localtime_r, and mktime will
return the values for the embedder's TZ.
However, it is true that we screw up the embedders TZ env. That is, even if the
embedder is nice and doesn't change the TZ, *we* do it behind its back. So the
embedder might get into troubles if it relies on localtime_r and mktime to
return local times.
I just looked at V8's code, and I will try to adapt their approach, so that we
don't change the env (for the embedder's sake).

   struct tm tm_broken_down;
   // mktime takes the years since 1900.
   tm_broken_down.tm_year = broken_down.year;
@@ -52,21 +60,29 @@ bool OS::BrokenDownToSecondsSinceEpoch(
   tm_broken_down.tm_sec = broken_down.seconds;
   // Set wday to an impossible day, so that we can catch bad input.
   tm_broken_down.tm_wday = -1;
-  // Make sure the libc knows about the local zone.
-  // In case of 'in_utc' this call is mainly for multi-threading issues. If
-  // another thread uses a time-function it will set the timezone. The timezone
-  // adjustement below would then not work anymore.
-  // TODO(floitsch): we should be able to call tzset only once during
-  // initialization.
-  tzset();
   if (in_utc) {
+    char* saved_timezone = getenv("TZ");
+    // Set to UTC.
+    setenv("TZ", "", 1);
+    tzset();
     // Disable daylight saving in utc mode.
     tm_broken_down.tm_isdst = 0;
-    // mktime assumes that the given date is local time zone.
     *result = mktime(&tm_broken_down);
-    // Remove the timezone.
-    *result -= timezone;
+    // Restore old value of the timezone.
+    if (saved_timezone) {
+      setenv("TZ", saved_timezone, 1);
+    } else {
+      unsetenv("TZ");
+    }
+    tzset();
   } else {
+    // Make sure the libc knows about the local zone.
+    // In case of 'in_utc' this call is mainly for multi-threading issues. If
+    // another thread uses a time-function it will set the timezone. The
+    // timezone adjustement below would then not work anymore.
+    // TODO(floitsch): we should be able to call tzset only once during
+    // initialization.
+    tzset();
     // Let libc figure out if daylight saving is active.
     tm_broken_down.tm_isdst = -1;
     *result = mktime(&tm_broken_down);