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

runtime/vm/os_linux.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/os.h"
 
 #include <errno.h>
 #include <limits.h>
 #include <time.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #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) {
   struct tm tm_result;
   struct tm* error_code;
   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);
   }
   result->year = tm_result.tm_year;
   result->month= tm_result.tm_mon;
   result->day = tm_result.tm_mday;
   result->hours = tm_result.tm_hour;
   result->minutes = tm_result.tm_min;
   result->seconds = tm_result.tm_sec;
   return error_code != NULL;
 }
 
 
 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;
   tm_broken_down.tm_mon = broken_down.month;
   tm_broken_down.tm_mday = broken_down.day;
   tm_broken_down.tm_hour = broken_down.hours;
   tm_broken_down.tm_min = broken_down.minutes;
   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);
   }
   if ((*result == -1) && (tm_broken_down.tm_wday == -1)) {
     return false;
   }
   return true;
 }
 
@@ skipping 140 matching lines @@
 void OS::Abort() {
   abort();
 }
 
 
 void OS::Exit(int code) {
   exit(code);
 }
 
 }  // namespace dart