Refactored ErrorCode into it's own class

content/common/sandbox_seccomp_bpf_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 <asm/unistd.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/audit.h>
 #include <linux/filter.h>
@@ skipping 16 matching lines @@
 // These are the only architectures supported for now.
 #if defined(__i386__) || defined(__x86_64__) || \
     (defined(__arm__) && (defined(__thumb__) || defined(__ARM_EABI__)))
 #define SECCOMP_BPF_SANDBOX
 #endif
 
 #if defined(SECCOMP_BPF_SANDBOX)
 #include "sandbox/linux/seccomp-bpf/sandbox_bpf.h"
 #include "sandbox/linux/services/linux_syscalls.h"
 
+using playground2::arch_seccomp_data;
+using playground2::ErrorCode;
+using playground2::Sandbox;
+
 namespace {
 
 inline bool IsChromeOS() {
 #if defined(OS_CHROMEOS)
   return true;
 #else
   return false;
 #endif
 }
 
@@ skipping 1127 matching lines @@
       IsArmPciConfig(sysno) ||
 #endif
       IsTimer(sysno)) {
     return true;
   } else {
     return false;
   }
 }
 
 // x86_64 only for now. Needs to be adapted and tested for i386.
-playground2::Sandbox::ErrorCode BaselinePolicy_x86_64(int sysno) {
+ErrorCode BaselinePolicy_x86_64(int sysno) {
   if (IsBaselinePolicyAllowed_x86_64(sysno)) {
-    return playground2::Sandbox::SB_ALLOWED;
+    return ErrorCode(ErrorCode::ERR_ALLOWED);
   }
   // TODO(jln): some system calls in those sets are not supposed to
   // return ENOENT. Return the appropriate error.
   if (IsFileSystem(sysno) || IsCurrentDirectory(sysno)) {
-    return ENOENT;
+    return ErrorCode(ENOENT);
   }
 
   if (IsUmask(sysno) || IsDeniedFileSystemAccessViaFd(sysno)) {
-    return EPERM;
+    return ErrorCode(EPERM);
   }
 
   if (IsBaselinePolicyWatched_x86_64(sysno)) {
     // Previously unseen syscalls. TODO(jln): some of these should
     // be denied gracefully right away.
-    return playground2::Sandbox::ErrorCode(CrashSIGSYS_Handler, NULL);
+    return Sandbox::Trap(CrashSIGSYS_Handler, NULL);
   }
   // 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 for now. Needs to be adapted and tested for i386.
-playground2::Sandbox::ErrorCode GpuProcessPolicy_x86_64(int sysno) {
+ErrorCode GpuProcessPolicy_x86_64(int sysno) {
   switch(sysno) {
     case __NR_ioctl:
-      return playground2::Sandbox::SB_ALLOWED;
+      return ErrorCode(ErrorCode::ERR_ALLOWED);
 #if defined(__x86_64__)
     case __NR_socket:
-      return EACCES;  // Nvidia binary driver.
+      return ErrorCode(EACCES);  // Nvidia binary driver.
 #endif
     case __NR_open:
       // Accelerated video decode is enabled by default only on Chrome OS.
       if (IsAcceleratedVideoDecodeEnabled()) {
         // Accelerated video decode needs to open /dev/dri/card0, and
         // dup()'ing an already open file descriptor does not work.
         // Allow open() even though it severely weakens the sandbox,
         // to test the sandboxing mechanism in general.
         // TODO(jorgelo): remove this once we solve the libva issue.
-        return playground2::Sandbox::SB_ALLOWED;
+        return ErrorCode(ErrorCode::ERR_ALLOWED);
       } else {
         // 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 (IsEventFd(sysno))
-        return playground2::Sandbox::SB_ALLOWED;
+        return ErrorCode(ErrorCode::ERR_ALLOWED);
 
       // Default on the baseline policy.
       return BaselinePolicy_x86_64(sysno);
   }
 }
 
-playground2::Sandbox::ErrorCode RendererProcessPolicy_x86_64(int sysno) {
+ErrorCode RendererProcessPolicy_x86_64(int sysno) {
   switch (sysno) {
     case __NR_ioctl:  // TODO(jln) investigate legitimate use in the renderer
                       // and see if alternatives can be used.
     case __NR_fdatasync:
     case __NR_fsync:
 #if defined(__i386__) || defined(__x86_64__)
     case __NR_getrlimit:
 #endif
     case __NR_pread64:
     case __NR_pwrite64:
     case __NR_sched_get_priority_max:
     case __NR_sched_get_priority_min:
     case __NR_sched_getparam:
     case __NR_sched_getscheduler:
     case __NR_sched_setscheduler:
     case __NR_setpriority:
     case __NR_sysinfo:
     case __NR_times:
     case __NR_uname:
-      return playground2::Sandbox::SB_ALLOWED;
+      return ErrorCode(ErrorCode::ERR_ALLOWED);
     default:
 #if defined(__x86_64__)
       if (IsSystemVSharedMemory(sysno))
-        return playground2::Sandbox::SB_ALLOWED;
+        return ErrorCode(ErrorCode::ERR_ALLOWED);
 #endif
 
       // Default on the baseline policy.
       return BaselinePolicy_x86_64(sysno);
   }
 }
 
 // x86_64 only for now. Needs to be adapted and tested for i386.
-playground2::Sandbox::ErrorCode FlashProcessPolicy_x86_64(int sysno) {
+ErrorCode FlashProcessPolicy_x86_64(int sysno) {
   switch (sysno) {
     case __NR_sched_getaffinity:
     case __NR_sched_setscheduler:
     case __NR_times:
-      return playground2::Sandbox::SB_ALLOWED;
+      return ErrorCode(ErrorCode::ERR_ALLOWED);
     case __NR_ioctl:
-      return ENOTTY;  // Flash Access.
+      return ErrorCode(ENOTTY);  // Flash Access.
 #if defined(__x86_64__)
     case __NR_socket:
-      return EACCES;
+      return ErrorCode(EACCES);
 #endif
     default:
 #if defined(__x86_64__)
       // These are under investigation, and hopefully not here for the long
       // term.
       if (IsSystemVSharedMemory(sysno))
-        return playground2::Sandbox::SB_ALLOWED;
+        return ErrorCode(ErrorCode::ERR_ALLOWED);
 #endif
 
       // Default on the baseline policy.
       return BaselinePolicy_x86_64(sysno);
   }
 }
 
-playground2::Sandbox::ErrorCode BlacklistDebugAndNumaPolicy(int sysno) {
+ErrorCode BlacklistDebugAndNumaPolicy(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);
   }
 
   if (IsDebug(sysno) || IsNuma(sysno))
-    return playground2::Sandbox::ErrorCode(CrashSIGSYS_Handler, NULL);
+    return Sandbox::Trap(CrashSIGSYS_Handler, NULL);
 
-  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);
     // Accelerated video decode dlopen()'s this shared object
     // inside the sandbox, so preload it now.
     // TODO(jorgelo): generalize this to other platforms.
     if (IsAcceleratedVideoDecodeEnabled()) {
       const char kI965DrvVideoPath_64[] =
           "/usr/lib64/va/drivers/i965_drv_video.so";
       dlopen(kI965DrvVideoPath_64, RTLD_NOW|RTLD_GLOBAL|RTLD_NODELETE);
     }
   }
 #endif
 }
 
-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) {
     // On Chrome OS, --enable-gpu-sandbox enables the more restrictive policy.
     if (IsChromeOS() && !command_line.HasSwitch(switches::kEnableGpuSandbox))
       return BlacklistDebugAndNumaPolicy;
     else
       return GpuProcessPolicy_x86_64;
   }
@@ skipping 18 matching lines @@
   // On other architectures (currently IA32 or ARM),
   // we only have a small blacklist at the moment.
   (void) process_type;
   return BlacklistDebugAndNumaPolicy;
 #endif  // __x86_64__
 }
 
 // Initialize the seccomp-bpf sandbox.
 bool StartBpfSandbox(const CommandLine& command_line,
                      const std::string& process_type) {
-  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();
 
   return true;
 }
 
 }  // namespace
 
 #endif  // SECCOMP_BPF_SANDBOX
 
 namespace content {
 
@@ skipping 17 matching lines @@
 
   return true;
 #endif
   return false;
 }
 
 bool SandboxSeccompBpf::SupportsSandbox() {
 #if defined(SECCOMP_BPF_SANDBOX)
   // TODO(jln): pass the saved proc_fd_ from the LinuxSandbox singleton
   // here.
-  if (playground2::Sandbox::supportsSeccompSandbox(-1) ==
-      playground2::Sandbox::STATUS_AVAILABLE) {
+  if (Sandbox::supportsSeccompSandbox(-1) ==
+      Sandbox::STATUS_AVAILABLE) {
     return true;
   }
 #endif
   return false;
 }
 
 bool SandboxSeccompBpf::StartSandbox(const std::string& process_type) {
 #if defined(SECCOMP_BPF_SANDBOX)
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   if (IsSeccompBpfDesired() &&  // Global switches policy.
       // Process-specific policy.
       ShouldEnableSeccompBpf(process_type) &&
       SupportsSandbox()) {
     return StartBpfSandbox(command_line, process_type);
   }
 #endif
   return false;
 }
 
 }  // namespace content