Module: Net::BER::BERParser

Included in:

IO, String, StringIO

Defined in:

lib/net/ber.rb

Overview

This module is for mixing into IO and IO-like objects.

Constant Summary

TagClasses =

The order of these follows the class-codes in BER. Maybe this should have been a hash.

[:universal, :application, :context_specific, :private]

BuiltinSyntax =

BER.compile_syntax( {
	:universal => {
 :primitive => {
		1 => :boolean,
		2 => :integer,
		4 => :string,
		5 => :null,
		6 => :oid,
		10 => :integer,
		13 => :string # (relative OID)
 },
 :constructed => {
		16 => :array,
		17 => :array
 }
	},
	:context_specific => {
 :primitive => {
		10 => :integer
 }
	}
})

Instance Method Summary

• #read_ber(syntax = nil) ⇒ Object

  read_ber TODO: clean this up so it works properly with partial packets coming from streams that don’t block when we ask for more data (like StringIOs).

• #read_ber_from_string(str, syntax = nil) ⇒ Object

  – Violates DRY! This replicates the functionality of #read_ber.

Instance Method Details

#read_ber(syntax = nil) ⇒ Object

read_ber TODO: clean this up so it works properly with partial packets coming from streams that don’t block when we ask for more data (like StringIOs). At it is, this can throw TypeErrors and other nasties. – BEWARE, this violates DRY and is largely equal in functionality to read_ber_from_string. Eventually that method may subsume the functionality of this one.

# File 'lib/net/ber.rb', line 147

def read_ber syntax=nil
  # don't bother with this line, since IO#getc by definition returns nil on eof.
  #return nil if eof?

  id = getc or return nil  # don't trash this value, we'll use it later
  #tag = id & 31
  #tag < 31 or raise BerError.new( "unsupported tag encoding: #{id}" )
  #tagclass = TagClasses[ id >> 6 ]
  #encoding = (id & 0x20 != 0) ? :constructed : :primitive

  n = getc
  lengthlength,contentlength = if n <= 127
    [1,n]
  else
    # Replaced the inject because it profiles hot.
    #j = (0...(n & 127)).inject(0) {|mem,x| mem = (mem << 8) + getc}
    j = 0
    read( n & 127 ).each_byte {|n1| j = (j << 8) + n1}
    [1 + (n & 127), j]
  end

  newobj = read contentlength

  # This exceptionally clever and clear bit of code is verrrry slow.
  objtype = (syntax && syntax[id]) || BuiltinSyntax[id]


  # == is expensive so sort this if/else so the common cases are at the top.
  obj = if objtype == :string
    #(newobj || "").dup
    s = BerIdentifiedString.new( newobj || "" )
    s.ber_identifier = id
    s
  elsif objtype == :integer
    j = 0
    newobj.each_byte {|b| j = (j << 8) + b}
    j
  elsif objtype == :oid
	  # cf X.690 pgh 8.19 for an explanation of this algorithm.
	  # Potentially not good enough. We may need a BerIdentifiedOid
	  # as a subclass of BerIdentifiedArray, to get the ber identifier
	  # and also a to_s method that produces the familiar dotted notation.
	  oid = newobj.unpack("w*")
	  f = oid.shift
	  g = if f < 40
   [0, f]
	  elsif f < 80
   [1, f-40]
	  else
   [2, f-80] # f-80 can easily be > 80. What a weird optimization.
	  end
	  oid.unshift g.last
	  oid.unshift g.first
	  oid
  elsif objtype == :array
    #seq = []
    seq = BerIdentifiedArray.new
    seq.ber_identifier = id
    sio = StringIO.new( newobj || "" )
    # Interpret the subobject, but note how the loop
    # is built: nil ends the loop, but false (a valid
    # BER value) does not!
    while (e = sio.read_ber(syntax)) != nil
      seq << e
    end
    seq
  elsif objtype == :boolean
    newobj != "\000"
  elsif objtype == :null
	  n = BerIdentifiedNull.new
	  n.ber_identifier = id
	  n
  else
    #raise BerError.new( "unsupported object type: class=#{tagclass}, encoding=#{encoding}, tag=#{tag}" )
    raise BerError.new( "unsupported object type: id=#{id}" )
  end

  # Add the identifier bits into the object if it's a String or an Array.
  # We can't add extra stuff to Fixnums and booleans, not that it makes much sense anyway.
  # Replaced this mechanism with subclasses because the instance_eval profiled too hot.
  #obj and ([String,Array].include? obj.class) and obj.instance_eval "def ber_identifier; #{id}; end"
  #obj.ber_identifier = id if obj.respond_to?(:ber_identifier)
  obj

end

#read_ber_from_string(str, syntax = nil) ⇒ Object

– Violates DRY! This replicates the functionality of #read_ber. Eventually this method may replace that one. This version of #read_ber behaves properly in the face of incomplete data packets. If a full BER object is detected, we return an array containing the detected object and the number of bytes consumed from the string. If we don’t detect a complete packet, return nil.

Observe that weirdly we recursively call the original #read_ber in here. That needs to be fixed if we ever obsolete the original method in favor of this one.

# File 'lib/net/ber.rb', line 243

def read_ber_from_string str, syntax=nil
		id = str[0] or return nil
		n = str[1] or return nil
		n_consumed = 2
		lengthlength,contentlength = if n <= 127
 [1,n]
		else
 n1 = n & 127
 return nil unless str.length >= (n_consumed + n1)
 j = 0
 n1.times {
			j = (j << 8) + str[n_consumed]
			n_consumed += 1
 }
 [1 + (n1), j]
		end

		return nil unless str.length >= (n_consumed + contentlength)
		newobj = str[n_consumed...(n_consumed + contentlength)]
		n_consumed += contentlength

		objtype = (syntax && syntax[id]) || BuiltinSyntax[id]

		# == is expensive so sort this if/else so the common cases are at the top.
		obj = if objtype == :array
 seq = BerIdentifiedArray.new
 seq.ber_identifier = id
 sio = StringIO.new( newobj || "" )
 # Interpret the subobject, but note how the loop
 # is built: nil ends the loop, but false (a valid
 # BER value) does not!
 # Also, we can use the standard read_ber method because
 # we know for sure we have enough data. (Although this
 # might be faster than the standard method.)
 while (e = sio.read_ber(syntax)) != nil
			seq << e
 end
 seq
		elsif objtype == :string
 s = BerIdentifiedString.new( newobj || "" )
 s.ber_identifier = id
 s
		elsif objtype == :integer
 j = 0
 newobj.each_byte {|b| j = (j << 8) + b}
 j
		elsif objtype == :oid
 # cf X.690 pgh 8.19 for an explanation of this algorithm.
 # Potentially not good enough. We may need a BerIdentifiedOid
 # as a subclass of BerIdentifiedArray, to get the ber identifier
 # and also a to_s method that produces the familiar dotted notation.
 oid = newobj.unpack("w*")
 f = oid.shift
 g = if f < 40
			[0,f]
 elsif f < 80
			[1, f-40]
 else
			[2, f-80] # f-80 can easily be > 80. What a weird optimization.
 end
 oid.unshift g.last
 oid.unshift g.first
 oid
		elsif objtype == :boolean
 newobj != "\000"
		elsif objtype == :null
 n = BerIdentifiedNull.new
 n.ber_identifier = id
 n
		else
 raise BerError.new( "unsupported object type: id=#{id}" )
		end

		[obj, n_consumed]
end