Allow the seccomp sandbox to be enabled, even if the suid sandbox has...

sandbox/linux/seccomp/ipc.cc

 #include "debug.h"
 #include "sandbox_impl.h"
 
 namespace playground {
 
 #ifndef IPC_PRIVATE
 #define IPC_PRIVATE 0
 #endif
 #ifndef IPC_RMID
 #define IPC_RMID    0
@@ skipping 90 matching lines @@
   long rc;
   SysCalls sys;
   if (write(sys, processFdPub(), &request, sizeof(request)) !=
       sizeof(request) ||
       read(sys, threadFdPub(), &rc, sizeof(rc)) != sizeof(rc)) {
     die("Failed to forward shmget() request [sandbox]");
   }
   return static_cast<int>(rc);
 }
 
-bool Sandbox::process_shmat(int parentProc, int sandboxFd, int threadFdPub,
+bool Sandbox::process_shmat(int parentMapsFd, int sandboxFd, int threadFdPub,
                             int threadFd, SecureMem::Args* mem) {
   // Read request
   ShmAt shmat_req;
   SysCalls sys;
   if (read(sys, sandboxFd, &shmat_req, sizeof(shmat_req)) !=
       sizeof(shmat_req)) {
     die("Failed to read parameters for shmat() [process]");
   }
 
   // We only allow attaching to the shm identifier that was returned by
   // the most recent call to shmget(IPC_PRIVATE)
   if (shmat_req.shmaddr || shmat_req.shmflg || shmat_req.shmid != mem->shmId) {
     mem->shmId = -1;
     SecureMem::abandonSystemCall(threadFd, -EINVAL);
     return false;
   }
 
   mem->shmId = -1;
   SecureMem::sendSystemCall(threadFdPub, false, -1, mem,
                             __NR_shmat, shmat_req.shmid, shmat_req.shmaddr,
                             shmat_req.shmflg);
   return true;
 }
 
-bool Sandbox::process_shmctl(int parentProc, int sandboxFd, int threadFdPub,
+bool Sandbox::process_shmctl(int parentMapsFd, int sandboxFd, int threadFdPub,
                              int threadFd, SecureMem::Args* mem) {
   // Read request
   ShmCtl shmctl_req;
   SysCalls sys;
   if (read(sys, sandboxFd, &shmctl_req, sizeof(shmctl_req)) !=
       sizeof(shmctl_req)) {
     die("Failed to read parameters for shmctl() [process]");
   }
 
   // The only shmctl() operation that we need to support is removal. This
   // operation is generally safe.
   if ((shmctl_req.cmd & ~(IPC_64 | IPC_RMID)) || shmctl_req.buf) {
     mem->shmId = -1;
     SecureMem::abandonSystemCall(threadFd, -EINVAL);
     return false;
   }
 
   mem->shmId = -1;
   SecureMem::sendSystemCall(threadFdPub, false, -1, mem,
                             __NR_shmctl, shmctl_req.shmid, shmctl_req.cmd,
                             shmctl_req.buf);
   return true;
 }
 
-bool Sandbox::process_shmdt(int parentProc, int sandboxFd, int threadFdPub,
+bool Sandbox::process_shmdt(int parentMapsFd, int sandboxFd, int threadFdPub,
                             int threadFd, SecureMem::Args* mem) {
   // Read request
   ShmDt shmdt_req;
   SysCalls sys;
   if (read(sys, sandboxFd, &shmdt_req, sizeof(shmdt_req)) !=
       sizeof(shmdt_req)) {
     die("Failed to read parameters for shmdt() [process]");
   }
 
   // Detaching shared memory segments it generally safe, but just in case
@@ skipping 14 matching lines @@
       return false;
     }
   }
 
   mem->shmId = -1;
   SecureMem::sendSystemCall(threadFdPub, false, -1, mem,
                             __NR_shmdt, shmdt_req.shmaddr);
   return true;
 }
 
-bool Sandbox::process_shmget(int parentProc, int sandboxFd, int threadFdPub,
+bool Sandbox::process_shmget(int parentMapsFd, int sandboxFd, int threadFdPub,
                              int threadFd, SecureMem::Args* mem) {
   // Read request
   ShmGet shmget_req;
   SysCalls sys;
   if (read(sys, sandboxFd, &shmget_req, sizeof(shmget_req)) !=
       sizeof(shmget_req)) {
     die("Failed to read parameters for shmget() [process]");
   }
 
   // We do not want to allow the sandboxed application to access arbitrary
@@ skipping 47 matching lines @@
   long rc;
   SysCalls sys;
   if (write(sys, processFdPub(), &request, sizeof(request)) !=
       sizeof(request) ||
       read(sys, threadFdPub(), &rc, sizeof(rc)) != sizeof(rc)) {
     die("Failed to forward ipc() request [sandbox]");
   }
   return static_cast<int>(rc);
 }
 
-bool Sandbox::process_ipc(int parentProc, int sandboxFd, int threadFdPub,
+bool Sandbox::process_ipc(int parentMapsFd, int sandboxFd, int threadFdPub,
                           int threadFd, SecureMem::Args* mem) {
   // Read request
   IPC ipc_req;
   SysCalls sys;
   if (read(sys, sandboxFd, &ipc_req, sizeof(ipc_req)) != sizeof(ipc_req)) {
     die("Failed to read parameters for ipc() [process]");
   }
 
   // We do not support all of the SysV IPC calls. In fact, we only support
   // the minimum feature set necessary for Chrome's renderers to share memory
@@ skipping 53 matching lines @@
       // other SysV IPC calls.
     deny:
       mem->shmId = -1;
       SecureMem::abandonSystemCall(threadFd, -EINVAL);
       return false;
   }
 }
 #endif
 
 } // namespace