Seccomp sandbox changes (performance and correctness fixes, primarily targetting x86-32)

sandbox/linux/seccomp/maps.cc

+// Copyright (c) 2010 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 <errno.h>
 #include <fcntl.h>
 #include <iostream>
 #include <linux/unistd.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <sys/ptrace.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ skipping 24 matching lines @@
         }
       }
       char *ptr = buf;
       if (!long_line) {
         long_line = true;
         unsigned long start = strtoul(ptr, &ptr, 16);
         unsigned long stop = strtoul(ptr + 1, &ptr, 16);
         while (*ptr == ' ' || *ptr == '\t') ++ptr;
         char *perm_ptr = ptr;
         while (*ptr && *ptr != ' ' && *ptr != '\t') ++ptr;
-        std::string perm(perm_ptr, ptr - perm_ptr);
+        string perm(perm_ptr, ptr - perm_ptr);
         unsigned long offset = strtoul(ptr, &ptr, 16);
         while (*ptr == ' ' || *ptr == '\t') ++ptr;
         char *id_ptr = ptr;
         while (*ptr && *ptr != ' ' && *ptr != '\t') ++ptr;
         while (*ptr == ' ' || *ptr == '\t') ++ptr;
         while (*ptr && *ptr != ' ' && *ptr != '\t') ++ptr;
-        std::string id(id_ptr, ptr - id_ptr);
+        string id(id_ptr, ptr - id_ptr);
         while (*ptr == ' ' || *ptr == '\t') ++ptr;
         char *library_ptr = ptr;
         while (*ptr && *ptr != ' ' && *ptr != '\t' && *ptr != '\n') ++ptr;
-        std::string library(library_ptr, ptr - library_ptr);
+        string library(library_ptr, ptr - library_ptr);
         bool isVDSO = false;
         if (library == "[vdso]") {
           // /proc/self/maps has a misleading file offset in the [vdso] entry.
           // Override it with a sane value.
           offset = 0;
           isVDSO = true;
         } else if (library == "[vsyscall]") {
           vsyscall_ = reinterpret_cast<char *>(start);
         } else if (library.empty() || library[0] == '[') {
           goto skip_entry;
         }
         int prot = 0;
-        if (perm.find('r') != std::string::npos) {
+        if (perm.find('r') != string::npos) {
           prot |= PROT_READ;
         }
-        if (perm.find('w') != std::string::npos) {
+        if (perm.find('w') != string::npos) {
           prot |= PROT_WRITE;
         }
-        if (perm.find('x') != std::string::npos) {
+        if (perm.find('x') != string::npos) {
           prot |= PROT_EXEC;
         }
         if ((prot & (PROT_EXEC | PROT_READ)) == 0) {
           goto skip_entry;
         }
         Library* lib = &libs_[id + ' ' + library];
         lib->setLibraryInfo(this);
         lib->addMemoryRange(reinterpret_cast<void *>(start),
                             reinterpret_cast<void *>(stop),
                             Elf_Addr(offset),
@@ skipping 53 matching lines @@
 }
 
 bool Maps::Iterator::operator==(const Maps::Iterator& iter) const {
   return getIterator().operator==(iter.getIterator());
 }
 
 bool Maps::Iterator::operator!=(const Maps::Iterator& iter) const {
   return !operator==(iter);
 }
 
-std::string Maps::Iterator::name() const {
+Maps::string Maps::Iterator::name() const {
   return getIterator()->first;
 }
 
 // Test whether a line ends with "[stack]"; used for identifying the
 // stack entry of /proc/self/maps.
 static bool isStackLine(char* buf, char* end) {
   char* ptr = buf;
   for ( ; *ptr != '\n' && ptr < end; ++ptr)
     ;
   if (ptr < end && ptr - 7 > buf) {
@@ skipping 92 matching lines @@
         break;
       }
     }
   } while (len || long_line);
   new_addr = NULL;
 done:
   return reinterpret_cast<char*>(new_addr);
 }
 
 } // namespace