Module: Interfacez

Defined in:
lib/interfacez.rb,
lib/interfacez/version.rb

Constant Summary collapse

VERSION = 
"1.0.4"

Class Method Summary collapse

Class Method Details

.all ⇒ Object

All network interface names available on system.



82
83
84
85
86
87
88
89
90
 
# File 'lib/interfacez.rb', line 82

def self.all
  addrs = raw_interface_addresses.collect { |iface| iface.name }.uniq 
  if block_given?
    addrs.each do |addr|
      yield addr
    end
  end
  return addrs
end

.default ⇒ Object

Emulated LibPcap’s pcap_lookupdev function to find the default device on which to capture packets.



8
9
10
11
12
13
14
 
# File 'lib/interfacez.rb', line 8

def self.default
  raw_interface_addresses.each do |iface| 
    next unless iface.broadaddr
    return iface.name 
  end
  nil
end

.index_of(interface) ⇒ Object

Get index of network interface.



189
190
191
192
193
194
 
# File 'lib/interfacez.rb', line 189

def self.index_of(interface)
  raw_interface_addresses.each do |iface|
    return iface.ifindex if iface.name == interface
  end
  return nil
end

.ipv4_address_of(interface) ⇒ Object

Return all ipv4 addresses of a given interface.



113
114
115
116
117
 
# File 'lib/interfacez.rb', line 113

def self.ipv4_address_of(interface)
  addresses = Interfacez.ipv4_addresses[interface]
  return nil if addresses.nil?
  return addresses[0]
end

.ipv4_addresses(interface = nil) ⇒ Object

Network interfaces with their ipv4 addresses, if they have any asscoited with it.



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/interfacez.rb', line 94

def self.ipv4_addresses(interface = nil)
  return ipv4_addresses_of(interface) unless interface.nil?
  results = Hash.new()
  raw_interface_addresses.each do |iface|
    next unless iface.addr
    if iface.addr.ipv4?
      results[iface.name] = [] unless results[iface.name]
      results[iface.name] << iface.addr.ip_address
    end
  end
  if block_given?
    results.each do |result|
      yield result
    end
  end
  return results
end

.ipv4_addresses_of(interface) ⇒ Object

Return the first ipv4 address of a given interface.



120
121
122
 
# File 'lib/interfacez.rb', line 120

def self.ipv4_addresses_of(interface)
  return Interfacez.ipv4_addresses[interface] || []
end

.ipv4_loopback ⇒ Object

First available ipv4 loopback interface.



42
43
44
 
# File 'lib/interfacez.rb', line 42

def self.ipv4_loopback
  Interfacez.ipv4_loopbacks { |iface| return iface }
end

.ipv4_loopbacks ⇒ Object

All ipv4 loopback interfaces.



47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/interfacez.rb', line 47

def self.ipv4_loopbacks
  if block_given?
    raw_interface_addresses.each do |iface| 
      next unless iface.addr
      next unless iface.addr.ipv4_loopback?
      yield iface.name if block_given?
    end
  else
    results = []
    Interfacez.ipv4_loopbacks { |l| results << l }
    return results 
  end
end

.ipv6_address_of(interface) ⇒ Object

Return the first ipv6 address of a given interface.



150
151
152
153
154
 
# File 'lib/interfacez.rb', line 150

def self.ipv6_address_of(interface)
  addresses = Interfacez.ipv6_addresses_of(interface)
  return nil if addresses.nil? 
  return addresses[0]
end

.ipv6_addresses(interface = nil) ⇒ Object

Network interfaces with their ipv6 addresses, if they have any asscoited with it.



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/interfacez.rb', line 126

def self.ipv6_addresses(interface = nil)
  return ipv6_addresses_of(interface) unless interface.nil?
  results = Hash.new()
  raw_interface_addresses.each do |iface|
    next unless iface.addr
    if iface.addr.ipv6?
      results[iface.name] = [] unless results[iface.name]
      results[iface.name] << iface.addr.ip_address
    end
  end
  if block_given?
    results.each do |result|
      yield result
    end
  end
  return results
end

.ipv6_addresses_of(interface) ⇒ Object

Return all available ipv6 addreses of a given interface.



145
146
147
 
# File 'lib/interfacez.rb', line 145

def self.ipv6_addresses_of(interface)
  return Interfacez.ipv6_addresses[interface] || []
end

.ipv6_loopback ⇒ Object

First available ipv6 loopback interface.



62
63
64
 
# File 'lib/interfacez.rb', line 62

def self.ipv6_loopback
  Interfacez.ipv6_loopbacks { |iface| return iface }
end

.ipv6_loopbacks ⇒ Object

All ipv6 loopback interfaces.



67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/interfacez.rb', line 67

def self.ipv6_loopbacks
  if block_given?
    raw_interface_addresses.each do |iface| 
      next unless iface.addr
      next unless iface.addr.ipv6_loopback?
      yield iface.name if block_given?
    end
  else
    results = []
    Interfacez.ipv4_loopbacks { |l| results << l }
    return results 
  end
end

.loopback ⇒ Object

Get first (ipv4 or ipv6) loopback interface.



17
18
19
20
 
# File 'lib/interfacez.rb', line 17

def self.loopback
  Interfacez.ipv4_loopbacks { |iface| return iface }
  Interfacez.ipv6_loopbacks { |iface| return iface }
end

.loopback? ⇒ Boolean

Check for any (ipv4 or ipv6) loopback interface.

Returns:

  • (Boolean) 


23
24
25
26
27
 
# File 'lib/interfacez.rb', line 23

def self.loopback?
  Interfacez.ipv4_loopbacks { |iface| return true }
  Interfacez.ipv6_loopbacks { |iface| return true }
  return false
end

.loopbacks ⇒ Object

Get all (ipv4 or ipv6) loopback interfaces.



30
31
32
33
34
35
36
37
38
39
 
# File 'lib/interfacez.rb', line 30

def self.loopbacks
  if block_given?
    Interfacez.ipv4_loopbacks { |iface| yield iface }
    Interfacez.ipv6_loopbacks { |iface| yield iface }
  else
    loopbacks = []
    Interfacez.loopbacks { |l| loopbacks << l unless loopbacks.any?(l) }
    return loopbacks
  end
end

.mac_address_of(interface) ⇒ Object

Return first available mac addresses of a given interface.



157
158
159
160
161
 
# File 'lib/interfacez.rb', line 157

def self.mac_address_of(interface)
  list = Interfacez.mac_addresses_of(interface)
  return nil if list.size.zero?
  return list[0]
end

.mac_addresses_of(interface) ⇒ Object

Return all available mac addresses of a given interface.



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/interfacez.rb', line 164

def self.mac_addresses_of(interface)
  # BSD support
  if Socket.const_defined? :PF_LINK
    list = raw_interface_addresses.map! do |iface|
      next unless iface.name == interface
      next unless iface.addr
      nameinfo = iface.addr.getnameinfo
      if nameinfo.first != "" && nameinfo.last == ""
        nameinfo[0]
      end
    end.compact
  # Linux support
  elsif Socket.const_defined? :PF_PACKET 
    list = raw_interface_addresses.map! do |iface|
      next unless iface.name == interface
      next unless iface.addr
      iface.addr.inspect_sockaddr[/hwaddr=([\h:]+)/, 1]
    end.compact
  else
    warn "This platform may not be fully supported!"
    return []
  end
end

.raw_interface_addresses ⇒ Object

:nodoc:



197
198
199
200
201
202
 
# File 'lib/interfacez.rb', line 197

def self.raw_interface_addresses
  Socket.getifaddrs
rescue
  warn "Unable to get raw interface address list from Socket class"
  return []
end