mrpin-amf 2.1.8

data/ext/rocketamf_ext/serializer.h

@@ -0,0 +1,29 @@
+#include <ruby.h>
+#ifdef HAVE_RB_STR_ENCODE
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+#else
+#include <st.h>
+#endif
+
+typedef struct {
+    int version;
+    VALUE class_mapper;
+    VALUE stream;
+    long depth;
+    st_table* str_cache;
+    long str_index;
+    st_table* trait_cache;
+    long trait_index;
+    st_table* obj_cache;
+    long obj_index;
+} AMF_SERIALIZER;
+
+void ser_write_byte(AMF_SERIALIZER *ser, char byte);
+void ser_write_int(AMF_SERIALIZER *ser, int num);
+void ser_write_uint16(AMF_SERIALIZER *ser, long num);
+void ser_write_uint32(AMF_SERIALIZER *ser, long num);
+void ser_write_double(AMF_SERIALIZER *ser, double num);
+void ser_get_string(VALUE obj, VALUE encode, char** str, long* len);
+
+VALUE ser_serialize(VALUE self, VALUE ver, VALUE obj);

data/ext/rocketamf_ext/utility.h

@@ -0,0 +1,4 @@
+// Before RFLOAT_VALUE, value was in a different place in the struct
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif

data/lib/amf/common/hash_with_type.rb

@@ -0,0 +1,20 @@
+module AMF
+  # Hash-like object that can store a type string. Used to preserve type information
+  # for unmapped objects after deserialization.
+  class HashWithType < Hash
+
+    #
+    # Properties
+    #
+
+    attr_reader :class_type
+
+    #
+    # Methods
+    #
+
+    def initialize(type)
+      @class_type = type
+    end
+  end
+end

data/lib/amf/ext.rb

@@ -0,0 +1,22 @@
+begin
+  # Fat binaries for Windows
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "#{$1}/rocketamf_ext"
+rescue LoadError
+  require 'rocketamf_ext'
+end
+
+module AMF
+  # This module holds all the modules/classes that implement AMF's functionality
+  # in C
+  module Ext
+    $DEBUG and warn 'Using C library for AMF.'
+  end
+
+  #:stopdoc:
+  # Import serializer/deserializer
+  Deserializer = AMF::Ext::Deserializer
+  Serializer = AMF::Ext::Serializer
+
+  #:startdoc:
+end

data/lib/amf/pure/amf_constants.rb

@@ -0,0 +1,42 @@
+module AMF
+  module AMFConstants
+    # AMF3 Type Markers
+    AMF3_MARKER_UNDEFINED = 0x00 #"\000"
+    AMF3_MARKER_NULL      = 0x01 #"\001"
+
+    AMF3_MARKER_FALSE = 0x02 #"\002"
+    AMF3_MARKER_TRUE  = 0x03 #"\003"
+
+    AMF3_MARKER_INTEGER    = 0x04 #"\004"
+    AMF3_MARKER_DOUBLE     = 0x05 #"\005"
+    AMF3_MARKER_STRING     = 0x06 #"\006"
+    AMF3_MARKER_XML_DOC    = 0x07 #"\a"   not supported
+    AMF3_MARKER_DATE       = 0x08 #"\b"
+    AMF3_MARKER_ARRAY      = 0x09 #"\t"
+    AMF3_MARKER_OBJECT     = 0x0A #"\n"
+    AMF3_MARKER_XML        = 0x0B #"\v"   not supported
+    AMF3_MARKER_BYTE_ARRAY = 0x0C #"\f"
+
+    AMF3_MARKER_VECTOR_INT    = 0x0D #"\r"    not supported
+    AMF3_MARKER_VECTOR_UINT   = 0x0E #"\016"  not supported
+    AMF3_MARKER_VECTOR_DOUBLE = 0x0F #"\017"  not supported
+    AMF3_MARKER_VECTOR_OBJECT = 0x10 #"\020"  not supported
+
+    AMF3_MARKER_DICTIONARY = 0x11 #"\021"
+
+    # Other AMF3 Markers
+    AMF3_EMPTY_STRING      = 0x01
+
+    AMF3_CLOSE_DYNAMIC_OBJECT = 0x01
+    AMF3_CLOSE_DYNAMIC_ARRAY  = 0x01
+
+    # The minimum value for an integer that will avoid promotion to an ActionScript's Number type.
+    INTEGER_MIN               = -268_435_456
+    # The maximum value for an integer that will avoid promotion to an ActionScript's Number type.
+    INTEGER_MAX               = 268_435_455
+
+    MIN_INT_2_BYTE = 0x80
+    MIN_INT_3_BYTE = 0x4000
+    MIN_INT_4_BYTE = 0x200000
+  end
+end

data/lib/amf/pure/deserializer.rb

@@ -0,0 +1,354 @@
+module AMF
+  module Pure
+    # Pure ruby deserializer for AMF3 requests
+    class Deserializer
+
+      #
+      # Modules
+      #
+      private
+      include AMF::Pure::IOHelperRead
+      include AMF::AMFConstants
+
+      #
+      # Properties
+      #
+
+      # Used for read_object
+      public
+      attr_reader :source
+
+      # Pass in the class mapper instance to use when deserializing. This
+      # enables better caching behavior in the class mapper and allows
+      # one to change mappings between deserialization attempts.
+      public
+      def initialize(class_mapper)
+        @class_mapper = class_mapper
+      end
+
+      # Deserialize the source using AMF3. Source should either
+      # be a string or StringIO object. If you pass a StringIO object,
+      # it will have its position updated to the end of the deserialized
+      # data.
+      # raise AMFError if error appeared in deserialize, source is nil
+      # raise AMFErrorIncomplete if source is incomplete
+      # return hash {objects: [], incomplete_objects: String}
+      public
+      def deserialize(source)
+        raise AMFError, 'no source to deserialize' if source.nil?
+
+        @source = source.is_a?(StringIO) ? source : StringIO.new(source)
+
+        objects = []
+
+        incomplete_objects = nil
+
+        until @source.eof?
+
+          @cache_strings = []
+          @cache_objects = []
+          @cache_traits  = []
+
+          source_position = @source.pos
+
+          begin
+            objects << amf3_deserialize
+          rescue AMFErrorIncomplete, AMFError => e
+
+            @source.pos = source_position
+
+            incomplete_objects = @source.read
+
+            break
+          end
+        end
+
+        {
+            objects:            objects,
+            incomplete_objects: incomplete_objects
+        }
+      end
+
+      # Reads an object from the deserializer stream and returns it.
+      public
+      def read_object
+        amf3_deserialize
+      end
+
+      private
+      def amf3_deserialize
+        type = read_int8(@source)
+
+        case type
+          when AMF3_MARKER_UNDEFINED
+            nil
+          when AMF3_MARKER_NULL
+            nil
+          when AMF3_MARKER_FALSE
+            false
+          when AMF3_MARKER_TRUE
+            true
+          when AMF3_MARKER_INTEGER
+            amf3_read_integer
+          when AMF3_MARKER_DOUBLE
+            amf3_read_number
+          when AMF3_MARKER_STRING
+            amf3_read_string
+          when AMF3_MARKER_DATE
+            amf3_read_date
+          when AMF3_MARKER_ARRAY
+            amf3_read_array
+          when AMF3_MARKER_OBJECT
+            amf3_read_object
+          when AMF3_MARKER_BYTE_ARRAY
+            amf3_read_byte_array
+          when AMF3_MARKER_VECTOR_INT, AMF3_MARKER_VECTOR_UINT, AMF3_MARKER_VECTOR_DOUBLE, AMF3_MARKER_VECTOR_OBJECT, AMF3_MARKER_XML_DOC, AMF3_MARKER_XML
+            raise AMFError, "Unsupported type: #{type}"
+          when AMF3_MARKER_DICTIONARY
+            amf3_read_dictionary
+          else
+            raise AMFError, "Invalid type: #{type}"
+        end
+      end
+
+      private
+      def get_as_reference_object(type)
+        result = nil
+
+        if (type & 0x01) == 0 #is reference?
+          reference = type >> 1
+          result    = @cache_objects[reference]
+        end
+
+        result
+      end
+
+      private
+      def get_as_reference_string(type)
+        result = nil
+
+        if (type & 0x01) == 0 #is reference?
+          reference = type >> 1
+          result    = @cache_strings[reference]
+        end
+
+        result
+      end
+
+      private
+      def amf3_read_integer
+        result = 0
+
+        n = 0
+        b = read_word8(@source) || 0
+
+        while (b & 0x80) != 0 && n < 3
+          result = result << 7
+          result = result | (b & 0x7f)
+          b      = read_word8(@source) || 0
+          n      = n + 1
+        end
+
+        if n < 3
+          result = result << 7
+          result = result | b
+        else
+          #Use all 8 bits from the 4th byte
+          result = result << 8
+          result = result | b
+
+          #Check if the integer should be negative
+          if result > INTEGER_MAX
+            result -= (1 << 29)
+          end
+        end
+
+        result
+      end
+
+      private
+      def amf3_read_number
+        result = read_double(@source)
+
+        #check for NaN and convert them to nil
+        if result.is_a?(Float) && result.nan?
+          result = nil
+        end
+
+        result
+      end
+
+      private
+      def amf3_read_string
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_string(type)
+
+        if result.nil?
+          length = type >> 1
+          result = ''
+
+          if length > 0
+
+            if length > (@source.size - @source.pos)
+              raise AMFErrorIncomplete.new
+            end
+
+            result = @source.read(length)
+            result.force_encoding('UTF-8') if result.respond_to?(:force_encoding)
+            @cache_strings << result
+          end
+        end
+
+        result
+      end
+
+      private
+      def amf3_read_date
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
+          seconds = read_double(@source).to_f / 1000
+          result  = Time.at(seconds)
+          @cache_objects << result
+        end
+
+        result
+      end
+
+      private
+      def amf3_read_array
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
+          length        = type >> 1
+          property_name = amf3_read_string
+          result        = property_name.length > 0 ? {} : []
+          @cache_objects << result
+
+          while property_name.length > 0
+            value                 = amf3_deserialize
+            result[property_name] = value
+            property_name         = amf3_read_string
+          end
+
+          0.upto(length - 1) { |i| result[i] = amf3_deserialize }
+        end
+
+        result
+      end
+
+      # dynamic - c an instance of a Class definition with the dynamic trait declared; public variable members can be added and removed from instances dynamically at runtime
+      private
+      def amf3_read_object
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
+          class_type         = type >> 1
+          class_is_reference = (class_type & 0x01) == 0
+
+          if class_is_reference
+            reference = class_type >> 1
+            traits    = @cache_traits[reference]
+          else
+            dynamic         = (class_type & 0x04) != 0
+            attribute_count = class_type >> 3
+            class_name      = amf3_read_string
+
+            class_attributes = []
+            attribute_count.times { class_attributes << amf3_read_string } # Read class members
+
+            traits =
+                {
+                    class_name: class_name,
+                    members:    class_attributes,
+                    dynamic:    dynamic
+                }
+            @cache_traits << traits
+          end
+
+          result = @class_mapper.create_object(traits[:class_name])
+          @cache_objects << result
+
+          properties = {}
+
+          traits[:members].each do |key|
+            value           = amf3_deserialize
+            properties[key] = value
+          end
+
+          if traits[:dynamic]
+            while (key = amf3_read_string) && key.length != 0 do # read next key
+              value           = amf3_deserialize
+              properties[key] = value
+            end
+          end
+
+          @class_mapper.object_deserialize(result, properties)
+        end
+
+        result
+      end
+
+      private
+      def amf3_read_byte_array
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
+          length = type >> 1
+
+          if length > (@source.size - @source.pos)
+            raise AMFErrorIncomplete.new
+          end
+
+          result = StringIO.new(@source.read(length))
+          @cache_objects << result
+        end
+
+        result
+      end
+
+      private
+      def amf3_read_dictionary
+        result = nil
+
+        type = amf3_read_integer
+
+        result = get_as_reference_object(type)
+
+        if result.nil?
+          result = {}
+          @cache_objects << result
+          length    = type >> 1
+          weak_keys = read_int8(@source) # Ignore: Not supported in ruby
+
+          0.upto(length - 1) do |i|
+            result[amf3_deserialize] = amf3_deserialize
+          end
+
+        end
+
+        result
+      end
+
+    end #Deserializer
+  end #Pure
+end

data/lib/amf/pure/errors/all_files.rb

@@ -0,0 +1,2 @@
+require 'amf/pure/errors/amf_error'
+require 'amf/pure/errors/amf_error_incomplete'

data/lib/amf/pure/errors/amf_error.rb

@@ -0,0 +1,5 @@
+module AMF
+  # The standard AMF error.
+  class AMFError < StandardError
+  end
+end

data/lib/amf/pure/errors/amf_error_incomplete.rb

@@ -0,0 +1,5 @@
+module AMF
+  # Error for incomplete messages
+  class AMFErrorIncomplete < AMFError
+  end
+end

data/lib/amf/pure/helpers/all_files.rb

@@ -0,0 +1,8 @@
+require 'amf/pure/amf_constants'
+
+require 'amf/pure/helpers/io_helper_base'
+require 'amf/pure/helpers/io_helper_write'
+require 'amf/pure/helpers/io_helper_read'
+
+require 'amf/pure/helpers/cache_objects'
+require 'amf/pure/helpers/cache_strings'

data/lib/amf/pure/helpers/cache_objects.rb

@@ -0,0 +1,18 @@
+module AMF
+  module Pure
+    class CacheObjects < Hash #:nodoc:
+      def initialize
+        @cache_index    = 0
+      end
+
+      def [](obj)
+        super(obj.object_id)
+      end
+
+      def add_object(value)
+        self[value.object_id] = @cache_index
+        @cache_index        += 1
+      end
+    end
+  end
+end

data/lib/amf/pure/helpers/cache_strings.rb

@@ -0,0 +1,14 @@
+module AMF
+  module Pure
+    class CacheStrings < Hash #:nodoc:
+      def initialize
+        @cache_index = 0
+      end
+
+      def add_string(value)
+        self[value]    = @cache_index
+        @cache_index += 1
+      end
+    end
+  end
+end

data/lib/amf/pure/helpers/io_helper_base.rb

@@ -0,0 +1,19 @@
+module AMF
+  module Pure
+    module IOHelperBase
+
+      def byte_order
+        if [0x12345678].pack('L') == "\x12\x34\x56\x78"
+          :BigEndian
+        else
+          :LittleEndian
+        end
+      end
+
+      def byte_order_little?
+        byte_order == :LittleEndian
+      end
+
+    end
+  end
+end

data/lib/amf/pure/helpers/io_helper_read.rb

@@ -0,0 +1,67 @@
+require 'amf/pure/helpers/io_helper_base'
+
+module AMF
+  module Pure
+    module IOHelperRead #:nodoc:
+
+      include IOHelperBase
+
+      #
+      # Methods
+      #
+
+      public
+      def read_int8(source)
+        raise AMFErrorIncomplete.new if source.eof?
+
+        source.read(1).unpack('c').first
+      end
+
+      public
+      def read_word8(source)
+        raise AMFErrorIncomplete.new if source.eof?
+
+        source.read(1).unpack('C').first
+      end
+
+      public
+      def read_double(source)
+        bytes_to_read = 8
+
+        raise AMFErrorIncomplete.new if bytes_to_read > (source.size - source.pos)
+
+        source.read(bytes_to_read).unpack('G').first
+      end
+
+      public
+      def read_word16_network(source)
+        bytes_to_read = 2
+
+        raise AMFErrorIncomplete.new if bytes_to_read > (source.size - source.pos)
+
+        source.read(2).unpack('n').first
+      end
+
+      public
+      def read_int16_network(source)
+        bytes_to_read = 2
+
+        raise AMFErrorIncomplete.new if bytes_to_read > (source.size - source.pos)
+
+        result = source.read(bytes_to_read)
+        result.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        result.unpack('s').first
+      end
+
+      public
+      def read_word32_network(source)
+        bytes_to_read = 4
+
+        raise AMFErrorIncomplete.new if bytes_to_read > (source.size - source.pos)
+
+        source.read(bytes_to_read).unpack('N').first
+      end
+
+    end
+  end
+end

data/lib/amf/pure/helpers/io_helper_write.rb

@@ -0,0 +1,49 @@
+require 'amf/pure/helpers/io_helper_base'
+
+module AMF
+  module Pure
+    module IOHelperWrite #:nodoc:
+
+      include IOHelperBase
+
+      def pack_integer(integer)
+        integer = integer & 0x1fffffff
+
+        if integer < AMF::AMFConstants::MIN_INT_2_BYTE
+          [integer].pack('c')
+        elsif integer < AMF::AMFConstants::MIN_INT_3_BYTE
+          [integer >> 7 & 0x7f | 0x80].pack('c') +
+              [integer & 0x7f].pack('c')
+        elsif integer < AMF::AMFConstants::MIN_INT_4_BYTE
+          [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)
+        result = [val].pack('L')
+        result.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        result
+      end
+
+    end
+  end
+end