Linux sandbox: plumb timezone calls through the sandbox

chrome/browser/renderer_host/render_sandbox_host_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 "chrome/browser/renderer_host/render_sandbox_host_linux.h"
 
 #include <stdint.h>
 #include <unistd.h>
 #include <sys/uio.h>
 #include <sys/socket.h>
 #include <sys/poll.h>
+#include <time.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/process_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
 #include "base/unix_domain_socket_posix.h"
 #include "chrome/common/sandbox_methods_linux.h"
 #include "webkit/api/public/gtk/WebFontInfo.h"
@@ skipping 147 matching lines @@
     int kind;
     if (!pickle.ReadInt(&iter, &kind))
       goto error;
 
     if (kind == FontConfigIPC::METHOD_MATCH) {
       HandleFontMatchRequest(fd, pickle, iter, fds);
     } else if (kind == FontConfigIPC::METHOD_OPEN) {
       HandleFontOpenRequest(fd, pickle, iter, fds);
     } else if (kind == LinuxSandbox::METHOD_GET_FONT_FAMILY_FOR_CHARS) {
       HandleGetFontFamilyForChars(fd, pickle, iter, fds);
+    } else if (kind == LinuxSandbox::METHOD_LOCALTIME) {
+      HandleLocaltime(fd, pickle, iter, fds);
     }
 
   error:
     for (std::vector<int>::const_iterator
          i = fds.begin(); i != fds.end(); ++i) {
       close(*i);
     }
   }
 
   void HandleFontMatchRequest(int fd, Pickle& pickle, void* iter,
@@ skipping 85 matching lines @@
     }
 
     const WebString family = WebFontInfo::familyForChars(chars.get(), num_chars);
     const std::string family_utf8 = UTF16ToUTF8(family);
 
     Pickle reply;
     reply.WriteString(family_utf8);
     SendRendererReply(fds, reply, -1);
   }
 
+  void HandleLocaltime(int fd, Pickle& pickle, void* iter,
+                       std::vector<int>& fds) {
+    // The other side of this call is in zygote_main_linux.cc
+
+    std::string time_string;
+    if (!pickle.ReadString(&iter, &time_string) ||
+        time_string.size() != sizeof(time_t)) {
+      return;
+    }
+
+    time_t time;
+    memcpy(&time, time_string.data(), sizeof(time));
+    struct tm expanded_time;
+    localtime_r(&time, &expanded_time);
+
+    const std::string result_string(reinterpret_cast<char*>(&expanded_time),
+                                    sizeof(expanded_time));
+
+    Pickle reply;
+    reply.WriteString(result_string);
+    SendRendererReply(fds, reply, -1);
+  }
+
   void SendRendererReply(const std::vector<int>& fds, const Pickle& reply,
                          int reply_fd) {
     struct msghdr msg;
     memset(&msg, 0, sizeof(msg));
     struct iovec iov = {const_cast<void*>(reply.data()), reply.size()};
     msg.msg_iov = &iov;
     msg.msg_iovlen = 1;
 
     char control_buffer[CMSG_SPACE(sizeof(int))];
 
@@ skipping 40 matching lines @@
     SandboxIPCProcess handler(child_lifeline_fd, browser_socket);
     handler.Run();
     _exit(0);
   }
 }
 
 RenderSandboxHostLinux::~RenderSandboxHostLinux() {
   HANDLE_EINTR(close(renderer_socket_));
   HANDLE_EINTR(close(childs_lifeline_fd_));
 }