Module:IP: Difference between revisions

From the Croc Wiki, the Croc encyclopedia
Jump to navigationJump to search

Module:IP (view source)

Revision as of 04:15, July 23, 2016

5,334 bytes added ,  7 years ago
need to use __index to have a unique key which is really private - if outside code gets uniqueKey with getmetatable then they can set it in another table's __eq metamethod, thus foiling isSubnetObject
(add more methods to RawIP and rework IPAddress and Subnet to use them)
(need to use __index to have a unique key which is really private - if outside code gets uniqueKey with getmetatable then they can set it in another table's __eq metamethod, thus foiling isSubnetObject)
 
(30 intermediate revisions by 2 users not shown)
Line 7:
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
end
end
 
--------------------------------------------------------------------------------
Line 46 ⟶ 64:
-- Constructors
function RawIP.newFromIPv4(ipStr)
-- ReturnsReturn a RawIP object if ipStr is a valid IPv4 string. Otherwise,
-- returnsreturn nil.
-- This representation is for compatibility with IPv6 addresses.
local octets = Collection()
Line 61 ⟶ 79:
if num > 0 and s:match('^0') then
-- A redundant leading zero is for an IP in octal.
return falsenil
end
octets[i] = num
else
return falsenil
end
else
return falsenil
end
end
Line 79 ⟶ 97:
return nil
end
 
function RawIP.newFromIPv6(ipStr)
-- IfReturn a RawIP object if ipStr is a valid IPv6 string. Otherwise, return a collection of its parts.
-- Otherwise, return nil.
ipStr = ipStr:match('^%s*(.-)%s*$')
local _, n = ipStr:gsub(':', ':')
Line 97 ⟶ 115:
parts[i] = 0
else
local num = tonumber('0x's, .. s16)
if num and 0 <= num and num <= 65535 then
parts[i] = num
Line 119 ⟶ 137:
-- 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
Line 140 ⟶ 161:
local result = Collection()
result.n = self.n
local carry = downprevious and 0xffff or 1
for i = self.n, 1, -1 do
local sum = self[i] + carry
if sum >= 0x10000 then
carry = downprevious and 0x10000 or 1
sum = sum - 0x10000
else
carry = downprevious and 0xffff or 0
end
result[i] = sum
Line 165 ⟶ 186:
bitLength = bitLength - 16
else
result[i] = bit32.bandreplace(self[i], 0, 0, 16 - bitLength)
bit32.arshift(0xffff8000, bitLength - 1))
bitLength = 0
end
Line 198 ⟶ 218:
width = width - 16
else
result[i] = bit32.replace(self[i], 0xffff, width - 10, width)
width = 0
end
Line 209 ⟶ 229:
 
function RawIP:_makeIPv6String()
-- Return an IPv6 string representation of the object. Behavior is undefined
-- undefined if the current object is IPv4.
local z1, z2 -- indices of run of zeros to be displayed as "::"
local zstart, zcount
Line 254 ⟶ 274:
 
function RawIP:_makeIPv4String()
-- Return an IPv4 string representation of the object. Behavior is undefined
-- undefined if the current object is IPv6.
local parts = Collection()
for i = 1, 2 do
Line 300 ⟶ 320:
 
--------------------------------------------------------------------------------
-- Initialize private methods available to IPAddress and Subnet
-- Set up classes to be exported
--------------------------------------------------------------------------------
 
-- TheBoth IPAddress class and the Subnet classneed shouldaccess beto accessibleeach fromothers' eachprivate constructor
-- functions. IPAddress must be able to make Subnet objects from CIDR strings
-- other, but should not be accessible from the RawIP class, so initialize them
-- and from RawIP objects, and Subnet must be able to make IPAddress objects
-- here.
-- from IP strings and from RawIP objects. These constructors must all be
local IPAddress, Subnet = {}, {}
-- 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
 
-- IPAddress needsand toSubnet createalso Subnetneed objectsto usingbe itsable RawIPto data,validate Subnet and SubnetIPAddress
-- objects that they are passed as input, so initialize those functions here
-- needs to create IPAddress objects with its RawIP data as well. However,
-- as well.
-- other modules shouldn't have to worry about RawIP data, so the constructors
local validateIPAddress, validateSubnet
-- need to be private. Hence the variables holding the constructor functions
-- need to be initialized here as well.
local makeIPAddress, makeSubnet
 
--------------------------------------------------------------------------------
Line 319 ⟶ 341:
-- Represents a single IPv4 or IPv6 address.
--------------------------------------------------------------------------------
 
local IPAddress = {}
 
do
local-- dataKey =is {} -- Aa 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
Line 332 ⟶ 367:
end
 
local function concatIPsconcatIP(ip1ip, ip2val)
return ip1:getIPtostring(ip) .. ip2:getIPtostring(val)
end
 
Line 341 ⟶ 376:
 
-- Constructors
makeIPAddressmakeIPAddressFromRaw = 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
Line 352 ⟶ 387:
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: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')
return makeSubnetFromRaw(data.rawIP, bitLength)
end
 
function obj:getNextIP()
checkSelf(self, 'getNextIP')
return makeIPAddress(data.rawIP:getAdjacent())
return makeIPAddressFromRaw(data.rawIP:getAdjacent())
end
 
function obj:getPreviousIP()
checkSelf(self, 'getPreviousIP')
return makeIPAddress(data.rawIP:getAdjacent(true))
return makeIPAddressFromRaw(data.rawIP:getAdjacent(true))
end
 
Line 386 ⟶ 451:
__eq = ipEquals,
__lt = ipLessThan,
__concat = concatIPsconcatIP,
__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 IPAddress.new(ip)
checkType('IPAddress.new', 1, ip, 'string')
local rawIP = RawIP.newFromIP(ip)
if not rawIP then
error(string.format("'%s' is an invalid IP address", ip), 23)
end
return makeIPAddressmakeIPAddressFromRaw(rawIP)
end
 
function IPAddress.new(ip)
checkType('IPAddress.new', 1, ip, 'string')
return makeIPAddress(ip)
end
end
Line 410 ⟶ 482:
-- Represents a block of IPv4 or IPv6 addresses.
--------------------------------------------------------------------------------
 
local Subnet = {}
 
do
-- uniqueKey is a unique, private key used to test whether a given object
-- Initialize metatable
-- is a Subnet object.
local mt = {}
local uniqueKey = setmetatable({}, {__metatable = false})
 
-- Private static methods
local function isSubnetObject(val)
-- Return true if val is a Subnet object, and false otherwise.
return getmetatable(val) == uniqueKey
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)
 
-- Metamethods that don't need upvalues
local function subnetEquals(subnet1, subnet2)
return subnet1:getCIDR() == subnet2:getCIDR()
end
 
local function concatenateSubnets(subnet1, subnet2)
return tostring(subnet1) .. tostring(subnet2)
end
 
local function subnetToString(subnet)
return subnet:getCIDR()
end
 
-- Constructors
makeSubnetmakeSubnetFromRaw = 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 = makeIPAddressmakeIPAddressFromRaw(
data.rawIP:getPrefix(data.bitLength)
)
Line 435 ⟶ 546:
 
function obj:getHighestIP()
checkSelf(self, 'getHighestIP')
if not data.highestIP then
data.highestIP = makeIPAddressmakeIPAddressFromRaw(
data.rawIP:getHighestHost(data.bitLength)
)
Line 444 ⟶ 556:
 
function obj:getBitLength()
checkSelf(self, 'getBitLength')
return data.bitLength
end
 
function obj:getCIDR()
checkSelf(self, 'getCIDR')
return string.format(
'%s/%d',
Line 455 ⟶ 569:
 
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()
Line 474 ⟶ 600:
 
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 (
Line 483 ⟶ 618:
end
 
returnfunction 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
end
end
 
return setmetatable(obj, {
__index = function (self, key)
if key == uniqueKey then
return true
end
end,
__eq = subnetEquals,
__concat = concatenateSubnets,
__tostring = subnetToString,
__metatable = false,
})
end
 
makeSubnet = function Subnet.new(cidr)
checkType('-- Return a Subnet object from a CIDR string.new', 1,If cidr,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
local prefix = base:getPrefix(n)
-- The left-hand side is a valid IP address.
if base == prefix then
returnlocal makeSubnet(prefix, = base:getPrefix(n)
if base == prefix then
-- The left-hand side is the lowest IP in the subnet.
return makeSubnetFromRaw(prefix, n)
end
end
end
end
error(string.format("'%s' is an invalid CIDR string", cidr), 23)
end
 
function Subnet.new(cidr)
-- Metamethods
checkType('Subnet.new', 1, cidr, 'string')
function mt:__eq(obj)
return self:getCIDR() == obj:getCIDRmakeSubnet(cidr)
end
 
function mt:__tostring()
return self:getCIDR()
end
end
Retrieved from "https://crocwiki.com/wiki/Special:MobileDiff/30982...31013"
Cookies help us deliver our services. By using our services, you agree to our use of cookies.
More information

Navigation menu