diff options
Diffstat (limited to 'libs/uvl')
| -rw-r--r-- | libs/uvl/Makefile | 2 | ||||
| -rw-r--r-- | libs/uvl/luasrc/uvl.lua | 403 | ||||
| -rw-r--r-- | libs/uvl/luasrc/uvl/datatypes.lua | 135 |
3 files changed, 540 insertions, 0 deletions
diff --git a/libs/uvl/Makefile b/libs/uvl/Makefile new file mode 100644 index 000000000..81a96f6a8 --- /dev/null +++ b/libs/uvl/Makefile @@ -0,0 +1,2 @@ +include ../../build/config.mk +include ../../build/module.mk
\ No newline at end of file diff --git a/libs/uvl/luasrc/uvl.lua b/libs/uvl/luasrc/uvl.lua new file mode 100644 index 000000000..4894d3006 --- /dev/null +++ b/libs/uvl/luasrc/uvl.lua @@ -0,0 +1,403 @@ +--[[ + +UCI Validation Layer - Main Library +(c) 2008 Jo-Philipp Wich <xm@leipzig.freifunk.net> +(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 + +$Id$ + +]]-- + +module( "luci.uvl", package.seeall ) + +require("luci.fs") +require("luci.util") +require("luci.model.uci") +require("luci.uvl.datatypes") + +TYPE_SECTION = 0x01 +TYPE_VARIABLE = 0x02 +TYPE_ENUM = 0x03 + + +local default_schemedir = "/etc/scheme" +local function _assert( condition, fmt, ... ) + if not condition then + return assert( nil, string.format( fmt, ... ) ) + else + return condition + end +end + +UVL = luci.util.class() + +function UVL.__init__( self, schemedir ) + + self.schemedir = schemedir or default_schemedir + self.packages = { } + self.uci = luci.model.uci + self.datatypes = luci.uvl.datatypes +end + +--- Validate given configuration. +-- @param config Name of the configuration to validate +-- @param scheme Scheme to validate against (optional) +-- @return Boolean indicating weather the given config validates +-- @return String containing the reason for errors (if any) +function UVL.validate( self, config, scheme ) + + if not scheme then + return false, "No scheme found" + end + + for k, v in pairs( config ) do + local ok, err = self:validate_section( config, k, scheme ) + + if not ok then + return ok, err + end + end + + return true, nil +end + +--- Validate given section of given configuration. +-- @param config Name of the configuration to validate +-- @param section Key of the section to validate +-- @param scheme Scheme to validate against +-- @return Boolean indicating weather the given config validates +-- @return String containing the reason for errors (if any) +function UVL.validate_section( self, config, section, scheme ) + + if not scheme then + return false, "No scheme found" + end + + for k, v in pairs( config[section] ) do + local ok, err = self:validate_option( config, section, k, scheme ) + + if not ok then + return ok, err + end + end + + return true, nil +end + +--- Validate given option within section of given configuration. +-- @param config Name of the configuration to validate +-- @param section Key of the section to validate +-- @param option Name of the option to validate +-- @param scheme Scheme to validate against +-- @return Boolean indicating weather the given config validates +-- @return String containing the reason for errors (if any) +function UVL.validate_option( self, config, section, option, scheme ) + + if type(config) == "string" then + config = { ["variables"] = { [section] = { [option] = config } } } + end + + if not scheme then + return false, "No scheme found" + end + + local sv = scheme.variables[section] + if not sv then return false, "Requested section not found in scheme" end + + sv = sv[option] + if not sv then return false, "Requested option not found in scheme" end + + if not ( config[section] and config[section][option] ) and sv.required then + return false, "Mandatory variable doesn't have a value" + end + + if sv.type then + if self.datatypes[sv.type] then + if not self.datatypes[sv.type]( config[section][option] ) then + return false, "Value of given option doesn't validate" + end + else + return false, "Unknown datatype '" .. sv.type .. "' encountered" + end + end + + return true, nil +end + +--- Find all parts of given scheme and construct validation tree +-- @param scheme Name of the scheme to parse +-- @return Parsed scheme +function UVL.read_scheme( self, scheme ) + local schemes = { } + + for i, file in ipairs( luci.fs.glob(self.schemedir .. '/*/' .. scheme) ) do + _assert( luci.fs.access(file), "Can't access file '%s'", file ) + + self.uci.set_confdir( luci.fs.dirname(file) ) + self.uci.load( luci.fs.basename(file) ) + + table.insert( schemes, self.uci.get_all( luci.fs.basename(file) ) ) + end + + return self:_read_scheme_parts( scheme, schemes ) +end + +-- Process all given parts and construct validation tree +function UVL._read_scheme_parts( self, scheme, schemes ) + + local stbl = { } + + -- helper function to construct identifiers for given elements + local function _id( c, t ) + if c == TYPE_SECTION then + return string.format( + "section '%s.%s'", + scheme, t.name or '?' ) + elseif c == TYPE_VARIABLE then + return string.format( + "variable '%s.%s.%s'", + scheme, t.section or '?.?', t.name or '?' ) + elseif c == TYPE_ENUM then + return string.format( + "enum '%s.%s.%s'", + scheme, t.variable or '?.?.?', t.value or '?' ) + end + end + + -- helper function to check for required fields + local function _req( c, t, r ) + for i, v in ipairs(r) do + _assert( t[v], "Missing required field '%s' in %s", v, _id(c, t) ) + end + end + + -- helper function to validate references + local function _ref( c, t ) + local k + if c == TYPE_SECTION then + k = "package" + elseif c == TYPE_VARIABLE then + k = "section" + elseif c == TYPE_ENUM then + k = "variable" + end + + local r = luci.util.split( t[k], "." ) + r[1] = ( #r[1] > 0 and r[1] or scheme ) + + _assert( #r == c, "Malformed %s reference in %s", k, _id(c, t) ) + + return r + end + + -- Step 1: get all sections + for i, conf in ipairs( schemes ) do + for k, v in pairs( conf ) do + if v['.type'] == 'section' then + + _req( TYPE_SECTION, v, { "name", "package" } ) + + local r = _ref( TYPE_SECTION, v ) + + stbl.packages[r[1]] = + stbl.packages[r[1]] or { + ["sections"] = { }; + ["variables"] = { }; + } + + local p = stbl.packages[r[1]] + p.sections[v.name] = p.sections[v.name] or { } + p.variables[v.name] = p.variables[v.name] or { } + + local s = p.sections[v.name] + + for k, v in pairs(v) do + if k ~= "name" and k ~= "package" and k:sub(1,1) ~= "." then + if k:match("^depends") then + s["depends"] = _assert( + self:_read_depency( v, s["depends"] ), + "Section '%s' in scheme '%s' has malformed " .. + "depency specification in '%s'", + v.name, scheme, k + ) + else + s[k] = v + end + end + end + end + end + end + + -- Step 2: get all variables + for i, conf in ipairs( schemes ) do + for k, v in pairs( conf ) do + if v['.type'] == "variable" then + + _req( TYPE_VARIABLE, v, { "name", "type", "section" } ) + + local r = _ref( TYPE_VARIABLE, v ) + + local p = _assert( stbl.packages[r[1]], + "Variable '%s' in scheme '%s' references unknown package '%s'", + v.name, scheme, r[1] ) + + local s = _assert( p.variables[r[2]], + "Variable '%s' in scheme '%s' references unknown section '%s'", + v.name, scheme, r[2] ) + + s[v.name] = s[v.name] or { } + + local t = s[v.name] + + for k, v in pairs(v) do + if k ~= "name" and k ~= "section" and k:sub(1,1) ~= "." then + if k:match("^depends") then + t["depends"] = _assert( + self:_read_depency( v, t["depends"] ), + "Variable '%s' in scheme '%s' has malformed " .. + "depency specification in '%s'", + v.name, scheme, k + ) + elseif k:match("^validator") then + t["validators"] = _assert( + self:_read_validator( v, t["validators"] ), + "Variable '%s' in scheme '%s' has malformed " .. + "validator specification in '%s'", + v.name, scheme, k + ) + else + t[k] = v + end + end + end + end + end + end + + -- Step 3: get all enums + for i, conf in ipairs( schemes ) do + for k, v in pairs( conf ) do + if v['.type'] == "enum" then + + _req( TYPE_ENUM, v, { "value", "variable" } ) + + local r = _ref( TYPE_ENUM, v ) + + local p = _assert( stbl.packages[r[1]], + "Enum '%s' in scheme '%s' references unknown package '%s'", + v.value, scheme, r[1] ) + + local s = _assert( p.variables[r[2]], + "Enum '%s' in scheme '%s' references unknown section '%s'", + v.value, scheme, r[2] ) + + local t = _assert( s[r[3]], + "Enum '%s' in scheme '%s', section '%s' references " .. + "unknown variable '%s'", + v.value, scheme, r[2], r[3] ) + + _assert( t.type == "enum", + "Enum '%s' in scheme '%s', section '%s' references " .. + "variable '%s' with non enum type '%s'", + v.value, scheme, r[2], r[3], t.type ) + + if not t.values then + t.values = { [v.value] = v.title or v.value } + else + t.values[v.value] = v.title or v.value + end + + if v.default then + _assert( not t.default, + "Enum '%s' in scheme '%s', section '%s' redeclares " .. + "the default value of variable '%s'", + v.value, scheme, r[2], v.variable ) + + t.default = v.value + end + end + end + end + + return stbl +end + +-- Read a depency specification +function UVL._read_depency( self, value, deps ) + local parts = luci.util.split( value, "%s*;%s*" ) + local condition = { } + + for i, val in ipairs(parts) do + local k, v = unpack(luci.util.split( val, "%s*=%s*" )) + + if k and ( + k:match("^%$?[a-zA-Z0-9_]+%.%$?[a-zA-Z0-9_]+%.%$?[a-zA-Z0-9_]+$") + k:match("^%$?[a-zA-Z0-9_]+%.%$?[a-zA-Z0-9_]+$") or + k:match("^%$?[a-zA-Z0-9_]+$") or + ) then + condition[k] = v or true + else + return nil + end + end + + if not deps then + deps = { condition } + else + table.insert( deps, condition ) + end + + return deps +end + +-- Read a validator specification +function UVL._read_validator( self, value, validators ) + local validator + + if value and value:match("/") and self.datatypes.file(value) then + validator = value + else + validator = self:_resolve_function( value ) + end + + if validator then + if not validators then + validators = { validator } + else + table.insert( validators, validator ) + end + + return validators + end +end + +-- Resolve given path +function UVL._resolve_function( self, value ) + local path = luci.util.split(value, ".") + + for i=1, #path-1 do + local stat, mod = pcall(require, table.concat(path, ".", 1, i)) + if stat and mod then + for j=i+1, #path-1 do + if not type(mod) == "table" then + break; + end + mod = mod[path[j]] + if not mod then + break + end + end + mod = type(mod) == "table" and mod[path[#path]] or nil + if type(mod) == "function" then + return mod + end + end + end +end diff --git a/libs/uvl/luasrc/uvl/datatypes.lua b/libs/uvl/luasrc/uvl/datatypes.lua new file mode 100644 index 000000000..586e3f8b8 --- /dev/null +++ b/libs/uvl/luasrc/uvl/datatypes.lua @@ -0,0 +1,135 @@ +--[[ + +UCI Validation Layer - Datatype Tests +(c) 2008 Jo-Philipp Wich <xm@leipzig.freifunk.net> +(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 + +$Id$ + +]]-- + +module( "luci.uvl.datatypes", package.seeall ) + +require("luci.fs") +require("luci.ip") +require("luci.util") + + +function boolean( val ) + if val == "1" or val == "yes" or val == "on" then + return true + elseif val == "0" or val == "no" or val == "off" then + return true + end + + return false +end + +function integer( val ) + local n = tonumber(val) + if n ~= nil and math.floor(n) == n then + return true + end + + return false +end + +function float( val ) + return ( tonumber(val) ~= nil ) +end + +function ip4addr( val ) + if val then + return luci.ip.IPv4(val) and true or false + end + + return false +end + +function ip4prefix( val ) + val = tonumber(val) + return ( val and val >= 0 and val <= 32 ) +end + +function ip6addr( val ) + if val then + return luci.ip.IPv6(val) and true or false + end + + return false +end + +function ip6prefix( val ) + val = tonumber(val) + return ( val and val >= 0 and val <= 128 ) +end + +function macaddr( val ) + if val and val:match( + "^[a-fA-F0-9]+:[a-fA-F0-9]+:[a-fA-F0-9]+:" .. + "[a-fA-F0-9]+:[a-fA-F0-9]+:[a-fA-F0-9]+$" + ) then + local parts = luci.util.split( val, ":" ) + + for i = 1,6 do + parts[i] = tonumber( parts[i], 16 ) + if parts[i] < 0 or parts[i] > 255 then + return false + end + end + + return true + end + + return false +end + +function hostname( val ) + if val and val:match("[a-zA-Z0-9_][a-zA-Z0-9_%-%.]*") then + return true -- XXX: ToDo: need better solution + end + + return false +end + +function string( val ) + return true -- Everything qualifies as valid string +end + +function directory( val, seen ) + local s = luci.fs.stat( val ) + seen = seen or { } + + if s and not seen[s.ino] then + seen[s.ino] = true + if s.type == "directory" then + return true + elseif s.type == "link" then + return directory( luci.fs.readlink(val), seen ) + end + end + + return false +end + +function file( val, seen ) + local s = luci.fs.stat( val ) + seen = seen or { } + + if s and not seen[s.ino] then + seen[s.ino] = true + if s.type == "regular" then + return true + elseif s.type == "link" then + return file( luci.fs.readlink(val), seen ) + end + end + + return false +end |