Send event when device is paired/unpaired and update mDNS service reachability

The mDNS txt record entry 'sf' indicates the reachability of the transport.
If a device is already paired with the transport, sf should be set to 0.
iOS 9 checks for this flag and does not connect to the accessory if it still
set to 1.

Now when a device is paired or unpaired, an event is send using an event emitter
and the mDNS txt records are updated.

This commit fixes #2.

Author: brutella

event/constant.go

@@ -1,7 +1,7 @@
 package event
 
-// DevicePairingAdded is emitted when transport paired with a device (e.g. iOS client successfully paired with the accessory)
-type DevicePairingAdded struct{}
+// DevicePaired is emitted when transport paired with a device (e.g. iOS client successfully paired with the accessory)
+type DevicePaired struct{}
 
-// DevicePairingRemoved is emitted when pairing with a device is removed (e.g. iOS client removed the accessory from HomeKit)
-type DevicePairingRemoved struct{}
+// DeviceUnpaired is emitted when pairing with a device is removed (e.g. iOS client removed the accessory from HomeKit)
+type DeviceUnpaired struct{}

hap/ip_transport.go

@@ -7,11 +7,11 @@ import (
 	"sync"
 
 	"github.com/brutella/hc/db"
+	"github.com/brutella/hc/event"
 	"github.com/brutella/hc/model/accessory"
 	"github.com/brutella/hc/model/characteristic"
 	"github.com/brutella/hc/model/container"
 	"github.com/brutella/hc/netio"
-	"github.com/brutella/hc/netio/event"
 	"github.com/brutella/hc/server"
 	"github.com/brutella/hc/util"
 	"github.com/brutella/log"
@@ -30,6 +30,8 @@ type ipTransport struct {
 	name      string
 	device    netio.SecuredDevice
 	container *container.Container
+
+	emitter event.Emitter
 }
 
 // NewIPTransport creates a transport to provide accessories over IP.
@@ -71,25 +73,34 @@ func NewIPTransport(pin string, a *accessory.Accessory, as ...*accessory.Accesso
 		container: container.NewContainer(),
 		mutex:     &sync.Mutex{},
 		context:   netio.NewContextForSecuredDevice(device),
+		emitter:   event.NewEmitter(),
 	}
 
 	t.addAccessory(a)
 	for _, a := range as {
 		t.addAccessory(a)
 	}
 
+	t.emitter.AddListener(t)
+
 	return t, err
 }
 
 func (t *ipTransport) Start() {
-	s := server.NewServer(t.context, t.database, t.container, t.device, t.mutex)
+	s := server.NewServer(t.context, t.database, t.container, t.device, t.mutex, t.emitter)
 	t.server = s
 	port := to.Int64(s.Port())
 
 	mdns := NewMDNSService(t.name, t.device.Name(), int(port))
 	t.mdns = mdns
 
+	if t.isPaired() {
+		// Paired accessories must not be reachable for other clients since iOS 9
+		mdns.SetReachable(false)
+	}
+
 	mdns.Publish()
+
 	// Listen until server.Stop() is called
 	s.ListenAndServe()
 }
@@ -105,6 +116,26 @@ func (t *ipTransport) Stop() {
 	}
 }
 
+// isPaired returns true when the transport is already paired
+func (t *ipTransport) isPaired() bool {
+
+	// If more than one entity is stored in the database, we are paired with a device.
+	// The transport itself is a device and is stored in the database, therefore
+	// we have to check for more than one entity.
+	if es, err := t.database.Entities(); err == nil && len(es) > 1 {
+		return true
+	}
+
+	return false
+}
+
+func (t *ipTransport) updateMDNSReachability() {
+	if mdns := t.mdns; mdns != nil {
+		mdns.SetReachable(t.isPaired() == false)
+		mdns.Update()
+	}
+}
+
 func (t *ipTransport) addAccessory(a *accessory.Accessory) {
 	t.container.AddAccessory(a)
 
@@ -136,7 +167,7 @@ func (t *ipTransport) notifyListener(a *accessory.Accessory, c *characteristic.C
 		if conn == except {
 			continue
 		}
-		resp, err := event.New(a, c)
+		resp, err := netio.New(a, c)
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -146,7 +177,7 @@ func (t *ipTransport) notifyListener(a *accessory.Accessory, c *characteristic.C
 		var buffer = new(bytes.Buffer)
 		resp.Write(buffer)
 		bytes, err := ioutil.ReadAll(buffer)
-		bytes = event.FixProtocolSpecifier(bytes)
+		bytes = netio.FixProtocolSpecifier(bytes)
 		log.Printf("[VERB] %s <- %s", conn.RemoteAddr(), string(bytes))
 		conn.Write(bytes)
 	}
@@ -166,3 +197,17 @@ func transportUUIDInStorage(storage util.Storage) string {
 	}
 	return string(uuid)
 }
+
+// Handles event which are sent when pairing with a device is added or removed
+func (t *ipTransport) Handle(ev interface{}) {
+	switch ev.(type) {
+	case event.DevicePaired:
+		log.Printf("[INFO] Event: paired with device")
+		t.updateMDNSReachability()
+	case event.DeviceUnpaired:
+		log.Printf("[INFO] Event: unpaired with device")
+		t.updateMDNSReachability()
+	default:
+		break
+	}
+}

netio/endpoint/pair-setup.go

@@ -2,8 +2,10 @@ package endpoint
 
 import (
 	"github.com/brutella/hc/db"
+	"github.com/brutella/hc/event"
 	"github.com/brutella/hc/netio"
 	"github.com/brutella/hc/netio/pair"
+	"github.com/brutella/hc/util"
 	"github.com/brutella/log"
 
 	"io"
@@ -15,49 +17,65 @@ import (
 // This endoint is session based and handles requests based on their connections.
 // Which means that there is one pair setup controller for every connection.
 // This is required to support simultaneous pairing connections.
+//
+// When pairing finished, the DevicePaired event is sent using an event emitter.
 type PairSetup struct {
 	http.Handler
 
 	device   netio.SecuredDevice
 	database db.Database
 	context  netio.HAPContext
+	emitter  event.Emitter
 }
 
 // NewPairSetup returns a new handler for pairing endpoint
-func NewPairSetup(context netio.HAPContext, device netio.SecuredDevice, database db.Database) *PairSetup {
-	handler := PairSetup{
+func NewPairSetup(context netio.HAPContext, device netio.SecuredDevice, database db.Database, emitter event.Emitter) *PairSetup {
+	endpoint := PairSetup{
 		device:   device,
 		database: database,
 		context:  context,
+		emitter:  emitter,
 	}
 
-	return &handler
+	return &endpoint
 }
 
-func (handler *PairSetup) ServeHTTP(response http.ResponseWriter, request *http.Request) {
+func (endpoint *PairSetup) ServeHTTP(response http.ResponseWriter, request *http.Request) {
 	log.Printf("[VERB] %v POST /pair-setup", request.RemoteAddr)
 	response.Header().Set("Content-Type", netio.HTTPContentTypePairingTLV8)
 
-	key := handler.context.GetConnectionKey(request)
-	session := handler.context.Get(key).(netio.Session)
-	controller := session.PairSetupHandler()
-	if controller == nil {
+	var err error
+	var in util.Container
+	var out util.Container
+
+	key := endpoint.context.GetConnectionKey(request)
+	session := endpoint.context.Get(key).(netio.Session)
+	ctrl := session.PairSetupHandler()
+	if ctrl == nil {
 		log.Println("[VERB] Create new pair setup controller")
-		var err error
-		controller, err = pair.NewSetupServerController(handler.device, handler.database)
-		if err != nil {
+
+		if ctrl, err = pair.NewSetupServerController(endpoint.device, endpoint.database); err != nil {
 			log.Println(err)
 		}
 
-		session.SetPairSetupHandler(controller)
+		session.SetPairSetupHandler(ctrl)
 	}
 
-	res, err := pair.HandleReaderForHandler(request.Body, controller)
+	if in, err = util.NewTLV8ContainerFromReader(request.Body); err == nil {
+		out, err = ctrl.Handle(in)
+	}
 
 	if err != nil {
 		log.Println("[ERRO]", err)
 		response.WriteHeader(http.StatusInternalServerError)
 	} else {
-		io.Copy(response, res)
+		io.Copy(response, out.BytesBuffer())
+
+		// Send event when key exchange is done
+		b := out.GetByte(pair.TagSequence)
+		switch pair.PairStepType(b) {
+		case pair.PairStepKeyExchangeResponse:
+			endpoint.emitter.Emit(event.DevicePaired{})
+		}
 	}
 }

netio/endpoint/pair-verify.go

@@ -5,6 +5,7 @@ import (
 	"github.com/brutella/hc/db"
 	"github.com/brutella/hc/netio"
 	"github.com/brutella/hc/netio/pair"
+	"github.com/brutella/hc/util"
 	"github.com/brutella/log"
 
 	"io"
@@ -22,47 +23,55 @@ type PairVerify struct {
 	database db.Database
 }
 
-// NewPairVerify returns a new handler for pair verify endpoint
+// NewPairVerify returns a new endpoint for pair verify endpoint
 func NewPairVerify(context netio.HAPContext, database db.Database) *PairVerify {
-	handler := PairVerify{
+	endpoint := PairVerify{
 		context:  context,
 		database: database,
 	}
 
-	return &handler
+	return &endpoint
 }
 
-func (handler *PairVerify) ServeHTTP(response http.ResponseWriter, request *http.Request) {
+func (endpoint *PairVerify) ServeHTTP(response http.ResponseWriter, request *http.Request) {
 	log.Printf("[VERB] %v POST /pair-verify", request.RemoteAddr)
 	response.Header().Set("Content-Type", netio.HTTPContentTypePairingTLV8)
 
-	key := handler.context.GetConnectionKey(request)
-	session := handler.context.Get(key).(netio.Session)
-	controller := session.PairVerifyHandler()
-	if controller == nil {
+	key := endpoint.context.GetConnectionKey(request)
+	session := endpoint.context.Get(key).(netio.Session)
+	ctlr := session.PairVerifyHandler()
+	if ctlr == nil {
 		log.Println("[VERB] Create new pair verify controller")
-		controller = pair.NewVerifyServerController(handler.database, handler.context)
-		session.SetPairVerifyHandler(controller)
+		ctlr = pair.NewVerifyServerController(endpoint.database, endpoint.context)
+		session.SetPairVerifyHandler(ctlr)
 	}
 
-	res, err := pair.HandleReaderForHandler(request.Body, controller)
+	var err error
+	var in util.Container
+	var out util.Container
+	var secSession crypto.Cryptographer
+
+	if in, err = util.NewTLV8ContainerFromReader(request.Body); err == nil {
+		out, err = ctlr.Handle(in)
+	}
 
 	if err != nil {
 		log.Println(err)
 		response.WriteHeader(http.StatusInternalServerError)
 	} else {
-		io.Copy(response, res)
-		// Setup secure session
-		if controller.KeyVerified() == true {
-			// Verification is done
-			// Switch to secure session
-			secureSession, err := crypto.NewSecureSessionFromSharedKey(controller.SharedKey())
-			if err != nil {
-				log.Println("[ERRO] Could not setup secure session.", err)
-			} else {
+		io.Copy(response, out.BytesBuffer())
+
+		// When key verification is done, switch to a secure session
+		// based on the negotiated shared session key
+		b := out.GetByte(pair.TagSequence)
+		switch pair.VerifyStepType(b) {
+		case pair.VerifyStepFinishResponse:
+			if secSession, err = crypto.NewSecureSessionFromSharedKey(ctlr.SharedKey()); err == nil {
 				log.Println("[VERB] Setup secure session")
+				session.SetCryptographer(secSession)
+			} else {
+				log.Println("[ERRO] Could not setup secure session.", err)
 			}
-			session.SetCryptographer(secureSession)
 		}
 	}
 }

netio/endpoint/pairings.go

@@ -1,8 +1,10 @@
 package endpoint
 
 import (
+	"github.com/brutella/hc/event"
 	"github.com/brutella/hc/netio"
 	"github.com/brutella/hc/netio/pair"
+	"github.com/brutella/hc/util"
 	"github.com/brutella/log"
 	"io"
 	"net/http"
@@ -15,27 +17,46 @@ type Pairing struct {
 	http.Handler
 
 	controller *pair.PairingController
+	emitter    event.Emitter
 }
 
 // NewPairing returns a new handler for pairing enpdoint
-func NewPairing(controller *pair.PairingController) *Pairing {
-	handler := Pairing{
+func NewPairing(controller *pair.PairingController, emitter event.Emitter) *Pairing {
+	endpoint := Pairing{
 		controller: controller,
+		emitter:    emitter,
 	}
 
-	return &handler
+	return &endpoint
 }
 
-func (handler *Pairing) ServeHTTP(response http.ResponseWriter, request *http.Request) {
+func (endpoint *Pairing) ServeHTTP(response http.ResponseWriter, request *http.Request) {
 	log.Printf("[VERB] %v POST /pairings", request.RemoteAddr)
 	response.Header().Set("Content-Type", netio.HTTPContentTypePairingTLV8)
 
-	res, err := pair.HandleReaderForHandler(request.Body, handler.controller)
+	var err error
+	var in util.Container
+	var out util.Container
+
+	if in, err = util.NewTLV8ContainerFromReader(request.Body); err == nil {
+		out, err = endpoint.controller.Handle(in)
+	}
 
 	if err != nil {
 		log.Println(err)
 		response.WriteHeader(http.StatusInternalServerError)
 	} else {
-		io.Copy(response, res)
+		io.Copy(response, out.BytesBuffer())
+
+		// Send events based on pairing method type
+		b := in.GetByte(pair.TagPairingMethod)
+		switch pair.PairMethodType(b) {
+		case pair.PairingMethodDelete: // pairing removed
+			endpoint.emitter.Emit(event.DeviceUnpaired{})
+
+		case pair.PairingMethodAdd: // pairing added
+			endpoint.emitter.Emit(event.DevicePaired{})
+
+		}
 	}
 }

netio/handler.go

@@ -16,7 +16,6 @@ type ContainerHandler interface {
 type PairVerifyHandler interface {
 	ContainerHandler
 	SharedKey() [32]byte
-	KeyVerified() bool
 }
 
 // A AccessoriesHandler returns a list of accessories as json.

netio/pair/errors.go

@@ -7,15 +7,15 @@ import (
 
 var errInvalidClientKeyLength = errors.New("Invalid client public key size")
 
-var errInvalidPairMethod = func(m pairMethodType) error {
+var errInvalidPairMethod = func(m PairMethodType) error {
 	return fmt.Errorf("Invalid pairing method %v\n", m)
 }
 
-var errInvalidPairStep = func(t pairStepType) error {
+var errInvalidPairStep = func(t PairStepType) error {
 	return fmt.Errorf("Invalid pairing step %v\n", t)
 }
 
-var errInvalidInternalPairStep = func(t pairStepType) error {
+var errInvalidInternalPairStep = func(t PairStepType) error {
 	return fmt.Errorf("Invalid internal pairing step %v\n", t)
 }