libs/core: luci.model.network: implement contains_inteface(), fix bugs
[project/luci.git] / 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 --- LuCI IP calculation library.
18 module( "luci.ip", package.seeall )
19
20 require "nixio"
21 local bit  = nixio.bit
22 local util = require "luci.util"
23
24 --- Boolean; true if system is little endian
25 LITTLE_ENDIAN = not util.bigendian()
26
27 --- Boolean; true if system is big endian
28 BIG_ENDIAN    = not LITTLE_ENDIAN
29
30 --- Specifier for IPv4 address family
31 FAMILY_INET4  = 0x04
32
33 --- Specifier for IPv6 address family
34 FAMILY_INET6  = 0x06
35
36
37 local function __bless(x)
38         return setmetatable( x, {
39                 __index = luci.ip.cidr,
40                 __add   = luci.ip.cidr.add,
41                 __sub   = luci.ip.cidr.sub,
42                 __lt    = luci.ip.cidr.lower,
43                 __eq    = luci.ip.cidr.equal,
44                 __le    =
45                         function(...)
46                                 return luci.ip.cidr.equal(...) or luci.ip.cidr.lower(...)
47                         end
48         } )
49 end
50
51 local function __array16( x, family )
52         local list
53
54         if type(x) == "number" then
55                 list = { bit.rshift(x, 16), bit.band(x, 0xFFFF) }
56
57         elseif type(x) == "string" then
58                 if x:find(":") then x = IPv6(x) else x = IPv4(x) end
59                 if x then
60                         assert( x[1] == family, "Can't mix IPv4 and IPv6 addresses" )
61                         list = { unpack(x[2]) }
62                 end
63
64         elseif type(x) == "table" and type(x[2]) == "table" then
65                 assert( x[1] == family, "Can't mix IPv4 and IPv6 addresses" )
66                 list = { unpack(x[2]) }
67
68         elseif type(x) == "table" then
69                 list = { unpack(x) }
70         end
71
72         assert( list, "Invalid operand" )
73
74         return list
75 end
76
77 local function __mask16(bits)
78         return bit.lshift( bit.rshift( 0xFFFF, 16 - bits % 16 ), 16 - bits % 16 )
79 end
80
81 local function __not16(bits)
82         return bit.band( bit.bnot( __mask16(bits) ), 0xFFFF )
83 end
84
85 local function __maxlen(family)
86         return ( family == FAMILY_INET4 ) and 32 or 128
87 end
88
89 local function __sublen(family)
90         return ( family == FAMILY_INET4 ) and 30 or 127
91 end
92
93
94 --- Convert given short value to network byte order on little endian hosts
95 -- @param x     Unsigned integer value between 0x0000 and 0xFFFF
96 -- @return      Byte-swapped value
97 -- @see         htonl
98 -- @see         ntohs
99 function htons(x)
100         if LITTLE_ENDIAN then
101                 return bit.bor(
102                         bit.rshift( x, 8 ),
103                         bit.band( bit.lshift( x, 8 ), 0xFF00 )
104                 )
105         else
106                 return x
107         end
108 end
109
110 --- Convert given long value to network byte order on little endian hosts
111 -- @param x     Unsigned integer value between 0x00000000 and 0xFFFFFFFF
112 -- @return      Byte-swapped value
113 -- @see         htons
114 -- @see         ntohl
115 function htonl(x)
116         if LITTLE_ENDIAN then
117                 return bit.bor(
118                         bit.lshift( htons( bit.band( x, 0xFFFF ) ), 16 ),
119                         htons( bit.rshift( x, 16 ) )
120                 )
121         else
122                 return x
123         end
124 end
125
126 --- Convert given short value to host byte order on little endian hosts
127 -- @class       function
128 -- @name        ntohs
129 -- @param x     Unsigned integer value between 0x0000 and 0xFFFF
130 -- @return      Byte-swapped value
131 -- @see         htonl
132 -- @see         ntohs
133 ntohs = htons
134
135 --- Convert given short value to host byte order on little endian hosts
136 -- @class       function
137 -- @name        ntohl
138 -- @param x     Unsigned integer value between 0x00000000 and 0xFFFFFFFF
139 -- @return      Byte-swapped value
140 -- @see         htons
141 -- @see         ntohl
142 ntohl = htonl
143
144
145 --- Parse given IPv4 address in dotted quad or CIDR notation. If an optional
146 -- netmask is given as second argument and the IP address is encoded in CIDR
147 -- notation then the netmask parameter takes precedence. If neither a CIDR
148 -- encoded prefix nor a netmask parameter is given, then a prefix length of
149 -- 32 bit is assumed.
150 -- @param address       IPv4 address in dotted quad or CIDR notation
151 -- @param netmask       IPv4 netmask in dotted quad notation (optional)
152 -- @return                      luci.ip.cidr instance or nil if given address was invalid
153 -- @see                         IPv6
154 -- @see                         Hex
155 function IPv4(address, netmask)
156         address = address or "0.0.0.0/0"
157
158         local obj = __bless({ FAMILY_INET4 })
159
160         local data = {}
161         local prefix = address:match("/(.+)")
162         address = address:gsub("/.+","")
163         address = address:gsub("^%[(.*)%]$", "%1"):upper():gsub("^::FFFF:", "")
164
165         if netmask then
166                 prefix = obj:prefix(netmask)
167         elseif prefix then
168                 prefix = tonumber(prefix)
169                 if not prefix or prefix < 0 or prefix > 32 then return nil end
170         else
171                 prefix = 32
172         end
173
174         local b1, b2, b3, b4 = address:match("^(%d+)%.(%d+)%.(%d+)%.(%d+)$")
175
176         b1 = tonumber(b1)
177         b2 = tonumber(b2)
178         b3 = tonumber(b3)
179         b4 = tonumber(b4)
180
181         if b1 and b1 <= 255 and
182            b2 and b2 <= 255 and
183            b3 and b3 <= 255 and
184            b4 and b4 <= 255 and
185            prefix
186         then
187                 table.insert(obj, { b1 * 256 + b2, b3 * 256 + b4 })
188                 table.insert(obj, prefix)
189                 return obj
190         end
191 end
192
193 --- Parse given IPv6 address in full, compressed, mixed or CIDR notation.
194 -- If an optional netmask is given as second argument and the IP address is
195 -- encoded in CIDR notation then the netmask parameter takes precedence.
196 -- If neither a CIDR encoded prefix nor a netmask parameter is given, then a
197 -- prefix length of 128 bit is assumed.
198 -- @param address       IPv6 address in full/compressed/mixed or CIDR notation
199 -- @param netmask       IPv6 netmask in full/compressed/mixed notation (optional)
200 -- @return                      luci.ip.cidr instance or nil if given address was invalid
201 -- @see                         IPv4
202 -- @see                         Hex
203 function IPv6(address, netmask)
204         address = address or "::/0"
205
206         local obj = __bless({ FAMILY_INET6 })
207
208         local data = {}
209         local prefix = address:match("/(.+)")
210         address = address:gsub("/.+","")
211         address = address:gsub("^%[(.*)%]$", "%1")
212
213         if netmask then
214                 prefix = obj:prefix(netmask)
215         elseif prefix then
216                 prefix = tonumber(prefix)
217                 if not prefix or prefix < 0 or prefix > 128 then return nil end
218         else
219                 prefix = 128
220         end
221
222         local borderl = address:sub(1, 1) == ":" and 2 or 1
223         local borderh, zeroh, chunk, block
224
225         if #address > 45 then return nil end
226
227         repeat
228                 borderh = address:find(":", borderl, true)
229                 if not borderh then break end
230
231                 block = tonumber(address:sub(borderl, borderh - 1), 16)
232                 if block and block <= 0xFFFF then
233                         data[#data+1] = block
234                 else
235                         if zeroh or borderh - borderl > 1 then return nil end
236                         zeroh = #data + 1
237                 end
238
239                 borderl = borderh + 1
240         until #data == 7
241
242         chunk = address:sub(borderl)
243         if #chunk > 0 and #chunk <= 4 then
244                 block = tonumber(chunk, 16)
245                 if not block or block > 0xFFFF then return nil end
246
247                 data[#data+1] = block
248         elseif #chunk > 4 then
249                 if #data == 7 or #chunk > 15 then return nil end
250                 borderl = 1
251                 for i=1, 4 do
252                         borderh = chunk:find(".", borderl, true)
253                         if not borderh and i < 4 then return nil end
254                         borderh = borderh and borderh - 1
255
256                         block = tonumber(chunk:sub(borderl, borderh))
257                         if not block or block > 255 then return nil end
258
259                         if i == 1 or i == 3 then
260                                 data[#data+1] = block * 256
261                         else
262                                 data[#data] = data[#data] + block
263                         end
264
265                         borderl = borderh and borderh + 2
266                 end
267         end
268
269         if zeroh then
270                 if #data == 8 then return nil end
271                 while #data < 8 do
272                         table.insert(data, zeroh, 0)
273                 end
274         end
275
276         if #data == 8 and prefix then
277                 table.insert(obj, data)
278                 table.insert(obj, prefix)
279                 return obj
280         end
281 end
282
283 --- Transform given hex-encoded value to luci.ip.cidr instance of specified
284 -- address family.
285 -- @param hex           String containing hex encoded value
286 -- @param prefix        Prefix length of CIDR instance (optional, default is 32/128)
287 -- @param family        Address family, either luci.ip.FAMILY_INET4 or FAMILY_INET6
288 -- @param swap          Bool indicating whether to swap byteorder on low endian host
289 -- @return                      luci.ip.cidr instance or nil if given value was invalid
290 -- @see                         IPv4
291 -- @see                         IPv6
292 function Hex( hex, prefix, family, swap )
293         family = ( family ~= nil ) and family or FAMILY_INET4
294         swap   = ( swap   == nil ) and true   or swap
295         prefix = prefix or __maxlen(family)
296
297         local len  = __maxlen(family)
298         local tmp  = ""
299         local data = { }
300
301         for i = 1, (len/4) - #hex do tmp = tmp .. '0' end
302
303         if swap and LITTLE_ENDIAN then
304                 for i = #hex, 1, -2 do tmp = tmp .. hex:sub( i - 1, i ) end
305         else
306                 tmp = tmp .. hex
307         end
308
309         hex = tmp
310
311         for i = 1, ( len / 4 ), 4 do
312                 local n = tonumber( hex:sub( i, i+3 ), 16 )
313                 if n then
314                         data[#data+1] = n
315                 else
316                         return nil
317                 end
318         end
319
320         return __bless({ family, data, prefix })
321 end
322
323
324 --- LuCI IP Library / CIDR instances
325 -- @class       module
326 -- @cstyle      instance
327 -- @name        luci.ip.cidr
328 cidr = util.class()
329
330 --- Test whether the instance is a IPv4 address.
331 -- @return      Boolean indicating a IPv4 address type
332 -- @see         cidr.is6
333 function cidr.is4( self )
334         return self[1] == FAMILY_INET4
335 end
336
337 --- Test whether the instance is a IPv6 address.
338 -- @return      Boolean indicating a IPv6 address type
339 -- @see         cidr.is4
340 function cidr.is6( self )
341         return self[1] == FAMILY_INET6
342 end
343
344 --- Return a corresponding string representation of the instance.
345 -- If the prefix length is lower then the maximum possible prefix length for the
346 -- corresponding address type then the address is returned in CIDR notation,
347 -- otherwise the prefix will be left out.
348 function cidr.string( self )
349         local str
350         if self:is4() then
351                 str = string.format(
352                         "%d.%d.%d.%d",
353                         bit.rshift(self[2][1], 8), bit.band(self[2][1], 0xFF),
354                         bit.rshift(self[2][2], 8), bit.band(self[2][2], 0xFF)
355                 )
356                 if self[3] < 32 then
357                         str = str .. "/" .. self[3]
358                 end
359         elseif self:is6() then
360                 str = string.format( "%X:%X:%X:%X:%X:%X:%X:%X", unpack(self[2]) )
361                 if self[3] < 128 then
362                         str = str .. "/" .. self[3]
363                 end
364         end
365         return str
366 end
367
368 --- Test whether the value of the instance is lower then the given address.
369 -- This function will throw an exception if the given address has a different
370 -- family than this instance.
371 -- @param addr  A luci.ip.cidr instance to compare against
372 -- @return              Boolean indicating whether this instance is lower
373 -- @see                 cidr.higher
374 -- @see                 cidr.equal
375 function cidr.lower( self, addr )
376         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
377         for i = 1, #self[2] do
378                 if self[2][i] ~= addr[2][i] then
379                         return self[2][i] < addr[2][i]
380                 end
381         end
382         return false
383 end
384
385 --- Test whether the value of the instance is higher then the given address.
386 -- This function will throw an exception if the given address has a different
387 -- family than this instance.
388 -- @param addr  A luci.ip.cidr instance to compare against
389 -- @return              Boolean indicating whether this instance is higher
390 -- @see                 cidr.lower
391 -- @see                 cidr.equal
392 function cidr.higher( self, addr )
393         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
394         for i = 1, #self[2] do
395                 if self[2][i] ~= addr[2][i] then
396                         return self[2][i] > addr[2][i]
397                 end
398         end
399         return false
400 end
401
402 --- Test whether the value of the instance is equal to the given address.
403 -- This function will throw an exception if the given address is a different
404 -- family than this instance.
405 -- @param addr  A luci.ip.cidr instance to compare against
406 -- @return              Boolean indicating whether this instance is equal
407 -- @see                 cidr.lower
408 -- @see                 cidr.higher
409 function cidr.equal( self, addr )
410         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
411         for i = 1, #self[2] do
412                 if self[2][i] ~= addr[2][i] then
413                         return false
414                 end
415         end
416         return true
417 end
418
419 --- Return the prefix length of this CIDR instance.
420 -- @param mask  Override instance prefix with given netmask (optional)
421 -- @return              Prefix length in bit
422 function cidr.prefix( self, mask )
423         local prefix = self[3]
424
425         if mask then
426                 prefix = 0
427
428                 local stop = false
429                 local obj = type(mask) ~= "table"
430                         and ( self:is4() and IPv4(mask) or IPv6(mask) ) or mask
431
432                 if not obj then return nil end
433
434                 for _, word in ipairs(obj[2]) do
435                         if word == 0xFFFF then
436                                 prefix = prefix + 16
437                         else
438                                 local bitmask = bit.lshift(1, 15)
439                                 while bit.band(word, bitmask) == bitmask do
440                                         prefix  = prefix + 1
441                                         bitmask = bit.lshift(1, 15 - (prefix % 16))
442                                 end
443
444                                 break
445                         end
446                 end
447         end
448
449         return prefix
450 end
451
452 --- Return a corresponding CIDR representing the network address of this
453 -- instance.
454 -- @param bits  Override prefix length of this instance (optional)
455 -- @return              CIDR instance containing the network address
456 -- @see                 cidr.host
457 -- @see                 cidr.broadcast
458 -- @see                 cidr.mask
459 function cidr.network( self, bits )
460         local data = { }
461         bits = bits or self[3]
462
463         for i = 1, math.floor( bits / 16 ) do
464                 data[#data+1] = self[2][i]
465         end
466
467         if #data < #self[2] then
468                 data[#data+1] = bit.band( self[2][1+#data], __mask16(bits) )
469
470                 for i = #data + 1, #self[2] do
471                         data[#data+1] = 0
472                 end
473         end
474
475         return __bless({ self[1], data, __maxlen(self[1]) })
476 end
477
478 --- Return a corresponding CIDR representing the host address of this
479 -- instance. This is intended to extract the host address from larger subnet.
480 -- @return              CIDR instance containing the network address
481 -- @see                 cidr.network
482 -- @see                 cidr.broadcast
483 -- @see                 cidr.mask
484 function cidr.host( self )
485         return __bless({ self[1], self[2], __maxlen(self[1]) })
486 end
487
488 --- Return a corresponding CIDR representing the netmask of this instance.
489 -- @param bits  Override prefix length of this instance (optional)
490 -- @return              CIDR instance containing the netmask
491 -- @see                 cidr.network
492 -- @see                 cidr.host
493 -- @see                 cidr.broadcast
494 function cidr.mask( self, bits )
495         local data = { }
496         bits = bits or self[3]
497
498         for i = 1, math.floor( bits / 16 ) do
499                 data[#data+1] = 0xFFFF
500         end
501
502         if #data < #self[2] then
503                 data[#data+1] = __mask16(bits)
504
505                 for i = #data + 1, #self[2] do
506                         data[#data+1] = 0
507                 end
508         end
509
510         return __bless({ self[1], data, __maxlen(self[1]) })
511 end
512
513 --- Return CIDR containing the broadcast address of this instance.
514 -- @return              CIDR instance containing the netmask, always nil for IPv6
515 -- @see                 cidr.network
516 -- @see                 cidr.host
517 -- @see                 cidr.mask
518 function cidr.broadcast( self )
519         -- IPv6 has no broadcast addresses (XXX: assert() instead?)
520         if self[1] == FAMILY_INET4 then
521                 local data   = { unpack(self[2]) }
522                 local offset = math.floor( self[3] / 16 ) + 1
523
524                 if offset <= #data then
525                         data[offset] = bit.bor( data[offset], __not16(self[3]) )
526                         for i = offset + 1, #data do data[i] = 0xFFFF end
527
528                         return __bless({ self[1], data, __maxlen(self[1]) })
529                 end
530         end
531 end
532
533 --- Test whether this instance fully contains the given CIDR instance.
534 -- @param addr  CIDR instance to test against
535 -- @return              Boolean indicating whether this instance contains the given CIDR
536 function cidr.contains( self, addr )
537         assert( self[1] == addr[1], "Can't compare IPv4 and IPv6 addresses" )
538
539         if self:prefix() <= addr:prefix() then
540                 return self:network() == addr:network(self:prefix())
541         end
542
543         return false
544 end
545
546 --- Add specified amount of hosts to this instance.
547 -- @param amount        Number of hosts to add to this instance
548 -- @param inplace       Boolen indicating whether to alter values inplace (optional)
549 -- @return                      CIDR representing the new address or nil on overflow error
550 -- @see                         cidr.sub
551 function cidr.add( self, amount, inplace )
552         local data   = { unpack(self[2]) }
553         local shorts = __array16( amount, self[1] )
554
555         for pos = #data, 1, -1 do
556                 local add = ( #shorts > 0 ) and table.remove( shorts, #shorts ) or 0
557                 if ( data[pos] + add ) > 0xFFFF then
558                         data[pos] = ( data[pos] + add ) % 0xFFFF
559                         if pos > 1 then
560                                 data[pos-1] = data[pos-1] + ( add - data[pos] )
561                         else
562                                 return nil
563                         end
564                 else
565                         data[pos] = data[pos] + add
566                 end
567         end
568
569         if inplace then
570                 self[2] = data
571                 return self
572         else
573                 return __bless({ self[1], data, self[3] })
574         end
575 end
576
577 --- Substract specified amount of hosts from this instance.
578 -- @param amount        Number of hosts to substract from this instance
579 -- @param inplace       Boolen indicating whether to alter values inplace (optional)
580 -- @return                      CIDR representing the new address or nil on underflow error
581 -- @see                         cidr.add
582 function cidr.sub( self, amount, inplace )
583         local data   = { unpack(self[2]) }
584         local shorts = __array16( amount, self[1] )
585
586         for pos = #data, 1, -1 do
587                 local sub = ( #shorts > 0 ) and table.remove( shorts, #shorts ) or 0
588                 if ( data[pos] - sub ) < 0 then
589                         data[pos] = ( sub - data[pos] ) % 0xFFFF
590                         if pos > 1 then
591                                 data[pos-1] = data[pos-1] - ( sub + data[pos] )
592                         else
593                                 return nil
594                         end
595                 else
596                         data[pos] = data[pos] - sub
597                 end
598         end
599
600         if inplace then
601                 self[2] = data
602                 return self
603         else
604                 return __bless({ self[1], data, self[3] })
605         end
606 end
607
608 --- Return CIDR containing the lowest available host address within this subnet.
609 -- @return              CIDR containing the host address, nil if subnet is too small
610 -- @see                 cidr.maxhost
611 function cidr.minhost( self )
612         if self[3] <= __sublen(self[1]) then
613                 -- 1st is Network Address in IPv4 and Subnet-Router Anycast Adresse in IPv6
614                 return self:network():add(1, true)
615         end
616 end
617
618 --- Return CIDR containing the highest available host address within the subnet.
619 -- @return              CIDR containing the host address, nil if subnet is too small
620 -- @see                 cidr.minhost
621 function cidr.maxhost( self )
622         if self[3] <= __sublen(self[1]) then
623                 local data   = { unpack(self[2]) }
624                 local offset = math.floor( self[3] / 16 ) + 1
625
626                 data[offset] = bit.bor( data[offset], __not16(self[3]) )
627                 for i = offset + 1, #data do data[i] = 0xFFFF end
628                 data = __bless({ self[1], data, __maxlen(self[1]) })
629
630                 -- Last address in reserved for Broadcast Address in IPv4
631                 if data[1] == FAMILY_INET4 then data:sub(1, true) end
632
633                 return data
634         end
635 end