Linux: add support for tm_zone to localtime via the sandbox.

chrome/browser/zygote_main_linux.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <unistd.h>
 #include <sys/epoll.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/signal.h>
 #include <sys/prctl.h>
@@ skipping 185 matching lines @@
     for (std::vector<int>::const_iterator
          i = fds.begin(); i != fds.end(); ++i)
       close(*i);
     return false;
   }
 };
 
 // Patched dynamic symbol wrapper functions...
 namespace sandbox_wrapper {
 
-void do_localtime(time_t input, struct tm* output) {
+void do_localtime(time_t input, struct tm* output, char* timezone_out,
+                  size_t timezone_out_len) {
   Pickle request;
   request.WriteInt(LinuxSandbox::METHOD_LOCALTIME);
   request.WriteString(
       std::string(reinterpret_cast<char*>(&input), sizeof(input)));
 
   uint8_t reply_buf[512];
   const ssize_t r = base::SendRecvMsg(
       kMagicSandboxIPCDescriptor, reply_buf, sizeof(reply_buf), NULL, request);
   if (r == -1) {
     memset(output, 0, sizeof(struct tm));
     return;
   }
 
   Pickle reply(reinterpret_cast<char*>(reply_buf), r);
   void* iter = NULL;
-  std::string result;
+  std::string result, timezone;
   if (!reply.ReadString(&iter, &result) ||
+      !reply.ReadString(&iter, &timezone) ||
       result.size() != sizeof(struct tm)) {
     memset(output, 0, sizeof(struct tm));
     return;
   }
 
   memcpy(output, result.data(), sizeof(struct tm));
+  if (timezone_out_len) {
+    const size_t copy_len = std::min(timezone_out_len - 1, timezone.size());
+    memcpy(timezone_out, timezone.data(), copy_len);
+    timezone_out[copy_len] = 0;
+    output->tm_zone = timezone_out;
+  } else {
+    output->tm_zone = NULL;
+  }
 }
 
 struct tm* localtime(const time_t* timep) {
   static struct tm time_struct;
-  do_localtime(*timep, &time_struct);
+  static char timezone_string[64];
+  do_localtime(*timep, &time_struct, timezone_string, sizeof(timezone_string));
   return &time_struct;
 }
 
 struct tm* localtime_r(const time_t* timep, struct tm* result) {
-  do_localtime(*timep, result);
+  do_localtime(*timep, result, NULL, 0);
   return result;
 }
 
 }  // namespace sandbox_wrapper
 
 /* On IA-32, function calls which need to be resolved by the dynamic linker are
  * directed to the producure linking table (PLT). Each PLT entry contains code
  * which jumps (indirectly) via the global offset table (GOT):
  *   Dump of assembler code for function f@plt:
  *   0x0804830c <f@plt+0>:   jmp    *0x804a004  # GOT indirect jump
@@ skipping 110 matching lines @@
 bool ZygoteMain(const MainFunctionParams& params) {
   if (!MaybeEnterChroot()) {
     LOG(FATAL) << "Failed to enter sandbox. Fail safe abort. (errno: "
                << errno << ")";
     return false;
   }
 
   Zygote zygote;
   return zygote.ProcessRequests();
 }