Ponali
628 lines
19 KiB
Lua
628 lines
19 KiB
Lua
local loadfile = ... -- raw loadfile from boot.lua
|
|
local unicode, component, computer
|
|
|
|
local bufferSize = math.huge or math.maxinteger
|
|
|
|
if loadfile then
|
|
unicode = loadfile("/lib/unicode.lua")(loadfile)
|
|
component = loadfile("/lib/component.lua")(loadfile)
|
|
computer = _G.computer
|
|
elseif require then
|
|
unicode = require("unicode")
|
|
component = require("component")
|
|
computer = require("computer")
|
|
end
|
|
|
|
local filesystem = {}
|
|
|
|
function filesystem.canonical(path)
|
|
checkArg(1, path, "string")
|
|
local segList = {}
|
|
if path:sub(1, 1) ~= "/" then
|
|
path = "/" .. path
|
|
end
|
|
path = path:gsub("/+", "/")
|
|
for segment in path:gmatch("[^/]+") do
|
|
if segment == ".." and segList[1] then
|
|
table.remove(segList, #segList)
|
|
elseif segment ~= "." then
|
|
table.insert(segList, segment)
|
|
end
|
|
end
|
|
return "/" .. table.concat(segList, "/")
|
|
end
|
|
|
|
function filesystem.concat(path1, path2)
|
|
checkArg(1, path1, "string")
|
|
checkArg(2, path2, "string")
|
|
if path1:sub(-1, -1) == "/" then
|
|
path1 = path1:sub(1, -2)
|
|
end
|
|
if path2:sub(1, 1) ~= "/" then
|
|
path2 = "/" .. path2
|
|
end
|
|
return path1 .. path2
|
|
end
|
|
|
|
function filesystem.absolutePath(path) -- returns the address and absolute path of an object
|
|
checkArg(1, path, "string")
|
|
path = filesystem.canonical(path)
|
|
local address = nil
|
|
if path:find("^/tmp") then
|
|
address = computer.tmpAddress()
|
|
path = path:sub(5)
|
|
elseif path:find("^/mnt/...") then
|
|
address = component.get(path:sub(6, 8))
|
|
if not address then
|
|
address = computer.getBootAddress()
|
|
else
|
|
path = path:sub(9)
|
|
end
|
|
else
|
|
address = computer.getBootAddress()
|
|
end
|
|
if not address then
|
|
return nil, "no such component"
|
|
end
|
|
return address, path
|
|
end
|
|
|
|
function filesystem.exists(path) -- check if path exists
|
|
checkArg(1, path, "string")
|
|
local address, absPath = filesystem.absolutePath(path)
|
|
if not address then
|
|
return false
|
|
end
|
|
if absPath:find("^/special/drive/...") then
|
|
return not not (computer.getBootAddress() and component.get(absPath:sub(16, 18)))
|
|
end
|
|
if absPath:find("^/special/eeprom/") then
|
|
return table.find({ "init.lua", "data.bin", "label.txt" }, absPath:sub(17))
|
|
end
|
|
return component.invoke(address, "exists", absPath)
|
|
end
|
|
|
|
local function readBytes(self, n)
|
|
n = n or 1
|
|
if n == 1 then
|
|
local byte = self:read(1)
|
|
if byte == nil then
|
|
return nil
|
|
end
|
|
return string.byte(byte)
|
|
end
|
|
local bytes, res = { string.byte(self:read(n), 1, n) }, 0
|
|
if self.littleEndian then
|
|
for i = #bytes, 1, -1 do
|
|
res = (res << 8) & 0xFFFFFFFF | bytes[i]
|
|
end
|
|
else
|
|
for i = 1, #bytes do
|
|
res = (res << 8) & 0xFFFFFFFF | bytes[i]
|
|
end
|
|
end
|
|
return res
|
|
end
|
|
|
|
local function readUnicodeChar(self)
|
|
return unicode.readChar(function()
|
|
return self:readBytes(1)
|
|
end)
|
|
end
|
|
|
|
local function iterateBytes(self)
|
|
return function()
|
|
local byte = readBytes(self, 1)
|
|
if byte == nil then
|
|
self:close()
|
|
end
|
|
return byte
|
|
end
|
|
end
|
|
|
|
local function iterateUnicodeChars(self)
|
|
return unicode.iterate(iterateBytes(self))
|
|
end
|
|
|
|
function filesystem.makeReadStream(content)
|
|
local properHandle = {}
|
|
local readCursor = 1
|
|
function properHandle.read(self, amount)
|
|
checkArg(2, amount, "number")
|
|
local limit = string.len(content) + 1
|
|
local out = nil
|
|
if readCursor < limit then
|
|
if amount == math.huge then
|
|
out = string.sub(content, math.min(readCursor, limit))
|
|
else
|
|
out = string.sub(content, math.min(readCursor, limit), math.min(readCursor + amount - 1, limit))
|
|
end
|
|
end
|
|
readCursor = readCursor + amount
|
|
if out == "" then
|
|
return nil
|
|
end
|
|
return out
|
|
end
|
|
|
|
properHandle.readBytes = readBytes
|
|
properHandle.readUnicodeChar = readUnicodeChar
|
|
properHandle.iterateBytes = iterateBytes
|
|
properHandle.iterateUnicodeChars = iterateUnicodeChars
|
|
function properHandle.write()
|
|
return nil
|
|
end
|
|
|
|
function properHandle.close()
|
|
content = nil
|
|
end
|
|
|
|
return properHandle
|
|
end
|
|
|
|
function filesystem.open(path, mode, buffered) -- opens a file and returns its handle
|
|
checkArg(1, path, "string")
|
|
checkArg(2, mode, "string", "nil")
|
|
checkArg(3, buffered, "boolean", "nil")
|
|
if not mode then
|
|
mode = "r"
|
|
end
|
|
if buffered == nil then
|
|
buffered = true
|
|
end
|
|
if not (mode == "r" or mode == "w" or mode == "rb" or mode == "wb" or mode == "a" or mode == "ab") then
|
|
return nil, "invalid handle type"
|
|
end
|
|
if path:find("^/special") and not filesystem.exists(path) then
|
|
return nil, "/special does not allow creating files"
|
|
end
|
|
local address, absPath = filesystem.absolutePath(path)
|
|
local unmanagedDrive = address == computer.getBootAddress() and absPath:find("^/special/drive")
|
|
local unmanagedProxy, sectorSize, sectorCount, handle
|
|
if unmanagedDrive then
|
|
unmanagedProxy = component.proxy(component.get(absPath:sub(16, 18)))
|
|
sectorSize = unmanagedProxy.getSectorSize()
|
|
sectorCount = math.ceil(unmanagedProxy.getCapacity() / sectorSize)
|
|
elseif not (address == computer.getBootAddress() and absPath:find("^/special/")) then
|
|
local handleArgs = { component.invoke(address, "open", absPath, mode) }
|
|
handle = handleArgs[1]
|
|
if not handle then
|
|
return table.unpack(handleArgs)
|
|
end
|
|
handleArgs = nil
|
|
end
|
|
local properHandle = {}
|
|
properHandle.handle = handle
|
|
properHandle.address = address
|
|
local content = nil
|
|
local bufferOffset = 0 -- Position in file where buffer starts
|
|
local readCursor = 1 -- Position within buffer (1-based)
|
|
|
|
if buffered and mode == "r" then
|
|
content = component.invoke(address, "read", handle, bufferSize) or ""
|
|
bufferOffset = 0
|
|
readCursor = 1
|
|
end
|
|
|
|
function properHandle.read(self, amount)
|
|
checkArg(2, amount, "number")
|
|
if unmanagedDrive then
|
|
-- TODO: Test if this still works
|
|
local sectorIdx = ((readCursor - 1) // sectorSize) + 1
|
|
if sectorIdx > sectorCount then
|
|
return nil
|
|
end
|
|
local sector = unmanagedProxy.readSector(sectorIdx)
|
|
local data = sector:sub(
|
|
((readCursor - 1) % sectorSize) + 1,
|
|
((readCursor + math.min(amount, sectorSize) - 2) % sectorSize) + 1
|
|
)
|
|
readCursor = readCursor + #data
|
|
if data == "" then
|
|
return nil
|
|
end
|
|
return data
|
|
else
|
|
if buffered then
|
|
if amount == math.huge or amount == math.maxinteger then
|
|
-- Read everything remaining
|
|
local result = ""
|
|
|
|
-- First, get what's left in current buffer
|
|
if content and readCursor <= #content then
|
|
result = content:sub(readCursor)
|
|
readCursor = #content + 1
|
|
end
|
|
|
|
-- Then read all remaining data from file
|
|
while true do
|
|
local newData = component.invoke(address, "read", handle, bufferSize)
|
|
if not newData or newData == "" then
|
|
break
|
|
end
|
|
result = result .. newData
|
|
end
|
|
|
|
-- Update buffer state
|
|
content = nil
|
|
bufferOffset = bufferOffset + #(content or "")
|
|
|
|
return result ~= "" and result or nil
|
|
else
|
|
local result = ""
|
|
local remaining = amount
|
|
|
|
while remaining > 0 do
|
|
-- If we need more data or buffer is empty
|
|
if not content or readCursor > #content then
|
|
content = component.invoke(address, "read", handle, bufferSize)
|
|
if not content or content == "" then
|
|
break
|
|
end
|
|
bufferOffset = bufferOffset + (readCursor - 1)
|
|
readCursor = 1
|
|
end
|
|
|
|
-- Extract data from current buffer
|
|
local available = #content - readCursor + 1
|
|
local toRead = math.min(remaining, available)
|
|
local chunk = content:sub(readCursor, readCursor + toRead - 1)
|
|
|
|
result = result .. chunk
|
|
readCursor = readCursor + toRead
|
|
remaining = remaining - toRead
|
|
end
|
|
|
|
return result ~= "" and result or nil
|
|
end
|
|
else
|
|
return component.invoke(self.address, "read", self.handle, amount)
|
|
end
|
|
end
|
|
end
|
|
|
|
properHandle.readBytes = readBytes
|
|
properHandle.readUnicodeChar = readUnicodeChar
|
|
properHandle.iterateBytes = iterateBytes
|
|
properHandle.iterateUnicodeChars = iterateUnicodeChars
|
|
function properHandle.write(self, data)
|
|
checkArg(2, data, "string")
|
|
if unmanagedDrive then
|
|
local startSector = ((readCursor - 1) // sectorSize) + 1
|
|
if startSector > sectorCount then
|
|
return nil, "not enough space"
|
|
end
|
|
local startSByte = ((readCursor - 1) % sectorSize) + 1
|
|
local sect = unmanagedProxy.readSector(startSector)
|
|
unmanagedProxy.writeSector(startSector, sect:sub(1, startSByte - 1) .. data:sub(1, sectorSize - startSByte + 1))
|
|
for i = 2, (#data + startSByte) // sectorSize do
|
|
if startSector + i - 1 > sectorCount then
|
|
return nil, "not enough space"
|
|
end
|
|
unmanagedProxy.writeSector(
|
|
startSector + i - 1,
|
|
data:sub(startSByte + sectorSize * (i - 1), startSByte + sectorSize * i - 1)
|
|
)
|
|
end
|
|
readCursor = readCursor + #data
|
|
return true
|
|
else
|
|
return component.invoke(self.address, "write", self.handle, data)
|
|
end
|
|
end
|
|
|
|
function properHandle.close(self)
|
|
if buffered then
|
|
content = nil
|
|
end
|
|
return component.invoke(self.address, "close", self.handle)
|
|
end
|
|
|
|
if address == computer.getBootAddress() then
|
|
local eeprom
|
|
pcall(function()
|
|
eeprom = component.eeprom
|
|
end)
|
|
if eeprom then
|
|
local getFunc, setFunc
|
|
if absPath == "/special/eeprom/init.lua" then
|
|
getFunc, setFunc = "get", "set"
|
|
elseif absPath == "/special/eeprom/data.bin" then
|
|
getFunc, setFunc = "getData", "setData"
|
|
elseif absPath == "/special/eeprom/label.txt" then
|
|
getFunc, setFunc = "getLabel", "setLabel"
|
|
end
|
|
if mode:sub(1, 1) == "r" and getFunc then
|
|
local stream = filesystem.makeReadStream(eeprom[getFunc]() or "")
|
|
properHandle.read = stream.read
|
|
properHandle.close = stream.close
|
|
elseif mode:sub(1, 1) == "w" and setFunc then
|
|
local content = ""
|
|
function properHandle.write(self, data)
|
|
checkArg(2, data, "string")
|
|
content = content .. data
|
|
end
|
|
|
|
function properHandle.close(self)
|
|
return eeprom[setFunc](content)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
function properHandle.seek(self, whence, offset)
|
|
checkArg(2, whence, "string", "number")
|
|
checkArg(3, offset, "number", "nil")
|
|
if not offset then
|
|
offset = 0
|
|
end
|
|
if type(whence) == "number" then
|
|
offset = whence
|
|
end
|
|
if not whence or type(whence) == "number" then
|
|
whence = "cur"
|
|
end
|
|
|
|
if buffered then
|
|
local currentAbsolutePos = bufferOffset + readCursor - 1
|
|
-- Seek real handle position to buffer handle position
|
|
component.invoke(self.address, "seek", self.handle, "set", currentAbsolutePos)
|
|
local newPos = component.invoke(self.address, "seek", self.handle, whence, math.max(offset, -currentAbsolutePos))
|
|
content = nil
|
|
bufferOffset = newPos or 0
|
|
readCursor = 1
|
|
return newPos
|
|
else
|
|
return component.invoke(self.address, "seek", self.handle, whence, offset)
|
|
end
|
|
end
|
|
|
|
return properHandle
|
|
end
|
|
|
|
function filesystem.list(path)
|
|
checkArg(1, path, "string")
|
|
path = filesystem.canonical(path)
|
|
if path == "/mnt" then
|
|
-- list drives
|
|
local returnTable = {}
|
|
local tmpAddress = computer.tmpAddress()
|
|
for address, _ in component.list("filesystem") do
|
|
if address ~= tmpAddress then
|
|
table.insert(returnTable, address:sub(1, 3) .. "/")
|
|
end
|
|
end
|
|
return returnTable
|
|
elseif path == "/special/drive" then
|
|
local returnTable = {}
|
|
local tmpAddress = computer.tmpAddress()
|
|
for address, type in component.list("drive") do
|
|
if address ~= tmpAddress and type == "drive" then
|
|
table.insert(returnTable, address:sub(1, 3))
|
|
end
|
|
end
|
|
return returnTable
|
|
elseif path == "/special/eeprom" then
|
|
return { "init.lua", "data.bin", "label.txt" }
|
|
else
|
|
local address, absPath = filesystem.absolutePath(path)
|
|
if not address then
|
|
return false
|
|
end
|
|
return component.invoke(address, "list", absPath)
|
|
end
|
|
end
|
|
|
|
function filesystem.size(path)
|
|
checkArg(1, path, "string")
|
|
local address, absPath = filesystem.absolutePath(path)
|
|
if not address then
|
|
return false
|
|
end
|
|
if address == computer.getBootAddress() then
|
|
if absPath:find("^/special/drive") then
|
|
local drive = component.get(absPath:sub(16, 18))
|
|
if not drive then
|
|
return false
|
|
end
|
|
return component.invoke(drive, "getCapacity")
|
|
elseif absPath:find("^/special/eeprom") then
|
|
local eeprom
|
|
pcall(function()
|
|
eeprom = component.eeprom
|
|
end)
|
|
if eeprom then
|
|
local getFunc
|
|
if absPath == "/special/eeprom/init.lua" then
|
|
getFunc = "get"
|
|
elseif absPath == "/special/eeprom/data.bin" then
|
|
getFunc = "getData"
|
|
elseif absPath == "/special/eeprom/label.txt" then
|
|
getFunc = "getLabel"
|
|
end
|
|
return #(eeprom[getFunc]())
|
|
end
|
|
end
|
|
end
|
|
return component.invoke(address, "size", absPath)
|
|
end
|
|
|
|
local function getRecursiveList(address, absPath)
|
|
local list = component.invoke(address, "list", absPath)
|
|
local dirList = {}
|
|
local listChanged = true
|
|
while listChanged do
|
|
listChanged = false
|
|
for i = 1, #list do
|
|
if component.invoke(address, "isDirectory", absPath .. "/" .. list[i]) then
|
|
listChanged = true
|
|
local dir = list[i]
|
|
if dir:sub(-1) == "/" then
|
|
dir = dir:sub(1, -2)
|
|
end
|
|
table.insert(dirList, dir)
|
|
table.remove(list, i)
|
|
local subDir = component.invoke(address, "list", absPath .. "/" .. dir)
|
|
for j = 1, #subDir do
|
|
table.insert(list, dir .. "/" .. subDir[j])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return list, dirList
|
|
end
|
|
|
|
local function copyContent(fromHandle, toHandle)
|
|
if not (fromHandle and toHandle) then
|
|
return
|
|
end
|
|
local memory = math.floor(computer.freeMemory() * 0.8)
|
|
local tmpdata
|
|
while true do
|
|
tmpdata = fromHandle:read(memory)
|
|
if not tmpdata then
|
|
break
|
|
end
|
|
local status, reason = toHandle:write(tmpdata)
|
|
if status ~= true then
|
|
break
|
|
end
|
|
end
|
|
fromHandle:close()
|
|
toHandle:close()
|
|
end
|
|
|
|
local function copyRecursive(fromAddress, fromAbsPath, toAddress, toAbsPath)
|
|
-- TODO: make this use copyContent
|
|
if fromAbsPath:sub(-1) == "/" then
|
|
fromAbsPath = fromAbsPath:sub(1, -2)
|
|
end
|
|
if toAbsPath:sub(-1) == "/" then
|
|
toAbsPath = toAbsPath:sub(1, -2)
|
|
end
|
|
component.invoke(toAddress, "makeDirectory", toAbsPath)
|
|
local fileList, dirList = getRecursiveList(fromAddress, fromAbsPath)
|
|
for i = 1, #dirList do
|
|
component.invoke(toAddress, "makeDirectory", toAbsPath .. "/" .. dirList[i])
|
|
end
|
|
for i = 1, #fileList do
|
|
local fromFile, toFile = fromAbsPath .. "/" .. fileList[i], toAbsPath .. "/" .. fileList[i]
|
|
--[[ local handle = component.invoke(fromAddress, "open", fromFile, "r")
|
|
local data, tmpdata = "", nil
|
|
repeat
|
|
tmpdata = component.invoke(fromAddress, "read", handle, math.huge or math.maxinteger)
|
|
data = data .. (tmpdata or "")
|
|
until not tmpdata
|
|
tmpdata = component.invoke(fromAddress, "close", handle)
|
|
local handle = component.invoke(toAddress, "open", toFile, "w")
|
|
component.invoke(toAddress, "write", handle, data)
|
|
component.invoke(toAddress, "close", handle) ]]
|
|
local fromHandle = component.invoke(fromAddress, "open", fromFile, "r")
|
|
local toHandle = component.invoke(toAddress, "open", toFile, "w")
|
|
copyContent({
|
|
["read"] = function(...)
|
|
return component.invoke(fromAddress, "read", handle, ...)
|
|
end,
|
|
["close"] = function(...)
|
|
return component.invoke(fromAddress, "close", handle, ...)
|
|
end,
|
|
}, {
|
|
["write"] = function(...)
|
|
return component.invoke(fromAddress, "write", handle, ...)
|
|
end,
|
|
["close"] = function(...)
|
|
return component.invoke(fromAddress, "close", handle, ...)
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
function filesystem.isDirectory(path)
|
|
checkArg(1, path, "string")
|
|
local address, absPath = filesystem.absolutePath(path)
|
|
if not address then
|
|
return false
|
|
end
|
|
return component.invoke(address, "isDirectory", absPath)
|
|
end
|
|
|
|
function filesystem.rename(fromPath, toPath)
|
|
checkArg(1, fromPath, "string")
|
|
checkArg(2, toPath, "string")
|
|
local fromAddress, fromAbsPath = filesystem.absolutePath(fromPath)
|
|
local toAddress, toAbsPath = filesystem.absolutePath(toPath)
|
|
if not fromAddress or not toAddress then
|
|
return false
|
|
end
|
|
if fromAddress == toAddress then
|
|
return component.invoke(fromAddress, "rename", fromAbsPath, toAbsPath)
|
|
elseif filesystem.isDirectory(fromPath) then -- component.invoke(fromAddress, "isDirectory", fromAbsPath) then
|
|
copyRecursive(fromAddress, fromAbsPath, toAddress, toAbsPath)
|
|
filesystem.remove(fromPath) -- component.invoke(fromAddress,"remove", fromAbsPath)
|
|
else
|
|
local handle, data, tmpdata = filesystem.open(fromPath), "", nil -- component.invoke(fromAddress, "open", fromAbsPath, "r"), "", nil
|
|
repeat
|
|
tmpdata = handle:read(math.huge or math.maxinteger) -- component.invoke(fromAddress, "read", handle, math.huge or math.maxinteger)
|
|
data = data .. (tmpdata or "")
|
|
until not tmpdata
|
|
tmpdata = handle:close() -- component.invoke(fromAddress, "close", handle)
|
|
local handle = filesystem.open(toPath) -- component.invoke(toAddress, "open", toAbsPath, "w")
|
|
handle:write(data) -- component.invoke(toAddress, "write", handle, data)
|
|
handle:close() -- component.invoke(toAddress, "close", handle)
|
|
filesystem.remove(fromPath) -- component.invoke(fromAddress, "remove", fromAbsPath)
|
|
end
|
|
end
|
|
|
|
function filesystem.copy(fromPath, toPath)
|
|
checkArg(1, fromPath, "string")
|
|
checkArg(2, toPath, "string")
|
|
local fromAddress, fromAbsPath = filesystem.absolutePath(fromPath)
|
|
local toAddress, toAbsPath = filesystem.absolutePath(toPath)
|
|
if not fromAddress or not toAddress then
|
|
return false
|
|
end
|
|
if filesystem.isDirectory(fromPath) then -- component.invoke(fromAddress, "isDirectory", fromAbsPath)
|
|
copyRecursive(fromAddress, fromAbsPath, toAddress, toAbsPath)
|
|
else
|
|
--[[ local handle = filesystem.open(fromPath,"r")
|
|
local data, tmpdata = "", nil
|
|
repeat
|
|
tmpdata = handle:read(math.huge or math.maxinteger)
|
|
data = data .. (tmpdata or "")
|
|
until not tmpdata
|
|
tmpdata = handle:close()
|
|
local handle = filesystem.open(toPath,"w")
|
|
handle:write(data)
|
|
handle:close() ]]
|
|
copyContent(filesystem.open(fromPath, "r"), filesystem.open(toPath, "w"))
|
|
end
|
|
end
|
|
|
|
function filesystem.remove(path)
|
|
checkArg(1, path, "string")
|
|
local address, absPath = filesystem.absolutePath(path)
|
|
if not address then
|
|
return false
|
|
end
|
|
if absPath:find("^/special") then
|
|
return false
|
|
end
|
|
if absPath:find("^/tmp") then
|
|
return false
|
|
end
|
|
if absPath:find("^/mnt") then
|
|
return false
|
|
end
|
|
return component.invoke(address, "remove", absPath)
|
|
end
|
|
|
|
function filesystem.makeDirectory(path)
|
|
checkArg(1, path, "string")
|
|
local address, absPath = filesystem.absolutePath(path)
|
|
if not address then
|
|
return false
|
|
end
|
|
return component.invoke(address, "makeDirectory", absPath)
|
|
end
|
|
|
|
return filesystem
|