Module: Facter::Util::IP

Defined in:
lib/facter/util/ip.rb

Overview

A base module for collecting IP-related information from all kinds of platforms.

Defined Under Namespace

Classes: Windows

Constant Summary collapse

REGEX_MAP =

A map of all the different regexes that work for a given platform or set of platforms.

{
  :linux => {
    :ipaddress  => /inet (?:addr:)?([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
    :ipaddress6 => /inet6 (?:addr: )?((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
    :macaddress => /(?:ether|HWaddr)\s+((\w{1,2}:){5,}\w{1,2})/,
    :netmask  => /(?:Mask:|netmask )([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
    :mtu  => /MTU:?\s*(\d+)/i
  },
  :bsd   => {
    :aliases  => [:openbsd, :netbsd, :freebsd, :darwin, :"gnu/kfreebsd", :dragonfly],
    :ipaddress  => /inet\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
    :ipaddress6 => /inet6 ((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
    :macaddress => /(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/,
    :netmask  => /netmask\s+0x(\w{8})/,
    :mtu => /mtu\s+(\d+)/
  },
  :sunos => {
    :ipaddress  => /inet\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
    :ipaddress6 => /inet6 ((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
    :macaddress => /(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/,
    :netmask  => /netmask\s+(\w{8})/,
    :mtu => /mtu\s+(\d+)/
  },
  :"hp-ux" => {
    :ipaddress  => /\s+inet (\S+)\s.*/,
    :macaddress => /(\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2})/,
    :netmask  => /.*\s+netmask (\S+)\s.*/
  },
  :windows => {}
}

Class Method Summary collapse

Class Method Details

.alphafy(interface) ⇒ Object

Convert an interface name into purely alphanumeric characters.



38
39
40
 
# File 'lib/facter/util/ip.rb', line 38

def self.alphafy(interface)
  interface.gsub(/[^a-z0-9_]/i, '_')
end

.convert_from_hex?(kernel) ⇒ Boolean

Returns:

  • (Boolean) 


42
43
44
45
 
# File 'lib/facter/util/ip.rb', line 42

def self.convert_from_hex?(kernel)
  kernels_to_convert = [:sunos, :openbsd, :netbsd, :freebsd, :darwin, :"hp-ux", :"gnu/kfreebsd", :dragonfly]
  kernels_to_convert.include?(kernel)
end

.exec_ifconfig(additional_arguments = []) ⇒ String

exec_ifconfig uses the ifconfig command

Returns:

  • (String) —

    the output of ‘ifconfig #arguments 2>/dev/null` or nil



98
99
100
 
# File 'lib/facter/util/ip.rb', line 98

def self.exec_ifconfig(additional_arguments=[])
  Facter::Core::Execution.exec("#{self.get_ifconfig} #{additional_arguments.join(' ')}")
end

.get_all_interface_output ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/facter/util/ip.rb', line 74

def self.get_all_interface_output
  case Facter.value(:kernel)
  when 'Linux', 'OpenBSD', 'NetBSD', 'FreeBSD', 'Darwin', 'GNU/kFreeBSD', 'DragonFly'
    output = Facter::Util::IP.exec_ifconfig(["-a","2>/dev/null"])
  when 'SunOS'
    output = Facter::Util::IP.exec_ifconfig(["-a"])
  when 'HP-UX'
    # (#17487)[https://projects.puppetlabs.com/issues/17487]
    # Handle NIC bonding where asterisks and virtual NICs are printed.
    if output = hpux_netstat_in
      output.gsub!(/\*/, "")                  # delete asterisks.
      output.gsub!(/^[^\n]*none[^\n]*\n/, "") # delete lines with 'none' instead of IPs.
      output.sub!(/^[^\n]*\n/, "")            # delete the header line.
      output
    end
  end
  output
end

.get_bonding_master(interface) ⇒ Object 



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/facter/util/ip.rb', line 174

def self.get_bonding_master(interface)
  if Facter.value(:kernel) != 'Linux'
    return nil
  end
  # We need ip instead of ifconfig because it will show us
  # the bonding master device.
  if not FileTest.executable?("/sbin/ip")
    return nil
  end
  # A bonding interface can never be an alias interface. Alias
  # interfaces do have a colon in their name and the ip link show
  # command throws an error message when we pass it an alias
  # interface.
  if interface =~ /:/
    return nil
  end
  regex = /SLAVE[,>].* (bond[0-9]+)/
    ethbond = regex.match(%x{/sbin/ip link show #{interface}})
  if ethbond
    device = ethbond[1]
  else
    device = nil
  end
  device
end

.get_ifconfig ⇒ String

get_ifconfig looks up the ifconfig binary

Returns:

  • (String) —

    path to the ifconfig binary



105
106
107
108
 
# File 'lib/facter/util/ip.rb', line 105

def self.get_ifconfig
  common_paths=["/bin/ifconfig","/sbin/ifconfig","/usr/sbin/ifconfig"]
  common_paths.select{|path| File.executable?(path)}.first
end

.get_infiniband_macaddress(interface) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/facter/util/ip.rb', line 116

def self.get_infiniband_macaddress(interface)
  if File.exists?("/sys/class/net/#{interface}/address") then
    ib_mac_address = `cat /sys/class/net/#{interface}/address`.chomp
  elsif File.exists?("/sbin/ip") then
    ip_output = %x{/sbin/ip link show #{interface}}
    ib_mac_address = ip_output.scan(%r{infiniband\s+((\w{1,2}:){5,}\w{1,2})})
  else
    ib_mac_address = "FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF"
    Facter.debug("ip.rb: nothing under /sys/class/net/#{interface}/address and /sbin/ip not available")
  end
  ib_mac_address
end

.get_interface_value(interface, label) ⇒ String

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

get_interface_value obtains the value of a specific attribute of a specific interface.

e.g. “netmask” or “ipaddress”

returned if the kernel is not supported by the REGEX_MAP constant.

Parameters:

  • interface (String) —

    the interface identifier, e.g. “eth0” or “bond0”

  • label (String) —

    the attribute of the interface to obtain a value for,

Returns:

  • (String) —

    representing the requested value. An empty array is



213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/facter/util/ip.rb', line 213

def self.get_interface_value(interface, label)
  if Facter.value(:kernel) == 'windows'
    require 'facter/util/ip/windows'
    return Facter::Util::IP::Windows.value_for_interface_and_label(interface, label)
  end

  tmp1 = []

  kernel = Facter.value(:kernel).downcase.to_sym

  # If it's not directly in the map or aliased in the map, then we don't know how to deal with it.
  unless map = REGEX_MAP[kernel] || REGEX_MAP.values.find { |tmp| tmp[:aliases] and tmp[:aliases].include?(kernel) }
    return []
  end

  # Pull the correct regex out of the map.
  regex = map[label.to_sym]

  # Linux changes the MAC address reported via ifconfig when an ethernet interface
  # becomes a slave of a bonding device to the master MAC address.
  # We have to dig a bit to get the original/real MAC address of the interface.
  bonddev = get_bonding_master(interface)
  if label == 'macaddress' and bonddev
    bondinfo = read_proc_net_bonding("/proc/net/bonding/#{bonddev}")
    re = /^Slave Interface: #{interface}\b.*?\bPermanent HW addr: (([0-9A-F]{2}:?)*)$/im
    if match = re.match(bondinfo)
      value = match[1].upcase
    end
  else
    output_int = get_output_for_interface_and_label(interface, label)

    output_int.each_line do |s|
      if s =~ regex
        value = $1
          if label == 'netmask' && convert_from_hex?(kernel)
            value = value.scan(/../).collect do |byte| byte.to_i(16) end.join('.')
          end
        tmp1.push(value)
      end
    end

    if tmp1
      value = tmp1.shift
    end
  end
end

.get_interfaces ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/facter/util/ip.rb', line 59

def self.get_interfaces
  if Facter.value(:kernel) == 'windows'
    require 'facter/util/ip/windows'
    return Facter::Util::IP::Windows.interfaces
  end

  return [] unless output = Facter::Util::IP.get_all_interface_output()

  # Our regex appears to be stupid, in that it leaves colons sitting
  # at the end of interfaces.  So, we have to trim those trailing
  # characters.  I tried making the regex better but supporting all
  # platforms with a single regex is probably a bit too much.
  output.scan(/^\S+/).collect { |i| i.sub(/:$/, '') }.uniq
end

.get_network_value(interface) ⇒ Object 



273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/facter/util/ip.rb', line 273

def self.get_network_value(interface)
  require 'ipaddr'

  ipaddress = get_interface_value(interface, "ipaddress")
  netmask = get_interface_value(interface, "netmask")

  if ipaddress && netmask
    ip = IPAddr.new(ipaddress, Socket::AF_INET)
    subnet = IPAddr.new(netmask, Socket::AF_INET)
    network = ip.mask(subnet.to_s).to_s
  end
end

.get_output_for_interface_and_label(interface, label) ⇒ Object 



166
167
168
169
170
171
172
 
# File 'lib/facter/util/ip.rb', line 166

def self.get_output_for_interface_and_label(interface, label)
  return get_single_interface_output(interface) unless Facter.value(:kernel) == 'windows'

  require 'facter/util/ip/windows'
  output = Facter::Util::IP::Windows.value_for_interface_and_label(interface, label)
  output ? output : ""
end

.get_single_interface_output(interface) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/facter/util/ip.rb', line 133

def self.get_single_interface_output(interface)
  output = ""
  case Facter.value(:kernel)
  when 'OpenBSD', 'NetBSD', 'FreeBSD', 'Darwin', 'GNU/kFreeBSD', 'DragonFly'
    output = Facter::Util::IP.ifconfig_interface(interface)
  when 'Linux'
    ifconfig_output = Facter::Util::IP.ifconfig_interface(interface)
    if interface =~ /^ib/ then
      real_mac_address = get_infiniband_macaddress(interface)
      output = ifconfig_output.sub(%r{(?:ether|HWaddr)\s+((\w{1,2}:){5,}\w{1,2})}, "HWaddr #{real_mac_address}")
    else
      output = ifconfig_output
    end
  when 'SunOS'
    output = Facter::Util::IP.exec_ifconfig([interface])
  when 'HP-UX'
     mac = ""
     ifc = hpux_ifconfig_interface(interface)
     hpux_lanscan.scan(/(\dx\S+).*UP\s+(\w+\d+)/).each {|i| mac = i[0] if i.include?(interface) }
     mac = mac.sub(/0x(\S+)/,'\1').scan(/../).join(":")
     output = ifc + "\n" + mac
  end
  output
end

.hpux_ifconfig_interface(interface) ⇒ Object 



158
159
160
 
# File 'lib/facter/util/ip.rb', line 158

def self.hpux_ifconfig_interface(interface)
  Facter::Util::IP.exec_ifconfig([interface])
end

.hpux_lanscan ⇒ Object 



162
163
164
 
# File 'lib/facter/util/ip.rb', line 162

def self.hpux_lanscan
  Facter::Core::Execution.exec("/usr/sbin/lanscan")
end

.hpux_netstat_in ⇒ Object

hpux_netstat_in is a delegate method that allows us to stub netstat -in without stubbing exec.



112
113
114
 
# File 'lib/facter/util/ip.rb', line 112

def self.hpux_netstat_in
  Facter::Core::Execution.exec("/bin/netstat -in")
end

.ifconfig_interface(interface) ⇒ Object 



129
130
131
 
# File 'lib/facter/util/ip.rb', line 129

def self.ifconfig_interface(interface)
  output = Facter::Util::IP.exec_ifconfig([interface,"2>/dev/null"])
end

.supported_platforms ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/facter/util/ip.rb', line 47

def self.supported_platforms
  REGEX_MAP.inject([]) do |result, tmp|
    key, map = tmp
    if map[:aliases]
      result += map[:aliases]
    else
      result << key
    end
    result
  end
end