aaalex-ruby-ifconfig 1.2.1

data/lib/ifconfig/bsd/interface_types.rb

@@ -0,0 +1,69 @@
+# $Id: interface_types.rb,v 1.1.1.1 2005/07/02 19:10:58 hobe Exp $
+#
+require 'ifconfig/common/interface_types'
+
+class NetworkAdapter
+  # becuase on *BSD we get activity from netstat
+  # we need to have a way to set this:
+  attr_writer :mtu
+
+  # iterate line by line and dispatch to helper functions
+  # for lines that match a pattern
+  #
+  def parse_ifconfig
+    @ifconfig.split("\n").each { |line|
+      case line
+        when /^\s+#{@protos}/
+          add_network(line)
+        when /flags\=/i
+          parse_flags(line)
+      end
+    }
+  end
+
+  # parses the "UP LOOPBACK RUNNING  MTU:3924  Metric:1" line
+  #
+  def parse_flags(line)
+    flags = line.match(/\<(\S+)\>/i)[1]
+    @flags = flags.strip.split(',')
+    @status = true if @flags.include?('UP')
+  end
+
+  # Parses networks on an interface based on the first token in the line.
+  # eg: inet or inet6
+  #
+  def add_network(line)
+    case line
+      when /^\s+inet\s/
+        addr,mask = line.match(/\s+([\d\d?\d?\.]{4,})\s+netmask\s+(\S+)/i)[1..2]
+        bcast = line.match(/\s+broadcast\s([\d\d?\d?\.]{4,})/i)
+        bcast = bcast[1] unless bcast.nil?
+        @networks['inet'] = Ipv4Network.new(addr, mask, bcast)
+      when /^\s+inet6\s/
+        # there can be multiple inet6 entries
+        begin
+          addr,scope = line.match(/inet6\s+(\S+)%/i)[1]
+        rescue NoMethodError
+          addr,scope = line.match(/inet6\s+(\S+)/i)[1]
+        end
+        @networks["inet6:#{addr}"] = Ipv6Network.new(addr)
+      else
+        puts "unknown network type: #{line}"
+    end
+  end
+end
+
+
+class EthernetAdapter
+  def set_mac
+    begin
+      match=@ifconfig.match(/\s+ether\s+([a-f\d]{1,2}(?:\:[a-f\d]{1,2}){5})/im)
+      return match[1] unless match.nil?
+      # Openbsd
+      match = @ifconfig.match(/\s+address\:\s+([a-f\d]{1,2}(?:\:[a-f\d]{1,2}){5})/im)
+      return match[1] unless match.nil?
+    rescue NoMethodError
+      puts "Couldn't Parse MAC Address for: "+@name
+    end
+  end
+end

data/lib/ifconfig/bsd/network_types.rb

@@ -0,0 +1,3 @@
+# $Id: network_types.rb,v 1.1.1.1 2005/07/02 19:10:58 hobe Exp $
+#
+require 'ifconfig/common/network_types'

data/lib/ifconfig/common/ifconfig.rb

@@ -0,0 +1,84 @@
+# $Id: ifconfig.rb,v 1.1.1.1 2005/07/02 19:10:58 hobe Exp $
+#
+class Ifconfig
+  include Enumerable
+
+  #
+  # Give hash like access to the interfaces
+  #
+  def [](iface)
+    return @ifaces[iface]
+  end
+
+  def each( &block )
+    return @ifaces.each_value( &block )
+  end
+
+  # return list of interface names
+  #
+  def interfaces
+    return @ifaces.keys
+  end
+
+  # returns array of interface text blocks
+  #
+  def split_interfaces(text)
+    ifaces = []
+    text.split("\n").each { |line|
+      ifaces[ifaces.length] = "" if line =~ /^\S/
+      ifaces[ifaces.length-1] += line.rstrip+"\n"
+    }
+    return ifaces
+  end
+
+  # Given an interface block
+  # returns the name of an interface (eth0, eth0:1 ppp0, etc.)
+  #
+  def get_iface_name(text)
+    name = Regexp.compile(/^(\S+)/).match(text)[1]
+    # strip trailing :, for bsd, sun
+    name.sub!(/:$/,'')
+    return name
+  end
+
+  def to_s
+    s=""
+    self.interfaces.sort.each { |k|
+      s += @ifaces[k].to_s
+      s += "\n-------------------------\n"
+    }
+    return s
+  end
+
+  # return list of all addresses on all interfaces reported by ifconfig
+  #
+  def addresses(type=nil)
+    addr = []
+    @ifaces.each_value { |iface|
+      addr += iface.addresses
+    }
+    return addr
+  end
+
+  # returns array of arrays
+  # [ [address , type ] ]
+  #
+  def addrs_with_type
+    addr = []
+    @ifaces.each_value { |iface|
+      addr += iface.addrs_with_type
+    }
+    return addr
+  end
+
+  def valid_addr?(addr,type='inet')
+    case type
+      when /(inet|v4)/
+        return addr.ipv4?
+      when /(inet6|v6)/
+        return addr.ipv6?
+      else
+        raise "Unknown address type `#{type}' for address `#{addr}'"
+    end
+  end
+end

data/lib/ifconfig/common/interface_types.rb

@@ -0,0 +1,130 @@
+# $Id: interface_types.rb,v 1.1.1.1 2005/07/02 19:10:58 hobe Exp $
+#
+class NetworkAdapter
+  def initialize(name, ifacetxt)
+    @name = name
+    @ifconfig = ifacetxt
+    @status = false
+    @protos = ['inet','inet6','IPX/Ethernet II',
+               'IPX/Ethernet SNAP',
+               'IPX/Ethernet 802.2',
+               'IPX/Ethernet 802.3',
+               'EtherTalk Phase 2'].join("|")
+    @networks = {}
+    @flags = []
+    @mtu = nil
+    @metric = nil
+    @rx = @tx = {}
+    parse_ifconfig
+  end
+  attr_reader :status, :name, :flags, :mtu
+  attr_accessor :tx, :rx
+
+  # take array and turn each two entries into
+  # hash key and value, also converts each value to an integer
+  #
+  # [1,2,3,4] => { 1 => 2, 3 => 4}
+  #
+  # Internal utility function used to populate rx and tx hashes
+  def array_to_hash_elem(array)
+    h = {}
+    if array.length.modulo(2) != 0
+      puts "Array mus have even number of elements to turn into a hash"
+      return nil
+    end
+    while array.length > 0
+      h[array.shift] = array.shift.to_i
+    end
+    return h
+  end
+
+  # Return all addresses bound to this interface or
+  # optionally only the specified type of network address
+  #
+  def addresses(type=nil)
+    a = []
+    @networks.each_value { |network|
+      a << (network.addr) if network.nettype == type or type.nil?
+    }
+    return a
+  end
+
+  def ifacetype
+    return self.class
+  end
+
+  def up?
+    return status
+  end
+
+  # returns array of arrays
+  # [ [address , type ] ]
+  #
+  def addrs_with_type
+    addrs = []
+    @networks.each_value { |network|
+      addrs.push([network.addr,network.nettype])
+    }
+    return addrs
+  end
+
+  def addr_types
+    types = []
+    @networks.each_value { |network|
+      types.push(network.nettype) unless types.include?(network.nettype)
+    }
+    return types
+  end
+
+  def has_addr?(addr)
+    return self.addresses.include?(addr)
+  end
+
+  def to_s
+    s = @name+":"+self.ifacetype.to_s+"\n"
+    @networks.keys.sort.each { |network|
+      s += @networks[network].to_s+"\n"
+    }
+    if self.rx['bytes'] && self.tx['bytes']
+      s += " RX bytes: #{self.rx['bytes']}, TX bytes: #{self.tx['bytes']}\n"
+    elsif self.rx['packets'] && self.tx['packets']
+      s += " RX packets: #{self.rx['packets']}, TX packets: #{self.tx['packets']}\n"
+    end
+
+    s += " MTU: #{@mtu}\n"
+    s += " Metric: #{@metric}\n"
+    s += " Flags: #{@flags.join(',')}\n"
+    s += " Status: UP" if self.status
+    return s
+  end
+end
+
+# each platform defines it's own set_mac
+# function to get the mac address
+#
+class EthernetAdapter < NetworkAdapter
+  def initialize(name,ifconfigtxt)
+    super(name,ifconfigtxt)
+    @mac = set_mac
+  end
+
+  attr_reader :mac, :interrupt, :rxbytes, :txbytes, :rxpackets,
+              :txpackets
+
+  def to_s
+    super + "\n MAC: #{@mac}"
+  end
+
+end
+
+class PPP < NetworkAdapter
+end
+
+class LoopbackInterface < NetworkAdapter
+end
+
+class IPv6_in_IPv4 < NetworkAdapter
+end
+
+class SerialLineIP < NetworkAdapter
+end

data/lib/ifconfig/common/network_types.rb

@@ -0,0 +1,49 @@
+# $Id: network_types.rb,v 1.1.1.1 2005/07/02 19:10:58 hobe Exp $
+#
+
+# base type to hold information about the kinds of networks
+# on to each adapter.  ipv4,6 ppp etc
+class BasicNetworkType
+  def initialize
+    @nettype = nil
+  end
+  attr_reader :nettype
+end
+
+#
+# Ipv4 Network type
+# Optional Broadcast and Point to Point Arguments
+#
+class Ipv4Network < BasicNetworkType
+  def initialize(addr,mask,bcast=nil,ptp=nil)
+    super()
+    @nettype = 'inet'
+    @addr = IPAddr.new(addr)
+    @bcast = bcast
+    @mask = mask
+    @ptp = ptp
+  end
+  attr_reader :addr, :bcast, :mask, :ptp
+
+  def to_s
+    a = [" #{@nettype} Address: #{@addr}","Mask: #{@mask}"]
+    a.push "Broadcast: #{@bcast}" unless @bcast.nil?
+    a.push "P-t-P: #{@ptp}" unless @ptp.nil?
+    return a.join(', ')
+  end
+
+end
+
+class Ipv6Network < BasicNetworkType
+  def initialize(addr,scope=nil)
+    super()
+    @nettype = 'inet6'
+    @addr = IPAddr.new(addr)
+    @scope = scope
+  end
+  attr_reader :addr, :scope
+
+  def to_s
+    " #{@nettype} Address: #{@addr}"
+  end
+end

data/lib/ifconfig/linux/ifconfig.rb

@@ -0,0 +1,41 @@
+# $Id: ifconfig.rb,v 1.1.1.1 2005/07/02 19:10:57 hobe Exp $
+#
+
+require 'ifconfig/common/ifconfig'
+require 'ifconfig/linux/network_types'
+require 'ifconfig/linux/interface_types'
+
+class Ifconfig
+  #
+  # Can manually specify the platform (should be output of the 'uname' command)
+  # and the ifconfig input
+  # 
+  def initialize(input=nil,verbose=nil)
+    if input.nil?
+      cmd = IO.popen('which ifconfig'){ |f| f.readlines[0] }
+      exit unless !cmd.nil?
+      @ifconfig = IO.popen("/sbin/ifconfig -a"){ |f| f.readlines.join }
+    else
+      @ifconfig = input
+    end
+    @verbose = verbose
+    @ifaces = {}
+    split_interfaces(@ifconfig).each do |iface|
+      iface_name = get_iface_name(iface)
+      case iface
+        when /encap\:ethernet/im
+          @ifaces[iface_name] = EthernetAdapter.new(iface_name,iface)
+        when /encap\:Local Loopback/im
+          @ifaces[iface_name] = LoopbackInterface.new(iface_name,iface)
+        when /encap\:IPv6-in-IPv4/im
+          @ifaces[iface_name] = IPv6_in_IPv4.new(iface_name,iface)
+        when /encap\:Point-to-Point Protocol/im
+          @ifaces[iface_name] = PPP.new(iface_name,iface)
+        when /encap\:Serial Line IP/im
+          @ifaces[iface_name] = SerialLineIP.new(iface_name,iface)
+        else
+          puts "Unknown Adapter Type on Linux: #{iface}" if @verbose
+      end
+    end
+  end
+end

data/lib/ifconfig/linux/interface_types.rb

@@ -0,0 +1,112 @@
+# $Id: interface_types.rb,v 1.1.1.1 2005/07/02 19:10:57 hobe Exp $
+#
+
+require 'ifconfig/common/interface_types'
+
+class NetworkAdapter
+  # Parse activity on interface
+  #
+  def parse_activity(line)
+    atr = %w(packets,errors,dropped,overruns)
+    case line.strip!
+
+    when /^RX packets/
+      @rx = array_to_hash_elem(
+        line.match(/^RX\s+(\w+)\:(\d+)\s+(\w+)\:(\d+)\s+(\w+)\:(\d+)\s+(\w+)\:(\d)/i)[1..8])
+      match = line.match(/\s+frame\:(\d+)/i)
+      @rx['frame'] = match[1] unless match.nil?
+
+    when /^TX packets/
+      @tx = array_to_hash_elem(
+        line.match(/^TX\s+(\w+)\:(\d+)\s+(\w+)\:(\d+)\s+(\w+)\:(\d+)\s+(\w+)\:(\d+)/i)[1..8])
+      match = line.match(/\s+carrier\:(\d+)/i)
+      @tx['carrier'] = match[1] unless match.nil?
+
+    when /^RX bytes/
+      match = line.match(/RX\s+(\w+)\:(\d+).*TX\s+(\w+)\:(\d+)/i)[1..4]
+      @rx.merge!(array_to_hash_elem(match[0..1]))
+      @tx.merge!(array_to_hash_elem(match[2..3]))
+    end
+  end
+
+  # iterate line by line and dispatch to helper functions
+  # for lines that match a pattern
+  #
+  def parse_ifconfig
+    @ifconfig.split("\n").each { |line|
+      case line
+        when /^\s+#{@protos}/
+          add_network(line)
+        when /MTU\:\d+\s+Metric\:/
+          parse_flags(line)
+        when /^\s+RX|TX/
+          parse_activity(line)
+      end
+    }
+  end
+
+  # parses the "UP LOOPBACK RUNNING  MTU:3924  Metric:1" line
+  #
+  def parse_flags(line)
+    flags = line.strip.split
+    @metric =  flags.pop.split(':')[1].to_i
+    @mtu =  flags.pop.split(':')[1].to_i
+    @flags = flags
+    @status = true if @flags.include?('UP')
+  end
+
+  # Parses networks on an interface based on the first token in the line.
+  # eg: inet or inet6
+  #
+  def add_network(line)
+    case line
+      when /^\s+inet\s/
+        addr = line.match(/\s+addr\:([\d\d?\d?\.]{4,})/i)[1]
+        mask = line.match(/\s+mask\:([\d\d?\d?\.]{4,})/i)[1]
+        bcast = line.match(/\s+bcast\:([\d\d?\d?\.]{4,})/i)
+        bcast = bcast[1] unless bcast.nil?
+        ptp = line.match(/\s+P-t-P\:([\d\d?\d?\.]{4,})/i)
+        ptp = ptp[1] unless ptp.nil?
+        @networks['inet'] = Ipv4Network.new(addr, mask, bcast, ptp)
+
+      when /^\s+inet6\s/
+        # there can be multiple inet6 entries
+        addr,scope = line.match(/\s+addr\:\s+(\S+)\s+scope\:\s*(\w+)/i)[1..2]
+        @networks["inet6:#{addr}"] = Ipv6Network.new(addr,scope)
+
+      when /^\s+#{Regexp.escape('IPX/Ethernet II')}\s/
+        addr = line.match(/\s+addr\:\s*(\S+)/)[1]
+        @networks["IPX/Ethernet II"] = IPX_EthernetII.new(addr)
+
+      when /^\s+#{Regexp.escape('IPX/Ethernet 802.2')}\s/
+        addr = line.match(/\s+addr\:\s*(\S+)/)[1]
+        @networks["IPX/Ethernet 802.2"] = IPX_Ethernet802_2.new(addr)
+
+      when /^\s+#{Regexp.escape('IPX/Ethernet 802.3')}\s/
+        addr = line.match(/\s+addr\:\s*(\S+)/)[1]
+        @networks["IPX/Ethernet 802.3"] = IPX_Ethernet802_3.new(addr)
+
+      when /^\s+#{Regexp.escape('EtherTalk Phase 2')}\s/
+        addr = line.match(/\s+addr\:\s*(\S+)/)[1]
+        @networks["EtherTalk Phase 2"] = EtherTalkPhase2.new(addr)
+
+      when /^\s+#{Regexp.escape('IPX/Ethernet SNAP')}\s/
+        addr = line.match(/\s+addr\:\s*(\S+)/)[1]
+        @networks["IPX/Ethernet SNAP"] = IPX_EthernetSNAP.new(addr)
+
+      else
+        puts "unknown network type: #{line}"
+    end
+  end
+end
+
+
+class EthernetAdapter
+  def set_mac
+    begin
+      return @ifconfig.match(/\s+hwaddr\s+([a-f\d]{1,2}(?:\:[a-f\d]{1,2}){5})/im)[1]
+    rescue NoMethodError
+      puts "Couldn't Parse MAC Address for: #{@name}: #{$!}"
+    end
+  end
+end