Переходим на MineOS Standalone #1

Libraries/Network.lua

@@ -0,0 +1,737 @@
+
+local GUI = require("GUI")
+local event = require("Event")
+local filesystem = require("Filesystem")
+local system = require("System")
+local paths = require("Paths")
+local text = require("Text")
+
+local network = {}
+
+----------------------------------------------------------------------------------------------------------------
+
+local filesystemProxy = filesystem.getProxy()
+
+network.filesystemHandles = {}
+
+network.modemProxy = nil
+network.modemPort = 1488
+network.modemPacketReserve = 128
+network.modemTimeout = 2
+
+network.internetProxy = nil
+network.internetDelay = 0.05
+network.internetTimeout = 0.25
+
+network.proxySpaceUsed = 0
+network.proxySpaceTotal = 1073741824
+
+----------------------------------------------------------------------------------------------------------------
+
+local function unmountProxy(type)
+	for proxy in filesystem.mounts() do
+		if proxy[type] then
+			filesystem.unmount(proxy)
+		end
+	end
+end
+
+function network.updateComponents()
+	local modem, internet = component.get("modem"), component.get("internet")
+	if modem then
+		network.modemProxy = modem
+		network.modemProxy.open(network.modemPort)
+	else
+		network.modemProxy = nil
+		network.unmountModems()
+	end
+
+	if internet then
+		network.internetProxy = internet
+	else
+		network.internetProxy = nil
+		network.unmountFTPs()
+	end
+end
+
+----------------------------------------------------------------------------------------------------------------
+
+function network.unmountFTPs()
+	unmountProxy("networkFTP")
+end
+
+function network.getFTPProxyName(address, port, user)
+	return user .. "@" .. address .. ":" .. port
+end
+
+local function FTPSocketWrite(socketHandle, data)
+	local success, result = pcall(socketHandle.write, data .. "\r\n")
+	if success then
+		return true, result
+	else
+		return false, result
+	end
+end
+
+local function FTPSocketRead(socketHandle)
+	event.sleep(network.internetDelay)
+
+	local deadline, data, success, result = computer.uptime() + network.internetTimeout, ""
+	while computer.uptime() < deadline do
+		success, result = pcall(socketHandle.read, math.huge)
+		if success then
+			if not result or #result == 0 then
+				if #data > 0 then
+					return true, data
+				end
+			else
+				data, deadline = data .. result, computer.uptime() + network.internetTimeout
+			end
+		else
+			return false, result
+		end
+	end
+
+	return false, "Socket read time out"
+end
+
+local function FTPParseLines(data)
+	local lines = {}
+
+	for line in data:gmatch("[^\r\n]+") do
+		table.insert(lines, line)
+	end
+
+	return lines
+end
+
+local function FTPLogin(socketHandle, user, password)
+	FTPSocketWrite(socketHandle, "USER " .. user)
+	FTPSocketWrite(socketHandle, "PASS " .. password)
+	FTPSocketWrite(socketHandle, "TYPE I")
+	
+	local success, result = FTPSocketRead(socketHandle)
+	if success then
+		if result:match("TYPE okay") then
+			return true
+		else
+			return false, "Authentication failed"
+		end
+	else
+		return false, result
+	end
+end
+
+local function FTPEnterPassiveModeAndRunCommand(commandSocketHandle, command, dataToWrite)
+	FTPSocketWrite(commandSocketHandle, "PASV")
+
+	local success, result = FTPSocketRead(commandSocketHandle)
+	if success then
+		local digits = {result:match("Entering Passive Mode %((%d+),(%d+),(%d+),(%d+),(%d+),(%d+)%)")}
+		if #digits == 6 then
+			local address, port =  table.concat(digits, ".", 1, 4), tonumber(digits[5]) * 256 + tonumber(digits[6])
+
+			FTPSocketWrite(commandSocketHandle, command)
+
+			local dataSocketHandle = network.internetProxy.connect(address, port)
+			if dataToWrite then
+				event.sleep(network.internetDelay)
+				dataSocketHandle.read(1)
+				dataSocketHandle.write(dataToWrite)
+				dataSocketHandle.close()
+
+				return true
+			else
+				local success, result = FTPSocketRead(dataSocketHandle)
+				dataSocketHandle.close()
+
+				if success then
+					return true, result
+				else
+					return false, result
+				end
+			end
+		else
+			return false, "Entering passive mode failed: wrong address byte array. Socket response message was: " .. tostring(result)
+		end
+	else
+		return false, result
+	end
+end
+
+local function FTPParseFileInfo(result)
+	local size, year, month, day, hour, minute, sec, type, name = result:match("Size=(%d+);Modify=(%d%d%d%d)(%d%d)(%d%d)(%d%d)(%d%d)(%d%d)[^;]*;Type=([^;]+);%s([^\r\n]+)")
+	if size then
+		return
+			true,
+			name,
+			type == "dir",
+			tonumber(size),
+			os.time({
+				year = year,
+				day = day,
+				month = month,
+				hour = hour,
+				minute = minute,
+				sec = sec
+			})
+	else
+		return false, "File not exists"
+	end
+end
+
+local function FTPFileInfo(socketHandle, path, field)
+	FTPSocketWrite(socketHandle, "MLST " .. path)
+	
+	local success, result = FTPSocketRead(socketHandle)
+	if success then
+		local success, name, isDirectory, size, lastModified = FTPParseFileInfo(result)
+		if success then
+			if field == "isDirectory" then
+				return true, isDirectory
+			elseif field == "lastModified" then
+				return true, lastModified
+			else
+				return true, size
+			end
+		else
+			return true, false
+		end
+	else
+		return false, result
+	end
+end
+
+local function check(...)
+	local result = {...}
+	if not result[1] then
+		GUI.error(table.unpack(result, 2))
+	end
+	return table.unpack(result)
+end
+
+function network.connectToFTP(address, port, user, password)
+	if network.internetProxy then
+		local socketHandle, reason = network.internetProxy.connect(address, port)
+		if socketHandle then
+			FTPSocketRead(socketHandle)
+
+			local result, reason = FTPLogin(socketHandle, user, password)
+			if result then
+
+				local proxy, fileHandles, label = {}, {}, network.getFTPProxyName(address, port, user)
+
+				proxy.type = "filesystem"
+				proxy.slot = 0
+				proxy.address = label
+				proxy.networkFTP = true
+
+				proxy.getLabel = function()
+					return label
+				end
+
+				proxy.spaceUsed = function()
+					return network.proxySpaceUsed
+				end
+
+				proxy.spaceTotal = function()
+					return network.proxySpaceTotal
+				end
+
+				proxy.setLabel = function(text)
+					label = text
+					return true
+				end
+
+				proxy.isReadOnly = function()
+					return false
+				end
+
+				proxy.closeSocketHandle = function()
+					filesystem.unmount(proxy)
+					return socketHandle.close()
+				end
+
+				proxy.list = function(path)
+					local success, result = FTPEnterPassiveModeAndRunCommand(socketHandle, "MLSD -a " .. path)
+					if success then
+						local list = FTPParseLines(result)
+						for i = 1, #list do
+							local success, name, isDirectory = FTPParseFileInfo(list[i])
+							if success then
+								list[i] = name .. (isDirectory and "/" or "")
+							end
+						end
+
+						return list
+					else
+						return {}
+					end
+				end
+
+				proxy.isDirectory = function(path)
+					local success, result = check(FTPFileInfo(socketHandle, path, "isDirectory"))
+					if success then
+						return result
+					else
+						return false
+					end
+				end
+
+				proxy.lastModified = function(path)
+					local success, result = check(FTPFileInfo(socketHandle, path, "lastModified"))
+					if success then
+						return result
+					else
+						return 0
+					end
+				end
+
+				proxy.size = function(path)
+					local success, result = check(FTPFileInfo(socketHandle, path, "size"))
+					if success then
+						return result
+					else
+						return 0
+					end
+				end
+
+				proxy.exists = function(path)
+					local success, result = check(FTPFileInfo(socketHandle, path))
+					if success then
+						return result
+					else
+						return false
+					end
+				end
+
+				proxy.open = function(path, mode)
+					local temporaryPath = system.getTemporaryPath()
+					
+					if mode == "r" or mode == "rb" or mode == "a" or mode == "ab" then
+						local success, result = FTPEnterPassiveModeAndRunCommand(socketHandle, "RETR " .. path)		
+						
+						filesystem.write(temporaryPath, success and result or "")
+					end
+					
+					local fileHandle, reason = filesystemProxy.open(temporaryPath, mode)
+					if fileHandle then
+						fileHandles[fileHandle] = {
+							temporaryPath = temporaryPath,
+							path = path,
+							needUpload = mode ~= "r" and mode ~= "rb",
+						}
+					end
+
+					return fileHandle, reason
+				end
+
+				proxy.close = function(fileHandle)
+					filesystemProxy.close(fileHandle)
+
+					if fileHandles[fileHandle].needUpload then
+						local data = filesystem.read(fileHandles[fileHandle].temporaryPath)
+
+						check(FTPEnterPassiveModeAndRunCommand(socketHandle, "STOR " .. fileHandles[fileHandle].path, data))
+					end
+
+					filesystem.remove(fileHandles[fileHandle].temporaryPath)
+					fileHandles[fileHandle] = nil
+				end
+
+				proxy.write = function(...)
+					return filesystemProxy.write(...)
+				end
+
+				proxy.read = function(...)
+					return filesystemProxy.read(...)
+				end
+
+				proxy.seek = function(...)
+					return filesystemProxy.seek(...)
+				end
+
+				proxy.remove = function(path)
+					if proxy.isDirectory(path) then		
+						local list = proxy.list(path)
+						for i = 1, #list do
+							proxy.remove((path .. "/" .. list[i]):gsub("/+", "/"))
+						end
+
+						FTPSocketWrite(socketHandle, "RMD " .. path)
+					else
+						FTPSocketWrite(socketHandle, "DELE " .. path)
+					end
+				end
+
+				proxy.makeDirectory = function(path)
+					FTPSocketWrite(socketHandle, "MKD " .. path)
+					return true
+				end
+
+				proxy.rename = function(oldPath, newPath)
+					FTPSocketWrite(socketHandle, "RNFR " .. oldPath)
+					FTPSocketWrite(socketHandle, "RNTO " .. newPath)
+
+					return true
+				end
+
+				return proxy
+			else
+				return false, reason
+			end
+		else
+			return false, reason
+		end
+	else
+		return false, "Internet component is not available"
+	end
+end
+
+----------------------------------------------------------------------------------------------------------------
+
+function network.unmountModems()
+	unmountProxy("networkModem")
+end
+
+function network.getModemProxyName(proxy)
+	return proxy.name and proxy.name .. " (" .. proxy.address .. ")" or proxy.address
+end
+
+function network.getMountedModemProxy(address)
+	for proxy, path in filesystem.mounts() do
+		if proxy.networkModem and proxy.address == address then
+			return proxy
+		end
+	end
+end
+
+function network.sendMessage(address, ...)
+	if network.modemProxy then
+		return network.modemProxy.send(address, network.modemPort, ...)
+	else
+		network.modemProxy = nil
+		return false, "Modem component is not available"
+	end
+end
+
+function network.broadcastMessage(...)
+	if network.modemProxy then
+		return network.modemProxy.broadcast(network.modemPort, ...)
+	else
+		network.modemProxy = nil
+		return false, "Modem component is not available"
+	end
+end
+
+function network.setSignalStrength(strength)
+	if network.modemProxy then
+		if network.modemProxy.isWireless() then
+			return network.modemProxy.setStrength(strength)
+		else
+			return false, "Modem component is not wireless"
+		end
+	else
+		network.modemProxy = nil
+		return false, "Modem component is not available"
+	end
+end
+
+function network.broadcastComputerState(state)
+	return network.broadcastMessage("network", state and "computerAvailable" or "computerNotAvailable", system.properties.networkName)
+end
+
+local function newModemProxy(address)
+	local function request(method, returnOnFailure, ...)
+		network.sendMessage(address, "network", "request", method, ...)
+		
+		while true do
+			local eventData = { event.pull(network.modemTimeout) }
+			if eventData[1] == "modem_message" then
+				if eventData[3] == address and eventData[6] == "network" then
+					if eventData[7] == "response" and eventData[8] == method then
+						return table.unpack(eventData, 9)
+					elseif eventData[7] == "accessDenied" then
+						computer.pushSignal("network", "accessDenied", address)
+						return returnOnFailure, "Access denied"
+					end
+				elseif not eventData[1] then
+					local proxy = network.getMountedModemProxy(address)
+					if proxy then
+						filesystem.unmount(proxy)
+					end
+
+					computer.pushSignal("network", "timeout")
+
+					return returnOnFailure, "Network filesystem timeout"
+				end
+			end
+		end
+	end
+
+	local proxy = {}
+
+	proxy.type = "filesystem"
+	proxy.address = address
+	proxy.slot = 0
+	proxy.networkModem = true
+	
+	proxy.getLabel = function()
+		return request("getLabel", "N/A")
+	end
+
+	proxy.isReadOnly = function()
+		return request("isReadOnly", 0)
+	end
+
+	proxy.spaceUsed = function()
+		return request("spaceUsed", network.proxySpaceUsed)
+	end
+
+	proxy.spaceTotal = function()
+		return request("spaceTotal", network.proxySpaceTotal)
+	end
+
+	proxy.exists = function(path)
+		return request("exists", false, path)
+	end
+
+	proxy.isDirectory = function(path)
+		return request("isDirectory", false, path)
+	end
+
+	proxy.makeDirectory = function(path)
+		return request("makeDirectory", false, path)
+	end
+
+	proxy.setLabel = function(name)
+		return request("setLabel", false, name)
+	end
+
+	proxy.remove = function(path)
+		return request("remove", false, path)
+	end
+
+	proxy.lastModified = function(path)
+		return request("lastModified", 0, path)
+	end
+
+	proxy.size = function(path)
+		return request("size", 0, path)
+	end
+
+	proxy.list = function(path)
+		return text.deserialize(request("list", "{}", path))
+	end
+
+	proxy.open = function(path, mode)
+		return request("open", false, path, mode)
+	end
+
+	proxy.close = function(handle)
+		return request("close", false, handle)
+	end
+
+	proxy.seek = function(...)
+		return request("seek", 0, ...)
+	end
+
+	proxy.read = function(...)
+		return request("read", "", ...)
+	end
+
+	write = function(handle, data)
+		local maxPacketSize = network.modemProxy.maxPacketSize() - network.modemPacketReserve
+		repeat
+			if not request("write", false, handle, data:sub(1, maxPacketSize)) then
+				return false
+			end
+			data = data:sub(maxPacketSize + 1)
+		until #data == 0
+
+		return true
+	end
+
+	proxy.rename = function(from, to)
+		local proxyFrom = filesystem.get(from)
+		local proxyTo = filesystem.get(to)
+
+		if proxyFrom.networkModem or proxyTo.networkModem then
+			local success, handleFrom, handleTo, data, reason = true
+			
+			handleFrom, reason = proxyFrom.open(from, "rb")
+			if handleFrom then
+				handleTo, reason = proxyTo.open(to, "wb")
+				if handleTo then
+					while true do
+						data, readReason = proxyFrom.read(handleFrom, 1024)
+						if data then
+							success, reason = proxyTo.write(handleTo, data)
+							if not success then
+								break
+							end
+						else
+							success = false
+							break
+						end
+					end
+
+					proxyFrom.close(handleTo)
+				else
+					success = false
+				end
+
+				proxyFrom.close(handleFrom)
+			else
+				success = false
+			end
+
+			if success then
+				success, reason = proxyFrom.remove(from)
+			end
+
+			return success, reason
+		else
+			return request("rename", false, from, to)
+		end
+	end
+
+	return proxy
+end
+
+local exceptionMethods = {
+	getLabel = function()
+		return system.properties.networkName or network.modemProxy.address
+	end,
+
+	list = function(path)
+		return text.serialize(filesystemProxy.list(path))
+	end,
+
+	open = function(path, mode)
+		local ID
+		while not ID do
+			ID = math.random(1, 0x7FFFFFFF)
+			for handleID in pairs(network.filesystemHandles) do
+				if handleID == ID then
+					ID = nil
+				end
+			end
+		end
+
+		network.filesystemHandles[ID] = filesystemProxy.open(path, mode)
+		
+		return ID
+	end,
+
+	close = function(ID)
+		local data, reason = filesystemProxy.close(network.filesystemHandles[ID])
+		network.filesystemHandles[ID] = nil
+		return data, reason
+	end,
+
+	read = function(ID, ...)
+		return filesystemProxy.read(network.filesystemHandles[ID], ...)
+	end,
+
+	write = function(ID, ...)
+		return filesystemProxy.write(network.filesystemHandles[ID], ...)
+	end,
+
+	seek = function(ID, ...)
+		return filesystemProxy.seek(network.filesystemHandles[ID], ...)
+	end,
+}
+
+local function handleRequest(eventData)	
+	if system.properties.networkUsers[eventData[3]].allowReadAndWrite then
+		local result = { pcall(exceptionMethods[eventData[8]] or filesystemProxy[eventData[8]], table.unpack(eventData, 9)) }
+		network.sendMessage(eventData[3], "network", "response", eventData[8], table.unpack(result, result[1] and 2 or 1))
+	else
+		network.sendMessage(eventData[3], "network", "accessDenied")
+	end
+end
+
+----------------------------------------------------------------------------------------------------------------
+
+function network.update()
+	network.unmountModems()
+	network.unmountFTPs()
+	network.updateComponents()
+	network.setSignalStrength(system.properties.networkSignalStrength)
+	network.broadcastComputerState(system.properties.networkEnabled)
+
+	if network.eventHandlerID then
+		event.removeHandler(network.eventHandlerID)
+	end
+
+	if system.properties.networkEnabled then
+		network.eventHandlerID = event.addHandler(function(...)
+			local eventData = {...}
+			
+			if (eventData[1] == "component_added" or eventData[1] == "component_removed") and (eventData[3] == "modem" or eventData[3] == "internet") then
+				network.updateComponents()
+			elseif eventData[1] == "modem_message" and system.properties.networkEnabled and eventData[6] == "network" then
+				if eventData[7] == "request" then
+					handleRequest(eventData)
+				elseif eventData[7] == "computerAvailable" or eventData[7] == "computerAvailableRedirect" then
+					for proxy in filesystem.mounts() do
+						if proxy.networkModem and proxy.address == eventData[3] then
+							filesystem.unmount(proxy)
+						end
+					end
+
+					proxy = newModemProxy(eventData[3])
+					proxy.name = eventData[8]
+					filesystem.mount(proxy, paths.system.mounts .. eventData[3] .. "/")
+
+					if eventData[7] == "computerAvailable" then
+						network.sendMessage(eventData[3], "network", "computerAvailableRedirect", system.properties.networkName)
+					end
+
+					if not system.properties.networkUsers[eventData[3]] then
+						system.properties.networkUsers[eventData[3]] = {}
+						system.saveProperties()
+					end
+
+					computer.pushSignal("network", "updateProxyList")
+				elseif eventData[7] == "computerNotAvailable" then
+					local proxy = network.getMountedModemProxy(eventData[3])
+					if proxy then
+						filesystem.unmount(proxy)
+					end
+
+					computer.pushSignal("network", "updateProxyList")
+				end
+			end
+		end)
+	end
+end
+
+function network.disable()
+	system.properties.networkEnabled = false
+	system.saveProperties()
+	network.update()
+end
+
+function network.enable()
+	system.properties.networkEnabled = true
+	system.saveProperties()
+	network.update()
+end
+
+----------------------------------------------------------------------------------------------------------------
+
+-- network.updateComponents()
+
+-- local proxy, reason = network.FTPProxy("localhost", 8888, "root", "1234")
+-- print(proxy, reason)
+
+----------------------------------------------------------------------------------------------------------------
+
+return network
+
+
+
+
+