amfora 0.0.1

data/lib/amf/pure/io_helpers.rb

@@ -0,0 +1,94 @@
+module AMF
+  module Pure
+    module ReadIOHelpers #:nodoc:
+      def read_int8(source)
+        source.read(1).unpack('c').first
+      end
+
+      def read_word8(source)
+        source.read(1).unpack('C').first
+      end
+
+      def read_double(source)
+        source.read(8).unpack('G').first
+      end
+
+      def read_word16_network(source)
+        source.read(2).unpack('n').first
+      end
+
+      def read_int16_network(source)
+        str = source.read(2)
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        str.unpack('s').first
+      end
+
+      def read_word32_network(source)
+        source.read(4).unpack('N').first
+      end
+
+      def byte_order
+        if [0x12345678].pack("L") == "\x12\x34\x56\x78"
+          :BigEndian
+        else
+          :LittleEndian
+        end
+      end
+
+      def byte_order_little?
+        (byte_order == :LittleEndian) ? true : false;
+      end
+    end
+
+    module WriteIOHelpers #:nodoc:
+      def pack_integer(integer)
+        integer = integer & 0x1fffffff
+        if(integer < 0x80)
+          [integer].pack('c')
+        elsif(integer < 0x4000)
+          [integer >> 7 & 0x7f | 0x80].pack('c')+
+          [integer & 0x7f].pack('c')
+        elsif(integer < 0x200000)
+          [integer >> 14 & 0x7f | 0x80].pack('c') +
+          [integer >> 7 & 0x7f | 0x80].pack('c') +
+          [integer & 0x7f].pack('c')
+        else
+          [integer >> 22 & 0x7f | 0x80].pack('c')+
+          [integer >> 15 & 0x7f | 0x80].pack('c')+
+          [integer >> 8 & 0x7f | 0x80].pack('c')+
+          [integer & 0xff].pack('c')
+        end
+      end
+
+      def pack_double(double)
+        [double].pack('G')
+      end
+
+      def pack_int8(val)
+        [val].pack('c')
+      end
+
+      def pack_int16_network(val)
+        [val].pack('n')
+      end
+
+      def pack_word32_network(val)
+        str = [val].pack('L')
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        str
+      end
+
+      def byte_order
+        if [0x12345678].pack("L") == "\x12\x34\x56\x78"
+          :BigEndian
+        else
+          :LittleEndian
+        end
+      end
+
+      def byte_order_little?
+        (byte_order == :LittleEndian) ? true : false;
+      end
+    end
+  end
+end

data/lib/amf/pure/remoting.rb

@@ -0,0 +1,119 @@
+require 'amf/pure/io_helpers'
+
+module AMF
+  module Pure
+    # AMF request object wrapper, it is responsible for deserializing AMF requests
+    class Request
+      attr_reader :amf_version, :headers, :message
+
+      def initialize
+        @amf_version = 3
+        @headers = []
+      end
+
+      def populate_from_stream(stream)
+        stream = StringIO.new(stream) unless StringIO === stream
+
+        # Read AMF version
+        @amf_version = read_word16_network(stream)
+
+        # Read in headers
+        header_count = read_word16_network(stream)
+        0.upto(header_count-1) do
+          name = stream.read(read_word16_network(stream))
+          must_understand = read_int8(stream) != 0
+          length = read_word32_network(stream)
+          data = AMF.deserialize(stream)
+          @headers << Header.new(name, must_understand, data)
+        end
+
+        # Read in first message
+        message_count = read_word16_network(stream)
+        target_uri = stream.read(read_word16_network(stream))
+        response_uri = stream.read(read_word16_network(stream))
+        length = read_word32_network(stream)
+        data = AMF.deserialize(stream)
+        if data.is_a?(Array) && data.length == 1 && data[0].is_a?(::AMF::Messages::AbstractMessage)
+          data = data[0]
+        end
+        @message = Message.new(target_uri, response_uri, data)
+
+        self
+      end
+
+      private
+      include AMF::Pure::ReadIOHelpers
+    end
+
+    # AMF response object wrapper, it is responsible for serializing the AMF response
+    class Response
+      attr_accessor :amf_version, :headers, :message
+
+      def initialize
+        @amf_version = 0
+        @headers = []
+      end
+
+      def serialize
+        stream = ""
+
+        # Write version
+        stream << pack_int16_network(@amf_version)
+
+        # Write headers
+        stream << pack_int16_network(@headers.length) # Header count
+        @headers.each do |h|
+          stream << pack_int16_network(h.name.length)
+          stream << h.name
+          stream << pack_int8(h.must_understand ? 1 : 0)
+          stream << pack_word32_network(-1)
+          stream << AMF.serialize(h.data, 0)
+        end
+
+        # Write messages
+        stream << pack_int16_network(1) # we only send one message
+        stream << pack_int16_network(@message.target_uri.length)
+        stream << @message.target_uri
+
+        stream << pack_int16_network(@message.response_uri.length)
+        stream << @message.response_uri
+
+        stream << pack_word32_network(-1)
+        stream << AMF0_AMF3_MARKER if @amf_version == 3
+        # stream << AMF.serialize(m.data, @amf_version)
+        stream << @message.data
+
+        stream
+      end
+      
+      def to_s
+        serialize
+      end
+
+      private
+      include AMF::Pure::WriteIOHelpers
+    end
+
+    # AMF::Request or AMF::Response header
+    class Header
+      attr_accessor :name, :must_understand, :data
+
+      def initialize name, must_understand, data
+        @name = name
+        @must_understand = must_understand
+        @data = data
+      end
+    end
+
+    # AMF::Request or AMF::Response message
+    class Message
+      attr_accessor :target_uri, :response_uri, :data
+
+      def initialize target_uri, response_uri, data
+        @target_uri = target_uri
+        @response_uri = response_uri
+        @data = data
+      end
+    end
+  end
+end

data/lib/amf/pure/serializer.rb

@@ -0,0 +1,230 @@
+require 'amf/pure/io_helpers'
+
+module AMF
+  module Pure
+    class AMF0Serializer
+      def version
+        0
+      end
+      
+      def serialize(obj, &block)
+        
+      end
+    end
+
+      # AMF3 implementation of serializer
+    class AMF3Serializer
+      attr_accessor :stream
+      attr_reader :string_cache
+
+      def initialize(params = {})
+        @stream = ""
+        @string_cache = SerializerCache.new :string
+        @object_cache = SerializerCache.new :object
+        @serializable_names = params[:serializable_names]
+        @opts = params[:options]
+      end
+
+      def version
+        3
+      end
+
+      def serialize(obj, &block)
+        if obj.is_a?(NilClass)
+          write_null
+        elsif obj.is_a?(TrueClass)
+          write_true
+        elsif obj.is_a?(FalseClass)
+          write_false
+        elsif obj.is_a?(Float)
+          write_float(obj)
+        elsif obj.is_a?(Integer)
+          write_integer(obj)
+        elsif obj.is_a?(Symbol) || obj.is_a?(String)
+          write_string(obj.to_s)
+        elsif obj.is_a?(Time)
+          write_date(obj)
+        elsif obj.is_a?(Array)
+          write_array(obj, &block)
+        elsif obj.is_a?(Hash) || obj.is_a?(Object)
+          write_object(obj, &block)
+        end
+        @stream
+      end
+
+      def write_reference index
+        header = index << 1 # shift value left to leave a low bit of 0
+        @stream << pack_integer(header)
+      end
+
+      def write_null
+        @stream << AMF3_NULL_MARKER
+      end
+
+      def write_true
+        @stream << AMF3_TRUE_MARKER
+      end
+
+      def write_false
+        @stream << AMF3_FALSE_MARKER
+      end
+
+      def write_integer(int)
+        if int < MIN_INTEGER || int > MAX_INTEGER # Check valid range for 29 bits
+          write_float(int.to_f)
+        else
+          @stream << AMF3_INTEGER_MARKER
+          @stream << pack_integer(int)
+        end
+      end
+
+      def write_float(float)
+        @stream << AMF3_DOUBLE_MARKER
+        @stream << pack_double(float)
+      end
+
+      def write_string(str)
+        @stream << AMF3_STRING_MARKER
+        write_utf8_vr(str)
+      end
+
+      def write_date(date)
+        @stream << AMF3_DATE_MARKER
+        if @object_cache[date] != nil
+          write_reference(@object_cache[date])
+        else
+          # Cache date
+          @object_cache.add_obj(date)
+
+          # Build AMF string
+          date.utc unless date.utc?
+          seconds = (date.to_f * 1000).to_i
+          @stream << pack_integer(AMF3_NULL_MARKER)
+          @stream << pack_double(seconds)
+        end
+      end
+
+      def write_array(array)
+        @stream << AMF3_ARRAY_MARKER
+        if @object_cache[array] != nil
+          write_reference(@object_cache[array])
+        else
+          # Cache array
+          @object_cache.add_obj(array)
+
+          # Build AMF string
+          header = array.length << 1 # make room for a low bit of 1
+          header = header | 1 # set the low bit to 1
+          @stream << pack_integer(header)
+          @stream << AMF3_CLOSE_DYNAMIC_ARRAY
+          array.each do |elem|
+            if elem.respond_to?(:to_amf)
+              @stream << elem.to_amf(@opts)
+            else
+              serialize(elem)
+            end
+          end
+          
+          block.call(self) if block_given?
+        end
+      end
+
+      def write_object(obj, &block)
+        @stream << AMF3_OBJECT_MARKER
+        if @object_cache[obj] != nil
+          write_reference(@object_cache[obj])
+        else
+          # Cache object
+          @object_cache.add_obj(obj)
+
+          # Always serialize things as dynamic objects
+          @stream << AMF3_DYNAMIC_OBJECT
+
+          if obj.is_a?(Hash)
+            @stream << AMF3_ANONYMOUS_OBJECT
+            
+            # Stringify keys to make it easier later on and allow sorting
+            obj.each do |k,v| 
+              write_utf8_vr(k.to_s)
+              serialize(obj[k])
+            end
+          else
+            # Write class name/anonymous
+            class_name = AMF::ClassMapper.get_as_class_name(obj)
+            if class_name
+              write_utf8_vr(class_name)
+            else
+              @stream << AMF3_ANONYMOUS_OBJECT
+            end
+          
+            @serializable_names.sort.each do |name|
+              write_utf8_vr(name.to_s.camelize(:lower))
+              serialize(obj.send(name))
+            end
+          end
+
+          block.call(self) if block_given?
+
+          # Write close
+          @stream << AMF3_CLOSE_DYNAMIC_OBJECT
+        end
+      end
+
+      def write_utf8_vr(str)
+        if str == ''
+          @stream << AMF3_EMPTY_STRING
+        elsif @string_cache[str] != nil
+          write_reference(@string_cache[str])
+        else
+          # Cache string
+          @string_cache.add_obj(str)
+
+          # Build AMF string
+          header = str.length << 1 # make room for a low bit of 1
+          header = header | 1 # set the low bit to 1
+          @stream << pack_integer(header)
+          @stream << str
+        end
+      end
+
+      private
+      include AMF::Pure::WriteIOHelpers
+    end
+
+    class SerializerCache #:nodoc:all:
+      def self.new(type)
+        if type == :string
+          StringCache.new
+        elsif type == :object
+          ObjectCache.new
+        end
+      end
+
+      class StringCache < Hash
+        def initialize
+          @cache_index = 0
+        end
+
+        def add_obj(str)
+          self[str] = @cache_index
+          @cache_index += 1
+        end
+      end
+
+      class ObjectCache < Hash
+        def initialize
+          @cache_index = 0
+        end
+
+        def [](obj)
+          super(obj.object_id)
+        end
+
+        def add_obj(obj)
+          self[obj.object_id] = @cache_index
+          @cache_index += 1
+        end
+      end
+    end
+  end
+end

data/lib/amf/version.rb

@@ -0,0 +1,9 @@
+module AMF
+  # AMF version
+  VERSION         = '0.0.1'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+  VARIANT_BINARY  = false
+end