Fixes some memory leaks in //runtime/bin

runtime/bin/file_linux.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_LINUX)
 
 #include "bin/file.h"
 
 #include <errno.h>  // NOLINT
 #include <fcntl.h>  // NOLINT
 #include <sys/stat.h>  // NOLINT
 #include <sys/types.h>  // NOLINT
 #include <sys/sendfile.h>  // NOLINT
 #include <unistd.h>  // NOLINT
 #include <libgen.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/log.h"
 #include "platform/signal_blocker.h"
 #include "platform/utils.h"
 
-
 namespace dart {
 namespace bin {
 
 class FileHandle {
  public:
   explicit FileHandle(int fd) : fd_(fd) { }
   ~FileHandle() { }
   int fd() const { return fd_; }
   void set_fd(int fd) { fd_ = fd; }
 
@@ skipping 71 matching lines @@
 
 
 bool File::Flush() {
   ASSERT(handle_->fd() >= 0);
   return NO_RETRY_EXPECTED(fsync(handle_->fd())) != -1;
 }
 
 
 bool File::Lock(File::LockType lock, int64_t start, int64_t end) {
   ASSERT(handle_->fd() >= 0);
-  ASSERT(end == -1 || end > start);
+  ASSERT((end == -1) || (end > start));
   struct flock fl;
   switch (lock) {
     case File::kLockUnlock:
       fl.l_type = F_UNLCK;
       break;
     case File::kLockShared:
       fl.l_type = F_RDLCK;
       break;
     case File::kLockExclusive:
       fl.l_type = F_WRLCK;
@@ skipping 13 matching lines @@
 int64_t File::Length() {
   ASSERT(handle_->fd() >= 0);
   struct stat64 st;
   if (TEMP_FAILURE_RETRY(fstat64(handle_->fd(), &st)) == 0) {
     return st.st_size;
   }
   return -1;
 }
 
 
-File* File::Open(const char* name, FileOpenMode mode) {
+File* File::FileOpenW(const wchar_t* system_name, FileOpenMode mode) {
+  UNREACHABLE();
+  return NULL;
+}
+
+
+File* File::ScopedOpen(const char* name, FileOpenMode mode) {
   // Report errors for non-regular files.
   struct stat64 st;
   if (TEMP_FAILURE_RETRY(stat64(name, &st)) == 0) {
     // Only accept regular files and character devices.
     if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
       errno = (S_ISDIR(st.st_mode)) ? EISDIR : ENOENT;
       return NULL;
     }
   }
   int flags = O_RDONLY;
@@ skipping 17 matching lines @@
       (((mode & kWriteOnly) != 0) && ((mode & kTruncate) == 0))) {
     int64_t position = NO_RETRY_EXPECTED(lseek64(fd, 0, SEEK_END));
     if (position < 0) {
       return NULL;
     }
   }
   return new File(new FileHandle(fd));
 }
 
 
+File* File::Open(const char* path, FileOpenMode mode) {
+  // ScopedOpen doesn't actually need a scope.
+  return ScopedOpen(path, mode);
+}
+
+
 File* File::OpenStdio(int fd) {
-  if (fd < 0 || 2 < fd) return NULL;
+  if ((fd < 0) || (2 < fd)) {
+    return NULL;
+  }
   return new File(new FileHandle(fd));
 }
 
 
 bool File::Exists(const char* name) {
   struct stat64 st;
   if (TEMP_FAILURE_RETRY(stat64(name, &st)) == 0) {
     return S_ISREG(st.st_mode);
   } else {
     return false;
@@ skipping 85 matching lines @@
     int64_t offset = 0;
     intptr_t result = 1;
     while (result > 0) {
       // Loop to ensure we copy everything, and not only up to 2GB.
       result = NO_RETRY_EXPECTED(
           sendfile64(new_fd, old_fd, &offset, kMaxUint32));
     }
     // From sendfile man pages:
     //   Applications may wish to fall back to read(2)/write(2) in the case
     //   where sendfile() fails with EINVAL or ENOSYS.
-    if (result < 0 && (errno == EINVAL || errno == ENOSYS)) {
+    if ((result < 0) && ((errno == EINVAL) || (errno == ENOSYS))) {
       const intptr_t kBufferSize = 8 * KB;
       uint8_t buffer[kBufferSize];
       while ((result = TEMP_FAILURE_RETRY(
           read(old_fd, buffer, kBufferSize))) > 0) {
         int wrote = TEMP_FAILURE_RETRY(write(new_fd, buffer, result));
         if (wrote != result) {
           result = -1;
           break;
         }
       }
@@ skipping 56 matching lines @@
 
 time_t File::LastModified(const char* name) {
   struct stat64 st;
   if (TEMP_FAILURE_RETRY(stat64(name, &st)) == 0) {
     return st.st_mtime;
   }
   return -1;
 }
 
 
-char* File::LinkTarget(const char* pathname) {
+const char* File::LinkTarget(const char* pathname) {
   struct stat64 link_stats;
-  if (TEMP_FAILURE_RETRY(lstat64(pathname, &link_stats)) != 0) return NULL;
+  if (TEMP_FAILURE_RETRY(lstat64(pathname, &link_stats)) != 0) {
+    return NULL;
+  }
   if (!S_ISLNK(link_stats.st_mode)) {
     errno = ENOENT;
     return NULL;
   }
   // Don't rely on the link_stats.st_size for the size of the link
   // target. For some filesystems, e.g. procfs, this value is always
   // 0. Also the link might have changed before the readlink call.
   const int kBufferSize = PATH_MAX + 1;
   char target[kBufferSize];
   size_t target_size = TEMP_FAILURE_RETRY(
       readlink(pathname, target, kBufferSize));
   if (target_size <= 0) {
     return NULL;
   }
-  char* target_name = reinterpret_cast<char*>(malloc(target_size + 1));
-  if (target_name == NULL) {
-    return NULL;
-  }
+  char* target_name = DartUtils::ScopedCString(target_size + 1);
+  ASSERT(target_name != NULL);
   memmove(target_name, target, target_size);
   target_name[target_size] = '\0';
   return target_name;
 }
 
 
 bool File::IsAbsolutePath(const char* pathname) {
   return (pathname != NULL && pathname[0] == '/');
 }
 
 
-char* File::GetCanonicalPath(const char* pathname) {
+const char* File::GetCanonicalPath(const char* pathname) {
   char* abs_path = NULL;
   if (pathname != NULL) {
+    char* resolved_path = DartUtils::ScopedCString(PATH_MAX + 1);
+    ASSERT(resolved_path != NULL);
     do {
-      abs_path = realpath(pathname, NULL);
+      abs_path = realpath(pathname, resolved_path);
     } while (abs_path == NULL && errno == EINTR);
     ASSERT(abs_path == NULL || IsAbsolutePath(abs_path));
+    ASSERT(abs_path == NULL || (abs_path == resolved_path));
   }
   return abs_path;
 }
 
 
 const char* File::PathSeparator() {
   return "/";
 }
 
 
 const char* File::StringEscapedPathSeparator() {
   return "/";
 }
 
 
 File::StdioHandleType File::GetStdioHandleType(int fd) {
-  ASSERT(0 <= fd && fd <= 2);
+  ASSERT((0 <= fd) && (fd <= 2));
   struct stat64 buf;
   int result = TEMP_FAILURE_RETRY(fstat64(fd, &buf));
   if (result == -1) {
     const int kBufferSize = 1024;
     char error_buf[kBufferSize];
     FATAL2("Failed stat on file descriptor %d: %s", fd,
            Utils::StrError(errno, error_buf, kBufferSize));
   }
-  if (S_ISCHR(buf.st_mode)) return kTerminal;
-  if (S_ISFIFO(buf.st_mode)) return kPipe;
-  if (S_ISSOCK(buf.st_mode)) return kSocket;
-  if (S_ISREG(buf.st_mode)) return kFile;
+  if (S_ISCHR(buf.st_mode)) {
+    return kTerminal;
+  }
+  if (S_ISFIFO(buf.st_mode)) {
+    return kPipe;
+  }
+  if (S_ISSOCK(buf.st_mode)) {
+    return kSocket;
+  }
+  if (S_ISREG(buf.st_mode)) {
+    return kFile;
+  }
   return kOther;
 }
 
 
 File::Type File::GetType(const char* pathname, bool follow_links) {
   struct stat64 entry_info;
   int stat_success;
   if (follow_links) {
     stat_success = TEMP_FAILURE_RETRY(stat64(pathname, &entry_info));
   } else {
     stat_success = TEMP_FAILURE_RETRY(lstat64(pathname, &entry_info));
   }
-  if (stat_success == -1) return File::kDoesNotExist;
-  if (S_ISDIR(entry_info.st_mode)) return File::kIsDirectory;
-  if (S_ISREG(entry_info.st_mode)) return File::kIsFile;
-  if (S_ISLNK(entry_info.st_mode)) return File::kIsLink;
+  if (stat_success == -1) {
+    return File::kDoesNotExist;
+  }
+  if (S_ISDIR(entry_info.st_mode)) {
+    return File::kIsDirectory;
+  }
+  if (S_ISREG(entry_info.st_mode)) {
+    return File::kIsFile;
+  }
+  if (S_ISLNK(entry_info.st_mode)) {
+    return File::kIsLink;
+  }
   return File::kDoesNotExist;
 }
 
 
 File::Identical File::AreIdentical(const char* file_1, const char* file_2) {
   struct stat64 file_1_info;
   struct stat64 file_2_info;
-  if (TEMP_FAILURE_RETRY(lstat64(file_1, &file_1_info)) == -1 ||
-      TEMP_FAILURE_RETRY(lstat64(file_2, &file_2_info)) == -1) {
+  if ((TEMP_FAILURE_RETRY(lstat64(file_1, &file_1_info)) == -1) ||
+      (TEMP_FAILURE_RETRY(lstat64(file_2, &file_2_info)) == -1)) {
     return File::kError;
   }
-  return (file_1_info.st_ino == file_2_info.st_ino &&
-          file_1_info.st_dev == file_2_info.st_dev) ?
+  return ((file_1_info.st_ino == file_2_info.st_ino) &&
+          (file_1_info.st_dev == file_2_info.st_dev)) ?
       File::kIdentical :
       File::kDifferent;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)