directory.cc

Go to the documentation of this file.

// 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 <cstdlib>
#include <memory>
 
#include "bin/directory.h"
 
#include "bin/dartutils.h"
#include "bin/io_buffer.h"
#include "bin/namespace.h"
#include "bin/typed_data_utils.h"
#include "bin/utils.h"
#include "include/dart_api.h"
#include "platform/assert.h"
#include "platform/syslog.h"
 
namespace dart {
namespace bin {
 
char* Directory::system_temp_path_override_ = nullptr;
 
void FUNCTION_NAME(Directory_Current)(Dart_NativeArguments args) {
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  const char* current = Directory::Current(namespc);
  if (current != nullptr) {
    Dart_Handle str = ThrowIfError(DartUtils::NewString(current));
    Dart_SetReturnValue(args, str);
  } else {
    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
  }
}
 
void FUNCTION_NAME(Directory_SetCurrent)(Dart_NativeArguments args) {
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  const char* name = DartUtils::GetNativeTypedDataArgument(args, 1);
  bool result = Directory::SetCurrent(namespc, name);
  if (result) {
    Dart_SetBooleanReturnValue(args, true);
  } else {
    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
  }
}
 
void FUNCTION_NAME(Directory_Exists)(Dart_NativeArguments args) {
  const int kExists = 1;
  const int kDoesNotExist = 0;
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  const char* name = DartUtils::GetNativeTypedDataArgument(args, 1);
  Directory::ExistsResult result = Directory::Exists(namespc, name);
  if (result == Directory::EXISTS) {
    Dart_SetIntegerReturnValue(args, kExists);
  } else if (result == Directory::DOES_NOT_EXIST) {
    Dart_SetIntegerReturnValue(args, kDoesNotExist);
  } else {
    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
  }
}
 
void FUNCTION_NAME(Directory_Create)(Dart_NativeArguments args) {
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  const char* name = DartUtils::GetNativeTypedDataArgument(args, 1);
  bool result = Directory::Create(namespc, name);
  if (result) {
    Dart_SetBooleanReturnValue(args, true);
  } else {
    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
  }
}
 
void FUNCTION_NAME(Directory_SystemTemp)(Dart_NativeArguments args) {
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  const char* result = Directory::SystemTemp(namespc);
  Dart_Handle str = ThrowIfError(DartUtils::NewString(result));
  Dart_SetReturnValue(args, str);
}
 
void FUNCTION_NAME(Directory_CreateTemp)(Dart_NativeArguments args) {
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  const char* name = DartUtils::GetNativeTypedDataArgument(args, 1);
  const char* result = Directory::CreateTemp(namespc, name);
  if (result != nullptr) {
    Dart_Handle str = ThrowIfError(DartUtils::NewString(result));
    Dart_SetReturnValue(args, str);
  } else {
    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
  }
}
 
void FUNCTION_NAME(Directory_Delete)(Dart_NativeArguments args) {
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  const char* name = DartUtils::GetNativeTypedDataArgument(args, 1);
  bool result = Directory::Delete(namespc, name,
                                  DartUtils::GetNativeBooleanArgument(args, 2));
  if (result) {
    Dart_SetBooleanReturnValue(args, true);
  } else {
    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
  }
}
 
void FUNCTION_NAME(Directory_Rename)(Dart_NativeArguments args) {
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  const char* name = DartUtils::GetNativeTypedDataArgument(args, 1);
  bool result = Directory::Rename(namespc, name,
                                  DartUtils::GetNativeStringArgument(args, 2));
  if (result) {
    Dart_SetBooleanReturnValue(args, true);
  } else {
    Dart_SetReturnValue(args, DartUtils::NewDartOSError());
  }
}
 
void FUNCTION_NAME(Directory_FillWithDirectoryListing)(
    Dart_NativeArguments args) {
  Namespace* namespc = Namespace::GetNamespace(args, 0);
  // The list that we should fill.
  Dart_Handle results = Dart_GetNativeArgument(args, 1);
  Dart_Handle path = Dart_GetNativeArgument(args, 2);
  Dart_Handle dart_error;
  const char* name;
  {
    TypedDataScope data(path);
    ASSERT(data.type() == Dart_TypedData_kUint8);
    // We need to release our typed data before creating SyncDirectoryListing
    // since it allocates objects which require us to not be holding typed data
    // that has been acquired.
    name = data.GetScopedCString();
  }
  {
    // Pass the list that should hold the directory listing to the
    // SyncDirectoryListing object, which adds elements to it.
    SyncDirectoryListing sync_listing(
        results, namespc, name, DartUtils::GetNativeBooleanArgument(args, 3),
        DartUtils::GetNativeBooleanArgument(args, 4));
    Directory::List(&sync_listing);
    dart_error = sync_listing.dart_error();
  }
  if (Dart_IsError(dart_error)) {
    Dart_PropagateError(dart_error);
  } else if (!Dart_IsNull(dart_error)) {
    Dart_ThrowException(dart_error);
  }
}
 
static constexpr int kAsyncDirectoryListerFieldIndex = 0;
 
void FUNCTION_NAME(Directory_GetAsyncDirectoryListerPointer)(
    Dart_NativeArguments args) {
  AsyncDirectoryListing* listing;
  Dart_Handle dart_this = ThrowIfError(Dart_GetNativeArgument(args, 0));
  ASSERT(Dart_IsInstance(dart_this));
  ThrowIfError(
      Dart_GetNativeInstanceField(dart_this, kAsyncDirectoryListerFieldIndex,
                                  reinterpret_cast<intptr_t*>(&listing)));
  if (listing != nullptr) {
    intptr_t listing_pointer = reinterpret_cast<intptr_t>(listing);
    // Increment the listing's reference count. This native should only be
    // be called when we are about to send the AsyncDirectoryListing* to the
    // IO service.
    listing->Retain();
    Dart_SetReturnValue(args, Dart_NewInteger(listing_pointer));
  }
}
 
static void ReleaseListing(void* isolate_callback_data, void* peer) {
  AsyncDirectoryListing* listing =
      reinterpret_cast<AsyncDirectoryListing*>(peer);
  listing->Release();
}
 
void FUNCTION_NAME(Directory_SetAsyncDirectoryListerPointer)(
    Dart_NativeArguments args) {
  Dart_Handle dart_this = ThrowIfError(Dart_GetNativeArgument(args, 0));
  intptr_t listing_pointer =
      DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 1));
  AsyncDirectoryListing* listing =
      reinterpret_cast<AsyncDirectoryListing*>(listing_pointer);
  Dart_NewFinalizableHandle(dart_this, reinterpret_cast<void*>(listing),
                            sizeof(*listing), ReleaseListing);
  Dart_Handle result = Dart_SetNativeInstanceField(
      dart_this, kAsyncDirectoryListerFieldIndex, listing_pointer);
  ThrowIfError(result);
}
 
void Directory::SetSystemTemp(const char* path) {
  if (system_temp_path_override_ != nullptr) {
    free(system_temp_path_override_);
    system_temp_path_override_ = nullptr;
  }
  if (path != nullptr) {
    system_temp_path_override_ = Utils::StrDup(path);
  }
}
 
static Namespace* CObjectToNamespacePointer(CObject* cobject) {
  CObjectIntptr value(cobject);
  return reinterpret_cast<Namespace*>(value.Value());
}
 
CObject* Directory::CreateRequest(const CObjectArray& request) {
  if ((request.Length() < 1) || !request[0]->IsIntptr()) {
    return CObject::IllegalArgumentError();
  }
  Namespace* namespc = CObjectToNamespacePointer(request[0]);
  RefCntReleaseScope<Namespace> rs(namespc);
  if ((request.Length() != 2) || !request[1]->IsUint8Array()) {
    return CObject::IllegalArgumentError();
  }
  CObjectUint8Array path(request[1]);
  return Directory::Create(namespc,
                           reinterpret_cast<const char*>(path.Buffer()))
             ? CObject::True()
             : CObject::NewOSError();
}
 
CObject* Directory::DeleteRequest(const CObjectArray& request) {
  if ((request.Length() < 1) || !request[0]->IsIntptr()) {
    return CObject::IllegalArgumentError();
  }
  Namespace* namespc = CObjectToNamespacePointer(request[0]);
  RefCntReleaseScope<Namespace> rs(namespc);
  if ((request.Length() != 3) || !request[1]->IsUint8Array() ||
      !request[2]->IsBool()) {
    return CObject::IllegalArgumentError();
  }
  CObjectUint8Array path(request[1]);
  CObjectBool recursive(request[2]);
  return Directory::Delete(namespc,
                           reinterpret_cast<const char*>(path.Buffer()),
                           recursive.Value())
             ? CObject::True()
             : CObject::NewOSError();
}
 
CObject* Directory::ExistsRequest(const CObjectArray& request) {
  const int kExists = 1;
  const int kDoesNotExist = 0;
  if ((request.Length() < 1) || !request[0]->IsIntptr()) {
    return CObject::IllegalArgumentError();
  }
  Namespace* namespc = CObjectToNamespacePointer(request[0]);
  RefCntReleaseScope<Namespace> rs(namespc);
  if ((request.Length() != 2) || !request[1]->IsUint8Array()) {
    return CObject::IllegalArgumentError();
  }
  CObjectUint8Array path(request[1]);
  Directory::ExistsResult result =
      Directory::Exists(namespc, reinterpret_cast<const char*>(path.Buffer()));
  if (result == Directory::EXISTS) {
    return new CObjectInt32(CObject::NewInt32(kExists));
  } else if (result == Directory::DOES_NOT_EXIST) {
    return new CObjectInt32(CObject::NewInt32(kDoesNotExist));
  } else {
    return CObject::NewOSError();
  }
}
 
CObject* Directory::CreateTempRequest(const CObjectArray& request) {
  if ((request.Length() < 1) || !request[0]->IsIntptr()) {
    return CObject::IllegalArgumentError();
  }
  Namespace* namespc = CObjectToNamespacePointer(request[0]);
  RefCntReleaseScope<Namespace> rs(namespc);
  if ((request.Length() != 2) || !request[1]->IsUint8Array()) {
    return CObject::IllegalArgumentError();
  }
  CObjectUint8Array path(request[1]);
  const char* result = Directory::CreateTemp(
      namespc, reinterpret_cast<const char*>(path.Buffer()));
  if (result == nullptr) {
    return CObject::NewOSError();
  }
  return new CObjectString(CObject::NewString(result));
}
 
static CObject* CreateIllegalArgumentError() {
  // Respond with an illegal argument list error message.
  CObjectArray* error = new CObjectArray(CObject::NewArray(3));
  error->SetAt(0, new CObjectInt32(
                      CObject::NewInt32(AsyncDirectoryListing::kListError)));
  error->SetAt(1, CObject::Null());
  error->SetAt(2, CObject::IllegalArgumentError());
  return error;
}
 
CObject* Directory::ListStartRequest(const CObjectArray& request) {
  if ((request.Length() < 1) || !request[0]->IsIntptr()) {
    return CreateIllegalArgumentError();
  }
  Namespace* namespc = CObjectToNamespacePointer(request[0]);
  RefCntReleaseScope<Namespace> rs(namespc);
  if ((request.Length() != 4) || !request[1]->IsUint8Array() ||
      !request[2]->IsBool() || !request[3]->IsBool()) {
    return CreateIllegalArgumentError();
  }
  CObjectUint8Array path(request[1]);
  CObjectBool recursive(request[2]);
  CObjectBool follow_links(request[3]);
  AsyncDirectoryListing* dir_listing = new AsyncDirectoryListing(
      namespc, reinterpret_cast<const char*>(path.Buffer()), recursive.Value(),
      follow_links.Value());
  if (dir_listing->error()) {
    // Report error now, so we capture the correct OSError.
    CObject* err = CObject::NewOSError();
    dir_listing->Release();
    CObjectArray* error = new CObjectArray(CObject::NewArray(3));
    error->SetAt(0, new CObjectInt32(
                        CObject::NewInt32(AsyncDirectoryListing::kListError)));
    error->SetAt(1, request[1]);
    error->SetAt(2, err);
    return error;
  }
  // TODO(ajohnsen): Consider returning the first few results.
  return new CObjectIntptr(
      CObject::NewIntptr(reinterpret_cast<intptr_t>(dir_listing)));
}
 
CObject* Directory::ListNextRequest(const CObjectArray& request) {
  if ((request.Length() != 1) || !request[0]->IsIntptr()) {
    return CreateIllegalArgumentError();
  }
  CObjectIntptr ptr(request[0]);
  AsyncDirectoryListing* dir_listing =
      reinterpret_cast<AsyncDirectoryListing*>(ptr.Value());
  RefCntReleaseScope<AsyncDirectoryListing> rs(dir_listing);
  if (dir_listing->IsEmpty()) {
    return new CObjectArray(CObject::NewArray(0));
  }
  const int kArraySize = 128;
  CObjectArray* response = new CObjectArray(CObject::NewArray(kArraySize));
  dir_listing->SetArray(response, kArraySize);
  Directory::List(dir_listing);
  // In case the listing ended before it hit the buffer length, we need to
  // override the array length.
  response->AsApiCObject()->value.as_array.length = dir_listing->index();
  return response;
}
 
CObject* Directory::ListStopRequest(const CObjectArray& request) {
  if ((request.Length() != 1) || !request[0]->IsIntptr()) {
    return CreateIllegalArgumentError();
  }
  CObjectIntptr ptr(request[0]);
  AsyncDirectoryListing* dir_listing =
      reinterpret_cast<AsyncDirectoryListing*>(ptr.Value());
  RefCntReleaseScope<AsyncDirectoryListing> rs(dir_listing);
 
  // We have retained a reference to the listing here. Therefore the listing's
  // destructor can't be running. Since no further requests are dispatched by
  // the Dart code after an async stop call, this PopAll() can't be racing
  // with any other call on the listing. We don't do an extra Release(), and
  // we don't delete the weak persistent handle. The file is closed here, but
  // the memory for the listing will be cleaned up when the finalizer runs.
  dir_listing->PopAll();
  return new CObjectBool(CObject::Bool(true));
}
 
CObject* Directory::RenameRequest(const CObjectArray& request) {
  if ((request.Length() < 1) || !request[0]->IsIntptr()) {
    return CObject::IllegalArgumentError();
  }
  Namespace* namespc = CObjectToNamespacePointer(request[0]);
  RefCntReleaseScope<Namespace> rs(namespc);
  if ((request.Length() != 3) || !request[1]->IsUint8Array() ||
      !request[2]->IsString()) {
    return CObject::IllegalArgumentError();
  }
  CObjectUint8Array path(request[1]);
  CObjectString new_path(request[2]);
  return Directory::Rename(namespc,
                           reinterpret_cast<const char*>(path.Buffer()),
                           new_path.CString())
             ? CObject::True()
             : CObject::NewOSError();
}
 
bool AsyncDirectoryListing::AddFileSystemEntityToResponse(Response type,
                                                          const char* arg) {
  array_->SetAt(index_++, new CObjectInt32(CObject::NewInt32(type)));
  if (arg != nullptr) {
    size_t len = strlen(arg);
    Dart_CObject* io_buffer = CObject::NewIOBuffer(len);
    uint8_t* data = io_buffer->value.as_external_typed_data.data;
    memmove(reinterpret_cast<char*>(data), arg, len);
 
    CObjectExternalUint8Array* external_array =
        new CObjectExternalUint8Array(io_buffer);
    array_->SetAt(index_++, external_array);
  } else {
    array_->SetAt(index_++, CObject::Null());
  }
  return index_ < length_;
}
 
bool AsyncDirectoryListing::HandleDirectory(const char* dir_name) {
  return AddFileSystemEntityToResponse(kListDirectory, dir_name);
}
 
bool AsyncDirectoryListing::HandleFile(const char* file_name) {
  return AddFileSystemEntityToResponse(kListFile, file_name);
}
 
bool AsyncDirectoryListing::HandleLink(const char* link_name) {
  return AddFileSystemEntityToResponse(kListLink, link_name);
}
 
void AsyncDirectoryListing::HandleDone() {
  AddFileSystemEntityToResponse(kListDone, nullptr);
}
 
bool AsyncDirectoryListing::HandleError() {
  CObject* err = CObject::NewOSError();
  array_->SetAt(index_++, new CObjectInt32(CObject::NewInt32(kListError)));
  CObjectArray* response = new CObjectArray(CObject::NewArray(3));
  response->SetAt(0, new CObjectInt32(CObject::NewInt32(kListError)));
  // Delay calling CurrentPath() until after CObject::NewOSError() in case
  // CurrentPath() pollutes the OS error code.
  response->SetAt(1, new CObjectString(CObject::NewString(
                         error() ? "Invalid path" : CurrentPath())));
  response->SetAt(2, err);
  array_->SetAt(index_++, response);
  return index_ < length_;
}
 
bool SyncDirectoryListing::HandleDirectory(const char* dir_name) {
  // Allocates a Uint8List for dir_name, and invokes the Directory.fromRawPath
  // constructor. This avoids/delays interpreting the UTF-8 bytes in dir_name.
  // Later, client code may either choose to access FileSystemEntity.path.
  // FileSystemEntity.path will trigger UTF-8 decoding and return a path with
  // non-UTF-8 characters replaced with U+FFFD.
 
  size_t dir_name_length = strlen(dir_name);
  uint8_t* buffer = nullptr;
  Dart_Handle dir_name_dart = IOBuffer::Allocate(dir_name_length, &buffer);
  if (Dart_IsNull(dir_name_dart)) {
    dart_error_ = DartUtils::NewDartOSError();
    return false;
  }
  memmove(buffer, dir_name, dir_name_length);
  Dart_Handle constructor_name = from_raw_path_string_;
  Dart_Handle dir =
      Dart_New(directory_type_, constructor_name, 1, &dir_name_dart);
  Dart_Handle result = Dart_Invoke(results_, add_string_, 1, &dir);
  if (Dart_IsError(result)) {
    dart_error_ = result;
    return false;
  }
  return true;
}
 
bool SyncDirectoryListing::HandleLink(const char* link_name) {
  // Allocates a Uint8List for dir_name, and invokes the Directory.fromRawPath
  // constructor. This avoids/delays interpreting the UTF-8 bytes in dir_name.
  // Later, client code may either choose to access FileSystemEntity.path.
  // FileSystemEntity.path will trigger UTF-8 decoding and return a path with
  // non-UTF-8 characters replaced with U+FFFD.
 
  size_t link_name_length = strlen(link_name);
  uint8_t* buffer = nullptr;
  Dart_Handle link_name_dart = IOBuffer::Allocate(link_name_length, &buffer);
  if (Dart_IsNull(link_name_dart)) {
    dart_error_ = DartUtils::NewDartOSError();
    return false;
  }
  memmove(buffer, link_name, link_name_length);
  Dart_Handle constructor_name = from_raw_path_string_;
  Dart_Handle link = Dart_New(link_type_, constructor_name, 1, &link_name_dart);
  Dart_Handle result = Dart_Invoke(results_, add_string_, 1, &link);
  if (Dart_IsError(result)) {
    dart_error_ = result;
    return false;
  }
  return true;
}
 
bool SyncDirectoryListing::HandleFile(const char* file_name) {
  // Allocates a Uint8List for dir_name, and invokes the Directory.fromRawPath
  // constructor. This avoids/delays interpreting the UTF-8 bytes in dir_name.
  // Later, client code may either choose to access FileSystemEntity.path.
  // FileSystemEntity.path will trigger UTF-8 decoding and return a path with
  // non-UTF-8 characters replaced with U+FFFD.
 
  size_t file_name_length = strlen(file_name);
  uint8_t* buffer = nullptr;
  Dart_Handle file_name_dart = IOBuffer::Allocate(file_name_length, &buffer);
  if (Dart_IsNull(file_name_dart)) {
    dart_error_ = DartUtils::NewDartOSError();
    return false;
  }
  memmove(buffer, file_name, file_name_length);
  Dart_Handle constructor_name = from_raw_path_string_;
  Dart_Handle file = Dart_New(file_type_, constructor_name, 1, &file_name_dart);
  Dart_Handle result = Dart_Invoke(results_, add_string_, 1, &file);
  if (Dart_IsError(result)) {
    dart_error_ = result;
    return false;
  }
  return true;
}
 
bool SyncDirectoryListing::HandleError() {
  Dart_Handle dart_os_error = DartUtils::NewDartOSError();
  Dart_Handle args[3];
  args[0] = dart_os_error;
  args[1] = DartUtils::NewString("Directory listing failed");
  args[2] = DartUtils::NewString(error() ? "Invalid path" : CurrentPath());
 
  dart_error_ = Dart_New(
      DartUtils::GetDartType(DartUtils::kIOLibURL, "FileSystemException"),
      DartUtils::NewString("_fromOSError"), 3, args);
  return false;
}
 
static bool ListNext(DirectoryListing* listing) {
  switch (listing->top()->Next(listing)) {
    case kListFile:
      return listing->HandleFile(listing->CurrentPath());
 
    case kListLink:
      return listing->HandleLink(listing->CurrentPath());
 
    case kListDirectory:
      if (listing->recursive()) {
        listing->Push(new DirectoryListingEntry(listing->top()));
      }
      return listing->HandleDirectory(listing->CurrentPath());
 
    case kListError:
      return listing->HandleError();
 
    case kListDone:
      listing->Pop();
      if (listing->IsEmpty()) {
        listing->HandleDone();
        return false;
      } else {
        return true;
      }
 
    default:
      UNREACHABLE();
  }
  return false;
}
 
void Directory::List(DirectoryListing* listing) {
  if (listing->error()) {
    listing->HandleError();
    listing->HandleDone();
  } else {
    while (ListNext(listing)) {
    }
  }
}
 
const char* Directory::Current(Namespace* namespc) {
  return Namespace::GetCurrent(namespc);
}
 
bool Directory::SetCurrent(Namespace* namespc, const char* name) {
  return Namespace::SetCurrent(namespc, name);
}
 
}  // namespace bin
}  // namespace dart