electron/shell/common/api/atom_api_asar.cc

142 lines
5 KiB
C++
Raw Normal View History

// Copyright (c) 2014 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
2015-02-04 19:18:25 +00:00
#include <stddef.h>
2014-09-24 10:44:00 +00:00
#include <vector>
#include "native_mate/arguments.h"
#include "native_mate/object_template_builder_deprecated.h"
#include "native_mate/wrappable.h"
#include "shell/common/asar/archive.h"
#include "shell/common/gin_converters/callback_converter.h"
#include "shell/common/gin_helper/dictionary.h"
#include "shell/common/native_mate_converters/file_path_converter.h"
#include "shell/common/node_includes.h"
#include "third_party/electron_node/src/node_native_module_env.h"
2017-04-27 07:56:47 +00:00
namespace {
2016-04-25 01:17:54 +00:00
class Archive : public mate::Wrappable<Archive> {
public:
2015-05-22 11:11:22 +00:00
static v8::Local<v8::Value> Create(v8::Isolate* isolate,
2018-04-18 01:55:30 +00:00
const base::FilePath& path) {
auto archive = std::make_unique<asar::Archive>(path);
if (!archive->Init())
2014-09-24 10:44:00 +00:00
return v8::False(isolate);
2016-04-25 01:17:54 +00:00
return (new Archive(isolate, std::move(archive)))->GetWrapper();
}
2018-04-18 01:55:30 +00:00
static void BuildPrototype(v8::Isolate* isolate,
v8::Local<v8::FunctionTemplate> prototype) {
2016-08-02 10:28:12 +00:00
prototype->SetClassName(mate::StringToV8(isolate, "Archive"));
mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
2016-04-25 01:17:54 +00:00
.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("getFd", &Archive::GetFD);
}
protected:
2016-05-23 01:59:39 +00:00
Archive(v8::Isolate* isolate, std::unique_ptr<asar::Archive> archive)
2016-04-25 01:17:54 +00:00
: archive_(std::move(archive)) {
Init(isolate);
}
// Returns the path of the file.
2018-04-18 01:55:30 +00:00
base::FilePath GetPath() { return archive_->path(); }
2014-09-24 04:02:33 +00:00
// Reads the offset and size of file.
2015-05-22 11:11:22 +00:00
v8::Local<v8::Value> GetFileInfo(v8::Isolate* isolate,
2018-04-18 01:55:30 +00:00
const base::FilePath& path) {
asar::Archive::FileInfo info;
if (!archive_ || !archive_->GetFileInfo(path, &info))
2014-09-24 10:44:00 +00:00
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();
}
2014-09-24 04:02:33 +00:00
// Returns a fake result of fs.stat(path).
2018-04-18 01:55:30 +00:00
v8::Local<v8::Value> Stat(v8::Isolate* isolate, const base::FilePath& path) {
2014-09-24 04:02:33 +00:00
asar::Archive::Stats stats;
if (!archive_ || !archive_->Stat(path, &stats))
2014-09-24 10:44:00 +00:00
return v8::False(isolate);
gin_helper::Dictionary dict(isolate, v8::Object::New(isolate));
2014-09-24 04:02:33 +00:00
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();
}
2014-09-24 10:44:00 +00:00
// Returns all files under a directory.
2015-05-22 11:11:22 +00:00
v8::Local<v8::Value> Readdir(v8::Isolate* isolate,
2018-04-18 01:55:30 +00:00
const base::FilePath& path) {
2014-09-24 10:44:00 +00:00
std::vector<base::FilePath> files;
if (!archive_ || !archive_->Readdir(path, &files))
2014-09-24 10:44:00 +00:00
return v8::False(isolate);
return mate::ConvertToV8(isolate, files);
}
2014-09-30 06:53:41 +00:00
// Returns the path of file with symbol link resolved.
2015-05-22 11:11:22 +00:00
v8::Local<v8::Value> Realpath(v8::Isolate* isolate,
2018-04-18 01:55:30 +00:00
const base::FilePath& path) {
2014-09-30 06:53:41 +00:00
base::FilePath realpath;
if (!archive_ || !archive_->Realpath(path, &realpath))
return v8::False(isolate);
return mate::ConvertToV8(isolate, realpath);
}
// Copy the file out into a temporary file and returns the new path.
2015-05-22 11:11:22 +00:00
v8::Local<v8::Value> CopyFileOut(v8::Isolate* isolate,
2018-04-18 01:55:30 +00:00
const base::FilePath& path) {
base::FilePath new_path;
if (!archive_ || !archive_->CopyFileOut(path, &new_path))
return v8::False(isolate);
return mate::ConvertToV8(isolate, new_path);
}
2015-05-11 03:02:17 +00:00
// Return the file descriptor.
int GetFD() const {
if (!archive_)
return -1;
return archive_->GetFD();
}
private:
2016-05-23 01:59:39 +00:00
std::unique_ptr<asar::Archive> archive_;
DISALLOW_COPY_AND_ASSIGN(Archive);
};
void InitAsarSupport(v8::Isolate* isolate, v8::Local<v8::Value> require) {
2017-05-08 21:06:58 +00:00
// Evaluate asar_init.js.
std::vector<v8::Local<v8::String>> asar_init_params = {
node::FIXED_ONE_BYTE_STRING(isolate, "require")};
std::vector<v8::Local<v8::Value>> asar_init_args = {require};
node::native_module::NativeModuleEnv::CompileAndCall(
isolate->GetCurrentContext(), "electron/js2c/asar_init",
&asar_init_params, &asar_init_args, nullptr);
}
2018-04-18 01:55:30 +00:00
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("initAsarSupport", &InitAsarSupport);
}
} // namespace
NODE_LINKED_MODULE_CONTEXT_AWARE(atom_common_asar, Initialize)