--[[
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