755 lines
16 KiB
Lua
755 lines
16 KiB
Lua
--[[
|
|
LuCI - Network model
|
|
|
|
Copyright 2009-2010 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, tonumber, i18n
|
|
= type, pairs, ipairs, loadfile, table, tonumber, luci.i18n
|
|
|
|
local nxo = require "nixio"
|
|
local ipc = require "luci.ip"
|
|
local sys = require "luci.sys"
|
|
local utl = require "luci.util"
|
|
local dsp = require "luci.dispatcher"
|
|
local uci = require "luci.model.uci"
|
|
|
|
module "luci.model.network"
|
|
|
|
|
|
local ifs, brs, sws, uci_r, uci_s
|
|
|
|
function list_remove(c, s, o, r)
|
|
local val = uci_r:get(c, s, o)
|
|
if val then
|
|
local l = { }
|
|
if type(val) == "string" then
|
|
for val in val:gmatch("%S+") do
|
|
if val ~= r then
|
|
l[#l+1] = val
|
|
end
|
|
end
|
|
if #l > 0 then
|
|
uci_r:set(c, s, o, table.concat(l, " "))
|
|
else
|
|
uci_r:delete(c, s, o)
|
|
end
|
|
elseif type(val) == "table" then
|
|
for _, val in ipairs(val) do
|
|
if val ~= r then
|
|
l[#l+1] = val
|
|
end
|
|
end
|
|
if #l > 0 then
|
|
uci_r:set(c, s, o, l)
|
|
else
|
|
uci_r:delete(c, s, o)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function list_add(c, s, o, a)
|
|
local val = uci_r:get(c, s, o) or ""
|
|
if type(val) == "string" then
|
|
local l = { }
|
|
for val in val:gmatch("%S+") do
|
|
if val ~= a then
|
|
l[#l+1] = val
|
|
end
|
|
end
|
|
l[#l+1] = a
|
|
uci_r:set(c, s, o, table.concat(l, " "))
|
|
elseif type(val) == "table" then
|
|
local l = { }
|
|
for _, val in ipairs(val) do
|
|
if val ~= a then
|
|
l[#l+1] = val
|
|
end
|
|
end
|
|
l[#l+1] = a
|
|
uci_r:set(c, s, o, l)
|
|
end
|
|
end
|
|
|
|
function wifi_iface(x)
|
|
return (
|
|
x:match("^wlan%d") or x:match("^wl%d") or x:match("^ath%d") or
|
|
x:match("^%w+%.network%d")
|
|
)
|
|
end
|
|
|
|
function wifi_lookup(ifn)
|
|
-- got a radio#.network# pseudo iface, locate the corresponding section
|
|
local radio, ifnidx = ifn:match("^(%w+)%.network(%d+)$")
|
|
if radio and ifnidx then
|
|
local sid = nil
|
|
local num = 0
|
|
|
|
ifnidx = tonumber(ifnidx)
|
|
uci_r:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.device == radio then
|
|
num = num + 1
|
|
if num == ifnidx then
|
|
sid = s['.name']
|
|
return false
|
|
end
|
|
end
|
|
end)
|
|
|
|
return sid
|
|
|
|
-- looks like wifi, try to locate the section via state vars
|
|
elseif wifi_iface(ifn) then
|
|
local sid = nil
|
|
|
|
uci_s:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.ifname == ifn then
|
|
sid = s['.name']
|
|
return false
|
|
end
|
|
end)
|
|
|
|
return sid
|
|
end
|
|
end
|
|
|
|
function iface_ignore(x)
|
|
return (
|
|
x:match("^wmaster%d") or x:match("^wifi%d") or x:match("^hwsim%d") or
|
|
x:match("^imq%d") or x:match("^mon.wlan%d") or x:match("^6in4-%w") or
|
|
x:match("^3g-%w") or x:match("^ppp-%w") or x:match("^pppoe-%w") or
|
|
x:match("^pppoa-%w") or x == "lo"
|
|
)
|
|
end
|
|
|
|
|
|
function init(cursor)
|
|
if cursor then
|
|
uci_r = cursor
|
|
uci_s = cursor:substate()
|
|
|
|
ifs = { }
|
|
brs = { }
|
|
sws = { }
|
|
|
|
-- 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 iface_ignore(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 uci_r:section("network", "interface", n, options) then
|
|
return network(n)
|
|
end
|
|
end
|
|
end
|
|
|
|
function get_network(self, n)
|
|
if n and uci_r:get("network", n) == "interface" then
|
|
return network(n)
|
|
end
|
|
end
|
|
|
|
function get_networks(self)
|
|
local nets = { }
|
|
uci_r:foreach("network", "interface",
|
|
function(s)
|
|
nets[#nets+1] = network(s['.name'])
|
|
end)
|
|
return nets
|
|
end
|
|
|
|
function del_network(self, n)
|
|
local r = uci_r:delete("network", n)
|
|
if r then
|
|
uci_r:foreach("network", "alias",
|
|
function(s)
|
|
if s.interface == n then
|
|
uci_r:delete("network", s['.name'])
|
|
end
|
|
end)
|
|
|
|
uci_r:foreach("network", "route",
|
|
function(s)
|
|
if s.interface == n then
|
|
uci_r:delete("network", s['.name'])
|
|
end
|
|
end)
|
|
|
|
uci_r:foreach("network", "route6",
|
|
function(s)
|
|
if s.interface == n then
|
|
uci_r:delete("network", s['.name'])
|
|
end
|
|
end)
|
|
|
|
uci_r:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.network == n then
|
|
uci_r:delete("wireless", s['.name'], "network")
|
|
end
|
|
end)
|
|
|
|
uci_r:delete("network", n)
|
|
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 = uci_r:section("network", "interface", new, uci_r:get_all("network", old))
|
|
|
|
if r then
|
|
uci_r:foreach("network", "alias",
|
|
function(s)
|
|
if s.interface == old then
|
|
uci_r:set("network", s['.name'], "interface", new)
|
|
end
|
|
end)
|
|
|
|
uci_r:foreach("network", "route",
|
|
function(s)
|
|
if s.interface == old then
|
|
uci_r:set("network", s['.name'], "interface", new)
|
|
end
|
|
end)
|
|
|
|
uci_r:foreach("network", "route6",
|
|
function(s)
|
|
if s.interface == old then
|
|
uci_r:set("network", s['.name'], "interface", new)
|
|
end
|
|
end)
|
|
|
|
uci_r:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.network == old then
|
|
uci_r:set("wireless", s['.name'], "network", new)
|
|
end
|
|
end)
|
|
|
|
uci_r:delete("network", old)
|
|
end
|
|
end
|
|
return r or false
|
|
end
|
|
|
|
function get_interface(self, i)
|
|
if ifs[i] or wifi_iface(i) then
|
|
return interface(i)
|
|
else
|
|
local ifc
|
|
local num = { }
|
|
uci_r:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.device then
|
|
num[s.device] = num[s.device] and num[s.device] + 1 or 1
|
|
if s['.name'] == i then
|
|
ifc = interface(
|
|
"%s.network%d" %{s.device, num[s.device] })
|
|
return false
|
|
end
|
|
end
|
|
end)
|
|
return ifc
|
|
end
|
|
end
|
|
|
|
function get_interfaces(self)
|
|
local iface
|
|
local ifaces = { }
|
|
|
|
-- find normal interfaces
|
|
for iface in utl.kspairs(ifs) do
|
|
if not iface_ignore(iface) and not wifi_iface(iface) then
|
|
ifaces[#ifaces+1] = interface(iface)
|
|
end
|
|
end
|
|
|
|
-- find wifi interfaces
|
|
local num = { }
|
|
local wfs = { }
|
|
uci_r:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.device then
|
|
num[s.device] = num[s.device] and num[s.device] + 1 or 1
|
|
local i = "%s.network%d" %{ s.device, num[s.device] }
|
|
wfs[i] = interface(i)
|
|
end
|
|
end)
|
|
|
|
for iface in utl.kspairs(wfs) do
|
|
ifaces[#ifaces+1] = wfs[iface]
|
|
end
|
|
|
|
return ifaces
|
|
end
|
|
|
|
function ignore_interface(self, x)
|
|
return iface_ignore(x)
|
|
end
|
|
|
|
|
|
network = utl.class()
|
|
|
|
function network.__init__(self, name)
|
|
self.sid = name
|
|
end
|
|
|
|
function network._get(self, opt)
|
|
local v = uci_r:get("network", self.sid, opt)
|
|
if type(v) == "table" then
|
|
return table.concat(v, " ")
|
|
end
|
|
return v or ""
|
|
end
|
|
|
|
function network.ifname(self)
|
|
local p = self:proto()
|
|
if self:is_bridge() then
|
|
return "br-" .. self.sid
|
|
elseif self:is_virtual() then
|
|
return p .. "-" .. self.sid
|
|
else
|
|
local dev = self:_get("ifname") or
|
|
uci_r:get("network", self.sid, "ifname")
|
|
|
|
dev = dev and dev:match("%S+")
|
|
|
|
if not dev then
|
|
uci_r:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.device then
|
|
num[s.device] = num[s.device]
|
|
and num[s.device] + 1 or 1
|
|
|
|
if s.network == self.sid then
|
|
dev = "%s.network%d" %{ s.device, num[s.device] }
|
|
return false
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
|
|
return dev
|
|
end
|
|
end
|
|
|
|
function network.device(self)
|
|
local dev = self:_get("device")
|
|
if not dev or dev:match("[^%w%-%.%s]") then
|
|
dev = uci_r:get("network", self.sid, "ifname")
|
|
end
|
|
return dev
|
|
end
|
|
|
|
function network.proto(self)
|
|
return self:_get("proto") or "none"
|
|
end
|
|
|
|
function network.type(self)
|
|
return self:_get("type")
|
|
end
|
|
|
|
function network.name(self)
|
|
return self.sid
|
|
end
|
|
|
|
function network.is_bridge(self)
|
|
return (self:type() == "bridge")
|
|
end
|
|
|
|
function network.is_virtual(self)
|
|
local p = self:proto()
|
|
return (
|
|
p == "3g" or p == "6in4" or p == "ppp" or
|
|
p == "pppoe" or p == "pppoa"
|
|
)
|
|
end
|
|
|
|
function network.is_empty(self)
|
|
if self:is_virtual() then
|
|
return false
|
|
else
|
|
local rv = true
|
|
|
|
if (self:_get("ifname") or ""):match("%S+") then
|
|
rv = false
|
|
end
|
|
|
|
uci_r:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.network == self.sid then
|
|
rv = false
|
|
return false
|
|
end
|
|
end)
|
|
|
|
return rv
|
|
end
|
|
end
|
|
|
|
function network.add_interface(self, ifname)
|
|
if not self:is_virtual() then
|
|
if type(ifname) ~= "string" then
|
|
ifname = ifname:name()
|
|
else
|
|
ifname = ifname:match("[^%s:]+")
|
|
end
|
|
|
|
-- remove the interface from all ifaces
|
|
uci_r:foreach("network", "interface",
|
|
function(s)
|
|
list_remove("network", s['.name'], "ifname", ifname)
|
|
end)
|
|
|
|
-- if its a wifi interface, change its network option
|
|
local wif = wifi_lookup(ifname)
|
|
if wif then
|
|
uci_r:set("wireless", wif, "network", self.sid)
|
|
|
|
-- add iface to our iface list
|
|
else
|
|
list_add("network", self.sid, "ifname", ifname)
|
|
end
|
|
end
|
|
end
|
|
|
|
function network.del_interface(self, ifname)
|
|
if not self:is_virtual() then
|
|
if type(ifname) ~= "string" then
|
|
ifname = ifname:name()
|
|
else
|
|
ifname = ifname:match("[^%s:]+")
|
|
end
|
|
|
|
-- if its a wireless interface, clear its network option
|
|
local wif = wifi_lookup(ifname)
|
|
if wif then uci_r:delete("wireless", wif, "network") end
|
|
|
|
-- remove the interface
|
|
list_remove("network", self.sid, "ifname", ifname)
|
|
end
|
|
end
|
|
|
|
function network.get_interfaces(self)
|
|
local ifaces = { }
|
|
|
|
local ifn
|
|
if self:is_virtual() then
|
|
ifn = self:proto() .. "-" .. self.sid
|
|
ifaces = { interface(ifn) }
|
|
else
|
|
local nfs = { }
|
|
for ifn in self:_get("ifname"):gmatch("%S+") do
|
|
ifn = ifn:match("[^:]+")
|
|
nfs[ifn] = interface(ifn)
|
|
end
|
|
|
|
for ifn in utl.kspairs(nfs) do
|
|
ifaces[#ifaces+1] = nfs[ifn]
|
|
end
|
|
|
|
local num = { }
|
|
local wfs = { }
|
|
uci_r:foreach("wireless", "wifi-iface",
|
|
function(s)
|
|
if s.device then
|
|
num[s.device] = num[s.device] and num[s.device] + 1 or 1
|
|
if s.network == self.sid then
|
|
ifn = "%s.network%d" %{ s.device, num[s.device] }
|
|
wfs[ifn] = interface(ifn)
|
|
end
|
|
end
|
|
end)
|
|
|
|
for ifn in utl.kspairs(wfs) do
|
|
ifaces[#ifaces+1] = wfs[ifn]
|
|
end
|
|
end
|
|
|
|
return ifaces
|
|
end
|
|
|
|
function network.contains_interface(self, ifname)
|
|
if type(ifname) ~= "string" then
|
|
ifname = ifname:name()
|
|
else
|
|
ifname = ifname:match("[^%s:]+")
|
|
end
|
|
|
|
local ifn
|
|
if self:is_virtual() then
|
|
ifn = self:proto() .. "-" .. self.sid
|
|
return ifname == ifn
|
|
else
|
|
for ifn in self:_get("ifname"):gmatch("%S+") do
|
|
ifn = ifn:match("[^:]+")
|
|
if ifn == ifname then
|
|
return true
|
|
end
|
|
end
|
|
|
|
local wif = wifi_lookup(ifname)
|
|
if wif then
|
|
return (uci_r:get("wireless", wif, "network") == self.sid)
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function network.adminlink(self)
|
|
return dsp.build_url("admin", "network", "network", self.sid)
|
|
end
|
|
|
|
|
|
interface = utl.class()
|
|
function interface.__init__(self, ifname)
|
|
self.wif = wifi_lookup(ifname)
|
|
|
|
if self.wif then
|
|
self.ifname = uci_s:get("wireless", self.wif, "ifname")
|
|
self.iwinfo = self.ifname and sys.wifi.getiwinfo(self.ifname) or { }
|
|
self.iwdata = uci_s:get_all("wireless", self.wif) or { }
|
|
self.iwname = ifname
|
|
end
|
|
|
|
self.ifname = self.ifname or ifname
|
|
self.dev = ifs[self.ifname]
|
|
end
|
|
|
|
function interface.name(self)
|
|
return self.wif and uci_s:get("wireless", self.wif, "ifname") or self.ifname
|
|
end
|
|
|
|
function interface.mac(self)
|
|
return self.dev and self.dev or "00:00:00:00:00:00"
|
|
end
|
|
|
|
function interface.ipaddrs(self)
|
|
return self.dev and self.dev.ipaddrs or { }
|
|
end
|
|
|
|
function interface.ip6addrs(self)
|
|
return self.dev and self.dev.ip6addrs or { }
|
|
end
|
|
|
|
function interface.type(self)
|
|
if wifi_iface(self.ifname) then
|
|
return "wifi"
|
|
elseif brs[self.ifname] then
|
|
return "bridge"
|
|
elseif sws[self.ifname] or self.ifname:match("%.") then
|
|
return "switch"
|
|
else
|
|
return "ethernet"
|
|
end
|
|
end
|
|
|
|
function _choose(s1, s2)
|
|
if not s1 or #s1 == 0 then
|
|
return s2 and #s2 > 0 and s2
|
|
else
|
|
return s1
|
|
end
|
|
end
|
|
|
|
function interface.shortname(self)
|
|
if self.iwinfo or self.iwdata then
|
|
return "%s %q" %{
|
|
i18n.translate(self.iwinfo.mode),
|
|
_choose(self.iwinfo.ssid, self.iwdata.ssid ) or
|
|
_choose(self.iwinfo.bssid, self.iwdata.bssid) or
|
|
"%s (%s)" %{ i18n.translate("unknown"), self.ifname }
|
|
}
|
|
else
|
|
return self.ifname
|
|
end
|
|
end
|
|
|
|
function interface.get_i18n(self)
|
|
if self.iwinfo or self.iwdata then
|
|
return "%s: %s %q" %{
|
|
i18n.translate("Wireless Network"),
|
|
_choose(self.iwinfo.mode, self.iwdata.mode ),
|
|
_choose(self.iwinfo.ssid, self.iwdata.ssid ) or
|
|
_choose(self.iwinfo.bssid, self.iwdata.bssid) or
|
|
"%s (%s)" %{ i18n.translate("unknown"), self.ifname }
|
|
}
|
|
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.adminlink(self)
|
|
if self:type() == "wifi" then
|
|
return dsp.build_url("admin", "network", "wireless",
|
|
self.iwdata.device, self.iwname)
|
|
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 and self.dev.flags and self.dev.flags.up or false
|
|
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
|