Rework LuCI build system

 * Rename subdirectories to their repective OpenWrt package names
 * Make each LuCI module its own standalone package
 * Deploy a shared luci.mk which is used by each module Makefile

Signed-off-by: Jo-Philipp Wich <jow@openwrt.org>

7 files changed, 3001 insertions, 0 deletions

diff --git a/modules/luci-base/luasrc/model/cbi/admin_network/proto_dhcp.lua b/modules/luci-base/luasrc/model/cbi/admin_network/proto_dhcp.lua
new file mode 100644
index 0000000000..fe3fec6fa1
--- /dev/null
+++ b/modules/luci-base/luasrc/model/cbi/admin_network/proto_dhcp.lua
@@ -0,0 +1,76 @@
+--[[
+LuCI - Lua Configuration Interface
+
+Copyright 2011-2012 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
+]]--
+
+local map, section, net = ...
+local ifc = net:get_interface()
+
+local hostname, accept_ra, send_rs
+local bcast, defaultroute, peerdns, dns, metric, clientid, vendorclass
+
+
+hostname = section:taboption("general", Value, "hostname",
+	translate("Hostname to send when requesting DHCP"))
+
+hostname.placeholder = luci.sys.hostname()
+hostname.datatype    = "hostname"
+
+
+bcast = section:taboption("advanced", Flag, "broadcast",
+	translate("Use broadcast flag"),
+	translate("Required for certain ISPs, e.g. Charter with DOCSIS 3"))
+
+bcast.default = bcast.disabled
+
+
+defaultroute = section:taboption("advanced", Flag, "defaultroute",
+	translate("Use default gateway"),
+	translate("If unchecked, no default route is configured"))
+
+defaultroute.default = defaultroute.enabled
+
+
+peerdns = section:taboption("advanced", Flag, "peerdns",
+	translate("Use DNS servers advertised by peer"),
+	translate("If unchecked, the advertised DNS server addresses are ignored"))
+
+peerdns.default = peerdns.enabled
+
+
+dns = section:taboption("advanced", DynamicList, "dns",
+	translate("Use custom DNS servers"))
+
+dns:depends("peerdns", "")
+dns.datatype = "ipaddr"
+dns.cast     = "string"
+
+
+metric = section:taboption("advanced", Value, "metric",
+	translate("Use gateway metric"))
+
+metric.placeholder = "0"
+metric.datatype    = "uinteger"
+
+
+clientid = section:taboption("advanced", Value, "clientid",
+	translate("Client ID to send when requesting DHCP"))
+
+
+vendorclass = section:taboption("advanced", Value, "vendorid",
+	translate("Vendor Class to send when requesting DHCP"))
+
+
+luci.tools.proto.opt_macaddr(section, ifc, translate("Override MAC address"))
+
+
+mtu = section:taboption("advanced", Value, "mtu", translate("Override MTU"))
+mtu.placeholder = "1500"
+mtu.datatype    = "max(9200)"
diff --git a/modules/luci-base/luasrc/model/cbi/admin_network/proto_none.lua b/modules/luci-base/luasrc/model/cbi/admin_network/proto_none.lua
new file mode 100644
index 0000000000..0e34b67de6
--- /dev/null
+++ b/modules/luci-base/luasrc/model/cbi/admin_network/proto_none.lua
@@ -0,0 +1,13 @@
+--[[
+LuCI - Lua Configuration Interface
+
+Copyright 2011 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
+]]--
+
+local map, section, net = ...
diff --git a/modules/luci-base/luasrc/model/cbi/admin_network/proto_static.lua b/modules/luci-base/luasrc/model/cbi/admin_network/proto_static.lua
new file mode 100644
index 0000000000..338c0b7d83
--- /dev/null
+++ b/modules/luci-base/luasrc/model/cbi/admin_network/proto_static.lua
@@ -0,0 +1,90 @@
+--[[
+LuCI - Lua Configuration Interface
+
+Copyright 2011 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
+]]--
+
+local map, section, net = ...
+local ifc = net:get_interface()
+
+local ipaddr, netmask, gateway, broadcast, dns, accept_ra, send_rs, ip6addr, ip6gw
+local mtu, metric
+
+
+ipaddr = section:taboption("general", Value, "ipaddr", translate("IPv4 address"))
+ipaddr.datatype = "ip4addr"
+
+
+netmask = section:taboption("general", Value, "netmask",
+	translate("IPv4 netmask"))
+
+netmask.datatype = "ip4addr"
+netmask:value("255.255.255.0")
+netmask:value("255.255.0.0")
+netmask:value("255.0.0.0")
+
+
+gateway = section:taboption("general", Value, "gateway", translate("IPv4 gateway"))
+gateway.datatype = "ip4addr"
+
+
+broadcast = section:taboption("general", Value, "broadcast", translate("IPv4 broadcast"))
+broadcast.datatype = "ip4addr"
+
+
+dns = section:taboption("general", DynamicList, "dns",
+	translate("Use custom DNS servers"))
+
+dns.datatype = "ipaddr"
+dns.cast     = "string"
+
+
+if luci.model.network:has_ipv6() then
+
+	local ip6assign = section:taboption("general", Value, "ip6assign", translate("IPv6 assignment length"),
+		translate("Assign a part of given length of every public IPv6-prefix to this interface"))
+	ip6assign:value("", translate("disabled"))
+	ip6assign:value("64")
+	ip6assign.datatype = "max(64)"
+
+	local ip6hint = section:taboption("general", Value, "ip6hint", translate("IPv6 assignment hint"),
+		translate("Assign prefix parts using this hexadecimal subprefix ID for this interface."))
+	for i=33,64 do ip6hint:depends("ip6assign", i) end
+
+	ip6addr = section:taboption("general", Value, "ip6addr", translate("IPv6 address"))
+	ip6addr.datatype = "ip6addr"
+	ip6addr:depends("ip6assign", "")
+
+
+	ip6gw = section:taboption("general", Value, "ip6gw", translate("IPv6 gateway"))
+	ip6gw.datatype = "ip6addr"
+	ip6gw:depends("ip6assign", "")
+
+
+	local ip6prefix = s:taboption("general", Value, "ip6prefix", translate("IPv6 routed prefix"),
+		translate("Public prefix routed to this device for distribution to clients."))
+	ip6prefix.datatype = "ip6addr"
+	ip6prefix:depends("ip6assign", "")
+
+end
+
+
+luci.tools.proto.opt_macaddr(section, ifc, translate("Override MAC address"))
+
+
+mtu = section:taboption("advanced", Value, "mtu", translate("Override MTU"))
+mtu.placeholder = "1500"
+mtu.datatype    = "max(9200)"
+
+
+metric = section:taboption("advanced", Value, "metric",
+	translate("Use gateway metric"))
+
+metric.placeholder = "0"
+metric.datatype    = "uinteger"
diff --git a/modules/luci-base/luasrc/model/firewall.lua b/modules/luci-base/luasrc/model/firewall.lua
new file mode 100644
index 0000000000..a9f6fdb7fc
--- /dev/null
+++ b/modules/luci-base/luasrc/model/firewall.lua
@@ -0,0 +1,582 @@
+--[[
+LuCI - Firewall 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, table, luci, math
+	= type, pairs, ipairs, table, luci, math
+
+local tpl = require "luci.template.parser"
+local utl = require "luci.util"
+local uci = require "luci.model.uci"
+
+module "luci.model.firewall"
+
+
+local uci_r, uci_s
+
+function _valid_id(x)
+	return (x and #x > 0 and x:match("^[a-zA-Z0-9_]+$"))
+end
+
+function _get(c, s, o)
+	return uci_r:get(c, s, o)
+end
+
+function _set(c, s, o, v)
+	if v ~= nil then
+		if type(v) == "boolean" then v = v and "1" or "0" end
+		return uci_r:set(c, s, o, v)
+	else
+		return uci_r:delete(c, s, o)
+	end
+end
+
+
+function init(cursor)
+	uci_r = cursor or uci_r or uci.cursor()
+	uci_s = uci_r:substate()
+
+	return _M
+end
+
+function save(self, ...)
+	uci_r:save(...)
+	uci_r:load(...)
+end
+
+function commit(self, ...)
+	uci_r:commit(...)
+	uci_r:load(...)
+end
+
+function get_defaults()
+	return defaults()
+end
+
+function new_zone(self)
+	local name = "newzone"
+	local count = 1
+
+	while self:get_zone(name) do
+		count = count + 1
+		name = "newzone%d" % count
+	end
+
+	return self:add_zone(name)
+end
+
+function add_zone(self, n)
+	if _valid_id(n) and not self:get_zone(n) then
+		local d = defaults()
+		local z = uci_r:section("firewall", "zone", nil, {
+			name    = n,
+			network = " ",
+			input   = d:input()   or "DROP",
+			forward = d:forward() or "DROP",
+			output  = d:output()  or "DROP"
+		})
+
+		return z and zone(z)
+	end
+end
+
+function get_zone(self, n)
+	if uci_r:get("firewall", n) == "zone" then
+		return zone(n)
+	else
+		local z
+		uci_r:foreach("firewall", "zone",
+			function(s)
+				if n and s.name == n then
+					z = s['.name']
+					return false
+				end
+			end)
+		return z and zone(z)
+	end
+end
+
+function get_zones(self)
+	local zones = { }
+	local znl = { }
+
+	uci_r:foreach("firewall", "zone",
+		function(s)
+			if s.name then
+				znl[s.name] = zone(s['.name'])
+			end
+		end)
+
+	local z
+	for z in utl.kspairs(znl) do
+		zones[#zones+1] = znl[z]
+	end
+
+	return zones
+end
+
+function get_zone_by_network(self, net)
+	local z
+
+	uci_r:foreach("firewall", "zone",
+		function(s)
+			if s.name and net then
+				local n
+				for n in utl.imatch(s.network or s.name) do
+					if n == net then
+						z = s['.name']
+						return false
+					end
+				end
+			end
+		end)
+
+	return z and zone(z)
+end
+
+function del_zone(self, n)
+	local r = false
+
+	if uci_r:get("firewall", n) == "zone" then
+		local z = uci_r:get("firewall", n, "name")
+		r = uci_r:delete("firewall", n)
+		n = z
+	else
+		uci_r:foreach("firewall", "zone",
+			function(s)
+				if n and s.name == n then
+					r = uci_r:delete("firewall", s['.name'])
+					return false
+				end
+			end)
+	end
+
+	if r then
+		uci_r:foreach("firewall", "rule",
+			function(s)
+				if s.src == n or s.dest == n then
+					uci_r:delete("firewall", s['.name'])
+				end
+			end)
+
+		uci_r:foreach("firewall", "redirect",
+			function(s)
+				if s.src == n or s.dest == n then
+					uci_r:delete("firewall", s['.name'])
+				end
+			end)
+
+		uci_r:foreach("firewall", "forwarding",
+			function(s)
+				if s.src == n or s.dest == n then
+					uci_r:delete("firewall", s['.name'])
+				end
+			end)
+	end
+
+	return r
+end
+
+function rename_zone(self, old, new)
+	local r = false
+
+	if _valid_id(new) and not self:get_zone(new) then
+		uci_r:foreach("firewall", "zone",
+			function(s)
+				if old and s.name == old then
+					if not s.network then
+						uci_r:set("firewall", s['.name'], "network", old)
+					end
+					uci_r:set("firewall", s['.name'], "name", new)
+					r = true
+					return false
+				end
+			end)
+
+		if r then
+			uci_r:foreach("firewall", "rule",
+				function(s)
+					if s.src == old then
+						uci_r:set("firewall", s['.name'], "src", new)
+					end
+					if s.dest == old then
+						uci_r:set("firewall", s['.name'], "dest", new)
+					end
+				end)
+
+			uci_r:foreach("firewall", "redirect",
+				function(s)
+					if s.src == old then
+						uci_r:set("firewall", s['.name'], "src", new)
+					end
+					if s.dest == old then
+						uci_r:set("firewall", s['.name'], "dest", new)
+					end
+				end)
+
+			uci_r:foreach("firewall", "forwarding",
+				function(s)
+					if s.src == old then
+						uci_r:set("firewall", s['.name'], "src", new)
+					end
+					if s.dest == old then
+						uci_r:set("firewall", s['.name'], "dest", new)
+					end
+				end)
+		end
+	end
+
+	return r
+end
+
+function del_network(self, net)
+	local z
+	if net then
+		for _, z in ipairs(self:get_zones()) do
+			z:del_network(net)
+		end
+	end
+end
+
+
+defaults = utl.class()
+function defaults.__init__(self)
+	uci_r:foreach("firewall", "defaults",
+		function(s)
+			self.sid  = s['.name']
+			return false
+		end)
+
+	self.sid = self.sid or uci_r:section("firewall", "defaults", nil, { })
+end
+
+function defaults.get(self, opt)
+	return _get("firewall", self.sid, opt)
+end
+
+function defaults.set(self, opt, val)
+	return _set("firewall", self.sid, opt, val)
+end
+
+function defaults.syn_flood(self)
+	return (self:get("syn_flood") == "1")
+end
+
+function defaults.drop_invalid(self)
+	return (self:get("drop_invalid") == "1")
+end
+
+function defaults.input(self)
+	return self:get("input") or "DROP"
+end
+
+function defaults.forward(self)
+	return self:get("forward") or "DROP"
+end
+
+function defaults.output(self)
+	return self:get("output") or "DROP"
+end
+
+
+zone = utl.class()
+function zone.__init__(self, z)
+	if uci_r:get("firewall", z) == "zone" then
+		self.sid  = z
+		self.data = uci_r:get_all("firewall", z)
+	else
+		uci_r:foreach("firewall", "zone",
+			function(s)
+				if s.name == z then
+					self.sid  = s['.name']
+					self.data = s
+					return false
+				end
+			end)
+	end
+end
+
+function zone.get(self, opt)
+	return _get("firewall", self.sid, opt)
+end
+
+function zone.set(self, opt, val)
+	return _set("firewall", self.sid, opt, val)
+end
+
+function zone.masq(self)
+	return (self:get("masq") == "1")
+end
+
+function zone.name(self)
+	return self:get("name")
+end
+
+function zone.network(self)
+	return self:get("network")
+end
+
+function zone.input(self)
+	return self:get("input") or defaults():input() or "DROP"
+end
+
+function zone.forward(self)
+	return self:get("forward") or defaults():forward() or "DROP"
+end
+
+function zone.output(self)
+	return self:get("output") or defaults():output() or "DROP"
+end
+
+function zone.add_network(self, net)
+	if uci_r:get("network", net) == "interface" then
+		local nets = { }
+
+		local n
+		for n in utl.imatch(self:get("network") or self:get("name")) do
+			if n ~= net then
+				nets[#nets+1] = n
+			end
+		end
+
+		nets[#nets+1] = net
+
+		_M:del_network(net)
+		self:set("network", table.concat(nets, " "))
+	end
+end
+
+function zone.del_network(self, net)
+	local nets = { }
+
+	local n
+	for n in utl.imatch(self:get("network") or self:get("name")) do
+		if n ~= net then
+			nets[#nets+1] = n
+		end
+	end
+
+	if #nets > 0 then
+		self:set("network", table.concat(nets, " "))
+	else
+		self:set("network", " ")
+	end
+end
+
+function zone.get_networks(self)
+	local nets = { }
+
+	local n
+	for n in utl.imatch(self:get("network") or self:get("name")) do
+		nets[#nets+1] = n
+	end
+
+	return nets
+end
+
+function zone.clear_networks(self)
+	self:set("network", " ")
+end
+
+function zone.get_forwardings_by(self, what)
+	local name = self:name()
+	local forwards = { }
+
+	uci_r:foreach("firewall", "forwarding",
+		function(s)
+			if s.src and s.dest and s[what] == name then
+				forwards[#forwards+1] = forwarding(s['.name'])
+			end
+		end)
+
+	return forwards
+end
+
+function zone.add_forwarding_to(self, dest)
+	local exist, forward
+
+	for _, forward in ipairs(self:get_forwardings_by('src')) do
+		if forward:dest() == dest then
+			exist = true
+			break
+		end
+	end
+
+	if not exist and dest ~= self:name() and _valid_id(dest) then
+		local s = uci_r:section("firewall", "forwarding", nil, {
+			src     = self:name(),
+			dest    = dest
+		})
+
+		return s and forwarding(s)
+	end
+end
+
+function zone.add_forwarding_from(self, src)
+	local exist, forward
+
+	for _, forward in ipairs(self:get_forwardings_by('dest')) do
+		if forward:src() == src then
+			exist = true
+			break
+		end
+	end
+
+	if not exist and src ~= self:name() and _valid_id(src) then
+		local s = uci_r:section("firewall", "forwarding", nil, {
+			src     = src,
+			dest    = self:name()
+		})
+
+		return s and forwarding(s)
+	end
+end
+
+function zone.del_forwardings_by(self, what)
+	local name = self:name()
+
+	uci_r:delete_all("firewall", "forwarding",
+		function(s)
+			return (s.src and s.dest and s[what] == name)
+		end)
+end
+
+function zone.add_redirect(self, options)
+	options = options or { }
+	options.src = self:name()
+
+	local s = uci_r:section("firewall", "redirect", nil, options)
+	return s and redirect(s)
+end
+
+function zone.add_rule(self, options)
+	options = options or { }
+	options.src = self:name()
+
+	local s = uci_r:section("firewall", "rule", nil, options)
+	return s and rule(s)
+end
+
+function zone.get_color(self)
+	if self and self:name() == "lan" then
+		return "#90f090"
+	elseif self and self:name() == "wan" then
+		return "#f09090"
+	elseif self then
+		math.randomseed(tpl.hash(self:name()))
+
+		local r   = math.random(128)
+		local g   = math.random(128)
+		local min = 0
+		local max = 128
+
+		if ( r + g ) < 128 then
+			min = 128 - r - g
+		else
+			max = 255 - r - g
+		end
+
+		local b = min + math.floor( math.random() * ( max - min ) )
+
+		return "#%02x%02x%02x" % { 0xFF - r, 0xFF - g, 0xFF - b }
+	else
+		return "#eeeeee"
+	end
+end
+
+
+forwarding = utl.class()
+function forwarding.__init__(self, f)
+	self.sid = f
+end
+
+function forwarding.src(self)
+	return uci_r:get("firewall", self.sid, "src")
+end
+
+function forwarding.dest(self)
+	return uci_r:get("firewall", self.sid, "dest")
+end
+
+function forwarding.src_zone(self)
+	return zone(self:src())
+end
+
+function forwarding.dest_zone(self)
+	return zone(self:dest())
+end
+
+
+rule = utl.class()
+function rule.__init__(self, f)
+	self.sid = f
+end
+
+function rule.get(self, opt)
+	return _get("firewall", self.sid, opt)
+end
+
+function rule.set(self, opt, val)
+	return _set("firewall", self.sid, opt, val)
+end
+
+function rule.src(self)
+	return uci_r:get("firewall", self.sid, "src")
+end
+
+function rule.dest(self)
+	return uci_r:get("firewall", self.sid, "dest")
+end
+
+function rule.src_zone(self)
+	return zone(self:src())
+end
+
+function rule.dest_zone(self)
+	return zone(self:dest())
+end
+
+
+redirect = utl.class()
+function redirect.__init__(self, f)
+	self.sid = f
+end
+
+function redirect.get(self, opt)
+	return _get("firewall", self.sid, opt)
+end
+
+function redirect.set(self, opt, val)
+	return _set("firewall", self.sid, opt, val)
+end
+
+function redirect.src(self)
+	return uci_r:get("firewall", self.sid, "src")
+end
+
+function redirect.dest(self)
+	return uci_r:get("firewall", self.sid, "dest")
+end
+
+function redirect.src_zone(self)
+	return zone(self:src())
+end
+
+function redirect.dest_zone(self)
+	return zone(self:dest())
+end
diff --git a/modules/luci-base/luasrc/model/ipkg.lua b/modules/luci-base/luasrc/model/ipkg.lua
new file mode 100644
index 0000000000..c927e71163
--- /dev/null
+++ b/modules/luci-base/luasrc/model/ipkg.lua
@@ -0,0 +1,239 @@
+--[[
+LuCI - Lua Configuration Interface
+
+(c) 2008-2011 Jo-Philipp Wich <xm@subsignal.org>
+(c) 2008 Steven Barth <steven@midlink.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
+
+]]--
+
+local os   = require "os"
+local io   = require "io"
+local fs   = require "nixio.fs"
+local util = require "luci.util"
+
+local type  = type
+local pairs = pairs
+local error = error
+local table = table
+
+local ipkg = "opkg --force-removal-of-dependent-packages --force-overwrite --nocase"
+local icfg = "/etc/opkg.conf"
+
+--- LuCI OPKG call abstraction library
+module "luci.model.ipkg"
+
+
+-- Internal action function
+local function _action(cmd, ...)
+	local pkg = ""
+	for k, v in pairs({...}) do
+		pkg = pkg .. " '" .. v:gsub("'", "") .. "'"
+	end
+
+	local c = "%s %s %s >/tmp/opkg.stdout 2>/tmp/opkg.stderr" %{ ipkg, cmd, pkg }
+	local r = os.execute(c)
+	local e = fs.readfile("/tmp/opkg.stderr")
+	local o = fs.readfile("/tmp/opkg.stdout")
+
+	fs.unlink("/tmp/opkg.stderr")
+	fs.unlink("/tmp/opkg.stdout")
+
+	return r, o or "", e or ""
+end
+
+-- Internal parser function
+local function _parselist(rawdata)
+	if type(rawdata) ~= "function" then
+		error("OPKG: Invalid rawdata given")
+	end
+
+	local data = {}
+	local c = {}
+	local l = nil
+
+	for line in rawdata do
+		if line:sub(1, 1) ~= " " then
+			local key, val = line:match("(.-): ?(.*)%s*")
+
+			if key and val then
+				if key == "Package" then
+					c = {Package = val}
+					data[val] = c
+				elseif key == "Status" then
+					c.Status = {}
+					for j in val:gmatch("([^ ]+)") do
+						c.Status[j] = true
+					end
+				else
+					c[key] = val
+				end
+				l = key
+			end
+		else
+			-- Multi-line field
+			c[l] = c[l] .. "\n" .. line
+		end
+	end
+
+	return data
+end
+
+-- Internal lookup function
+local function _lookup(act, pkg)
+	local cmd = ipkg .. " " .. act
+	if pkg then
+		cmd = cmd .. " '" .. pkg:gsub("'", "") .. "'"
+	end
+
+	-- OPKG sometimes kills the whole machine because it sucks
+	-- Therefore we have to use a sucky approach too and use
+	-- tmpfiles instead of directly reading the output
+	local tmpfile = os.tmpname()
+	os.execute(cmd .. (" >%s 2>/dev/null" % tmpfile))
+
+	local data = _parselist(io.lines(tmpfile))
+	os.remove(tmpfile)
+	return data
+end
+
+
+--- Return information about installed and available packages.
+-- @param pkg Limit output to a (set of) packages
+-- @return Table containing package information
+function info(pkg)
+	return _lookup("info", pkg)
+end
+
+--- Return the package status of one or more packages.
+-- @param pkg Limit output to a (set of) packages
+-- @return Table containing package status information
+function status(pkg)
+	return _lookup("status", pkg)
+end
+
+--- Install one or more packages.
+-- @param ... List of packages to install
+-- @return Boolean indicating the status of the action
+-- @return OPKG return code, STDOUT and STDERR
+function install(...)
+	return _action("install", ...)
+end
+
+--- Determine whether a given package is installed.
+-- @param pkg Package
+-- @return Boolean
+function installed(pkg)
+	local p = status(pkg)[pkg]
+	return (p and p.Status and p.Status.installed)
+end
+
+--- Remove one or more packages.
+-- @param ... List of packages to install
+-- @return Boolean indicating the status of the action
+-- @return OPKG return code, STDOUT and STDERR
+function remove(...)
+	return _action("remove", ...)
+end
+
+--- Update package lists.
+-- @return Boolean indicating the status of the action
+-- @return OPKG return code, STDOUT and STDERR
+function update()
+	return _action("update")
+end
+
+--- Upgrades all installed packages.
+-- @return Boolean indicating the status of the action
+-- @return OPKG return code, STDOUT and STDERR
+function upgrade()
+	return _action("upgrade")
+end
+
+-- List helper
+function _list(action, pat, cb)
+	local fd = io.popen(ipkg .. " " .. action ..
+		(pat and (" '%s'" % pat:gsub("'", "")) or ""))
+
+	if fd then
+		local name, version, desc
+		while true do
+			local line = fd:read("*l")
+			if not line then break end
+
+			name, version, desc = line:match("^(.-) %- (.-) %- (.+)")
+
+			if not name then
+				name, version = line:match("^(.-) %- (.+)")
+				desc = ""
+			end
+
+			cb(name, version, desc)
+
+			name    = nil
+			version = nil
+			desc    = nil
+		end
+
+		fd:close()
+	end
+end
+
+--- List all packages known to opkg.
+-- @param pat	Only find packages matching this pattern, nil lists all packages
+-- @param cb	Callback function invoked for each package, receives name, version and description as arguments
+-- @return	nothing
+function list_all(pat, cb)
+	_list("list", pat, cb)
+end
+
+--- List installed packages.
+-- @param pat	Only find packages matching this pattern, nil lists all packages
+-- @param cb	Callback function invoked for each package, receives name, version and description as arguments
+-- @return	nothing
+function list_installed(pat, cb)
+	_list("list_installed", pat, cb)
+end
+
+--- Find packages that match the given pattern.
+-- @param pat	Find packages whose names or descriptions match this pattern, nil results in zero results
+-- @param cb	Callback function invoked for each patckage, receives name, version and description as arguments
+-- @return	nothing
+function find(pat, cb)
+	_list("find", pat, cb)
+end
+
+
+--- Determines the overlay root used by opkg.
+-- @return		String containing the directory path of the overlay root.
+function overlay_root()
+	local od = "/"
+	local fd = io.open(icfg, "r")
+
+	if fd then
+		local ln
+
+		repeat
+			ln = fd:read("*l")
+			if ln and ln:match("^%s*option%s+overlay_root%s+") then
+				od = ln:match("^%s*option%s+overlay_root%s+(%S+)")
+
+				local s = fs.stat(od)
+				if not s or s.type ~= "dir" then
+					od = "/"
+				end
+
+				break
+			end
+		until not ln
+
+		fd:close()
+	end
+
+	return od
+end
diff --git a/modules/luci-base/luasrc/model/network.lua b/modules/luci-base/luasrc/model/network.lua
new file mode 100644
index 0000000000..6119abd73c
--- /dev/null
+++ b/modules/luci-base/luasrc/model/network.lua
@@ -0,0 +1,1597 @@
+--[[
+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, next, pairs, ipairs, loadfile, table
+	= type, next, pairs, ipairs, loadfile, table
+
+local tonumber, tostring, math = tonumber, tostring, math
+
+local require = require
+
+local bus = require "ubus"
+local nxo = require "nixio"
+local nfs = require "nixio.fs"
+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"
+local lng = require "luci.i18n"
+
+module "luci.model.network"
+
+
+IFACE_PATTERNS_VIRTUAL  = { }
+IFACE_PATTERNS_IGNORE   = { "^wmaster%d", "^wifi%d", "^hwsim%d", "^imq%d", "^ifb%d", "^mon%.wlan%d", "^sit%d", "^gre%d", "^lo$" }
+IFACE_PATTERNS_WIRELESS = { "^wlan%d", "^wl%d", "^ath%d", "^%w+%.network%d" }
+
+
+protocol = utl.class()
+
+local _protocols = { }
+
+local _interfaces, _bridge, _switch, _tunnel
+local _ubus, _ubusnetcache, _ubusdevcache, _ubuswificache
+local _uci_real, _uci_state
+
+function _filter(c, s, o, r)
+	local val = _uci_real: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_real:set(c, s, o, table.concat(l, " "))
+			else
+				_uci_real: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_real:set(c, s, o, l)
+			else
+				_uci_real:delete(c, s, o)
+			end
+		end
+	end
+end
+
+function _append(c, s, o, a)
+	local val = _uci_real: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_real: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_real:set(c, s, o, l)
+	end
+end
+
+function _stror(s1, s2)
+	if not s1 or #s1 == 0 then
+		return s2 and #s2 > 0 and s2
+	else
+		return s1
+	end
+end
+
+function _get(c, s, o)
+	return _uci_real:get(c, s, o)
+end
+
+function _set(c, s, o, v)
+	if v ~= nil then
+		if type(v) == "boolean" then v = v and "1" or "0" end
+		return _uci_real:set(c, s, o, v)
+	else
+		return _uci_real:delete(c, s, o)
+	end
+end
+
+function _wifi_iface(x)
+	local _, p
+	for _, p in ipairs(IFACE_PATTERNS_WIRELESS) do
+		if x:match(p) then
+			return true
+		end
+	end
+	return false
+end
+
+function _wifi_state(key, val, field)
+	local radio, radiostate, ifc, ifcstate
+
+	if not next(_ubuswificache) then
+		_ubuswificache = _ubus:call("network.wireless", "status", {}) or {}
+
+		-- workaround extended section format
+		for radio, radiostate in pairs(_ubuswificache) do
+			for ifc, ifcstate in pairs(radiostate.interfaces) do
+				if ifcstate.section and ifcstate.section:sub(1, 1) == '@' then
+					local s = _uci_real:get_all('wireless.%s' % ifcstate.section)
+					if s then
+						ifcstate.section = s['.name']
+					end
+				end
+			end
+		end
+	end
+
+	for radio, radiostate in pairs(_ubuswificache) do
+		for ifc, ifcstate in pairs(radiostate.interfaces) do
+			if ifcstate[key] == val then
+				return ifcstate[field]
+			end
+		end
+	end
+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_real: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 = _wifi_state("ifname", ifn, "section")
+		if not sid then
+			_uci_state:foreach("wireless", "wifi-iface",
+				function(s)
+					if s.ifname == ifn then
+						sid = s['.name']
+						return false
+					end
+				end)
+		end
+
+		return sid
+	end
+end
+
+function _iface_virtual(x)
+	local _, p
+	for _, p in ipairs(IFACE_PATTERNS_VIRTUAL) do
+		if x:match(p) then
+			return true
+		end
+	end
+	return false
+end
+
+function _iface_ignore(x)
+	local _, p
+	for _, p in ipairs(IFACE_PATTERNS_IGNORE) do
+		if x:match(p) then
+			return true
+		end
+	end
+	return _iface_virtual(x)
+end
+
+
+function init(cursor)
+	_uci_real  = cursor or _uci_real or uci.cursor()
+	_uci_state = _uci_real:substate()
+
+	_interfaces = { }
+	_bridge     = { }
+	_switch     = { }
+	_tunnel     = { }
+
+	_ubus          = bus.connect()
+	_ubusnetcache  = { }
+	_ubusdevcache  = { }
+	_ubuswificache = { }
+
+	-- read interface information
+	local n, i
+	for n, i in ipairs(nxo.getifaddrs()) do
+		local name = i.name:match("[^:]+")
+		local prnt = name:match("^([^%.]+)%.")
+
+		if _iface_virtual(name) then
+			_tunnel[name] = true
+		end
+
+		if _tunnel[name] or not _iface_ignore(name) then
+			_interfaces[name] = _interfaces[name] or {
+				idx      = i.ifindex or n,
+				name     = name,
+				rawname  = i.name,
+				flags    = { },
+				ipaddrs  = { },
+				ip6addrs = { }
+			}
+
+			if prnt then
+				_switch[name] = true
+				_switch[prnt] = true
+			end
+
+			if i.family == "packet" then
+				_interfaces[name].flags   = i.flags
+				_interfaces[name].stats   = i.data
+				_interfaces[name].macaddr = i.addr
+			elseif i.family == "inet" then
+				_interfaces[name].ipaddrs[#_interfaces[name].ipaddrs+1] = ipc.IPv4(i.addr, i.netmask)
+			elseif i.family == "inet6" then
+				_interfaces[name].ip6addrs[#_interfaces[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 = { _interfaces[r[4]] }
+				}
+				if b.ifnames[1] then
+					b.ifnames[1].bridge = b
+				end
+				_bridge[r[1]] = b
+			elseif b then
+				b.ifnames[#b.ifnames+1] = _interfaces[r[2]]
+				b.ifnames[#b.ifnames].bridge = b
+			end
+		end
+	end
+
+	return _M
+end
+
+function save(self, ...)
+	_uci_real:save(...)
+	_uci_real:load(...)
+end
+
+function commit(self, ...)
+	_uci_real:commit(...)
+	_uci_real:load(...)
+end
+
+function ifnameof(self, x)
+	if utl.instanceof(x, interface) then
+		return x:name()
+	elseif utl.instanceof(x, protocol) then
+		return x:ifname()
+	elseif type(x) == "string" then
+		return x:match("^[^:]+")
+	end
+end
+
+function get_protocol(self, protoname, netname)
+	local v = _protocols[protoname]
+	if v then
+		return v(netname or "__dummy__")
+	end
+end
+
+function get_protocols(self)
+	local p = { }
+	local _, v
+	for _, v in ipairs(_protocols) do
+		p[#p+1] = v("__dummy__")
+	end
+	return p
+end
+
+function register_protocol(self, protoname)
+	local proto = utl.class(protocol)
+
+	function proto.__init__(self, name)
+		self.sid = name
+	end
+
+	function proto.proto(self)
+		return protoname
+	end
+
+	_protocols[#_protocols+1] = proto
+	_protocols[protoname]     = proto
+
+	return proto
+end
+
+function register_pattern_virtual(self, pat)
+	IFACE_PATTERNS_VIRTUAL[#IFACE_PATTERNS_VIRTUAL+1] = pat
+end
+
+
+function has_ipv6(self)
+	return nfs.access("/proc/net/ipv6_route")
+end
+
+function add_network(self, n, options)
+	local oldnet = self:get_network(n)
+	if n and #n > 0 and n:match("^[a-zA-Z0-9_]+$") and not oldnet then
+		if _uci_real:section("network", "interface", n, options) then
+			return network(n)
+		end
+	elseif oldnet and oldnet:is_empty() then
+		if options then
+			local k, v
+			for k, v in pairs(options) do
+				oldnet:set(k, v)
+			end
+		end
+		return oldnet
+	end
+end
+
+function get_network(self, n)
+	if n and _uci_real:get("network", n) == "interface" then
+		return network(n)
+	end
+end
+
+function get_networks(self)
+	local nets = { }
+	local nls = { }
+
+	_uci_real:foreach("network", "interface",
+		function(s)
+			nls[s['.name']] = network(s['.name'])
+		end)
+
+	local n
+	for n in utl.kspairs(nls) do
+		nets[#nets+1] = nls[n]
+	end
+
+	return nets
+end
+
+function del_network(self, n)
+	local r = _uci_real:delete("network", n)
+	if r then
+		_uci_real:delete_all("network", "alias",
+			function(s) return (s.interface == n) end)
+
+		_uci_real:delete_all("network", "route",
+			function(s) return (s.interface == n) end)
+
+		_uci_real:delete_all("network", "route6",
+			function(s) return (s.interface == n) end)
+
+		_uci_real:foreach("wireless", "wifi-iface",
+			function(s)
+				local net
+				local rest = { }
+				for net in utl.imatch(s.network) do
+					if net ~= n then
+						rest[#rest+1] = net
+					end
+				end
+				if #rest > 0 then
+					_uci_real:set("wireless", s['.name'], "network",
+					              table.concat(rest, " "))
+				else
+					_uci_real:delete("wireless", s['.name'], "network")
+				end
+			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 = _uci_real:section("network", "interface", new, _uci_real:get_all("network", old))
+
+		if r then
+			_uci_real:foreach("network", "alias",
+				function(s)
+					if s.interface == old then
+						_uci_real:set("network", s['.name'], "interface", new)
+					end
+				end)
+
+			_uci_real:foreach("network", "route",
+				function(s)
+					if s.interface == old then
+						_uci_real:set("network", s['.name'], "interface", new)
+					end
+				end)
+
+			_uci_real:foreach("network", "route6",
+				function(s)
+					if s.interface == old then
+						_uci_real:set("network", s['.name'], "interface", new)
+					end
+				end)
+
+			_uci_real:foreach("wireless", "wifi-iface",
+				function(s)
+					local net
+					local list = { }
+					for net in utl.imatch(s.network) do
+						if net == old then
+							list[#list+1] = new
+						else
+							list[#list+1] = net
+						end
+					end
+					if #list > 0 then
+						_uci_real:set("wireless", s['.name'], "network",
+						              table.concat(list, " "))
+					end
+				end)
+
+			_uci_real:delete("network", old)
+		end
+	end
+	return r or false
+end
+
+function get_interface(self, i)
+	if _interfaces[i] or _wifi_iface(i) then
+		return interface(i)
+	else
+		local ifc
+		local num = { }
+		_uci_real: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 = { }
+	local seen = { }
+	local nfs = { }
+	local baseof = { }
+
+	-- find normal interfaces
+	_uci_real:foreach("network", "interface",
+		function(s)
+			for iface in utl.imatch(s.ifname) do
+				if not _iface_ignore(iface) and not _wifi_iface(iface) then
+					seen[iface] = true
+					nfs[iface] = interface(iface)
+				end
+			end
+		end)
+
+	for iface in utl.kspairs(_interfaces) do
+		if not (seen[iface] or _iface_ignore(iface) or _wifi_iface(iface)) then
+			nfs[iface] = interface(iface)
+		end
+	end
+
+	-- find vlan interfaces
+	_uci_real:foreach("network", "switch_vlan",
+		function(s)
+			if not s.device then
+				return
+			end
+
+			local base = baseof[s.device]
+			if not base then
+				if not s.device:match("^eth%d") then
+					local l
+					for l in utl.execi("swconfig dev %q help 2>/dev/null" % s.device) do
+						if not base then
+							base = l:match("^%w+: (%w+)")
+						end
+					end
+					if not base or not base:match("^eth%d") then
+						base = "eth0"
+					end
+				else
+					base = s.device
+				end
+				baseof[s.device] = base
+			end
+
+			local vid = tonumber(s.vid or s.vlan)
+			if vid ~= nil and vid >= 0 and vid <= 4095 then
+				local iface = "%s.%d" %{ base, vid }
+				if not seen[iface] then
+					seen[iface] = true
+					nfs[iface] = interface(iface)
+				end
+			end
+		end)
+
+	for iface in utl.kspairs(nfs) do
+		ifaces[#ifaces+1] = nfs[iface]
+	end
+
+	-- find wifi interfaces
+	local num = { }
+	local wfs = { }
+	_uci_real: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
+
+function get_wifidev(self, dev)
+	if _uci_real:get("wireless", dev) == "wifi-device" then
+		return wifidev(dev)
+	end
+end
+
+function get_wifidevs(self)
+	local devs = { }
+	local wfd  = { }
+
+	_uci_real:foreach("wireless", "wifi-device",
+		function(s) wfd[#wfd+1] = s['.name'] end)
+
+	local dev
+	for _, dev in utl.vspairs(wfd) do
+		devs[#devs+1] = wifidev(dev)
+	end
+
+	return devs
+end
+
+function get_wifinet(self, net)
+	local wnet = _wifi_lookup(net)
+	if wnet then
+		return wifinet(wnet)
+	end
+end
+
+function add_wifinet(self, net, options)
+	if type(options) == "table" and options.device and
+		_uci_real:get("wireless", options.device) == "wifi-device"
+	then
+		local wnet = _uci_real:section("wireless", "wifi-iface", nil, options)
+		return wifinet(wnet)
+	end
+end
+
+function del_wifinet(self, net)
+	local wnet = _wifi_lookup(net)
+	if wnet then
+		_uci_real:delete("wireless", wnet)
+		return true
+	end
+	return false
+end
+
+function get_status_by_route(self, addr, mask)
+	local _, object
+	for _, object in ipairs(_ubus:objects()) do
+		local net = object:match("^network%.interface%.(.+)")
+		if net then
+			local s = _ubus:call(object, "status", {})
+			if s and s.route then
+				local rt
+				for _, rt in ipairs(s.route) do
+					if not rt.table and rt.target == addr and rt.mask == mask then
+						return net, s
+					end
+				end
+			end
+		end
+	end
+end
+
+function get_status_by_address(self, addr)
+	local _, object
+	for _, object in ipairs(_ubus:objects()) do
+		local net = object:match("^network%.interface%.(.+)")
+		if net then
+			local s = _ubus:call(object, "status", {})
+			if s and s['ipv4-address'] then
+				local a
+				for _, a in ipairs(s['ipv4-address']) do
+					if a.address == addr then
+						return net, s
+					end
+				end
+			end
+			if s and s['ipv6-address'] then
+				local a
+				for _, a in ipairs(s['ipv6-address']) do
+					if a.address == addr then
+						return net, s
+					end
+				end
+			end
+		end
+	end
+end
+
+function get_wannet(self)
+	local net = self:get_status_by_route("0.0.0.0", 0)
+	return net and network(net)
+end
+
+function get_wandev(self)
+	local _, stat = self:get_status_by_route("0.0.0.0", 0)
+	return stat and interface(stat.l3_device or stat.device)
+end
+
+function get_wan6net(self)
+	local net = self:get_status_by_route("::", 0)
+	return net and network(net)
+end
+
+function get_wan6dev(self)
+	local _, stat = self:get_status_by_route("::", 0)
+	return stat and interface(stat.l3_device or stat.device)
+end
+
+
+function network(name, proto)
+	if name then
+		local p = proto or _uci_real:get("network", name, "proto")
+		local c = p and _protocols[p] or protocol
+		return c(name)
+	end
+end
+
+function protocol.__init__(self, name)
+	self.sid = name
+end
+
+function protocol._get(self, opt)
+	local v = _uci_real:get("network", self.sid, opt)
+	if type(v) == "table" then
+		return table.concat(v, " ")
+	end
+	return v or ""
+end
+
+function protocol._ubus(self, field)
+	if not _ubusnetcache[self.sid] then
+		_ubusnetcache[self.sid] = _ubus:call("network.interface.%s" % self.sid,
+		                                     "status", { })
+	end
+	if _ubusnetcache[self.sid] and field then
+		return _ubusnetcache[self.sid][field]
+	end
+	return _ubusnetcache[self.sid]
+end
+
+function protocol.get(self, opt)
+	return _get("network", self.sid, opt)
+end
+
+function protocol.set(self, opt, val)
+	return _set("network", self.sid, opt, val)
+end
+
+function protocol.ifname(self)
+	local ifname
+	if self:is_floating() then
+		ifname = self:_ubus("l3_device")
+	else
+		ifname = self:_ubus("device")
+	end
+	if not ifname then
+		local num = { }
+		_uci_real:foreach("wireless", "wifi-iface",
+			function(s)
+				if s.device then
+					num[s.device] = num[s.device]
+						and num[s.device] + 1 or 1
+
+					local net
+					for net in utl.imatch(s.network) do
+						if net == self.sid then
+							ifname = "%s.network%d" %{ s.device, num[s.device] }
+							return false
+						end
+					end
+				end
+			end)
+	end
+	return ifname
+end
+
+function protocol.proto(self)
+	return "none"
+end
+
+function protocol.get_i18n(self)
+	local p = self:proto()
+	if p == "none" then
+		return lng.translate("Unmanaged")
+	elseif p == "static" then
+		return lng.translate("Static address")
+	elseif p == "dhcp" then
+		return lng.translate("DHCP client")
+	else
+		return lng.translate("Unknown")
+	end
+end
+
+function protocol.type(self)
+	return self:_get("type")
+end
+
+function protocol.name(self)
+	return self.sid
+end
+
+function protocol.uptime(self)
+	return self:_ubus("uptime") or 0
+end
+
+function protocol.expires(self)
+	local a = tonumber(_uci_state:get("network", self.sid, "lease_acquired"))
+	local l = tonumber(_uci_state:get("network", self.sid, "lease_lifetime"))
+	if a and l then
+		l = l - (nxo.sysinfo().uptime - a)
+		return l > 0 and l or 0
+	end
+	return -1
+end
+
+function protocol.metric(self)
+	return tonumber(_uci_state:get("network", self.sid, "metric")) or 0
+end
+
+function protocol.ipaddr(self)
+	local addrs = self:_ubus("ipv4-address")
+	return addrs and #addrs > 0 and addrs[1].address
+end
+
+function protocol.netmask(self)
+	local addrs = self:_ubus("ipv4-address")
+	return addrs and #addrs > 0 and
+		ipc.IPv4("0.0.0.0/%d" % addrs[1].mask):mask():string()
+end
+
+function protocol.gwaddr(self)
+	local _, route
+	for _, route in ipairs(self:_ubus("route") or { }) do
+		if route.target == "0.0.0.0" and route.mask == 0 then
+			return route.nexthop
+		end
+	end
+end
+
+function protocol.dnsaddrs(self)
+	local dns = { }
+	local _, addr
+	for _, addr in ipairs(self:_ubus("dns-server") or { }) do
+		if not addr:match(":") then
+			dns[#dns+1] = addr
+		end
+	end
+	return dns
+end
+
+function protocol.ip6addr(self)
+	local addrs = self:_ubus("ipv6-address")
+	if addrs and #addrs > 0 then
+		return "%s/%d" %{ addrs[1].address, addrs[1].mask }
+	else
+		addrs = self:_ubus("ipv6-prefix-assignment")
+		if addrs and #addrs > 0 then
+			return "%s/%d" %{ addrs[1].address, addrs[1].mask }
+		end
+	end
+end
+
+function protocol.gw6addr(self)
+	local _, route
+	for _, route in ipairs(self:_ubus("route") or { }) do
+		if route.target == "::" and route.mask == 0 then
+			return ipc.IPv6(route.nexthop):string()
+		end
+	end
+end
+
+function protocol.dns6addrs(self)
+	local dns = { }
+	local _, addr
+	for _, addr in ipairs(self:_ubus("dns-server") or { }) do
+		if addr:match(":") then
+			dns[#dns+1] = addr
+		end
+	end
+	return dns
+end
+
+function protocol.is_bridge(self)
+	return (not self:is_virtual() and self:type() == "bridge")
+end
+
+function protocol.opkg_package(self)
+	return nil
+end
+
+function protocol.is_installed(self)
+	return true
+end
+
+function protocol.is_virtual(self)
+	return false
+end
+
+function protocol.is_floating(self)
+	return false
+end
+
+function protocol.is_empty(self)
+	if self:is_floating() then
+		return false
+	else
+		local rv = true
+
+		if (self:_get("ifname") or ""):match("%S+") then
+			rv = false
+		end
+
+		_uci_real:foreach("wireless", "wifi-iface",
+			function(s)
+				local n
+				for n in utl.imatch(s.network) do
+					if n == self.sid then
+						rv = false
+						return false
+					end
+				end
+			end)
+
+		return rv
+	end
+end
+
+function protocol.add_interface(self, ifname)
+	ifname = _M:ifnameof(ifname)
+	if ifname and not self:is_floating() then
+		-- if its a wifi interface, change its network option
+		local wif = _wifi_lookup(ifname)
+		if wif then
+			_append("wireless", wif, "network", self.sid)
+
+		-- add iface to our iface list
+		else
+			_append("network", self.sid, "ifname", ifname)
+		end
+	end
+end
+
+function protocol.del_interface(self, ifname)
+	ifname = _M:ifnameof(ifname)
+	if ifname and not self:is_floating() then
+		-- if its a wireless interface, clear its network option
+		local wif = _wifi_lookup(ifname)
+		if wif then _filter("wireless", wif, "network", self.sid) end
+
+		-- remove the interface
+		_filter("network", self.sid, "ifname", ifname)
+	end
+end
+
+function protocol.get_interface(self)
+	if self:is_virtual() then
+		_tunnel[self:proto() .. "-" .. self.sid] = true
+		return interface(self:proto() .. "-" .. self.sid, self)
+	elseif self:is_bridge() then
+		_bridge["br-" .. self.sid] = true
+		return interface("br-" .. self.sid, self)
+	else
+		local ifn = nil
+		local num = { }
+		for ifn in utl.imatch(_uci_real:get("network", self.sid, "ifname")) do
+			ifn = ifn:match("^[^:/]+")
+			return ifn and interface(ifn, self)
+		end
+		ifn = nil
+		_uci_real:foreach("wireless", "wifi-iface",
+			function(s)
+				if s.device then
+					num[s.device] = num[s.device] and num[s.device] + 1 or 1
+
+					local net
+					for net in utl.imatch(s.network) do
+						if net == self.sid then
+							ifn = "%s.network%d" %{ s.device, num[s.device] }
+							return false
+						end
+					end
+				end
+			end)
+		return ifn and interface(ifn, self)
+	end
+end
+
+function protocol.get_interfaces(self)
+	if self:is_bridge() or (self:is_virtual() and not self:is_floating()) then
+		local ifaces = { }
+
+		local ifn
+		local nfs = { }
+		for ifn in utl.imatch(self:get("ifname")) do
+			ifn = ifn:match("^[^:/]+")
+			nfs[ifn] = interface(ifn, self)
+		end
+
+		for ifn in utl.kspairs(nfs) do
+			ifaces[#ifaces+1] = nfs[ifn]
+		end
+
+		local num = { }
+		local wfs = { }
+		_uci_real:foreach("wireless", "wifi-iface",
+			function(s)
+				if s.device then
+					num[s.device] = num[s.device] and num[s.device] + 1 or 1
+
+					local net
+					for net in utl.imatch(s.network) do
+						if net == self.sid then
+							ifn = "%s.network%d" %{ s.device, num[s.device] }
+							wfs[ifn] = interface(ifn, self)
+						end
+					end
+				end
+			end)
+
+		for ifn in utl.kspairs(wfs) do
+			ifaces[#ifaces+1] = wfs[ifn]
+		end
+
+		return ifaces
+	end
+end
+
+function protocol.contains_interface(self, ifname)
+	ifname = _M:ifnameof(ifname)
+	if not ifname then
+		return false
+	elseif self:is_virtual() and self:proto() .. "-" .. self.sid == ifname then
+		return true
+	elseif self:is_bridge() and "br-" .. self.sid == ifname then
+		return true
+	else
+		local ifn
+		for ifn in utl.imatch(self:get("ifname")) do
+			ifn = ifn:match("[^:]+")
+			if ifn == ifname then
+				return true
+			end
+		end
+
+		local wif = _wifi_lookup(ifname)
+		if wif then
+			local n
+			for n in utl.imatch(_uci_real:get("wireless", wif, "network")) do
+				if n == self.sid then
+					return true
+				end
+			end
+		end
+	end
+
+	return false
+end
+
+function protocol.adminlink(self)
+	return dsp.build_url("admin", "network", "network", self.sid)
+end
+
+
+interface = utl.class()
+
+function interface.__init__(self, ifname, network)
+	local wif = _wifi_lookup(ifname)
+	if wif then
+		self.wif    = wifinet(wif)
+		self.ifname = _wifi_state("section", wif, "ifname")
+	end
+
+	self.ifname  = self.ifname or ifname
+	self.dev     = _interfaces[self.ifname]
+	self.network = network
+end
+
+function interface._ubus(self, field)
+	if not _ubusdevcache[self.ifname] then
+		_ubusdevcache[self.ifname] = _ubus:call("network.device", "status",
+		                                        { name = self.ifname })
+	end
+	if _ubusdevcache[self.ifname] and field then
+		return _ubusdevcache[self.ifname][field]
+	end
+	return _ubusdevcache[self.ifname]
+end
+
+function interface.name(self)
+	return self.wif and self.wif:ifname() or self.ifname
+end
+
+function interface.mac(self)
+	return (self:_ubus("macaddr") or "00:00:00:00:00:00"):upper()
+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 self.wif or _wifi_iface(self.ifname) then
+		return "wifi"
+	elseif _bridge[self.ifname] then
+		return "bridge"
+	elseif _tunnel[self.ifname] then
+		return "tunnel"
+	elseif self.ifname:match("%.") then
+		return "vlan"
+	elseif _switch[self.ifname] then
+		return "switch"
+	else
+		return "ethernet"
+	end
+end
+
+function interface.shortname(self)
+	if self.wif then
+		return "%s %q" %{
+			self.wif:active_mode(),
+			self.wif:active_ssid() or self.wif:active_bssid()
+		}
+	else
+		return self.ifname
+	end
+end
+
+function interface.get_i18n(self)
+	if self.wif then
+		return "%s: %s %q" %{
+			lng.translate("Wireless Network"),
+			self.wif:active_mode(),
+			self.wif:active_ssid() or self.wif:active_bssid()
+		}
+	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 lng.translate("Wireless Adapter")
+	elseif x == "bridge" then
+		return lng.translate("Bridge")
+	elseif x == "switch" then
+		return lng.translate("Ethernet Switch")
+	elseif x == "vlan" then
+		return lng.translate("VLAN Interface")
+	elseif x == "tunnel" then
+		return lng.translate("Tunnel Interface")
+	else
+		return lng.translate("Ethernet Adapter")
+	end
+end
+
+function interface.adminlink(self)
+	if self.wif then
+		return self.wif:adminlink()
+	end
+end
+
+function interface.ports(self)
+	local members = self:_ubus("bridge-members")
+	if members then
+		local _, iface
+		local ifaces = { }
+		for _, iface in ipairs(members) do
+			ifaces[#ifaces+1] = interface(iface)
+		end
+	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:_ubus("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)
+	local stat = self:_ubus("statistics")
+	return stat and stat.tx_bytes or 0
+end
+
+function interface.rx_bytes(self)
+	local stat = self:_ubus("statistics")
+	return stat and stat.rx_bytes or 0
+end
+
+function interface.tx_packets(self)
+	local stat = self:_ubus("statistics")
+	return stat and stat.tx_packets or 0
+end
+
+function interface.rx_packets(self)
+	local stat = self:_ubus("statistics")
+	return stat and stat.rx_packets or 0
+end
+
+function interface.get_network(self)
+	return self:get_networks()[1]
+end
+
+function interface.get_networks(self)
+	if not self.networks then
+		local nets = { }
+		local _, net
+		for _, net in ipairs(_M:get_networks()) do
+			if net:contains_interface(self.ifname) or
+			   net:ifname() == self.ifname
+			then
+				nets[#nets+1] = net
+			end
+		end
+		table.sort(nets, function(a, b) return a.sid < b.sid end)
+		self.networks = nets
+		return nets
+	else
+		return self.networks
+	end
+end
+
+function interface.get_wifinet(self)
+	return self.wif
+end
+
+
+wifidev = utl.class()
+
+function wifidev.__init__(self, dev)
+	self.sid    = dev
+	self.iwinfo = dev and sys.wifi.getiwinfo(dev) or { }
+end
+
+function wifidev.get(self, opt)
+	return _get("wireless", self.sid, opt)
+end
+
+function wifidev.set(self, opt, val)
+	return _set("wireless", self.sid, opt, val)
+end
+
+function wifidev.name(self)
+	return self.sid
+end
+
+function wifidev.hwmodes(self)
+	local l = self.iwinfo.hwmodelist
+	if l and next(l) then
+		return l
+	else
+		return { b = true, g = true }
+	end
+end
+
+function wifidev.get_i18n(self)
+	local t = "Generic"
+	if self.iwinfo.type == "wl" then
+		t = "Broadcom"
+	elseif self.iwinfo.type == "madwifi" then
+		t = "Atheros"
+	end
+
+	local m = ""
+	local l = self:hwmodes()
+	if l.a then m = m .. "a" end
+	if l.b then m = m .. "b" end
+	if l.g then m = m .. "g" end
+	if l.n then m = m .. "n" end
+	if l.ac then m = "ac" end
+
+	return "%s 802.11%s Wireless Controller (%s)" %{ t, m, self:name() }
+end
+
+function wifidev.is_up(self)
+	if _ubuswificache[self.sid] then
+		return (_ubuswificache[self.sid].up == true)
+	end
+
+	local up = false
+	_uci_state:foreach("wireless", "wifi-iface",
+		function(s)
+			if s.device == self.sid then
+				if s.up == "1" then
+					up = true
+					return false
+				end
+			end
+		end)
+
+	return up
+end
+
+function wifidev.get_wifinet(self, net)
+	if _uci_real:get("wireless", net) == "wifi-iface" then
+		return wifinet(net)
+	else
+		local wnet = _wifi_lookup(net)
+		if wnet then
+			return wifinet(wnet)
+		end
+	end
+end
+
+function wifidev.get_wifinets(self)
+	local nets = { }
+
+	_uci_real:foreach("wireless", "wifi-iface",
+		function(s)
+			if s.device == self.sid then
+				nets[#nets+1] = wifinet(s['.name'])
+			end
+		end)
+
+	return nets
+end
+
+function wifidev.add_wifinet(self, options)
+	options = options or { }
+	options.device = self.sid
+
+	local wnet = _uci_real:section("wireless", "wifi-iface", nil, options)
+	if wnet then
+		return wifinet(wnet, options)
+	end
+end
+
+function wifidev.del_wifinet(self, net)
+	if utl.instanceof(net, wifinet) then
+		net = net.sid
+	elseif _uci_real:get("wireless", net) ~= "wifi-iface" then
+		net = _wifi_lookup(net)
+	end
+
+	if net and _uci_real:get("wireless", net, "device") == self.sid then
+		_uci_real:delete("wireless", net)
+		return true
+	end
+
+	return false
+end
+
+
+wifinet = utl.class()
+
+function wifinet.__init__(self, net, data)
+	self.sid = net
+
+	local num = { }
+	local netid
+	_uci_real: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'] == self.sid then
+					netid = "%s.network%d" %{ s.device, num[s.device] }
+					return false
+				end
+			end
+		end)
+
+	local dev = _wifi_state("section", self.sid, "ifname") or netid
+
+	self.netid  = netid
+	self.wdev   = dev
+	self.iwinfo = dev and sys.wifi.getiwinfo(dev) or { }
+	self.iwdata = data or _uci_state:get_all("wireless", self.sid) or
+		_uci_real:get_all("wireless", self.sid) or { }
+end
+
+function wifinet.get(self, opt)
+	return _get("wireless", self.sid, opt)
+end
+
+function wifinet.set(self, opt, val)
+	return _set("wireless", self.sid, opt, val)
+end
+
+function wifinet.mode(self)
+	return _uci_state:get("wireless", self.sid, "mode") or "ap"
+end
+
+function wifinet.ssid(self)
+	return _uci_state:get("wireless", self.sid, "ssid")
+end
+
+function wifinet.bssid(self)
+	return _uci_state:get("wireless", self.sid, "bssid")
+end
+
+function wifinet.network(self)
+	return _uci_state:get("wifinet", self.sid, "network")
+end
+
+function wifinet.id(self)
+	return self.netid
+end
+
+function wifinet.name(self)
+	return self.sid
+end
+
+function wifinet.ifname(self)
+	local ifname = self.iwinfo.ifname
+	if not ifname or ifname:match("^wifi%d") or ifname:match("^radio%d") then
+		ifname = self.wdev
+	end
+	return ifname
+end
+
+function wifinet.get_device(self)
+	if self.iwdata.device then
+		return wifidev(self.iwdata.device)
+	end
+end
+
+function wifinet.is_up(self)
+	local ifc = self:get_interface()
+	return (ifc and ifc:is_up() or false)
+end
+
+function wifinet.active_mode(self)
+	local m = _stror(self.iwinfo.mode, self.iwdata.mode) or "ap"
+
+	if     m == "ap"      then m = "Master"
+	elseif m == "sta"     then m = "Client"
+	elseif m == "adhoc"   then m = "Ad-Hoc"
+	elseif m == "mesh"    then m = "Mesh"
+	elseif m == "monitor" then m = "Monitor"
+	end
+
+	return m
+end
+
+function wifinet.active_mode_i18n(self)
+	return lng.translate(self:active_mode())
+end
+
+function wifinet.active_ssid(self)
+	return _stror(self.iwinfo.ssid, self.iwdata.ssid)
+end
+
+function wifinet.active_bssid(self)
+	return _stror(self.iwinfo.bssid, self.iwdata.bssid) or "00:00:00:00:00:00"
+end
+
+function wifinet.active_encryption(self)
+	local enc = self.iwinfo and self.iwinfo.encryption
+	return enc and enc.description or "-"
+end
+
+function wifinet.assoclist(self)
+	return self.iwinfo.assoclist or { }
+end
+
+function wifinet.frequency(self)
+	local freq = self.iwinfo.frequency
+	if freq and freq > 0 then
+		return "%.03f" % (freq / 1000)
+	end
+end
+
+function wifinet.bitrate(self)
+	local rate = self.iwinfo.bitrate
+	if rate and rate > 0 then
+		return (rate / 1000)
+	end
+end
+
+function wifinet.channel(self)
+	return self.iwinfo.channel or
+		tonumber(_uci_state:get("wireless", self.iwdata.device, "channel"))
+end
+
+function wifinet.signal(self)
+	return self.iwinfo.signal or 0
+end
+
+function wifinet.noise(self)
+	return self.iwinfo.noise or 0
+end
+
+function wifinet.country(self)
+	return self.iwinfo.country or "00"
+end
+
+function wifinet.txpower(self)
+	local pwr = (self.iwinfo.txpower or 0)
+	return pwr + self:txpower_offset()
+end
+
+function wifinet.txpower_offset(self)
+	return self.iwinfo.txpower_offset or 0
+end
+
+function wifinet.signal_level(self, s, n)
+	if self:active_bssid() ~= "00:00:00:00:00:00" then
+		local signal = s or self:signal()
+		local noise  = n or self:noise()
+
+		if signal < 0 and noise < 0 then
+			local snr = -1 * (noise - signal)
+			return math.floor(snr / 5)
+		else
+			return 0
+		end
+	else
+		return -1
+	end
+end
+
+function wifinet.signal_percent(self)
+	local qc = self.iwinfo.quality or 0
+	local qm = self.iwinfo.quality_max or 0
+
+	if qc > 0 and qm > 0 then
+		return math.floor((100 / qm) * qc)
+	else
+		return 0
+	end
+end
+
+function wifinet.shortname(self)
+	return "%s %q" %{
+		lng.translate(self:active_mode()),
+		self:active_ssid() or self:active_bssid()
+	}
+end
+
+function wifinet.get_i18n(self)
+	return "%s: %s %q (%s)" %{
+		lng.translate("Wireless Network"),
+		lng.translate(self:active_mode()),
+		self:active_ssid() or self:active_bssid(),
+		self:ifname()
+	}
+end
+
+function wifinet.adminlink(self)
+	return dsp.build_url("admin", "network", "wireless", self.netid)
+end
+
+function wifinet.get_network(self)
+	return self:get_networks()[1]
+end
+
+function wifinet.get_networks(self)
+	local nets = { }
+	local net
+	for net in utl.imatch(tostring(self.iwdata.network)) do
+		if _uci_real:get("network", net) == "interface" then
+			nets[#nets+1] = network(net)
+		end
+	end
+	table.sort(nets, function(a, b) return a.sid < b.sid end)
+	return nets
+end
+
+function wifinet.get_interface(self)
+	return interface(self:ifname())
+end
+
+
+-- setup base protocols
+_M:register_protocol("static")
+_M:register_protocol("dhcp")
+_M:register_protocol("none")
+
+-- load protocol extensions
+local exts = nfs.dir(utl.libpath() .. "/model/network")
+if exts then
+	local ext
+	for ext in exts do
+		if ext:match("%.lua$") then
+			require("luci.model.network." .. ext:gsub("%.lua$", ""))
+		end
+	end
+end
diff --git a/modules/luci-base/luasrc/model/uci.lua b/modules/luci-base/luasrc/model/uci.lua
new file mode 100644
index 0000000000..a394563047
--- /dev/null
+++ b/modules/luci-base/luasrc/model/uci.lua
@@ -0,0 +1,404 @@
+--[[
+LuCI - UCI model
+
+Description:
+Generalized UCI model
+
+FileId:
+$Id$
+
+License:
+Copyright 2008 Steven Barth <steven@midlink.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 os    = require "os"
+local uci   = require "uci"
+local util  = require "luci.util"
+local table = require "table"
+
+
+local setmetatable, rawget, rawset = setmetatable, rawget, rawset
+local require, getmetatable = require, getmetatable
+local error, pairs, ipairs = error, pairs, ipairs
+local type, tostring, tonumber, unpack = type, tostring, tonumber, unpack
+
+--- LuCI UCI model library.
+-- The typical workflow for UCI is:  Get a cursor instance from the
+-- cursor factory, modify data (via Cursor.add, Cursor.delete, etc.),
+-- save the changes to the staging area via Cursor.save and finally
+-- Cursor.commit the data to the actual config files.
+-- LuCI then needs to Cursor.apply the changes so deamons etc. are
+-- reloaded.
+-- @cstyle	instance
+module "luci.model.uci"
+
+--- Create a new UCI-Cursor.
+-- @class function
+-- @name cursor
+-- @return	UCI-Cursor
+cursor = uci.cursor
+
+APIVERSION = uci.APIVERSION
+
+--- Create a new Cursor initialized to the state directory.
+-- @return UCI cursor
+function cursor_state()
+	return cursor(nil, "/var/state")
+end
+
+
+inst = cursor()
+inst_state = cursor_state()
+
+local Cursor = getmetatable(inst)
+
+--- Applies UCI configuration changes
+-- @param configlist		List of UCI configurations
+-- @param command			Don't apply only return the command
+function Cursor.apply(self, configlist, command)
+	configlist = self:_affected(configlist)
+	if command then
+		return { "/sbin/luci-reload", unpack(configlist) }
+	else
+		return os.execute("/sbin/luci-reload %s >/dev/null 2>&1"
+			% table.concat(configlist, " "))
+	end
+end
+
+
+--- Delete all sections of a given type that match certain criteria.
+-- @param config		UCI config
+-- @param type			UCI section type
+-- @param comparator	Function that will be called for each section and
+-- returns a boolean whether to delete the current section (optional)
+function Cursor.delete_all(self, config, stype, comparator)
+	local del = {}
+
+	if type(comparator) == "table" then
+		local tbl = comparator
+		comparator = function(section)
+			for k, v in pairs(tbl) do
+				if section[k] ~= v then
+					return false
+				end
+			end
+			return true
+		end
+	end
+
+	local function helper (section)
+
+		if not comparator or comparator(section) then
+			del[#del+1] = section[".name"]
+		end
+	end
+
+	self:foreach(config, stype, helper)
+
+	for i, j in ipairs(del) do
+		self:delete(config, j)
+	end
+end
+
+--- Create a new section and initialize it with data.
+-- @param config	UCI config
+-- @param type		UCI section type
+-- @param name		UCI section name (optional)
+-- @param values	Table of key - value pairs to initialize the section with
+-- @return			Name of created section
+function Cursor.section(self, config, type, name, values)
+	local stat = true
+	if name then
+		stat = self:set(config, name, type)
+	else
+		name = self:add(config, type)
+		stat = name and true
+	end
+
+	if stat and values then
+		stat = self:tset(config, name, values)
+	end
+
+	return stat and name
+end
+
+--- Updated the data of a section using data from a table.
+-- @param config	UCI config
+-- @param section	UCI section name (optional)
+-- @param values	Table of key - value pairs to update the section with
+function Cursor.tset(self, config, section, values)
+	local stat = true
+	for k, v in pairs(values) do
+		if k:sub(1, 1) ~= "." then
+			stat = stat and self:set(config, section, k, v)
+		end
+	end
+	return stat
+end
+
+--- Get a boolean option and return it's value as true or false.
+-- @param config	UCI config
+-- @param section	UCI section name
+-- @param option	UCI option
+-- @return			Boolean
+function Cursor.get_bool(self, ...)
+	local val = self:get(...)
+	return ( val == "1" or val == "true" or val == "yes" or val == "on" )
+end
+
+--- Get an option or list and return values as table.
+-- @param config	UCI config
+-- @param section	UCI section name
+-- @param option	UCI option
+-- @return			UCI value
+function Cursor.get_list(self, config, section, option)
+	if config and section and option then
+		local val = self:get(config, section, option)
+		return ( type(val) == "table" and val or { val } )
+	end
+	return nil
+end
+
+--- Get the given option from the first section with the given type.
+-- @param config	UCI config
+-- @param type		UCI section type
+-- @param option	UCI option (optional)
+-- @param default	Default value (optional)
+-- @return			UCI value
+function Cursor.get_first(self, conf, stype, opt, def)
+	local rv = def
+
+	self:foreach(conf, stype,
+		function(s)
+			local val = not opt and s['.name'] or s[opt]
+
+			if type(def) == "number" then
+				val = tonumber(val)
+			elseif type(def) == "boolean" then
+				val = (val == "1" or val == "true" or
+				       val == "yes" or val == "on")
+			end
+
+			if val ~= nil then
+				rv = val
+				return false
+			end
+		end)
+
+	return rv
+end
+
+--- Set given values as list.
+-- @param config	UCI config
+-- @param section	UCI section name
+-- @param option	UCI option
+-- @param value		UCI value
+-- @return			Boolean whether operation succeeded
+function Cursor.set_list(self, config, section, option, value)
+	if config and section and option then
+		return self:set(
+			config, section, option,
+			( type(value) == "table" and value or { value } )
+		)
+	end
+	return false
+end
+
+-- Return a list of initscripts affected by configuration changes.
+function Cursor._affected(self, configlist)
+	configlist = type(configlist) == "table" and configlist or {configlist}
+
+	local c = cursor()
+	c:load("ucitrack")
+
+	-- Resolve dependencies
+	local reloadlist = {}
+
+	local function _resolve_deps(name)
+		local reload = {name}
+		local deps = {}
+
+		c:foreach("ucitrack", name,
+			function(section)
+				if section.affects then
+					for i, aff in ipairs(section.affects) do
+						deps[#deps+1] = aff
+					end
+				end
+			end)
+
+		for i, dep in ipairs(deps) do
+			for j, add in ipairs(_resolve_deps(dep)) do
+				reload[#reload+1] = add
+			end
+		end
+
+		return reload
+	end
+
+	-- Collect initscripts
+	for j, config in ipairs(configlist) do
+		for i, e in ipairs(_resolve_deps(config)) do
+			if not util.contains(reloadlist, e) then
+				reloadlist[#reloadlist+1] = e
+			end
+		end
+	end
+
+	return reloadlist
+end
+
+--- Create a sub-state of this cursor. The sub-state is tied to the parent
+-- curser, means it the parent unloads or loads configs, the sub state will
+-- do so as well.
+-- @return			UCI state cursor tied to the parent cursor
+function Cursor.substate(self)
+	Cursor._substates = Cursor._substates or { }
+	Cursor._substates[self] = Cursor._substates[self] or cursor_state()
+	return Cursor._substates[self]
+end
+
+local _load = Cursor.load
+function Cursor.load(self, ...)
+	if Cursor._substates and Cursor._substates[self] then
+		_load(Cursor._substates[self], ...)
+	end
+	return _load(self, ...)
+end
+
+local _unload = Cursor.unload
+function Cursor.unload(self, ...)
+	if Cursor._substates and Cursor._substates[self] then
+		_unload(Cursor._substates[self], ...)
+	end
+	return _unload(self, ...)
+end
+
+
+--- Add an anonymous section.
+-- @class function
+-- @name Cursor.add
+-- @param config	UCI config
+-- @param type		UCI section type
+-- @return			Name of created section
+
+--- Get a table of saved but uncommitted changes.
+-- @class function
+-- @name Cursor.changes
+-- @param config	UCI config
+-- @return			Table of changes
+-- @see Cursor.save
+
+--- Commit saved changes.
+-- @class function
+-- @name Cursor.commit
+-- @param config	UCI config
+-- @return			Boolean whether operation succeeded
+-- @see Cursor.revert
+-- @see Cursor.save
+
+--- Deletes a section or an option.
+-- @class function
+-- @name Cursor.delete
+-- @param config	UCI config
+-- @param section	UCI section name
+-- @param option	UCI option (optional)
+-- @return			Boolean whether operation succeeded
+
+--- Call a function for every section of a certain type.
+-- @class function
+-- @name Cursor.foreach
+-- @param config	UCI config
+-- @param type		UCI section type
+-- @param callback	Function to be called
+-- @return			Boolean whether operation succeeded
+
+--- Get a section type or an option
+-- @class function
+-- @name Cursor.get
+-- @param config	UCI config
+-- @param section	UCI section name
+-- @param option	UCI option (optional)
+-- @return			UCI value
+
+--- Get all sections of a config or all values of a section.
+-- @class function
+-- @name Cursor.get_all
+-- @param config	UCI config
+-- @param section	UCI section name (optional)
+-- @return			Table of UCI sections or table of UCI values
+
+--- Manually load a config.
+-- @class function
+-- @name Cursor.load
+-- @param config	UCI config
+-- @return			Boolean whether operation succeeded
+-- @see Cursor.save
+-- @see Cursor.unload
+
+--- Revert saved but uncommitted changes.
+-- @class function
+-- @name Cursor.revert
+-- @param config	UCI config
+-- @return			Boolean whether operation succeeded
+-- @see Cursor.commit
+-- @see Cursor.save
+
+--- Saves changes made to a config to make them committable.
+-- @class function
+-- @name Cursor.save
+-- @param config	UCI config
+-- @return			Boolean whether operation succeeded
+-- @see Cursor.load
+-- @see Cursor.unload
+
+--- Set a value or create a named section.
+-- @class function
+-- @name Cursor.set
+-- @param config	UCI config
+-- @param section	UCI section name
+-- @param option	UCI option or UCI section type
+-- @param value		UCI value or nil if you want to create a section
+-- @return			Boolean whether operation succeeded
+
+--- Get the configuration directory.
+-- @class function
+-- @name Cursor.get_confdir
+-- @return			Configuration directory
+
+--- Get the directory for uncomitted changes.
+-- @class function
+-- @name Cursor.get_savedir
+-- @return			Save directory
+
+--- Set the configuration directory.
+-- @class function
+-- @name Cursor.set_confdir
+-- @param directory	UCI configuration directory
+-- @return			Boolean whether operation succeeded
+
+--- Set the directory for uncommited changes.
+-- @class function
+-- @name Cursor.set_savedir
+-- @param directory	UCI changes directory
+-- @return			Boolean whether operation succeeded
+
+--- Discard changes made to a config.
+-- @class function
+-- @name Cursor.unload
+-- @param config	UCI config
+-- @return			Boolean whether operation succeeded
+-- @see Cursor.load
+-- @see Cursor.save