Class: Yast::IPClass

Inherits:
Module
  • Object
show all
Includes:
Logger
Defined in:
../../src/modules/IP.rb

Instance Method Summary (collapse)

Instance Method Details

- (String) BitsToIPv4(bits)

Converts 32 bit binary number to its IPv4 representation.

Examples:

BitsToIPv4("10111100000110001110001100000101") -> "188.24.227.5"
BitsToIPv4("00110101000110001110001001100101") -> "53.24.226.101"

Parameters:

  • string

    binary

Returns:

See Also:

  • #IPv4ToBits()


215
216
217
218
# File '../../src/modules/IP.rb', line 215

def BitsToIPv4(bits)
  return nil unless /\A[01]{32}\z/ =~ bits
  ToString(bits.to_i(2))
end

- (Object) Check(ip)

Check syntax of IP address

Parameters:

Returns:

  • true if correct



118
119
120
# File '../../src/modules/IP.rb', line 118

def Check(ip)
  Check4(ip) || Check6(ip)
end

- (Object) Check4(ip)

Check syntax of IPv4 address

Parameters:

  • ip (String)

    IPv4 address

Returns:

  • true if correct



64
65
66
67
68
# File '../../src/modules/IP.rb', line 64

def Check4(ip)
  IPAddr.new(ip).ipv4?
rescue
  false
end

- (Object) Check6(ip)

Check syntax of IPv6 address

Parameters:

  • ip (String)

    IPv6 address

Returns:

  • true if correct



84
85
86
87
88
# File '../../src/modules/IP.rb', line 84

def Check6(ip)
  IPAddr.new(ip).ipv6?
rescue
  false
end

- (Object) CheckNetwork(network)

Checks the given network entry which can be defined in several formats: - Single IPv4 or IPv6, e.g., 192.168.0.1 or 2001:db8:0::1 - IP/Netmask, e.g., 192.168.0.0/255.255.255.0 or 2001:db8:0::1/ffff:ffff::0 - IP/CIDR, e.g., 192.168.0.0/20 or 2001:db8:0::1/56

Examples:

CheckNetwork("192.168.0.1") -> true
CheckNetwork("192.168.0.0/20") -> true
CheckNetwork("192.168.0.0/255.255.255.0") -> true
CheckNetwork("0/0") -> true
CheckNetwork("::1/128") -> true
CheckNetwork("2001:db8:0::1") -> true
CheckNetwork("2001:db8:0::1/64") -> true
CheckNetwork("2001:db8:0::1/ffff:ffff::0") -> true
CheckNetwork("2001:db8:0::xyz") -> false
CheckNetwork("::1/257") -> false
CheckNetwork("172.55.0.0/33") -> false
CheckNetwork("172.55.0.0/125.85.5.5") -> false


318
319
320
# File '../../src/modules/IP.rb', line 318

def CheckNetwork(network)
  CheckNetwork4(network) || CheckNetwork6(network)
end

- (Object) CheckNetwork4(network)

Checks the given IPv4 network entry.

Examples:

CheckNetwork("192.168.0.0/255.255.255.0") -> true
CheckNetwork("192.168.1.22") -> true
CheckNetwork("172.55.0.0/33") -> false

See Also:

  • for details.
  • for IPv6 version of the same function.


241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
# File '../../src/modules/IP.rb', line 241

def CheckNetwork4(network)
  generic_check = CheckNetworkShared(network)
  if !generic_check.nil?
    return generic_check

  # 192.168.0.0/20, 0.8.55/158
  elsif network =~ Regexp.new("^[" + @ValidChars4 + "]+/[0-9]+$")
    net_parts = network.split("/")
    return Check4(net_parts[0]) &&
      Netmask.CheckPrefix4(net_parts[1])

  # 192.168.0.0/255.255.255.0, 0.8.55/10.258.12
  elsif network =~ Regexp.new("^[" + @ValidChars4 + "]+/[" + @ValidChars4 + "]+$")
    net_parts = network.split("/")
    return Check4(net_parts[0]) &&
      Netmask.Check4(net_parts[1])

  # 192.168.0.1, 0.8.55.999
  elsif Check4(network)
    return true
  end

  false
end

- (Object) CheckNetwork6(network)

Checks the given IPv6 network entry.

Examples:

CheckNetwork("2001:db8:0::1/64") -> true
CheckNetwork("2001:db8:0::1") -> true
CheckNetwork("::1/257") -> false

See Also:

  • for details.
  • for IPv4 version of the same function.


275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
# File '../../src/modules/IP.rb', line 275

def CheckNetwork6(network)
  generic_check = CheckNetworkShared(network)
  if !generic_check.nil?
    return generic_check

    # 2001:db8:0::1/64
  elsif network =~ Regexp.new("^[" + @ValidChars6 + "]+/[" + Netmask.ValidChars6 + "]*$")
    net_parts = network.split("/")
    return Check6(net_parts[0]) &&
      Netmask.Check6(net_parts[1])

    # 2001:db8:0::1/ffff:ffff::0
  elsif network =~ Regexp.new("^[" + @ValidChars6 + "]+/[" + @ValidChars6 + "]+$")
    net_parts = network.split("/")
    return Check6(net_parts[0]) &&
      Check6(net_parts[1])
  # 2001:db8:0::1

  elsif Check6(network)
    return true
  end

  false
end

- (Object) CheckNetworkShared(network)



220
221
222
223
224
225
226
227
228
229
230
# File '../../src/modules/IP.rb', line 220

def CheckNetworkShared(network)
  if network.nil? || network == ""
    return false

    # all networks
  elsif network == "0/0"
    return true
  end

  nil
end

- (Object) ComputeBroadcast(ip, mask)

Compute IPv4 broadcast address from ip4 address and network mask.

The broadcast address is the highest address of network address range.

Parameters:

Returns:

  • computed broadcast



181
182
183
184
185
186
187
# File '../../src/modules/IP.rb', line 181

def ComputeBroadcast(ip, mask)
  i = ToInteger(ip)
  m = ToInteger(mask)
  ToString(
    Ops.bitwise_and(Ops.bitwise_or(i, Ops.bitwise_not(m)), 4_294_967_295)
  )
end

- (Object) ComputeNetwork(ip, mask)

Compute IPv4 network address from ip4 address and network mask.

Parameters:

Returns:

  • computed subnet



169
170
171
172
173
# File '../../src/modules/IP.rb', line 169

def ComputeNetwork(ip, mask)
  i = ToInteger(ip)
  m = ToInteger(mask)
  ToString(Ops.bitwise_and(Ops.bitwise_and(i, m), 4_294_967_295))
end

- (String) IPv4ToBits(ipv4)

Converts IPv4 into its 32 bit binary representation.

Examples:

IPv4ToBits("80.25.135.2")    -> "01010000000110011000011100000010"
IPv4ToBits("172.24.233.211") -> "10101100000110001110100111010011"

Parameters:

Returns:

See Also:

  • #BitsToIPv4()


199
200
201
202
203
# File '../../src/modules/IP.rb', line 199

def IPv4ToBits(ipv4)
  int = ToInteger(ipv4)
  return nil unless int
  format("%032b", int)
end

- (Object) main



39
40
41
42
43
44
45
46
47
48
49
50
# File '../../src/modules/IP.rb', line 39

def main
  textdomain "base"

  Yast.import "Netmask"

  @ValidChars = "0123456789abcdefABCDEF.:"
  @ValidChars4 = "0123456789."
  @ValidChars6 = "0123456789abcdefABCDEF:"

  # helper list, each bit has its decimal representation
  @bit_weight_row = [128, 64, 32, 16, 8, 4, 2, 1]
end

- (Object) reserved4(ip)

Checks if given IPv4 address is reserved by any related RFC.

RFCs covered by this method are #1700, #1918, #2544, #3068, #5735, #5737, 5771, #6333 and #6598

@param ip IPv4 address @return if address is reserved

Raises:

  • (RuntimeError)

    if ip address is invalid



331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
# File '../../src/modules/IP.rb', line 331

def reserved4(ip)
  raise "Invalid IP address passed '#{ip}'" unless Check4(ip)

  # RFC#1700
  return true if ip.start_with?("0.")

  # RFC#6598
  return true if private_carrier_grade_nat?(ip)

  # RFC#5735
  return true if ip.start_with?("127.")
  return true if ip.start_with?("169.254")

  # RFC#1918
  return true if private_network?(ip)

  # RFC#6333
  return true if ds_lite_address?(ip)

  # RFC#5737
  return true if ip.start_with?("192.0.2.")
  return true if ip.start_with?("198.51.100.")
  return true if ip.start_with?("203.0.113.")

  # RFC#3068
  return true if ip.start_with?("192.88.99.")

  # RFC#2544
  return true if ip.start_with?("192.18.")
  return true if ip.start_with?("192.19.")

  # all from 224. is covered by RFC#5771 and RFC#5735
  return true if (224..255).include?(ip.split(".").first.to_i)

  false
end

- (String) ToHex(ip)

Converts IPv4 address from string to hex format

Examples:

IP::ToHex(“192.168.1.1”) -> “C0A80101”

IP::ToHex(“10.10.0.1”) -> “0A0A0001”

Parameters:

  • ip (String)

    IPv4 address as string in “ipv4” format

Returns:

  • (String)

    representing IP in Hex



159
160
161
162
163
# File '../../src/modules/IP.rb', line 159

def ToHex(ip)
  int = ToInteger(ip)
  return nil unless int
  format("%08X", int)
end

- (Object) ToInteger(ip)

Convert IPv4 address from string to integer

Parameters:

  • ip (String)

    IPv4 address

Returns:

  • ip address as integer



142
143
144
145
# File '../../src/modules/IP.rb', line 142

def ToInteger(ip)
  return nil unless Check4(ip)
  IPAddr.new(ip).to_i
end

- (Object) ToString(ip)

Convert IPv4 address from integer to string

Parameters:

  • ip (Fixnum)

    IPv4 address

Returns:

  • ip address as string



150
151
152
# File '../../src/modules/IP.rb', line 150

def ToString(ip)
  IPAddr.new(ip, Socket::AF_INET).to_s
end

- (Object) UndecorateIPv6(ip)

If param contains IPv6 in one of its various forms, extracts it.

if ip is closed in [ ] or contain % then it can be special case of IPv6 syntax, so extract ipv6 (see description later) and continue with check.

IPv6 syntax: - pure ipv6 blob (e.g. f008::1) - ipv6 blob with link local suffix (e.g. f008::1%eth0) - dtto in square brackets (e.g. [f008::1%eth0] )

Parameters:

  • ip (String)

    a buffer with address

Returns:

  • IPv6 part of ip param, unchanged ip param otherwise



102
103
104
105
106
107
108
109
110
111
112
113
# File '../../src/modules/IP.rb', line 102

def UndecorateIPv6(ip)
  if Builtins.regexpmatch(ip, "^\\[.*\\]") ||
      Builtins.regexpmatch(ip, "^[^][%]+(%[^][%]+){0,1}$")
    ip = Builtins.regexpsub(
      ip,
      "^\\[?([^][%]+)(%[^][%]+){0,1}(\\]|$)",
      "\\1"
    )
  end

  ip
end

- (String) Valid4

Describe a valid IPv4 address

Returns:

  • (String)

    describtion a valid IPv4 address



54
55
56
57
58
59
# File '../../src/modules/IP.rb', line 54

def Valid4
  # Translators: dot: "."
  _(
    "A valid IPv4 address consists of four integers\nin the range 0-255 separated by dots."
  )
end

- (String) Valid6

Describe a valid IPv6 address

Returns:

  • (String)

    describtion a valid IPv4 address



72
73
74
75
76
77
78
79
# File '../../src/modules/IP.rb', line 72

def Valid6
  # Translators: colon: ":"
  _(
    "A valid IPv6 address consists of up to eight\n" \
      "hexadecimal numbers in the range 0 - FFFF separated by colons.\n" \
      "It can contain up to one double colon."
  )
end

- (String) ValidNetwork

Returns string of valid network definition. Both IPv4 and IPv6.

Returns:

  • (String)

    describing the valid network.



126
127
128
129
130
131
132
133
134
135
136
137
# File '../../src/modules/IP.rb', line 126

def ValidNetwork
  # TRANSLATORS: description of the valid network definition
  _(
    "A valid network definition can contain the IP,\n" \
      "IP/Netmask, IP/Netmask_Bits, or 0/0 for all networks.\n" \
      "\n" \
      "Examples:\n" \
      "IP: 192.168.0.1 or 2001:db8:0::1\n" \
      "IP/Netmask: 192.168.0.0/255.255.255.0 or 2001:db8:0::1/56\n" \
      "IP/Netmask_Bits: 192.168.0.0/24 or 192.168.0.1/32 or 2001:db8:0::1/ffff::0\n"
  )
end