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, netmask)
  78         address = address or "0.0.0.0/0"
  79
  80         local obj = __bless({ FAMILY_INET4 })
  81
  82         local data = {}
  83         local prefix = address:match("/(.+)")
  84
  85         if netmask then
  86                 prefix = obj:prefix(netmask)
  87         elseif prefix then
  88                 address = address:gsub("/.+","")
  89                 prefix = tonumber(prefix)
  90                 if not prefix or prefix < 0 or prefix > 32 then return nil end
  91         else
  92                 prefix = 32
  93         end
  94
  95         local b1, b2, b3, b4 = address:match("^(%d+)%.(%d+)%.(%d+)%.(%d+)$")
  96
  97         b1 = tonumber(b1)
  98         b2 = tonumber(b2)
  99         b3 = tonumber(b3)
 100         b4 = tonumber(b4)
 101
 102         if b1 and b1 <= 255 and
 103            b2 and b2 <= 255 and
 104            b3 and b3 <= 255 and
 105            b4 and b4 <= 255 and
 106            prefix
 107         then
 108                 table.insert(obj, { b1 * 256 + b2, b3 * 256 + b4 })
 109                 table.insert(obj, prefix)
 110                 return obj
 111         end
 112 end
 113
 114 function IPv6(address, netmask)
 115         address = address or "::/0"
 116
 117         local obj = __bless({ FAMILY_INET6 })
 118
 119         local data = {}
 120         local prefix = address:match("/(.+)")
 121
 122         if netmask then
 123                 prefix = obj:prefix(netmask)
 124         elseif prefix then
 125                 address = address:gsub("/.+","")
 126                 prefix = tonumber(prefix)
 127                 if not prefix or prefix < 0 or prefix > 128 then return nil end
 128         else
 129                 prefix = 128
 130         end
 131
 132         local borderl = address:sub(1, 1) == ":" and 2 or 1
 133         local borderh, zeroh, chunk, block
 134
 135         if #address > 45 then return nil end
 136
 137         repeat
 138                 borderh = address:find(":", borderl, true)
 139                 if not borderh then break end
 140
 141                 block = tonumber(address:sub(borderl, borderh - 1), 16)
 142                 if block and block <= 65535 then
 143                         table.insert(data, block)
 144                 else
 145                         if zeroh or borderh - borderl > 1 then return nil end
 146                         zeroh = #data + 1
 147                 end
 148
 149                 borderl = borderh + 1
 150         until #data == 7
 151
 152         chunk = address:sub(borderl)
 153         if #chunk > 0 and #chunk <= 4 then
 154                 block = tonumber(chunk, 16)
 155                 if not block or block > 65535 then return nil end
 156
 157                 table.insert(data, block)
 158         elseif #chunk > 4 then
 159                 if #data == 7 or #chunk > 15 then return nil end
 160                 borderl = 1
 161                 for i=1, 4 do
 162                         borderh = chunk:find(".", borderl, true)
 163                         if not borderh and i < 4 then return nil end
 164                         borderh = borderh and borderh - 1
 165
 166                         block = tonumber(chunk:sub(borderl, borderh))
 167                         if not block or block > 255 then return nil end
 168
 169                         if i == 1 or i == 3 then
 170                                 table.insert(data, block * 256)
 171                         else
 172                                 data[#data] = data[#data] + block
 173                         end
 174
 175                         borderl = borderh and borderh + 2
 176                 end
 177         end
 178
 179         if zeroh then
 180                 if #data == 8 then return nil end
 181                 while #data < 8 do
 182                         table.insert(data, zeroh, 0)
 183                 end
 184         end
 185
 186         if #data == 8 and prefix then
 187                 table.insert(obj, data)
 188                 table.insert(obj, prefix)
 189                 return obj
 190         end
 191 end
 192
 193
 194 cidr = luci.util.class()
 195
 196 function cidr.is4( self )
 197         return self[1] == FAMILY_INET4
 198 end
 199
 200 function cidr.is6( self )
 201         return self[1] == FAMILY_INET6
 202 end
 203
 204 function cidr.string( self )
 205         local str
 206         if self:is4() then
 207                 str = string.format(
 208                         "%d.%d.%d.%d",
 209                         bit.rshift(self[2][1], 8), bit.band(self[2][1], 0xFF),
 210                         bit.rshift(self[2][2], 8), bit.band(self[2][2], 0xFF)
 211                 )
 212                 if self[3] < 32 then
 213                         str = str .. "/" .. self[3]
 214                 end
 215         elseif self:is6() then
 216                 str = string.format( "%X:%X:%X:%X:%X:%X:%X:%X", unpack(self[2]) )
 217                 if self[3] < 128 then
 218                         str = str .. "/" .. self[3]
 219                 end
 220         end
 221         return str
 222 end
 223
 224 function cidr.lower( self, addr )
 225         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
 226         for i = 1, #self[2] do
 227                 if self[2][i] ~= addr[2][i] then
 228                         return self[2][i] < addr[2][i]
 229                 end
 230         end
 231         return false
 232 end
 233
 234 function cidr.higher( self, addr )
 235         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
 236         for i = 1, #self[2] do
 237                 if self[2][i] ~= addr[2][i] then
 238                         return self[2][i] > addr[2][i]
 239                 end
 240         end
 241         return false
 242 end
 243
 244 function cidr.equal( self, addr )
 245         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
 246         for i = 1, #self[2] do
 247                 if self[2][i] ~= addr[2][i] then
 248                         return false
 249                 end
 250         end
 251         return true
 252 end
 253
 254 function cidr.prefix( self, mask )
 255         local prefix = self[3]
 256
 257         if mask then
 258                 prefix = 0
 259                 local stop = false
 260                 local obj = self:is4() and IPv4(mask) or IPv6(mask)
 261
 262                 if not obj then
 263                         return nil
 264                 end
 265
 266                 for i, block in ipairs(obj[2]) do
 267                         local pos = bit.lshift(1, 15)
 268                         for i=15, 0, -1 do
 269                                 if bit.band(block, pos) == pos then
 270                                         if not stop then
 271                                                 prefix = prefix + 1
 272                                         else
 273                                                 return nil
 274                                         end
 275                                 else
 276                                         stop = true
 277                                 end
 278                                 pos = bit.rshift(pos, 1)
 279                         end
 280                 end
 281         end
 282
 283         return prefix
 284 end
 285
 286 function cidr.network( self )
 287         local data = { }
 288
 289         for i = 1, math.floor( self[3] / 16 ) do
 290                 table.insert( data, self[2][i] )
 291         end
 292
 293         table.insert( data, bit.band( self[2][1+#data], __mask16(self[3]) ) )
 294
 295         for i = #data, #self[2] do
 296                 table.insert( data, 0 )
 297         end
 298
 299         return __bless({ self[1], data, self:is4() and 32 or 128 })
 300 end
 301
 302 function cidr.host( self )
 303         return __bless({ self[1], data, self:is4() and 32 or 128 })
 304 end
 305
 306 function cidr.mask( self, bits )
 307         local data = { }
 308         bits = bits or self[3]
 309
 310         for i = 1, math.floor( bits / 16 ) do
 311                 table.insert( data, 0xFFFF )
 312         end
 313
 314         table.insert( data, __mask16(bits) )
 315
 316         for i = #data + 1, #self[2] do
 317                 table.insert( data, 0 )
 318         end
 319
 320         return __bless({ self[1], data, self:is4() and 32 or 128 })
 321 end
 322
 323 function cidr.contains( self, addr )
 324         if self:mask() <= addr:mask() then
 325                 return self:mask(addr:prefix()) == addr:mask()
 326         end
 327
 328         return false
 329 end
 330
 331 function cidr.add( self, amount )
 332         local shorts = { bit.rshift(amount, 16), bit.band(amount, 0xFFFF) }
 333         local data   = { unpack(self[2]) }
 334
 335         for pos = #data, 1, -1 do
 336                 local add = ( #shorts > 0 ) and table.remove( shorts, #shorts ) or 0
 337                 if ( data[pos] + add ) > 0xFFFF then
 338                         data[pos] = ( data[pos] + add ) % 0xFFFF
 339                         if pos > 2 then
 340                                 data[pos-1] = data[pos-1] + ( add - data[pos] )
 341                         end
 342                 else
 343                         data[pos] = data[pos] + add
 344                 end
 345         end
 346
 347         return __bless({ self[1], data, self[3] })
 348 end