rupnp 0.1.0

data/lib/rupnp/ssdp/http.rb

@@ -0,0 +1,45 @@
+module RUPNP
+  module SSDP
+
+    # HTTP module to provide some helper methods
+    # @author Sylvain Daubert
+    module SSDP::HTTP
+
+      # Return status from HTTP response
+      # @param [IO] sock
+      # @return [Booelan]
+      def is_http_status_ok?(sock)
+        sock.readline =~ /\s*HTTP\/1.1 200 OK\r\n\z/i
+      end
+
+      # Get HTTP headers from response
+      # @param [IO] sock
+      # @return [Hash] keys are downcase header name strings
+      def get_http_headers(sock)
+        headers = {}
+        sock.each_line do |l|
+          l =~ /([\w\.-]+):\s*(.*)/
+          if $1
+            headers[$1.downcase] = $2.strip
+          end
+        end
+        headers
+      end
+
+      # Get HTTP verb from HTTP request
+      # @param [IO] sock
+      # @return [nil,Hash] keys are +:verb+, +:path+, +:http_version+ and
+      #   +:cmd+ (all line)
+      def get_http_verb(sock)
+        str = sock.readline
+        if str =~ /([\w-]+)\s+(.*)\s+HTTP\/(\d\.\d)/
+          {:verb => $1, :path => $2, :http_version => $3, :cmd => str}
+        else
+          nil
+        end
+      end
+
+    end
+
+  end
+end

data/lib/rupnp/ssdp/listener.rb

@@ -0,0 +1,45 @@
+module RUPNP
+
+  # Listener class for listening for devices' notifications
+  # @author Sylvain Daubert
+  class SSDP::Listener < SSDP::MulticastConnection
+    include SSDP::HTTP
+
+    # Channel to receive notifications
+    # @return [EM::Channel]
+    attr_reader :notifications
+
+    # @param [Hash] options
+    # @option options [Integer] :ttl
+    def initialize(options={})
+      @notifications = EM::Channel.new
+
+      super options[:ttl]
+    end
+
+    # @private
+    def receive_data(data)
+      port, ip = peer_info
+      log :info, "Receive notification from #{ip}:#{port}"
+      log :debug, data
+
+      io = StringIO.new(data)
+      h = get_http_verb(io)
+
+      if h.nil?
+        log :warn, "No HTTP command"
+        return
+      elsif h[:verb] == 'M-SEARCH'
+        return
+      elsif !(h[:verb].upcase == 'NOTIFY' and h[:path] == '*' and
+              h[:http_version] == '1.1')
+        log :warn, "Unknown HTTP command: #{h[:cmd]}"
+        return
+      end
+
+      @notifications << get_http_headers(io)
+    end
+
+  end
+
+end

data/lib/rupnp/ssdp/msearch_responder.rb

@@ -0,0 +1,19 @@
+module RUPNP
+
+  # M-SEARCH responder for M-SEARCH multicast requests from control points.
+  # @author Sylvain Daubert
+  class SSDP::MSearchResponder < SSDP::MulticastConnection
+    include HTTP
+    include SSDP::SearchResponder
+
+    # @param [Hash] options
+    # @option options [Integer] :ttl
+    def initialize(device, options={})
+      @device = device
+      @options = options
+      super options[:ttl]
+    end
+
+  end
+
+end

data/lib/rupnp/ssdp/multicast_connection.rb

@@ -0,0 +1,48 @@
+require 'socket'
+require 'ipaddr'
+
+module RUPNP
+
+  # Base class for multicast connections (mainly SSDP search and listen)
+  # @abstract
+  class SSDP::MulticastConnection < EM::Connection
+    include LogMixin
+
+    # @param [Integer] ttl
+    def initialize(ttl=nil)
+      @ttl = ttl || DEFAULT_TTL
+      setup_multicast_socket
+    end
+
+    # Get peer info
+    # @return [Array] [port, hostname]
+    def peer_info
+      Socket.unpack_sockaddr_in(get_peername)
+    end
+
+
+    private
+
+    def setup_multicast_socket
+      set_membership IPAddr.new(MULTICAST_IP).hton + IPAddr.new('0.0.0.0').hton
+      set_ttl
+      set_reuse_addr
+    end
+
+    def set_membership(value)
+      set_sock_opt Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, value
+    end
+
+    def set_ttl
+      value = [@ttl].pack('i')
+      set_sock_opt Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, value
+      set_sock_opt Socket::IPPROTO_IP, Socket::IP_TTL, value
+    end
+
+    def set_reuse_addr
+      set_sock_opt Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true
+    end
+
+  end
+
+end

data/lib/rupnp/ssdp/notifier.rb

@@ -0,0 +1,93 @@
+
+module RUPNP
+
+  # Searcher class for searching devices
+  # @author Sylvain Daubert
+  class SSDP::Notifier < SSDP::MulticastConnection
+    include SSDP::HTTP
+
+    # Number of SEARCH datagrams to send
+    DEFAULT_NOTIFY_TRY = 2
+
+    # @param [Hash] options
+    # @option options [Integer] :try_number
+    # @option options [Integer] :ttl
+    # @option options [String] :ip
+    def initialize(type, subtype, options={})
+      @type = (type == :root) ? 'upnp:rootdevice' : type
+      @subtype = subtype
+      @notify_count = options[:try_number] || DEFAULT_NOTIFY_TRY
+      @options = options
+
+      super options.delete(:ttl)
+    end
+
+    # @private
+    def post_init
+      notify = notify_request
+      @notify_count.times do
+        send_datagram notify, MULTICAST_IP, DISCOVERY_PORT
+        log :debug, "#{self.class}: send datagram:\n#{notify}"
+      end
+      close_connection_after_writing
+    end
+
+    # @private
+    def receive_data(data)
+    end
+
+
+    private
+
+    def notify_request
+      usn = if @type[0..3] == 'uuid'
+              @type
+            else
+              "uuid:#{@options[:uuid]}::#@type"
+            end
+      case @subtype
+      when :alive
+      <<EOD
+NOTIFY * HTTP/1.1\r
+HOST: #{MULTICAST_IP}:#{DISCOVERY_PORT}\r
+CACHE-CONTROL: max-age = #{@options[:max_age]}\r
+LOCATION: http://#{@options[:ip]}:#{@options[:port]}/root_description.xml\r
+NT: #@type\r
+NTS: ssdp:#@subtype\r
+SERVER: #{USER_AGENT}\r
+USN: #{usn}\r
+BOOTID.UPNP.ORG: #{@options[:boot_id]}\r
+CONFIGID.UPNP.ORG: #{@options[:config_id]}\r
+SEARCHPORT.UPNP.ORG: #{@options[:u_search_port]}\r
+\r
+EOD
+      when :byebye
+      <<EOD
+NOTIFY * HTTP/1.1\r
+HOST: #{MULTICAST_IP}:#{DISCOVERY_PORT}\r
+NT: #@type\r
+NTS: ssdp:#@subtype\r
+USN: #{usn}\r
+BOOTID.UPNP.ORG: #{@options[:boot_id]}\r
+CONFIGID.UPNP.ORG: #{@options[:config_id]}\r
+\r
+EOD
+      when :update
+      <<EOD
+NOTIFY * HTTP/1.1\r
+HOST: #{MULTICAST_IP}:#{DISCOVERY_PORT}\r
+LOCATION: http://#{@options[:ip]}:#{@options[:port]}/root_description.xml\r
+NT: #@type\r
+NTS: ssdp:#@subtype\r
+USN: #{usn}\r
+BOOTID.UPNP.ORG: #{(@options[:boot_id] - 1) % 2**31}\r
+CONFIGID.UPNP.ORG: #{@options[:config_id]}\r
+NEXTBOOTID.UPNP.ORG: #{@options[:boot_id]}\r
+SEARCHPORT.UPNP.ORG: #{@options[:u_search_port]}\r
+\r
+EOD
+      end
+    end
+
+  end
+end

data/lib/rupnp/ssdp/search_responder.rb

@@ -0,0 +1,115 @@
+module RUPNP
+
+  # M-SEARCH responder for M-SEARCH multicast requests from control points.
+  # @author Sylvain Daubert
+  module SSDP::SearchResponder
+    include SSDP::HTTP
+
+    def receive_data(data)
+      port, ip = peer_info
+      log :debug,  "#{self.class}: Receive data from #{ip}:#{port}"
+      log :debug, data
+
+      io = StringIO.new(data)
+      h = get_http_verb(io)
+
+      if h[:verb].upcase == 'NOTIFY'
+        return
+      end
+
+      if h.nil? or !(h[:verb].upcase == 'M-SEARCH' and h[:path] == '*' and
+                       h[:http_version] == '1.1')
+        log :warn, "#{self.class}: Unknown HTTP command: #{h[:cmd]}"
+        return
+      end
+
+      h = get_http_headers(io)
+      if h['man'] != '"ssdp:discover"'
+        log :warn, "#{self.class}: Unknown MAN field: #{h['man']}"
+        return
+      end
+
+      log :info, "#{self.class}: Receive M-SEARCH request from #{ip}:#{port}"
+
+      callback = nil
+      case h['st']
+      when 'ssdp:all'
+        callback = Proc.new do
+          send_response 'upnp:rootdevice'
+          send_response "uuid:#{@device.uuid}"
+          send_response "urn:#{@device.urn}"
+          @device.services.each do |s|
+            send_response "urn:#{s.urn}"
+          end
+        end
+      when 'upnp:rootdevice'
+        callback = Proc.new { send_response 'upnp:rootdevice' }
+      when /^uuid:([0-9a-fA-F-]+)/
+         if $1 and $1 == @device.uuid
+           callback = Proc.new { send_response "uuid:#{@device.uuid}" }
+         end
+      when /^urn:schemas-upnp-org:(\w+):(\w+):(\w+)/
+        case $1
+        when 'device'
+          if urn_are_equivalent?(h['st'], @device.urn)
+            callback = Proc.new { send_response "urn:#{@device.urn}" }
+          end
+        when 'service'
+          if @device.services.one? { |s| urn_are_equivalent? h['st'], s.urn }
+            callback = Proc.new { send_response h['st'] }
+          end
+        end
+      end
+
+      if callback
+        if self.is_a? SSDP::MulticastConnection
+          if h['mx']
+            mx = h['mx'].to_i
+            # MX MUST not be greater than 5
+            mx = 5 if mx > 5
+            # Wait for a random time less than MX
+            wait_time = rand(mx)
+            EM.add_timer wait_time, &callback
+          else
+            log :warn, "#{self.class}: Multicast M-SEARCH request with no MX" +
+              " field. Discarded."
+          end
+        else
+          # Unicast request. Don't bother for MX field.
+          callback.call
+        end
+      else
+        log :debug, 'No response sent'
+      end
+    end
+
+
+    def send_response(st)
+      usn = "uuid:#{@device.uuid}"
+      usn += case st
+             when 'upnp:rootdevice', /^urn/
+               "::#{st}"
+             else
+               ''
+             end
+      response =<<EOR
+HTTP/1.1 200 OK\r
+CACHE-CONTROL: max-age = #{@options[:max_age]}\r
+DATE: #{Time.now.httpdate}\r
+EXT:\r
+LOCATION:  http://#{@options[:ip]}/root_description.xml\r
+SERVER: #{USER_AGENT}\r
+ST: #{st}
+USN: #{usn}\r
+BOOTID.UPNP.ORG: #{@options[:boot_id]}\r
+CONFIGID.UPNP.ORG: #{@options[:config_id]}\r
+SEARCHPORT.UPNP.ORG: #{@options[:u_search_port]}\r
+\r
+EOR
+
+      send_data response
+    end
+
+  end
+
+end

data/lib/rupnp/ssdp/searcher.rb

@@ -0,0 +1,69 @@
+
+module RUPNP
+
+  # Searcher class for searching devices
+  # @author Sylvain Daubert
+  class SSDP::Searcher < SSDP::MulticastConnection
+    include SSDP::HTTP
+
+    # Number of SEARCH datagrams to send
+    DEFAULT_M_SEARCH_TRY = 2
+
+    # Channel to receive discovery responses
+    # @return [EM::Channel]
+    attr_reader :discovery_responses
+
+
+    # @param [Hash] options
+    # @option options [String] :search_target
+    # @option options [Integer] :response_wait_time
+    # @option options [Integer] :try_number
+    # @option options [Integer] :ttl
+    def initialize(options={})
+      @options = options
+      @options[:try_number] ||= DEFAULT_M_SEARCH_TRY
+      @discovery_responses = EM::Channel.new
+
+      super options[:ttl]
+    end
+
+    # @private
+    def post_init
+      search = search_request
+      @options[:try_number].times do
+        send_datagram search, MULTICAST_IP, DISCOVERY_PORT
+        log :debug, "send datagram:\n#{search}"
+      end
+    end
+
+    # @private
+    def receive_data(data)
+      port, ip = peer_info
+      log :debug, "Response from #{ip}:#{port}"
+
+      response = StringIO.new(data)
+      if !is_http_status_ok?(response)
+        log :error, "bad HTTP response:\n #{data}"
+        return
+      end
+
+      @discovery_responses << get_http_headers(response)
+    end
+
+
+    private
+
+    def search_request
+      <<EOR
+M-SEARCH * HTTP/1.1\r
+HOST: #{MULTICAST_IP}:#{DISCOVERY_PORT}\r
+MAN: "ssdp:discover"\r
+MX: #{@options[:response_wait_time]}\r
+ST: #{@options[:search_target]}\r
+USER-AGENT: #{USER_AGENT}\r
+\r
+EOR
+    end
+
+  end
+end

data/lib/rupnp/ssdp/usearch_responder.rb

@@ -0,0 +1,29 @@
+require 'socket'
+
+module RUPNP
+
+  # M-SEARCH responder for M-SEARCH unicast requests from control points.
+  # @author Sylvain Daubert
+  class SSDP::USearchResponder < EM::Connection
+    include HTTP
+    include SSDP::SearchResponder
+
+    # @param [Hash] options
+    # @option options [Integer] :ttl
+    def initialize(device, options={})
+      @device = device
+      @options = options
+      set_ttl options[:ttl] || DEFAULT_TTL
+    end
+
+
+    private
+
+    def set_ttl(ttl)
+      value = [ttl].pack('i')
+      set_sock_opt Socket::IPPROTO_IP, Socket::IP_TTL, value
+    end
+
+  end
+
+end

data/lib/rupnp/ssdp.rb

@@ -0,0 +1,47 @@
+require_relative 'ssdp/http'
+require_relative 'ssdp/multicast_connection'
+require_relative 'ssdp/searcher'
+require_relative 'ssdp/listener'
+require_relative 'ssdp/notifier'
+require_relative 'ssdp/search_responder.rb'
+require_relative 'ssdp/msearch_responder.rb'
+require_relative 'ssdp/usearch_responder.rb'
+
+
+module RUPNP
+
+  # SSDP module. This a discovery part of UPnP.
+  # @author Sylvain Daubert
+  module SSDP
+
+    # Some shorcut for common targets
+    KNOWN_TARGETS = {
+      :all  => 'ssdp:all',
+      :root => 'upnp:rootdevice'
+    }
+
+
+    # Search devices
+    # @param [Symbol,String] target
+    # @param [Hash] options see {SSDP::Searcher#initialize}
+    def self.search(target=:all, options={})
+      options[:search_target] =  KNOWN_TARGETS[target] || target
+      EM.open_datagram_socket '0.0.0.0', 0, SSDP::Searcher, options
+    end
+
+    # Listen for devices' announces
+    # @param [Hash] options see {SSDP::Listener#initialize}
+    def self.listen(options={})
+      EM.open_datagram_socket(MULTICAST_IP, DISCOVERY_PORT,
+                              SSDP::Listener, options)
+    end
+
+    # Notify announces
+    # @param [Hash] options see {SSDP::Notifier#initialize}
+    def self.notify(type, stype, options={})
+      EM.open_datagram_socket(MULTICAST_IP, DISCOVERY_PORT,
+                              SSDP::Notifier, type, stype, options)
+    end
+  end
+
+end

data/lib/rupnp/tools.rb

@@ -0,0 +1,66 @@
+module RUPNP
+
+  # Helper module
+  # @author Sylvain Daubert
+  module Tools
+
+    # Build an url from a base and a relative url
+    # @param [String] base
+    # @param [String] rest
+    # @return [String]
+    def build_url(base, rest)
+      url = base + (base.end_with?('/') ? '' : '/')
+      url + (rest.start_with?('/') ? rest[1..-1] : rest)
+    end
+
+    # Convert a camel cased string to a snake cased one
+    #   snake_case("iconList")     # => "icon_list"
+    #   snake_case("eventSubURL")  # => "event_sub_url"
+    # @param [String] str
+    # @return [String]
+    def snake_case(str)
+      g = str.gsub(/([^A-Z_])([A-Z])/,'\1_\2')
+      g.downcase || str.downcase
+    end
+
+    # Check if two URN are equivalent. They are equivalent if they have
+    # the same name and the same major version.
+    # @param [String] urn1
+    # @param [String] urn2
+    # @return [Boolean]
+    def urn_are_equivalent?(urn1, urn2)
+      u1 = urn1
+      if urn1[0..3] == 'urn:'
+        u1 = urn1[4..-1]
+      end
+      u2 = urn2
+      if urn2[0..3] == 'urn:'
+        u2 = urn2[4..-1]
+      end
+
+      m1 = u1.match(/(\w+):(\w+):(\w+):([\d-]+)/)
+      m2 = u2.match(/(\w+):(\w+):(\w+):([\d-]+)/)
+      if m1[1] == m2[1]
+        if m1[2] == m2[2]
+          if m1[3] == m2[3]
+            v1_major = m1[4].split(/-/).first
+            v2_major = m2[4].split(/-/).first
+            if v1_major == v2_major
+              return true
+            end
+          end
+        end
+      end
+      false
+    end
+
+    # Retrieve UDN from USN
+    # @param [String] usn
+    # @return [String]
+    def usn2udn(usn)
+      rex = '([A-Fa-f0-9]{8,8}(-[A-Fa-f0-9]{4,4}){3,3}-[A-Fa-f0-9]{12,12})'
+      usn.match(/#{rex}/)[1]
+    end
+  end
+
+end

data/lib/rupnp.rb

@@ -0,0 +1,62 @@
+require 'awesome_print'
+require 'eventmachine-le'
+
+# Module for RUPNP namespace
+# @author Sylvain Daubert
+module RUPNP
+
+  # RUPNP version
+  VERSION = '0.1.0'
+
+  @logdev = STDERR
+  @log_level = :info
+
+  # Set log device
+  # @param [IO,String] io_or_string io or filename to log to
+  # @return [IO]
+  def self.logdev=(io_or_string)
+    if io_or_string.is_a? String
+      @logdev = File.open(io_or_string, 'w')
+    else
+      @logdev = io_or_string
+    end
+  end
+
+  # Get log device
+  # @return [IO] io used to log
+  def self.logdev
+    @logdev
+  end
+
+  # Set log level
+  # @param [:debug,:info,:warn,:error] lvl
+  def self.log_level=(lvl)
+    @log_level = lvl
+  end
+
+  # Get log level
+  # @return [Symbol]
+  def self.log_level
+    @log_level
+  end
+
+
+  # Base class for RUPNP errors.
+  class Error < StandardError; end
+
+end
+
+
+require_relative 'rupnp/constants'
+require_relative 'rupnp/tools'
+require_relative 'rupnp/log_mixin'
+require_relative 'rupnp/event'
+require_relative 'rupnp/control_point'
+require_relative 'rupnp/cp/base'
+require_relative 'rupnp/cp/remote_service'
+require_relative 'rupnp/cp/remote_device'
+require_relative 'rupnp/cp/event_server'
+require_relative 'rupnp/cp/event_subscriber'
+require_relative 'rupnp/ssdp'
+
+#require_relative 'rupnp/device'