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