[dart:io] Namespaces for file IO

runtime/bin/file_win.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(HOST_OS_WINDOWS)
 
 #include "bin/file.h"
 
 #include <WinIoCtl.h>  // NOLINT
 #include <fcntl.h>     // NOLINT
 #include <io.h>        // NOLINT
 #include <stdio.h>     // NOLINT
 #include <string.h>    // NOLINT
 #include <sys/stat.h>  // NOLINT
 #include <sys/utime.h>  // NOLINT
 
 #include "bin/builtin.h"
 #include "bin/log.h"
+#include "bin/namespace.h"
 #include "bin/utils.h"
 #include "bin/utils_win.h"
 #include "platform/utils.h"
 
 namespace dart {
 namespace bin {
 
 class FileHandle {
  public:
   explicit FileHandle(int fd) : fd_(fd) {}
@@ skipping 235 matching lines @@
   if ((((mode & kWrite) != 0) && ((mode & kTruncate) == 0)) ||
       (((mode & kWriteOnly) != 0) && ((mode & kTruncate) == 0))) {
     int64_t position = _lseeki64(fd, 0, SEEK_END);
     if (position < 0) {
       return NULL;
     }
   }
   return new File(new FileHandle(fd));
 }
 
-File* File::Open(const char* path, FileOpenMode mode) {
+File* File::Open(Namespace* namespc, const char* path, FileOpenMode mode) {
   Utf8ToWideScope system_name(path);
   File* file = FileOpenW(system_name.wide(), mode);
   return file;
 }
 
 File* File::OpenStdio(int fd) {
   int stdio_fd = -1;
   switch (fd) {
     case 1:
       stdio_fd = _fileno(stdout);
@@ skipping 13 matching lines @@
   if (stat_status != 0) {
     return false;
   }
   if ((st->st_mode & S_IFMT) != S_IFREG) {
     SetLastError(ERROR_NOT_SUPPORTED);
     return false;
   }
   return true;
 }
 
-bool File::Exists(const char* name) {
+bool File::Exists(Namespace* namespc, const char* name) {
   struct __stat64 st;
   Utf8ToWideScope system_name(name);
   return StatHelper(system_name.wide(), &st);
 }
 
-bool File::Create(const char* name) {
+bool File::Create(Namespace* namespc, const char* name) {
   Utf8ToWideScope system_name(name);
   int fd = _wopen(system_name.wide(), O_RDONLY | O_CREAT, 0666);
   if (fd < 0) {
     return false;
   }
   return (close(fd) == 0);
 }
 
 // This structure is needed for creating and reading Junctions.
 typedef struct _REPARSE_DATA_BUFFER {
@@ skipping 21 matching lines @@
 
     struct {
       UCHAR DataBuffer[1];
     } GenericReparseBuffer;
   };
 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
 
 static const int kReparseDataHeaderSize = sizeof ULONG + 2 * sizeof USHORT;
 static const int kMountPointHeaderSize = 4 * sizeof USHORT;
 
-bool File::CreateLink(const char* utf8_name, const char* utf8_target) {
+bool File::CreateLink(Namespace* namespc,
+                      const char* utf8_name,
+                      const char* utf8_target) {
   Utf8ToWideScope name(utf8_name);
   int create_status = CreateDirectoryW(name.wide(), NULL);
   // If the directory already existed, treat it as a success.
   if ((create_status == 0) &&
       ((GetLastError() != ERROR_ALREADY_EXISTS) ||
        ((GetFileAttributesW(name.wide()) & FILE_ATTRIBUTE_DIRECTORY) != 0))) {
     return false;
   }
 
   HANDLE dir_handle = CreateFileW(
@@ skipping 36 matching lines @@
       dir_handle, FSCTL_SET_REPARSE_POINT, reparse_data_buffer,
       reparse_data_buffer->ReparseDataLength + kReparseDataHeaderSize, NULL, 0,
       &dummy_received_bytes, NULL);
   free(reparse_data_buffer);
   if (CloseHandle(dir_handle) == 0) {
     return false;
   }
   return (result != 0);
 }
 
-bool File::Delete(const char* name) {
+bool File::Delete(Namespace* namespc, const char* name) {
   Utf8ToWideScope system_name(name);
   int status = _wremove(system_name.wide());
   return status != -1;
 }
 
-bool File::DeleteLink(const char* name) {
+bool File::DeleteLink(Namespace* namespc, const char* name) {
   Utf8ToWideScope system_name(name);
   bool result = false;
   DWORD attributes = GetFileAttributesW(system_name.wide());
   if ((attributes != INVALID_FILE_ATTRIBUTES) &&
       (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     // It's a junction(link), delete it.
     result = (RemoveDirectoryW(system_name.wide()) != 0);
   } else {
     SetLastError(ERROR_NOT_A_REPARSE_POINT);
   }
   return result;
 }
 
-bool File::Rename(const char* old_path, const char* new_path) {
-  File::Type type = GetType(old_path, false);
+bool File::Rename(Namespace* namespc,
+                  const char* old_path,
+                  const char* new_path) {
+  File::Type type = GetType(namespc, old_path, false);
   if (type == kIsFile) {
     Utf8ToWideScope system_old_path(old_path);
     Utf8ToWideScope system_new_path(new_path);
     DWORD flags = MOVEFILE_WRITE_THROUGH | MOVEFILE_REPLACE_EXISTING;
     int move_status =
         MoveFileExW(system_old_path.wide(), system_new_path.wide(), flags);
     return (move_status != 0);
   } else {
     SetLastError(ERROR_FILE_NOT_FOUND);
   }
   return false;
 }
 
-bool File::RenameLink(const char* old_path, const char* new_path) {
-  File::Type type = GetType(old_path, false);
+bool File::RenameLink(Namespace* namespc,
+                      const char* old_path,
+                      const char* new_path) {
+  File::Type type = GetType(namespc, old_path, false);
   if (type == kIsLink) {
     Utf8ToWideScope system_old_path(old_path);
     Utf8ToWideScope system_new_path(new_path);
     DWORD flags = MOVEFILE_WRITE_THROUGH | MOVEFILE_REPLACE_EXISTING;
     int move_status =
         MoveFileExW(system_old_path.wide(), system_new_path.wide(), flags);
     return (move_status != 0);
   } else {
     SetLastError(ERROR_FILE_NOT_FOUND);
   }
   return false;
 }
 
-bool File::Copy(const char* old_path, const char* new_path) {
-  File::Type type = GetType(old_path, false);
+bool File::Copy(Namespace* namespc,
+                const char* old_path,
+                const char* new_path) {
+  File::Type type = GetType(namespc, old_path, false);
   if (type == kIsFile) {
     Utf8ToWideScope system_old_path(old_path);
     Utf8ToWideScope system_new_path(new_path);
     bool success = CopyFileExW(system_old_path.wide(), system_new_path.wide(),
                                NULL, NULL, NULL, 0) != 0;
     return success;
   } else {
     SetLastError(ERROR_FILE_NOT_FOUND);
   }
   return false;
 }
 
-int64_t File::LengthFromPath(const char* name) {
+int64_t File::LengthFromPath(Namespace* namespc, const char* name) {
   struct __stat64 st;
   Utf8ToWideScope system_name(name);
   if (!StatHelper(system_name.wide(), &st)) {
     return -1;
   }
   return st.st_size;
 }
 
-const char* File::LinkTarget(const char* pathname) {
+const char* File::LinkTarget(Namespace* namespc, const char* pathname) {
   const wchar_t* name = StringUtilsWin::Utf8ToWide(pathname);
   HANDLE dir_handle = CreateFileW(
       name, GENERIC_READ,
       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
       OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
       NULL);
   if (dir_handle == INVALID_HANDLE_VALUE) {
     return NULL;
   }
 
@@ skipping 42 matching lines @@
                                         0, NULL, NULL);
   char* utf8_target = DartUtils::ScopedCString(utf8_length + 1);
   if (0 == WideCharToMultiByte(CP_UTF8, 0, target, target_length, utf8_target,
                                utf8_length, NULL, NULL)) {
     return NULL;
   }
   utf8_target[utf8_length] = '\0';
   return utf8_target;
 }
 
-void File::Stat(const char* name, int64_t* data) {
-  File::Type type = GetType(name, false);
+void File::Stat(Namespace* namespc, const char* name, int64_t* data) {
+  File::Type type = GetType(namespc, name, false);
   data[kType] = type;
   if (type != kDoesNotExist) {
     struct _stat64 st;
     Utf8ToWideScope system_name(name);
     int stat_status = _wstat64(system_name.wide(), &st);
     if (stat_status == 0) {
       data[kCreatedTime] = st.st_ctime * 1000;
       data[kModifiedTime] = st.st_mtime * 1000;
       data[kAccessedTime] = st.st_atime * 1000;
       data[kMode] = st.st_mode;
       data[kSize] = st.st_size;
     } else {
       data[kType] = File::kDoesNotExist;
     }
   }
 }
 
-time_t File::LastAccessed(const char* name) {
+time_t File::LastAccessed(Namespace* namespc, const char* name) {
   struct __stat64 st;
   Utf8ToWideScope system_name(name);
   if (!StatHelper(system_name.wide(), &st)) {
     return -1;
   }
   return st.st_atime;
 }
 
-time_t File::LastModified(const char* name) {
+time_t File::LastModified(Namespace* namespc, const char* name) {
   struct __stat64 st;
   Utf8ToWideScope system_name(name);
   if (!StatHelper(system_name.wide(), &st)) {
     return -1;
   }
   return st.st_mtime;
 }
 
-bool File::SetLastAccessed(const char* name, int64_t millis) {
+bool File::SetLastAccessed(Namespace* namespc,
+                           const char* name,
+                           int64_t millis) {
   // First get the current times.
   struct __stat64 st;
   Utf8ToWideScope system_name(name);
   if (!StatHelper(system_name.wide(), &st)) {
     return false;
   }
 
   // Set the new time:
   struct __utimbuf64 times;
   times.actime = millis / kMillisecondsPerSecond;
   times.modtime = st.st_mtime;
   return _wutime64(system_name.wide(), &times) == 0;
 }
 
-bool File::SetLastModified(const char* name, int64_t millis) {
+bool File::SetLastModified(Namespace* namespc,
+                           const char* name,
+                           int64_t millis) {
   // First get the current times.
   struct __stat64 st;
   Utf8ToWideScope system_name(name);
   if (!StatHelper(system_name.wide(), &st)) {
     return false;
   }
 
   // Set the new time:
   struct __utimbuf64 times;
   times.actime = st.st_atime;
   times.modtime = millis / kMillisecondsPerSecond;
   return _wutime64(system_name.wide(), &times) == 0;
 }
 
 bool File::IsAbsolutePath(const char* pathname) {
   // Should we consider network paths?
   if (pathname == NULL) {
     return false;
   }
   return ((strlen(pathname) > 2) && (pathname[1] == ':') &&
           ((pathname[2] == '\\') || (pathname[2] == '/')));
 }
 
-const char* File::GetCanonicalPath(const char* pathname) {
+const char* File::GetCanonicalPath(Namespace* namespc, const char* pathname) {
   Utf8ToWideScope system_name(pathname);
   HANDLE file_handle =
       CreateFileW(system_name.wide(), 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
                   FILE_FLAG_BACKUP_SEMANTICS, NULL);
   if (file_handle == INVALID_HANDLE_VALUE) {
     return NULL;
   }
   wchar_t dummy_buffer[1];
   int required_size =
       GetFinalPathNameByHandle(file_handle, dummy_buffer, 0, VOLUME_NAME_DOS);
@@ skipping 31 matching lines @@
   // This is already UTF-8 encoded.
   return "\\\\";
 }
 
 File::StdioHandleType File::GetStdioHandleType(int fd) {
   // Treat all stdio handles as pipes. The Windows event handler and
   // socket code will handle the different handle types.
   return kPipe;
 }
 
-File::Type File::GetType(const char* pathname, bool follow_links) {
+File::Type File::GetType(Namespace* namespc,
+                         const char* pathname,
+                         bool follow_links) {
   // Convert to wchar_t string.
   Utf8ToWideScope name(pathname);
   DWORD attributes = GetFileAttributesW(name.wide());
   File::Type result = kIsFile;
   if (attributes == INVALID_FILE_ATTRIBUTES) {
     result = kDoesNotExist;
   } else if ((attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
     if (follow_links) {
       HANDLE dir_handle =
           CreateFileW(name.wide(), 0,
                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                       NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
       if (dir_handle == INVALID_HANDLE_VALUE) {
         result = File::kIsLink;
       } else {
         CloseHandle(dir_handle);
         result = File::kIsDirectory;
       }
     } else {
       result = kIsLink;
     }
   } else if ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
     result = kIsDirectory;
   }
   return result;
 }
 
-File::Identical File::AreIdentical(const char* file_1, const char* file_2) {
+File::Identical File::AreIdentical(Namespace* namespc,
+                                   const char* file_1,
+                                   const char* file_2) {
   BY_HANDLE_FILE_INFORMATION file_info[2];
   const char* file_names[2] = {file_1, file_2};
   for (int i = 0; i < 2; ++i) {
     Utf8ToWideScope wide_name(file_names[i]);
     HANDLE file_handle = CreateFileW(
         wide_name.wide(), 0,
         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
         OPEN_EXISTING,
         FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
     if (file_handle == INVALID_HANDLE_VALUE) {
@@ skipping 17 matching lines @@
     return kIdentical;
   } else {
     return kDifferent;
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_WINDOWS)