rbupnptools 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 03fbd519c8cb1e74cc7a96cbbb204a48792f4bf792872c59c8df39ace6b8458b
+  data.tar.gz: 96fa311850190c03e6f9adc502f078cfc7f28cfd6b436cd3dd1c3d8de7057f48
+SHA512:
+  metadata.gz: 3a1c31bf6a73f12fc09d226b4ada2c6246dcc17d2fe168b269333b51be3c876e9d6265645c0f0675fdbba35065a55d6bbe5c1ae5ef34e9c58f5b72ce6189fc23
+  data.tar.gz: 1e804d391a806988ef463240f4eb0420a7338d935bfa2c7e7e52d3955bc1cb39f88548333a1d00bf31c671433685a914f06e69663fcb5806badd6afa789d4d7f

data/lib/http_header.rb

@@ -0,0 +1,84 @@
+class FirstLine
+  def initialize(tokens)
+    @tokens = tokens
+  end
+
+  def [](key)
+    @tokens[key]
+  end
+
+  def []=(key, value)
+    @tokens[key] = value
+  end
+
+  def to_s
+    @tokens.join(' ')
+  end
+end
+
+def FirstLine.read(line)
+  FirstLine.new line.split(%r{\s+}, 3)
+end
+
+
+class HttpHeader < Hash
+
+  def initialize(firstline)
+    @name_table = Hash.new
+    @firstline = firstline
+  end
+
+  def firstline
+    @firstline
+  end
+
+  def org_keys
+    @name_table.values
+  end
+  
+  def [](key)
+    super _issensitive(key)
+  end
+
+  def []=(key, value)
+    @name_table[_issensitive(key)] = key
+    super _issensitive(key), value
+  end
+
+  def update!(hash)
+    hash.each { |k,v| self[k] = v }
+  end
+
+  def to_s
+    s = "#{firstline}\r\n"
+    self.each do |key, value|
+      s << "#{@name_table[key]}: #{value}\r\n"
+    end
+    s << "\r\n"
+    return s
+  end
+
+  def to_str
+    self.to_s
+  end
+
+  protected
+
+  def _issensitive(key)
+    key.respond_to?(:upcase) ? key.upcase : key
+  end
+end
+
+
+def HttpHeader.read(text)
+  firstline = text.lines[0].strip
+  fields = text.lines[1..-1]
+  header = HttpHeader.new FirstLine.read(firstline)
+  fields.each do |line|
+    tokens = line.split ':', 2
+    name = tokens[0].strip
+    value = tokens[1].strip
+    header[name] = value
+  end
+  header
+end

data/lib/ssdp.rb

@@ -0,0 +1,168 @@
+require 'socket'
+require 'logger'
+require_relative 'http_header.rb'
+
+$logger = Logger.new(STDOUT)
+
+module SSDP
+
+  MCAST_HOST = '239.255.255.250'
+  MCAST_PORT = 1900
+
+
+  class SsdpHeader < HttpHeader
+    def initialize(http_header)
+      @http_header = http_header
+    end
+
+    def notify?
+      @http_header.firstline[0] == 'NOTIFY'
+    end
+
+    def notify_alive?
+      self.notify? and @http_header['nts'] == 'ssdp:alive'
+    end
+
+    def notify_byebye?
+      self.notify? and @http_header['nts'] == 'ssdp:byebye'
+    end
+
+    def msearch?
+      @http_header.firstline[0] == 'M-SEARCH'
+    end
+
+    def http_response?
+      @http_header.firstline[0].start_with? 'HTTP'
+    end
+
+    def usn
+      self['usn']
+    end
+
+    def location
+      self['location']
+    end
+
+    def [](key)
+      @http_header[key]
+    end
+
+    def []=(key, value)
+      @http_header[key] = value
+    end
+
+    def to_s
+      @http_header.to_s
+    end
+
+    def to_str
+      @http_header.to_str
+    end
+  end
+
+
+  class SsdpHandler
+    def initialize(func = nil)
+      @func = func
+    end
+    
+    def on_ssdp_header(ssdp_header)
+      if @func
+        return @func.(ssdp_header)
+      end
+    end
+  end
+
+
+  class SsdpListener
+    def initialize(port = 1900)
+      @host = '0.0.0.0'
+      @port = port
+      @handler = nil
+      @finishing = false
+    end
+
+    attr_reader :port
+    attr_accessor :handler
+
+    def finish
+      @finishing = true
+    end
+    
+    def run
+      @finishing = false
+      socket = UDPSocket.new
+      membership = IPAddr.new(MCAST_HOST).hton + IPAddr.new(@host).hton
+      socket.setsockopt(:IPPROTO_IP, :IP_ADD_MEMBERSHIP, membership)
+      socket.setsockopt(:SOL_SOCKET, :SO_REUSEADDR, 1)
+      socket.setsockopt(:SOL_SOCKET, :SO_REUSEPORT, 1)
+      socket.bind(@host, @port)
+      fds = [socket]
+      $logger.debug 'listen...'
+      while @finishing == false do
+        timeout = 1
+        if ios = select(fds, [], [], timeout)
+          data, addr = socket.recvfrom(4096)
+          ssdp_header = SsdpHeader.new HttpHeader.read(data.chomp)
+          if @handler
+            responses = @handler.on_ssdp_header(ssdp_header)
+            if responses != nil
+              responses.each do |response|
+                socket.send response.to_s, 0, addr[2], addr[1]
+              end
+            end
+          end
+        end
+      end
+      socket.close
+    end
+
+    def start
+      @run_thread = Thread.new { self.run }
+    end
+
+    def stop
+      @finishing = true
+      @run_thread.join
+    end
+  end
+
+
+  def self.send_msearch(st, mx, handler = nil)
+    socket = UDPSocket.new
+    socket.setsockopt(:IPPROTO_IP, :IP_MULTICAST_TTL, 1)
+    payload = "M-SEARCH * HTTP/1.1\r\n" \
+              "HOST: #{MCAST_HOST}:#{MCAST_PORT}\r\n" \
+              "MAN: \"ssdp:discover\"\r\n" \
+              "MX: 3\r\n" \
+              "ST: ssdp:all\r\n" \
+              "\r\n"
+
+    socket.send(payload, 0, MCAST_HOST, MCAST_PORT)
+
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+
+    fds = [socket]
+
+    lst = []
+
+    while true
+      cur = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+      if (cur - start) >= mx 
+        break
+      end
+      if ios = select(fds, [], [], 1)
+        data, addr = socket.recvfrom(4096)
+        ssdp_header = SsdpHeader.new HttpHeader.read(data.chomp)
+        if handler
+          handler.call(ssdp_header)
+        end
+        lst << ssdp_header
+      end
+    end
+    socket.close
+    return lst
+  end
+
+
+end

data/lib/upnp_control_point.rb

@@ -0,0 +1,197 @@
+require 'active_support/core_ext/hash/conversions'
+require "webrick"
+require 'net/http'
+require 'uri'
+require 'logger'
+require_relative "ssdp.rb"
+require_relative "upnp_model.rb"
+require_relative "usn.rb"
+require_relative "upnp_soap.rb"
+require_relative "upnp_event.rb"
+
+
+$logger = Logger.new STDOUT
+
+
+class UPnPDeviceListener
+  def initialize(on_device_added = nil, on_device_removed = nil)
+    @on_device_added = on_device_added
+    @on_device_removed = on_device_removed
+  end
+  
+  def on_device_added(device)
+    if @on_device_added
+      @on_device_added.call(device)
+    end
+  end
+
+  def on_device_removed(device)
+    if @on_device_removed
+      @on_device_removed.call(device)
+    end
+  end
+end
+
+
+class EventNotifyServlet < WEBrick::HTTPServlet::AbstractServlet
+  def do_NOTIFY(req, res)
+    cp = @options[0]
+    if req.path == '/event'
+      cp.on_event_notify req['SID'], req.body
+    end
+    res.status = 200
+  end
+end
+
+
+class UPnPControlPoint
+
+  def initialize(host = '0.0.0.0', port = 0)
+    @finishing = false
+    @ssdp_listener = SSDP::SsdpListener.new
+    @ssdp_listener.handler = self
+    @http_server = WEBrick::HTTPServer.new :BindAddress => host, :Port => port
+    @http_server.mount '/', EventNotifyServlet, self
+    @devices = {}
+    @subscriptions = {}
+    @interval_timer = 10
+  end
+
+  attr_accessor :device_listener, :event_listener, :subscriptions
+
+
+  def on_event_notify(sid, body)
+    props = UPnPEventProperty.read(body)
+    if @event_listener
+      @event_listener.on_event_notify sid, props
+    end
+  end
+
+
+  def on_ssdp_header(ssdp_header)
+    if ssdp_header.notify_alive? or ssdp_header.http_response?
+      usn = Usn.read(ssdp_header.usn)
+      if not @devices.key? usn.udn
+        xml = self.build_device ssdp_header
+        if xml.to_s.empty?
+          return
+        end
+        device = UPnPDevice.read xml
+        device.base_url = ssdp_header.location
+        @devices[usn.udn] = device
+        if @device_listener
+          @device_listener.on_device_added device
+        end
+      end
+    elsif ssdp_header.notify_byebye?
+      usn = Usn.read(ssdp_header['usn'])
+      device = @devices[usn.udn]
+      if device
+        if @device_listener
+          @device_listener.on_device_removed device
+        end
+        @devices.delete usn.udn
+      end
+    end
+  end
+
+
+  def send_msearch(st, mx = 3)
+    $logger.debug("send msearch / #{st}")
+    SSDP.send_msearch st, mx, lambda {
+      |ssdp_header| on_ssdp_header ssdp_header}
+  end
+
+
+  def build_device(ssdp_header)
+    uri = URI(ssdp_header.location)
+    xml = Net::HTTP.get(uri)
+  end
+
+
+  def get_ip_address
+    Socket::getaddrinfo(Socket.gethostname, 'echo', Socket::AF_INET)[0][3]
+  end
+
+
+  def subscribe(device, service)
+    host = self.get_ip_address
+    port = @http_server.config[:Port]
+    headers = {
+      'NT' => 'upnp:event',
+      'CALLBACK' => "<http://#{host}:#{port}/event>",
+      'TIMEOUT' => 'Second-1800'
+    }
+    url = URI::join(device.base_url, service['eventSubURL'])
+    Net::HTTP.start(url.host, url.port) { |http|
+      req = SubscribeRequest.new url, initheader = headers
+      res = http.request req
+      sid = res['sid']
+      timeout = res['timeout'].split('-')[-1]
+      subscription = UPnPEventSubscription.new device, service, sid, timeout
+      @subscriptions[sid] = subscription
+      return subscription
+    }
+  end
+
+
+  def unsubscribe(subscription)
+    headers = {
+      'SID' => subscription.sid,
+    }
+    url = URI::join(subscription.device.base_url, subscription.service.scpdurl)
+    Net::HTTP.start(url.host, url.port) { |http|
+      req = UnsubscribeRequest.new url, initheader = headers
+      res = http.request req
+      $logger.debug("response : #{res.code}'")
+    }
+    @subscriptions.delete(subscription.sid)
+  end
+
+
+  def invoke_action(device, service, action_name, params)
+    url = URI::join(device.base_url, service['controlURL'])
+    soap_req = UPnPSoapRequest.new service.service_type, action_name
+    soap_req.merge! params
+    header = {
+      'SOAPACTION' => "#{service.service_type}##{action_name}",
+      'Content-Type' => 'text/xml; charset="utf-8'
+    }
+    http = Net::HTTP.new(url.host, url.port)
+    req = Net::HTTP::Post.new(url.request_uri, header)
+    req.body = soap_req.to_xml
+    res = http.request(req)
+    UPnPSoapResponse.read res.body
+  end
+
+  
+  def on_timer
+    @devices.reject! {|key, value| value.expired? }
+  end
+
+  def timer_loop
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+    while not @finishing
+      dur = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second) - start
+      if dur >= @interval_timer
+        on_timer
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+      end
+    end
+  end
+  
+  def start
+    @finishing = false
+    @ssdp_listener_thread = Thread.new { @ssdp_listener.run }
+    @http_server_thread = Thread.new { @http_server.start }
+    @timer_thread = Thread.new { timer_loop }
+  end
+
+
+  def stop
+    @finishing = true
+    @http_server.shutdown
+    @http_server_thread.join
+    @timer_thread.join
+  end
+end