rupnp 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,34 @@
+Copyright (C) 2013 Sylvain Daubert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+Search part of this library is derived from turboladen/upnp:
+Copyright (c) 2012 Steve Loveless
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the ‘Software’), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.

data/README.md

@@ -0,0 +1,45 @@
+RUPNP will be a Ruby UPNP framework.
+
+Its first purpose is to make my first eventmachine development.
+
+## Create a control point
+RUPNP will help you to create a UPnP control point (a client) :
+```ruby
+require 'rupnp'
+
+EM.run do
+  # Search for root devices
+  cp = RUPNP::ControlPoint(:root)
+  cp.start do |new_devices, disappeared_devices|
+    new_devices.subscribe do |device|
+      # Do what you want here with new devices
+      # Services are available through device.services
+    end
+    disappeared_devices.subscribe do |device|
+      # Do what you want here with devices which unsubscribe
+    end
+  end
+end
+```
+## Create a device
+TODO
+
+## `discover` utility
+`discover` is a command line utility to act as a control point:
+```
+$ discover
+discover> search ssdp:all
+1 devices found
+discover> devices[0].class
+=> RUPNP::CP::RemoteDevice
+discover>
+```
+
+The `search` command take an argument : the target for a UPnP M-SEARCH. This
+argument may be:
+* `ssdp:all`;
+* `upnp:rootdevice`;
+* a URN as `upnp:{URN}`.
+If no argument is given, default to `ssdp:all`.
+
+`discover` use `pry`. So, in `discover`, you can use the power of Pry.

data/Rakefile

@@ -0,0 +1,3 @@
+Dir.glob('tasks/*.rake').each do |file|
+  load file
+end

data/bin/discover

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'rupnp/discover'
+
+RUPNP::Discover.run

data/lib/rupnp/constants.rb

@@ -0,0 +1,31 @@
+require 'socket'
+
+module RUPNP
+
+  # Multicast IP for UPnP
+  MULTICAST_IP = '239.255.255.250'.freeze
+
+  # Default port for UPnP
+  DISCOVERY_PORT = 1900
+
+  # Default TTL for UPnP
+  DEFAULT_TTL = 2
+
+  # UPnP version
+  UPNP_VERSION = '1.1'.freeze
+
+  # User agent for UPnP messages
+  USER_AGENT = `uname -s`.chomp + "/#{`uname -r `.chomp.gsub(/-.*/, '')} " +
+    "UPnP/#{UPNP_VERSION} rupnp/#{VERSION}".freeze
+
+  # Host IP
+  HOST_IP = Socket.ip_address_list.
+    find_all { |ai| ai.ipv4? && !ai.ipv4_loopback? }.last.ip_address.freeze
+
+  # Default port for listening for events
+  EVENT_SUB_DEFAULT_PORT = 8080
+
+  # Default timeout for event subscription (in seconds)
+  EVENT_SUB_DEFAULT_TIMEOUT = 30 * 60
+
+end

data/lib/rupnp/control_point.rb

@@ -0,0 +1,173 @@
+module RUPNP
+
+  # This class is the base one for control points (clients in UPnP
+  # terminology).
+  #
+  # To create a control point :
+  #   EM.run do
+  #     cp = RUPNP::ControlPoint.new(:root)
+  #     cp.start do |new_devices, disappeared_devices|
+  #       new_devices.subscribe do |device|
+  #         puts "New device: #{device.udn}"
+  #       end
+  #     end
+  #   end
+  # @author Sylvain Daubert
+  class ControlPoint
+    include LogMixin
+    include Tools
+
+    # Default response wait time for searching devices. This is set
+    # to the maximum value from UPnP 1.1 specification.
+    DEFAULT_RESPONSE_WAIT_TIME = 5
+
+    # Get event listening port
+    # @return [Integer]
+    attr_reader :event_port
+    # Return channel to add event URL (URL to listen for a specific
+    # event)
+    # @return [EM::Channel]
+    attr_reader :add_event_url
+    # Return remote devices controlled by this control point
+    # @return [Array<CP::RemoteDevice>]
+    attr_reader :devices
+
+
+    # @param [Symbol,String] search_target target to search for.
+    #  May be +:all+, +:root+ or a device identifier
+    # @param [Hash] search_options
+    # @option search_options [Integer] :response_wait_time time to wait
+    #  for responses from devices
+    # @option search_options [Integer] :try_number number or search
+    #  requests to send (specification says that 2 is a minimum)
+    def initialize(search_target, search_options={})
+      @search_target = search_target
+      @search_options = search_options
+      @search_options[:response_wait_time] ||= DEFAULT_RESPONSE_WAIT_TIME
+
+      @devices = []
+      @new_device_channel = EM::Channel.new
+      @bye_device_channel = EM::Channel.new
+    end
+
+    # Start control point.
+    # This methos starts a search for devices. Then, listening is
+    # performed for device notifications.
+    # @yieldparam new_device_channel [EM::Channel]
+    #  channel on which new devices are announced
+    # @yieldparam bye_device_channel [EM::Channel]
+    #  channel on which +byebye+ device notifications are announced
+    # @return [void]
+    def start
+      search_devices_and_listen @search_target, @search_options
+      yield @new_device_channel, @bye_device_channel
+    end
+
+    def search_only
+      options = @search_options.dup
+      options[:search_only] = true
+      search_devices_and_listen @search_target, options
+    end
+
+    # Start event server for listening for device events
+    # @param [Integer] port port to listen for
+    # @return [void]
+    def start_event_server(port=EVENT_SUB_DEFAULT_PORT)
+      @event_port = port
+      @add_event_url = EM::Channel.new
+      @event_server ||= EM.start_server('0.0.0.0', port, CP::EventServer,
+                                        @add_event_url)
+    end
+
+    # Stop event server
+    # @see #start_event_server
+    # @return [void]
+    def stop_event_server
+      EM.stop_server @event_server
+    end
+
+    # Add a device to the control point
+    # @param [Device] device device to add
+    # @return [void]
+    def add_device(device)
+      if has_already_device?(device)
+       log :info, "Device already in database: #{device.udn}"
+        existing_device = self.find_device_by_udn(device.udn)
+        if existing_device.expiration < device.expiration
+          log :info, 'update expiration time for device #{device.udn}'
+          @devices.delete existing_device
+          @devices << device
+        end
+      else
+        log :info, "adding device #{device.udn}"
+        @devices << device
+        @new_device_channel << device
+      end
+    end
+
+
+    # Find a device from control point's device list by its UDN
+    # @param [String] udn
+    # @return [Device,nil]
+    def find_device_by_udn(udn)
+      @devices.find { |d| d.udn == udn }
+    end
+
+
+    private
+
+    def search_devices_and_listen(target, options)
+      log :info, 'search for devices'
+      searcher = SSDP.search(target, options)
+
+      EM.add_timer(@search_options[:response_wait_time] + 1) do
+        log :info, 'search timeout'
+        searcher.close_connection
+
+        unless options[:search_only]
+          log :info, 'now listening for device advertisement'
+          listener = SSDP.listen
+
+          listener.notifications.subscribe do |notification|
+            case notification['nts']
+            when 'ssdp:alive'
+              create_device notification
+            when 'ssdp:byebye'
+              udn = usn2udn(notification['usn'])
+              log :info, "byebye notification sent by device #{udn}"
+              rejected = @devices.reject! { |d| d.udn == udn }
+              log :info, "#{rejected.udn} device removed" if rejected
+            else
+              log :warn, "Unknown notification type: #{notification['nts']}"
+            end
+          end
+        end
+      end
+
+      searcher.discovery_responses.subscribe do |notification|
+        log :debug, 'receive a notification'
+        create_device notification
+      end
+    end
+
+    def create_device(notification)
+      device = CP::RemoteDevice.new(self, notification)
+
+      device.errback do |device, message|
+        log :warn, message
+      end
+
+      device.callback do |device|
+        add_device device
+      end
+
+      device.fetch
+    end
+
+    def has_already_device?(dev)
+      @devices.any? { |d| d.udn == dev.udn || d.usn == dev.usn }
+    end
+
+  end
+
+end

data/lib/rupnp/cp/base.rb

@@ -0,0 +1,67 @@
+require 'em-http-request'
+
+
+module RUPNP
+
+  # CP module to group all control point's classes
+  # @author Sylvain Daubert
+  module CP
+
+    # Base class for devices and services
+    # @author Sylvain Daubert
+    class Base
+      include EM::Deferrable
+      include Tools
+      include LogMixin
+
+      # Common HTTP headers for description requests
+      HTTP_COMMON_CONFIG = {
+        :head => {
+          :user_agent => USER_AGENT,
+          :host => "#{HOST_IP}:#{DISCOVERY_PORT}",
+        },
+      }
+
+      def initialize
+        @parser = Nori.new(:convert_tags_to => ->(tag){ tag.snakecase.to_sym })
+      end
+
+      # Get description from +location+
+      # @param [String] location
+      # @param [EM::Defferable] getter deferrable to advice about failure
+      #  or success. On fail, +getter+ receive a message. On success, it
+      #  receive a description (XML Nori hash)
+      # @return [void]
+      def get_description(location, getter)
+        log :info, "getting description for #{location}"
+        http = EM::HttpRequest.new(location).get(HTTP_COMMON_CONFIG)
+
+        http.errback do |error|
+          getter.set_deferred_status :failed, 'Cannot get description'
+        end
+
+        callback = Proc.new do
+          description = @parser.parse(http.response)
+          log :debug, 'Description received'
+          getter.succeed description
+        end
+
+        http.headers do |h|
+          unless h['SERVER'] =~ /UPnP\/1\.\d/
+            log :error, "Not a supported UPnP response : #{h['SERVER']}"
+            http.cancel_callback callback
+          end
+        end
+
+        http.callback &callback
+      end
+
+      # @return String
+      def inspect
+        "#<#{self.class}:#{object_id} type=#{type.inspect}>"
+      end
+
+    end
+
+  end
+end

data/lib/rupnp/cp/event_server.rb

@@ -0,0 +1,52 @@
+require 'em-http-server'
+
+module RUPNP
+
+  # Event server to receive events from services.
+  # @author Sylvain Daubert
+  class CP::EventServer < EM::HttpServer::Server
+    include LogMixin
+
+    # Channel to add url for listening to
+    # @return [EM::Channel]
+    attr_reader :add_url
+
+
+    # @param [EM::Channel] add_url_channel channel for adding url
+    def initialize(add_url_channel)
+      super
+
+      @urls = []
+      @add_url = add_url_channel
+
+      @add_url.subscribe do |url|
+        log :info, "add URL #{url} for eventing"
+        @urls << url
+      end
+    end
+
+    # Process a HTTP request received from a service/device
+    def process_http_request
+      log :debug, 'EventServer: receive request'
+      url, event = @urls.find { |a| a[0] == @http_request_uri }
+
+      if event.is_a? EM::Channel
+        if @http_request_method == 'NOTIFY'
+          if @http[:nt] == 'upnp:event' and @http[:nts] == 'upnp:propchange'
+            event << {
+              :sid => @http[:sid],
+              :seq => @http[:seq],
+              :content => @http_content }
+          else
+            log :warn, 'EventServer: ' +
+              "malformed NOTIFY event message:\n#@http_headers\n#@http_content"
+          end
+        else
+          log :warn, "EventServer: unknown HTTP verb: #@http_request_method"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/rupnp/cp/event_subscriber.rb

@@ -0,0 +1,49 @@
+module RUPNP
+
+  # Event subscriber to an event's service
+  # @author Sylvain Daubert
+  class CP::EventSubscriber < EM::Connection
+    include LogMixin
+
+    # Response from device
+    # @return [EM::Channel]
+    attr_reader :response
+
+
+    # @param [String] msg message to send for subscribing
+    def initialize(msg)
+      @msg = msg
+      @response = EM::Channel.new
+    end
+
+    # @return [void]
+    def post_init
+      log :debug, "send event subscribe request:\n#@msg"
+      send_data @msg
+    end
+
+    # Receive response from device and send it through {#response}
+    # @param [String] data
+    # @return [void]
+    def receive_data(data)
+      log :debug, "receive data from subscribe event action:\n#{data}"
+      resp = {}
+      io = StringIO.new(data)
+
+      status = io.readline
+      status =~ /HTTP\/1\.1 (\d+) (.+)/
+      resp[:status] = $2
+      resp[:status_code] = $1
+
+      io.each_line do |line|
+        if line =~ /(\w+):\s*(.*)/
+          resp[$1.downcase.to_sym] = $2.chomp
+        end
+      end
+
+      @response << resp
+    end
+
+  end
+
+end