[project/luci.git] / libs / core / luasrc / model / network.lua

--[[
LuCI - Network model

Copyright 2009 Jo-Philipp Wich <xm@subsignal.org>

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

]]--

local type, pairs, ipairs, loadfile, table, i18n
        = type, pairs, ipairs, loadfile, table, luci.i18n

local lmo = require "lmo"
local nxo = require "nixio"
local nfs = require "nixio.fs"
local iwi = require "iwinfo"
local ipc = require "luci.ip"
local utl = require "luci.util"
local uct = require "luci.model.uci.bind"

module "luci.model.network"

-- load extensions
local ext
local handler = { }

for ext in nfs.glob(utl.libpath() .. "/model/network/*.lua") do
        if nfs.access(ext) then
                local m = loadfile(ext)
                if m then
                        handler[#handler+1] = m()
                end
        end
end

function foreach_handler(code, ...)
        local h
        for _, h in ipairs(handler) do
                if code(h, ...) then
                        return true
                end
        end
        return false
end

local ub = uct.bind("network")
local ifs, brs, sws

function init(cursor)
        if cursor then
                cursor:unload("network")
                cursor:load("network")
                ub:init(cursor)

                ifs = { }
                brs = { }
                sws = { }

                -- init handler
                foreach_handler(function(h)
                        h:init(cursor)
                        h:find_interfaces(ifs, brs)
                end)

                -- read interface information
                local n, i
                for n, i in ipairs(nxo.getifaddrs()) do
                        local name = i.name:match("[^:]+")
                        local prnt = name:match("^([^%.]+)%.")

                        if not _M:ignore_interface(name) then
                                ifs[name] = ifs[name] or {
                                        idx      = i.ifindex or n,
                                        name     = name,
                                        rawname  = i.name,
                                        flags    = { },
                                        ipaddrs  = { },
                                        ip6addrs = { }
                                }

                                if prnt then
                                        sws[name] = true
                                        sws[prnt] = true
                                end

                                if i.family == "packet" then
                                        ifs[name].flags   = i.flags
                                        ifs[name].stats   = i.data
                                        ifs[name].macaddr = i.addr
                                elseif i.family == "inet" then
                                        ifs[name].ipaddrs[#ifs[name].ipaddrs+1] = ipc.IPv4(i.addr, i.netmask)
                                elseif i.family == "inet6" then
                                        ifs[name].ip6addrs[#ifs[name].ip6addrs+1] = ipc.IPv6(i.addr, i.netmask)
                                end
                        end
                end

                -- read bridge informaton
                local b, l
                for l in utl.execi("brctl show") do
                        if not l:match("STP") then
                                local r = utl.split(l, "%s+", nil, true)
                                if #r == 4 then
                                        b = {
                                                name    = r[1],
                                                id      = r[2],
                                                stp     = r[3] == "yes",
                                                ifnames = { ifs[r[4]] }
                                        }
                                        if b.ifnames[1] then
                                                b.ifnames[1].bridge = b
                                        end
                                        brs[r[1]] = b
                                elseif b then
                                        b.ifnames[#b.ifnames+1] = ifs[r[2]]
                                        b.ifnames[#b.ifnames].bridge = b
                                end
                        end
                end
        end
end

function has_ipv6(self)
        return nfs.access("/proc/net/ipv6_route")
end

function add_network(self, n, options)
        if n and #n > 0 and n:match("^[a-zA-Z0-9_]+$") and not self:get_network(n) then
                if ub.uci:section("network", "interface", n, options) then
                        return network(n)
                end
        end
end

function get_network(self, n)
        if n and ub.uci:get("network", n) == "interface" then
                return network(n)
        end
end

function get_networks(self)
        local nets = { }
        ub.uci:foreach("network", "interface",
                function(s)
                        nets[#nets+1] = network(s['.name'])
                end)
        return nets
end

function del_network(self, n)
        local r = ub.uci:delete("network", n)
        if r then
                ub.uci:foreach("network", "alias",
                        function(s)
                                if s.interface == n then
                                        ub.uci:delete("network", s['.name'])
                                end
                        end)
                ub.uci:foreach("network", "route",
                        function(s)
                                if s.interface == n then
                                        ub.uci:delete("network", s['.name'])
                                end
                        end)
                ub.uci:foreach("network", "route6",
                        function(s)
                                if s.interface == n then
                                        ub.uci:delete("network", s['.name'])
                                end
                        end)

                foreach_handler(function(h) h:del_network(n) end)
        end
        return r
end

function rename_network(self, old, new)
        local r
        if new and #new > 0 and new:match("^[a-zA-Z0-9_]+$") and not self:get_network(new) then
                r = ub.uci:section("network", "interface", new,
                        ub.uci:get_all("network", old))

                if r then
                        ub.uci:foreach("network", "alias",
                                function(s)
                                        if s.interface == old then
                                                ub.uci:set("network", s['.name'], "interface", new)
                                        end
                                end)
                        ub.uci:foreach("network", "route",
                                function(s)
                                        if s.interface == old then
                                                ub.uci:set("network", s['.name'], "interface", new)
                                        end
                                end)
                        ub.uci:foreach("network", "route6",
                                function(s)
                                        if s.interface == old then
                                                ub.uci:set("network", s['.name'], "interface", new)
                                        end
                                end)

                        foreach_handler(function(h) h:rename_network(old, new) end)
                end
        end
        return r or false
end

function get_interface(self, i)
        if ifs[i] then
                return interface(i)
        else
                local j
                for j, _ in pairs(ifs) do
                        if ifs[j].sid == i then
                                return interface(j)
                        end
                end
        end
end

function get_interfaces(self)
        local ifaces = { }
        local iface
        for iface, _ in pairs(ifs) do
                ifaces[#ifaces+1] = interface(iface)
        end
        return ifaces
end

function ignore_interface(self, x)
        if foreach_handler(function(h) return h:ignore_interface(x) end) then
                return true
        else
                return (x:match("^wmaster%d") or x:match("^wifi%d")
                        or x:match("^hwsim%d") or x:match("^imq%d") or x == "lo")
        end
end


network = ub:section("interface")
network:property("device")
network:property("ifname")
network:property("proto")
network:property("type")

function network.name(self)
        return self.sid
end

function network.is_bridge(self)
        return (self:type() == "bridge")
end

function network.add_interface(self, ifname)
        local ifaces, iface

        if type(ifname) ~= "string" then
                ifaces = { ifname:name() }
        else
                ifaces = ub:list(ifname)
        end

        for _, iface in ipairs(ifaces) do
                if ifs[iface] then
                        -- make sure the interface is removed from all networks
                        local i = interface(iface)
                        local n = i:get_network()
                        if n then n:del_interface(iface) end

                        if ifs[iface].handler then
                                ifs[iface].handler:add_interface(self, iface, ifs[iface])
                        else
                                self:ifname(ub:list((self:ifname() or ''), iface))
                        end
                end
        end
end

function network.del_interface(self, ifname)
        if type(ifname) ~= "string" then
                ifname = ifname:name()
        end

        if ifs[ifname] and ifs[ifname].handler then
                ifs[ifname].handler:del_interface(self, ifname, ifs[ifname])
        else
                self:ifname(ub:list((self:ifname() or ''), nil, ifname))
        end
end

function network.get_interfaces(self)
        local ifaces = { }
        local iface
        for _, iface in ipairs(ub:list(self:ifname())) do
                iface = iface:match("[^:]+")
                if ifs[iface] then
                        ifaces[#ifaces+1] = interface(iface)
                end
        end
        for iface, _ in pairs(ifs) do
                if ifs[iface].network == self:name() then
                        ifaces[#ifaces+1] = interface(iface)
                end
        end
        return ifaces
end

function network.contains_interface(self, iface)
        local i
        local ifaces = ub:list(self:ifname())

        if type(iface) ~= "string" then
                iface = iface:name()
        end

        for _, i in ipairs(ifaces) do
                if i == iface then
                        return true
                end
        end

        for i, _ in pairs(ifs) do
                if ifs[i].dev and ifs[i].dev.network == self:name() then
                        return true
                end
        end

        return false
end


interface = utl.class()
function interface.__init__(self, ifname)
        if ifs[ifname] then
                self.ifname = ifname
                self.dev    = ifs[ifname]
                self.br     = brs[ifname]
        end
end

function interface.name(self)
        return self.ifname
end

function interface.mac(self)
        return self.dev.macaddr or "00:00:00:00:00:00"
end

function interface.ipaddrs(self)
        return self.dev.ipaddrs or { }
end

function interface.ip6addrs(self)
        return self.dev.ip6addrs or { }
end

function interface.type(self)
        if self.dev and self.dev.type then
                return self.dev.type
        elseif brs[self.ifname] then
                return "bridge"
        elseif sws[self.ifname] or self.ifname:match("%.") then
                return "switch"
        else
                return "ethernet"
        end
end

function interface.shortname(self)
        if self.dev and self.dev.handler then
                return self.dev.handler:shortname(self)
        else
                return self.ifname
        end
end

function interface.get_i18n(self)
        if self.dev and self.dev.handler then
                return self.dev.handler:get_i18n(self)
        else
                return "%s: %q" %{ self:get_type_i18n(), self:name() }
        end
end

function interface.get_type_i18n(self)
        local x = self:type()
        if x == "wifi" then
                return i18n.translate("Wireless Adapter")
        elseif x == "bridge" then
                return i18n.translate("Bridge")
        elseif x == "switch" then
                return i18n.translate("Ethernet Switch")
        else
                return i18n.translate("Ethernet Adapter")
        end
end

function interface.ports(self)
        if self.br then
                local iface
                local ifaces = { }
                for _, iface in ipairs(self.br.ifnames) do
                        ifaces[#ifaces+1] = interface(iface.name)
                end
                return ifaces
        end
end

function interface.bridge_id(self)
        if self.br then
                return self.br.id
        else
                return nil
        end
end

function interface.bridge_stp(self)
        if self.br then
                return self.br.stp
        else
                return false
        end
end

function interface.is_up(self)
        return self.dev.flags and self.dev.flags.up
end

function interface.is_bridge(self)
        return (self:type() == "bridge")
end

function interface.is_bridgeport(self)
        return self.dev and self.dev.bridge and true or false
end

function interface.tx_bytes(self)
        return self.dev and self.dev.stats
                and self.dev.stats.tx_bytes or 0
end

function interface.rx_bytes(self)
        return self.dev and self.dev.stats
                and self.dev.stats.rx_bytes or 0
end

function interface.tx_packets(self)
        return self.dev and self.dev.stats
                and self.dev.stats.tx_packets or 0
end

function interface.rx_packets(self)
        return self.dev and self.dev.stats
                and self.dev.stats.rx_packets or 0
end

function interface.get_network(self)
        if self.dev and self.dev.network then
                self.network = _M:get_network(self.dev.network)
        end

        if not self.network then
                local net
                for _, net in ipairs(_M:get_networks()) do
                        if net:contains_interface(self.ifname) then
                                self.network = net
                                return net
                        end
                end
        else
                return self.network
        end
end

--[==[
#!/usr/bin/lua

local uci = require "luci.model.uci".cursor_state()
local utl = require "luci.util"
local sys = require "luci.sys"
local lip = require "luci.ip"
local nxo = require "nixio"
local nfs = require "nixio.fs"

-- patch uci
local x = getmetatable(uci)

function x:list(...)
        local val = self:get(...)
        local lst = { }

        if type(val) == "list" then
                local _, v
                for _, v in ipairs(val) do
                        local i
                        for i in v:gmatch("%S+") do
                                lst[#lst+1] = i
                        end
                end
        elseif type(val) == "string" then
                local i
                for i in val:gmatch("%S+") do
                        lst[#lst+1] = i
                end
        end

        return lst
end


system = utl.class()

system._switches = { }
system._vlans    = { }

function system:__init__()
        self._networks = { }

        uci:foreach("network2", "interface",
                function(s)
                        self._networks[#self._networks+1] = system.network(s, self)
                end)
end

function system:networks()
        local index = 0
        return function()
                if index <= #self._networks then
                        index = index + 1
                        return self._networks[index]
                else
                        return nil
                end
        end
end

function system:find_network(name)
        local v
        for _, v in ipairs(self._networks) do
                if v:name() == name then
                        return v
                end
        end
end

function system:find_interface(name)
        local v
        for _, v in ipairs(self._networks) do
                local i
                for i in v:interfaces() do
                        if i:is_bridge() then
                                local p
                                for p in i:interfaces() do
                                        if p:name() == name then
                                                return p
                                        end
                                end
                        end

                        if i:name() == name then
                                return i
                        end
                end
        end
end

function system:delete_network(name)
        local i
        for i = 1, #self._networks do
                if self._networks[i]:name() == name then
                        local x

                        for x in self._networks[i]:aliases() do
                                uci:delete("network2", x:name())
                        end

                        for x in self._networks[i]:routes() do
                                uci:delete("network2", x:name())
                        end

                        uci:delete("network2", self._networks[i])
                        table.remove(self._networks, i)

                        return true
                end
        end
        return false
end

function system:print()
        local v
        for v in self:networks() do
                print(v:name())
                v:print()
                print("--")
        end
end

function system.ignore_iface(ifn)
        return (nil ~= (
                ifn:match("^wlan%d") or 
                ifn:match("^ath%d")  or
                ifn:match("^wl%d")   or
                ifn:match("^imq%d")  or
                ifn:match("^br%-")   or
                ifn:match("^/dev/")
        ))
end

function system.find_wifi_networks(net)
        local lst = { }
        local cnt = 0

        uci:foreach("wireless", "wifi-iface",
                function(s)
                        if s.device and s.network == net then
                                lst[#lst+1] = { s.device, s['.name'], cnt }
                        end
                        cnt = cnt + 1
                end)

        return lst
end

function system.find_iface_names(net)
        local lst = { }

        local val = uci:list("network2", net, "device")
        if #val == 0 or val[1]:match("^/dev/") then
                val = uci:list("network2", net, "ifname")
        end

        local ifn
        for _, ifn in ipairs(val) do
                if not system.ignore_iface(ifn) then
                        lst[#lst+1] = ifn
                end
        end
        
        return lst
end

function system.find_switch(name)
        local swname, swdev, swvlan

        -- find switch
        uci:foreach("network2", "switch",
                function(s)
                        swname = s.name or s['.name']

                        -- special: rtl8366s is eth0 (wan is eth1)
                        if swname == "rtl8366s" then
                                swdev = "eth0"

                        -- special: rtl8366rb is eth0 (wan + lan)
                        elseif swname == "rtl8366rb" then
                                swdev = "eth0"

                        -- treat swname as swdev
                        else
                                swdev = swname
                        end

                        return false
                end)

        -- find first vlan
        if swdev then
                uci:foreach("network2", "switch_vlan",
                        function(s)
                                if s.device == swname then
                                        local vlan = tonumber(s.vlan)
                                        if vlan and (not swvlan or vlan < swvlan) then
                                                swvlan = vlan
                                        end
                                end
                        end)
        end


        local veth, vlan = name:match("^(%S+)%.(%d+)$")

        -- have vlan id and matching switch
        if vlan and veth == swdev then
                return swname, swdev, vlan

        -- have no vlan id but matching switch, assume first switch vlan
        elseif not vlan and name == swdev then
                return swname, swdev, swvlan

        -- have vlan and no matching switch, assume software vlan
        elseif vlan then
                return nil, veth, vlan
        end
end


system.network = utl.class()

function system.network:__init__(s, sys)
        self._name    = s['.name']
        self._sys     = sys
        self._routes  = { }
        self._aliases = { }

        if s.type == "bridge" then
                self._interfaces = { system.network.bridge(s['.name'], self) }
        else
                self._interfaces = { }

                local ifn

                -- find wired ifaces
                for _, ifn in ipairs(system.find_iface_names(self._name)) do
                        self._interfaces[#self._interfaces+1] = system.network.iface(ifn, self)
                end

                -- find wifi networks
                for _, ifn in ipairs(system.find_wifi_networks(self._name)) do
                        self._interfaces[#self._interfaces+1] = system.network.iface(ifn, self)
                end
        end

        -- find ipv4 routes
        uci:foreach("network2", "route",
                function(s)
                        if s.interface == self._name and s.target then
                                self._routes[#self._routes+1] = system.network.route(s, self)
                        end
                end)

        -- find ipv6 routes
        uci:foreach("network2", "route6",
                function(s)
                        if s.interface == self._name and s.target then
                                self._routes[#self._routes+1] = system.network.route(s, self)
                        end
                end)

        -- find aliases
        uci:foreach("network2", "alias",
                function(s)
                        if s.interface == self._name and s.proto then
                                self._aliases[#self._aliases+1] = system.network.alias(s, self)
                        end
                end)
end

function system.network:name()
        return self._name
end

function system.network:system()
        return self._sys
end

function system.network:interfaces()
        local index = 0
        return function()
                if index <= #self._interfaces then
                        index = index + 1
                        return self._interfaces[index]
                else
                        return nil
                end
        end
end

function system.network:interface()
        return self._interfaces[1]
end

function system.network:num_routes()
        return #self._routes
end

function system.network:routes()
        local index = 0
        return function()
                if index <= #self._routes then
                        index = index + 1
                        return self._routes[index]
                else
                        return nil
                end
        end
end

function system.network:num_aliases()
        return #self._aliases
end

function system.network:aliases()
        local index = 0
        return function()
                if index <= #self._aliases then
                        index = index + 1
                        return self._aliases[index]
                else
                        return nil
                end
        end
end

function system.network:delete_route(rt)
        local i
        for i = 1, #self._routes do
                if self._routes[i]:name() == rt:name() then
                        uci:delete("network2", rt:name())
                        table.remove(self._routes, i)
                        return true
                end
        end
        return false
end

function system.network:delete_alias(al)
        local i
        for i = 1, #self._aliases do
                if self._aliases[i]:name() == al:name() then
                        uci:delete("network2", al:name())
                        table.remove(self._aliases, i)
                        return true
                end
        end
        return false
end

function system.network:print()
        self:interface():print()
end


system.network.iface = utl.class()

function system.network.iface:__init__(ifn, net, parent)
        self._net    = net
        self._parent = parent

        -- is a wifi iface
        if type(ifn) == "table" then
                local wifidev, network, index = unpack(ifn)

                self._name    = "%s.%d" %{ wifidev, index }
                self._wifidev = wifidev
                self._wifinet = index
                self._ifname  = uci:get("wireless", network, "ifname") or self._name

        -- is a wired iface
        else
                self._name   = ifn
                self._ifname = ifn

                local switch, swdev, vlan = system.find_switch(self._ifname)

                if switch then
                        self._switch = system.switch(switch, swdev, self)
                end

                if vlan then
                        self._vlan = system.vlan(vlan, self._switch, self)
                end
        end
end

function system.network.iface:name()
        return self._name
end

function system.network.iface:parent()
        return self._parent
end

function system.network.iface:network()
        return self._net
end

function system.network.iface:is_managed()
        return (self._net ~= nil)
end

function system.network.iface:is_vlan()
        return (self._vlan ~= nil)
end

function system.network.iface:is_software_vlan()
        return (not self._switch and self._vlan ~= nil)
end

function system.network.iface:is_hardware_vlan()
        return (self._switch ~= nil and self._vlan ~= nil)
end

function system.network.iface:_sysfs(path, default)
        path = "/sys/class/net/%s/%s" %{ self._ifname, path }

        local data = nfs.readfile(path)

        if type(default) == "number" then
                return tonumber(data) or default
        elseif data and #data > 0 then
                return data and data:gsub("%s+$", "") or default
        end

        return default
end

function system.network.iface:rx_bytes()
        return self:_sysfs("statistics/rx_bytes", 0)
end

function system.network.iface:tx_bytes()
        return self:_sysfs("statistics/tx_bytes", 0)
end

function system.network.iface:rx_packets()
        return self:_sysfs("statistics/rx_packets", 0)
end

function system.network.iface:tx_packets()
        return self:_sysfs("statistics/tx_packets", 0)
end

function system.network.iface:macaddr()
        return self:_sysfs("address")
end

function system.network.iface:mtu()
        return self:_sysfs("mtu", 1500)
end

function system.network.iface:is_bridge()
        return (self:_sysfs("bridge/max_age", 0) > 0)
end

function system.network.iface:is_bridge_port()
        return (self:_sysfs("brport/port_no", 0) > 0)
end

function system.network.iface:delete()
        if self._wifidev then
                local cnt = 0
                uci:foreach("wireless", "wifi-iface", 
                        function(s)
                                cnt = cnt + 1
                                if s.device == self._wifidev and cnt == self._wifinet then
                                        uci:delete("wireless", s['.name'])
                                        return false
                                end
                        end)
        end
end

function system.network.iface:print()
        if self._wifidev then
                print("  wifi: ", self._wifidev, "net: ", self._wifinet)
        else
                print("  iface: ", self._name)
        end

        print("    rx: ", self:rx_bytes(), self:rx_packets())
        print("    tx: ", self:tx_bytes(), self:tx_packets())
        print("    mtu: ", self:mtu())
        print("    mac: ", self:macaddr())
        print("    bridge? ", self:is_bridge())
        print("    port? ", self:is_bridge_port())
        print("    swvlan? ", self:is_software_vlan())
        print("    hwvlan? ", self:is_hardware_vlan())

        if self._switch then
                self._switch:print()
        end

        if self._vlan then
                self._vlan:print()
        end
end


system.network.bridge = utl.class(system.network.iface)

function system.network.bridge:__init__(brn, net)
        self._net    = net
        self._name   = "br-" .. brn
        self._ifname = self._name
        self._interfaces = { }

        local ifn

        -- find wired ifaces
        for _, ifn in ipairs(system.find_iface_names(brn)) do
                self._interfaces[#self._interfaces+1] = system.network.iface(ifn, net, self)
        end

        -- find wifi networks
        for _, ifn in ipairs(system.find_wifi_networks(brn)) do
                self._interfaces[#self._interfaces+1] = system.network.iface(ifn, net, self)
        end
end

function system.network.bridge:interfaces()
        local index = 0
        return function()
                if index <= #self._interfaces then
                        index = index + 1
                        return self._interfaces[index]
                else
                        return nil
                end
        end
end

function system.network.bridge:print()
        local v
        for v in self:interfaces() do
                io.write("  port: ")
                v:print()
        end
        print("  rx: ", self:rx_bytes(), self:rx_packets())
        print("  tx: ", self:tx_bytes(), self:tx_packets())
        print("  mtu: ", self:mtu())
        print("  mac: ", self:macaddr())
        print("  bridge? ", self:is_bridge())
        print("  port? ", self:is_bridge_port())
end


system.network.route = utl.class()

function system.network.route:__init__(rt, net)
        self._net    = net
        self._name   = rt['.name']
        self._ipv6   = (rt['.type'] == "route6")
        self._mtu    = tonumber(rt.mtu) or (net and net:interface():mtu() or 1500)
        self._metric = tonumber(rt.metric) or 0

        if self._ipv6 then
                self._gateway = lip.IPv6(rt.gateway or "::")
                self._target  = lip.IPv6(rt.target  or "::")
        else
                self._gateway = lip.IPv4(rt.gateway or "0.0.0.0")
                self._target  = lip.IPv4(rt.target  or "0.0.0.0", rt.netmask or "0.0.0.0")
        end
end

function system.network.route:name()
        return self._name
end

function system.network.route:network()
        return self._net
end

function system.network.route:mtu()
        return self._mtu
end

function system.network.route:metric()
        return self._metric
end

function system.network.route:is_ipv4()
        return not self._ipv6
end

function system.network.route:is_ipv6()
        return self._ipv6
end

function system.network.route:target()
        return self._target
end

function system.network.route:gateway()
        return self._gateway
end


system.network.alias = utl.class()

function system.network.alias:__init__(a, net)
        self._net  = net
        self._name = a['.name']
end


system.switch = utl.class()

function system.switch:__init__(switch, swdev, net)
        self._name   = switch
        self._ifname = swdev
        self._net    = net

        if not system._switches[switch] then
                local x = io.popen("swconfig dev %q help 2>/dev/null" % switch)
                if x then
                        local desc = x:read("*l")

                        if desc then
                                local name, num_ports, num_cpu, num_vlans =
                                        desc:match("Switch %d: %S+%((.-)%), ports: (%d+) %(cpu @ (%d+)%), vlans: (%d+)")

                                self._model   = name
                                self._ports   = tonumber(num_ports)
                                self._cpuport = tonumber(num_cpu)
                                self._vlans   = tonumber(num_vlans)
                        end

                        x:close()

                elseif nfs.access("/proc/switch/%s" % switch) then
                        self._model   = self:_proc("driver", switch)
                        self._ports   = self:_proc_count("port", 6)
                        self._vlans   = self:_proc_count("vlan", 16)
                end

                -- defaults
                self._model   = self._model   or switch
                self._ports   = self._ports   or 6
                self._vlans   = self._vlans   or 16
                self._cpuport = self._cpuport or 5

                system._switches[switch] = self
        else
                self._model   = system._switches[switch]._model
                self._ports   = system._switches[switch]._ports
                self._vlans   = system._switches[switch]._vlans
                self._cpuport = system._switches[switch]._cpuport
        end
end

function system.switch:_proc(path, default)
        local data = nfs.readfile("/proc/switch/%s/%s" %{ self._name, path })
        if data then
                return data:gsub("%s+$", "")
        end
        return default
end

function system.switch:_proc_count(path, default)
        local cnt = 0
        for _ in nfs.dir("/proc/switch/%s/%s" %{ self._name, path }) do
                cnt = cnt + 1
        end
        return cnt > 0 and cnt or default
end

function system.switch:name()
        return self._name
end

function system.switch:model()
        return self._model
end

function system.switch:num_possible_vlans()
        return self._vlans
end

function system.switch:num_active_vlans()
        local cnt = 0
        uci:foreach("network2", "switch_vlan",
                function(s)
                        if s.device == self._name then cnt = cnt + 1 end
                end)
        return cnt
end

function system.switch:vlans()
        local index = 0
        local vlans = { }

        uci:foreach("network2", "switch_vlan",
                function(s)
                        if s.device == self._name and tonumber(s.vlan) then
                                vlans[#vlans+1] = tonumber(s.vlan)
                        end
                end)

        return function()
                if index <= #vlans then
                        index = index + 1
                        return system.vlan(vlans[index], self)
                else
                        return nil
                end
        end
end

function system.switch:num_ports()
        return self._ports
end

function system.switch:delete_vlan(vlan)
        local rv = false

        uci:foreach("network2", "switch_vlan",
                function(s)
                        if s.device == self._name and tonumber(s.vlan) == vlan then
                                rv = true
                                uci:delete("network2", s['.name'])

                                if system._vlans[s.device] and system._vlans[s.device][vlan] then
                                        table.remove(system._vlans[s.device], vlan)
                                end

                                return false
                        end
                end)

        return rv
end

function system.switch:print()
        print("Switch:", self._model)
        print("  Ports:", self._ports, "Cpu:", self._cpuport)
        print("  Vlans:", self._vlans)
end


system.vlan = utl.class()

function system.vlan:__init__(vlan, switch, iface)
        self._vlan   = vlan
        self._switch = switch
        self._iface  = iface

        local swid = (switch and switch:name()) or (iface and iface:name()) or ""

        if not system._vlans[swid] or not system._vlans[swid][vlan] then
                self._ports  = { }

                if switch then
                        uci:foreach("network2", "switch_vlan",
                                function(s)
                                        if s.device == switch:name() and tonumber(s.vlan) == vlan then
                                                local p
                                                for _, p in ipairs(uci:list("network2", s['.name'], "ports")) do
                                                        self._ports[#self._ports+1] = system.vlan.port(p, self)
                                                end
                                                self._name = s['.name']
                                        end
                                end)
                else
                        self._ports[#self._ports+1] = system.vlan.port("0t", self)
                end

                system._vlans[swid] = system._vlans[swid] or { }
                system._vlans[swid][vlan] = self
        else
                self._ports = system._vlans[swid][vlan]._ports
        end
end

function system.vlan:name()
        return self._name
end

function system.vlan:number()
        return self._vlan
end

function system.vlan:switch()
        return self._switch
end

function system.vlan:interface()
        return self._iface
end

function system.vlan:is_software()
        return (self._switch == nil)
end

function system.vlan:is_hardware()
        return not self:is_software()
end

function system.vlan:num_ports()
        return #self._ports
end

function system.vlan:ports()
        local index = 0
        return function()
                if index <= #self._ports then
                        index = index + 1
                        return self._ports[index]
                else
                        return nil
                end
        end
end

function system.vlan:_update()
        local i
        local ports = { }

        for i = 1, #self._ports do
                ports[#ports+1] = self._ports[i]:string()
        end

        uci:set("network2", self._name, "ports", table.concat(ports, " "))
end

function system.vlan:delete_port(port)
        if self._switch then
                local i
                for i = 1, #self._ports do
                        if self._ports[i]:number() == port then
                                table.remove(self._ports, i)
                                self:_update()
                                return true
                        end
                end
        end
        return false
end

function system.vlan:print()
        print(" Vlan:", self._vlan, "Software?", self:is_software())
        local p
        for p in self:ports() do
                p:print()
        end
end


system.vlan.port = utl.class()

function system.vlan.port:__init__(port, vlan)
        local num, tag = port:match("^(%d+)([tu]?)")

        self._vlan   = vlan
        self._port   = tonumber(num)
        self._tagged = (tag == "t")
end

function system.vlan.port:number()
        return self._port
end

function system.vlan.port:vlan()
        return self._vlan
end

function system.vlan.port:string()
        return "%i%s" %{ self._port, self._tagged ? "t" : "" }
end

function system.vlan.port:is_tagged()
        return self._tagged
end

function system.vlan.port:print()
        print("  Port:", self._port, "Tagged:", self._tagged)
end


-- ------------------------------

local s = system()

s:print()

s:find_network("wan"):print()
s:find_interface("eth0"):parent():print()

]==]