CC_IEC-OS host v3

local modemSide = "back"
local credentials = {}
credentials["Grauly"] = {pass="f09513d6da1023d369a37bbad13638865c1d0f7aae3b157395fa7bdc3d2b2e89",access=3}
credentials["Marten"] = {pass="53643a3b756ad2ff75b5e63d865c1fffdd8b93796a85eb7b54ea93c157b6ab64",access=2}

-- end of config
sha256 = require("sha256").sha256

function startup()
    if (peripheral.isPresent(modemSide)) then
        if (peripheral.getType(modemSide) == "modem") then
            print("Modem found present - starting!")
            rednet.open(modemSide)
            return true
        else
            print("Modem was not found - aborting.")
            return false
        end
    else
        print("Modem was not found - aborting.")
        return false
    end
end

function hostnet(net)
    print("Starting " .. net .. "...")
    rednet.host(net, "IEC-Host")
    print(net .. " Successfully hosted!")
end

function hostnets()
    hostnet("IECNET")
    hostnet("Turtlenet")
    hostnet("Energynet")
    hostnet("Turretnet")
end

function unhostnet(net)
    rednet.unhost(net, "IEC-Host")
    print(net .. " Offline.")
end

function unhostnets()
    unhostnet("IECNET")
    unhostnet("Turtlenet")
    unhostnet("Energynet")
    unhostnet("Turretnet")
end

function tableContainsValue(table,value)
    if (type(table) == "table") then
        for k,v in pairs(table) do
            if (v == value) then
                return true
            end
        end
        return false
    else
        return false
    end
end

-- rednet handeling and main functionality
local lastTurtleTransmissions = {}
local lastTurtleTransmissionsTimer = {}
local lastEnergyReadouts = {}
local lastEnergyNetTransmissionTimer = {}
local turretRegisters = {}
local lastTurretCommands = {}
local loggedIn = {}

function rednetHandeling(sender, message, protocol)
    if (message == "ping") then -- ping
        rednet.send(sender, "pong", protocol)
    elseif (protocol == "Turtlenet") then -- Turtlenet handeling
        if (type(message) == "string") then
            lastTurtleTransmissions[sender] = message;
        end
        lastEnergyNetTransmissionTimer[sender] = 0
    elseif (protocol == "Energynet") then -- Energynet handeling
        lastEnergyReadouts[sender] = message
        lastEnergyNetTransmissionTimer[sender] = 0
    elseif (protocol == "Turretnet") then
        if (type(message) == "table") then
            if (message["command"] == "register") then
                turretsRegistered = turretRegisters[message["input"]]
                if (turretsRegistered == nil) then
                    turretsRegistered = {}
                end
                if (not tableContainsValue(turretsRegistered,sender)) then
                    table.insert(turretsRegistered,sender)
                    turretRegisters[message["input"]] = turretsRegistered
                    rednet.send(sender,"registered",protocol)
                    turretMessage = {}
                    turretMessage["n"] = false
                    turretMessage["m"] = false
                    turretMessage["p"] = false
                    rednet.send(sender,turretMessage,protocol)
                    lastTurretCommands[message["input"]] = turretMessage
                end
            end
        end
    elseif (protocol == "IECNET") then
        -- actual protocol handeling
        if (message == "Turtlenet querry") then
            returnMessage = {}
            returnMessage["message"] = lastTurtleTransmissions
            returnMessage["format"] = "turtle"
            rednet.send(sender, returnMessage, protocol)
        elseif (message == "Energynet querry") then
            returnMessage = {}
            returnMessage["message"] = lastEnergyReadouts
            returnMessage["format"] = "energy"
            rednet.send(sender, returnMessage, protocol)
        elseif (message == "Turtlenet Harvest") then
            print("Turtlenet Harvest Initiated")
            returnMessage = {}
            returnMessage["message"] = "Turtlenet Harvest"
            returnMessage["format"] = "Turtlenet"
            rednet.broadcast(returnMessage,"Turtlenet")
        elseif (message == "Turtlenet Reboot") then
            print("Turtlenet Reboot Initiated")
            returnMessage = {}
            returnMessage["message"] = "Turtlenet Reboot"
            returnMessage["format"] = "Turtlenet"
            rednet.broadcast(returnMessage,"Turtlenet")
        elseif (message == "Turretnet querry") then
            if (not (loggedIn[sender] == nil)) then --check if the user is logged in
                returnMessage = {}
                returnMessage["message"] = lastTurretCommands
                returnMessage["format"] = "Securitynet-Data"
                rednet.send(sender,returnMessage,protocol)
            else
                rednet.send(sender,"Logout",protocol)
            end
        elseif (type(message) == "table") then
            if (message["format"] == "Securitynet") then
                message = message["message"]
                if (message["action"] == "login") then
                    returnMessage = {}
                    returnMessage["message"] = "Denied"
                    if (type(message["user"]) == "string" and type(message["pass"]) == "string") then
                        if (not (credentials[message["user"]] == nil)) then
                            if (credentials[message["user"]]["pass"] == sha256(message["pass"])) then --password check
                                loggedIn[sender] = {access=credentials[message["user"]]["access"],timeout=0}
                                returnMessage["message"] = "Success"
                            end
                        end
                    end
                    returnMessage["format"] = "Securitynet-Login"
                    rednet.send(sender, returnMessage, protocol)
                elseif (message["action"] == "control") then
                    if (not (loggedIn[sender] == nil)) then --check if the user is logged in
                        turretsToRecieve = turretRegisters[message["label"]]
                        turretMessage = {}
                        turretMessage["n"] = lastTurretCommands[message["label"]]["n"]
                        turretMessage["m"] = lastTurretCommands[message["label"]]["m"]
                        turretMessage["p"] = lastTurretCommands[message["label"]]["p"]
                        if (type(message["n"]) == "boolean") then
                            turretMessage["n"] = message["n"]
                        end
                        if (type(message["m"]) == "boolean") then
                            turretMessage["m"] = message["m"]
                        end
                        if (type(message["p"]) == "boolean") then
                            turretMessage["p"] = message["p"]
                        end
                        for k,v in pairs(turretsToRecieve) do
                            rednet.send(v,turretMessage,"Turretnet")
                        end
                        lastTurretCommands[message["label"]] = turretMessage
                    else
                        rednet.send(sender,"Logout",protocol)
                    end
                end
            end
        end
    end
end

function routine()
    for k, v in pairs(lastEnergyNetTransmissionTimer) do
        if (v > 20) then
            readout = lastEnergyReadouts[k]
            if (not (readout == nil)) then
                readout["online"] = false
                lastEnergyReadouts[k] = readout
            end
        end
        lastEnergyNetTransmissionTimer[k] = v + 1
    end
    for k, v in pairs(lastTurtleTransmissionsTimer) do
        if (v > 500) then
            lastEnergyReadouts[k] = nil
        end
        lastTurtleTransmissionsTimer[k] = v + 1
    end
    for k, v in pairs(loggedIn) do
        if (v["timeout"] > 300) then
            loggedIn[k] = nil
            rednet.send(k,"Logout","IECNET")
        end
        v["timeout"] = v["timeout"] - 1
    end
end

if (not startup()) then
    print("Unable to Open Networking.")
    return
end
hostnets()
print("IEC-Host Active!")

timer = os.startTimer(1)
while true do
    event, a1, a2, a3 = os.pullEventRaw()
    if (event == "timer" and a1 == timer) then
        routine()
        timer = os.startTimer(1)
    elseif (event == "rednet_message") then
        rednetHandeling(a1, a2, a3)
        routine()
    elseif (event == "terminate") then
        term.setTextColor(colors.red)
        print("Shutting down...")
        term.setTextColor(colors.white)
        unhostnets()
        rednet.close(modemSide)
        return
    end
end