Add namespace sandbox class.

sandbox/linux/services/namespace_utils.cc

 // Copyright 2015 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 "sandbox/linux/services/namespace_utils.h"
 
 #include <fcntl.h>
 #include <sched.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/launch.h"
-#include "base/strings/stringprintf.h"
+#include "base/strings/safe_sprintf.h"
 #include "base/third_party/valgrind/valgrind.h"
 
 namespace sandbox {
 
 namespace {
 bool IsRunningOnValgrind() {
   return RUNNING_ON_VALGRIND;
 }
 }  // namespace
 
 // static
 bool NamespaceUtils::WriteToIdMapFile(const char* map_file, generic_id_t id) {
   base::ScopedFD fd(HANDLE_EINTR(open(map_file, O_WRONLY)));

[jln (very slow on Chromium), 2015/02/03 01:14:30]

I would rather not assume ScopedFD to be async-safe unfortunately. Thankfully, I
don't think this will make this function much more complex to avoid it.

[rickyz (no longer on Chrome), 2015/02/03 01:27:22]

Done.

   if (!fd.is_valid()) {
     return false;
   }
 
   const generic_id_t inside_id = id;
   const generic_id_t outside_id = id;
-  const std::string mapping =
-      base::StringPrintf("%d %d 1\n", inside_id, outside_id);
-  const size_t len = mapping.size();
-  const ssize_t rc = HANDLE_EINTR(write(fd.get(), mapping.c_str(), len));
-  return rc == static_cast<ssize_t>(len);
+
+  // This function needs to be async-signal-safe, as it is called in between

[jln (very slow on Chromium), 2015/02/03 01:14:30]

Add this as a comment to the function instead.

[rickyz (no longer on Chrome), 2015/02/03 01:27:22]

Done.

+  // fork and exec.
+  char mapping[64];
+  ssize_t len =
+      base::strings::SafeSPrintf(mapping, "%d %d 1\n", inside_id, outside_id);
+  const ssize_t rc = HANDLE_EINTR(write(fd.get(), mapping, len));
+  return rc == len;
 }
 
 // static
 bool NamespaceUtils::KernelSupportsUnprivilegedNamespace(int type) {
   // Valgrind will let clone(2) pass-through, but doesn't support unshare(),
   // so always consider namespaces unsupported there.
   if (IsRunningOnValgrind()) {
     return false;
   }
 
@@ skipping 25 matching lines @@
       break;
     default:
       NOTREACHED();
       return false;
   }
 
   return base::PathExists(base::FilePath(path));
 }
 
 }  // namespace sandbox