ssdp 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a650ded600f6688ce2d53aa7185b275d39b279f3
+  data.tar.gz: 65f3d49aa1aae08d792d61424c7891e4ffc4c35d
+SHA512:
+  metadata.gz: 428f3aa8fb465cd6407f9ef31723187ea2fe7810bb96da72a807dd8fe18c04e1e9be656e74567a27520b5dffc4f1c5f01448f18673e3ab6656a0017babd83964
+  data.tar.gz: 61af0480b1a12ac1230c7452d3a6d5271748686adf9aa8c11c6852eb8aa2508f8b1f3297442d9b0dc3f10bdb593218df0971791716f3514c1851ff8e89c555d5

data/LICENSE

@@ -0,0 +1,12 @@
+Copyright © 2015, Dillon Aumiller
+All rights reserved.
+
+BSD 2-Clause License
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/ssdp.rb

@@ -0,0 +1,64 @@
+require 'socket'
+require 'ipaddr'
+require_relative 'ssdp/producer'
+require_relative 'ssdp/consumer'
+
+module SSDP
+  DEFAULTS = {
+    # Shared
+    :broadcast   => '239.255.255.250',
+    :bind        => '0.0.0.0',
+    :port        => 1900,
+    :maxpack     => 65_507,
+    # Producer-Only
+    :interval    => 30,
+    :notifier    => true,
+    # Consumer-Only
+    :timeout     => 30,
+    :first_only  => false,
+    :synchronous => true,
+    :no_warnings => false
+  }
+
+  HEADER_MATCH = /^([^:]+):\s*(.+)$/
+
+  def parse_ssdp(message)
+    message.gsub! "\r\n", "\n"
+    header, body = message.split "\n\n"
+
+    header = header.split "\n"
+    status = header.shift
+    params = {}
+    header.each do |line|
+      match = HEADER_MATCH.match line
+      next if match.nil?
+      value = match[2]
+      value = (value[1, value.length - 2] || '') if value.start_with?('"') && value.end_with?('"')
+      params[match[1]] = value
+    end
+
+    { :status => status, :params => params, :body => body }
+  end
+  module_function :parse_ssdp
+
+  def create_listener(options)
+    listener = UDPSocket.new
+    listener.do_not_reverse_lookup = true
+    membership = IPAddr.new(options[:broadcast]).hton + IPAddr.new(options[:bind]).hton
+    listener.setsockopt Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, membership
+    listener.setsockopt Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true
+    listener.setsockopt Socket::SOL_SOCKET, Socket::SO_REUSEPORT, true
+    listener.bind options[:bind], options[:port]
+    listener
+  end
+  module_function :create_listener
+
+  def create_broadcaster
+    broadcaster = UDPSocket.new
+    broadcaster.setsockopt Socket::SOL_SOCKET, Socket::SO_BROADCAST, true
+    broadcaster.setsockopt :IPPROTO_IP, :IP_MULTICAST_TTL, 1
+    broadcaster
+  end
+  module_function :create_broadcaster
+
+end

data/lib/ssdp/consumer.rb

@@ -0,0 +1,144 @@
+require 'socket'
+require 'ssdp'
+
+module SSDP
+  class Consumer
+    def initialize(options = {})
+      @options = SSDP::DEFAULTS.merge options
+      @search_socket = SSDP.create_broadcaster
+      @watch = {
+        :socket   => nil,
+        :thread   => nil,
+        :services => {}
+      }
+    end
+
+    def search(options, &block)
+      options = @options.merge options
+      options[:callback] ||= block unless block.nil?
+      fail "SSDP consumer async search missing callback." if (options[:synchronous] == false) && options[:callback].nil?
+      fail "SSDP consumer search accepting multiple responses must specify a timeout value." if (options[:first_only] == false) && (options[:timeout].to_i < 1)
+      warn "Warning: Calling SSDP search without a service specified." if options[:service].nil? && (options[:no_warnings] != true)
+      warn "Warning: Calling SSDP search without a timeout value." if (options[:timeout].to_i < 1) && (options[:no_warnings] != true)
+
+      @search_socket.send compose_search(options), 0, options[:broadcast], options[:port]
+
+      if options[:synchronous]
+        search_sync options
+      else
+        search_async options
+      end
+    end
+
+    def start_watching_type(type, &block)
+      @watch[:services][type] = block
+      start_watch if @watch[:thread].nil?
+    end
+
+    def stop_watching_type(type)
+      @watch[:services].delete type
+      stop_watch if (@watch[:services].count == 0) && (@watch[:thread] != nil)
+    end
+
+    def stop_watching_all
+      @watch[:services] = {}
+      stop_watch if @watch[:thread] != nil
+    end
+
+    private
+
+    def compose_search(options)
+      query = "M-SEARCH * HTTP/1.1\n"                            \
+              "Host: #{options[:broadcast]}:#{options[:port]}\n" \
+              "Man: \"ssdp:discover\"\n"
+      query += "ST: #{options[:service]}\n" if options[:service]
+      options[:params].each { |key, val| query += "#{key}: #{value}\n" } if options[:params]
+      query + "\n"
+    end
+
+    def search_sync(options)
+      if options[:first_only]
+        search_single options
+      else
+        search_multi options
+      end
+    end
+
+    def search_async(options)
+      if options[:first_only]
+        Thread.new { search_single options }
+      else
+        Thread.new { search_multi options }
+      end
+    end
+
+    def search_single(options)
+      result = nil
+
+      if options[:timeout]
+        ready = IO::select [@search_socket], nil, nil, options[:timeout]
+        if ready
+          message, producer = @search_socket.recvfrom options[:maxpack]
+          result = process_ssdp_packet message, producer
+        end
+      else
+        message, producer = @search_socket.recvfrom options[:maxpack]
+        result = process_ssdp_packet message, producer
+      end
+
+      if options[:synchronous]
+        result
+      else
+        options[:callback].call result
+      end
+    end
+
+    def search_multi(options)
+      remaining = options[:timeout]
+      responses = []
+
+      while remaining > 0
+        start_time = Time.now
+        ready = IO::select [@search_socket], nil, nil, remaining
+        if ready
+          message, producer = @search_socket.recvfrom options[:maxpack]
+          responses << process_ssdp_packet(message, producer)
+        end
+        remaining -= (Time.now - start_time).to_i
+      end
+
+      if options[:synchronous]
+        responses
+      else
+        options[:callback].call responses
+      end
+    end
+
+    def process_ssdp_packet(message, producer)
+      ssdp = SSDP.parse_ssdp message
+      { :address => producer[3], :port => producer[1] }.merge ssdp
+    end
+
+    def start_watch
+      @watch[:socket] = SSDP.create_listener @options
+      @watch[:thread] = Thread.new do
+        begin
+          while true
+            message, producer = @watch[:socket].recvfrom @options[:maxpack]
+            notification = process_ssdp_packet message, producer
+            notification_type = notification[:params]['NT']
+            @watch[:services][notification_type].call notification if @watch[:services].include? notification_type
+          end
+        ensure
+          @watch[:socket].close
+        end
+      end
+    end
+
+    def stop_watch
+      @watch[:thread].exit
+      @watch[:thread] = nil
+    end
+
+  end
+end

data/lib/ssdp/producer.rb

@@ -0,0 +1,138 @@
+require 'socket'
+require 'SecureRandom'
+require 'ssdp'
+
+module SSDP
+  class Producer
+    attr_accessor :services
+    attr_accessor :uuid
+
+    def initialize(options = {})
+      @uuid = SecureRandom.uuid
+      @services = {}
+      @listener = { :socket => nil, :thread => nil }
+      @notifier = { :thread => nil }
+      @options = SSDP::DEFAULTS.merge options
+    end
+
+    def running?
+      @listener[:thread] != nil
+    end
+
+    def start
+      start_notifier if @options[:notifier]
+      start_listener
+    end
+
+    def stop(bye_bye = true)
+      @services.each { |type, params| send_bye_bye type, params } if bye_bye
+
+      if @listener[:thread] != nil
+        @listener[:thread].exit
+        @listener[:thread] = nil
+      end
+      if @notifier[:thread] != nil
+        @notifier[:thread].exit
+        @notifier[:thread] = nil
+      end
+    end
+
+    def add_service(type, location_or_param_hash)
+      params = {}
+      if location_or_param_hash.is_a? Hash
+        params = location_or_param_hash
+      else
+        params['AL']       = location_or_param_hash
+        params['LOCATION'] = location_or_param_hash
+      end
+
+      @services[type] = params
+      send_notification type, params if @options[:notifier]
+    end
+
+    def remove_service(type)
+      @services.delete[type]
+    end
+
+    private
+
+    def process_ssdp(message, consumer)
+      ssdp = SSDP.parse_ssdp message
+      return unless ssdp[:status].start_with? 'M-SEARCH * HTTP'
+
+      return if ssdp[:params]['ST'].nil?
+      return if @services[ssdp[:params]['ST']].nil?
+      send_response ssdp[:params]['ST'], consumer
+    end
+
+    def send_response(type, consumer)
+      params = @services[type]
+      response_body = "HTTP/1.1 200 OK\r\n"    \
+                      "ST: #{type}\r\n"        \
+                      "USN: uuid:#{@uuid}\r\n" +
+                      params.map { |k, v| "#{k}: #{v}" }.join("\r\n") +
+                      "\r\n\r\n"
+      send_direct_packet response_body, consumer
+    end
+
+    def send_notification(type, params)
+      notify_body = "NOTIFY * HTTP/1.1\r\n"                                \
+                    "Host: #{@options[:broadcast]}:#{@options[:port]}\r\n" \
+                    "NTS: ssdp:alive\r\n"                                  \
+                    "NT: #{type}\r\n"                                      \
+                    "USN: uuid:#{@uuid}\r\n" +
+                    params.map { |k, v| "#{k}: #{v}" }.join("\r\n") +
+                    "\r\n\r\n"
+
+      send_broadcast_packet notify_body
+    end
+
+    def send_bye_bye(type, params)
+      bye_bye_body = "NOTIFY * HTTP/1.1\r\n"                                \
+                     "Host: #{@options[:broadcast]}:#{@options[:port]}\r\n" \
+                     "NTS: ssdp:byebye\r\n"                                 \
+                     "NT: #{type}\r\n"                                      \
+                     "USN: uuid:#{@uuid}\r\n" +
+                     params.map { |k, v| "#{k}: #{v}" }.join("\r\n") +
+                     "\r\n\r\n"
+
+      send_broadcast_packet bye_bye_body
+    end
+
+    def send_direct_packet(body, endpoint)
+      udp_socket = UDPSocket.new
+      udp_socket.send body, 0, endpoint[:address], endpoint[:port]
+      udp_socket.close
+    end
+
+    def send_broadcast_packet(body)
+      broadcaster = SSDP.create_broadcaster
+      broadcaster.send body, 0, @options[:broadcast], @options[:port]
+      broadcaster.close
+    end
+
+    def start_listener
+      @listener[:socket] = SSDP.create_listener @options
+      @listener[:thread] = Thread.new do
+        begin
+          while true
+            message, consumer = @listener[:socket].recvfrom @options[:maxpack]
+            process_ssdp message, { :address => consumer[3], :port => consumer[1] } unless @services.count == 0
+          end
+        ensure
+          @listener[:socket].close
+        end
+      end
+    end
+
+    def start_notifier
+      @notifier[:thread] = Thread.new do
+        while true
+          sleep @options[:interval]
+          @services.each { |type, params| send_notification type, params }
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: ssdp
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Dillon Aumiller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-02 00:00:00.000000000 Z
+dependencies: []
+description: SSDP client/server library. Server notify/part/respond; client search/listen.
+email: dillonaumiller@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/ssdp.rb
+- lib/ssdp/consumer.rb
+- lib/ssdp/producer.rb
+homepage: https://github.com/daumiller/ssdp
+licenses:
+- BSD 2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: SSDP client/server library.
+test_files: []