217 lines
8 KiB
C++
217 lines
8 KiB
C++
// Copyright (c) 2014 GitHub, Inc.
|
|
// Use of this source code is governed by the MIT license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include <vector>
|
|
|
|
#include "base/numerics/safe_math.h"
|
|
#include "gin/handle.h"
|
|
#include "gin/object_template_builder.h"
|
|
#include "gin/wrappable.h"
|
|
#include "shell/common/asar/archive.h"
|
|
#include "shell/common/asar/asar_util.h"
|
|
#include "shell/common/gin_converters/callback_converter.h"
|
|
#include "shell/common/gin_converters/file_path_converter.h"
|
|
#include "shell/common/gin_helper/dictionary.h"
|
|
#include "shell/common/gin_helper/error_thrower.h"
|
|
#include "shell/common/gin_helper/function_template_extensions.h"
|
|
#include "shell/common/gin_helper/promise.h"
|
|
#include "shell/common/node_includes.h"
|
|
#include "shell/common/node_util.h"
|
|
|
|
namespace {
|
|
|
|
class Archive : public gin::Wrappable<Archive> {
|
|
public:
|
|
static gin::Handle<Archive> Create(v8::Isolate* isolate,
|
|
const base::FilePath& path) {
|
|
auto archive = std::make_unique<asar::Archive>(path);
|
|
if (!archive->Init())
|
|
return gin::Handle<Archive>();
|
|
return gin::CreateHandle(isolate, new Archive(isolate, std::move(archive)));
|
|
}
|
|
|
|
// gin::Wrappable
|
|
static gin::WrapperInfo kWrapperInfo;
|
|
gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
|
|
v8::Isolate* isolate) override {
|
|
return gin::ObjectTemplateBuilder(isolate)
|
|
.SetProperty("path", &Archive::GetPath)
|
|
.SetMethod("getFileInfo", &Archive::GetFileInfo)
|
|
.SetMethod("stat", &Archive::Stat)
|
|
.SetMethod("readdir", &Archive::Readdir)
|
|
.SetMethod("realpath", &Archive::Realpath)
|
|
.SetMethod("copyFileOut", &Archive::CopyFileOut)
|
|
.SetMethod("read", &Archive::Read)
|
|
.SetMethod("readSync", &Archive::ReadSync);
|
|
}
|
|
|
|
const char* GetTypeName() override { return "Archive"; }
|
|
|
|
protected:
|
|
Archive(v8::Isolate* isolate, std::unique_ptr<asar::Archive> archive)
|
|
: archive_(std::move(archive)) {}
|
|
|
|
// Returns the path of the file.
|
|
base::FilePath GetPath() { return archive_->path(); }
|
|
|
|
// Reads the offset and size of file.
|
|
v8::Local<v8::Value> GetFileInfo(v8::Isolate* isolate,
|
|
const base::FilePath& path) {
|
|
asar::Archive::FileInfo info;
|
|
if (!archive_ || !archive_->GetFileInfo(path, &info))
|
|
return v8::False(isolate);
|
|
gin_helper::Dictionary dict(isolate, v8::Object::New(isolate));
|
|
dict.Set("size", info.size);
|
|
dict.Set("unpacked", info.unpacked);
|
|
dict.Set("offset", info.offset);
|
|
return dict.GetHandle();
|
|
}
|
|
|
|
// Returns a fake result of fs.stat(path).
|
|
v8::Local<v8::Value> Stat(v8::Isolate* isolate, const base::FilePath& path) {
|
|
asar::Archive::Stats stats;
|
|
if (!archive_ || !archive_->Stat(path, &stats))
|
|
return v8::False(isolate);
|
|
gin_helper::Dictionary dict(isolate, v8::Object::New(isolate));
|
|
dict.Set("size", stats.size);
|
|
dict.Set("offset", stats.offset);
|
|
dict.Set("isFile", stats.is_file);
|
|
dict.Set("isDirectory", stats.is_directory);
|
|
dict.Set("isLink", stats.is_link);
|
|
return dict.GetHandle();
|
|
}
|
|
|
|
// Returns all files under a directory.
|
|
v8::Local<v8::Value> Readdir(v8::Isolate* isolate,
|
|
const base::FilePath& path) {
|
|
std::vector<base::FilePath> files;
|
|
if (!archive_ || !archive_->Readdir(path, &files))
|
|
return v8::False(isolate);
|
|
return gin::ConvertToV8(isolate, files);
|
|
}
|
|
|
|
// Returns the path of file with symbol link resolved.
|
|
v8::Local<v8::Value> Realpath(v8::Isolate* isolate,
|
|
const base::FilePath& path) {
|
|
base::FilePath realpath;
|
|
if (!archive_ || !archive_->Realpath(path, &realpath))
|
|
return v8::False(isolate);
|
|
return gin::ConvertToV8(isolate, realpath);
|
|
}
|
|
|
|
// Copy the file out into a temporary file and returns the new path.
|
|
v8::Local<v8::Value> CopyFileOut(v8::Isolate* isolate,
|
|
const base::FilePath& path) {
|
|
base::FilePath new_path;
|
|
if (!archive_ || !archive_->CopyFileOut(path, &new_path))
|
|
return v8::False(isolate);
|
|
return gin::ConvertToV8(isolate, new_path);
|
|
}
|
|
|
|
v8::Local<v8::ArrayBuffer> ReadSync(gin_helper::ErrorThrower thrower,
|
|
uint64_t offset,
|
|
uint64_t length) {
|
|
base::CheckedNumeric<uint64_t> safe_offset(offset);
|
|
base::CheckedNumeric<uint64_t> safe_end = safe_offset + length;
|
|
if (!safe_end.IsValid() ||
|
|
safe_end.ValueOrDie() > archive_->file()->length()) {
|
|
thrower.ThrowError("Out of bounds read");
|
|
return v8::Local<v8::ArrayBuffer>();
|
|
}
|
|
auto array_buffer = v8::ArrayBuffer::New(thrower.isolate(), length);
|
|
auto backing_store = array_buffer->GetBackingStore();
|
|
memcpy(backing_store->Data(), archive_->file()->data() + offset, length);
|
|
return array_buffer;
|
|
}
|
|
|
|
v8::Local<v8::Promise> Read(v8::Isolate* isolate,
|
|
uint64_t offset,
|
|
uint64_t length) {
|
|
gin_helper::Promise<v8::Local<v8::ArrayBuffer>> promise(isolate);
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
|
|
|
base::CheckedNumeric<uint64_t> safe_offset(offset);
|
|
base::CheckedNumeric<uint64_t> safe_end = safe_offset + length;
|
|
if (!safe_end.IsValid() ||
|
|
safe_end.ValueOrDie() > archive_->file()->length()) {
|
|
promise.RejectWithErrorMessage("Out of bounds read");
|
|
return handle;
|
|
}
|
|
|
|
auto backing_store = v8::ArrayBuffer::NewBackingStore(isolate, length);
|
|
base::ThreadPool::PostTaskAndReplyWithResult(
|
|
FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
|
|
base::BindOnce(&Archive::ReadOnIO, isolate, archive_,
|
|
std::move(backing_store), offset, length),
|
|
base::BindOnce(&Archive::ResolveReadOnUI, std::move(promise)));
|
|
|
|
return handle;
|
|
}
|
|
|
|
private:
|
|
static std::unique_ptr<v8::BackingStore> ReadOnIO(
|
|
v8::Isolate* isolate,
|
|
std::shared_ptr<asar::Archive> archive,
|
|
std::unique_ptr<v8::BackingStore> backing_store,
|
|
uint64_t offset,
|
|
uint64_t length) {
|
|
memcpy(backing_store->Data(), archive->file()->data() + offset, length);
|
|
return backing_store;
|
|
}
|
|
|
|
static void ResolveReadOnUI(
|
|
gin_helper::Promise<v8::Local<v8::ArrayBuffer>> promise,
|
|
std::unique_ptr<v8::BackingStore> backing_store) {
|
|
v8::HandleScope scope(promise.isolate());
|
|
v8::Context::Scope context_scope(promise.GetContext());
|
|
auto array_buffer =
|
|
v8::ArrayBuffer::New(promise.isolate(), std::move(backing_store));
|
|
promise.Resolve(array_buffer);
|
|
}
|
|
|
|
std::shared_ptr<asar::Archive> archive_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(Archive);
|
|
};
|
|
|
|
// static
|
|
gin::WrapperInfo Archive::kWrapperInfo = {gin::kEmbedderNativeGin};
|
|
|
|
void InitAsarSupport(v8::Isolate* isolate, v8::Local<v8::Value> require) {
|
|
// Evaluate asar_bundle.js.
|
|
std::vector<v8::Local<v8::String>> asar_bundle_params = {
|
|
node::FIXED_ONE_BYTE_STRING(isolate, "require")};
|
|
std::vector<v8::Local<v8::Value>> asar_bundle_args = {require};
|
|
electron::util::CompileAndCall(
|
|
isolate->GetCurrentContext(), "electron/js2c/asar_bundle",
|
|
&asar_bundle_params, &asar_bundle_args, nullptr);
|
|
}
|
|
|
|
v8::Local<v8::Value> SplitPath(v8::Isolate* isolate,
|
|
const base::FilePath& path) {
|
|
gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
|
|
base::FilePath asar_path, file_path;
|
|
if (asar::GetAsarArchivePath(path, &asar_path, &file_path, true)) {
|
|
dict.Set("isAsar", true);
|
|
dict.Set("asarPath", asar_path);
|
|
dict.Set("filePath", file_path);
|
|
} else {
|
|
dict.Set("isAsar", false);
|
|
}
|
|
return dict.GetHandle();
|
|
}
|
|
|
|
void Initialize(v8::Local<v8::Object> exports,
|
|
v8::Local<v8::Value> unused,
|
|
v8::Local<v8::Context> context,
|
|
void* priv) {
|
|
gin_helper::Dictionary dict(context->GetIsolate(), exports);
|
|
dict.SetMethod("createArchive", &Archive::Create);
|
|
dict.SetMethod("splitPath", &SplitPath);
|
|
dict.SetMethod("initAsarSupport", &InitAsarSupport);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
NODE_LINKED_MODULE_CONTEXT_AWARE(electron_common_asar, Initialize)
|