ruby_home 0.1.5 → 0.1.7

data/lib/ruby_home/{http → hap}/hap_response.rb

@@ -1,10 +1,11 @@
 module RubyHome
-  module HTTP
+  module HAP
     class HAPResponse < WEBrick::HTTPResponse
-      def initialize(*args)
+      def initialize(config, sock)
+        @sock = sock
         cache[:accessory_to_controller_count] ||= 0
 
-        super(*args)
+        super(config)
       end
 
       def send_response(socket)
@@ -25,6 +26,8 @@ module RubyHome
 
       private
 
+      attr_reader :sock
+
       def encrypter
         @_encrypter ||= RubyHome::HAP::HTTPEncryption.new(encryption_key, encrypter_params)
       end
@@ -44,7 +47,7 @@ module RubyHome
       end
 
       def cache
-        RequestStore.store
+        RubyHome.socket_store[sock]
       end
     end
   end

data/lib/ruby_home/hap/server.rb

@@ -0,0 +1,81 @@
+module RubyHome
+  module HAP
+    class Server
+      def initialize(host, port, socket_store)
+        @port = port
+        @host = host
+        @socket_store = socket_store
+        @selector = NIO::Selector.new
+      end
+
+      attr_reader :port, :host, :socket_store
+
+      def run
+        puts "Listening on #{host}:#{port}"
+        @server = TCPServer.new(host, port)
+
+        monitor = @selector.register(@server, :r)
+        monitor.value = proc { accept }
+
+        loop do
+          @selector.select { |monitor| monitor.value.call(monitor) }
+        end
+      end
+
+      private
+
+      def accept
+        socket = @server.accept
+        _, port, host = socket.peeraddr
+        puts "*** #{host}:#{port} connected"
+
+        monitor = @selector.register(socket, :r)
+        monitor.value = proc { read(socket) }
+      end
+
+      def upstream
+        @_upstream ||= HTTP::Application.run
+      end
+
+      def read(socket)
+        return close(socket) if socket.eof?
+
+        socket_store[socket] ||= {}
+
+        request = HAPRequest.new(WEBrick::Config::HTTP, socket)
+        response = HAPResponse.new(WEBrick::Config::HTTP, socket)
+
+        request.parse(socket)
+
+        response.received_encrypted_request = request.received_encrypted_request?
+        response.request_method = request.request_method
+        response.request_uri = request.request_uri
+        response.request_http_version = request.http_version
+        response.keep_alive = request.keep_alive?
+
+        upstream.service(request, response)
+
+        if request.request_line
+          if request.keep_alive? && response.keep_alive?
+            request.fixup()
+          end
+          response.send_response(socket)
+        end
+
+        return close(socket) unless request.keep_alive?
+        return close(socket) unless response.keep_alive?
+      rescue EOFError
+        close(socket)
+      end
+
+      def close(socket)
+        _, port, host = socket.peeraddr
+        puts "*** #{host}:#{port} disconnected"
+        @selector.deregister(socket)
+        socket_store.delete(socket)
+        socket.close
+      end
+    end
+  end
+end
+

data/lib/ruby_home/hap/service.rb

@@ -8,28 +8,24 @@ module RubyHome
       @description = description
       @uuid = uuid
       @characteristics = []
+      @instance_id = accessory.next_available_instance_id
     end
 
-    attr_reader :accessory, :characteristics, :primary, :hidden, :name, :description, :uuid
-    attr_accessor :instance_id
+    attr_reader(
+      :accessory,
+      :characteristics,
+      :primary,
+      :hidden,
+      :name,
+      :description,
+      :uuid,
+      :instance_id
+    )
 
     def characteristic(characteristic_name)
       characteristics.find do |characteristic|
         characteristic.name == characteristic_name
       end
     end
-
-    def save
-      IdentifierCache.add_accessory(accessory)
-      IdentifierCache.add_service(self)
-    end
-
-    def inspect
-      {
-        primary: primary,
-        hidden: hidden,
-        characteristics: characteristics
-      }
-    end
   end
 end

data/lib/ruby_home/http/application.rb

@@ -1,31 +1,26 @@
-Dir[File.dirname(__FILE__) + '/controllers/*.rb'].each {|file| require file }
+Dir[File.dirname(__FILE__) + '/controllers/*.rb'].each { |file| require file }
 
 module RubyHome
   module HTTP
     class Application
-      def run
-        RubyHome::Rack::Handler::HAPServer.run rack_builder,
-          Port: port,
-          Host: bind_address,
-          ServerSoftware: 'RubyHome'
-      end
-
-      def port
-        @_port ||= Integer(ENV['PORT'] && !ENV['PORT'].empty? ? ENV['PORT'] : 4567)
-      end
+      class << self
+        def run
+          ::Rack::Handler::WEBrick.new(
+            ::WEBrick::HTTPServer.new(DoNotListen: true),
+            rack_builder
+          )
+        end
 
-      def bind_address
-        '0.0.0.0'
-      end
+        def rack_builder
+          ::Rack::Builder.new do
+            use ::Rack::CommonLogger
 
-      def rack_builder
-        ::Rack::Builder.new do
-          use ::Rack::CommonLogger
-          map('/accessories', &Proc.new { run AccessoriesController })
-          map('/characteristics', &Proc.new { run CharacteristicsController })
-          map('/pair-setup', &Proc.new { run PairSetupsController })
-          map('/pair-verify', &Proc.new { run PairVerifiesController })
-          map('/pairings', &Proc.new { run PairingsController })
+            map('/accessories') { run AccessoriesController }
+            map('/characteristics') { run CharacteristicsController }
+            map('/pair-setup') { run PairSetupsController }
+            map('/pair-verify') { run PairVerifiesController }
+            map('/pairings') { run PairingsController }
+          end
         end
       end
     end

data/lib/ruby_home/http/controllers/application_controller.rb

@@ -28,15 +28,19 @@ module RubyHome
       end
 
       def identifier_cache
-        IdentifierCache
+        Accessory.all
       end
 
-      def cache
-        RequestStore.store
+      def socket
+        env["REQUEST_SOCKET"]
       end
 
       def clear_cache
-        RequestStore.clear!
+        RubyHome.socket_store.delete(socket)
+      end
+
+      def cache
+        RubyHome.socket_store[socket]
       end
 
       def tlv(object)

data/lib/ruby_home/http/controllers/characteristics_controller.rb

@@ -14,7 +14,11 @@ module RubyHome
 
       put '/' do
         json_body.fetch('characteristics', []).each do |characteristic_params|
-          update_characteristics(characteristic_params)
+          if characteristic_params['value']
+            update_characteristics(characteristic_params)
+          elsif characteristic_params['ev']
+            subscribe_characteristics(characteristic_params)
+          end
         end
 
         status 204
@@ -30,14 +34,25 @@ module RubyHome
         end
 
         def update_characteristics(characteristic_params)
-          characteristic = find_characteristic(**characteristic_params.symbolize_keys.slice(:aid, :iid))
-          if characteristic && characteristic_params['value']
+          find_characteristic(**characteristic_params.symbolize_keys.slice(:aid, :iid)) do |characteristic|
             characteristic.value = characteristic_params['value']
           end
         end
 
+        def subscribe_characteristics(characteristic_params)
+          find_characteristic(**characteristic_params.symbolize_keys.slice(:aid, :iid)) do |characteristic|
+            notifier = SocketNotifier.new(socket, characteristic)
+
+            unless characteristic.listeners.include?(notifier)
+              characteristic.subscribe(notifier)
+            end
+          end
+        end
+
         def find_characteristic(aid:, iid:)
-          IdentifierCache.find_characteristic(accessory_id: aid.to_i, instance_id: iid.to_i)
+          characteristic = identifier_cache.find_characteristic(accessory_id: aid.to_i, instance_id: iid.to_i)
+          yield characteristic if block_given?
+          characteristic
         end
 
         def require_session

data/lib/ruby_home/http/controllers/pair_verifies_controller.rb

@@ -56,11 +56,9 @@ module RubyHome
         unpacked_decrypted_data = HAP::TLV.read(decrypted_data)
 
         if accessory_info.paired_clients.any? {|h| h[:identifier] == unpacked_decrypted_data[:identifier]}
-          hkdf = HAP::Crypto::HKDF.new(info: 'Control-Write-Encryption-Key', salt: 'Control-Salt')
-          cache[:controller_to_accessory_key] = hkdf.encrypt(cache[:shared_secret])
-
-          hkdf = HAP::Crypto::HKDF.new(info: 'Control-Read-Encryption-Key', salt: 'Control-Salt')
-          cache[:accessory_to_controller_key] = hkdf.encrypt(cache[:shared_secret])
+          shared_secret = HAP::Crypto::SessionKey.new(cache[:shared_secret])
+          cache[:controller_to_accessory_key] = shared_secret.controller_to_accessory_key
+          cache[:accessory_to_controller_key] = shared_secret.accessory_to_controller_key
 
           cache.delete(:session_key)
           cache.delete(:shared_secret)

data/lib/ruby_home/http/serializers/object_serializer.rb

@@ -15,7 +15,7 @@ module RubyHome
 
       def serializable_hash
         serializable_hash = if @resource
-          record_hash(resource)
+          record_hash(@resource)
         elsif @resources
           @resources.map do |resource|
             record_hash(resource)

data/lib/ruby_home/http/services/socket_notifier.rb

@@ -0,0 +1,40 @@
+module RubyHome
+  module HTTP
+    class SocketNotifier
+      def initialize(socket, characteristic)
+        @socket = socket
+        @characteristic = characteristic
+      end
+
+      def updated(_)
+        if socket_still_active?
+          send_ev_response
+        else
+          characteristic.unsubscribe(self)
+        end
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          self.socket == other.socket &&
+          self.characteristic == other.characteristic
+      end
+
+      attr_reader :socket, :characteristic
+
+      private
+
+        def socket_still_active?
+          RubyHome.socket_store.include?(socket)
+        end
+
+        def send_ev_response
+          HAP::EVResponse.new(socket, serialized_characteristic).send_response
+        end
+
+        def serialized_characteristic
+          HTTP::CharacteristicValueSerializer.new([characteristic]).serialized_json
+        end
+    end
+  end
+end

data/lib/ruby_home/http/services/start_srp_service.rb

@@ -1,46 +1,48 @@
-class StartSRPService
-  def initialize(username: , password:)
-    @username = username
-    @password = password
-  end
+module RubyHome
+  class StartSRPService
+    def initialize(username: , password:)
+      @username = username
+      @password = password
+    end
 
-  def salt_bytes
-    [salt].pack('H*')
-  end
+    def salt_bytes
+      [salt].pack('H*')
+    end
 
-  def public_key_bytes
-    [public_key].pack('H*')
-  end
+    def public_key_bytes
+      [public_key].pack('H*')
+    end
 
-  def proof
-    challenge_and_proof[:proof]
-  end
+    def proof
+      challenge_and_proof[:proof]
+    end
 
-  private
+    private
 
-  def salt
-    user_auth[:salt]
-  end
+    def salt
+      user_auth[:salt]
+    end
 
-  def public_key
-    challenge[:B]
-  end
+    def public_key
+      challenge[:B]
+    end
 
-  def challenge
-    challenge_and_proof[:challenge]
-  end
+    def challenge
+      challenge_and_proof[:challenge]
+    end
 
-  def challenge_and_proof
-    srp_verifier.get_challenge_and_proof(username, user_auth[:verifier], user_auth[:salt])
-  end
+    def challenge_and_proof
+      srp_verifier.get_challenge_and_proof(username, user_auth[:verifier], user_auth[:salt])
+    end
 
-  def user_auth
-    @_user_auth ||= srp_verifier.generate_userauth(username, password)
-  end
+    def user_auth
+      @_user_auth ||= srp_verifier.generate_userauth(username, password)
+    end
 
-  def srp_verifier
-    @_verifier ||= RubyHome::SRP::Verifier.new
-  end
+    def srp_verifier
+      @_verifier ||= RubyHome::SRP::Verifier.new
+    end
 
-  attr_reader :username, :password
+    attr_reader :username, :password
+  end
 end

data/lib/ruby_home/http/services/verify_srp_service.rb

@@ -1,55 +1,57 @@
-class VerifySRPService
-  def initialize(public_key: , device_proof: , srp_session: )
-    @device_proof = device_proof
-    @srp_session = srp_session
-    @public_key = public_key
+module RubyHome
+  class VerifySRPService
+    def initialize(public_key: , device_proof: , srp_session: )
+      @device_proof = device_proof
+      @srp_session = srp_session
+      @public_key = public_key
+    end
+
+    def valid?
+      return false unless public_key
+      return false unless device_proof
+      return false unless srp_session
+      return false unless valid_session?
+
+      true
+    end
+
+    def session_key
+      srp_verifier.K
+    end
+
+    def server_proof
+      verify_session_bytes
+    end
+
+    private
+
+    def valid_session?
+      !!verify_session
+    end
+
+    def verify_session_bytes
+      [verify_session].pack('H*')
+    end
+
+    def verify_session
+      @_verify_session ||= srp_verifier.verify_session(
+        srp_session.merge({A: public_key_bytes}),
+        device_proof_bytes
+      )
+    end
+
+    def public_key_bytes
+      public_key.unpack1('H*')
+    end
+
+    def device_proof_bytes
+      device_proof.unpack1('H*')
+    end
+
+    def srp_verifier
+      @_verifier ||= RubyHome::SRP::Verifier.new
+    end
+
+    attr_reader :public_key, :device_proof, :srp_session
   end
-
-  def valid?
-    return false unless public_key
-    return false unless device_proof
-    return false unless srp_session
-    return false unless valid_session?
-
-    true
-  end
-
-  def session_key
-    srp_verifier.K
-  end
-
-  def server_proof
-    verify_session_bytes
-  end
-
-  private
-
-  def valid_session?
-    !!verify_session
-  end
-
-  def verify_session_bytes
-    [verify_session].pack('H*')
-  end
-
-  def verify_session
-    @_verify_session ||= srp_verifier.verify_session(
-      srp_session.merge({A: public_key_bytes}),
-      device_proof_bytes
-    )
-  end
-
-  def public_key_bytes
-    public_key.unpack1('H*')
-  end
-
-  def device_proof_bytes
-    device_proof.unpack1('H*')
-  end
-
-  def srp_verifier
-    @_verifier ||= RubyHome::SRP::Verifier.new
-  end
-
-  attr_reader :public_key, :device_proof, :srp_session
 end

data/lib/ruby_home/identifier_cache.rb

@@ -1,59 +1,32 @@
+require_relative 'persistable'
+
 module RubyHome
   class IdentifierCache
-    class << self
-      attr_accessor :accessories
-
-      def accessories
-        @@accessories ||= []
-      end
-
-      def reset!
-        @@accessories = []
-      end
-
-      def services
-        accessories.flat_map(&:services)
-      end
-
-      def characteristics
-        services.flat_map(&:characteristics)
-      end
-
-      def find_characteristic(attributes)
-        characteristics.find do |characteristic|
-          attributes.all? do |key, value|
-            characteristic.send(key) == value
-          end
-        end
-      end
-
-      def add_accessory(accessory)
-        return true if accessories.include?(accessory)
+    include Persistable
 
-        accessories << accessory.tap do |a|
-          a.id = accessories.size + 1
-        end
+    self.source = 'identifier_cache.yml'
 
-      end
-
-      def add_service(service)
-        return true if services.include?(service)
-
-        accessory = service.accessory
-        accessory.services << service.tap do |s|
-          s.instance_id = accessory.next_available_instance_id
-        end
+    def self.instance
+      @@_instance ||= persisted || create
+    end
 
-      end
+    def self.reload
+      @@_instance = nil
+    end
 
-      def add_characteristic(characteristic)
-        return true if characteristics.include?(characteristic)
+    def initialize(accessory_id: , instance_id: , uuid: )
+      @accessory_id = accessory_id
+      @instance_id = instance_id
+      @uuid = uuid
+    end
 
-        service = characteristic.service
-        service.characteristics << characteristic.tap do |c|
-          c.instance_id = characteristic.accessory.next_available_instance_id
-        end
-      end
+    def persisted_attributes
+      {
+        accessory_id: accessory.id,
+        instance_id: instance.instance_id,
+        uuid: instance.uuid
+      }
     end
   end
 end
+

data/lib/ruby_home/persistable.rb

@@ -0,0 +1,36 @@
+module RubyHome
+  module Persistable
+    def self.included(base)
+      base.send(:cattr_accessor, :source)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def persisted
+        new(read) if read
+      end
+
+      def create(**options)
+        new(**options).tap(&:save)
+      end
+
+      def write(collection)
+        File.open(source, 'w') {|f| f.write(collection.to_yaml) }
+      end
+
+      def read
+        return false unless File.exists?(source)
+
+        YAML.load_file(source)
+      end
+    end
+
+    def reload
+      self.class.reload
+    end
+
+    def save
+      self.class.write(persisted_attributes)
+    end
+  end
+end

data/lib/ruby_home/version.rb

@@ -1,3 +1,3 @@
 module RubyHome
-  VERSION = '0.1.5'
+  VERSION = '0.1.7'
 end