linux: turn on -Wextra

sandbox/linux/suid/sandbox.c

 // Copyright (c) 2009 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
 
 #define _GNU_SOURCE
 #include <asm/unistd.h>
 #include <errno.h>
 #include <fcntl.h>
@@ skipping 72 matching lines @@
     return -1;
   }
 
   // Some people mount /tmp on a non-POSIX filesystem (e.g. NFS). This
   // breaks all sorts of assumption in our code. So, if we don't recognize the
   // filesystem, we will try to use an alternative location for our temp
   // directory.
   char tempDirectoryTemplate[80] = "/tmp/chrome-sandbox-chroot-XXXXXX";
   struct statfs sfs;
   if (!statfs("/tmp", &sfs) &&
-      sfs.f_type != BTRFS_SUPER_MAGIC &&
-      sfs.f_type != EXT2_SUPER_MAGIC &&
-      sfs.f_type != EXT3_SUPER_MAGIC &&
-      sfs.f_type != EXT4_SUPER_MAGIC &&
-      sfs.f_type != REISERFS_SUPER_MAGIC &&
-      sfs.f_type != TMPFS_MAGIC &&
-      sfs.f_type != XFS_SUPER_MAGIC) {
+      (unsigned long)sfs.f_type != BTRFS_SUPER_MAGIC &&
+      (unsigned long)sfs.f_type != EXT2_SUPER_MAGIC &&
+      (unsigned long)sfs.f_type != EXT3_SUPER_MAGIC &&
+      (unsigned long)sfs.f_type != EXT4_SUPER_MAGIC &&
+      (unsigned long)sfs.f_type != REISERFS_SUPER_MAGIC &&
+      (unsigned long)sfs.f_type != TMPFS_MAGIC &&
+      (unsigned long)sfs.f_type != XFS_SUPER_MAGIC) {
     // If /dev/shm exists, it is supposed to be a tmpfs filesystem. While we
     // are not actually using it for shared memory, moving our temp directory
     // into a known tmpfs filesystem is preferable over using a potentially
     // unreliable non-POSIX filesystem.
     if (!statfs("/dev/shm", &sfs) && sfs.f_type == TMPFS_MAGIC) {
       *tempDirectoryTemplate = '\000';
       strncat(tempDirectoryTemplate, "/dev/shm/chrome-sandbox-chroot-XXXXXX",
               sizeof(tempDirectoryTemplate) - 1);
     } else {
       // Neither /tmp is a well-known POSIX filesystem, nor /dev/shm is a
@@ skipping 20 matching lines @@
   }
 
   if (rmdir(temp_dir)) {
     perror("rmdir");
     return -1;
   }
 
   char proc_self_fd_str[128];
   int printed = snprintf(proc_self_fd_str, sizeof(proc_self_fd_str),
                          "/proc/self/fd/%d", chroot_dir_fd);
-  if (printed < 0 || printed >= sizeof(proc_self_fd_str)) {
+  if (printed < 0 || printed >= (int)sizeof(proc_self_fd_str)) {
     fprintf(stderr, "Error in snprintf");
     return -1;
   }
 
   if (fchown(chroot_dir_fd, 0 /* root */, 0 /* root */)) {
     fprintf(stderr, "Could not set up sandbox work directory. Maybe, /tmp is "
                     "a non-POSIX filesystem and /dev/shm doesn't exist "
                     "either. Consider mounting a \"tmpfs\" on /tmp.\n");
     return -1;
   }
@@ skipping 88 matching lines @@
 static bool SpawnChrootHelper() {
   const int chroot_signal_fd = CloneChrootHelperProcess();
 
   if (chroot_signal_fd == -1)
     return false;
 
   // In the parent process, we install an environment variable containing the
   // number of the file descriptor.
   char desc_str[64];
   int printed = snprintf(desc_str, sizeof(desc_str), "%d", chroot_signal_fd);
-  if (printed < 0 || printed >= sizeof(desc_str)) {
+  if (printed < 0 || printed >= (int)sizeof(desc_str)) {
     fprintf(stderr, "Failed to snprintf\n");
     return false;
   }
 
   if (setenv(kSandboxDescriptorEnvironmentVarName, desc_str, 1)) {
     perror("setenv");
     close(chroot_signal_fd);
     return false;
   }
 
@@ skipping 112 matching lines @@
     if (!FindProcessHoldingSocket(&pid, inode))
       return 1;
     printf("%d\n", pid);
     return 0;
   }
   // Likewise, we cannot adjust /proc/pid/oom_adj for sandboxed renderers
   // because those files are owned by root. So we need another helper here.
   if (argc == 4 && (0 == strcmp(argv[1], kAdjustOOMScoreSwitch))) {
     char* endptr;
     long score;
-    pid_t pid = strtoul(argv[2], &endptr, 10);
-    if (pid == ULONG_MAX || *endptr)
+    unsigned long pid_ul = strtoul(argv[2], &endptr, 10);
+    if (pid_ul == ULONG_MAX || *endptr)
       return 1;
+    pid_t pid = pid_ul;
     score = strtol(argv[3], &endptr, 10);
     if (score == LONG_MAX || score == LONG_MIN || *endptr)
       return 1;
     return AdjustOOMScore(pid, score);
   }
 
   if (!MoveToNewPIDNamespace())
     return 1;
   if (!SpawnChrootHelper())
     return 1;
   if (!DropRoot())
     return 1;
   if (!SetupChildEnvironment())
     return 1;
 
   execv(argv[1], &argv[1]);
   FatalError("execv failed");
 
   return 1;
 }