1 files changed, 204 insertions, 2 deletions

diff --git a/core/io/file_access.cpp b/core/io/file_access.cpp
index 72c00bd678..499f083f51 100644
--- a/core/io/file_access.cpp
+++ b/core/io/file_access.cpp
@@ -32,6 +32,8 @@
 
 #include "core/config/project_settings.h"
 #include "core/crypto/crypto_core.h"
+#include "core/io/file_access_compressed.h"
+#include "core/io/file_access_encrypted.h"
 #include "core/io/file_access_pack.h"
 #include "core/io/marshalls.h"
 #include "core/os/os.h"
@@ -41,6 +43,7 @@ FileAccess::CreateFunc FileAccess::create_func[ACCESS_MAX] = { nullptr, nullptr
 FileAccess::FileCloseFailNotify FileAccess::close_fail_notify = nullptr;
 
 bool FileAccess::backup_save = false;
+thread_local Error FileAccess::last_file_open_error = OK;
 
 Ref<FileAccess> FileAccess::create(AccessType p_access) {
 	ERR_FAIL_INDEX_V(p_access, ACCESS_MAX, nullptr);
@@ -81,7 +84,7 @@ Ref<FileAccess> FileAccess::create_for_path(const String &p_path) {
 }
 
 Error FileAccess::reopen(const String &p_path, int p_mode_flags) {
-	return _open(p_path, p_mode_flags);
+	return open_internal(p_path, p_mode_flags);
 }
 
 Ref<FileAccess> FileAccess::open(const String &p_path, int p_mode_flags, Error *r_error) {
@@ -99,7 +102,7 @@ Ref<FileAccess> FileAccess::open(const String &p_path, int p_mode_flags, Error *
 	}
 
 	ret = create_for_path(p_path);
-	Error err = ret->_open(p_path, p_mode_flags);
+	Error err = ret->open_internal(p_path, p_mode_flags);
 
 	if (r_error) {
 		*r_error = err;
@@ -111,6 +114,66 @@ Ref<FileAccess> FileAccess::open(const String &p_path, int p_mode_flags, Error *
 	return ret;
 }
 
+Ref<FileAccess> FileAccess::_open(const String &p_path, ModeFlags p_mode_flags) {
+	Error err = OK;
+	Ref<FileAccess> fa = open(p_path, p_mode_flags, &err);
+	last_file_open_error = err;
+	if (err) {
+		return Ref<FileAccess>();
+	}
+	return fa;
+}
+
+Ref<FileAccess> FileAccess::open_encrypted(const String &p_path, ModeFlags p_mode_flags, const Vector<uint8_t> &p_key) {
+	Ref<FileAccess> fa = _open(p_path, p_mode_flags);
+	if (fa.is_null()) {
+		return fa;
+	}
+
+	Ref<FileAccessEncrypted> fae;
+	fae.instantiate();
+	Error err = fae->open_and_parse(fa, p_key, (p_mode_flags == WRITE) ? FileAccessEncrypted::MODE_WRITE_AES256 : FileAccessEncrypted::MODE_READ);
+	if (err) {
+		last_file_open_error = err;
+		return Ref<FileAccess>();
+	}
+	return fae;
+}
+
+Ref<FileAccess> FileAccess::open_encrypted_pass(const String &p_path, ModeFlags p_mode_flags, const String &p_pass) {
+	Ref<FileAccess> fa = _open(p_path, p_mode_flags);
+	if (fa.is_null()) {
+		return fa;
+	}
+
+	Ref<FileAccessEncrypted> fae;
+	fae.instantiate();
+	Error err = fae->open_and_parse_password(fa, p_pass, (p_mode_flags == WRITE) ? FileAccessEncrypted::MODE_WRITE_AES256 : FileAccessEncrypted::MODE_READ);
+	if (err) {
+		last_file_open_error = err;
+		return Ref<FileAccess>();
+	}
+	return fae;
+}
+
+Ref<FileAccess> FileAccess::open_compressed(const String &p_path, ModeFlags p_mode_flags, CompressionMode p_compress_mode) {
+	Ref<FileAccessCompressed> fac;
+	fac.instantiate();
+	fac->configure("GCPF", (Compression::Mode)p_compress_mode);
+	Error err = fac->open_internal(p_path, p_mode_flags);
+
+	if (err) {
+		last_file_open_error = err;
+		return Ref<FileAccess>();
+	}
+
+	return fac;
+}
+
+Error FileAccess::get_open_error() {
+	return last_file_open_error;
+}
+
 FileAccess::CreateFunc FileAccess::get_create_func(AccessType p_access) {
 	return create_func[p_access];
 }
@@ -227,6 +290,20 @@ real_t FileAccess::get_real() const {
 	}
 }
 
+Variant FileAccess::get_var(bool p_allow_objects) const {
+	uint32_t len = get_32();
+	Vector<uint8_t> buff = _get_buffer(len);
+	ERR_FAIL_COND_V((uint32_t)buff.size() != len, Variant());
+
+	const uint8_t *r = buff.ptr();
+
+	Variant v;
+	Error err = decode_variant(v, &r[0], len, nullptr, p_allow_objects);
+	ERR_FAIL_COND_V_MSG(err != OK, Variant(), "Error when trying to encode Variant.");
+
+	return v;
+}
+
 double FileAccess::get_double() const {
 	MarshallDouble m;
 	m.l = get_64();
@@ -370,6 +447,17 @@ Vector<String> FileAccess::get_csv_line(const String &p_delim) const {
 	return strings;
 }
 
+String FileAccess::get_as_text(bool p_skip_cr) const {
+	uint64_t original_pos = get_position();
+	const_cast<FileAccess *>(this)->seek(0);
+
+	String text = get_as_utf8_string(p_skip_cr);
+
+	const_cast<FileAccess *>(this)->seek(original_pos);
+
+	return text;
+}
+
 uint64_t FileAccess::get_buffer(uint8_t *p_dst, uint64_t p_length) const {
 	ERR_FAIL_COND_V(!p_dst && p_length > 0, -1);
 
@@ -381,6 +469,27 @@ uint64_t FileAccess::get_buffer(uint8_t *p_dst, uint64_t p_length) const {
 	return i;
 }
 
+Vector<uint8_t> FileAccess::_get_buffer(int64_t p_length) const {
+	Vector<uint8_t> data;
+
+	ERR_FAIL_COND_V_MSG(p_length < 0, data, "Length of buffer cannot be smaller than 0.");
+	if (p_length == 0) {
+		return data;
+	}
+
+	Error err = data.resize(p_length);
+	ERR_FAIL_COND_V_MSG(err != OK, data, "Can't resize data to " + itos(p_length) + " elements.");
+
+	uint8_t *w = data.ptrw();
+	int64_t len = get_buffer(&w[0], p_length);
+
+	if (len < p_length) {
+		data.resize(len);
+	}
+
+	return data;
+}
+
 String FileAccess::get_as_utf8_string(bool p_skip_cr) const {
 	Vector<uint8_t> sourcef;
 	uint64_t len = get_length();
@@ -554,6 +663,33 @@ void FileAccess::store_buffer(const uint8_t *p_src, uint64_t p_length) {
 	}
 }
 
+void FileAccess::_store_buffer(const Vector<uint8_t> &p_buffer) {
+	uint64_t len = p_buffer.size();
+	if (len == 0) {
+		return;
+	}
+
+	const uint8_t *r = p_buffer.ptr();
+
+	store_buffer(&r[0], len);
+}
+
+void FileAccess::store_var(const Variant &p_var, bool p_full_objects) {
+	int len;
+	Error err = encode_variant(p_var, nullptr, len, p_full_objects);
+	ERR_FAIL_COND_MSG(err != OK, "Error when trying to encode Variant.");
+
+	Vector<uint8_t> buff;
+	buff.resize(len);
+
+	uint8_t *w = buff.ptrw();
+	err = encode_variant(p_var, &w[0], len, p_full_objects);
+	ERR_FAIL_COND_MSG(err != OK, "Error when trying to encode Variant.");
+
+	store_32(len);
+	_store_buffer(buff);
+}
+
 Vector<uint8_t> FileAccess::get_file_as_array(const String &p_path, Error *r_error) {
 	Ref<FileAccess> f = FileAccess::open(p_path, READ, r_error);
 	if (f.is_null()) {
@@ -666,3 +802,69 @@ String FileAccess::get_sha256(const String &p_file) {
 
 	return String::hex_encode_buffer(hash, 32);
 }
+
+void FileAccess::_bind_methods() {
+	ClassDB::bind_static_method("FileAccess", D_METHOD("open", "path", "flags"), &FileAccess::_open);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("open_encrypted", "path", "mode_flags", "key"), &FileAccess::open_encrypted);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("open_encrypted_with_pass", "path", "mode_flags", "pass"), &FileAccess::open_encrypted_pass);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("open_compressed", "path", "mode_flags", "compression_mode"), &FileAccess::open_compressed, DEFVAL(0));
+	ClassDB::bind_static_method("FileAccess", D_METHOD("get_open_error"), &FileAccess::get_open_error);
+
+	ClassDB::bind_method(D_METHOD("flush"), &FileAccess::flush);
+	ClassDB::bind_method(D_METHOD("get_path"), &FileAccess::get_path);
+	ClassDB::bind_method(D_METHOD("get_path_absolute"), &FileAccess::get_path_absolute);
+	ClassDB::bind_method(D_METHOD("is_open"), &FileAccess::is_open);
+	ClassDB::bind_method(D_METHOD("seek", "position"), &FileAccess::seek);
+	ClassDB::bind_method(D_METHOD("seek_end", "position"), &FileAccess::seek_end, DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("get_position"), &FileAccess::get_position);
+	ClassDB::bind_method(D_METHOD("get_length"), &FileAccess::get_length);
+	ClassDB::bind_method(D_METHOD("eof_reached"), &FileAccess::eof_reached);
+	ClassDB::bind_method(D_METHOD("get_8"), &FileAccess::get_8);
+	ClassDB::bind_method(D_METHOD("get_16"), &FileAccess::get_16);
+	ClassDB::bind_method(D_METHOD("get_32"), &FileAccess::get_32);
+	ClassDB::bind_method(D_METHOD("get_64"), &FileAccess::get_64);
+	ClassDB::bind_method(D_METHOD("get_float"), &FileAccess::get_float);
+	ClassDB::bind_method(D_METHOD("get_double"), &FileAccess::get_double);
+	ClassDB::bind_method(D_METHOD("get_real"), &FileAccess::get_real);
+	ClassDB::bind_method(D_METHOD("get_buffer", "length"), &FileAccess::_get_buffer);
+	ClassDB::bind_method(D_METHOD("get_line"), &FileAccess::get_line);
+	ClassDB::bind_method(D_METHOD("get_csv_line", "delim"), &FileAccess::get_csv_line, DEFVAL(","));
+	ClassDB::bind_method(D_METHOD("get_as_text", "skip_cr"), &FileAccess::get_as_text, DEFVAL(false));
+	ClassDB::bind_static_method("FileAccess", D_METHOD("get_md5", "path"), &FileAccess::get_md5);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("get_sha256", "path"), &FileAccess::get_sha256);
+	ClassDB::bind_method(D_METHOD("is_big_endian"), &FileAccess::is_big_endian);
+	ClassDB::bind_method(D_METHOD("set_big_endian", "big_endian"), &FileAccess::set_big_endian);
+	ClassDB::bind_method(D_METHOD("get_error"), &FileAccess::get_error);
+	ClassDB::bind_method(D_METHOD("get_var", "allow_objects"), &FileAccess::get_var, DEFVAL(false));
+
+	ClassDB::bind_method(D_METHOD("store_8", "value"), &FileAccess::store_8);
+	ClassDB::bind_method(D_METHOD("store_16", "value"), &FileAccess::store_16);
+	ClassDB::bind_method(D_METHOD("store_32", "value"), &FileAccess::store_32);
+	ClassDB::bind_method(D_METHOD("store_64", "value"), &FileAccess::store_64);
+	ClassDB::bind_method(D_METHOD("store_float", "value"), &FileAccess::store_float);
+	ClassDB::bind_method(D_METHOD("store_double", "value"), &FileAccess::store_double);
+	ClassDB::bind_method(D_METHOD("store_real", "value"), &FileAccess::store_real);
+	ClassDB::bind_method(D_METHOD("store_buffer", "buffer"), &FileAccess::_store_buffer);
+	ClassDB::bind_method(D_METHOD("store_line", "line"), &FileAccess::store_line);
+	ClassDB::bind_method(D_METHOD("store_csv_line", "values", "delim"), &FileAccess::store_csv_line, DEFVAL(","));
+	ClassDB::bind_method(D_METHOD("store_string", "string"), &FileAccess::store_string);
+	ClassDB::bind_method(D_METHOD("store_var", "value", "full_objects"), &FileAccess::store_var, DEFVAL(false));
+
+	ClassDB::bind_method(D_METHOD("store_pascal_string", "string"), &FileAccess::store_pascal_string);
+	ClassDB::bind_method(D_METHOD("get_pascal_string"), &FileAccess::get_pascal_string);
+
+	ClassDB::bind_static_method("FileAccess", D_METHOD("file_exists", "path"), &FileAccess::exists);
+	ClassDB::bind_static_method("FileAccess", D_METHOD("get_modified_time", "file"), &FileAccess::get_modified_time);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "big_endian"), "set_big_endian", "is_big_endian");
+
+	BIND_ENUM_CONSTANT(READ);
+	BIND_ENUM_CONSTANT(WRITE);
+	BIND_ENUM_CONSTANT(READ_WRITE);
+	BIND_ENUM_CONSTANT(WRITE_READ);
+
+	BIND_ENUM_CONSTANT(COMPRESSION_FASTLZ);
+	BIND_ENUM_CONSTANT(COMPRESSION_DEFLATE);
+	BIND_ENUM_CONSTANT(COMPRESSION_ZSTD);
+	BIND_ENUM_CONSTANT(COMPRESSION_GZIP);
+}