amf-ruby 0.0.2

data/lib/amf/deserializer.rb

@@ -0,0 +1,354 @@
+module AMF
+  class Deserializer
+    require 'stringio'
+    require 'ostruct'
+    require 'amf/constants'
+    require 'amf/header'
+    require 'amf/message'
+
+    attr_reader :headers, :messages, :version
+
+    def initialize( data )
+      if StringIO == data.class
+        @data = data
+      else
+        @data = StringIO.new data
+      end
+      readHeaders
+      readMessages
+
+      resetReferences
+      @data = nil
+    end
+
+    def serialize
+      AMF::Serializer.new( headers, messages, version ).data
+    end
+
+    # make this work a little bit more like a ruby object
+    def to_hash
+      {
+          'version' => self.version,
+          'headers' => self.headers.map{ |h| h.to_hash },
+          'messages' => self.messages.map{ |m| m.to_hash },
+      }
+    end
+
+    private
+
+    def readHeaders
+      @headers = Array.new
+      if ! [0,3].include? readByte
+          raise "Data is not in expected format"
+      end
+
+      # throw away the next byte, flash version which we're ignoring
+      readByte
+
+      # we have Int headers, process them all
+      readInt.times do
+        resetReferences
+        name = readUTF
+        required = readByte == 1
+        length = readLong # throwaway
+        type = readByte
+        content = readData( type )
+
+        @headers << AMF::Header.new( name, required, content )
+      end
+    end
+
+    def readMessages
+      @messages = Array.new
+      readInt.times do
+        resetReferences
+        target = readUTF
+        response = readUTF
+        length = readLong # throwaway
+        type = readByte
+        data = readData( type )
+
+        @messages << AMF::Message.new( target, response, data )
+      end
+    end
+
+    def readData( type )
+      case type
+        when AMF0_AMF3_MARKER
+          readAMF3Data
+        when AMF0_NUMBER_MARKER
+          readDouble
+        when AMF0_BOOLEAN_MARKER
+          readByte == 1
+        when AMF0_STRING_MARKER
+          readUTF
+        when AMF0_OBJECT_MARKER
+          raise 'Unsupported type AMF0_OBJECT_MARKER'
+        when AMF0_MOVIE_CLIP_MARKER
+          raise 'Unsupported type AMF0_MOVIE_CLIP_MARKER'
+        when AMF0_NULL_MARKER
+          nil
+        when AMF0_UNDEFINED_MARKER
+          nil
+        when AMF0_REFERENCE_MARKER
+          raise 'Unsupported type AMF0_REFERENCE_MARKER'
+        when AMF0_HASH_MARKER
+          raise 'Unsupported type AMF0_HASH_MARKER'
+        when AMF0_OBJECT_END_MARKER
+          raise 'Unsupported type AMF0_OBJECT_END_MARKER'
+        when AMF0_STRICT_ARRAY_MARKER
+          raise 'Unsupported type AMF0_STRICT_ARRAY_MARKER'
+        when AMF0_DATE_MARKER
+          raise 'Unsupported type AMF0_DATE_MARKER'
+        when AMF0_LONG_STRING_MARKER
+          raise 'Unsupported type AMF0_LONG_STRING_MARKER'
+        when AMF0_UNSUPPORTED_MARKER
+          nil
+        when AMF0_RECORDSET_MARKER
+          raise 'Unsupported type AMF0_RECORDSET_MARKER'
+        when AMF0_XML_MARKER
+          raise 'Unsupported type AMF0_XML_MARKER'
+        when AMF0_TYPED_OBJECT_MARKER
+          raise 'Unsupported type AMF0_TYPED_OBJECT_MARKER'
+        else
+          raise "Unsupported AMF0 type: #{ type }"
+        end
+    end
+
+    def readAMF3Data
+      @version = AMF3_VERSION
+
+      type = readByte
+      case type
+        when AMF3_UNDEFINED_MARKER
+          nil
+        when AMF3_NULL_MARKER
+          nil
+        when AMF3_FALSE_MARKER
+          false
+        when AMF3_TRUE_MARKER
+          true
+        when AMF3_INTEGER_MARKER
+          readAMF3Int
+        when AMF3_DOUBLE_MARKER
+          readDouble
+        when AMF3_STRING_MARKER
+          readAMF3String
+        when AMF3_XML_DOC_MARKER
+          raise 'Unsupported type AMF3_XML_DOC_MARKER'
+        when AMF3_DATE_MARKER
+          readAMF3Date
+        when AMF3_ARRAY_MARKER
+          readAMF3Array
+        when AMF3_OBJECT_MARKER
+          readAMF3Object
+        when AMF3_XML_MARKER
+          raise 'Unsupported type AMF3_XML_MARKER'
+        when AMF3_BYTE_ARRAY_MARKER
+          raise 'Unsupported type AMF3_BYTE_ARRAY_MARKER'
+        when AMF3_DICT_MARKER
+          raise 'Unsupported type AMF3_DICT_MARKER'
+        else
+          raise "Unsported AMF3 type: #{ type }"
+      end
+    end
+
+    def readByte
+      @data.readchar.unpack("C")[0]
+    end
+
+    def readInt
+      ( readByte << 8 ) + readByte
+    end
+
+  def readUTF
+      length = readInt
+      if length == 0
+        ''
+      else
+        string = String.new
+        length.times do
+          string << readByte.chr
+        end
+      end
+      string
+    end
+
+    def readAMF3Int
+      int = readByte
+      if int < 128
+        int
+      else
+        int = ( int & 127 ) << 7
+        next_int = readByte
+        if next_int < 128
+          int | next_int
+        else
+          int = ( int | ( next_int & 127 ) ) << 7
+          next_int = readByte
+          if next_int < 128
+            int | next_int
+          else
+            int = ( int | ( next_int & 127 ) ) << 8
+            int |= readByte
+
+            # We have 29bit ints in AMF3, need to convert those to something
+            # more normalized
+            if int & 0x10000000 != 0
+              int |= ~0x1fffffff
+            end
+            int
+          end
+        end
+      end
+    end
+
+    def readDouble
+      bytes = String.new
+      8.times do
+        bytes << readByte
+      end
+      bytes.to_s.reverse.unpack( 'dbfl' )[0]
+    end
+
+    def readLong
+      ( readByte << 24 ) | ( readByte << 16 ) | ( readByte << 8 ) | readByte
+    end
+
+    def readAMF3String
+      strref = readAMF3Int
+
+      if ( strref & 1 ) == 0
+        strref = strref >> 1
+        if @storedStrings[ strref ].nil?
+          raise "found a undefined string ref: #{ strref }"
+        end
+        @storedStrings[ strref ]
+      else
+        strlen = strref >> 1
+        str = String.new
+        if strlen > 0
+          @storedStrings << readBuffer( strlen )
+          @storedStrings.last
+        else
+          ''
+        end
+      end
+    end
+
+    def readBuffer( length )
+      data = String.new
+      length.times do
+        data << readByte.chr
+      end
+      data
+    end
+
+    def readAMF3Date
+      firstInt = readAMF3Int
+      if ( firstInt & 1 ) == 0
+        firstInt = firstInt >> 1
+        if @storedObjects[ firstInt ].nil?
+          raise "found an undeifned storedObject ref: #{ firstInt }"
+        end
+        @storedObjects[ firstInt ]
+      else
+        ms = readDouble
+        @storedObjects << Time.at( ms )
+        Time.at ms
+      end
+    end
+
+    def readAMF3Array
+      handle = readAMF3Int
+      inline = ( handle & 1 ) != 0
+      handle = handle >> 1
+      if inline
+        storeable = Hash.new
+        @storedObjects << storeable
+        key = readAMF3String
+        while key != ''
+          storeable[ key ] = readAMF3Data
+          key = readAMF3String
+        end
+
+        handle.times do |i|
+          storeable[ i ] = readAMF3Data
+        end
+
+        storeable
+      else
+        @storedObjects[ handle ]
+      end
+    end
+
+    # uhhggg, this one sucks!
+    def readAMF3Object
+      handle = readAMF3Int
+      inline = ( handle & 1 ) != 0
+      handle = handle >> 1
+
+      if ! inline
+        return @storedObjects[ handle ]
+      end
+
+      inlineClassDef = ( handle &1 ) != 0
+      handle = handle >> 1
+      if inlineClassDef
+        typeId = readAMF3String
+        externalizable = ( handle &1 ) != 0
+        handle = handle >> 1
+        dynamic = ( handle &1 ) !=0
+        handle = handle >> 1
+        classMemberCount = handle
+
+        classMemberDefinitions = Array.new
+        classMemberCount.times do
+          classMemberDefinitions << readAMF3String
+        end
+
+        classDefinition = {
+                  'type'              => typeId,
+                  'externalizable'    => externalizable,
+                  'dynamic'           => dynamic,
+                  'members'           => classMemberDefinitions
+        }
+        @storedDefinitions << classDefinition
+      else
+        classDefinition = @storedDefinitions[ handle ]
+      end
+
+      obj = OpenStruct.new
+      @storedObjects << obj
+
+      if classDefinition[ 'externalizable' ]
+        obj.send( "#{ AMF_FIELD_EXTERNALIZED_DATA }=", readAMF3Data )
+      else
+        classDefinition[ 'members' ].each do |member|
+          obj.send( "#{ member }=", readAMF3Data )
+        end
+
+        if classDefinition[ 'dynamic' ]
+          key = readAMF3String
+          while key != ''
+            obj.send( "#{ key }=", readAMF3Data )
+            key = readAMF3String
+          end
+        end
+      end
+
+      if classDefinition[ 'type' ] != ''
+        obj.send( "#{ AMF_FIELD_EXPLICIT_TYPE }=", classDefinition[ 'type' ] )
+      end
+
+      obj
+    end
+
+    def resetReferences
+      @storedStrings      = Array.new
+      @storedObjects      = Array.new
+      @storedDefinitions  = Array.new
+    end
+  end
+end
+

data/lib/amf/header.rb

@@ -0,0 +1,21 @@
+module AMF
+  class Header
+    attr_accessor :target, :required, :data
+
+    def initialize( target, required, data )
+      @target = target
+      @required = required
+      @data = data
+    end
+
+    def to_hash
+      { 'name' => self.target, 'required' => self.required, 'data' => self.data }
+    end
+
+    # needed this method, it is a bit of a hack
+    def each
+      self.to_hash.each
+    end
+  end
+end
+

data/lib/amf/message.rb

@@ -0,0 +1,36 @@
+module AMF
+  class Message
+    attr_accessor :targetURL, :responseURL, :data
+
+    def initialize( targetURL, responseURL, data )
+      @targetURL = targetURL
+      @responseURL = responseURL
+      @data = data
+    end
+
+    def to_hash
+      { 'targetUri' => self.targetURL, 'responseUri' => self.responseURL, 'data' => recursive_marshal( data ) }
+    end
+
+    private
+
+    def recursive_marshal( data )
+      ret = Hash.new
+      if data.class == OpenStruct
+        data.marshal_dump.each{ |k,v|
+          ret[k] = recursive_marshal v
+        }
+      elsif data.class == Hash
+        data.each{ |k,v|
+          ret[k] = recursive_marshal v
+        }
+      else
+        ret = data
+      end
+
+      ret
+    end
+
+  end
+end
+

data/lib/amf/serializer.rb

@@ -0,0 +1,288 @@
+module AMF
+  class Serializer
+
+    attr_accessor :data
+
+    def initialize( headers, messages, amfVersion )
+      @headers      = headers
+      @messages     = messages
+      @amfVersion   = amfVersion
+      @data         = String.new
+
+      writeInt 0 # start if off right
+
+      # start writing the headers
+      writeInt @headers.count
+      @headers.each do |header|
+        resetReferences
+        writeUTF header.target
+        if header.required == true
+          writeByte 1
+        else
+          writeByte 0
+        end
+        tmpdata = @data
+        @data = String.new
+        writeData header.data
+        serializedHeader = @data
+        @data = tmpdata
+        writeLong serializedHeader.length
+        @data += serializedHeader
+      end
+
+      # and write the data
+      writeInt @messages.count
+      @messages.each do |message|
+        resetReferences
+        writeUTF message.targetURL
+        writeUTF message.responseURL
+        tmpdata = @data
+        @data = String.new
+        writeData message.data
+        serializedMessage = @data
+        @data = tmpdata
+        writeLong serializedMessage.length
+        @data += serializedMessage
+      end
+    end
+
+    private
+
+    def writeData( data )
+      if @amfVersion == AMF3_VERSION
+        writeByte( AMF0_AMF3_MARKER )
+        writeAMF3Data( data )
+      else
+        raise "Unsupported writing AMF0 types"
+      end
+    end
+
+    def writeAMF3Data( data )
+      case data.class.to_s
+        when 'Fixnum'
+          writeAMF3Number( data )
+        when 'Float'
+          writeByte( AMF3_DOUBLE_MARKER )
+          writeDouble( data )
+        when 'String'
+          writeByte( AMF3_STRING_MARKER )
+          writeAMF3String( data )
+        when 'FalseClass'
+          writeByte( AMF3_FALSE_MARKER )
+        when 'TrueClass'
+          writeByte( AMF3_TRUE_MARKER )
+        when 'NilClass'
+          writeByte( AMF3_NULL_MARKER )
+        when 'Time'
+          writeAMF3Date( data )
+        when 'Hash'
+          writeAMF3Array( data )
+        when 'OpenStruct'
+          if data.send( AMF_FIELD_EXPLICIT_TYPE )
+            writeAMF3TypedObject( data )
+          else
+            writeAMF3AnonymousObject( data )
+          end
+      else
+         raise "Unknown data type: #{ data.class }"
+      end
+    end
+
+    def writeByte( byte )
+      @data << [ byte ].pack( 'c' )
+    end
+
+    def writeInt( int )
+      @data << [ int ].pack( 'n' )
+    end
+
+    def writeLong( long )
+      @data << [ long ].pack( 'N' )
+    end
+
+    def writeDouble( double )
+     @data << [ double ].pack( 'd' ).reverse
+    end
+
+    def writeUTF( string )
+      writeInt( string.length )
+      @data << string
+    end
+
+    def writeLongUTF( string )
+      writeLong( string.length )
+      @data << string
+    end
+
+    def writeBoolean( bit )
+      writeByte( AMF0_BOOLEAN_MARKER )
+      writeByte( bit )
+    end
+
+    def writeString( string )
+      if string.count < 65536
+        writeByte( AMF0_STRING_MARKER )
+        writeUFT( string )
+      else
+        writeByte( AMF0_LONG_STRING_MARKER )
+        writeLongUTF( string )
+      end
+    end
+
+    def writeNumber( number )
+      writeByte( AMF0_NUMBER_MARKER )
+      writeDouble( number.to_f )
+    end
+
+    def writeNull
+      writeByte( AMF0_NULL_MARKER )
+    end
+
+    def writeUndefined
+      writeByte( AMF0_UNDEFINED_MARKER )
+    end
+
+    def writeAMF3Int( int )
+      int &= 0x1fffffff
+      if int < 0x80
+        data = int.chr
+      elsif int < 0x4000
+        data = ( int >> 7 & 0x7f | 0x80 ).chr + ( int & 0x7f ).chr
+      elsif int < 0x200000
+        data = ( int >> 14 & 0x7f | 0x80 ).chr + ( int >> 7 & 0x7f | 0x80 ).chr + ( int & 0x7f ).chr
+      else
+        data = ( int >> 22 & 0x7f | 0x80 ).chr + ( int >> 15 & 0x7f | 0x80 ).chr + ( int >> 8 & 0x7f | 0x80 ).chr + ( int & 0xff ).chr
+      end
+
+      @data += data
+    end
+
+    def writeAMF3String( string )
+      if string.empty?
+        writeByte( AMF3_NULL_MARKER )
+      elsif ! handleReference( string, @storedStrings )
+        writeAMF3Int( ( string.length << 1 | 1 ) )
+        @data += string
+      end
+    end
+
+    # in ruby speak this is time, but we go with the status quo
+    def writeAMF3Date( date )
+      writeByte AMF3_DATE_MARKER
+      writeAMF3Int 1
+      writeDouble date.to_f
+    end
+
+    def writeAMF3Array( array )
+      if @storedObjects.keys.count <= AMF_MAX_STORED_OBJECTS
+        @storedObjects[ @storedObjects.keys.count ] = @storedObjects.keys.count
+      end
+
+      # meh, so there is a whole boat of stuff that we're missing here -
+      # arrays that are sparse, arrays with string 'keys'.  in my testing
+      # I never saw any of those data types so just doing it the easy way
+      writeByte( AMF3_ARRAY_MARKER )
+      writeAMF3Int( ( array.count * 2 ) + 1 )
+      array.select{ |x| x.class == String }.each do |key, value|
+        writeAMF3String( key.to_s )
+        writeAMF3Data( value )
+      end
+      writeAMF3String('')
+
+      array.select{ |x| x.class == Fixnum }.each do |key,value|
+        writeAMF3Data value
+      end
+    end
+
+    def writeAMF3TypedObject( data )
+      writeByte( AMF3_OBJECT_MARKER )
+      if ! handleReference( data, @storedObjects )
+        classname = data.send( AMF_FIELD_EXPLICIT_TYPE )
+        if @className2TraitsInfo[ classname ].nil?
+          propertyNames = Array.new
+          data.marshal_dump.each do |key, value|
+            if key[0] != "\0" and key.to_s != AMF_FIELD_EXPLICIT_TYPE
+              propertyNames << key
+            end
+          end
+
+          writeAMF3Int( propertyNames.count << 4 | 3 )
+          writeAMF3String( classname )
+          propertyNames.each do |p|
+            writeAMF3String( p.to_s )
+          end
+
+          traitsInfo = { 'referenceId' => @className2TraitsInfo.keys.count, 'propertyNames' => propertyNames }
+          @className2TraitsInfo[ classname ] = traitsInfo
+        else
+          traitsInfo = @className2TraitsInfo[ classname ]
+          referenceId = traitsInfo[ 'referenceId' ]
+          propertyNames = traitsInfo[ 'propertyNames' ]
+          writeAMF3Int( referenceId << 2 | 1 )
+        end
+
+        propertyNames.each do |p|
+          writeAMF3Data( data.marshal_dump[ p ] )
+        end
+      end
+    end
+
+
+    def writeAMF3AnonymousObject( data, doRef = true )
+      writeByte( AMF3_OBJECT_MARKER )
+      if doRef && handleReference( data, @storedObjects )
+        return
+      end
+
+      writeAMF3Int( 0xB )
+      @className2TraitsInfo[ data.hash ] = Hash.new
+      writeAMF3String( '' )
+      data.marshal_dump.each do |key, value|
+        writeAMF3String( key.to_s )
+        writeAMF3Data( value )
+      end
+      writeByte( AMF3_NULL_MARKER )
+    end
+
+    def writeAMF3Number( number )
+      # can only handle signed 29bit ints
+      if number >= -2^28 or number <= 2^28
+        writeByte( AMF3_INTEGER_MARKER )
+        writeAMF3Int( number )
+      else
+        writeByte( AMF3_DOUBLE_MARKER )
+        writeDouble( number )
+      end
+    end
+
+    def handleReference( obj, reference )
+      key = false
+      hash = obj.hash.to_s
+      if reference[ hash ].nil?
+        if reference.keys.count <= AMF_MAX_STORED_OBJECTS
+          reference[ hash ] = reference.keys.count
+        end
+      else
+        key = reference[ hash ]
+      end
+
+      if key
+        if @amfVersion == AMF0_VERSION
+          raise "unsupported AMF0_VERSION reference"
+        else
+          handle = key << 1
+          writeAMF3Int( handle )
+          return true
+        end
+      else
+        return false
+      end
+    end
+
+    def resetReferences
+      @storedObjects          = Hash.new
+      @storedStrings          = Hash.new
+      @className2TraitsInfo   = Hash.new
+    end
+  end
+end