libs/core/luasrc/ip.lua

   1 --[[
   2
   3 LuCI ip calculation libarary
   4 (c) 2008 Jo-Philipp Wich <xm@leipzig.freifunk.net>
   5 (c) 2008 Steven Barth <steven@midlink.org>
   6
   7 Licensed under the Apache License, Version 2.0 (the "License");
   8 you may not use this file except in compliance with the License.
   9 You may obtain a copy of the License at
  10
  11         http://www.apache.org/licenses/LICENSE-2.0
  12
  13 $Id$
  14
  15 ]]--
  16
  17 module( "luci.ip", package.seeall )
  18
  19 require("bit")
  20 require("luci.util")
  21
  22 LITTLE_ENDIAN = not luci.util.bigendian()
  23 BIG_ENDIAN    = not LITTLE_ENDIAN
  24
  25 FAMILY_INET4  = 0x04
  26 FAMILY_INET6  = 0x06
  27
  28
  29 local function __bless(x)
  30         return setmetatable( x, {
  31                 __index = luci.ip.cidr,
  32                 __add   = luci.ip.cidr.add,
  33                 __lt    = luci.ip.cidr.lower,
  34                 __eq    = luci.ip.cidr.equal,
  35                 __le    =
  36                         function(...)
  37                                 return luci.ip.cidr.equal(...) or luci.ip.cidr.lower(...)
  38                         end
  39         } )
  40 end
  41
  42 local function __mask16(bits)
  43         return bit.lshift(
  44                 bit.rshift( 0xFFFF, 16 - bits % 16 ),
  45                 16 - bits % 16
  46         )
  47 end
  48
  49 -- htons(), htonl(), ntohs(), ntohl()
  50
  51 function htons(x)
  52         if LITTLE_ENDIAN then
  53                 return bit.bor(
  54                         bit.rshift( x, 8 ),
  55                         bit.band( bit.lshift( x, 8 ), 0xFF00 )
  56                 )
  57         else
  58                 return x
  59         end
  60 end
  61
  62 function htonl(x)
  63         if LITTLE_ENDIAN then
  64                 return bit.bor(
  65                         bit.lshift( htons( bit.band( x, 0xFFFF ) ), 16 ),
  66                         htons( bit.rshift( x, 16 ) )
  67                 )
  68         else
  69                 return x
  70         end
  71 end
  72
  73 ntohs = htons
  74 ntohl = htonl
  75
  76
  77 function IPv4(address)
  78         local data = {}
  79         local prefix = address:match("/(.+)")
  80
  81         if prefix then
  82                 address = address:gsub("/.+","")
  83                 prefix = tonumber(prefix)
  84                 if not prefix or prefix < 0 or prefix > 32 then return nil end
  85         else
  86                 prefix = 32
  87         end
  88
  89         local b1, b2, b3, b4 = address:match("(%d+)%.(%d+)%.(%d+)%.(%d+)")
  90
  91         b1 = tonumber(b1)
  92         b2 = tonumber(b2)
  93         b3 = tonumber(b3)
  94         b4 = tonumber(b4)
  95
  96         if b1 and b1 <= 255 and
  97            b2 and b2 <= 255 and
  98            b3 and b3 <= 255 and
  99            b4 and b4 <= 255
 100         then
 101                 return __bless({
 102                         FAMILY_INET4,
 103                         { b1 * 256 + b2, b3 * 256 + b4 },
 104                         prefix
 105                 })
 106         end
 107 end
 108
 109 function IPv6(address)
 110         local data = {}
 111         local prefix = address:match("/(.+)")
 112
 113         if prefix then
 114                 address = address:gsub("/.+","")
 115                 prefix = tonumber(prefix)
 116                 if not prefix or prefix < 0 or prefix > 128 then return nil end
 117         else
 118                 prefix = 128
 119         end
 120
 121         local borderl = address:sub(1, 1) == ":" and 2 or 1
 122         local borderh, zeroh, chunk, block
 123
 124         if #address > 45 then return nil end
 125
 126         repeat
 127                 borderh = address:find(":", borderl, true)
 128                 if not borderh then break end
 129
 130                 block = tonumber(address:sub(borderl, borderh - 1), 16)
 131                 if block and block <= 65535 then
 132                         table.insert(data, block)
 133                 else
 134                         if zeroh or borderh - borderl > 1 then return nil end
 135                         zeroh = #data + 1
 136                 end
 137
 138                 borderl = borderh + 1
 139         until #data == 7
 140
 141         chunk = address:sub(borderl)
 142         if #chunk > 0 and #chunk <= 4 then
 143                 block = tonumber(chunk, 16)
 144                 if not block or block > 65535 then return nil end
 145
 146                 table.insert(data, block)
 147         elseif #chunk > 4 then
 148                 if #data == 7 or #chunk > 15 then return nil end
 149                 borderl = 1
 150                 for i=1, 4 do
 151                         borderh = chunk:find(".", borderl, true)
 152                         if not borderh and i < 4 then return nil end
 153                         borderh = borderh and borderh - 1
 154
 155                         block = tonumber(chunk:sub(borderl, borderh))
 156                         if not block or block > 255 then return nil end
 157
 158                         if i == 1 or i == 3 then
 159                                 table.insert(data, block * 256)
 160                         else
 161                                 data[#data] = data[#data] + block
 162                         end
 163
 164                         borderl = borderh and borderh + 2
 165                 end
 166         end
 167
 168         if zeroh then
 169                 if #data == 8 then return nil end
 170                 while #data < 8 do
 171                         table.insert(data, zeroh, 0)
 172                 end
 173         end
 174
 175         if #data == 8 then
 176                 return __bless({ FAMILY_INET6, data, prefix })
 177         end
 178 end
 179
 180
 181 cidr = luci.util.class()
 182
 183 function cidr.is4( self )
 184         return self[1] == FAMILY_INET4
 185 end
 186
 187 function cidr.is6( self )
 188         return self[1] == FAMILY_INET6
 189 end
 190
 191 function cidr.string( self )
 192         local str
 193         if self:is4() then
 194                 str = string.format(
 195                         "%d.%d.%d.%d",
 196                         bit.rshift(self[2][1], 8), bit.band(self[2][1], 0xFF),
 197                         bit.rshift(self[2][2], 8), bit.band(self[2][2], 0xFF)
 198                 )
 199                 if self[3] < 32 then
 200                         str = str .. "/" .. self[3]
 201                 end
 202         elseif self:is6() then
 203                 str = string.format( "%X:%X:%X:%X:%X:%X:%X:%X", unpack(self[2]) )
 204                 if self[3] < 128 then
 205                         str = str .. "/" .. self[3]
 206                 end
 207         end
 208         return str
 209 end
 210
 211 function cidr.lower( self, addr )
 212         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
 213         for i = 1, #self[2] do
 214                 if self[2][i] ~= addr[2][i] then
 215                         return self[2][i] < addr[2][i]
 216                 end
 217         end
 218         return false
 219 end
 220
 221 function cidr.higher( self, addr )
 222         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
 223         for i = 1, #self[2] do
 224                 if self[2][i] ~= addr[2][i] then
 225                         return self[2][i] > addr[2][i]
 226                 end
 227         end
 228         return false
 229 end
 230
 231 function cidr.equal( self, addr )
 232         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
 233         for i = 1, #self[2] do
 234                 if self[2][i] ~= addr[2][i] then
 235                         return false
 236                 end
 237         end
 238         return true
 239 end
 240
 241 function cidr.prefix( self )
 242         return self[3]
 243 end
 244
 245 function cidr.network( self )
 246         local data = { }
 247
 248         for i = 1, math.floor( self[3] / 16 ) do
 249                 table.insert( data, self[2][i] )
 250         end
 251
 252         table.insert( data, bit.band( self[2][1+#data], __mask16(self[3]) ) )
 253
 254         for i = #data, #self[2] do
 255                 table.insert( data, 0 )
 256         end
 257
 258         return __bless({ self[1], data, self:is4() and 32 or 128 })
 259 end
 260
 261 function cidr.host( self )
 262         return __bless({ self[1], data, self:is4() and 32 or 128 })
 263 end
 264
 265 function cidr.mask( self, bits )
 266         local data = { }
 267         bits = bits or self[3]
 268
 269         for i = 1, math.floor( bits / 16 ) do
 270                 table.insert( data, 0xFFFF )
 271         end
 272
 273         table.insert( data, __mask16(bits) )
 274
 275         for i = #data + 1, #self[2] do
 276                 table.insert( data, 0 )
 277         end
 278
 279         return __bless({ self[1], data, self:is4() and 32 or 128 })
 280 end
 281
 282 function cidr.contains( self, addr )
 283         if self:mask() <= addr:mask() then
 284                 return self:mask(addr:prefix()) == addr:mask()
 285         end
 286
 287         return false
 288 end
 289
 290 function cidr.add( self, amount )
 291         local shorts = { bit.rshift(amount, 16), bit.band(amount, 0xFFFF) }
 292         local data   = { unpack(self[2]) }
 293
 294         for pos = #data, 1, -1 do
 295                 local add = ( #shorts > 0 ) and table.remove( shorts, #shorts ) or 0
 296                 if ( data[pos] + add ) > 0xFFFF then
 297                         data[pos] = ( data[pos] + add ) % 0xFFFF
 298                         if pos > 2 then
 299                                 data[pos-1] = data[pos-1] + ( add - data[pos] )
 300                         end
 301                 else
 302                         data[pos] = data[pos] + add
 303                 end
 304         end
 305
 306         return __bless({ self[1], data, self:is4() and 32 and 128 })
 307 end