datalink-socket 0.0.1

data/README.rdoc

@@ -0,0 +1,58 @@
+= A Datalink-Socket for OSX and Linux
+
+To receive and send ethernet frames using ruby.
+
+* Datalink::Socket class
+* Ethernet::Socket class < Datalink::Socket
+* Ethernet::Frame class
+* Arp class
+
+== Arp
+
+> Arp.methods false
+ => [:new_request, :new_reply]
+
+> Arp.new_request :hw_src=> '00:50:56:c0:00:01', 
+                  :proto_src=> '192.168.1.10', 
+                  :proto_tgt=> '192.168.1.13'
+ => ARP, Request who-has 192.168.1.13 tell 192.168.1.10 
+
+== Frame
+
+ > data, _ = s.recv
+ => 
+ > frame = Ethernet::Frame.new data
+ => #<Ethernet::Frame:0x00000100c94b08 ... >
+ > frame.src
+ => 00:24:b2:51:a8:8e 
+ > frame.dst
+ => 00:1f:5b:ce:bd:6a 
+ > frame.ether_type
+ => 2048 
+ > frame.payload.unpack('H*')
+ => ["45200034d5ae400035061ad .... 08195fba"]
+
+
+== Receiving
+
+require 'ethernet'
+s = Ethernet::Socket.new "en1"
+s.open
+s.recv
+
+
+== Sending
+
+request = Arp.new_request :hw_src=> '00:50:56:c0:00:01', 
+                  :proto_src=> '192.168.1.10', 
+                  :proto_tgt=> '192.168.1.13'
+
+s.send request
+
+= Installation
+
+gem install datalink-socket
+
+= License
+
+Copyright (c) 2011 Jean-Michel Esnault. Released under the same license as Ruby

data/lib/arp.rb

@@ -0,0 +1,87 @@
+require 'ethernet'
+require 'ipaddr'
+
+class Arp
+  include Args
+
+  HwSrc    = Class.new(Ethernet::Address)
+  HwTgt    = Class.new(Ethernet::Address)
+  ProtoSrc = Class.new(IPAddr)
+  ProtoTgt = Class.new(IPAddr)
+
+  attr_reader :hw_src, :hw_tgt, :proto_src, :proto_tgt, :opcode
+
+  def initialize(arg={})
+    if arg.is_a?(Hash)
+      @hw_tgt = HwTgt.new
+      @opcode, @hw_src, @proto_src, @proto_tgt = 1, nil, nil, nil
+      set arg
+    elsif arg.is_a?(String)
+      parse arg
+    else
+    end
+  end
+
+  def encode
+    s=[]
+    hw_src = @hw_src.encode
+    proto_src = @proto_src.hton
+    hw_tgt = @hw_tgt.encode
+    proto_tgt = @proto_tgt.hton
+    s << eth_hdr
+    s << [1,0x0800, 6, 4, @opcode, hw_src, proto_src, hw_tgt, proto_tgt].pack("nnCCn"+"a6a4"*2)
+    s.join
+  end
+
+  def parse(s)
+    # p s.unpack('H*')
+    # p s.size
+    s.slice!(0,14) if s.size>32
+    htype, ptype, hlen, plen, opcode = s.unpack('nnccn')
+    # p htype
+    # p ptype
+    hw_src, proto_src, hw_tgt, proto_tgt = s[8..-1].unpack("a#{hlen}a#{plen}"*2)
+    raise RuntimeError, "Unsupported Hardware Type" unless htype == 1 && ptype == 0x0800
+    @hw_src = HwSrc.new(hw_src)
+    @hw_tgt = HwTgt.new(hw_tgt)
+    @proto_src = ProtoSrc.ntop(proto_src)
+    @proto_tgt = ProtoTgt.ntop(proto_tgt)
+    @opcode = opcode
+  end
+
+  def to_s
+    case @opcode
+    when 1 ; "ARP, Request who-has #{@proto_tgt} tell #{@proto_src}"
+    when 2 ; "ARP, Reply #{@proto_src} is-at #{@hw_src}"
+    end
+  end
+  
+  def reply(hw_src)
+    self.class.new_reply :hw_src=> hw_src, :proto_src=> "#{@proto_tgt}",
+                   :hw_tgt => "#{@hw_src}", :proto_tgt => "#{@proto_src}"
+  end
+  
+  class << self
+    def Arp.new_request(arg={})
+      if arg.is_a?(Hash)
+        arg[:opcode]=1
+        new arg
+      end
+    end
+    def Arp.new_reply(arg={})
+      if arg.is_a?(Hash)
+        arg[:opcode]=2
+        new arg
+      end
+    end
+  end
+
+  private
+
+  def eth_hdr
+    src = @hw_src.to_s
+    dst = @opcode == 1 ? 'ffff.ffff.ffff' : @hw_tgt.to_s
+    f = ::Ethernet::Frame.new :dst=> dst, :src=> src
+    f.encode(::Ethernet::Type::ETH_ARP)
+  end
+end

data/lib/dl_socket.rb

@@ -0,0 +1 @@
+require "dl_socket_#{`uname`.chomp.downcase}"

data/lib/dl_socket_darwin.rb

@@ -0,0 +1,113 @@
+module Datalink
+
+  BIOCGBLEN      =   0x40044266
+  BIOCSBLEN      =   0xc0044266
+  BIOCSETF       =   0x80084267
+  BIOCFLUSH      =   0x20004268
+  BIOCPROMISC    =   0x20004269
+  BIOCGDLT       =   0x4004426a
+  BIOCGETIF      =   0x4020426b
+  BIOCSETIF      =   0x8020426c
+  BIOCSRTIMEOUT  =   0x8008426d
+  BIOCGRTIMEOUT  =   0x4008426e
+  BIOCGSTATS     =   0x4008426f
+  BIOCIMMEDIATE  =   0x80044270
+  BIOCVERSION    =   0x40044271
+  BIOCGRSIG      =   0x40044272
+  BIOCSRSIG      =   0x80044273
+  BIOCGHDRCMPLT  =   0x40044274
+  BIOCSHDRCMPLT  =   0x80044275
+  BIOCGSEESENT   =   0x40044276
+  BIOCSSEESENT   =   0x80044277
+  BIOCSDLT       =   0x80044278
+  BIOCGDLTLIST   =   0xc00c4279
+
+  class Socket
+
+    attr_accessor :if_name
+    attr_reader :device_name, :device
+
+    def initialize(if_name)
+      @if_name = if_name
+    end
+
+    def open(if_name=@if_name)
+      num=0
+      @if_name = if_name
+      begin
+        bpf_name = "/dev/bpf#{num}"
+        @file_handle = File.open(bpf_name, "w+")
+      rescue => error
+        if num < 30 and not defined?(@file_handle)
+          num +=1
+          retry
+        else
+          raise RuntimeError, "could not open #{bpf_name}: #{error}"
+        end
+      end
+
+      @file_handle_name = bpf_name
+      @file_handle.ioctl(BIOCSETIF, [@if_name].pack("a#{@if_name.size+1}"))
+      @file_handle.ioctl(BIOCIMMEDIATE, [1].pack('I'))
+      @file_handle.ioctl(BIOCGHDRCMPLT, [0].pack('N'))
+      buf = [0].pack('i')
+      @file_handle.ioctl(BIOCGBLEN, buf)
+      @buf_size = buf.unpack('i')[0]
+      timeout = [5,0].pack('LL')
+      @file_handle.ioctl(BIOCSRTIMEOUT, timeout)
+      self
+    end
+
+    def send(obj)
+      @file_handle.write_nonblock(obj.respond_to?(:encode) ? obj.encode : obj)
+    end
+
+    def recv
+      __recv
+    end
+
+    def close
+      @file_handle.close
+    end
+
+    private
+
+    def sysread_nb
+      buf=''
+      @file_handle.sysread(@buf_size, buf)
+      buf
+    end
+
+    def sysread
+      begin
+        buf = sysread_nb
+        return buf
+      rescue EOFError, Errno::EAGAIN => e
+        sleep(0.25)
+        retry
+      end
+    end
+
+    def __recv
+      @recvQueue     ||=[]
+      @packet_size   ||= lambda { |n| n+3 & ~3 }
+      @header_decode ||= lambda { |hdr|
+        datalen = hdr.slice(12,4).unpack('L')[0]
+        hdrlen  = hdr.slice(16,2).unpack('v')[0]
+        size    = @packet_size.call(datalen+hdrlen)
+        [size, hdrlen]
+      }
+      if @recvQueue.empty?
+        bpf_frames = sysread
+        while bpf_frames.size>0
+          size, hdrlen = @header_decode.call(bpf_frames)
+          @recvQueue << bpf_frames.slice!(0,size)[hdrlen..-1]
+        end
+        __recv
+      else
+        @recvQueue.shift
+      end
+    end
+  end
+end
+

data/lib/dl_socket_linux.rb

@@ -0,0 +1,83 @@
+require 'socket'
+
+module Datalink
+  class Socket < ::Socket
+
+    IFF_UP         =  0x0001
+    IFF_BROADCAST  =  0x0002
+    IFF_DEBUG      =  0x0004
+    IFF_LOOPBACK   =  0x0008
+    IFF_P2P        =  0x0010
+    IFF_NOTRAILERS =  0x0020
+    IFF_RUNNING    =  0x0040
+    IFF_NOARP      =  0x0080
+    IFF_PROMISC    =  0x0100
+    IFF_ALLMULTI   =  0x0200
+    IFF_MASTER     =  0x0400
+    IFF_SLAVE      =  0x0800
+    IFF_MULTICAST  =  0x1000
+    SIOCGIFINDEX   =  0x8933
+    SIOCGIFFLAGS   =  0x8913
+    SIOCSIFFLAGS   =  0x8914
+    PF_PACKET      =  17
+    AF_PACKET      =  PF_PACKET
+    IFNAMSIZ       =  16
+
+    def flags
+      read_flags
+    end
+    self.class.constants.reject { |c| !( c =~/^IFF_/) }.collect { |f| f.to_s.split('_')[1].downcase}.each do |f|
+      define_method("#{f}?") do
+        flags & self.class.const_get("IFF_#{f.upcase}") > 0
+      end
+      define_method("set_#{f}") do
+        flags = read_flags
+        flags |= self.class.const_get("IFF_#{f.upcase}")
+        write_flags(flags) 
+      end
+      define_method("unset_#{f}") do
+        flags = read_flags
+        flags &= ~self.class.const_get("IFF_#{f.upcase}")
+        write_flags(flags) 
+      end
+    end
+
+    def initialize(if_name, proto=0x003)
+      @if_name = if_name
+      super(PF_PACKET, Socket::SOCK_RAW, proto)
+      ifreq = [if_name.dup].pack 'a32'
+      ioctl(SIOCGIFINDEX, ifreq)
+      bind [AF_PACKET].pack('s') + [proto].pack('n') + ifreq[16..20]+ ("\x00" * 12)
+    end
+
+    def recv
+      data, from = recvfrom(2048)
+      ether_type = data[12,2].unpack('n')[0]
+      [data, ether_type, Time.now]
+    end
+
+    def send(obj)
+      if obj.respond_to?(:encode)
+        super(obj.encode,0)
+      else
+        super(obj,0)
+      end
+    end
+
+    def open
+    end
+
+    private
+
+    def read_flags
+      ifreq = [@if_name.dup].pack "a#{IFNAMSIZ}"
+      ioctl(SIOCGIFFLAGS,ifreq)
+      ifreq[IFNAMSIZ,2].unpack('s')[0]
+    end
+
+    def write_flags(flags)
+      ifreq = [@if_name.dup].pack("a#{IFNAMSIZ}") + [flags].pack('s')
+      ioctl(SIOCSIFFLAGS,ifreq)
+    end
+  end
+end

data/lib/ethernet.rb

@@ -0,0 +1,165 @@
+require 'ruby-ext'
+require 'dl_socket'
+require 'rubygems'
+# require 'oui'
+
+module Ethernet
+  class Socket < Datalink::Socket
+    def recv(*args)
+      eth_frame = super
+      eth_type = eth_frame.slice(12,2).unpack('n')[0]
+      [eth_frame, eth_type]
+    end
+  end
+  
+  module Type
+    ETH_IPv4        = 0x0800
+    ETH_ARP         = 0x0806
+    ETH_RARP        = 0x8035
+    ETH_Ethertalk   = 0x809B
+    ETH_AARP        = 0x80F3
+    ETH_IEEE_802_1Q = 0x8100
+    ETH_IPv6        = 0x86DD
+    def self.to_s(type)
+      case type
+      when ETH_IPv4        ; 'IPv4'
+      when ETH_IPv6        ; 'IPv6'
+      when ETH_ARP         ; 'ARP'
+      when ETH_RARP        ; 'RARP'
+      when ETH_Ethertalk   ; 'AppleTalk Ethertalk'
+      when ETH_AARP        ; 'AppleTalk Address Resolution Protocol'
+      when ETH_IEEE_802_1Q ; 'IEEE_802_1Q'
+      else
+        format("0x%04x",type)
+      end
+    end
+
+  end
+  class Address
+    attr_reader :mac
+
+    def initialize(arg=nil)
+      if arg.is_a?(String) and arg.size==6
+        parse(arg)
+      elsif arg.is_a?(String) and arg.size==14
+        parse [arg.split('.').join].pack('H*')
+      elsif arg.is_a?(String)
+        @mac = arg.split(/[-:]/).collect { |n| n.to_i(16) }
+      elsif arg.is_a?(String) and size==14
+      elsif arg.kind_of?(self.class)
+        parse arg.encode
+      elsif arg.kind_of?(self.class)
+        parse arg.encode
+      elsif ! arg
+        @mac = [0,0,0,0,0,0]
+      else
+        raise ArgumentError, "Argument error: #{self.class} #{arg.inspect}"
+      end
+    end
+
+    def to_s(delim=":")
+      case delim
+      when ':'
+        (format (["%02x"]*6).join(delim), *@mac)
+      when '.'
+        (format (["%04x"]*3).join(delim), *(@mac.pack('C6').unpack('n3')))
+      end
+    end
+
+    # def to_s_oui
+    #   comp_id = Ethernet::OUI.company_id_from_arr(@mac[0..2])
+    #   if comp_id == 'Unknown'
+    #     to_s.downcase
+    #   else
+    #     s = []
+    #     s << comp_id
+    #     s <<  (format (["%02x"]*3).join(":"), *@mac[3..5])
+    #     s.join('_')
+    #   end
+    # end
+
+    def encode
+      @mac.pack('C*')
+    end
+    
+    def to_hash
+      to_s
+    end
+
+    private
+
+    def parse(s)
+      @mac = s.unpack('C6')
+    end
+  end
+
+  include Type
+
+  def self.packet_factory(frame, ether_type, time)
+    s = frame.dup
+    case ether_type
+    when IPv4  ; puts "IPv4:"
+    when IPv6  ; puts "IPv6:"
+    when ARP   ; puts "ARP:"
+    when RARP  ; puts "RARP:"
+    else
+      puts "Ether_type: #{ether_type}:"
+    end
+    puts s.unpack('H*')
+  end
+
+  class Frame
+    include Args
+    Src = Class.new(Address)
+    Dst = Class.new(Address)
+    attr_reader :src, :dst, :ether_type, :payload
+    attr_writer_delegate :src, :dst
+    def initialize(arg={})
+      if arg.is_a?(Hash)
+        @src = Src.new
+        @dst = Dst.new
+        @ether_type=0
+        set(arg)
+      elsif arg.is_a?(String)
+        parse arg
+      else
+        raise ArgumentError, "Invalid argument :#{arg.inspect}"
+      end
+    end
+    def encode(ether_type=@ether_type, payload=nil)
+      @ether_type = ether_type if ether_type
+      @payload = payload if payload
+      frame = []
+      frame << @dst.encode
+      frame << @src.encode
+      frame << [ether_type].pack('n')
+      if @payload
+        if @payload.respond_to?(:encode)
+          frame << @payload.encode if @payload.respond_to?(:encode)
+        else
+          frame << @payload
+        end
+      end
+      frame.join
+    end
+    def parse(s)
+      self.dst = s.slice!(0,6)
+      self.src = s.slice!(0,6)
+      @ether_type = s.slice!(0,2).unpack('n')[0]
+      @payload = s
+    end
+    def ieee_802_3?
+      type? == :ieee_802_3
+    end
+    def ethernet_v2?
+      type? == :ethernet_v2
+    end
+    def type?
+      if @ether_type < 0x600
+        :ieee_802_3
+      else
+        :ethernet_v2
+      end
+    end
+  end
+end

data/lib/ruby-ext.rb

@@ -0,0 +1,108 @@
+
+class Object
+  def to_shex(*args)
+    self.respond_to?(:encode) ? self.encode(*args).unpack('H*')[0] : ""
+  end
+  alias to_s_hexlify to_shex
+end
+
+class Class
+  def attr_checked(attribute, &validation)
+    define_method "#{attribute}=" do |val|
+      raise "Invalid attribute #{val.inspect}" unless validation.call(val)
+      instance_variable_set("@#{attribute}", val)
+    end
+    define_method attribute do
+      instance_variable_get "@#{attribute}"
+    end
+  end
+  def attr_writer_delegate(*args)
+    args.each do |name|
+      define_method "#{name}=" do |value|
+        instance_variable_set("@#{name}", self.class.const_get(name.to_s.to_camel.to_sym).new(value))
+      end
+    end
+  end
+end
+
+class String
+  def to_underscore
+    gsub(/([A-Z]+|[A-Z][a-z])/) {|x| ' ' + x }.gsub(/[A-Z][a-z]+/) {|x| ' ' + x }.split.collect{|x| x.downcase}.join('_')
+  end
+  def to_camel
+    split('_').collect {|x| x.capitalize}.join
+  end
+  def hexlify
+    l,n,ls,s=0,0,[''],self.dup
+    while s.size>0
+      l = s.slice!(0,16)
+      ls << format("0x%4.4x:  %s", n, l.unpack("n#{l.size/2}").collect { |x| format("%4.4x",x) }.join(' '))
+      n+=1
+    end
+    if l.size%2 >0
+      ns = l.size>1 ? 1 : 0
+      ls.last << format("%s%2.2x",' '*ns,l[-1].pack('C')[0])
+    end
+    ls
+  end
+end
+
+class Symbol
+  def to_klass
+    to_s.to_camel.to_sym
+  end
+  def to_setter
+    (to_s + "=").to_sym
+  end
+end
+
+module Args
+  def set(h)
+    for key in [ivars].flatten
+      if h.has_key?(key) and ! h[key].nil?
+        begin
+          klassname = key.to_klass
+          if self.class.const_defined?(klassname)
+            instance_variable_set("@#{key.to_s}", self.class.const_get(klassname).new(h[key]))
+          elsif self.respond_to?(key.to_setter)
+            self.send key.to_setter, h[key]
+          else
+            instance_variable_set("@#{key.to_s}", h[key])
+          end
+        rescue ArgumentError => e
+          raise
+        ensure
+          #h.delete(key)
+        end
+      else
+      end
+    end
+  end
+
+  def to_hash
+    h = {}
+    for key in [ivars].flatten
+      ivar = instance_variable_get("@#{key.to_s}")
+      if ivar.respond_to?(:to_hash)
+        h.store(key,ivar.to_hash)
+      elsif ivar.is_a?(Array)
+        h.store(key, ivar.collect { |x| 
+          if x.respond_to?(:to_hash)
+            x.to_hash
+          else
+            # x.to_s
+            nil
+          end
+        }
+        )
+      else
+        h.store(key,ivar) unless ivar.nil?
+      end
+    end
+    h
+  end
+
+  def ivars
+    instance_variables.reject { |x| x =~ /^@_/ }.collect { |x| x[1..-1].to_sym }
+  end
+end

data/test/arp_test.rb

@@ -0,0 +1,18 @@
+require "test/unit"
+require "arp"
+class TestNetArp2 < Test::Unit::TestCase
+  def test_arp_request
+    req = Arp.new_request :hw_src=> '1:2:3:4:5:6', :proto_src=> '10.0.0.1', :proto_tgt=>'10.0.0.2'
+    assert_equal(1, req.opcode)
+    assert_equal('01:02:03:04:05:06', req.hw_src.to_s)
+    assert_equal('00:00:00:00:00:00', req.hw_tgt.to_s)
+    assert_equal('10.0.0.1', req.proto_src.to_s)
+    assert_equal('10.0.0.2', req.proto_tgt.to_s)
+    assert_equal('ffffffffffff010203040506080600010800060400010102030405060a0000010000000000000a000002', req.to_shex)
+  end
+  def test_arp_reply
+    req = Arp.new_request :hw_src=> '1:2:3:4:5:6', :proto_src=> '10.0.0.1', :proto_tgt=>'10.0.0.2'
+    reply  = req.reply '00:50:56:c0:00:01'
+    #TODO finish test
+  end  
+end

data/test/ethernet_test.rb

@@ -0,0 +1,71 @@
+require "test/unit"
+
+require "ethernet"
+
+class TestEthernetIeAddress < Test::Unit::TestCase
+  def test_create_address
+    assert Ethernet::Address.new
+    assert Ethernet::Address.new '00:01:02:03:04:05'
+    assert_equal '01:02:03:04:05:06', Ethernet::Address.new('1:2:3:4:5:6').to_s
+    assert_equal '0a:0b:0c:0d:0e:0f', Ethernet::Address.new('a:b:c:d:e:f').to_s
+    assert_equal '00:b0:64:fd:4f:6c', Ethernet::Address.new('00b0.64fd.4f6c').to_s
+  end
+  def test_to_s
+    assert_equal '0102.0304.0506', Ethernet::Address.new('1:2:3:4:5:6').to_s('.')
+    assert_equal '0a0b.0c0d.0e0f', Ethernet::Address.new('a:b:c:d:e:f').to_s('.')
+    assert_equal '00b0.64fd.4f6c', Ethernet::Address.new('00b0.64fd.4f6c').to_s('.')
+  end
+  def test_encode
+    assert_equal '010203040506', Ethernet::Address.new('1:2:3:4:5:6').to_shex
+    assert_equal '0a0b0c0d0e0f', Ethernet::Address.new('a:b:c:d:e:f').to_shex
+  end
+  def test_parse
+    assert_equal Ethernet::Address, Ethernet::Address.new(['010203040506'].pack('H*')).class
+    assert_equal '010203040506', Ethernet::Address.new(['010203040506'].pack('H*')).to_shex
+  end
+  # def test_to_s_oui
+  #   assert_equal 'Apple_d8:93:a4',   Ethernet::Address.new('00:1f:f3:d8:93:a4').to_s_oui
+  #   assert_equal 'Dell_01:3e:3d',    Ethernet::Address.new('00:21:9b:01:3e:3d').to_s_oui
+  #   assert_equal 'Hewlett_64:66:73', Ethernet::Address.new('00:50:8b:64:66:73').to_s_oui
+  #   assert_equal 'Intel_40:b8:8f',   Ethernet::Address.new('0:2:b3:40:b8:8f').to_s_oui
+  #   assert_equal 'Cisco_fd:4f:6c',   Ethernet::Address.new('00b0.64fd.4f6c').to_s_oui
+  # end
+end
+
+class TestEthernetType < Test::Unit::TestCase
+  def test_case_name
+    assert_equal 2054, Ethernet::Type::ETH_ARP
+    assert_equal 2048, Ethernet::Type::ETH_IPv4
+    assert_equal 34525, Ethernet::Type::ETH_IPv6
+    assert_equal 32821, Ethernet::Type::ETH_RARP
+    assert_equal 'ARP',Ethernet::Type.to_s(2054)
+    assert_equal 'RARP',Ethernet::Type.to_s(32821)
+    assert_equal 'IPv4',Ethernet::Type.to_s(2048)
+    assert_equal 'AppleTalk Ethertalk',Ethernet::Type.to_s(0x809B)
+  end
+end
+
+class TestEthernetFrame < Test::Unit::TestCase
+  include Ethernet
+  def test_create_a_frame
+    frame = Ethernet::Frame.new :src=> '0001.0002.0003', :dst=>'0004.0005.0006', :ether_type=>0x800
+    assert_equal '00:01:00:02:00:03', frame.src.to_s
+    assert_equal '00:04:00:05:00:06', frame.dst.to_s
+    assert_equal 2048, frame.ether_type
+    frame = Ethernet::Frame.new(['0004000500060001000200030800'].pack('H*'))
+    assert_equal '00:01:00:02:00:03', frame.src.to_s
+    assert_equal '00:04:00:05:00:06', frame.dst.to_s
+    assert_equal 2048, frame.ether_type
+  end
+  def test_create_ntop_ip
+    s = '01005e00000500b064fd4f6c0800' +
+    '45c0004084fe000001599131c0a801c8e0000005' + 
+    '0201002c0200000000000000fa1f00000000000000000000ffffff00000a0280000000280000000000000000'
+    sbin  = [s].pack('H*')
+    frame = Frame.new(sbin)
+    # assert_equal 'Cisco_fd:4f:6c', frame.src.to_s_oui
+    # assert_equal '01:00:5e:00:00:05', frame.dst.to_s_oui
+    assert_equal 2048, frame.ether_type
+    assert_equal '45c0004084fe000001599131c0a801c8e000000502', frame.payload[0..20].unpack('H*')[0]
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: datalink-socket
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jean-Michel Esnault
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-05 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Datalink Socket
+email: jesnault@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- lib/arp.rb
+- lib/dl_socket.rb
+- lib/dl_socket_darwin.rb
+- lib/dl_socket_linux.rb
+- lib/ethernet.rb
+- lib/ruby-ext.rb
+- test/arp_test.rb
+- test/ethernet_test.rb
+has_rdoc: true
+homepage: http://github.com/jesnault/dl
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- Datalink Socket
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Datalink Socket
+test_files: 
+- test/arp_test.rb
+- test/ethernet_test.rb