Linux sandbox: style cleanup for setuid sandbox.

sandbox/linux/suid/sandbox.c

 // 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.
 
 // http://code.google.com/p/chromium/wiki/LinuxSUIDSandbox
 
-#include "common/sandbox.h"
+#include "sandbox/linux/suid/common/sandbox.h"
 
 #define _GNU_SOURCE
 #include <asm/unistd.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <sched.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/prctl.h>
 #include <sys/resource.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/vfs.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
-#include "linux_util.h"
-#include "process_util.h"
-#include "common/suid_unsafe_environment_variables.h"
+#include "sandbox/linux/suid/common/suid_unsafe_environment_variables.h"
+#include "sandbox/linux/suid/linux_util.h"
+#include "sandbox/linux/suid/process_util.h"
 
 #if !defined(CLONE_NEWPID)
 #define CLONE_NEWPID 0x20000000
 #endif
 #if !defined(CLONE_NEWNET)
 #define CLONE_NEWNET 0x40000000
 #endif
 
 static bool DropRoot();
 
 #define HANDLE_EINTR(x) TEMP_FAILURE_RETRY(x)
 
-static void FatalError(const char *msg, ...)
+static void FatalError(const char* msg, ...)
     __attribute__((noreturn, format(printf, 1, 2)));
 
-static void FatalError(const char *msg, ...) {
+static void FatalError(const char* msg, ...) {
   va_list ap;
   va_start(ap, msg);
 
   vfprintf(stderr, msg, ap);
   fprintf(stderr, ": %s\n", strerror(errno));
   fflush(stderr);
   va_end(ap);
   _exit(1);
 }
 
@@ skipping 17 matching lines @@
 #define SAFE_DIR "/proc/self/fdinfo"
 #define SAFE_DIR2 "/proc/self/fd"
 
 static bool SpawnChrootHelper() {
   int sv[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, sv) == -1) {
     perror("socketpair");
     return false;
   }
 
-  char *safedir = NULL;
+  char* safedir = NULL;
   struct stat sdir_stat;
-  if (!stat(SAFE_DIR, &sdir_stat) && S_ISDIR(sdir_stat.st_mode))
+  if (!stat(SAFE_DIR, &sdir_stat) && S_ISDIR(sdir_stat.st_mode)) {
     safedir = SAFE_DIR;
-  else
-    if (!stat(SAFE_DIR2, &sdir_stat) && S_ISDIR(sdir_stat.st_mode))
-      safedir = SAFE_DIR2;
-    else {
-      fprintf(stderr, "Could not find %s\n", SAFE_DIR2);
-      return false;
-    }
+  } else if (!stat(SAFE_DIR2, &sdir_stat) && S_ISDIR(sdir_stat.st_mode)) {
+    safedir = SAFE_DIR2;
+  } else {
+    fprintf(stderr, "Could not find %s\n", SAFE_DIR2);
+    return false;
+  }
 
-  const pid_t pid = syscall(
-      __NR_clone, CLONE_FS | SIGCHLD, 0, 0, 0);
+  const pid_t pid = syscall(__NR_clone, CLONE_FS | SIGCHLD, 0, 0, 0);
 
   if (pid == -1) {
     perror("clone");
     close(sv[0]);
     close(sv[1]);
     return false;
   }
 
   if (pid == 0) {
     // We share our files structure with an untrusted process. As a security in
@@ skipping 95 matching lines @@
   // Don't "Core" on SIGABRT. SIGABRT is sent by the Chrome OS session manager
   // when things are hanging.
   // Here, the current process is going to waitid() and _exit(), so there is no
   // point in generating a crash report. The child process is the one
   // blocking us.
   if (signal(SIGABRT, ExitWithErrorSignalHandler) == SIG_ERR) {
     FatalError("Failed to change signal handler");
   }
 
   int wait_ret =
-    HANDLE_EINTR(waitid(P_PID, child_pid, &reaped_child_info, WEXITED));
+      HANDLE_EINTR(waitid(P_PID, child_pid, &reaped_child_info, WEXITED));
 
   if (!wait_ret && reaped_child_info.si_pid == child_pid) {
     if (reaped_child_info.si_code == CLD_EXITED) {
       exit_code = reaped_child_info.si_status;
     } else {
       // Exit with code 0 if the child got signaled.
       exit_code = 0;
     }
   }
   _exit(exit_code);
 }
 
 static bool MoveToNewNamespaces() {
   // These are the sets of flags which we'll try, in order.
-  const int kCloneExtraFlags[] = {
-    CLONE_NEWPID | CLONE_NEWNET,
-    CLONE_NEWPID,
-  };
+  const int kCloneExtraFlags[] = {CLONE_NEWPID | CLONE_NEWNET, CLONE_NEWPID, };
 
   // We need to close kZygoteIdFd before the child can continue. We use this
   // socketpair to tell the child when to continue;
   int sync_fds[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, sync_fds)) {
     FatalError("Failed to create a socketpair");
   }
 
-  for (size_t i = 0;
-       i < sizeof(kCloneExtraFlags) / sizeof(kCloneExtraFlags[0]);
+  for (size_t i = 0; i < sizeof(kCloneExtraFlags) / sizeof(kCloneExtraFlags[0]);
        i++) {
     pid_t pid = syscall(__NR_clone, SIGCHLD | kCloneExtraFlags[i], 0, 0, 0);
     const int clone_errno = errno;
 
     if (pid > 0) {
       if (!DropRoot()) {
         FatalError("Could not drop privileges");
       } else {
         if (close(sync_fds[0]) || shutdown(sync_fds[1], SHUT_RD))
           FatalError("Could not close socketpair");
@@ skipping 123 matching lines @@
     free(saved_envvar);
   }
 
   return true;
 }
 
 bool CheckAndExportApiVersion() {
   // Check the environment to see if a specific API version was requested.
   // assume version 0 if none.
   long api_number = -1;
-  char *api_string = getenv(kSandboxEnvironmentApiRequest);
+  char* api_string = getenv(kSandboxEnvironmentApiRequest);
   if (!api_string) {
     api_number = 0;
   } else {
     errno = 0;
     char* endptr = NULL;
     api_number = strtol(api_string, &endptr, 10);
     if (!endptr || *endptr || errno != 0)
       return false;
   }
 
   // Warn only for now.
   if (api_number != kSUIDSandboxApiNumber) {
-    fprintf(stderr, "The setuid sandbox provides API version %ld, "
-      "but you need %ld\n"
-      "Please read "
-      "https://code.google.com/p/chromium/wiki/LinuxSUIDSandboxDevelopment."
-      "\n\n",
-      kSUIDSandboxApiNumber,
-      api_number);
+    fprintf(
+        stderr,
+        "The setuid sandbox provides API version %ld, "
+        "but you need %ld\n"
+        "Please read "
+        "https://code.google.com/p/chromium/wiki/LinuxSUIDSandboxDevelopment."
+        "\n\n",
+        kSUIDSandboxApiNumber,
+        api_number);
   }
 
   // Export our version so that the sandboxed process can verify it did not
   // use an old sandbox.
   char version_string[64];
-  snprintf(version_string, sizeof(version_string), "%ld",
-           kSUIDSandboxApiNumber);
+  snprintf(
+      version_string, sizeof(version_string), "%ld", kSUIDSandboxApiNumber);
   if (setenv(kSandboxEnvironmentApiProvides, version_string, 1)) {
     perror("setenv");
     return false;
   }
 
   return true;
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   if (argc <= 1) {
     if (argc <= 0) {
       return 1;
     }
 
     fprintf(stderr, "Usage: %s <renderer process> <args...>\n", argv[0]);
     return 1;
   }
 
   // Allow someone to query our API version
@@ skipping 34 matching lines @@
     char* endptr = NULL;
     long score;
     errno = 0;
     unsigned long pid_ul = strtoul(argv[2], &endptr, 10);
     if (pid_ul == ULONG_MAX || !endptr || *endptr || errno != 0)
       return 1;
     pid_t pid = pid_ul;
     endptr = NULL;
     errno = 0;
     score = strtol(argv[3], &endptr, 10);
-    if (score == LONG_MAX || score == LONG_MIN ||
-        !endptr || *endptr || errno != 0)
+    if (score == LONG_MAX || score == LONG_MIN || !endptr || *endptr ||
+        errno != 0) {
       return 1;
+    }
     return AdjustOOMScore(pid, score);
   }
 
   // Protect the core setuid sandbox functionality with an API version
   if (!CheckAndExportApiVersion()) {
     return 1;
   }
 
   if (geteuid() != 0) {
     fprintf(stderr,
-        "The setuid sandbox is not running as root. Common causes:\n"
-        "  * An unprivileged process using ptrace on it, like a debugger.\n"
-        "  * A parent process set prctl(PR_SET_NO_NEW_PRIVS, ...)\n");
+            "The setuid sandbox is not running as root. Common causes:\n"
+            "  * An unprivileged process using ptrace on it, like a debugger.\n"
+            "  * A parent process set prctl(PR_SET_NO_NEW_PRIVS, ...)\n");
   }
 
   if (!MoveToNewNamespaces())
     return 1;
   if (!SpawnChrootHelper())
     return 1;
   if (!DropRoot())
     return 1;
   if (!SetupChildEnvironment())
     return 1;
 
   execv(argv[1], &argv[1]);
   FatalError("execv failed");
 
   return 1;
 }