From 1da491f9093bd1a387ee5f0179df5a62181d428c Mon Sep 17 00:00:00 2001
From: Ale32bit <ale.proto00@gmail.com>
Date: Fri, 4 Nov 2016 20:56:13 +0100
Subject: [PATCH] Create vfs.lua

---
 src/system/vfs.lua | 616 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 616 insertions(+)
 create mode 100644 src/system/vfs.lua

diff --git a/src/system/vfs.lua b/src/system/vfs.lua
new file mode 100644
index 0000000..f0aadd9
--- /dev/null
+++ b/src/system/vfs.lua
@@ -0,0 +1,616 @@
+if fs.native then
+	return false, "VFS already installed"
+end
+
+local function checkArg(argtype, argn, arg)
+	if type(arg) ~= argtype then
+		error("invalid arg #" .. argn .. " (" .. argtype .. " expected, got " .. type(arg) .. ")", 1)
+	end
+end
+
+local proxy = {}
+local nativefs = fs; _G.fs = {}
+local rootfs = nativefs
+function fs.native()
+	return nativefs
+end
+function fs.setRoot(_proxy)
+	rootfs = _proxy
+end
+function fs.getRoot()
+	return rootfs
+end
+function fs.cleanPath(path)
+	local parts = {}
+	for match in string.gmatch(path, "[^/]+") do
+		if match == ".." then
+			if #parts < 1 then
+				error("Invalid path", 1)
+			end
+			table.remove(parts, #parts)
+		else
+			table.insert(parts, match)
+		end
+	end
+	return table.concat(parts, "/")
+end
+function fs.proxy(path, _proxy)
+	checkArg("string", 1, path)
+	checkArg("table",  2, _proxy)
+	path = fs.cleanPath(path)
+	if proxy[path] then
+		error("proxy already present at path", 1)
+	end
+	proxy[path] = _proxy
+end
+function fs.unproxy(path)
+	path = fs.cleanPath(path)
+	proxy[path] = nil
+end
+function fs.getProxy(path)
+	local p, pathbase = rootfs, ""
+	local depth = 0
+	for k, v in pairs(proxy) do
+		local _depth = 0
+		for _ in string.gmatch(k, "[/]+") do
+			_depth = _depth + 1
+		end
+		if (path == k or path:sub(1, #k + 1) == k .. "/") and _depth >= depth then
+			p = v
+			pathbase = k
+			depth = _depth
+		end
+	end
+	return p, pathbase
+end
+function fs.getProxiedPath(path)
+	local str = string.sub(path, #({fs.getProxy(path)})[2] + 1)
+	return fs.cleanPath(str)
+end
+function fs.listProxy()
+	local t = {}
+	for path in pairs(proxy) do
+		table.insert(t, path)
+	end
+	table.sort(t)
+	return t
+end
+function fs.list(path)
+	path = fs.cleanPath(path)
+	return fs.getProxy(path).list(fs.getProxiedPath(path))
+end
+function fs.move(path, target)
+	path = fs.cleanPath(path)
+	target = fs.cleanPath(target)
+	local p1 = fs.getProxy(path)
+	local p2 = fs.getProxy(target)
+	if p1 ~= p2 then
+		if p1.isDir(fs.getProxiedPath(path)) then
+			fs.copy(path, target)
+			p1.delete(fs.getProxiedPath(path))
+			return
+		end
+		if p2.exists(fs.getProxiedPath(target)) then
+			error("File exists", 1)
+		end
+		if p1.isReadOnly(fs.getProxiedPath(path)) or p2.isReadOnly(fs.getProxiedPath(target)) then
+			error("Access denied", 1)
+		end
+		local f1 = p1.open(fs.getProxiedPath(path), "r")
+		local f2 = p2.open(fs.getProxiedPath(path), "w")
+		f2.write(f1.readAll())
+		f1.close()
+		f2.close()
+		p1.delete(fs.getProxiedPath(path))
+	else
+		p1.move(fs.getProxiedPath(path), fs.getProxiedPath(target))
+	end
+end
+function fs.recursiveCopy(p1, p2, pA, pB)
+	for i, v in ipairs(p1.list(pA)) do
+		if p1.isDir(fs.combine(pA, v)) then
+			if not p2.exists(fs.combine(pB, v)) then
+				p2.makeDir(fs.combine(pB, v))
+			end
+			fs.recursiveCopy(p1, p2, fs.combine(pA, v), fs.combine(pB, v))
+		else
+			local f1 = p1.open(fs.combine(pA, v), "r")
+			local f2 = p2.open(fs.combine(pB, v), "w")
+			f2.write(f1.readAll())
+			f1.close()
+			f2.close()
+		end
+	end
+end
+function fs.copy(path, target)
+	path = fs.cleanPath(path)
+	target = fs.cleanPath(target)
+	local p1 = fs.getProxy(path)
+	local p2 = fs.getProxy(target)
+	if p1 ~= p2 then
+		if p1.isDir(fs.getProxiedPath(path)) then
+			fs.recursiveCopy(p1, p2, fs.getProxiedPath(path), fs.getProxiedPath(target))
+			return
+		end
+		if p2.exists(fs.getProxiedPath(target)) then
+			error("File exists", 1)
+		end
+		if p2.isReadOnly(fs.getProxiedPath(target)) then
+			error("Access denied", 1)
+		end
+		local f1 = p1.open(fs.getProxiedPath(path), "r")
+		local f2 = p2.open(fs.getProxiedPath(target), "w")
+		f2.write(f1.readAll())
+		f1.close()
+		f2.close()
+	else
+		p1.copy(fs.getProxiedPath(path), fs.getProxiedPath(target))
+	end
+end
+function fs.makeDir(path)
+	path = fs.cleanPath(path)
+	fs.getProxy(path).makeDir(fs.getProxiedPath(path))
+end
+function fs.delete(path)
+	path = fs.cleanPath(path)
+	fs.getProxy(path).delete(fs.getProxiedPath(path))
+end
+function fs.open(path, mode)
+	path = fs.cleanPath(path)
+	return fs.getProxy(path).open(fs.getProxiedPath(path), mode)
+end
+function fs.isDir(path)
+	path = fs.cleanPath(path)
+	return fs.getProxy(path).isDir(fs.getProxiedPath(path))
+end
+function fs.exists(path)
+	path = fs.cleanPath(path)
+	return fs.getProxy(path).exists(fs.getProxiedPath(path))
+end
+function fs.combine(path1, path2)
+	return nativefs.combine(path1, path2)
+end
+function fs.getName(path)
+	path = fs.cleanPath(path)
+	return nativefs.getName(path)
+end
+function fs.getDir(path)
+	path = fs.cleanPath(path)
+	return nativefs.getDir(path)
+end
+function fs.isReadOnly(path)
+	path = fs.cleanPath(path)
+	return fs.getProxy(path).isReadOnly(fs.getProxiedPath(path))
+end
+function fs.find(path) -- cclite copypaste
+	path = fs.cleanPath(path)
+	local function recurse_spec(results, path, spec)
+		local segment = spec:match('([^/]*)'):gsub('/', '')
+		local pattern = '^' .. segment:gsub("[%.%[%]%(%)%%%+%-%?%^%$]","%%%1"):gsub("%z","%%z"):gsub("%*","[^/]-") .. '$'
+			if fs.isDir(path) then
+			for _, file in ipairs(fs.list(path)) do
+				if file:match(pattern) then
+					local f = fs.combine(path, file)
+						if spec == segment then
+						table.insert(results, f)
+					end
+					if fs.isDir(f) then
+						recurse_spec(results, f, spec:sub(#segment + 2))
+					end
+				end
+			end
+		end
+	end
+	local results = {}
+	recurse_spec(results, '', path)
+	table.sort(results)
+	return results
+end
+function fs.getSize(path)
+	path = fs.cleanPath(path)
+	return fs.getProxy(path).getSize(fs.getProxiedPath(path))
+end
+fs.complete = nativefs.complete
+function fs.getDrive(path)
+	path = fs.cleanPath(path)
+	if fs.getProxy(path).getDrive then
+		return fs.getProxy(path).getDrive(fs.getProxiedPath(path))
+	else
+		return "???"
+	end
+end
+function fs.getFreeSpace(path)
+	path = fs.cleanPath(path)
+	if fs.getProxy(path).getFreeSpace then
+		return fs.getProxy(path).getFreeSpace(fs.getProxiedPath(path))
+	else
+		return 2^31 - 1
+	end
+end
+for i in pairs(nativefs) do
+	if not fs[i] then
+		print("MISSING: " .. i)
+	end
+end
+function fs.appfsProxy(structure)
+	local function getFile(path)
+		local file = structure
+		for part in string.gmatch(path, "[^/]+") do
+			if not file.files[part] then
+				return nil
+			end
+			file = file.files[part]
+		end
+		return file
+	end
+	local p = {}
+	function p.getDrive()
+		return "sys"
+	end
+	function p.getFreeSpace()
+		return 0
+	end
+	function p.exists(path)
+		local file = structure
+		for part in string.gmatch(path, "[^/]+") do
+			if not file.files[part] then
+				return false
+			end
+			file = file.files[part]
+		end
+		return file ~= nil
+	end
+	function p.list(path)
+		local file = getFile(path)
+		if not file then
+			error("Not a directory", 1)
+		end
+		if not file.files then
+			error("Not a directory", 1)
+		end
+		local files = {}
+		for f in pairs(file.files) do
+			table.insert(files, f)
+		end
+		table.sort(files)
+		return files
+	end
+	function p.delete(path)
+		if structure.noDelete then
+			error("Access denied", 1)
+		end
+	end
+	function p.isDir(path)
+		if not getFile(path) then
+			return false
+		end
+		return getFile(path).files ~= nil
+	end
+	function p.isReadOnly(path)
+		return getFile(path).ro == true
+	end
+	function p.open(path, mode)
+		local f = getFile(path)
+		if mode == "r" then
+			local handle = {closed = false, buffer = f.read and f.read() or ""}
+			function handle.readLine()
+				if handle.closed then
+					return
+				end
+				if #handle.buffer < 1 then
+					return nil
+				end
+				local tmp = ""
+				while #handle.buffer > 0 do
+					local chr = handle.buffer:sub(1, 1)
+					handle.buffer = handle.buffer:sub(2)
+					if chr == "\n" then
+						return tmp
+					else
+						tmp = tmp .. chr
+					end
+				end
+				return tmp
+			end
+			function handle.readAll()
+				if handle.closed then
+					return
+				end
+				local str = handle.buffer
+				handle.buffer = ""
+				return str
+			end
+			function handle.close()
+				handle.closed = true
+			end
+			return handle
+		elseif mode == "w" then
+			local handle = {closed = false, buffer = ""}
+			function handle.write(str)
+				if handle.closed then
+					return
+				end
+				handle.buffer = handle.buffer .. str
+			end
+			function handle.writeLine(str)
+				handle.write(str .. "\n")
+			end
+			function handle.close()
+				if handle.closed then
+					return
+				end
+				handle.closed = true
+				f.write(handle.buffer)
+			end
+			return handle
+		else
+			error("Not supported", 1)
+		end
+	end
+	function p.getSize()
+		return 0
+	end
+	return p
+end
+function fs.tmpfsProxy(structure, writeCallback, driveName)
+	if not structure then
+		structure = {files = {}}
+	elseif type(structure) == "table" and not structure.files then
+		structure.files = {}
+	end
+	local function getFile(path)
+		local file = structure
+		for part in string.gmatch(path, "[^/]+") do
+			if not file.files[part] then
+				error("Not a directory", 1)
+			end
+			file = file.files[part]
+		end
+		return file
+	end
+	local calculateUsed
+	function calculateUsed(file)
+		return #textutils.serialize(file)
+	end
+	local p = {}
+	function p.import(newstructure)
+		structure = newstructure
+	end
+	function p.dump()
+		return structure
+	end
+	function p.getDrive()
+		return driveName or "tmpfs"
+	end
+	function p.getFreeSpace()
+		return -calculateUsed(structure)
+	end
+	function p.isReadOnly()
+		return false
+	end
+	function p.exists(path)
+		local file = structure
+		for part in string.gmatch(path, "[^/]+") do
+			if not file.files[part] then
+				return false
+			end
+			file = file.files[part]
+		end
+		return file ~= nil
+	end
+	function p.isDir(path)
+		if path == "" then
+			return true
+		end
+		return p.exists(path) and getFile(path).files ~= nil
+	end
+	function p.list(path)
+		local file
+		if path == "" then
+			file = structure
+		else
+			file = getFile(path)
+		end
+		if not file.files then
+			error("Not a directory", 1)
+		end
+		local files = {}
+		for f in pairs(file.files) do
+			table.insert(files, f)
+		end
+		table.sort(files)
+		return files
+	end
+	function p.delete(path)
+		if path == "" then
+			error("Proxy at path", 1)
+		end
+		local parent = fs.getDir(path)
+		local dir
+		if parent == "" then
+			dir = structure
+		else
+			dir = getFile(parent)
+		end
+		local name = fs.getName(path)
+		dir.files[name] = nil
+	end
+	function p.makeDir(path)
+		local parent = structure
+		for part in string.gmatch(path, "[^/]+") do
+			if not parent.files[part] then
+				parent.files[part] = {
+					files = {},
+				}
+			end
+			parent = parent.files[part]
+		end
+	end
+	function p.copy(path, target)
+		if p.exists(target) then
+			error("File exists", 1)
+		end
+		if not p.exists(path) then
+			error("File not found", 1)
+		end
+		if p.isDir(path) then
+			fs.recursiveCopy(p, p, path, target)
+		else
+			getFile(fs.getDir(target)).files[fs.getName(target)] = {data = getFile(path).data}
+		end
+	end
+	function p.move(path, target)
+		getFile(fs.getDir(target)).files[fs.getName(target)] = getFile(fs.getDir(path)).files[fs.getName(path)]
+		p.delete(path)
+	end
+	function p.open(path, mode)
+		local handle = {buffer = "", closed = false}
+		if mode == "w" or mode == "a" then
+			p.makeDir(fs.getDir(path))
+			if not p.exists(path) then
+				getFile(fs.getDir(path)).files[fs.getName(path)] = {
+					data = "",
+				}
+			end
+			handle.file = getFile(path)
+			if handle.file.files then
+				return
+			end
+			if mode == "a" then
+				handle.buffer = handle.file.data
+			end
+			function handle.close()
+				if handle.closed then return end
+				handle.closed = true
+				handle.flush()
+			end
+			function handle.flush()
+				handle.file.data = handle.buffer
+				if writeCallback then
+					writeCallback(structure)
+				end
+			end
+			function handle.write(data)
+				if handle.closed then return end
+				handle.buffer = handle.buffer .. data
+			end
+			function handle.writeLine(data)
+				handle.write(data .. "\n")
+			end
+			return handle
+		elseif mode == "r" then
+			if not p.exists(path) or p.isDir(path) then
+				return
+			end
+			handle.file = getFile(path)
+			handle.buffer = handle.file.data
+			function handle.readLine()
+				if handle.closed then
+					return
+				end
+				if #handle.buffer < 1 then
+					return nil
+				end
+				local tmp = ""
+				while #handle.buffer > 0 do
+					local chr = handle.buffer:sub(1, 1)
+					handle.buffer = handle.buffer:sub(2)
+					if chr == "\n" then
+						return tmp
+					else
+						tmp = tmp .. chr
+					end
+				end
+				return tmp
+			end
+			function handle.readAll()
+				if handle.closed then
+					return
+				end
+				local str = handle.buffer
+				handle.buffer = ""
+				return str
+			end
+			function handle.close()
+				handle.closed = true
+			end
+			return handle
+		else
+			error("Mode not supported", 1)
+		end
+	end
+	function p.getSize(path)
+		if p.isDir(path) then
+			return 0
+		end
+		return #getFile(path).data
+	end
+	return p
+end
+function fs.fileProxy(path, label)
+	if not label then
+		label = fs.getName(path)
+	end
+	return fs.tmpfsProxy(aFile.unserializeFile(path) or {}, function(structure)
+		aFile.serializeFile(path, structure)
+	end, label)
+end
+function fs.redirectProxy(parent, dir)
+	local p = {}
+	function p.open(path, mode)
+		return parent.open(fs.combine(dir, fs.cleanPath(path)), mode)
+	end
+	for i, v in ipairs({"delete", "getSize", "getFreeSpace", "makeDir", "getDrive", "isReadOnly", "exists", "isDir", "list"}) do
+		p[v] = function(path)
+			return parent[v](fs.combine(dir, fs.cleanPath(path)))
+		end
+	end
+	function p.copy(src, dest)
+		return parent.copy(fs.combine(dir, fs.cleanPath(src)), fs.combine(dir, fs.cleanPath(dest)))
+	end
+	function p.move(src, dest)
+		return parent.move(fs.combine(dir, fs.cleanPath(src)), fs.combine(dir, fs.cleanPath(dest)))
+	end
+	return p
+end
+if not fs.exists("sys") then
+	fs.makeDir("sys")
+end
+if not fs.exists("tmp") then
+	fs.makeDir("tmp")
+end
+local sysStructure = {
+	files = {
+		reboot = {
+			read = nil,
+			write = function(data)
+				if data == "1" or data == "1\n" then
+					os.reboot()
+				end
+			end,
+		},
+		shutdown = {
+			read = nil,
+			write = function(data)
+				if data == "1" or data == "1\n" then
+					os.shutdown()
+				end
+			end,
+		},
+		label = {
+			read = function()
+				return os.getComputerLabel() or ""
+			end,
+			write = function(data)
+				data = data:gsub("\n", "")
+				if data == "" then
+					os.setComputerLabel(nil)
+				else
+					os.setComputerLabel(data)
+				end
+			end,
+		},
+	},
+}
+fs.proxy("sys", fs.appfsProxy(sysStructure))
+fs.proxy("tmp", fs.tmpfsProxy())