···
1
+
/* See: https://github.com/djacu/nixpkgs/blob/adb22cf/lib/network.nix */
6
+
Converts an IP address from a list of ints to a string.
8
+
Type: prettyIp :: [ Int ] -> String
11
+
prettyIp [ 192 168 70 9 ]
15
+
lib.concatStringsSep "." (builtins.map builtins.toString addr);
18
+
Given a bit mask, return the associated subnet mask.
20
+
Type: bitMaskToSubnetMask :: Int -> [ Int ]
23
+
bitMaskToSubnetMask 15
25
+
bitMaskToSubnetMask 24
26
+
=> [ 255 255 255 0 ]
28
+
bitMaskToSubnetMask = bitMask: let
33
+
# How many initial parts of the mask are full (=255)
34
+
fullParts = bitMask / octetBits;
38
+
# Fill up initial full parts
41
+
# If we're above the first non-full part, fill with 0
42
+
else if fullParts < idx
44
+
# First non-full part generation
45
+
else _genPartialMask (lib.mod bitMask octetBits)
50
+
Generate a the partial portion of a subnet mask.
52
+
Type: _genPartialMask :: Int -> Int
72
+
_genPartialMask = n:
75
+
else _genPartialMask (n - 1) / 2 + 128;
78
+
Given a subnet mask, return the associated bit mask.
80
+
Type: subnetMaskToBitMask :: [ Int ] -> Int
83
+
subnetMaskToBitMask [ 255 254 0 0 ]
85
+
subnetMaskToBitMask [ 255 255 255 0 ]
88
+
subnetMaskToBitMask = subnetMask: let
89
+
partialBits = octet:
92
+
else (lib.mod octet 2) + partialBits (octet / 2);
97
+
(builtins.map partialBits subnetMask);
100
+
Given a CIDR, return the IP Address.
102
+
Type: cidrToIpAddress :: String -> [ Int ]
105
+
cidrToIpAddress "192.168.70.9/15"
106
+
=> [ 192 168 70 9 ]
108
+
cidrToIpAddress = cidr: let
109
+
splitParts = lib.splitString "/" cidr;
110
+
addr = lib.elemAt splitParts 0;
114
+
(builtins.match "([0-9]+)\\.([0-9]+)\\.([0-9]+)\\.([0-9]+)" addr);
115
+
checkBounds = octet:
116
+
(octet >= 0) && (octet <= 255);
118
+
if (builtins.all checkBounds parsed)
120
+
else builtins.throw "IP ${prettyIp addr} has out of bounds octet(s)";
123
+
Given a CIDR, return the bitmask.
125
+
Type: cidrToBitMask :: String -> Int
128
+
cidrToBitMask "192.168.70.9/15"
131
+
cidrToBitMask = cidr: let
132
+
splitParts = lib.splitString "/" cidr;
133
+
mask = lib.toInt (lib.elemAt splitParts 1);
134
+
checkBounds = mask:
135
+
(mask >= 0) && (mask <= 32);
137
+
if (checkBounds mask)
139
+
else builtins.throw "Bitmask ${builtins.toString mask} is invalid.";
142
+
Given a CIDR, return the associated subnet mask.
144
+
Type: cidrToSubnetMask :: String -> [ Int ]
147
+
cidrToSubnetMask "192.168.70.9/15"
150
+
cidrToSubnetMask = cidr:
151
+
bitMaskToSubnetMask (cidrToBitMask cidr);
154
+
Given a CIDR, return the associated network ID.
156
+
Type: cidrToNetworkId :: String -> [ Int ]
159
+
cidrToNetworkId "192.168.70.9/15"
162
+
cidrToNetworkId = cidr: let
163
+
ip = cidrToIpAddress cidr;
164
+
subnetMask = cidrToSubnetMask cidr;
166
+
lib.zipListsWith lib.bitAnd ip subnetMask;
169
+
Given a CIDR, return the associated first usable IP address.
171
+
Type: cidrToFirstUsableIp :: String -> [ Int ]
174
+
cidrToFirstUsableIp "192.168.70.9/15"
177
+
cidrToFirstUsableIp = cidr: let
178
+
networkId = cidrToNetworkId cidr;
180
+
incrementIp networkId 1;
183
+
Given a CIDR, return the associated broadcast address.
185
+
Type: cidrToBroadcastAddress :: String -> [ Int ]
188
+
cidrToBroadcastAddress "192.168.70.9/15"
189
+
=> [ 192 169 255 255 ]
191
+
cidrToBroadcastAddress = cidr: let
192
+
subnetMask = cidrToSubnetMask cidr;
193
+
networkId = cidrToNetworkId cidr;
195
+
getBroadcastAddress networkId subnetMask;
198
+
Given a network ID and subnet mask, return the associated broadcast address.
200
+
Type: getBroadcastAddress :: [ Int ] -> [ Int ] -> [ Int ]
203
+
getBroadcastAddress [ 192 168 0 0 ] [ 255 254 0 0 ]
204
+
=> [ 192 169 255 255 ]
206
+
getBroadcastAddress = networkId: subnetMask:
207
+
lib.zipListsWith (nid: mask: 255 - mask + nid) networkId subnetMask;
210
+
Given a CIDR, return the associated last usable IP address.
212
+
Type: cidrToLastUsableIp :: String -> [ Int ]
215
+
cidrToLastUsableIp "192.168.70.9/15"
216
+
=> [ 192 169 255 254 ]
218
+
cidrToLastUsableIp = cidr: let
219
+
broadcast = cidrToBroadcastAddress cidr;
221
+
incrementIp broadcast (-1);
224
+
Increment the last octet of a given IP address.
226
+
Type: incrementIp :: [ Int ] -> Int -> [ Int ]
229
+
incrementIp [ 192 168 70 9 ] 3
230
+
=> [ 192 168 70 12 ]
231
+
incrementIp [ 192 168 70 9 ] (-2)
232
+
=> [ 192 168 70 7 ]
234
+
incrementIp = addr: offset: let
235
+
lastOctet = lib.last addr;
236
+
firstThree = lib.init addr;
238
+
firstThree ++ [(lastOctet + offset)];
241
+
Given an IP address and bit mask, return the associated CIDR.
243
+
Type: ipAndBitMaskToCidr :: [ Int ] -> Int -> String
246
+
ipAndBitMaskToCidr [ 192 168 70 9 ] 15
247
+
=> "192.168.70.9/15"
249
+
ipAndBitMaskToCidr = addr: bitMask:
250
+
lib.concatStringsSep "/"
253
+
(builtins.toString bitMask)
257
+
Given an IP address and subnet mask, return the associated CIDR.
259
+
Type: ipAndSubnetMaskToCidr :: [ Int ] -> Int -> String
262
+
ipAndSubnetMaskToCidr [ 192 168 70 9 ] [ 255 254 0 0 ]
263
+
=> "192.168.70.9/15"
265
+
ipAndSubnetMaskToCidr = addr: subnetMask:
266
+
ipAndBitMaskToCidr addr (subnetMaskToBitMask subnetMask);
269
+
Given a CIDR, return an attribute set of:
272
+
the first usable IP address,
273
+
the last usable IP address,
276
+
the broadcast address.
278
+
Type: getNetworkProperties :: str -> attrset
281
+
getNetworkProperties "192.168.70.9/15"
284
+
broadcast = "192.169.255.255";
285
+
firstUsableIp = "192.168.0.1";
286
+
ipAddress = "192.168.70.9";
287
+
lastUsableIp = "192.169.255.254";
288
+
networkId = "192.168.0.0";
289
+
subnetMask = "255.254.0.0";
292
+
getNetworkProperties = cidr: let
293
+
ipAddress = prettyIp (cidrToIpAddress cidr);
294
+
bitMask = cidrToBitMask cidr;
295
+
firstUsableIp = prettyIp (cidrToFirstUsableIp cidr);
296
+
lastUsableIp = prettyIp (cidrToLastUsableIp cidr);
297
+
networkId = prettyIp (cidrToNetworkId cidr);
298
+
subnetMask = prettyIp (cidrToSubnetMask cidr);
299
+
broadcast = prettyIp (cidrToBroadcastAddress cidr);
300
+
in {inherit ipAddress bitMask firstUsableIp lastUsableIp networkId subnetMask broadcast;};
306
+
bitMaskToSubnetMask
307
+
subnetMaskToBitMask
309
+
ipAndSubnetMaskToCidr
312
+
cidrToFirstUsableIp
316
+
cidrToBroadcastAddress
317
+
getNetworkProperties
kitten.sh