Difuse/luci
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

luci-lib-ip: add MAC address calculation support

Browse source 
Signed-off-by: Jo-Philipp Wich <jo@mein.io>
This commit is contained in:
Jo-Philipp Wich 2018-03-12 08:18:11 +01:00
parent 190b32452a
commit 4f412a76c2
4 changed files with 1232 additions and 268 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

322
documentation/api/modules/luci.ip.cidr.html
View file

@ -256,6 +256,30 @@ Checks whether the CIDR instance is an IPv6 link local address
<td class="summary"> <td class="summary">
Checks whether the CIDR instance is an IPv6 mapped IPv4 address Checks whether the CIDR instance is an IPv6 mapped IPv4 address
</td>
</tr>
<tr>
<td class="name" nowrap><a href="#cidr.ismac">cidr:ismac</a>&nbsp;()</td>
<td class="summary">
Checks whether the CIDR instance is an ethernet MAC address range
</td>
</tr>
<tr>
<td class="name" nowrap><a href="#cidr.ismaclocal">cidr:ismaclocal</a>&nbsp;()</td>
<td class="summary">
Checks whether the CIDR instance is a locally administered (LAA) MAC address
</td>
</tr>
<tr>
<td class="name" nowrap><a href="#cidr.ismacmcast">cidr:ismacmcast</a>&nbsp;()</td>
<td class="summary">
Checks whether the CIDR instance is a multicast MAC address
</td> </td>
</tr> </tr>
@ -322,6 +346,20 @@ Derive broadcast address of CIDR instance.</td>
Derive mapped IPv4 address of CIDR instance.</td> Derive mapped IPv4 address of CIDR instance.</td>
</tr> </tr>
<tr>
<td class="name" nowrap><a href="#cidr.tomac">cidr:tomac</a>&nbsp;()</td>
<td class="summary">
Derive MAC address of IPv6 link local CIDR instance.</td>
</tr>
<tr>
<td class="name" nowrap><a href="#cidr.tolinklocal">cidr:tolinklocal</a>&nbsp;()</td>
<td class="summary">
Derive IPv6 link local address from MAC address CIDR instance.</td>
</tr>
<tr> <tr>
<td class="name" nowrap><a href="#cidr.contains">cidr:contains</a>&nbsp;(addr)</td> <td class="name" nowrap><a href="#cidr.contains">cidr:contains</a>&nbsp;(addr)</td>
<td class="summary"> <td class="summary">
@ -405,6 +443,10 @@ Checks whether the CIDR instance is an IPv4 address range
cidr:is6 cidr:is6
</a> </a>
<li><a href="#cidr.ismac">
cidr:ismac
</a>
</ul> </ul>
</dd> </dd>
@ -499,6 +541,10 @@ Checks whether the CIDR instance is an IPv6 address range
cidr:is4 cidr:is4
</a> </a>
<li><a href="#cidr.ismac">
cidr:ismac
</a>
</ul> </ul>
</dd> </dd>
@ -566,13 +612,108 @@ end</pre>
<dt><a name="cidr.ismac"></a><strong>cidr:ismac</strong>&nbsp;()</dt>
<dd>
Checks whether the CIDR instance is an ethernet MAC address range
<h3>Return value:</h3>
<code>true</code> if the CIDR is a MAC address range, else <code>false</code>
<h3>See also:</h3>
<ul>
<li><a href="#cidr.is4">
cidr:is4
</a>
<li><a href="#cidr.is6">
cidr:is6
</a>
</ul>
</dd>
<dt><a name="cidr.ismaclocal"></a><strong>cidr:ismaclocal</strong>&nbsp;()</dt>
<dd>
Checks whether the CIDR instance is a locally administered (LAA) MAC address
<h3>Usage:</h3>
<pre>local mac = luci.ip.new("02:C0:FF:EE:00:01")
if mac:ismaclocal() then
print("Is an LAA MAC address")
end</pre>
<h3>Return value:</h3>
<code>true</code> if the MAC address sets the locally administered bit.
</dd>
<dt><a name="cidr.ismacmcast"></a><strong>cidr:ismacmcast</strong>&nbsp;()</dt>
<dd>
Checks whether the CIDR instance is a multicast MAC address
<h3>Usage:</h3>
<pre>local mac = luci.ip.new("01:00:5E:7F:00:10")
if addr:ismacmcast() then
print("Is a multicast MAC address")
end</pre>
<h3>Return value:</h3>
<code>true</code> if the MAC address sets the multicast bit.
</dd>
<dt><a name="cidr.lower"></a><strong>cidr:lower</strong>&nbsp;(addr)</dt> <dt><a name="cidr.lower"></a><strong>cidr:lower</strong>&nbsp;(addr)</dt>
<dd> <dd>
Checks whether this CIDR instance is lower than the given argument. Checks whether this CIDR instance is lower than the given argument.
The comparisation follows these rules: The comparisation follows these rules:
<ul><li>An IPv4 address is always lower than an IPv6 address</li> <ul><li>An IPv4 address is always lower than an IPv6 address and IPv6 addresses
are considered lower than MAC addresses</li>
<li>Prefix sizes are ignored</li></ul> <li>Prefix sizes are ignored</li></ul>
@ -595,7 +736,8 @@ The comparisation follows these rules:
print(addr:lower(addr)) -- false print(addr:lower(addr)) -- false
print(addr:lower("10.10.10.10/24")) -- false print(addr:lower("10.10.10.10/24")) -- false
print(addr:lower(luci.ip.new("::1"))) -- true print(addr:lower(luci.ip.new("::1"))) -- true
print(addr:lower(luci.ip.new("192.168.200.1"))) -- true</pre> print(addr:lower(luci.ip.new("192.168.200.1"))) -- true
print(addr:lower(luci.ip.new("00:14:22:01:23:45"))) -- true</pre>
@ -629,7 +771,8 @@ print(addr:lower(luci.ip.new("192.168.200.1"))) -- true</pre>
Checks whether this CIDR instance is higher than the given argument. Checks whether this CIDR instance is higher than the given argument.
The comparisation follows these rules: The comparisation follows these rules:
<ul><li>An IPv4 address is always lower than an IPv6 address</li> <ul><li>An IPv4 address is always lower than an IPv6 address and IPv6 addresses
are considered lower than MAC addresses</li>
<li>Prefix sizes are ignored</li></ul> <li>Prefix sizes are ignored</li></ul>
@ -652,7 +795,8 @@ The comparisation follows these rules:
print(addr:higher(addr)) -- false print(addr:higher(addr)) -- false
print(addr:higher("10.10.10.10/24")) -- true print(addr:higher("10.10.10.10/24")) -- true
print(addr:higher(luci.ip.new("::1"))) -- false print(addr:higher(luci.ip.new("::1"))) -- false
print(addr:higher(luci.ip.new("192.168.200.1"))) -- false</pre> print(addr:higher(luci.ip.new("192.168.200.1"))) -- false
print(addr:higher(luci.ip.new("00:14:22:01:23:45"))) -- false</pre>
@ -709,7 +853,11 @@ print(addr:equal(luci.ip.new("::1"))) -- false
local addr6 = luci.ip.new("::1") local addr6 = luci.ip.new("::1")
print(addr6:equal("0:0:0:0:0:0:0:1/64")) -- true print(addr6:equal("0:0:0:0:0:0:0:1/64")) -- true
print(addr6:equal(luci.ip.new("fe80::221:63ff:fe75:aa17"))) -- false</pre> print(addr6:equal(luci.ip.new("fe80::221:63ff:fe75:aa17"))) -- false
local mac = luci.ip.new("00:14:22:01:23:45")
print(mac:equal("0:14:22:1:23:45")) -- true
print(mac:equal(luci.ip.new("01:23:45:67:89:AB")) -- false</pre>
@ -752,8 +900,8 @@ else the current prefix size is returned.
<li> <li>
mask: Either a number containing the number of bits (<code>0..32</code> mask: Either a number containing the number of bits (<code>0..32</code>
for IPv4, <code>0..128</code> for IPv6) or a string containing a valid for IPv4, <code>0..128</code> for IPv6 or <code>0..48</code> for MAC addresses) or a string
netmask (optional) containing a valid netmask (optional)
</li> </li>
</ul> </ul>
@ -800,8 +948,8 @@ optional mask parameter.
<li> <li>
mask: Either a number containing the number of bits (<code>0..32</code> mask: Either a number containing the number of bits (<code>0..32</code>
for IPv4, <code>0..128</code> for IPv6) or a string containing a valid for IPv4, <code>0..128</code> for IPv6 or <code>0..48</code> for MAC addresses) or a string
netmask (optional) containing a valid netmask (optional)
</li> </li>
</ul> </ul>
@ -837,7 +985,7 @@ CIDR instance representing the network address
Derive host address of CIDR instance. Derive host address of CIDR instance.
This function essentially constructs a copy of this CIDR with the prefix size This function essentially constructs a copy of this CIDR with the prefix size
set to <code>32</code> for IPv4 and <code>128</code> for IPv6. set to <code>32</code> for IPv4, <code>128</code> for IPv6 or <code>48</code> for MAC addresses.
@ -877,8 +1025,8 @@ prefix size can be overridden by the optional mask parameter.
<li> <li>
mask: Either a number containing the number of bits (<code>0..32</code> mask: Either a number containing the number of bits (<code>0..32</code>
for IPv4, <code>0..128</code> for IPv6) or a string containing a valid for IPv4, <code>0..128</code> for IPv6 or <code>0..48</code> for MAC addresses) or a string
netmask (optional) containing a valid netmask (optional)
</li> </li>
</ul> </ul>
@ -913,8 +1061,8 @@ Derive broadcast address of CIDR instance.
Constructs a CIDR instance representing the broadcast address of this instance. Constructs a CIDR instance representing the broadcast address of this instance.
The used prefix size can be overridden by the optional mask parameter. The used prefix size can be overridden by the optional mask parameter.
This function has no effect on IPv6 instances, it will return nothing in this This function has no effect on IPv6 or MAC address instances, it will return
case. nothing in this case.
@ -922,9 +1070,8 @@ case.
<ul> <ul>
<li> <li>
mask: Either a number containing the number of bits (<code>0..32</code> mask: Either a number containing the number of bits (<code>0..32</code> for IPv4) or
for IPv4, <code>0..128</code> for IPv6) or a string containing a valid a string containing a valid netmask (optional)
netmask (optional)
</li> </li>
</ul> </ul>
@ -960,8 +1107,8 @@ Derive mapped IPv4 address of CIDR instance.
Constructs a CIDR instance representing the IPv4 address of the IPv6 mapped Constructs a CIDR instance representing the IPv4 address of the IPv6 mapped
IPv4 address in this instance. IPv4 address in this instance.
This function has no effect on IPv4 instances or IPv6 instances which are not a This function has no effect on IPv4 instances, MAC address instances or IPv6
mapped address, it will return nothing in this case. instances which are not a mapped address, it will return nothing in this case.
@ -985,6 +1132,74 @@ Return a new CIDR instance representing the IPv4 address if this
<dt><a name="cidr.tomac"></a><strong>cidr:tomac</strong>&nbsp;()</dt>
<dd>
Derive MAC address of IPv6 link local CIDR instance.
Constructs a CIDR instance representing the MAC address contained in the IPv6
link local address of this instance.
This function has no effect on IPv4 instances, MAC address instances or IPv6
instances which are not a link local address, it will return nothing in this
case.
<h3>Usage:</h3>
<pre>local addr = luci.ip.new("fe80::6666:b3ff:fe47:e1b9")
print(addr:tomac()) -- "64:66:B3:47:E1:B9"</pre>
<h3>Return value:</h3>
Return a new CIDR instance representing the MAC address if this
instance is an IPv6 link local address, else return nothing.
</dd>
<dt><a name="cidr.tolinklocal"></a><strong>cidr:tolinklocal</strong>&nbsp;()</dt>
<dd>
Derive IPv6 link local address from MAC address CIDR instance.
Constructs a CIDR instance representing the IPv6 link local address of the
MAC address represented by this instance.
This function has no effect on IPv4 instances or IPv6 instances, it will return
nothing in this case.
<h3>Usage:</h3>
<pre>local mac = luci.ip.new("64:66:B3:47:E1:B9")
print(mac:tolinklocal()) -- "fe80::6666:b3ff:fe47:e1b9"</pre>
<h3>Return value:</h3>
Return a new CIDR instance representing the IPv6 link local address.
</dd>
<dt><a name="cidr.contains"></a><strong>cidr:contains</strong>&nbsp;(addr)</dt> <dt><a name="cidr.contains"></a><strong>cidr:contains</strong>&nbsp;(addr)</dt>
<dd> <dd>
@ -1014,7 +1229,11 @@ print(range:contains("10.0.0.0/8")) -- false
local range6 = luci.ip.new("fe80::/10") local range6 = luci.ip.new("fe80::/10")
print(range6:contains("fe80::221:63f:fe75:aa17/64")) -- true print(range6:contains("fe80::221:63f:fe75:aa17/64")) -- true
print(range6:contains("fd9b:6b3:c5:0:221:63f:fe75:aa17/64")) -- false</pre> print(range6:contains("fd9b:6b3:c5:0:221:63f:fe75:aa17/64")) -- false
local intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00/24")
print(intel_macs:contains("C0:B6:F9:A3:C:11")) -- true
print(intel_macs:contains("64:66:B3:47:E1:B9")) -- false</pre>
@ -1059,30 +1278,40 @@ address space, the result is set to the highest possible address.
<h3>Usage:</h3> <h3>Usage:</h3>
<pre>local addr = luci.ip.new("192.168.1.1/24") <pre>local addr = luci.ip.new("192.168.1.1/24")
print(addr:add(250)) -- "192.168.1.251/24" print(addr:add(250)) -- "192.168.1.251/24"
print(addr:add("0.0.99.0")) -- "192.168.100.1/24" print(addr:add("0.0.99.0")) -- "192.168.100.1/24"
addr:add(256, true) -- true addr:add(256, true) -- true
print(addr) -- "192.168.2.1/24 print(addr) -- "192.168.2.1/24
addr:add("255.0.0.0", true) -- false (overflow) addr:add("255.0.0.0", true) -- false (overflow)
print(addr) -- "255.255.255.255/24 print(addr) -- "255.255.255.255/24
local addr6 = luci.ip.new("fe80::221:63f:fe75:aa17/64") local addr6 = luci.ip.new("fe80::221:63f:fe75:aa17/64")
print(addr6:add(256)) -- "fe80::221:63f:fe75:ab17/64" print(addr6:add(256)) -- "fe80::221:63f:fe75:ab17/64"
print(addr6:add("::ffff:0")) -- "fe80::221:640:fe74:aa17/64" print(addr6:add("::ffff:0")) -- "fe80::221:640:fe74:aa17/64"
addr:add(256, true) -- true addr6:add(256, true) -- true
print(addr) -- "fe80::221:63f:fe75:ab17/64 print(addr6) -- "fe80::221:63f:fe75:ab17/64
addr:add("ffff::", true) -- false (overflow) addr6:add("ffff::", true) -- false (overflow)
print(addr) -- "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/64"</pre> print(addr6) -- "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/64"
local mac = luci.ip.new("00:14:22:01:23:45")
print(mac:add(256)) -- "00:14:22:01:24:45"
print(mac:add("0:0:0:0:FF:0") -- "00:14:22:02:22:45"
mac:add(256, true) -- true
print(mac) -- "00:14:22:01:24:45"
mac:add("FF:FF:0:0:0:0", true) -- false (overflow)
print(mac) -- "FF:FF:FF:FF:FF:FF"</pre>
<h3>Return value:</h3> <h3>Return value:</h3>
<ul> <ul>
<li>When adding inplace: Return <code>true</code> if the addition succeeded <li>When adding inplace: Return <code>true</code> if the addition succeded
or <code>false</code> when the addition overflowed.</li> or <code>false</code> when the addition overflowed.</li>
<li>When deriving new CIDR: Return new instance representing the value of <li>When deriving new CIDR: Return new instance representing the value of
this instance plus the added amount or the highest possible address if this instance plus the added amount or the highest possible address if
@ -1142,7 +1371,17 @@ addr:sub(256, true) -- true
print(addr) -- "fe80::221:63f:fe75:a917/64" print(addr) -- "fe80::221:63f:fe75:a917/64"
addr:sub("ffff::", true) -- false (underflow) addr:sub("ffff::", true) -- false (underflow)
print(addr) -- "::/64"</pre> print(addr) -- "::/64"
local mac = luci.ip.new("00:14:22:01:23:45")
print(mac:sub(256)) -- "00:14:22:01:22:45"
print(mac:sub("0:0:0:0:FF:0") -- "00:14:22:00:24:45"
mac:sub(256, true) -- true
print(mac) -- "00:14:22:01:22:45"
mac:sub("FF:FF:0:0:0:0", true) -- false (overflow)
print(mac) -- "00:00:00:00:00:00"</pre>
@ -1177,7 +1416,10 @@ Calculate the lowest possible host address within this CIDR instance.
print(addr:minhost()) -- "192.168.123.1" print(addr:minhost()) -- "192.168.123.1"
local addr6 = luci.ip.new("fd9b:62b3:9cc5:0:221:63ff:fe75:aa17/64") local addr6 = luci.ip.new("fd9b:62b3:9cc5:0:221:63ff:fe75:aa17/64")
print(addr6:minhost()) -- "fd9b:62b3:9cc5::1"</pre> print(addr6:minhost()) -- "fd9b:62b3:9cc5::1"
local mac = luci.ip.new("00:14:22:01:22:45/32")
print(mac:minhost()) -- "00:14:22:01:00:01"</pre>
@ -1208,7 +1450,10 @@ Calculate the highest possible host address within this CIDR instance.
print(addr:maxhost()) -- "192.168.123.254" (.255 is broadcast) print(addr:maxhost()) -- "192.168.123.254" (.255 is broadcast)
local addr6 = luci.ip.new("fd9b:62b3:9cc5:0:221:63ff:fe75:aa17/64") local addr6 = luci.ip.new("fd9b:62b3:9cc5:0:221:63ff:fe75:aa17/64")
print(addr6:maxhost()) -- "fd9b:62b3:9cc5:0:ffff:ffff:ffff:ffff"</pre> print(addr6:maxhost()) -- "fd9b:62b3:9cc5:0:ffff:ffff:ffff:ffff"
local mac = luci.ip.new("00:14:22:01:22:45/32")
print(mac:maxhost()) -- "00:14:22:01:FF:FF"</pre>
@ -1229,8 +1474,9 @@ Returns a new CIDR instance representing the highest host address
Convert CIDR instance into string representation. Convert CIDR instance into string representation.
If the prefix size of instance is less than 32 for IPv4 or 128 for IPv6, the If the prefix size of instance is less than 32 for IPv4, 128 for IPv6 or 48 for
address is returned in the form "address/prefix" otherwise just "address". MACs, the address is returned in the form "address/prefix" otherwise just
"address".
It is usually not required to call this function directly as CIDR objects It is usually not required to call this function directly as CIDR objects
define it as __tostring function in the associated metatable. define it as __tostring function in the associated metatable.

288
documentation/api/modules/luci.ip.html
View file

@ -231,6 +231,34 @@ Construct a new IPv4 luci.ip.cidr instance.</td>
Construct a new IPv6 luci.ip.cidr instance.</td> Construct a new IPv6 luci.ip.cidr instance.</td>
</tr> </tr>
<tr>
<td class="name" nowrap><a href="#MAC">MAC</a>&nbsp;(address, netmask)</td>
<td class="summary">
Construct a new MAC luci.ip.cidr instance.</td>
</tr>
<tr>
<td class="name" nowrap><a href="#checkip4">checkip4</a>&nbsp;(address)</td>
<td class="summary">
Verify an IPv4 address.</td>
</tr>
<tr>
<td class="name" nowrap><a href="#checkip6">checkip6</a>&nbsp;(address)</td>
<td class="summary">
Verify an IPv6 address.</td>
</tr>
<tr>
<td class="name" nowrap><a href="#checkmac">checkmac</a>&nbsp;(address)</td>
<td class="summary">
Verify an ethernet MAC address.</td>
</tr>
<tr> <tr>
<td class="name" nowrap><a href="#route">route</a>&nbsp;(address)</td> <td class="name" nowrap><a href="#route">route</a>&nbsp;(address)</td>
<td class="summary"> <td class="summary">
@ -334,6 +362,10 @@ address/mask range.
IPv6 IPv6
</a> </a>
<li><a href="#MAC">
MAC
</a>
</ul> </ul>
</dd> </dd>
@ -389,6 +421,10 @@ A <code>luci.ip.cidr</code> object representing the given IPv4 range.
IPv6 IPv6
</a> </a>
<li><a href="#MAC">
MAC
</a>
</ul> </ul>
</dd> </dd>
@ -444,6 +480,252 @@ A <code>luci.ip.cidr</code> object representing the given IPv6 range.
IPv4 IPv4
</a> </a>
<li><a href="#MAC">
MAC
</a>
</ul>
</dd>
<dt><a name="MAC"></a><strong>MAC</strong>&nbsp;(address, netmask)</dt>
<dd>
Construct a new MAC luci.ip.cidr instance.
Throws an error if the given string does not represent a valid ethernet MAC
address or if the given optional mask is of a different family.
<h3>Parameters</h3>
<ul>
<li>
address: String containing a valid ethernet MAC address, optionally with
prefix size (CIDR notation) or mask separated by slash.
</li>
<li>
netmask: String containing a valid MAC address mask or number
containing a prefix size between <code>0</code> and <code>48</code> bit.
Overrides mask embedded in the first argument if specified. (optional)
</li>
</ul>
<h3>Usage:</h3>
<pre>intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00/24")
intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00/FF:FF:FF:0:0:0")
intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00", "FF:FF:FF:0:0:0")
intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00/24", 48) -- override mask</pre>
<h3>Return value:</h3>
A <code>luci.ip.cidr</code> object representing the given MAC address range.
<h3>See also:</h3>
<ul>
<li><a href="#IPv4">
IPv4
</a>
<li><a href="#IPv6">
IPv6
</a>
</ul>
</dd>
<dt><a name="checkip4"></a><strong>checkip4</strong>&nbsp;(address)</dt>
<dd>
Verify an IPv4 address.
Checks whether given argument is a preexisting luci.ip.cidr IPv4 address
instance or a string literal convertible to an IPv4 address and returns a
plain Lua string containing the canonical representation of the address.
If the argument is not a valid address, returns nothing. This function is
intended to aid in safely verifying address literals without having to deal
with exceptions.
<h3>Parameters</h3>
<ul>
<li>
address: String containing a valid IPv4 address or existing
luci.ip.cidr IPv4 instance.
</li>
</ul>
<h3>Usage:</h3>
<pre>ipv4 = luci.ip.checkip4(luci.ip.new("127.0.0.1")) -- "127.0.0.1"
ipv4 = luci.ip.checkip4("127.0.0.1") -- "127.0.0.1"
ipv4 = luci.ip.checkip4("nonesense") -- nothing
ipv4 = luci.ip.checkip4(123) -- nothing
ipv4 = luci.ip.checkip4(nil) -- nothing
ipv4 = luci.ip.checkip4() -- nothing</pre>
<h3>Return value:</h3>
A string representing the given IPv4 address.
<h3>See also:</h3>
<ul>
<li><a href="#checkip6">
checkip6
</a>
<li><a href="#checkmac">
checkmac
</a>
</ul>
</dd>
<dt><a name="checkip6"></a><strong>checkip6</strong>&nbsp;(address)</dt>
<dd>
Verify an IPv6 address.
Checks whether given argument is a preexisting luci.ip.cidr IPv6 address
instance or a string literal convertible to an IPv6 address and returns a
plain Lua string containing the canonical representation of the address.
If the argument is not a valid address, returns nothing. This function is
intended to aid in safely verifying address literals without having to deal
with exceptions.
<h3>Parameters</h3>
<ul>
<li>
address: String containing a valid IPv6 address or existing
luci.ip.cidr IPv6 instance.
</li>
</ul>
<h3>Usage:</h3>
<pre>ipv6 = luci.ip.checkip6(luci.ip.new("0:0:0:0:0:0:0:1")) -- "::1"
ipv6 = luci.ip.checkip6("0:0:0:0:0:0:0:1") -- "::1"
ipv6 = luci.ip.checkip6("nonesense") -- nothing
ipv6 = luci.ip.checkip6(123) -- nothing
ipv6 = luci.ip.checkip6(nil) -- nothing
ipv6 = luci.ip.checkip6() -- nothing</pre>
<h3>Return value:</h3>
A string representing the given IPv6 address.
<h3>See also:</h3>
<ul>
<li><a href="#checkip4">
checkip4
</a>
<li><a href="#checkmac">
checkmac
</a>
</ul>
</dd>
<dt><a name="checkmac"></a><strong>checkmac</strong>&nbsp;(address)</dt>
<dd>
Verify an ethernet MAC address.
Checks whether given argument is a preexisting luci.ip.cidr MAC address
instance or a string literal convertible to an ethernet MAC and returns a
plain Lua string containing the canonical representation of the address.
If the argument is not a valid address, returns nothing. This function is
intended to aid in safely verifying address literals without having to deal
with exceptions.
<h3>Parameters</h3>
<ul>
<li>
address: String containing a valid MAC address or existing luci.ip.cidr
MAC address instance.
</li>
</ul>
<h3>Usage:</h3>
<pre>mac = luci.ip.checkmac(luci.ip.new("00-11-22-cc-dd-ee")) -- "00:11:22:CC:DD:EE"
mac = luci.ip.checkmac("00:11:22:cc:dd:ee") -- "00:11:22:CC:DD:EE"
mac = luci.ip.checkmac("nonesense") -- nothing
mac = luci.ip.checkmac(123) -- nothing
mac = luci.ip.checkmac(nil) -- nothing
mac = luci.ip.checkmac() -- nothing</pre>
<h3>Return value:</h3>
A string representing the given MAC address.
<h3>See also:</h3>
<ul>
<li><a href="#checkip4">
checkip4
</a>
<li><a href="#checkip6">
checkip6
</a>
</ul> </ul>
</dd> </dd>
@ -787,7 +1069,7 @@ A neighbour entry is a table containing the following fields:
</tr> </tr>
<tr> <tr>
<td><code>mac</code></td> <td><code>mac</code></td>
<td>String containing the associated MAC address</td> <td>MAC address <code>luci.ip.cidr</code> instance</td>
</tr> </tr>
<tr> <tr>
<td><code>router</code></td> <td><code>router</code></td>
@ -905,8 +1187,8 @@ described below is returned, else an empty table.
</tr> </tr>
<tr> <tr>
<td><code>mac</code></td> <td><code>mac</code></td>
<td>String containing the link local address of the device in <td>MAC address <code>luci.ip.cidr</code> instance representing the device ethernet
dotted hex notation</td> address</td>
</tr> </tr>
</table> </table>

535
libs/luci-lib-ip/src/ip.c
View file

@ -1,5 +1,5 @@
/* /*
Copyright 2015 Jo-Philipp Wich <jow@openwrt.org> Copyright 2015-2018 Jo-Philipp Wich <jo@mein.io>
Licensed under the Apache License, Version 2.0 (the "License"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
@ -42,6 +42,16 @@ limitations under the License.
#define RTA_INT(x) (*(int *)RTA_DATA(x)) #define RTA_INT(x) (*(int *)RTA_DATA(x))
#define RTA_U32(x) (*(uint32_t *)RTA_DATA(x)) #define RTA_U32(x) (*(uint32_t *)RTA_DATA(x))
#define AF_BITS(f) \
((f) == AF_INET ? 32 : \
((f) == AF_INET6 ? 128 : \
((f) == AF_PACKET ? 48 : 0)))
#define AF_BYTES(f) \
((f) == AF_INET ? 4 : \
((f) == AF_INET6 ? 16 : \
((f) == AF_PACKET ? 6 : 0)))
static int hz = 0; static int hz = 0;
static struct nl_sock *sock = NULL; static struct nl_sock *sock = NULL;
@ -49,11 +59,11 @@ typedef struct {
union { union {
struct in_addr v4; struct in_addr v4;
struct in6_addr v6; struct in6_addr v6;
struct ether_addr mac;
uint8_t u8[16];
} addr; } addr;
int len; uint16_t family;
int bits; int16_t bits;
int family;
bool exact;
} cidr_t; } cidr_t;
struct dump_filter { struct dump_filter {
@ -70,6 +80,8 @@ struct dump_filter {
cidr_t src; cidr_t src;
cidr_t dst; cidr_t dst;
struct ether_addr mac; struct ether_addr mac;
bool from_exact;
bool dst_exact;
}; };
struct dump_state { struct dump_state {
@ -95,29 +107,68 @@ static cidr_t *L_checkcidr (lua_State *L, int index, cidr_t *p)
return NULL; return NULL;
} }
static bool parse_mask(int family, const char *mask, int *bits) static bool parse_mac(const char *mac, struct ether_addr *ea)
{
unsigned long int n;
char *e, sep = 0;
int i;
for (i = 0; i < 6; i++)
{
if (i > 0)
{
if (sep == 0 && (mac[0] == ':' || mac[0] == '-'))
sep = mac[0];
if (sep == 0 || mac[0] != sep)
return false;
mac++;
}
n = strtoul(mac, &e, 16);
if (n > 0xFF)
return false;
mac += (e - mac);
ea->ether_addr_octet[i] = n;
}
if (mac[0] != 0)
return false;
return true;
}
static bool parse_mask(int family, const char *mask, int16_t *bits)
{ {
char *e; char *e;
struct in_addr m; union {
struct in6_addr m6; struct in_addr v4;
struct in6_addr v6;
struct ether_addr mac;
uint8_t u8[16];
} m;
if (family == AF_INET && inet_pton(AF_INET, mask, &m)) if (family == AF_INET && inet_pton(AF_INET, mask, &m.v4))
{ {
for (*bits = 0, m.s_addr = ntohl(m.s_addr); for (*bits = 0, m.v4.s_addr = ntohl(m.v4.s_addr);
*bits < 32 && (m.s_addr << *bits) & 0x80000000; *bits < AF_BITS(AF_INET) && (m.v4.s_addr << *bits) & 0x80000000;
++*bits); ++*bits);
} }
else if (family == AF_INET6 && inet_pton(AF_INET6, mask, &m6)) else if ((family == AF_INET6 && inet_pton(AF_INET6, mask, &m.v6)) ||
(family == AF_PACKET && parse_mac(mask, &m.mac)))
{ {
for (*bits = 0; for (*bits = 0;
*bits < 128 && (m6.s6_addr[*bits / 8] << (*bits % 8)) & 128; *bits < AF_BITS(family) && (m.u8[*bits / 8] << (*bits % 8)) & 128;
++*bits); ++*bits);
} }
else else
{ {
*bits = strtoul(mask, &e, 10); *bits = strtoul(mask, &e, 10);
if (e == mask || *e != 0 || *bits > ((family == AF_INET) ? 32 : 128)) if (e == mask || *e != 0 || *bits > AF_BITS(family))
return false; return false;
} }
@ -127,7 +178,6 @@ static bool parse_mask(int family, const char *mask, int *bits)
static bool parse_cidr(const char *dest, cidr_t *pp) static bool parse_cidr(const char *dest, cidr_t *pp)
{ {
char *p, buf[INET6_ADDRSTRLEN * 2 + 2]; char *p, buf[INET6_ADDRSTRLEN * 2 + 2];
uint8_t bitlen = 0;
strncpy(buf, dest, sizeof(buf) - 1); strncpy(buf, dest, sizeof(buf) - 1);
@ -137,17 +187,11 @@ static bool parse_cidr(const char *dest, cidr_t *pp)
*p++ = 0; *p++ = 0;
if (inet_pton(AF_INET, buf, &pp->addr.v4)) if (inet_pton(AF_INET, buf, &pp->addr.v4))
{
bitlen = 32;
pp->family = AF_INET; pp->family = AF_INET;
pp->len = sizeof(struct in_addr);
}
else if (inet_pton(AF_INET6, buf, &pp->addr.v6)) else if (inet_pton(AF_INET6, buf, &pp->addr.v6))
{
bitlen = 128;
pp->family = AF_INET6; pp->family = AF_INET6;
pp->len = sizeof(struct in6_addr); else if (parse_mac(buf, &pp->addr.mac))
} pp->family = AF_PACKET;
else else
return false; return false;
@ -158,12 +202,45 @@ static bool parse_cidr(const char *dest, cidr_t *pp)
} }
else else
{ {
pp->bits = bitlen; pp->bits = AF_BITS(pp->family);
} }
return true; return true;
} }
static int format_cidr(lua_State *L, cidr_t *p)
{
char buf[INET6_ADDRSTRLEN];
if (p->family == AF_PACKET)
{
snprintf(buf, sizeof(buf), "%02X:%02X:%02X:%02X:%02X:%02X",
p->addr.mac.ether_addr_octet[0],
p->addr.mac.ether_addr_octet[1],
p->addr.mac.ether_addr_octet[2],
p->addr.mac.ether_addr_octet[3],
p->addr.mac.ether_addr_octet[4],
p->addr.mac.ether_addr_octet[5]);
if (p->bits < AF_BITS(AF_PACKET))
lua_pushfstring(L, "%s/%d", buf, p->bits);
else
lua_pushstring(L, buf);
}
else
{
if (p->bits < AF_BITS(p->family))
lua_pushfstring(L, "%s/%d",
inet_ntop(p->family, &p->addr.v6, buf, sizeof(buf)),
p->bits);
else
lua_pushstring(L,
inet_ntop(p->family, &p->addr.v6, buf, sizeof(buf)));
}
return 1;
}
static int L_getint(lua_State *L, int index, const char *name) static int L_getint(lua_State *L, int index, const char *name)
{ {
int rv = 0; int rv = 0;
@ -220,16 +297,20 @@ static void L_setaddr(struct lua_State *L, const char *name,
if (family == AF_INET) if (family == AF_INET)
{ {
p->family = AF_INET; p->family = AF_INET;
p->bits = (bits < 0) ? 32 : bits; p->bits = (bits < 0) ? AF_BITS(AF_INET) : bits;
p->len = sizeof(p->addr.v4);
p->addr.v4 = *(struct in_addr *)addr; p->addr.v4 = *(struct in_addr *)addr;
} }
else if (family == AF_INET6)
{
p->family = AF_INET6;
p->bits = (bits < 0) ? AF_BITS(AF_INET6) : bits;
p->addr.v6 = *(struct in6_addr *)addr;
}
else else
{ {
p->family = AF_INET6; p->family = AF_PACKET;
p->bits = (bits < 0) ? 128 : bits; p->bits = (bits < 0) ? AF_BITS(AF_PACKET) : bits;
p->len = sizeof(p->addr.v6); p->addr.mac = *(struct ether_addr *)addr;
p->addr.v6 = *(struct in6_addr *)addr;
} }
luaL_getmetatable(L, LUCI_IP_CIDR); luaL_getmetatable(L, LUCI_IP_CIDR);
@ -254,6 +335,7 @@ static void L_setdev(struct lua_State *L, const char *name,
static int L_checkbits(lua_State *L, int index, cidr_t *p) static int L_checkbits(lua_State *L, int index, cidr_t *p)
{ {
int16_t s16;
int bits; int bits;
if (lua_gettop(L) < index || lua_isnil(L, index)) if (lua_gettop(L) < index || lua_isnil(L, index))
@ -264,13 +346,15 @@ static int L_checkbits(lua_State *L, int index, cidr_t *p)
{ {
bits = lua_tointeger(L, index); bits = lua_tointeger(L, index);
if (bits < 0 || bits > ((p->family == AF_INET) ? 32 : 128)) if (bits < 0 || bits > AF_BITS(p->family))
return luaL_error(L, "Invalid prefix size"); return luaL_error(L, "Invalid prefix size");
} }
else if (lua_type(L, index) == LUA_TSTRING) else if (lua_type(L, index) == LUA_TSTRING)
{ {
if (!parse_mask(p->family, lua_tostring(L, index), &bits)) if (!parse_mask(p->family, lua_tostring(L, index), &s16))
return luaL_error(L, "Invalid netmask format"); return luaL_error(L, "Invalid netmask format");
bits = s16;
} }
else else
{ {
@ -293,20 +377,26 @@ static int _cidr_new(lua_State *L, int index, int family, bool mask)
if (family == AF_INET6) if (family == AF_INET6)
{ {
cidr.family = AF_INET6; cidr.family = AF_INET6;
cidr.bits = 128;
cidr.len = sizeof(cidr.addr.v6);
cidr.addr.v6.s6_addr[12] = n; cidr.addr.v6.s6_addr[12] = n;
cidr.addr.v6.s6_addr[13] = (n >> 8); cidr.addr.v6.s6_addr[13] = (n >> 8);
cidr.addr.v6.s6_addr[14] = (n >> 16); cidr.addr.v6.s6_addr[14] = (n >> 16);
cidr.addr.v6.s6_addr[15] = (n >> 24); cidr.addr.v6.s6_addr[15] = (n >> 24);
} }
else else if (family == AF_INET)
{ {
cidr.family = AF_INET; cidr.family = AF_INET;
cidr.bits = 32;
cidr.len = sizeof(cidr.addr.v4);
cidr.addr.v4.s_addr = n; cidr.addr.v4.s_addr = n;
} }
else
{
cidr.family = AF_PACKET;
cidr.addr.mac.ether_addr_octet[2] = n;
cidr.addr.mac.ether_addr_octet[3] = (n >> 8);
cidr.addr.mac.ether_addr_octet[4] = (n >> 16);
cidr.addr.mac.ether_addr_octet[5] = (n >> 24);
}
cidr.bits = AF_BITS(cidr.family);
} }
else else
{ {
@ -346,6 +436,62 @@ static int cidr_ipv6(lua_State *L)
return _cidr_new(L, 1, AF_INET6, true); return _cidr_new(L, 1, AF_INET6, true);
} }
static int cidr_mac(lua_State *L)
{
return _cidr_new(L, 1, AF_PACKET, true);
}
static int cidr_check(lua_State *L, int family)
{
cidr_t cidr = { }, *cidrp;
const char *addr;
if (lua_type(L, 1) == LUA_TSTRING)
{
addr = lua_tostring(L, 1);
if (addr && parse_cidr(addr, &cidr) && cidr.family == family)
return format_cidr(L, &cidr);
}
else
{
cidrp = lua_touserdata(L, 1);
if (cidrp == NULL)
return 0;
if (!lua_getmetatable(L, 1))
return 0;
lua_getfield(L, LUA_REGISTRYINDEX, LUCI_IP_CIDR);
if (!lua_rawequal(L, -1, -2))
cidrp = NULL;
lua_pop(L, 2);
if (cidrp != NULL && cidrp->family == family)
return format_cidr(L, cidrp);
}
return 0;
}
static int cidr_checkip4(lua_State *L)
{
return cidr_check(L, AF_INET);
}
static int cidr_checkip6(lua_State *L)
{
return cidr_check(L, AF_INET6);
}
static int cidr_checkmac(lua_State *L)
{
return cidr_check(L, AF_PACKET);
}
static int cidr_is4(lua_State *L) static int cidr_is4(lua_State *L)
{ {
cidr_t *p = L_checkcidr(L, 1, NULL); cidr_t *p = L_checkcidr(L, 1, NULL);
@ -424,6 +570,34 @@ static int cidr_is6linklocal(lua_State *L)
return 1; return 1;
} }
static int cidr_ismac(lua_State *L)
{
cidr_t *p = L_checkcidr(L, 1, NULL);
lua_pushboolean(L, p->family == AF_PACKET);
return 1;
}
static int cidr_ismacmcast(lua_State *L)
{
cidr_t *p = L_checkcidr(L, 1, NULL);
lua_pushboolean(L, (p->family == AF_PACKET &&
(p->addr.mac.ether_addr_octet[0] & 0x1)));
return 1;
}
static int cidr_ismaclocal(lua_State *L)
{
cidr_t *p = L_checkcidr(L, 1, NULL);
lua_pushboolean(L, (p->family == AF_PACKET &&
(p->addr.mac.ether_addr_octet[0] & 0x2)));
return 1;
}
static int _cidr_cmp(lua_State *L) static int _cidr_cmp(lua_State *L)
{ {
cidr_t *a = L_checkcidr(L, 1, NULL); cidr_t *a = L_checkcidr(L, 1, NULL);
@ -432,7 +606,7 @@ static int _cidr_cmp(lua_State *L)
if (a->family != b->family) if (a->family != b->family)
return (a->family - b->family); return (a->family - b->family);
return memcmp(&a->addr.v6, &b->addr.v6, a->len); return memcmp(&a->addr.v6, &b->addr.v6, AF_BYTES(a->family));
} }
static int cidr_lower(lua_State *L) static int cidr_lower(lua_State *L)
@ -475,24 +649,24 @@ static void _apply_mask(cidr_t *p, int bits, bool inv)
if (bits <= 0) if (bits <= 0)
{ {
memset(&p->addr.v6, inv * 0xFF, p->len); memset(&p->addr.u8, inv * 0xFF, AF_BYTES(p->family));
} }
else if (p->family == AF_INET && bits <= 32) else if (p->family == AF_INET && bits <= AF_BITS(AF_INET))
{ {
if (inv) if (inv)
p->addr.v4.s_addr |= ntohl((1 << (32 - bits)) - 1); p->addr.v4.s_addr |= ntohl((1 << (AF_BITS(AF_INET) - bits)) - 1);
else else
p->addr.v4.s_addr &= ntohl(~((1 << (32 - bits)) - 1)); p->addr.v4.s_addr &= ntohl(~((1 << (AF_BITS(AF_INET) - bits)) - 1));
} }
else if (p->family == AF_INET6 && bits <= 128) else if (bits <= AF_BITS(p->family))
{ {
for (i = 0; i < sizeof(p->addr.v6.s6_addr); i++) for (i = 0; i < AF_BYTES(p->family); i++)
{ {
b = (bits > 8) ? 8 : bits; b = (bits > 8) ? 8 : bits;
if (inv) if (inv)
p->addr.v6.s6_addr[i] |= ~((uint8_t)(0xFF << (8 - b))); p->addr.u8[i] |= ~((uint8_t)(0xFF << (8 - b)));
else else
p->addr.v6.s6_addr[i] &= (uint8_t)(0xFF << (8 - b)); p->addr.u8[i] &= (uint8_t)(0xFF << (8 - b));
bits -= b; bits -= b;
} }
} }
@ -507,7 +681,7 @@ static int cidr_network(lua_State *L)
return 0; return 0;
*p2 = *p1; *p2 = *p1;
p2->bits = (p1->family == AF_INET) ? 32 : 128; p2->bits = AF_BITS(p1->family);
_apply_mask(p2, bits, false); _apply_mask(p2, bits, false);
luaL_getmetatable(L, LUCI_IP_CIDR); luaL_getmetatable(L, LUCI_IP_CIDR);
@ -524,7 +698,7 @@ static int cidr_host(lua_State *L)
return 0; return 0;
*p2 = *p1; *p2 = *p1;
p2->bits = (p1->family == AF_INET) ? 32 : 128; p2->bits = AF_BITS(p1->family);
luaL_getmetatable(L, LUCI_IP_CIDR); luaL_getmetatable(L, LUCI_IP_CIDR);
lua_setmetatable(L, -2); lua_setmetatable(L, -2);
@ -539,7 +713,7 @@ static int cidr_mask(lua_State *L)
if (!(p2 = lua_newuserdata(L, sizeof(*p2)))) if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
return 0; return 0;
p2->bits = (p1->family == AF_INET) ? 32 : 128; p2->bits = AF_BITS(p1->family);
p2->family = p1->family; p2->family = p1->family;
memset(&p2->addr.v6.s6_addr, 0xFF, sizeof(p2->addr.v6.s6_addr)); memset(&p2->addr.v6.s6_addr, 0xFF, sizeof(p2->addr.v6.s6_addr));
@ -556,14 +730,14 @@ static int cidr_broadcast(lua_State *L)
cidr_t *p2; cidr_t *p2;
int bits = L_checkbits(L, 2, p1); int bits = L_checkbits(L, 2, p1);
if (p1->family == AF_INET6) if (p1->family != AF_INET)
return 0; return 0;
if (!(p2 = lua_newuserdata(L, sizeof(*p2)))) if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
return 0; return 0;
*p2 = *p1; *p2 = *p1;
p2->bits = (p1->family == AF_INET) ? 32 : 128; p2->bits = AF_BITS(AF_INET);
_apply_mask(p2, bits, true); _apply_mask(p2, bits, true);
luaL_getmetatable(L, LUCI_IP_CIDR); luaL_getmetatable(L, LUCI_IP_CIDR);
@ -583,7 +757,7 @@ static int cidr_mapped4(lua_State *L)
return 0; return 0;
p2->family = AF_INET; p2->family = AF_INET;
p2->bits = (p1->bits > 32) ? 32 : p1->bits; p2->bits = (p1->bits > AF_BITS(AF_INET)) ? AF_BITS(AF_INET) : p1->bits;
memcpy(&p2->addr.v4, p1->addr.v6.s6_addr + 12, sizeof(p2->addr.v4)); memcpy(&p2->addr.v4, p1->addr.v6.s6_addr + 12, sizeof(p2->addr.v4));
luaL_getmetatable(L, LUCI_IP_CIDR); luaL_getmetatable(L, LUCI_IP_CIDR);
@ -591,6 +765,72 @@ static int cidr_mapped4(lua_State *L)
return 1; return 1;
} }
static int cidr_tolinklocal(lua_State *L)
{
cidr_t *p1 = L_checkcidr(L, 1, NULL);
cidr_t *p2;
int i;
if (p1->family != AF_PACKET)
return 0;
if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
return 0;
p2->family = AF_INET6;
p2->bits = AF_BITS(AF_INET6);
p2->addr.u8[0] = 0xFE;
p2->addr.u8[1] = 0x80;
p2->addr.u8[8] = p1->addr.u8[0] ^ 0x02;
p2->addr.u8[9] = p1->addr.u8[1];
p2->addr.u8[10] = p1->addr.u8[2];
p2->addr.u8[11] = 0xFF;
p2->addr.u8[12] = 0xFE;
p2->addr.u8[13] = p1->addr.u8[3];
p2->addr.u8[14] = p1->addr.u8[4];
p2->addr.u8[15] = p1->addr.u8[5];
luaL_getmetatable(L, LUCI_IP_CIDR);
lua_setmetatable(L, -2);
return 1;
}
static int cidr_tomac(lua_State *L)
{
cidr_t *p1 = L_checkcidr(L, 1, NULL);
cidr_t *p2;
int i;
if (p1->family != AF_INET6 ||
p1->addr.u8[0] != 0xFE ||
p1->addr.u8[1] != 0x80 ||
p1->addr.u8[2] != 0x00 ||
p1->addr.u8[3] != 0x00 ||
p1->addr.u8[4] != 0x00 ||
p1->addr.u8[5] != 0x00 ||
p1->addr.u8[6] != 0x00 ||
p1->addr.u8[7] != 0x00 ||
p1->addr.u8[11] != 0xFF ||
p1->addr.u8[12] != 0xFE)
return 0;
if (!(p2 = lua_newuserdata(L, sizeof(*p2))))
return 0;
p2->family = AF_PACKET;
p2->bits = AF_BITS(AF_PACKET);
p2->addr.u8[0] = p1->addr.u8[8] ^ 0x02;
p2->addr.u8[1] = p1->addr.u8[9];
p2->addr.u8[2] = p1->addr.u8[10];
p2->addr.u8[3] = p1->addr.u8[13];
p2->addr.u8[4] = p1->addr.u8[14];
p2->addr.u8[5] = p1->addr.u8[15];
luaL_getmetatable(L, LUCI_IP_CIDR);
lua_setmetatable(L, -2);
return 1;
}
static int cidr_contains(lua_State *L) static int cidr_contains(lua_State *L)
{ {
cidr_t *p1 = L_checkcidr(L, 1, NULL); cidr_t *p1 = L_checkcidr(L, 1, NULL);
@ -603,15 +843,15 @@ static int cidr_contains(lua_State *L)
_apply_mask(&a, p1->bits, false); _apply_mask(&a, p1->bits, false);
_apply_mask(&b, p1->bits, false); _apply_mask(&b, p1->bits, false);
rv = !memcmp(&a.addr.v6, &b.addr.v6, a.len); rv = !memcmp(&a.addr.v6, &b.addr.v6, AF_BYTES(a.family));
} }
lua_pushboolean(L, rv); lua_pushboolean(L, rv);
return 1; return 1;
} }
#define S6_BYTE(a, i) \ #define BYTE(a, i) \
(a)->addr.v6.s6_addr[sizeof((a)->addr.v6.s6_addr) - (i) - 1] (a)->addr.u8[AF_BYTES((a)->family) - (i) - 1]
static int _cidr_add_sub(lua_State *L, bool add) static int _cidr_add_sub(lua_State *L, bool add)
{ {
@ -625,30 +865,7 @@ static int _cidr_add_sub(lua_State *L, bool add)
if (p1->family == p2->family) if (p1->family == p2->family)
{ {
if (p1->family == AF_INET6) if (p1->family == AF_INET)
{
for (i = 0, carry = 0; i < sizeof(r.addr.v6.s6_addr); i++)
{
if (add)
{
S6_BYTE(&r, i) = S6_BYTE(p1, i) + S6_BYTE(p2, i) + carry;
carry = (S6_BYTE(p1, i) + S6_BYTE(p2, i) + carry) / 256;
}
else
{
S6_BYTE(&r, i) = (S6_BYTE(p1, i) - S6_BYTE(p2, i) - carry);
carry = (S6_BYTE(p1, i) < (S6_BYTE(p2, i) + carry));
}
}
/* would over/underflow */
if (carry)
{
memset(&r.addr.v6, add * 0xFF, sizeof(r.addr.v6));
ok = false;
}
}
else
{ {
a = ntohl(p1->addr.v4.s_addr); a = ntohl(p1->addr.v4.s_addr);
b = ntohl(p2->addr.v4.s_addr); b = ntohl(p2->addr.v4.s_addr);
@ -664,6 +881,29 @@ static int _cidr_add_sub(lua_State *L, bool add)
r.addr.v4.s_addr = add ? htonl(a + b) : htonl(a - b); r.addr.v4.s_addr = add ? htonl(a + b) : htonl(a - b);
} }
} }
else
{
for (i = 0, carry = 0; i < AF_BYTES(p1->family); i++)
{
if (add)
{
BYTE(&r, i) = BYTE(p1, i) + BYTE(p2, i) + carry;
carry = (BYTE(p1, i) + BYTE(p2, i) + carry) / 256;
}
else
{
BYTE(&r, i) = (BYTE(p1, i) - BYTE(p2, i) - carry);
carry = (BYTE(p1, i) < (BYTE(p2, i) + carry));
}
}
/* would over/underflow */
if (carry)
{
memset(&r.addr.u8, add * 0xFF, AF_BYTES(r.family));
ok = false;
}
}
} }
else else
{ {
@ -705,22 +945,22 @@ static int cidr_minhost(lua_State *L)
_apply_mask(&r, r.bits, false); _apply_mask(&r, r.bits, false);
if (r.family == AF_INET6 && r.bits < 128) if (r.family == AF_INET && r.bits < AF_BITS(AF_INET))
{ {
r.bits = 128; r.bits = AF_BITS(AF_INET);
r.addr.v4.s_addr = htonl(ntohl(r.addr.v4.s_addr) + 1);
}
else if (r.bits < AF_BITS(r.family))
{
r.bits = AF_BITS(r.family);
for (i = 0, carry = 1; i < sizeof(r.addr.v6.s6_addr); i++) for (i = 0, carry = 1; i < AF_BYTES(r.family); i++)
{ {
rest = (S6_BYTE(&r, i) + carry) > 255; rest = (BYTE(&r, i) + carry) > 255;
S6_BYTE(&r, i) += carry; BYTE(&r, i) += carry;
carry = rest; carry = rest;
} }
} }
else if (r.family == AF_INET && r.bits < 32)
{
r.bits = 32;
r.addr.v4.s_addr = htonl(ntohl(r.addr.v4.s_addr) + 1);
}
if (!(p = lua_newuserdata(L, sizeof(*p)))) if (!(p = lua_newuserdata(L, sizeof(*p))))
return 0; return 0;
@ -739,14 +979,14 @@ static int cidr_maxhost(lua_State *L)
_apply_mask(&r, r.bits, true); _apply_mask(&r, r.bits, true);
if (r.family == AF_INET && r.bits < 32) if (r.family == AF_INET && r.bits < AF_BITS(AF_INET))
{ {
r.bits = 32; r.bits = AF_BITS(AF_INET);
r.addr.v4.s_addr = htonl(ntohl(r.addr.v4.s_addr) - 1); r.addr.v4.s_addr = htonl(ntohl(r.addr.v4.s_addr) - 1);
} }
else if (r.family == AF_INET6) else
{ {
r.bits = 128; r.bits = AF_BITS(r.family);
} }
if (!(p = lua_newuserdata(L, sizeof(*p)))) if (!(p = lua_newuserdata(L, sizeof(*p))))
@ -766,31 +1006,17 @@ static int cidr_gc (lua_State *L)
static int cidr_tostring (lua_State *L) static int cidr_tostring (lua_State *L)
{ {
char buf[INET6_ADDRSTRLEN];
cidr_t *p = L_checkcidr(L, 1, NULL); cidr_t *p = L_checkcidr(L, 1, NULL);
return format_cidr(L, p);
if ((p->family == AF_INET && p->bits < 32) ||
(p->family == AF_INET6 && p->bits < 128))
{
lua_pushfstring(L, "%s/%d",
inet_ntop(p->family, &p->addr.v6, buf, sizeof(buf)),
p->bits);
}
else
{
lua_pushstring(L, inet_ntop(p->family, &p->addr.v6, buf, sizeof(buf)));
}
return 1;
} }
/* /*
* route functions * route functions
*/ */
static bool diff_prefix(int family, void *addr, int bits, cidr_t *p) static bool diff_prefix(int family, void *addr, int bits, bool exact, cidr_t *p)
{ {
uint8_t i, b, r; uint8_t i, b, r, *a;
uint32_t m; uint32_t m;
if (!p->family) if (!p->family)
@ -799,28 +1025,27 @@ static bool diff_prefix(int family, void *addr, int bits, cidr_t *p)
if (!addr || p->family != family || p->bits > bits) if (!addr || p->family != family || p->bits > bits)
return true; return true;
if (family == AF_INET6) if (family == AF_INET)
{ {
for (i = 0, r = p->bits; i < sizeof(struct in6_addr); i++) m = p->bits ? htonl(~((1 << (AF_BITS(AF_INET) - p->bits)) - 1)) : 0;
if ((((struct in_addr *)addr)->s_addr & m) != (p->addr.v4.s_addr & m))
return true;
}
else
{
for (i = 0, a = addr, r = p->bits; i < AF_BYTES(p->family); i++)
{ {
b = r ? (0xFF << (8 - ((r > 8) ? 8 : r))) : 0; b = r ? (0xFF << (8 - ((r > 8) ? 8 : r))) : 0;
if ((((struct in6_addr *)addr)->s6_addr[i] & b) != if ((a[i] & b) != (p->addr.u8[i] & b))
(p->addr.v6.s6_addr[i] & b))
return true; return true;
r -= ((r > 8) ? 8 : r); r -= ((r > 8) ? 8 : r);
} }
} }
else
{
m = p->bits ? htonl(~((1 << (32 - p->bits)) - 1)) : 0;
if ((((struct in_addr *)addr)->s_addr & m) != (p->addr.v4.s_addr & m)) return (exact && p->bits != bits);
return true;
}
return (p->exact && p->bits != bits);
} }
static int cb_dump_route(struct nl_msg *msg, void *arg) static int cb_dump_route(struct nl_msg *msg, void *arg)
@ -848,7 +1073,7 @@ static int cb_dump_route(struct nl_msg *msg, void *arg)
dst = tb[RTA_DST] ? RTA_DATA(tb[RTA_DST]) : &def; dst = tb[RTA_DST] ? RTA_DATA(tb[RTA_DST]) : &def;
gw = tb[RTA_GATEWAY] ? RTA_DATA(tb[RTA_GATEWAY]) : NULL; gw = tb[RTA_GATEWAY] ? RTA_DATA(tb[RTA_GATEWAY]) : NULL;
bitlen = (rt->rtm_family == AF_INET6) ? 128 : 32; bitlen = AF_BITS(rt->rtm_family);
if ((f->type && rt->rtm_type != f->type) || if ((f->type && rt->rtm_type != f->type) ||
(f->family && rt->rtm_family != f->family) || (f->family && rt->rtm_family != f->family) ||
@ -857,10 +1082,14 @@ static int cb_dump_route(struct nl_msg *msg, void *arg)
(f->iif && iif != f->iif) || (f->iif && iif != f->iif) ||
(f->oif && oif != f->oif) || (f->oif && oif != f->oif) ||
(f->table && table != f->table) || (f->table && table != f->table) ||
diff_prefix(rt->rtm_family, from, rt->rtm_src_len, &f->from) || diff_prefix(rt->rtm_family, from, rt->rtm_src_len,
diff_prefix(rt->rtm_family, dst, rt->rtm_dst_len, &f->dst) || f->from_exact, &f->from) ||
diff_prefix(rt->rtm_family, gw, bitlen, &f->gw) || diff_prefix(rt->rtm_family, dst, rt->rtm_dst_len,
diff_prefix(rt->rtm_family, src, bitlen, &f->src)) f->dst_exact, &f->dst) ||
diff_prefix(rt->rtm_family, gw, bitlen,
false, &f->gw) ||
diff_prefix(rt->rtm_family, src, bitlen,
false, &f->src))
goto out; goto out;
if (s->callback) if (s->callback)
@ -988,7 +1217,8 @@ static int _route_dump(lua_State *L, struct dump_filter *filter)
nlmsg_append(msg, &rtm, sizeof(rtm), 0); nlmsg_append(msg, &rtm, sizeof(rtm), 0);
if (filter->get) if (filter->get)
nla_put(msg, RTA_DST, filter->dst.len, &filter->dst.addr.v6); nla_put(msg, RTA_DST, AF_BYTES(filter->dst.family),
&filter->dst.addr.v6);
nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_dump_route, &s); nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, cb_dump_route, &s);
nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_done, &s); nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, cb_done, &s);
@ -1063,10 +1293,10 @@ static int route_dump(lua_State *L)
filter.dst = p; filter.dst = p;
if ((s = L_getstr(L, 1, "from_exact")) != NULL && parse_cidr(s, &p)) if ((s = L_getstr(L, 1, "from_exact")) != NULL && parse_cidr(s, &p))
filter.from = p, filter.from.exact = true; filter.from = p, filter.from_exact = true;
if ((s = L_getstr(L, 1, "dest_exact")) != NULL && parse_cidr(s, &p)) if ((s = L_getstr(L, 1, "dest_exact")) != NULL && parse_cidr(s, &p))
filter.dst = p, filter.dst.exact = true; filter.dst = p, filter.dst_exact = true;
} }
return _route_dump(L, &filter); return _route_dump(L, &filter);
@ -1107,12 +1337,12 @@ static int cb_dump_neigh(struct nl_msg *msg, void *arg)
mac = tb[NDA_LLADDR] ? RTA_DATA(tb[NDA_LLADDR]) : NULL; mac = tb[NDA_LLADDR] ? RTA_DATA(tb[NDA_LLADDR]) : NULL;
dst = tb[NDA_DST] ? RTA_DATA(tb[NDA_DST]) : NULL; dst = tb[NDA_DST] ? RTA_DATA(tb[NDA_DST]) : NULL;
bitlen = (nd->ndm_family == AF_INET) ? 32 : 128; bitlen = AF_BITS(nd->ndm_family);
if ((f->family && nd->ndm_family != f->family) || if ((f->family && nd->ndm_family != f->family) ||
(f->iif && nd->ndm_ifindex != f->iif) || (f->iif && nd->ndm_ifindex != f->iif) ||
(f->type && !(f->type & nd->ndm_state)) || (f->type && !(f->type & nd->ndm_state)) ||
diff_prefix(nd->ndm_family, dst, bitlen, &f->dst) || diff_prefix(nd->ndm_family, dst, bitlen, false, &f->dst) ||
diff_macaddr(mac, &f->mac)) diff_macaddr(mac, &f->mac))
goto out; goto out;
@ -1140,15 +1370,7 @@ static int cb_dump_neigh(struct nl_msg *msg, void *arg)
L_setaddr(s->L, "dest", nd->ndm_family, dst, -1); L_setaddr(s->L, "dest", nd->ndm_family, dst, -1);
if (mac) if (mac)
{ L_setaddr(s->L, "mac", AF_PACKET, mac, -1);
snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x",
mac->ether_addr_octet[0], mac->ether_addr_octet[1],
mac->ether_addr_octet[2], mac->ether_addr_octet[3],
mac->ether_addr_octet[4], mac->ether_addr_octet[5]);
lua_pushstring(s->L, buf);
lua_setfield(s->L, -2, "mac");
}
s->index++; s->index++;
@ -1241,7 +1463,7 @@ out:
static int cb_dump_link(struct nl_msg *msg, void *arg) static int cb_dump_link(struct nl_msg *msg, void *arg)
{ {
char *p, *addr, buf[48]; char buf[48];
struct dump_state *s = arg; struct dump_state *s = arg;
struct nlmsghdr *hdr = nlmsg_hdr(msg); struct nlmsghdr *hdr = nlmsg_hdr(msg);
struct ifinfomsg *ifm = NLMSG_DATA(hdr); struct ifinfomsg *ifm = NLMSG_DATA(hdr);
@ -1266,19 +1488,8 @@ static int cb_dump_link(struct nl_msg *msg, void *arg)
if (tb[IFLA_MASTER]) if (tb[IFLA_MASTER])
L_setdev(s->L, "master", tb[IFLA_MASTER]); L_setdev(s->L, "master", tb[IFLA_MASTER]);
if (tb[IFLA_ADDRESS]) if (tb[IFLA_ADDRESS] && nla_len(tb[IFLA_ADDRESS]) == AF_BYTES(AF_PACKET))
{ L_setaddr(s->L, "mac", AF_PACKET, nla_get_string(tb[IFLA_ADDRESS]), -1);
len = nla_len(tb[IFLA_ADDRESS]);
addr = nla_get_string(tb[IFLA_ADDRESS]);
if ((len * 3) <= sizeof(buf))
{
for (p = buf, i = 0; i < len; i++)
p += sprintf(p, "%s%02x", (i ? ":" : ""), (uint8_t)*addr++);
L_setstr(s->L, "mac", buf);
}
}
s->pending = 0; s->pending = 0;
return NL_SKIP; return NL_SKIP;
@ -1333,13 +1544,18 @@ static const luaL_reg ip_methods[] = {
{ "new", cidr_new }, { "new", cidr_new },
{ "IPv4", cidr_ipv4 }, { "IPv4", cidr_ipv4 },
{ "IPv6", cidr_ipv6 }, { "IPv6", cidr_ipv6 },
{ "MAC", cidr_mac },
{ "checkip4", cidr_checkip4 },
{ "checkip6", cidr_checkip6 },
{ "checkmac", cidr_checkmac },
{ "route", route_get }, { "route", route_get },
{ "routes", route_dump }, { "routes", route_dump },
{ "neighbors", neighbor_dump }, { "neighbors", neighbor_dump },
{ "link", link_get }, { "link", link_get },
{ } { }
}; };
@ -1351,6 +1567,9 @@ static const luaL_reg ip_cidr_methods[] = {
{ "is6", cidr_is6 }, { "is6", cidr_is6 },
{ "is6linklocal", cidr_is6linklocal }, { "is6linklocal", cidr_is6linklocal },
{ "is6mapped4", cidr_is6mapped4 }, { "is6mapped4", cidr_is6mapped4 },
{ "ismac", cidr_ismac },
{ "ismaclocal", cidr_ismaclocal },
{ "ismacmcast", cidr_ismacmcast },
{ "lower", cidr_lower }, { "lower", cidr_lower },
{ "higher", cidr_higher }, { "higher", cidr_higher },
{ "equal", cidr_equal }, { "equal", cidr_equal },
@ -1360,7 +1579,9 @@ static const luaL_reg ip_cidr_methods[] = {
{ "mask", cidr_mask }, { "mask", cidr_mask },
{ "broadcast", cidr_broadcast }, { "broadcast", cidr_broadcast },
{ "mapped4", cidr_mapped4 }, { "mapped4", cidr_mapped4 },
{ "contains", cidr_contains }, { "tomac", cidr_tomac },
{ "tolinklocal", cidr_tolinklocal },
{ "contains", cidr_contains },
{ "add", cidr_add }, { "add", cidr_add },
{ "sub", cidr_sub }, { "sub", cidr_sub },
{ "minhost", cidr_minhost }, { "minhost", cidr_minhost },

347
libs/luci-lib-ip/src/ip.luadoc
View file

@ -27,6 +27,7 @@ addr6 = luci.ip.new("fe80::221:63ff:fe75:aa17", "ffff:ffff:ffff:ffff::")
addr6 = luci.ip.new("fe80::221:63ff:fe75:aa17/64", 128) -- override netmask` addr6 = luci.ip.new("fe80::221:63ff:fe75:aa17/64", 128) -- override netmask`
@see IPv4 @see IPv4
@see IPv6 @see IPv6
@see MAC
]] ]]
---[[ ---[[
@ -47,6 +48,7 @@ addr = luci.ip.IPv4("10.24.0.1/255.255.255.0")
addr = luci.ip.IPv4("10.24.0.1", "255.255.255.0") -- separate netmask addr = luci.ip.IPv4("10.24.0.1", "255.255.255.0") -- separate netmask
addr = luci.ip.IPv4("10.24.0.1/24", 16) -- override netmask` addr = luci.ip.IPv4("10.24.0.1/24", 16) -- override netmask`
@see IPv6 @see IPv6
@see MAC
]] ]]
---[[ ---[[
@ -67,12 +69,112 @@ addr6 = luci.ip.IPv6("fe80::221:63ff:fe75:aa17/ffff:ffff:ffff:ffff::")
addr6 = luci.ip.IPv6("fe80::221:63ff:fe75:aa17", "ffff:ffff:ffff:ffff::") addr6 = luci.ip.IPv6("fe80::221:63ff:fe75:aa17", "ffff:ffff:ffff:ffff::")
addr6 = luci.ip.IPv6("fe80::221:63ff:fe75:aa17/64", 128) -- override netmask` addr6 = luci.ip.IPv6("fe80::221:63ff:fe75:aa17/64", 128) -- override netmask`
@see IPv4 @see IPv4
@see MAC
]]
---[[
Construct a new MAC luci.ip.cidr instance.
Throws an error if the given string does not represent a valid ethernet MAC
address or if the given optional mask is of a different family.
@class function
@sort 4
@name MAC
@param address String containing a valid ethernet MAC address, optionally with
prefix size (CIDR notation) or mask separated by slash.
@param netmask String containing a valid MAC address mask or number
containing a prefix size between `0` and `48` bit.
Overrides mask embedded in the first argument if specified. (optional)
@return A `luci.ip.cidr` object representing the given MAC address range.
@usage `intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00/24")
intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00/FF:FF:FF:0:0:0")
intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00", "FF:FF:FF:0:0:0")
intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00/24", 48) -- override mask`
@see IPv4
@see IPv6
]]
---[[
Verify an IPv4 address.
Checks whether given argument is a preexisting luci.ip.cidr IPv4 address
instance or a string literal convertible to an IPv4 address and returns a
plain Lua string containing the canonical representation of the address.
If the argument is not a valid address, returns nothing. This function is
intended to aid in safely verifying address literals without having to deal
with exceptions.
@class function
@sort 5
@name checkip4
@param address String containing a valid IPv4 address or existing
luci.ip.cidr IPv4 instance.
@return A string representing the given IPv4 address.
@usage `ipv4 = luci.ip.checkip4(luci.ip.new("127.0.0.1")) -- "127.0.0.1"
ipv4 = luci.ip.checkip4("127.0.0.1") -- "127.0.0.1"
ipv4 = luci.ip.checkip4("nonesense") -- nothing
ipv4 = luci.ip.checkip4(123) -- nothing
ipv4 = luci.ip.checkip4(nil) -- nothing
ipv4 = luci.ip.checkip4() -- nothing`
@see checkip6
@see checkmac
]]
---[[
Verify an IPv6 address.
Checks whether given argument is a preexisting luci.ip.cidr IPv6 address
instance or a string literal convertible to an IPv6 address and returns a
plain Lua string containing the canonical representation of the address.
If the argument is not a valid address, returns nothing. This function is
intended to aid in safely verifying address literals without having to deal
with exceptions.
@class function
@sort 6
@name checkip6
@param address String containing a valid IPv6 address or existing
luci.ip.cidr IPv6 instance.
@return A string representing the given IPv6 address.
@usage `ipv6 = luci.ip.checkip6(luci.ip.new("0:0:0:0:0:0:0:1")) -- "::1"
ipv6 = luci.ip.checkip6("0:0:0:0:0:0:0:1") -- "::1"
ipv6 = luci.ip.checkip6("nonesense") -- nothing
ipv6 = luci.ip.checkip6(123) -- nothing
ipv6 = luci.ip.checkip6(nil) -- nothing
ipv6 = luci.ip.checkip6() -- nothing`
@see checkip4
@see checkmac
]]
---[[
Verify an ethernet MAC address.
Checks whether given argument is a preexisting luci.ip.cidr MAC address
instance or a string literal convertible to an ethernet MAC and returns a
plain Lua string containing the canonical representation of the address.
If the argument is not a valid address, returns nothing. This function is
intended to aid in safely verifying address literals without having to deal
with exceptions.
@class function
@sort 7
@name checkmac
@param address String containing a valid MAC address or existing luci.ip.cidr
MAC address instance.
@return A string representing the given MAC address.
@usage `mac = luci.ip.checkmac(luci.ip.new("00-11-22-cc-dd-ee")) -- "00:11:22:CC:DD:EE"
mac = luci.ip.checkmac("00:11:22:cc:dd:ee") -- "00:11:22:CC:DD:EE"
mac = luci.ip.checkmac("nonesense") -- nothing
mac = luci.ip.checkmac(123) -- nothing
mac = luci.ip.checkmac(nil) -- nothing
mac = luci.ip.checkmac() -- nothing`
@see checkip4
@see checkip6
]] ]]
---[[ ---[[
Determine the route leading to the given destination. Determine the route leading to the given destination.
@class function @class function
@sort 4 @sort 8
@name route @name route
@param address A `luci.ip.cidr` instance or a string containing @param address A `luci.ip.cidr` instance or a string containing
a valid IPv4 or IPv6 range as specified by `luci.ip.new()`. a valid IPv4 or IPv6 range as specified by `luci.ip.new()`.
@ -178,7 +280,7 @@ end`</li>
---[[ ---[[
Fetch all routes, optionally matching the given criteria. Fetch all routes, optionally matching the given criteria.
@class function @class function
@sort 5 @sort 9
@name routes @name routes
@param filter <p>Table containing one or more of the possible filter @param filter <p>Table containing one or more of the possible filter
critera described below (optional)</p><table> critera described below (optional)</p><table>
@ -258,7 +360,7 @@ end`</li>
---[[ ---[[
Fetches entries from the IPv4 ARP and IPv6 neighbour kernel table Fetches entries from the IPv4 ARP and IPv6 neighbour kernel table
@class function @class function
@sort 6 @sort 10
@name neighbors @name neighbors
@param filter <p>Table containing one or more of the possible filter @param filter <p>Table containing one or more of the possible filter
critera described below (optional)</p><table> critera described below (optional)</p><table>
@ -306,7 +408,7 @@ A neighbour entry is a table containing the following fields:
</tr> </tr>
<tr> <tr>
<td>`mac`</td> <td>`mac`</td>
<td>String containing the associated MAC address</td> <td>MAC address `luci.ip.cidr` instance</td>
</tr> </tr>
<tr> <tr>
<td>`router`</td> <td>`router`</td>
@ -367,7 +469,7 @@ end)`</li>
---[[ ---[[
Fetch basic device information Fetch basic device information
@class function @class function
@sort 7 @sort 11
@name link @name link
@param device String containing the network device to query @param device String containing the network device to query
@return If the given interface is found, a table containing the fields @return If the given interface is found, a table containing the fields
@ -403,8 +505,8 @@ described below is returned, else an empty table.
</tr> </tr>
<tr> <tr>
<td>`mac`</td> <td>`mac`</td>
<td>String containing the link local address of the device in <td>MAC address `luci.ip.cidr` instance representing the device ethernet
dotted hex notation</td> address</td>
</tr> </tr>
</table> </table>
@usage <ul> @usage <ul>
@ -430,6 +532,7 @@ Checks whether the CIDR instance is an IPv4 address range
@sort 1 @sort 1
@name cidr.is4 @name cidr.is4
@see cidr.is6 @see cidr.is6
@see cidr.ismac
@return `true` if the CIDR is an IPv4 range, else `false` @return `true` if the CIDR is an IPv4 range, else `false`
]] ]]
@ -470,6 +573,7 @@ Checks whether the CIDR instance is an IPv6 address range
@sort 4 @sort 4
@name cidr.is6 @name cidr.is6
@see cidr.is4 @see cidr.is4
@see cidr.ismac
@return `true` if the CIDR is an IPv6 range, else `false` @return `true` if the CIDR is an IPv6 range, else `false`
]] ]]
@ -502,13 +606,51 @@ end`
]] ]]
---[[ ---[[
Checks whether this CIDR instance is lower than the given argument. Checks whether the CIDR instance is an ethernet MAC address range
The comparisation follows these rules:
<ul><li>An IPv4 address is always lower than an IPv6 address</li>
<li>Prefix sizes are ignored</li></ul>
@class function @class function
@sort 7 @sort 7
@name cidr.ismac
@see cidr.is4
@see cidr.is6
@return `true` if the CIDR is a MAC address range, else `false`
]]
---[[
Checks whether the CIDR instance is a locally administered (LAA) MAC address
@class function
@sort 8
@name cidr.ismaclocal
@return `true` if the MAC address sets the locally administered bit.
@usage `local mac = luci.ip.new("02:C0:FF:EE:00:01")
if mac:ismaclocal() then
print("Is an LAA MAC address")
end`
]]
---[[
Checks whether the CIDR instance is a multicast MAC address
@class function
@sort 9
@name cidr.ismacmcast
@return `true` if the MAC address sets the multicast bit.
@usage `local mac = luci.ip.new("01:00:5E:7F:00:10")
if addr:ismacmcast() then
print("Is a multicast MAC address")
end`
]]
---[[
Checks whether this CIDR instance is lower than the given argument.
The comparisation follows these rules:
<ul><li>An IPv4 address is always lower than an IPv6 address and IPv6 addresses
are considered lower than MAC addresses</li>
<li>Prefix sizes are ignored</li></ul>
@class function
@sort 10
@name cidr.lower @name cidr.lower
@param addr A `luci.ip.cidr` instance or a string convertable by @param addr A `luci.ip.cidr` instance or a string convertable by
`luci.ip.new()` to compare against. `luci.ip.new()` to compare against.
@ -518,7 +660,8 @@ The comparisation follows these rules:
print(addr:lower(addr)) -- false print(addr:lower(addr)) -- false
print(addr:lower("10.10.10.10/24")) -- false print(addr:lower("10.10.10.10/24")) -- false
print(addr:lower(luci.ip.new("::1"))) -- true print(addr:lower(luci.ip.new("::1"))) -- true
print(addr:lower(luci.ip.new("192.168.200.1"))) -- true` print(addr:lower(luci.ip.new("192.168.200.1"))) -- true
print(addr:lower(luci.ip.new("00:14:22:01:23:45"))) -- true`
@see cidr.higher @see cidr.higher
@see cidr.equal @see cidr.equal
]] ]]
@ -526,11 +669,12 @@ print(addr:lower(luci.ip.new("192.168.200.1"))) -- true`
---[[ ---[[
Checks whether this CIDR instance is higher than the given argument. Checks whether this CIDR instance is higher than the given argument.
The comparisation follows these rules: The comparisation follows these rules:
<ul><li>An IPv4 address is always lower than an IPv6 address</li> <ul><li>An IPv4 address is always lower than an IPv6 address and IPv6 addresses
are considered lower than MAC addresses</li>
<li>Prefix sizes are ignored</li></ul> <li>Prefix sizes are ignored</li></ul>
@class function @class function
@sort 8 @sort 11
@name cidr.higher @name cidr.higher
@param addr A `luci.ip.cidr` instance or a string convertable by @param addr A `luci.ip.cidr` instance or a string convertable by
`luci.ip.new()` to compare against. `luci.ip.new()` to compare against.
@ -540,7 +684,8 @@ The comparisation follows these rules:
print(addr:higher(addr)) -- false print(addr:higher(addr)) -- false
print(addr:higher("10.10.10.10/24")) -- true print(addr:higher("10.10.10.10/24")) -- true
print(addr:higher(luci.ip.new("::1"))) -- false print(addr:higher(luci.ip.new("::1"))) -- false
print(addr:higher(luci.ip.new("192.168.200.1"))) -- false` print(addr:higher(luci.ip.new("192.168.200.1"))) -- false
print(addr:higher(luci.ip.new("00:14:22:01:23:45"))) -- false`
@see cidr.lower @see cidr.lower
@see cidr.equal @see cidr.equal
]] ]]
@ -549,7 +694,7 @@ print(addr:higher(luci.ip.new("192.168.200.1"))) -- false`
Checks whether this CIDR instance is equal to the given argument. Checks whether this CIDR instance is equal to the given argument.
@class function @class function
@sort 9 @sort 12
@name cidr.equal @name cidr.equal
@param addr A `luci.ip.cidr` instance or a string convertable by @param addr A `luci.ip.cidr` instance or a string convertable by
`luci.ip.new()` to compare against. `luci.ip.new()` to compare against.
@ -562,7 +707,11 @@ print(addr:equal(luci.ip.new("::1"))) -- false
local addr6 = luci.ip.new("::1") local addr6 = luci.ip.new("::1")
print(addr6:equal("0:0:0:0:0:0:0:1/64")) -- true print(addr6:equal("0:0:0:0:0:0:0:1/64")) -- true
print(addr6:equal(luci.ip.new("fe80::221:63ff:fe75:aa17"))) -- false` print(addr6:equal(luci.ip.new("fe80::221:63ff:fe75:aa17"))) -- false
local mac = luci.ip.new("00:14:22:01:23:45")
print(mac:equal("0:14:22:1:23:45")) -- true
print(mac:equal(luci.ip.new("01:23:45:67:89:AB")) -- false`
@see cidr.lower @see cidr.lower
@see cidr.higher @see cidr.higher
]] ]]
@ -573,11 +722,11 @@ If the optional mask parameter is given, the prefix size of this CIDR is altered
else the current prefix size is returned. else the current prefix size is returned.
@class function @class function
@sort 10 @sort 13
@name cidr.prefix @name cidr.prefix
@param mask Either a number containing the number of bits (`0..32` @param mask Either a number containing the number of bits (`0..32`
for IPv4, `0..128` for IPv6) or a string containing a valid for IPv4, `0..128` for IPv6 or `0..48` for MAC addresses) or a string
netmask (optional) containing a valid netmask (optional)
@return Bit count of the current prefix size @return Bit count of the current prefix size
@usage `local range = luci.ip.new("192.168.1.1/255.255.255.0") @usage `local range = luci.ip.new("192.168.1.1/255.255.255.0")
print(range:prefix()) -- 24 print(range:prefix()) -- 24
@ -597,11 +746,11 @@ with all host parts masked out. The used prefix size can be overridden by the
optional mask parameter. optional mask parameter.
@class function @class function
@sort 11 @sort 14
@name cidr.network @name cidr.network
@param mask Either a number containing the number of bits (`0..32` @param mask Either a number containing the number of bits (`0..32`
for IPv4, `0..128` for IPv6) or a string containing a valid for IPv4, `0..128` for IPv6 or `0..48` for MAC addresses) or a string
netmask (optional) containing a valid netmask (optional)
@return CIDR instance representing the network address @return CIDR instance representing the network address
@usage `local range = luci.ip.new("192.168.62.243/255.255.0.0") @usage `local range = luci.ip.new("192.168.62.243/255.255.0.0")
print(range:network()) -- "192.168.0.0" print(range:network()) -- "192.168.0.0"
@ -616,10 +765,10 @@ print(range6:network()) -- "fd9b:62b3:9cc5::"`
Derive host address of CIDR instance. Derive host address of CIDR instance.
This function essentially constructs a copy of this CIDR with the prefix size This function essentially constructs a copy of this CIDR with the prefix size
set to `32` for IPv4 and `128` for IPv6. set to `32` for IPv4, `128` for IPv6 or `48` for MAC addresses.
@class function @class function
@sort 12 @sort 15
@name cidr.host @name cidr.host
@return CIDR instance representing the host address @return CIDR instance representing the host address
@usage `local range = luci.ip.new("172.19.37.45/16") @usage `local range = luci.ip.new("172.19.37.45/16")
@ -634,11 +783,11 @@ Constructs a CIDR instance representing the netmask of this instance. The used
prefix size can be overridden by the optional mask parameter. prefix size can be overridden by the optional mask parameter.
@class function @class function
@sort 13 @sort 16
@name cidr.mask @name cidr.mask
@param mask Either a number containing the number of bits (`0..32` @param mask Either a number containing the number of bits (`0..32`
for IPv4, `0..128` for IPv6) or a string containing a valid for IPv4, `0..128` for IPv6 or `0..48` for MAC addresses) or a string
netmask (optional) containing a valid netmask (optional)
@return CIDR instance representing the netmask @return CIDR instance representing the netmask
@usage `local range = luci.ip.new("172.19.37.45/16") @usage `local range = luci.ip.new("172.19.37.45/16")
print(range:mask()) -- "255.255.0.0" print(range:mask()) -- "255.255.0.0"
@ -652,15 +801,14 @@ Derive broadcast address of CIDR instance.
Constructs a CIDR instance representing the broadcast address of this instance. Constructs a CIDR instance representing the broadcast address of this instance.
The used prefix size can be overridden by the optional mask parameter. The used prefix size can be overridden by the optional mask parameter.
This function has no effect on IPv6 instances, it will return nothing in this This function has no effect on IPv6 or MAC address instances, it will return
case. nothing in this case.
@class function @class function
@sort 14 @sort 17
@name cidr.broadcast @name cidr.broadcast
@param mask Either a number containing the number of bits (`0..32` @param mask Either a number containing the number of bits (`0..32` for IPv4) or
for IPv4, `0..128` for IPv6) or a string containing a valid a string containing a valid netmask (optional)
netmask (optional)
@return Return a new CIDR instance representing the broadcast address if this @return Return a new CIDR instance representing the broadcast address if this
instance is an IPv4 range, else return nothing. instance is an IPv4 range, else return nothing.
@usage `local range = luci.ip.new("172.19.37.45/16") @usage `local range = luci.ip.new("172.19.37.45/16")
@ -675,11 +823,11 @@ Derive mapped IPv4 address of CIDR instance.
Constructs a CIDR instance representing the IPv4 address of the IPv6 mapped Constructs a CIDR instance representing the IPv4 address of the IPv6 mapped
IPv4 address in this instance. IPv4 address in this instance.
This function has no effect on IPv4 instances or IPv6 instances which are not a This function has no effect on IPv4 instances, MAC address instances or IPv6
mapped address, it will return nothing in this case. instances which are not a mapped address, it will return nothing in this case.
@class function @class function
@sort 15 @sort 18
@name cidr.mapped4 @name cidr.mapped4
@return Return a new CIDR instance representing the IPv4 address if this @return Return a new CIDR instance representing the IPv4 address if this
instance is an IPv6 mapped IPv4 address, else return nothing. instance is an IPv6 mapped IPv4 address, else return nothing.
@ -687,11 +835,47 @@ mapped address, it will return nothing in this case.
print(addr:mapped4()) -- "172.16.19.1"` print(addr:mapped4()) -- "172.16.19.1"`
]] ]]
---[[
Derive MAC address of IPv6 link local CIDR instance.
Constructs a CIDR instance representing the MAC address contained in the IPv6
link local address of this instance.
This function has no effect on IPv4 instances, MAC address instances or IPv6
instances which are not a link local address, it will return nothing in this
case.
@class function
@sort 19
@name cidr.tomac
@return Return a new CIDR instance representing the MAC address if this
instance is an IPv6 link local address, else return nothing.
@usage `local addr = luci.ip.new("fe80::6666:b3ff:fe47:e1b9")
print(addr:tomac()) -- "64:66:B3:47:E1:B9"`
]]
---[[
Derive IPv6 link local address from MAC address CIDR instance.
Constructs a CIDR instance representing the IPv6 link local address of the
MAC address represented by this instance.
This function has no effect on IPv4 instances or IPv6 instances, it will return
nothing in this case.
@class function
@sort 20
@name cidr.tolinklocal
@return Return a new CIDR instance representing the IPv6 link local address.
@usage `local mac = luci.ip.new("64:66:B3:47:E1:B9")
print(mac:tolinklocal()) -- "fe80::6666:b3ff:fe47:e1b9"`
]]
---[[ ---[[
Test whether CIDR contains given range. Test whether CIDR contains given range.
@class function @class function
@sort 16 @sort 21
@name cidr.contains @name cidr.contains
@param addr A `luci.ip.cidr` instance or a string convertable by @param addr A `luci.ip.cidr` instance or a string convertable by
`luci.ip.new()` to test. `luci.ip.new()` to test.
@ -704,7 +888,11 @@ print(range:contains("10.0.0.0/8")) -- false
local range6 = luci.ip.new("fe80::/10") local range6 = luci.ip.new("fe80::/10")
print(range6:contains("fe80::221:63f:fe75:aa17/64")) -- true print(range6:contains("fe80::221:63f:fe75:aa17/64")) -- true
print(range6:contains("fd9b:6b3:c5:0:221:63f:fe75:aa17/64")) -- false` print(range6:contains("fd9b:6b3:c5:0:221:63f:fe75:aa17/64")) -- false
local intel_macs = luci.ip.MAC("C0:B6:F9:00:00:00/24")
print(intel_macs:contains("C0:B6:F9:A3:C:11")) -- true
print(intel_macs:contains("64:66:B3:47:E1:B9")) -- false`
]] ]]
---[[ ---[[
@ -712,7 +900,7 @@ Add given amount to CIDR instance. If the result would overflow the maximum
address space, the result is set to the highest possible address. address space, the result is set to the highest possible address.
@class function @class function
@sort 17 @sort 22
@name cidr.add @name cidr.add
@param amount A numeric value between 0 and 0xFFFFFFFF, a @param amount A numeric value between 0 and 0xFFFFFFFF, a
`luci.ip.cidr` instance or a string convertable by `luci.ip.cidr` instance or a string convertable by
@ -726,32 +914,42 @@ address space, the result is set to the highest possible address.
this instance plus the added amount or the highest possible address if this instance plus the added amount or the highest possible address if
the addition overflowed the available address space.</li></ul> the addition overflowed the available address space.</li></ul>
@usage `local addr = luci.ip.new("192.168.1.1/24") @usage `local addr = luci.ip.new("192.168.1.1/24")
print(addr:add(250)) -- "192.168.1.251/24" print(addr:add(250)) -- "192.168.1.251/24"
print(addr:add("0.0.99.0")) -- "192.168.100.1/24" print(addr:add("0.0.99.0")) -- "192.168.100.1/24"
addr:add(256, true) -- true addr:add(256, true) -- true
print(addr) -- "192.168.2.1/24 print(addr) -- "192.168.2.1/24
addr:add("255.0.0.0", true) -- false (overflow) addr:add("255.0.0.0", true) -- false (overflow)
print(addr) -- "255.255.255.255/24 print(addr) -- "255.255.255.255/24
local addr6 = luci.ip.new("fe80::221:63f:fe75:aa17/64") local addr6 = luci.ip.new("fe80::221:63f:fe75:aa17/64")
print(addr6:add(256)) -- "fe80::221:63f:fe75:ab17/64" print(addr6:add(256)) -- "fe80::221:63f:fe75:ab17/64"
print(addr6:add("::ffff:0")) -- "fe80::221:640:fe74:aa17/64" print(addr6:add("::ffff:0")) -- "fe80::221:640:fe74:aa17/64"
addr:add(256, true) -- true addr6:add(256, true) -- true
print(addr) -- "fe80::221:63f:fe75:ab17/64 print(addr6) -- "fe80::221:63f:fe75:ab17/64
addr:add("ffff::", true) -- false (overflow) addr6:add("ffff::", true) -- false (overflow)
print(addr) -- "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/64"` print(addr6) -- "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/64"
local mac = luci.ip.new("00:14:22:01:23:45")
print(mac:add(256)) -- "00:14:22:01:24:45"
print(mac:add("0:0:0:0:FF:0") -- "00:14:22:02:22:45"
mac:add(256, true) -- true
print(mac) -- "00:14:22:01:24:45"
mac:add("FF:FF:0:0:0:0", true) -- false (overflow)
print(mac) -- "FF:FF:FF:FF:FF:FF"`
]] ]]
---[[ ---[[
Substract given amount from CIDR instance. If the result would under, the lowest Subtract given amount from CIDR instance. If the result would under, the lowest
possible address is returned. possible address is returned.
@class function @class function
@sort 18 @sort 23
@name cidr.sub @name cidr.sub
@param amount A numeric value between 0 and 0xFFFFFFFF, a @param amount A numeric value between 0 and 0xFFFFFFFF, a
`luci.ip.cidr` instance or a string convertable by `luci.ip.cidr` instance or a string convertable by
@ -759,11 +957,11 @@ possible address is returned.
@param inplace If `true`, modify this instance instead of returning @param inplace If `true`, modify this instance instead of returning
a new derived CIDR instance. a new derived CIDR instance.
@return <ul> @return <ul>
<li>When substracting inplace: Return `true` if the substraction <li>When subtracting inplace: Return `true` if the subtraction
succeded or `false` when the substraction underflowed.</li> succeeded or `false` when the subtraction underflowed.</li>
<li>When deriving new CIDR: Return new instance representing the value of <li>When deriving new CIDR: Return new instance representing the value of
this instance minus the substracted amount or the lowest address if this instance minus the subtracted amount or the lowest address if
the substraction underflowed.</li></ul> the subtraction underflowed.</li></ul>
@usage `local addr = luci.ip.new("192.168.1.1/24") @usage `local addr = luci.ip.new("192.168.1.1/24")
print(addr:sub(256)) -- "192.168.0.1/24" print(addr:sub(256)) -- "192.168.0.1/24"
print(addr:sub("0.168.0.0")) -- "192.0.1.1/24" print(addr:sub("0.168.0.0")) -- "192.0.1.1/24"
@ -782,14 +980,24 @@ addr:sub(256, true) -- true
print(addr) -- "fe80::221:63f:fe75:a917/64" print(addr) -- "fe80::221:63f:fe75:a917/64"
addr:sub("ffff::", true) -- false (underflow) addr:sub("ffff::", true) -- false (underflow)
print(addr) -- "::/64"` print(addr) -- "::/64"
local mac = luci.ip.new("00:14:22:01:23:45")
print(mac:sub(256)) -- "00:14:22:01:22:45"
print(mac:sub("0:0:0:0:FF:0") -- "00:14:22:00:24:45"
mac:sub(256, true) -- true
print(mac) -- "00:14:22:01:22:45"
mac:sub("FF:FF:0:0:0:0", true) -- false (overflow)
print(mac) -- "00:00:00:00:00:00"`
]] ]]
---[[ ---[[
Calculate the lowest possible host address within this CIDR instance. Calculate the lowest possible host address within this CIDR instance.
@class function @class function
@sort 19 @sort 24
@name cidr.minhost @name cidr.minhost
@return Returns a new CIDR instance representing the lowest host address @return Returns a new CIDR instance representing the lowest host address
within this range. within this range.
@ -797,14 +1005,17 @@ Calculate the lowest possible host address within this CIDR instance.
print(addr:minhost()) -- "192.168.123.1" print(addr:minhost()) -- "192.168.123.1"
local addr6 = luci.ip.new("fd9b:62b3:9cc5:0:221:63ff:fe75:aa17/64") local addr6 = luci.ip.new("fd9b:62b3:9cc5:0:221:63ff:fe75:aa17/64")
print(addr6:minhost()) -- "fd9b:62b3:9cc5::1"` print(addr6:minhost()) -- "fd9b:62b3:9cc5::1"
local mac = luci.ip.new("00:14:22:01:22:45/32")
print(mac:minhost()) -- "00:14:22:01:00:01"`
]] ]]
---[[ ---[[
Calculate the highest possible host address within this CIDR instance. Calculate the highest possible host address within this CIDR instance.
@class function @class function
@sort 20 @sort 25
@name cidr.maxhost @name cidr.maxhost
@return Returns a new CIDR instance representing the highest host address @return Returns a new CIDR instance representing the highest host address
within this range. within this range.
@ -812,20 +1023,24 @@ Calculate the highest possible host address within this CIDR instance.
print(addr:maxhost()) -- "192.168.123.254" (.255 is broadcast) print(addr:maxhost()) -- "192.168.123.254" (.255 is broadcast)
local addr6 = luci.ip.new("fd9b:62b3:9cc5:0:221:63ff:fe75:aa17/64") local addr6 = luci.ip.new("fd9b:62b3:9cc5:0:221:63ff:fe75:aa17/64")
print(addr6:maxhost()) -- "fd9b:62b3:9cc5:0:ffff:ffff:ffff:ffff"` print(addr6:maxhost()) -- "fd9b:62b3:9cc5:0:ffff:ffff:ffff:ffff"
local mac = luci.ip.new("00:14:22:01:22:45/32")
print(mac:maxhost()) -- "00:14:22:01:FF:FF"`
]] ]]
---[[ ---[[
Convert CIDR instance into string representation. Convert CIDR instance into string representation.
If the prefix size of instance is less than 32 for IPv4 or 128 for IPv6, the If the prefix size of instance is less than 32 for IPv4, 128 for IPv6 or 48 for
address is returned in the form "address/prefix" otherwise just "address". MACs, the address is returned in the form "address/prefix" otherwise just
"address".
It is usually not required to call this function directly as CIDR objects It is usually not required to call this function directly as CIDR objects
define it as __tostring function in the associated metatable. define it as __tostring function in the associated metatable.
@class function @class function
@sort 21 @sort 26
@name cidr.string @name cidr.string
@return Returns a string representing the range or address of this CIDR instance @return Returns a string representing the range or address of this CIDR instance
]] ]]