Refactored ErrorCode into it's own class

content/common/sandbox_init_linux.cc

 // Copyright (c) 2012 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 "content/public/common/sandbox_init.h"
 
 #if defined(__i386__) || defined(__x86_64__)
 
 // This is an assert for GYP
 #if !defined(OS_LINUX)
@@ skipping 38 matching lines @@
 #ifndef __NR_process_vm_readv
   #define __NR_process_vm_readv 347
 #endif
 
 #ifndef __NR_process_vm_writev
   #define __NR_process_vm_writev 348
 #endif
 
 #endif
 
+using playground2::arch_seccomp_data;
+using playground2::ErrorCode;
+using playground2::Sandbox;
+
 namespace {
 
 bool IsSingleThreaded() {
   // Possibly racy, but it's ok because this is more of a debug check to catch
   // new threaded situations arising during development.
   int num_threads =
     file_util::CountFilesCreatedAfter(FilePath("/proc/self/task"),
                                       base::Time::UnixEpoch());
 
   // We pass the test if we don't know ( == 0), because the setuid sandbox
@@ skipping 140 matching lines @@
   if (strcmp(pathname, kDriRcPath) == 0) {
     int ret = OpenWithCache(pathname, flags);
     return (ret == -1) ? -errno : ret;
   } else {
     return -ENOENT;
   }
 }
 
 #if defined(__x86_64__)
 // x86_64 only because it references system calls that are multiplexed on IA32.
-playground2::Sandbox::ErrorCode GpuProcessPolicy_x86_64(int sysno) {
+ErrorCode GpuProcessPolicy_x86_64(int sysno) {
   switch(sysno) {
     case __NR_read:
     case __NR_ioctl:
     case __NR_poll:
     case __NR_epoll_wait:
     case __NR_recvfrom:
     case __NR_write:
     case __NR_writev:
     case __NR_gettid:
     case __NR_sched_yield:  // Nvidia binary driver.
@@ skipping 27 matching lines @@
     case __NR_dup:
     case __NR_mlock:
     case __NR_munlock:
     case __NR_exit:
     case __NR_exit_group:
     case __NR_lseek:
     case __NR_getpid:  // Nvidia binary driver.
     case __NR_getppid:  // ATI binary driver.
     case __NR_shutdown:  // Virtual driver.
     case __NR_rt_sigaction:  // Breakpad signal handler.
-      return playground2::Sandbox::SB_ALLOWED;
+      return ErrorCode(ErrorCode::ERR_ALLOWED);
     case __NR_socket:
-      return EACCES;  // Nvidia binary driver.
+      return ErrorCode(EACCES);  // Nvidia binary driver.
     case __NR_fchmod:
-      return EPERM;  // ATI binary driver.
+      return ErrorCode(EPERM);  // ATI binary driver.
     case __NR_open:
       // Hook open() in the GPU process to allow opening /etc/drirc,
       // needed by Mesa.
       // The hook needs dup(), lseek(), and close() to be allowed.
-      return playground2::Sandbox::ErrorCode(GpuOpenSIGSYS_Handler, NULL);
+      return Sandbox::Trap(GpuOpenSIGSYS_Handler, NULL);
     default:
       if (IsGettimeSyscall(sysno) ||
           IsKillSyscall(sysno)) { // GPU watchdog.
-        return playground2::Sandbox::SB_ALLOWED;
+        return ErrorCode(ErrorCode::ERR_ALLOWED);
       }
       // Generally, filename-based syscalls will fail with ENOENT to behave
       // similarly to a possible future setuid sandbox.
       if (IsFileSystemSyscall(sysno)) {
-        return ENOENT;
+        return ErrorCode(ENOENT);
       }
       // In any other case crash the program with our SIGSYS handler
-      return playground2::Sandbox::ErrorCode(CrashSIGSYS_Handler, NULL);
+      return Sandbox::Trap(CrashSIGSYS_Handler, NULL);
   }
 }
 
 // x86_64 only because it references system calls that are multiplexed on IA32.
-playground2::Sandbox::ErrorCode FlashProcessPolicy_x86_64(int sysno) {
+ErrorCode FlashProcessPolicy_x86_64(int sysno) {
   switch (sysno) {
     case __NR_futex:
     case __NR_write:
     case __NR_epoll_wait:
     case __NR_read:
     case __NR_times:
     case __NR_clone:  // TODO(jln): restrict flags.
     case __NR_set_robust_list:
     case __NR_getuid:
     case __NR_geteuid:
@@ skipping 25 matching lines @@
     case __NR_brk:
     case __NR_sched_yield:
     case __NR_shutdown:
     case __NR_sched_getaffinity:
     case __NR_sched_setscheduler:
     case __NR_dup:  // Flash Access.
     // These are under investigation, and hopefully not here for the long term.
     case __NR_shmctl:
     case __NR_shmat:
     case __NR_shmdt:
-      return playground2::Sandbox::SB_ALLOWED;
+      return ErrorCode(ErrorCode::ERR_ALLOWED);
     case __NR_ioctl:
-      return ENOTTY;  // Flash Access.
+      return ErrorCode(ENOTTY);  // Flash Access.
     case __NR_socket:
-      return EACCES;
+      return ErrorCode(EACCES);
 
     default:
       if (IsGettimeSyscall(sysno) ||
           IsKillSyscall(sysno)) {
-        return playground2::Sandbox::SB_ALLOWED;
+        return ErrorCode(ErrorCode::ERR_ALLOWED);
       }
       if (IsFileSystemSyscall(sysno)) {
-        return ENOENT;
+        return ErrorCode(ENOENT);
       }
       // In any other case crash the program with our SIGSYS handler.
-      return playground2::Sandbox::ErrorCode(CrashSIGSYS_Handler, NULL);
+      return Sandbox::Trap(CrashSIGSYS_Handler, NULL);
   }
 }
 #endif
 
-playground2::Sandbox::ErrorCode BlacklistPtracePolicy(int sysno) {
+ErrorCode BlacklistPtracePolicy(int sysno) {
   if (sysno < static_cast<int>(MIN_SYSCALL) ||
       sysno > static_cast<int>(MAX_SYSCALL)) {
     // TODO(jln) we should not have to do that in a trivial policy.
-    return ENOSYS;
+    return ErrorCode(ENOSYS);
   }
   switch (sysno) {
     case __NR_ptrace:
     case __NR_process_vm_readv:
     case __NR_process_vm_writev:
     case __NR_migrate_pages:
     case __NR_move_pages:
-      return playground2::Sandbox::ErrorCode(CrashSIGSYS_Handler, NULL);
+      return Sandbox::Trap(CrashSIGSYS_Handler, NULL);
     default:
-      return playground2::Sandbox::SB_ALLOWED;
+      return ErrorCode(ErrorCode::ERR_ALLOWED);
   }
 }
 
 // Allow all syscalls.
 // This will still deny x32 or IA32 calls in 64 bits mode or
 // 64 bits system calls in compatibility mode.
-playground2::Sandbox::ErrorCode AllowAllPolicy(int sysno) {
+ErrorCode AllowAllPolicy(int sysno) {
   if (sysno < static_cast<int>(MIN_SYSCALL) ||
       sysno > static_cast<int>(MAX_SYSCALL)) {
     // TODO(jln) we should not have to do that in a trivial policy.
-    return ENOSYS;
+    return ErrorCode(ENOSYS);
   } else {
-    return playground2::Sandbox::SB_ALLOWED;
+    return ErrorCode(ErrorCode::ERR_ALLOWED);
   }
 }
 
 // Warms up/preloads resources needed by the policies.
-void WarmupPolicy(playground2::Sandbox::EvaluateSyscall policy) {
+void WarmupPolicy(Sandbox::EvaluateSyscall policy) {
 #if defined(__x86_64__)
   if (policy == GpuProcessPolicy_x86_64)
     OpenWithCache(kDriRcPath, O_RDONLY);
 #endif
 }
 
 // Is the sandbox fully disabled for this process?
 bool ShouldDisableSandbox(const CommandLine& command_line,
                           const std::string& process_type) {
   if (command_line.HasSwitch(switches::kNoSandbox) ||
@@ skipping 17 matching lines @@
     if (command_line.HasSwitch(switches::kEnableGpuSandbox))
       should_disable = false;
     if (command_line.HasSwitch(switches::kDisableGpuSandbox))
       should_disable = true;
     return should_disable;
   }
 
   return false;
 }
 
-playground2::Sandbox::EvaluateSyscall GetProcessSyscallPolicy(
+Sandbox::EvaluateSyscall GetProcessSyscallPolicy(
     const CommandLine& command_line,
     const std::string& process_type) {
 #if defined(__x86_64__)
   if (process_type == switches::kGpuProcess) {
     return GpuProcessPolicy_x86_64;
   }
 
   if (process_type == switches::kPpapiPluginProcess) {
     // TODO(jln): figure out what to do with non-Flash PPAPI
     // out-of-process plug-ins.
@@ skipping 48 matching lines @@
     VLOG(1) << "Seccomp BPF disabled in "
             << process_type
             <<  " because seccomp mode 1 is enabled.";
     return;
   }
 
   // TODO(jln): find a way for the Zygote processes under the setuid sandbox to
   // have a /proc fd and pass it here.
   // Passing -1 as the /proc fd since we have no special way to have it for
   // now.
-  if (playground2::Sandbox::supportsSeccompSandbox(-1) !=
-      playground2::Sandbox::STATUS_AVAILABLE) {
+  if (Sandbox::supportsSeccompSandbox(-1) !=
+      Sandbox::STATUS_AVAILABLE) {
     return;
   }
 
-  playground2::Sandbox::EvaluateSyscall SyscallPolicy =
+  Sandbox::EvaluateSyscall SyscallPolicy =
       GetProcessSyscallPolicy(command_line, process_type);
 
   // Warms up resources needed by the policy we're about to enable.
   WarmupPolicy(SyscallPolicy);
 
-  playground2::Sandbox::setSandboxPolicy(SyscallPolicy, NULL);
-  playground2::Sandbox::startSandbox();
+  Sandbox::setSandboxPolicy(SyscallPolicy, NULL);
+  Sandbox::startSandbox();
 
   // TODO(jorgelo): remove this once we surface
   // seccomp filter sandbox status in about:sandbox.
   const std::string ActivatedSeccomp =
       "Activated seccomp filter sandbox for process type: " +
       process_type + ".";
   if (IsChromeOS())
     LOG(WARNING) << ActivatedSeccomp;
   else
     VLOG(1) << ActivatedSeccomp;
 }
 
 }  // anonymous namespace
 
 #endif  // defined(__i386__) || defined(__x86_64__)
 
 namespace content {
 
 void InitializeSandbox() {
 #if defined(__i386__) || defined(__x86_64__)
   InitializeSandbox_x86();
 #endif
 }
 
 }  // namespace content