em-rtmp 0.0.3

data/lib/em-rtmp/connection_delegate.rb

@@ -0,0 +1,60 @@
+require "em-rtmp/buffer"
+require "em-rtmp/io_helpers"
+
+module EventMachine
+  module RTMP
+    class ConnectionDelegate
+      include IOHelpers
+
+      attr_accessor :state
+
+      # Initialize the connection delegate by storing a reference to
+      # the connection
+      #
+      # Returns nothing.
+      def initialize(connection)
+        @connection = connection
+        @state = :none
+      end
+
+      # Connection Delegates send read operations directly to the connection
+
+      # Reads from the connection buffer
+      #
+      # length - Bytes to read
+      #
+      # Returns the result of the read
+      def read(length)
+        @connection.read length
+      end
+
+      # Connection Delegates send write operations directly to the connection
+
+      # Writes to the connection socket
+      #
+      # data - Data to write
+      #
+      # Returns the result of the write
+      def write(data)
+        @connection.write data
+      end
+
+      # Obtain the number of bytes waiting in the buffer
+      #
+      # Returns an Integer
+      def bytes_waiting
+        @connection.bytes_waiting
+      end
+
+      # Used to track changes in state
+      #
+      # Returns nothing
+      def change_state(state)
+        return if @state == state
+        Logger.info "state changed from #{@state} to #{state}", caller: caller
+        @state = state
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/handshake.rb

@@ -0,0 +1,94 @@
+require "em-rtmp/connection_delegate"
+
+module EventMachine
+  module RTMP
+    class Handshake < ConnectionDelegate
+
+      # The RTMP handshake involes each party sending 3 packets of data.
+      #
+      # Client                                Server
+      # --------------------------------------------
+      # 0x03 ->
+      # 1536 random bytes (a) ->
+      #                                      <- 0x03
+      #                     <- 1536 random bytes (b)
+      # b ->
+      #                                         <- a
+      #
+      # The handshake is completed by verifying that the response received
+      # matches the challenge string, with the notable exception that the
+      # first 4 bytes may be used for timestamping and can be different, and
+      # the second 4 bytes must all be zero.
+
+      HANDSHAKE_VERSION = 0x03
+      HANDSHAKE_LENGTH = 1536
+
+      # Handles a change to the buffer state
+      #
+      # Returns a symbol indicating our state
+      def buffer_changed
+        Logger.debug "#{state} #{bytes_waiting}"
+        case state
+        when :challenge_issued
+          if bytes_waiting >= (1 + HANDSHAKE_LENGTH)
+            handle_server_challenge
+          end
+        when :challenge_received
+          if bytes_waiting >= HANDSHAKE_LENGTH
+            handle_server_response
+          end
+        else
+          raise HandshakeError, "Reached unexpected state"
+        end
+
+        state
+      end
+
+      # Send the version byte followed by our challenge
+      #
+      # Returns a state update
+      def issue_challenge
+        Logger.debug "issuing client challenge"
+
+        @client_challenge = "\x00\x00\x00\x00\x00\x00\x00\x00" + (8...HANDSHAKE_LENGTH).map{rand(255)}.pack('C*')
+
+        write_uint8 HANDSHAKE_VERSION
+        write @client_challenge
+
+        change_state :challenge_issued
+      end
+
+      # Receives the server version byte and reissues it to the stream
+      #
+      # Returns a state update
+      def handle_server_challenge
+        Logger.debug "handling server challenge"
+
+        server_version = read_uint8
+        unless server_version == HANDSHAKE_VERSION
+          raise HandshakeError, "Expected version byte to be 0x03"
+        end
+
+        server_challenge = read(HANDSHAKE_LENGTH)
+        write server_challenge
+        change_state :challenge_received
+      end
+
+      # Reads the server response to our challenge to authenticate peer
+      #
+      # Returns a state update
+      def handle_server_response
+        Logger.debug "handling client response"
+
+        server_response = read(HANDSHAKE_LENGTH)
+        unless server_response == @client_challenge
+          raise HandshakeError, "Expected server to return client challenge"
+        end
+
+        Logger.debug "handshake complete"
+        change_state :handshake_complete
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/header.rb

@@ -0,0 +1,193 @@
+module EventMachine
+  module RTMP
+    class Header
+
+      # The packet header is read as follows:
+      #
+      # The first byte (8 bits) is read into two values:
+      #    Header type (2 bits)
+      #    Stream ID (6 bits)
+      #
+      # The header type determines a header length, from which the rest of the data may be read:
+      #    TYPE    BYTES    DESCRIPTION
+      #    0b11    1        Just the header
+      #    0b10    4        Above plus timestamp (uint24 big endian)
+      #    0b01    8        Above plus body length (uint24 big endian) and message id (uint8 big endian)
+      #    0b00    12       Above plus Message stream id (uint32 little endian)
+
+      attr_accessor :header_length, :body_length, :channel_id,
+                    :message_type_id, :message_stream_id, :timestamp
+
+      HEADER_DEFAULTS = {
+        header_length: 12,
+        timestamp: 0,
+        channel_id: 3,
+        message_type_id: 0,
+        message_stream_id: 0
+      }
+
+      # RTMP has a variable length header
+      # The keys below are binary values which correspond to expected byte lengths
+      # (0b00 in header length field would result in an expected 12 byte header)
+      HEADER_LENGTHS = {
+        0b00 => 12,
+        0b01 => 8,
+        0b10 => 4,
+        0b11 => 1
+      }
+
+      # RTMP uses a single byte to represent the message type
+      # These are the known values.
+      MESSAGE_TYPES = {
+        0x00 => :none,
+        0x01 => :chunk_size,
+        0x02 => :abort,
+        0x03 => :ack,
+        0x04 => :ping,
+        0x05 => :ack_size,
+        0x06 => :bandwidth,
+        0x08 => :audio,
+        0x09 => :video,
+        0x0f => :flex, # aka AMF3 data
+        0x10 => :amf3_shared_object, # documented as kMsgContainer=16
+        0x11 => :amf3,
+        0x12 => :invoke, # aka AMF0 data
+        0x13 => :amf0_shared_object, # documented as kMsgContainer=19
+        0x14 => :amf0,
+        0x16 => :flv # documented as aggregate
+      }
+
+      # Initialize and set instance variables
+      #
+      # attrs - Hash of instance variables
+      #
+      # Returns nothing
+      def initialize(attrs={})
+        attrs.each {|k,v| send("#{k}=", v)}
+      end
+
+      # Inherit values from another header
+      #
+      # h - other Header object
+      #
+      # Returns self
+      def +(header)
+        keys = %w[header_length body_length channel_id message_type_id message_stream_id timestamp]
+        other_values = Hash[keys.map {|k| [k, header.instance_variable_get("@#{k}")]}]
+        other_values.each do |k, v|
+          unless v.nil?
+            send("#{k}=", v) unless v.nil?
+          end
+        end
+        self
+      end
+
+      # Retrieve the message type for our header
+      #
+      # Returns a symbol or nil
+      def message_type
+        MESSAGE_TYPES[message_type_id] || "unknown_type_#{message_type_id}".to_sym
+      end
+
+      # Set message type as symbol
+      #
+      # type - message type symbol
+      #
+      # Returns the id set
+      def message_type=(type)
+        self.message_type_id = MESSAGE_TYPES.invert[type]
+      end
+
+      # Encode the instantiated header to a buffer
+      #
+      # io - IO destination to write to
+      #
+      # Returns the buffer
+      def encode
+
+        # Set defaults if necessary
+        HEADER_DEFAULTS.each do |k, v|
+          send("#{k}=", v) if instance_variable_get("@#{k}").nil?
+        end
+
+        h_type = HEADER_LENGTHS.invert[header_length]
+
+        buffer = Buffer.new
+        buffer.write_bitfield [h_type, 2], [channel_id, 6]
+
+        if header_length >= 4
+          buffer.write_uint24_be timestamp
+        end
+
+        if header_length >= 8
+          buffer.write_uint24_be body_length
+          buffer.write_uint8 message_type_id
+        end
+
+        if header_length == 12
+          buffer.write_uint32_le message_stream_id
+        end
+
+        buffer.string
+      end
+
+      # Read the header from a connection
+      #
+      # connection - connection to use
+      #
+      # Returns a new header instance
+      def self.read_from_connection(stream)
+        header = new
+
+        begin
+          h_type, header.channel_id = stream.read_bitfield(2, 6)
+        rescue => e
+          raise HeaderError, "Unable to read header type byte from buffer: #{e}"
+        end
+
+        unless header.header_length = HEADER_LENGTHS[h_type]
+          raise HeaderError, "invalid header type #{h_type}"
+        end
+
+        # Stream ID may occupy up to two more bytes depending on the
+        # value of the channel_id we have read:
+        # 0 - value is second byte + 64
+        # 1 - value is third byte * 256 + second byte + 64
+        # 2 - low level protocol message (ignore)
+
+        if header.channel_id == 0x00
+          header.channel_id = stream.read_uint8 + 64
+        elsif header.channel_id == 0x01
+          header.channel_id = stream.read_uint8 + 64 + (stream.read_uint8 * 256)
+        end
+
+        # The timestamp is a 3-byte uint24. If this matches 0xffffff we will use another 4 bytes
+        # after the header as the real timestamp.
+        if header.header_length >= 4
+          header.timestamp = stream.read_uint24_be
+        end
+
+        # The next 3 bytes are the length of the object body, followed by a single byte
+        # representing the content type
+        if header.header_length >= 8
+          header.body_length = stream.read_uint24_be
+          header.message_type_id = stream.read_uint8
+        end
+
+        # The next 4 bytes are the stream ID
+        if header.header_length >= 12
+          header.message_stream_id = stream.read_uint32_le
+        end
+
+        # If the timestamp was 0xffffff, the next 4 bytes are the real timestamp
+        if header.timestamp == 0xffffff
+          header.timestamp = stream.read_uint32_be
+        end
+
+        header
+      end
+
+    end
+
+  end
+end

data/lib/em-rtmp/heartbeat.rb

@@ -0,0 +1,36 @@
+module EventMachine
+  module RTMP
+    class Heartbeat < ConnectionDelegate
+
+      def initialize(connection)
+        super connection
+      end
+
+      def buffer_changed
+
+      end
+
+      def start
+        @timer ||= EventMachine::PeriodicTimer.new(15) do
+          pulse
+        end
+
+        @block = Proc.new do
+          Logger.debug "Heartbeat Pulsing"
+        end
+
+        @block.call
+      end
+
+      def pulse
+        @block.call
+      end
+
+      def cancel
+        @timer.cancel
+        @timer = nil
+      end
+
+    end
+  end
+end

data/lib/em-rtmp/io_helpers.rb

@@ -0,0 +1,192 @@
+module EventMachine
+  module RTMP
+    module IOHelpers
+
+      # Read a unsigned 8-bit integer
+      #
+      # Returns the result of the read
+      def read_uint8
+        read(1).unpack('C')[0]
+      end
+
+      # Write an unsigned 8-bit integer
+      #
+      # value - Value to write
+      #
+      # Returns the result of the stream operation
+      def write_uint8(value)
+        write [value].pack('C')
+      end
+
+      # Read a unsigned 16-bit integer
+      #
+      # Returns the result of the read
+      def read_uint16_be
+        read(2).unpack('n')[0]
+      end
+
+      # Write an unsigned 16-bit integer
+      #
+      # value - Value to write
+      #
+      # Returns the result of the stream operation
+      def write_uint16_be(value)
+        write [value].pack('n')
+      end
+
+      # Read a unsigned 24-bit integer
+      #
+      # Returns the result of the read
+      def read_uint24_be
+        ("\x00" + read(3)).unpack('N')[0]
+      end
+
+      # Write an unsigned 24-bit integer
+      #
+      # value - Value to write
+      #
+      # Returns the result of the stream operation
+      def write_uint24_be(value)
+        write [value].pack('N')[1,3]
+      end
+
+      # Read a unsigned 32-bit integer (big endian)
+      #
+      # Returns the result of the read
+      def read_uint32_be
+        read(4).unpack('N')[0]
+      end
+
+      # Read a unsigned 32-bit integer (little endian)
+      #
+      # Returns the result of the read
+      def read_uint32_le
+        read(4).unpack('V')[0]
+      end
+
+      # Write an unsigned 32-bit integer (big endian)
+      #
+      # value - Value to write
+      #
+      # Returns the result of the stream operation
+      def write_uint32_be(value)
+        write [value].pack('N')
+      end
+
+      # Write an unsigned 32-bit integer (big endian)
+      #
+      # value - Value to write
+      #
+      # Returns the result of the stream operation
+      def write_uint32_le(value)
+        write [value].pack('V')
+      end
+
+      # Read a double (big endian)
+      #
+      # Returns the result of the read
+      def read_double_be
+        read(8).unpack('G')[0]
+      end
+
+      # Write a double (big endian)
+      #
+      # value - Value to write
+      #
+      # Returns the result of the stream operation
+      def write_double_be(value)
+        write [value].pack('G')
+      end
+
+      # Read an int29
+      #
+      # Returns the result of the stream operation
+      def read_int29
+        count = 1
+        result = 0
+        byte = read_uint8
+
+        while (byte & 0x80 != 0) && count < 4 do
+          result <<= 7
+          result |= (byte & 0x7f)
+          byte = read_uint8
+          count += 1
+        end
+
+        if count < 4
+          result <<= 7
+          result |= byte
+        else
+          result <<= 8
+          result |= byte
+        end
+
+        result
+      end
+
+      # Write an int29
+      #
+      # value - Value to write
+      #
+      # Returns the result of the stream operation
+      def write_int29(value)
+        value = value & 0x1fffffff
+        if(value < 0x80)
+          result = [value].pack('c')
+          write result
+        elsif(value < 0x4000)
+          result = [value >> 7 & 0x7f | 0x80].pack('c') + [value & 0x7f].pack('c')
+          write result
+        elsif(value < 0x200000)
+          result = [value >> 14 & 0x7f | 0x80].pack('c') + [value >> 7 & 0x7f | 0x80].pack('c') + [value & 0x7f].pack('c')
+          write result
+        else
+          result = [value >> 22 & 0x7f | 0x80].pack('c') + [value >> 15 & 0x7f | 0x80].pack('c') + [value >> 8 & 0x7f | 0x80].pack('c') + [value & 0xff].pack('c')
+          write result
+        end
+      end
+
+      # Read a bit field and return the mapped results
+      #
+      # widths - Array of integers representing the size of the fields
+      #
+      # Returns the value for each field read
+      def read_bitfield(*widths)
+        byte = read_uint8
+        shifts_and_masks(widths).map{ |shift, mask|
+          (byte >> shift) & mask
+        }
+      end
+
+      # Write a bit field to the stream
+      #
+      # values_and_widths - An array of arrays, each containing two values:
+      #                       [0] - value to be written
+      #                       [1] - width of value
+      #
+      # Returns the value for each field read
+      def write_bitfield(*values_and_widths)
+        sm = shifts_and_masks(values_and_widths.map{ |_,w| w })
+        write_uint8 values_and_widths.zip(sm).inject(0){ |byte, ((value, width), (shift, mask))|
+          byte | ((value & mask) << shift)
+        }
+      end
+
+      private
+
+      # Obtain the shift and bitmasks for a set of widths
+      #
+      # Returns an array of arrays, each top-level array containing
+      # two values:
+      #   [0] - shift
+      #   [1] - mask
+      def shifts_and_masks(bit_widths)
+        (0 ... bit_widths.length).map{ |i| [
+          bit_widths[i+1 .. -1].inject(0){ |a,e| a + e },
+          0b1111_1111 >> (8 - bit_widths[i])
+        ]}
+      end
+
+    end
+  end
+end