rtsp_server 0.0.1

data/lib/rtsp/common.rb

@@ -0,0 +1,148 @@
+module RTSP
+
+  # Contains common methods belonging to Request and Response classes.
+  module Common
+
+    # @return [String] The unparsed request as a String.
+    def to_s
+      @raw_body
+    end
+
+    # Custom redefine to make sure all the dynamically created instance
+    # variables are displayed when this method is called.
+    #
+    # @return [String]
+    def inspect
+      me = "#<#{self.class.name}:#{self.__id__} "
+
+      self.instance_variables.each do |variable|
+        me << "#{variable}=#{instance_variable_get(variable).inspect}, "
+      end
+
+      me.sub!(/, $/, "")
+      me << ">"
+
+      me
+    end
+
+    # Takes the raw request text and splits it into a 2-element Array, where 0
+    # is the text containing the headers and 1 is the text containing the body.
+    #
+    # @param [String] raw_request
+    # @return [Array<String>] 2-element Array containing the head and body of
+    #   the request.  Body will be nil if there wasn't one in the request.
+    def split_head_and_body_from raw_request
+      head_and_body = raw_request.split("\r\n\r\n", 2)
+      head = head_and_body.first
+      body = head_and_body.last == head ? nil : head_and_body.last
+
+      [head, body]
+    end
+
+    # Pulls out the RTSP version, request code, and request message (AKA the
+    # status line info) into instance variables.
+    #
+    # @param [String] line The String containing the status line info.
+    def extract_status_line(line)
+      /RTSP\/(?<rtsp_version>\d\.\d)/ =~ line
+      /(?<url>rtsp:\/\/.*) RTSP/ =~ line
+      /rtsp:\/\/.*stream(?<stream_index>\d*)m?\/?.* RTSP/ =~ line
+      @url = url
+      @stream_index = stream_index.to_i
+
+      if rtsp_version.nil?
+        raise RTSP::Error, "Status line corrupted: #{line}"
+      end
+    end
+
+    # Returns the transport URL.
+    #
+    # @return [String] Transport URL associated with the request.
+    def transport_url
+      /client_port=(?<port>.*)-/ =~ transport
+
+      if port.nil?
+        log("Could not find client port associated with transport", :warn)
+      else
+        "#{@remote_host}:#{port}"
+      end
+    end
+
+    # Checks if the request is for a multicast stream.
+    #
+    # @return [Boolean] true if the request is for a multicast stream.
+    def multicast?
+      return false if @url.nil?
+
+      @url.end_with? "m"
+    end
+
+    # Reads through each header line of the RTSP request, extracts the
+    # request code, request message, request version, and creates a
+    # snake-case accessor with that value set.
+    #
+    # @param [String] head The section of headers from the request text.
+    def parse_head head
+      lines = head.split "\r\n"
+
+      lines.each_with_index do |line, i|
+        if i == 0
+          extract_status_line(line)
+          next
+        end
+
+        if line.include? "Session: "
+          value = {}
+          line =~ /Session: (\d+)/
+          value[:session_id] = $1.to_i
+
+          if line =~ /timeout=(.+)/
+            value[:timeout] = $1.to_i
+          end
+
+          create_reader("session", value)
+        elsif line.include? ": "
+          header_and_value = line.strip.split(":", 2)
+          header_name = header_and_value.first.downcase.gsub(/-/, "_")
+          create_reader(header_name, header_and_value[1].strip)
+        end
+      end
+    end
+
+    # Reads through each line of the RTSP response body and parses it if
+    # needed.  Returns a SDP::Description if the Content-Type is
+    # 'application/sdp', otherwise returns the String that was passed in.
+    #
+    # @param [String] body
+    # @return [SDP::Description,String]
+    def parse_body body
+      if body =~ /^(\r\n|\n)/
+        body.gsub!(/^(\r\n|\n)/, '')
+      end
+
+      if @content_type == "application/sdp"
+        SDP.parse body
+      else
+        body
+      end
+    end
+
+    private
+
+    # Creates an attr_reader with the name given and sets it to the value
+    # that's given.
+    #
+    # @param [String] name
+    # @param [String,Hash] value
+    def create_reader(name, value)
+      unless value.empty?
+        if value.is_a? String
+          value = value =~ /^[0-9]*$/ ? value.to_i : value
+        end
+      end
+
+      instance_variable_set("@#{name}", value)
+      self.instance_eval "def #{name}; @#{name}; end"
+    end
+  end
+end

data/lib/rtsp/error.rb

@@ -0,0 +1,6 @@
+module RTSP
+
+  # Custom error for RTSP problems.
+  class Error < StandardError
+  end
+end

data/lib/rtsp/global.rb

@@ -0,0 +1,63 @@
+require_relative '../ext/logger'
+
+module RTSP
+  module Global
+    DEFAULT_RTSP_PORT = 554
+    DEFAULT_VERSION = '1.0'
+
+    # Sets whether to log RTSP requests & responses.
+    attr_writer :log
+
+    # @return [Boolean] true if logging is enabled; false if it's turned off.
+    def log?
+      @log != false
+    end
+
+    # Sets the type logger to use.
+    attr_writer :logger
+
+    # By default, this creates a standard Ruby Logger.  If a different type was
+    # passed in via +#logger=+, this returns that object.
+    #
+    # @return [Logger]
+    def logger
+      @logger ||= ::Logger.new STDOUT
+    end
+
+    # @return [Symbol] The Logger method to use for logging all messages.
+    attr_writer :log_level
+
+    # The Logger method to use for logging all messages.
+    #
+    # @return [Symbol] Defaults to +:debug+.
+    def log_level
+      @log_level ||= :debug
+    end
+
+    # @param [String] message The string to log.
+    def log(message, level=log_level)
+      logger.send(level, message) if log?
+    end
+
+    # Use to disable the raising of +RTSP::Error+s.
+    attr_writer :raise_errors
+
+    # @return [Boolean] true if set to raise errors; false if not.
+    def raise_errors?
+      @raise_errors != false
+    end
+
+    # @return [String] The RTSP version.
+    def rtsp_version
+      @version ||= DEFAULT_VERSION
+    end
+
+    # Resets class variables back to defaults.
+    def reset_config!
+      self.log = true
+      self.logger = ::Logger.new STDOUT
+      self.log_level = :debug
+      self.raise_errors = true
+    end
+  end
+end

data/lib/rtsp/helpers.rb

@@ -0,0 +1,28 @@
+require 'uri'
+require_relative 'global'
+require_relative 'error'
+
+module RTSP
+  module Helpers
+    include RTSP::Global
+
+    # Takes the URL given and turns it into a URI.  This allows for enforcing
+    # values for each part of the URI.
+    #
+    # @param [String] url The URL to turn in to a URI.
+    # @return [URI]
+    def build_resource_uri_from url
+      if url.is_a? String
+        url = "rtsp://#{url}" unless url =~ /^rtsp/
+
+        resource_uri = URI.parse url
+        resource_uri.port ||= DEFAULT_RTSP_PORT
+
+        resource_uri
+
+      else
+        raise RTSP::Error, "url must be a String."
+      end
+    end
+  end
+end

data/lib/rtsp/message.rb

@@ -0,0 +1,272 @@
+require_relative 'helpers'
+require_relative 'error'
+require_relative 'version'
+
+module RTSP
+
+  # This class is responsible for building a single RTSP message that can be
+  # used by both clients and servers.
+  #
+  # Only message types defined in {RFC 2326}[http://tools.ietf.org/html/rfc2326]
+  # are implemented, however if you need to add a new message type (perhaps for
+  # some custom server implementation?), you can simply add to the supported
+  # list by:
+  #    RTSP::Message.message_types << :barrel_roll
+  #
+  # You can then build it like a standard message:
+  #   message = RTSP::Message.barrel_roll("192.168.1.10").with_headers({
+  #   cseq: 123, content_type: "video/x-m4v" })
+  class Message
+    include RTSP::Helpers
+
+    RTSP_ACCEPT_TYPE = "application/sdp"
+    RTSP_DEFAULT_NPT             = "0.000-"
+    RTSP_DEFAULT_SEQUENCE_NUMBER = 1
+    USER_AGENT                   =
+        "RubyRTSP/#{RTSP::VERSION} (Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL})"
+
+    @message_types = [
+      :announce,
+      :describe,
+      :get_parameter,
+      :options,
+      :play,
+      :pause,
+      :record,
+      :redirect,
+      :set_parameter,
+      :setup,
+      :teardown
+    ]
+
+    # TODO: define #describe somewhere so I can actually test that method.
+    class << self
+
+      # Lists the method/message types this class can create.
+      # @return [Array<Symbol>]
+      attr_accessor :message_types
+
+      # Make sure the class responds to our message types.
+      #
+      # @param [Symbol] method
+      def respond_to?(method)
+        @message_types.include?(method) || super
+      end
+
+      # Creates a new message based on the given method type and URI.
+      #
+      # @param [Symbol] method
+      # @param [Array] args
+      # @return [RTSP::Message]
+      def method_missing(method, *args)
+        request_uri = args.first
+
+        if @message_types.include? method
+          self.new(method, request_uri)
+        else
+          super
+        end
+      end
+    end
+
+    attr_reader :method_type
+    attr_reader :request_uri
+    attr_reader :headers
+    attr_reader :body
+    attr_writer :rtsp_version
+
+    # @param [Symbol] :method_type The RTSP method to build and send.
+    # @param [String] request_uri The URL to communicate to.
+    def initialize(method_type, request_uri)
+      @method_type = method_type
+      @request_uri = build_resource_uri_from request_uri
+      @headers     = default_headers
+      @body        = ""
+      @version     = DEFAULT_VERSION
+    end
+
+    # Adds the header and its value to the list of headers for the message.
+    #
+    # @param [Symbol] type The header type.
+    # @param [] value The value to set the header field to.
+    def header(type, value)
+      if type.is_a? Symbol
+        headers[type] = value
+      else
+        raise RTSP::Error, "Header type must be a Symbol (i.e. :cseq)."
+      end
+    end
+
+    # Use to message-chain with one of the method types; used when creating a
+    # new Message to add headers you want.
+    #
+    # @example Simple header
+    #   RTSP::Message.options("192.168.1.10").with_headers({ cseq: @cseq })
+    # @example Multi-word header
+    #   RTSP::Message.options("192.168.1.10").with_headers({ user_agent:
+    #   'My RTSP Client 1.0' })   # => "OPTIONS 192.168.1.10 RTSP 1.0\r\n
+    #                             #     CSeq: 1\r\n
+    #                             #     User-Agent: My RTSP Client 1.0\r\n"
+    # @param [Hash] new_headers The headers to add to the Request.  The Hash
+    #   key of each will be converted from snake_case to Rtsp-Style.
+    # @return [RTSP::Message]
+    def with_headers(new_headers)
+      add_headers new_headers
+
+      self
+    end
+
+    def add_headers(new_headers)
+      @headers.merge! new_headers
+    end
+
+    # Use when creating a new Message to add body you want.
+    #
+    # @example Simple header
+    #   RTSP::Message.options("192.168.1.10").with_body("The body!")
+    # @param [Hash] new_headers The headers to add to the Request.  The Hash
+    #   key will be capitalized; if
+    def with_body(new_body)
+      add_body new_body
+
+      self
+    end
+
+    def add_body new_body
+      add_headers({ content_length: new_body.length })
+      @body = new_body
+    end
+
+    # @param [String] value Content to send as the body of the message.
+    #   Generally this will be a String of some sort, but could be binary data as
+    #   well. Also, this adds the Content-Length header to the header list.
+    def body= value
+      add_body value
+    end
+
+    # @return [String] The message as a String.
+    def to_s
+      message.to_s
+    end
+
+    ###########################################################################
+    # PRIVATES
+    private
+
+    # Builds the request message to send to the server/client.
+    #
+    # @return [String]
+    def message
+      message = "#{@method_type.to_s.upcase} #{@request_uri} RTSP/#{@version}\r\n"
+      message << headers_to_s(@headers)
+      message << "\r\n"
+      message << "#{@body}" unless @body.nil?
+
+      #message.each_line { |line| RTSP::Client.log line.strip }
+
+      message
+    end
+
+    # Returns the required/default headers for the provided method.
+    #
+    # @return [Hash] The default headers for the given method.
+    def default_headers
+      headers = {}
+
+      headers[:cseq] ||= RTSP_DEFAULT_SEQUENCE_NUMBER
+      headers[:user_agent] ||= USER_AGENT
+
+      case @method_type
+      when :describe
+        headers[:accept] = RTSP_ACCEPT_TYPE
+      when :announce
+        headers[:content_type] = RTSP_ACCEPT_TYPE
+      when :play
+        headers[:range] = "npt=#{RTSP_DEFAULT_NPT}"
+      when :get_parameter
+        headers[:content_type] = 'text/parameters'
+      when :set_parameter
+        headers[:content_type] = 'text/parameters'
+      else
+        {}
+      end
+
+      headers
+    end
+
+    # Turns headers from Hash(es) into a String, where each element
+    # is a String in the form: [Header Type]: value(s)\r\n.
+    #
+    # @param [Hash] headers The headers to put to string.
+    # @return [String]
+    def headers_to_s headers
+      header_string = headers.inject("") do |result, (key, value)|
+        header_name = key.to_s.split(/_/).map do |header|
+          header.capitalize
+        end.join('-')
+
+        header_name = "CSeq" if header_name == "Cseq"
+
+        if value.is_a?(Hash) || value.is_a?(Array)
+          if header_name == "Content-Type"
+            values = values_to_s(value, ", ")
+          else
+            values = values_to_s(value)
+          end
+
+          result << "#{header_name}: #{values}\r\n"
+        else
+          result << "#{header_name}: #{value}\r\n"
+        end
+
+        result
+      end
+
+      arr = header_string.split "\r\n"
+      # Move the Session header to the top
+      session_index = arr.index { |a| a =~ /Session/ }
+      unless session_index.nil?
+        session = arr.delete_at(session_index)
+        arr.unshift(session)
+      end
+
+      # Move the User-Agent header to the top
+      user_agent_index = arr.index { |a| a =~ /User-Agent/ }
+      unless user_agent_index.nil?
+        user_agent = arr.delete_at(user_agent_index)
+        arr.unshift(user_agent)
+      end
+
+      # Move the CSeq header to the top
+      cseq_index = arr.index { |a| a =~ /CSeq/ }
+      cseq = arr.delete_at(cseq_index)
+      arr.unshift(cseq)
+
+      # Put it all back to a String
+      header_string = arr.join("\r\n")
+      header_string << "\r\n"
+    end
+
+    # Turns header values into a single string.
+    #
+    # @param [] values The header values to put to string.
+    # @param [String] separator The character to use to separate multiple
+    #   values that define a header.
+    # @return [String] The header values as a single string.
+    def values_to_s(values, separator=";")
+      result = values.inject("") do |values_string, (header_field, header_field_value)|
+        if header_field.is_a? Symbol
+          values_string << "#{header_field}=#{header_field_value}"
+        elsif header_field.is_a? Hash
+          values_string << values_to_s(header_field)
+        else
+          values_string << header_field.to_s
+        end
+
+        values_string + separator
+      end
+
+      result.sub!(/#{separator}$/, '') if result.end_with? separator
+    end
+  end
+end

data/lib/rtsp/request.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'sdp'
+require_relative 'error'
+require_relative 'global'
+require_relative 'common'
+
+module RTSP
+
+  # Parses raw request data from the server/client and turns it into
+  # attr_readers.
+  class Request
+    extend RTSP::Global
+    include RTSP::Common
+
+    attr_reader :rtsp_version
+    attr_reader :code
+    attr_reader :message
+    attr_reader :body
+    attr_reader :url
+    attr_reader :stream_index
+    attr_accessor :remote_host
+
+    # @param [String] raw_request The raw request string returned from the
+    # server/client.
+    # @param [String] remote_host The IP address of the remote host.
+    def initialize(raw_request, remote_host)
+      if raw_request.nil? || raw_request.empty?
+        raise RTSP::Error,
+          "#{self.class} received nil or empty string--this shouldn't happen."
+      end
+
+      @raw_body = raw_request
+      @remote_host = remote_host
+
+      head, body = split_head_and_body_from @raw_body
+      parse_head(head)
+    end
+  end
+end

data/lib/rtsp/response.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'sdp'
+require_relative 'error'
+require_relative 'common'
+
+module RTSP
+
+  # Parses raw response data from the server/client and turns it into
+  # attr_readers.
+  class Response
+    include RTSP::Common
+    attr_reader :rtsp_version
+    attr_reader :code
+    attr_reader :message
+    attr_reader :body
+
+    # @param [String] raw_response The raw response string returned from the
+    # server/client.
+    def initialize(raw_response)
+      if raw_response.nil? || raw_response.empty?
+        raise RTSP::Error,
+          "#{self.class} received nil string--this shouldn't happen."
+      end
+
+      @raw_body = raw_response
+
+      head, body = split_head_and_body_from @raw_body
+      parse_head(head)
+      @body = parse_body(body)
+    end
+
+    # Pulls out the RTSP version, response code, and response message (AKA the
+    # status line info) into instance variables.
+    #
+    # @param [String] line The String containing the status line info.
+    def extract_status_line(line)
+      line =~ /RTSP\/(\d\.\d) (\d\d\d) ([^\r\n]+)/
+      @rtsp_version = $1
+      @code         = $2.to_i
+      @message      = $3
+
+      if @rtsp_version.nil?
+        raise RTSP::Error, "Status line corrupted: #{line}"
+      end
+    end
+  end
+end