Module:IP/sandbox

-- IP library

-- This library contains classes for working with IP addresses and IP ranges.

-- Load modules

require('strict')

local bit32 = require('bit32')

local libraryUtil = require('libraryUtil')

local checkType = libraryUtil.checkType

local checkTypeMulti = libraryUtil.checkTypeMulti

local makeCheckSelfFunction = libraryUtil.makeCheckSelfFunction

-- Constants

local V4 = 'IPv4'

local V6 = 'IPv6'

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

-- Helper functions

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

local function makeValidationFunction(className, isObjectFunc)

-- Make a function for validating a specific object.

return function (methodName, argIdx, arg)

if not isObjectFunc(arg) then

error(string.format(

"bad argument #%d to '%s' (not a valid %s object)",

argIdx, methodName, className

), 3)

end

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

-- Collection class

-- This is a table used to hold items.

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

local Collection = {}

Collection.__index = Collection

function Collection:add(item)

if item ~= nil then

self.n = self.n + 1

self[self.n] = item

end

function Collection:join(sep)

return table.concat(self, sep)

end

function Collection:remove(pos)

if self.n > 0 and (pos == nil or (0 < pos and pos <= self.n)) then

self.n = self.n - 1

return table.remove(self, pos)

end

function Collection:sort(comp)

table.sort(self, comp)

end

function Collection:deobjectify()

-- Turns the collection into a plain array without any special properties

-- or methods.

self.n = nil

setmetatable(self, nil)

end

function Collection.new()

return setmetatable({n = 0}, Collection)

end

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

-- RawIP class

-- Numeric representation of an IPv4 or IPv6 address. Used internally.

-- A RawIP object is constructed by adding data to a Collection object and

-- then giving it a new metatable. This is to avoid the memory overhead of

-- copying the data to a new table.

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

local RawIP = {}

RawIP.__index = RawIP

-- Constructors

function RawIP.newFromIPv4(ipStr)

-- Return a RawIP object if ipStr is a valid IPv4 string. Otherwise,

-- return nil.

-- This representation is for compatibility with IPv6 addresses.

local octets = Collection.new()

local s = ipStr:match('^%s*(.-)%s*$') .. '.'

for item in s:gmatch('(.-)%.') do

octets:add(item)

end

if octets.n == 4 then

for i, s in ipairs(octets) do

if s:match('^%d+$') then

local num = tonumber(s)

if 0 <= num and num <= 255 then

if num > 0 and s:match('^0') then

-- A redundant leading zero is for an IP in octal.

return nil

end

octets[i] = num

else

return nil

end

else

return nil

end

local parts = Collection.new()

for i = 1, 3, 2 do

parts:add(octets[i] * 256 + octets[i+1])

end

return setmetatable(parts, RawIP)

end

return nil

end

function RawIP.newFromIPv6(ipStr)

-- Return a RawIP object if ipStr is a valid IPv6 string. Otherwise,

-- return nil.

ipStr = ipStr:match('^%s*(.-)%s*$')

local _, n = ipStr:gsub(':', ':')

if n < 7 then

ipStr = ipStr:gsub('::', string.rep(':', 9 - n))

end

local parts = Collection.new()

for item in (ipStr .. ':'):gmatch('(.-):') do

parts:add(item)

end

if parts.n == 8 then

for i, s in ipairs(parts) do

if s == '' then

parts[i] = 0

else

if s:match('^%x+$') then

local num = tonumber(s, 16)

if num and 0 <= num and num <= 65535 then

parts[i] = num

else

return nil

end

else

return nil

end

return setmetatable(parts, RawIP)

end

return nil

end

function RawIP.newFromIP(ipStr)

-- Return a new RawIP object from either an IPv4 string or an IPv6

-- string. If ipStr is not a valid IPv4 or IPv6 string, then return

-- nil.

return RawIP.newFromIPv4(ipStr) or RawIP.newFromIPv6(ipStr)

end

-- Methods

function RawIP:getVersion()

-- Return a string with the version of the IP protocol we are using.

return self.n == 2 and V4 or V6

end

function RawIP:isIPv4()

-- Return true if this is an IPv4 representation, and false otherwise.

return self.n == 2

end

function RawIP:isIPv6()

-- Return true if this is an IPv6 representation, and false otherwise.

return self.n == 8

end

function RawIP:getBitLength()

-- Return the bit length of the IP address.

return self.n * 16

end

function RawIP:getAdjacent(previous)

-- Return a RawIP object for an adjacent IP address. If previous is true

-- then the previous IP is returned; otherwise the next IP is returned.

-- Will wraparound:

-- next 255.255.255.255 → 0.0.0.0

-- ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff → ::

-- previous 0.0.0.0 → 255.255.255.255

-- :: → ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff

local result = Collection.new()

result.n = self.n

local carry = previous and 0xffff or 1

for i = self.n, 1, -1 do

local sum = self[i] + carry

if sum >= 0x10000 then

carry = previous and 0x10000 or 1

sum = sum - 0x10000

else

carry = previous and 0xffff or 0

end

result[i] = sum

end

return setmetatable(result, RawIP)

end

function RawIP:getPrefix(bitLength)

-- Return a RawIP object for the prefix of the current IP Address with a

-- bit length of bitLength.

local result = Collection.new()

result.n = self.n

for i = 1, self.n do

if bitLength > 0 then

if bitLength >= 16 then

result[i] = self[i]

bitLength = bitLength - 16

else

result[i] = bit32.replace(self[i], 0, 0, 16 - bitLength)

bitLength = 0

end

else

result[i] = 0

end

return setmetatable(result, RawIP)

end

function RawIP:getHighestHost(bitLength)

-- Return a RawIP object for the highest IP with the prefix of length

-- bitLength. In other words, the network (the most-significant bits)

-- is the same as the current IP's, but the host bits (the

-- least-significant bits) are all set to 1.

local bits = self.n * 16

local width

if bitLength <= 0 then

width = bits

elseif bitLength >= bits then

width = 0

else

width = bits - bitLength

end

local result = Collection.new()

result.n = self.n

for i = self.n, 1, -1 do

if width > 0 then

if width >= 16 then

result[i] = 0xffff

width = width - 16

else

result[i] = bit32.replace(self[i], 0xffff, 0, width)

width = 0

end

else

result[i] = self[i]

end

return setmetatable(result, RawIP)

end

function RawIP:_makeIPv6String()

-- Return an IPv6 string representation of the object. Behavior is

-- undefined if the current object is IPv4.

local z1, z2 -- indices of run of zeroes to be displayed as "::"

local zstart, zcount

for i = 1, 9 do

-- Find left-most occurrence of longest run of two or more zeroes.

if i < 9 and self[i] == 0 then

if zstart then

zcount = zcount + 1

else

zstart = i

zcount = 1

end

else

if zcount and zcount > 1 then

if not z1 or zcount > z2 - z1 + 1 then

z1 = zstart

z2 = zstart + zcount - 1

end

zstart = nil

zcount = nil

end

local parts = Collection.new()

for i = 1, 8 do

if z1 and z1 <= i and i <= z2 then

if i == z1 then

if z1 == 1 or z2 == 8 then

if z1 == 1 and z2 == 8 then

return '::'

end

parts:add(':')

else

parts:add('')

end

else

parts:add(string.format('%x', self[i]))

end

return parts:join(':')

end

function RawIP:_makeIPv4String()

-- Return an IPv4 string representation of the object. Behavior is

-- undefined if the current object is IPv6.

local parts = Collection.new()

for i = 1, 2 do

local w = self[i]

parts:add(math.floor(w / 256))

parts:add(w % 256)

end

return parts:join('.')

end

function RawIP:__tostring()

-- Return a string equivalent to given IP address (IPv4 or IPv6).

if self.n == 2 then

return self:_makeIPv4String()

else

return self:_makeIPv6String()

end

function RawIP:__lt(obj)

if self.n == obj.n then

for i = 1, self.n do

if self[i] ~= obj[i] then

return self[i] < obj[i]

end

return false

end

return self.n < obj.n

end

function RawIP:__eq(obj)

if self.n == obj.n then

for i = 1, self.n do

if self[i] ~= obj[i] then

return false

end

return true

end

return false

end

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

-- Initialize private methods available to IPAddress and Subnet

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

-- Both IPAddress and Subnet need access to each others' private constructor

-- functions. IPAddress must be able to make Subnet objects from CIDR strings

-- and from RawIP objects, and Subnet must be able to make IPAddress objects

-- from IP strings and from RawIP objects. These constructors must all be

-- private to ensure correct error levels and to stop other modules from having

-- to worry about RawIP objects. Because they are private, they must be

-- initialized here.

local makeIPAddress, makeIPAddressFromRaw, makeSubnet, makeSubnetFromRaw

-- Objects need to be able to validate other objects that they are passed

-- as input, so initialize those functions here as well.

local validateCollection, validateIPAddress, validateSubnet

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

-- IPAddress class

-- Represents a single IPv4 or IPv6 address.

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

local IPAddress = {}

-- dataKey is a unique key to access objects' internal data. This is needed

-- to access the RawIP objects contained in other IPAddress objects so that

-- they can be compared with the current object's RawIP object. This data

-- is not available to other classes or other modules.

local dataKey = {}

-- Private static methods

local function isIPAddressObject(val)

return type(val) == 'table' and val[dataKey] ~= nil

end

validateIPAddress = makeValidationFunction('IPAddress', isIPAddressObject)

-- Metamethods that don't need upvalues

local function ipEquals(ip1, ip2)

return ip1[dataKey].rawIP == ip2[dataKey].rawIP

end

local function ipLessThan(ip1, ip2)

return ip1[dataKey].rawIP < ip2[dataKey].rawIP

end

local function concatIP(ip, val)

return tostring(ip) .. tostring(val)

end

local function ipToString(ip)

return ip:getIP()

end

-- Constructors

makeIPAddressFromRaw = function (rawIP)

-- Constructs a new IPAddress object from a rawIP object. This function

-- is for internal use; it is called by IPAddress.new and from other

-- IPAddress methods, and should be available to the Subnet class, but

-- should not be available to other modules.

assert(type(rawIP) == 'table', 'rawIP was type ' .. type(rawIP) .. '; expected type table')

-- Set up structure

local obj = {}

local data = {}

data.rawIP = rawIP

-- A function to check whether methods are called with a valid self

-- parameter.

local checkSelf = makeCheckSelfFunction(

'IP',

'ipAddress',

obj,

'IPAddress object'

)

-- Public methods

function obj:getIP()

checkSelf(self, 'getIP')

return tostring(data.rawIP)

end

function obj:getVersion()

checkSelf(self, 'getVersion')

return data.rawIP:getVersion()

end

function obj:isIPv4()

checkSelf(self, 'isIPv4')

return data.rawIP:isIPv4()

end

function obj:isIPv6()

checkSelf(self, 'isIPv6')

return data.rawIP:isIPv6()

end

function obj:isInCollection(collection)

checkSelf(self, 'isInCollection')

validateCollection('isInCollection', 1, collection)

return collection:containsIP(self)

end

function obj:isInSubnet(subnet)

checkSelf(self, 'isInSubnet')

local tp = type(subnet)

if tp == 'string' then

subnet = makeSubnet(subnet)

elseif tp == 'table' then

validateSubnet('isInSubnet', 1, subnet)

else

checkTypeMulti('isInSubnet', 1, subnet, {'string', 'table'})

end

return subnet:containsIP(self)

end

function obj:getSubnet(bitLength)

checkSelf(self, 'getSubnet')

checkType('getSubnet', 1, bitLength, 'number')

if bitLength < 0

or bitLength > data.rawIP:getBitLength()

or bitLength ~= math.floor(bitLength)

then

error(string.format(

"bad argument #1 to 'getSubnet' (must be an integer between 0 and %d)",

data.rawIP:getBitLength()

), 2)

end

return makeSubnetFromRaw(data.rawIP, bitLength)

end

function obj:getNextIP()

checkSelf(self, 'getNextIP')

return makeIPAddressFromRaw(data.rawIP:getAdjacent())

end

function obj:getPreviousIP()

checkSelf(self, 'getPreviousIP')

return makeIPAddressFromRaw(data.rawIP:getAdjacent(true))

end

-- Metamethods

return setmetatable(obj, {

__eq = ipEquals,

__lt = ipLessThan,

__concat = concatIP,

__tostring = ipToString,

__index = function (self, key)

-- If any code knows the unique data key, allow it to access

-- the data table.

if key == dataKey then

return data

end

end,

__metatable = false, -- don't allow access to the metatable

})

end

makeIPAddress = function (ip)

local rawIP = RawIP.newFromIP(ip)

if not rawIP then

error(string.format("'%s' is an invalid IP address", ip), 3)

end

return makeIPAddressFromRaw(rawIP)

end

function IPAddress.new(ip)

checkType('IPAddress.new', 1, ip, 'string')

return makeIPAddress(ip)

end

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

-- Subnet class

-- Represents a block of IPv4 or IPv6 addresses.

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

local Subnet = {}

-- uniqueKey is a unique, private key used to test whether a given object

-- is a Subnet object.

local uniqueKey = {}

-- Metatable

local mt = {

__index = function (self, key)

if key == uniqueKey then

return true

end

end,

__eq = function (self, obj)

return self:getCIDR() == obj:getCIDR()

end,

__concat = function (self, obj)

return tostring(self) .. tostring(obj)

end,

__tostring = function (self)

return self:getCIDR()

end,

__metatable = false

}

-- Private static methods

local function isSubnetObject(val)

-- Return true if val is a Subnet object, and false otherwise.

return type(val) == 'table' and val[uniqueKey] ~= nil

end

-- Function to validate subnet objects.

-- Params:

-- methodName (string) - the name of the method being validated

-- argIdx (number) - the position of the argument in the argument list

-- arg - the argument to be validated

validateSubnet = makeValidationFunction('Subnet', isSubnetObject)

-- Constructors

makeSubnetFromRaw = function (rawIP, bitLength)

-- Set up structure

local obj = setmetatable({}, mt)

local data = {

rawIP = rawIP,

bitLength = bitLength,

}

-- A function to check whether methods are called with a valid self

-- parameter.

local checkSelf = makeCheckSelfFunction(

'IP',

'subnet',

obj,

'Subnet object'

)

-- Public methods

function obj:getPrefix()

checkSelf(self, 'getPrefix')

if not data.prefix then

data.prefix = makeIPAddressFromRaw(

data.rawIP:getPrefix(data.bitLength)

)

end

return data.prefix

end

function obj:getHighestIP()

checkSelf(self, 'getHighestIP')

if not data.highestIP then

data.highestIP = makeIPAddressFromRaw(

data.rawIP:getHighestHost(data.bitLength)

)

end

return data.highestIP

end

function obj:getBitLength()

checkSelf(self, 'getBitLength')

return data.bitLength

end

function obj:getCIDR()

checkSelf(self, 'getCIDR')

return string.format(

'%s/%d',

tostring(self:getPrefix()), self:getBitLength()

)

end

function obj:getVersion()

checkSelf(self, 'getVersion')

return data.rawIP:getVersion()

end

function obj:isIPv4()

checkSelf(self, 'isIPv4')

return data.rawIP:isIPv4()

end

function obj:isIPv6()

checkSelf(self, 'isIPv6')

return data.rawIP:isIPv6()

end

function obj:containsIP(ip)

checkSelf(self, 'containsIP')

local tp = type(ip)

if tp == 'string' then

ip = makeIPAddress(ip)

elseif tp == 'table' then

validateIPAddress('containsIP', 1, ip)

else

checkTypeMulti('containsIP', 1, ip, {'string', 'table'})

end

if self:getVersion() == ip:getVersion() then

return self:getPrefix() <= ip and ip <= self:getHighestIP()

end

return false

end

function obj:overlapsCollection(collection)

checkSelf(self, 'overlapsCollection')

validateCollection('overlapsCollection', 1, collection)

return collection:overlapsSubnet(self)

end

function obj:overlapsSubnet(subnet)

checkSelf(self, 'overlapsSubnet')

local tp = type(subnet)

if tp == 'string' then

subnet = makeSubnet(subnet)

elseif tp == 'table' then

validateSubnet('overlapsSubnet', 1, subnet)

else

checkTypeMulti('overlapsSubnet', 1, subnet, {'string', 'table'})

end

if self:getVersion() == subnet:getVersion() then

return (

subnet:getHighestIP() >= self:getPrefix() and

subnet:getPrefix() <= self:getHighestIP()

)

end

return false

end

function obj:walk()

checkSelf(self, 'walk')

local started

local current = self:getPrefix()

local highest = self:getHighestIP()

return function ()

if not started then

started = true

return current

end

if current < highest then

current = current:getNextIP()

return current

end

return obj

end

makeSubnet = function (cidr)

-- Return a Subnet object from a CIDR string. If the CIDR string is

-- invalid, throw an error.

local lhs, rhs = cidr:match('^%s*(.-)/(%d+)%s*$')

if lhs then

local bits = lhs:find(':', 1, true) and 128 or 32

local n = tonumber(rhs)

if n and n <= bits and (n == 0 or not rhs:find('^0')) then

-- The right-hand side is a number between 0 and 32 (for IPv4)

-- or 0 and 128 (for IPv6) and doesn't have any leading zeroes.

local base = RawIP.newFromIP(lhs)

if base then

-- The left-hand side is a valid IP address.

local prefix = base:getPrefix(n)

if base == prefix then

-- The left-hand side is the lowest IP in the subnet.

return makeSubnetFromRaw(prefix, n)

end

error(string.format("'%s' is an invalid CIDR string", cidr), 3)

end

function Subnet.new(cidr)

checkType('Subnet.new', 1, cidr, 'string')

return makeSubnet(cidr)

end

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

-- Ranges class

-- Holds a list of IPAdress pairs representing contiguous IP ranges.

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

local Ranges = Collection.new()

Ranges.__index = Ranges

function Ranges.new()

return setmetatable({}, Ranges)

end

function Ranges:add(ip1, ip2)

validateIPAddress('add', 1, ip1)

if ip2 ~= nil then

validateIPAddress('add', 2, ip2)

if ip1 > ip2 then

error('The first IP must be less than or equal to the second', 2)

end

Collection.add(self, {ip1, ip2 or ip1})

end

function Ranges:merge()

self:sort(

function (lhs, rhs)

-- Sort by second value, then first.

if lhs[2] == rhs[2] then

return lhs[1] < rhs[1]

end

return lhs[2] < rhs[2]

end

)

local pos = self.n

while pos > 1 do

for i = pos - 1, 1, -1 do

local ip1 = self[i][2]

local ip2 = ip1:getNextIP()

if ip2 < ip1 then

ip2 = ip1 -- don't wrap around

end

if self[pos][1] > ip2 then

break

end

ip1 = self[i][1]

ip2 = self[pos][1]

self[i] = {ip1 > ip2 and ip2 or ip1, self[pos][2]}

self:remove(pos)

pos = pos - 1

if pos <= 1 then

break

end

pos = pos - 1

end

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

-- IPCollection class

-- Holds a list of IP addresses/subnets. Used internally.

-- Each address/subnet has the same version (either IPv4 or IPv6).

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

local IPCollection = {}

IPCollection.__index = IPCollection

function IPCollection.new(version)

assert(

version == V4 or version == V6,

'IPCollection.new called with an invalid version'

)

local obj = {

version = version, -- V4 or V6

addresses = Collection.new(), -- valid IP addresses

subnets = Collection.new(), -- valid subnets

omitted = Collection.new(), -- not-quite valid strings

}

return obj

end

function IPCollection:getVersion()

-- Return a string with the IP version of addresses in this collection.

return self.version

end

function IPCollection:_store(hit, stripColons)

local maker, location

if hit:find('/', 1, true) then

maker = Subnet.new

location = self.subnets

else

maker = IPAddress.new

location = self.addresses

end

local success, obj = pcall(maker, hit)

if success then

location:add(obj)

else

if stripColons then

local colons, hit = hit:match('^(:*)(.*)')

if colons ~= '' then

self:_store(hit)

return

end

self.omitted:add(hit)

end

function IPCollection:_assertVersion(version, msg)

if self.version ~= version then

error(msg, 3)

end

function IPCollection:addIP(ip)

local tp = type(ip)

if tp == 'string' then

ip = makeIPAddress(ip)

elseif tp == 'table' then

validateIPAddress('addIP', 1, ip)

else

checkTypeMulti('addIP', 1, ip, {'string', 'table'})

end

self:_assertVersion(ip:getVersion(), 'addIP called with incorrect IP version')

self.addresses:add(ip)

return self

end

function IPCollection:addSubnet(subnet)

local tp = type(subnet)

if tp == 'string' then

subnet = makeSubnet(subnet)

elseif tp == 'table' then

validateSubnet('addSubnet', 1, subnet)

else

checkTypeMulti('addSubnet', 1, subnet, {'string', 'table'})

end

self:_assertVersion(subnet:getVersion(), 'addSubnet called with incorrect subnet version')

self.subnets:add(subnet)

return self

end

function IPCollection:containsIP(ip)

-- Return true, obj if ip is in this collection,

-- where obj is the first IPAddress or Subnet with the ip.

-- Otherwise, return false.

local tp = type(ip)

if tp == 'string' then

ip = makeIPAddress(ip)

elseif tp == 'table' then

validateIPAddress('containsIP', 1, ip)

else

checkTypeMulti('containsIP', 1, ip, {'string', 'table'})

end

if self:getVersion() == ip:getVersion() then

for _, item in ipairs(self.addresses) do

if item == ip then

return true, item

end

for _, item in ipairs(self.subnets) do

if item:containsIP(ip) then

return true, item

end

return false

end

function IPCollection:getRanges()

-- Return a sorted table of IP pairs equivalent to the collection.

-- Each IP pair is a table representing a contiguous range of

-- IP addresses from pair[1] to pair[2] inclusive (IPAddress objects).

local ranges = Ranges.new()

for _, item in ipairs(self.addresses) do

ranges:add(item)

end

for _, item in ipairs(self.subnets) do

ranges:add(item:getPrefix(), item:getHighestIP())

end

ranges:merge()

ranges:deobjectify()

return ranges

end

function IPCollection:overlapsSubnet(subnet)

-- Return true, obj if subnet overlaps this collection,

-- where obj is the first IPAddress or Subnet overlapping the subnet.

-- Otherwise, return false.

local tp = type(subnet)

if tp == 'string' then

subnet = makeSubnet(subnet)

elseif tp == 'table' then

validateSubnet('overlapsSubnet', 1, subnet)

else

checkTypeMulti('overlapsSubnet', 1, subnet, {'string', 'table'})

end

if self:getVersion() == subnet:getVersion() then

for _, item in ipairs(self.addresses) do

if subnet:containsIP(item) then

return true, item

end

for _, item in ipairs(self.subnets) do

if subnet:overlapsSubnet(item) then

return true, item

end

return false

end

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

-- IPv4Collection class

-- Holds a list of IPv4 addresses/subnets.

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

local IPv4Collection = setmetatable({}, IPCollection)

IPv4Collection.__index = IPv4Collection

function IPv4Collection.new()

return setmetatable(IPCollection.new(V4), IPv4Collection)

end

function IPv4Collection:addFromString(text)

-- Extract any IPv4 addresses or CIDR subnets from given text.

checkType('addFromString', 1, text, 'string')

text = text:gsub('[:!"#&\'()+,%-;<=>?[%]_

}]', ' ')

for hit in text:gmatch('%S+') do

if hit:match('^%d+%.%d+[%.%d/]+$') then

local _, n = hit:gsub('%.', '.')

if n >= 3 then

self:_store(hit)

end

return self

end

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

-- IPv6Collection class

-- Holds a list of IPv6 addresses/subnets.

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

local IPv6Collection = setmetatable({}, IPCollection)

IPv6Collection.__index = IPv6Collection

-- Private static methods

local function isCollectionObject(val)

-- Return true if val is probably derived from an IPCollection object,

-- otherwise return false.

if type(val) == 'table' then

local mt = getmetatable(val)

if mt == IPv4Collection or mt == IPv6Collection then

return true

end

return false

end

validateCollection = makeValidationFunction('IPCollection', isCollectionObject)

function IPv6Collection.new()

return setmetatable(IPCollection.new(V6), IPv6Collection)

end

function IPv6Collection:addFromString(text)

-- Extract any IPv6 addresses or CIDR subnets from given text.

-- Want to accept all valid IPv6 despite the fact that addresses used

-- are unlikely to start with ':'.

-- Also want to be able to parse arbitrary wikitext which might use

-- colons for indenting.

-- Therefore, if an address at the start of a line is valid, use it;

-- otherwise strip any leading colons and try again.

checkType('addFromString', 1, text, 'string')

for line in string.gmatch(text .. '\n', '[\t ]*(.-)[\t\r ]*\n') do

line = line:gsub('[!"#&\'()+,%-;<=>?[%]_{

]', ' ')

for position, hit in line:gmatch('()(%S+)') do

local ip = hit:match('^([:%x]+)/?%d*$')

if ip then

local _, n = ip:gsub(':', ':')

if n >= 2 then

self:_store(hit, position == 1)

end

return self

end

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

-- Util class (static)

-- Holds utility functions.

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

local Util = {}

function Util.removeDirMarkers(str)

-- Remove any of following directional markers

-- LRM : LEFT-TO-RIGHT MARK (U+200E) : hex e2 80 8e = 226 128 142

-- LRE : LEFT-TO-RIGHT EMBEDDING (U+202A) : hex e2 80 aa = 226 128 170

-- PDF : POP DIRECTIONAL FORMATTING (U+202C) : hex e2 80 ac = 226 128 172

-- This is required for MediaWiki:Blockedtext message.

return string.gsub(str, '\226\128[\142\170\172]', '')

end

local function correctCidr(cidrStr)

-- Correct a well-formatted but invalid CIDR string to a valid one (e.g. 255.255.255.1/24 -> 255.255.255.0/24).

-- Return a Subnet object only if correction takes place.

local isCidr, cidr = pcall(Subnet.new, cidrStr)

local i, _ = string.find(cidrStr, '/%d+$');

if not isCidr and i ~= nil and i > 1 then

local bitLen = tonumber(cidrStr:sub(i + 1))

local root = cidrStr:sub(1, i - 1)

local isIp, ip = pcall(IPAddress.new, root)

if isIp then

local isValidSubnet = ip:isIPv4() and 0 <= bitLen and bitLen <= 32 or ip:isIPv6() and 0 <= bitLen and bitLen <= 128

if isValidSubnet then

return ip:getSubnet(bitLen)

end

return nil

end

local function isSpecifiedProtocol(obj, protocol)

-- Check if a given IPAddress/Subnet object is an instance of IPv4, IPv6, or either, and return a boolean value.

if protocol == 'v4' then

return obj:isIPv4()

elseif protocol == 'v6' then

return obj:isIPv6()

else

return obj:isIPv4() or obj:isIPv6()

end

local function verifyIP(str, allowCidr, cidrOnly, protocol)

-- Return 3 values: boolean, string, string/nil.

-- v[1] is the result of whether the input string is an IP address or CIDR of the specified protocol (IPv4, IPv6, or either).

-- v[2] is the input string.

-- v[3] is a corrected CIDR string only if allowCidr or cidrOnly is true AND v[1] is true AND the input string is in a possible

-- CIDR format but doesn't actually work as a CIDR and hence is corrected to a valid one (e.g. 1.2.3.4/24 -> 1.2.3.0/24).

str = Util.removeDirMarkers(str)

if cidrOnly == true then allowCidr = true end -- Ignores the value of allowCidr if cidrOnly is true

if allowCidr then

local corCidr = correctCidr(str)

local corrected = corCidr ~= nil

local isCidr, cidr

if corrected then

isCidr, cidr = true, corCidr

else

isCidr, cidr = pcall(Subnet.new, str)

end

if isCidr then -- The input (or corrected) string represents a valid CIDR

isCidr = isSpecifiedProtocol(cidr, protocol)

return isCidr, str, (function() if isCidr and corrected then return cidr:getCIDR() end end)()

elseif cidrOnly then -- Invalid as a CIDR

return false, str, nil

end

local isIp, ip = pcall(IPAddress.new, str)

if isIp then

isIp = isSpecifiedProtocol(ip, protocol)

end

return isIp, str, nil

end

function Util.isIPAddress(str, allowCidr, cidrOnly)

return verifyIP(str, allowCidr, cidrOnly, nil)

end

function Util.isIPv4Address(str, allowCidr, cidrOnly)

return verifyIP(str, allowCidr, cidrOnly, 'v4')

end

function Util.isIPv6Address(str, allowCidr, cidrOnly)

return verifyIP(str, allowCidr, cidrOnly, 'v6')

end

return {

IPAddress = IPAddress,

Subnet = Subnet,

IPv4Collection = IPv4Collection,

IPv6Collection = IPv6Collection,

Util = Util

}