mynewt-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccoll...@apache.org
Subject [5/7] incubator-mynewt-newt git commit: MYNEWT-653 Use runtimeco gatt fork.
Date Fri, 03 Mar 2017 03:19:47 GMT
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/hci.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/hci.go b/newtmgr/vendor/github.com/runtimeco/gatt/linux/hci.go
new file mode 100644
index 0000000..967680d
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/hci.go
@@ -0,0 +1,400 @@
+package linux
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"sync"
+
+	"github.com/runtimeco/gatt/linux/cmd"
+	"github.com/runtimeco/gatt/linux/evt"
+)
+
+type HCI struct {
+	AcceptMasterHandler  func(pd *PlatData)
+	AcceptSlaveHandler   func(pd *PlatData)
+	AdvertisementHandler func(pd *PlatData)
+
+	d io.ReadWriteCloser
+	c *cmd.Cmd
+	e *evt.Evt
+
+	plist   map[bdaddr]*PlatData
+	plistmu *sync.Mutex
+
+	bufCnt  chan struct{}
+	bufSize int
+
+	maxConn int
+	connsmu *sync.Mutex
+	conns   map[uint16]*conn
+
+	adv   bool
+	advmu *sync.Mutex
+}
+
+type bdaddr [6]byte
+
+type PlatData struct {
+	Name        string
+	AddressType uint8
+	Address     [6]byte
+	Data        []byte
+	Connectable bool
+	RSSI        int8
+
+	Conn io.ReadWriteCloser
+}
+
+func NewHCI(devID int, chk bool, maxConn int) (*HCI, error) {
+	d, err := newDevice(devID, chk)
+	if err != nil {
+		return nil, err
+	}
+	c := cmd.NewCmd(d)
+	e := evt.NewEvt()
+
+	h := &HCI{
+		d: d,
+		c: c,
+		e: e,
+
+		plist:   make(map[bdaddr]*PlatData),
+		plistmu: &sync.Mutex{},
+
+		bufCnt:  make(chan struct{}, 15-1),
+		bufSize: 27,
+
+		maxConn: maxConn,
+		connsmu: &sync.Mutex{},
+		conns:   map[uint16]*conn{},
+
+		advmu: &sync.Mutex{},
+	}
+
+	e.HandleEvent(evt.LEMeta, evt.HandlerFunc(h.handleLEMeta))
+	e.HandleEvent(evt.DisconnectionComplete, evt.HandlerFunc(h.handleDisconnectionComplete))
+	e.HandleEvent(evt.NumberOfCompletedPkts, evt.HandlerFunc(h.handleNumberOfCompletedPkts))
+	e.HandleEvent(evt.CommandComplete, evt.HandlerFunc(c.HandleComplete))
+	e.HandleEvent(evt.CommandStatus, evt.HandlerFunc(c.HandleStatus))
+
+	go h.mainLoop()
+	h.resetDevice()
+	return h, nil
+}
+
+func (h *HCI) Close() error {
+	for _, c := range h.conns {
+		c.Close()
+	}
+	return h.d.Close()
+}
+
+func (h *HCI) SetAdvertiseEnable(en bool) error {
+	h.advmu.Lock()
+	h.adv = en
+	h.advmu.Unlock()
+	return h.setAdvertiseEnable(en)
+}
+
+func (h *HCI) setAdvertiseEnable(en bool) error {
+	h.advmu.Lock()
+	defer h.advmu.Unlock()
+	if en && h.adv && (len(h.conns) == h.maxConn) {
+		return nil
+	}
+	return h.c.SendAndCheckResp(
+		cmd.LESetAdvertiseEnable{
+			AdvertisingEnable: btoi(en),
+		}, []byte{0x00})
+}
+
+func (h *HCI) SendCmdWithAdvOff(c cmd.CmdParam) error {
+	h.setAdvertiseEnable(false)
+	err := h.c.SendAndCheckResp(c, nil)
+	if h.adv {
+		h.setAdvertiseEnable(true)
+	}
+	return err
+}
+
+func (h *HCI) SetScanEnable(en bool, dup bool) error {
+	return h.c.SendAndCheckResp(
+		cmd.LESetScanEnable{
+			LEScanEnable:     btoi(en),
+			FilterDuplicates: btoi(!dup),
+		}, []byte{0x00})
+}
+
+func (h *HCI) Connect(pd *PlatData) error {
+	h.c.Send(
+		cmd.LECreateConn{
+			LEScanInterval:        0x0004,         // N x 0.625ms
+			LEScanWindow:          0x0004,         // N x 0.625ms
+			InitiatorFilterPolicy: 0x00,           // white list not used
+			PeerAddressType:       pd.AddressType, // public or random
+			PeerAddress:           pd.Address,     //
+			OwnAddressType:        0x00,           // public
+			ConnIntervalMin:       6,         // N x 0.125ms
+			ConnIntervalMax:       7,         // N x 0.125ms
+			ConnLatency:           0x0000,         //
+			SupervisionTimeout:    0x00100,         // N x 10ms
+			MinimumCELength:       0x0000,         // N x 0.625ms
+			MaximumCELength:       0x0000,         // N x 0.625ms
+		})
+	return nil
+}
+
+func (h *HCI) CancelConnection(pd *PlatData) error {
+	return pd.Conn.Close()
+}
+
+func (h *HCI) SendRawCommand(c cmd.CmdParam) ([]byte, error) {
+	return h.c.Send(c)
+}
+
+func btoi(b bool) uint8 {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+func (h *HCI) mainLoop() {
+	b := make([]byte, 4096)
+	for {
+		n, err := h.d.Read(b)
+		if err != nil {
+			return
+		}
+		if n == 0 {
+			return
+		}
+		p := make([]byte, n)
+		copy(p, b)
+		h.handlePacket(p)
+	}
+}
+
+func (h *HCI) handlePacket(b []byte) {
+	t, b := packetType(b[0]), b[1:]
+	var err error
+	switch t {
+	case typCommandPkt:
+		op := uint16(b[0]) | uint16(b[1])<<8
+		log.Printf("unmanaged cmd: opcode (%04x) [ % X ]\n", op, b)
+	case typACLDataPkt:
+		err = h.handleL2CAP(b)
+	case typSCODataPkt:
+		err = fmt.Errorf("SCO packet not supported")
+	case typEventPkt:
+		go func() {
+			err := h.e.Dispatch(b)
+			if err != nil {
+				log.Printf("hci: %s, [ % X]", err, b)
+			}
+		}()
+	case typVendorPkt:
+		err = fmt.Errorf("Vendor packet not supported")
+	default:
+		log.Fatalf("Unknown event: 0x%02X [ % X ]\n", t, b)
+	}
+	if err != nil {
+		log.Printf("hci: %s, [ % X]", err, b)
+	}
+}
+
+func (h *HCI) resetDevice() error {
+	seq := []cmd.CmdParam{
+		cmd.Reset{},
+		cmd.SetEventMask{EventMask: 0x3dbff807fffbffff},
+		cmd.LESetEventMask{LEEventMask: 0x000000000000001F},
+		cmd.WriteSimplePairingMode{SimplePairingMode: 1},
+		cmd.WriteLEHostSupported{LESupportedHost: 1, SimultaneousLEHost: 0},
+		cmd.WriteInquiryMode{InquiryMode: 2},
+		cmd.WritePageScanType{PageScanType: 1},
+		cmd.WriteInquiryScanType{ScanType: 1},
+		cmd.WriteClassOfDevice{ClassOfDevice: [3]byte{0x40, 0x02, 0x04}},
+		cmd.WritePageTimeout{PageTimeout: 0x2000},
+		cmd.WriteDefaultLinkPolicy{DefaultLinkPolicySettings: 0x5},
+		cmd.HostBufferSize{
+			HostACLDataPacketLength:            0x1000,
+			HostSynchronousDataPacketLength:    0xff,
+			HostTotalNumACLDataPackets:         0x0014,
+			HostTotalNumSynchronousDataPackets: 0x000a},
+		cmd.LESetScanParameters{
+			LEScanType:           0x01,   // [0x00]: passive, 0x01: active
+			LEScanInterval:       0x0010, // [0x10]: 0.625ms * 16
+			LEScanWindow:         0x0010, // [0x10]: 0.625ms * 16
+			OwnAddressType:       0x00,   // [0x00]: public, 0x01: random
+			ScanningFilterPolicy: 0x00,   // [0x00]: accept all, 0x01: ignore non-white-listed.
+		},
+	}
+	for _, s := range seq {
+		if err := h.c.SendAndCheckResp(s, []byte{0x00}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (h *HCI) handleAdvertisement(b []byte) {
+	// If no one is interested, don't bother.
+	if h.AdvertisementHandler == nil {
+		return
+	}
+	ep := &evt.LEAdvertisingReportEP{}
+	if err := ep.Unmarshal(b); err != nil {
+		return
+	}
+	for i := 0; i < int(ep.NumReports); i++ {
+		addr := bdaddr(ep.Address[i])
+		et := ep.EventType[i]
+		connectable := et == advInd || et == advDirectInd
+		scannable := et == advInd || et == advScanInd
+
+		if et == scanRsp {
+			h.plistmu.Lock()
+			pd, ok := h.plist[addr]
+			h.plistmu.Unlock()
+			if ok {
+				pd.Data = append(pd.Data, ep.Data[i]...)
+				h.AdvertisementHandler(pd)
+			}
+			continue
+		}
+
+		pd := &PlatData{
+			AddressType: ep.AddressType[i],
+			Address:     ep.Address[i],
+			Data:        ep.Data[i],
+			Connectable: connectable,
+			RSSI:        ep.RSSI[i],
+		}
+		h.plistmu.Lock()
+		h.plist[addr] = pd
+		h.plistmu.Unlock()
+		if scannable {
+			continue
+		}
+		h.AdvertisementHandler(pd)
+	}
+}
+
+func (h *HCI) handleNumberOfCompletedPkts(b []byte) error {
+	ep := &evt.NumberOfCompletedPktsEP{}
+	if err := ep.Unmarshal(b); err != nil {
+		return err
+	}
+	for _, r := range ep.Packets {
+		for i := 0; i < int(r.NumOfCompletedPkts); i++ {
+			<-h.bufCnt
+		}
+	}
+	return nil
+}
+
+func (h *HCI) handleConnection(b []byte) {
+	ep := &evt.LEConnectionCompleteEP{}
+	if err := ep.Unmarshal(b); err != nil {
+		return // FIXME
+	}
+	hh := ep.ConnectionHandle
+	c := newConn(h, hh)
+	h.connsmu.Lock()
+	h.conns[hh] = c
+	h.connsmu.Unlock()
+	h.setAdvertiseEnable(true)
+
+	// FIXME: sloppiness. This call should be called by the package user once we
+	// flesh out the support of l2cap signaling packets (CID:0x0001,0x0005)
+	if ep.ConnLatency != 0 || ep.ConnInterval > 0x18 {
+		c.updateConnection()
+	}
+
+	// master connection
+	if ep.Role == 0x01 {
+		pd := &PlatData{
+			Address: ep.PeerAddress,
+			Conn:    c,
+		}
+		h.AcceptMasterHandler(pd)
+		return
+	}
+	h.plistmu.Lock()
+	pd := h.plist[ep.PeerAddress]
+	h.plistmu.Unlock()
+	pd.Conn = c
+	h.AcceptSlaveHandler(pd)
+}
+
+func (h *HCI) handleDisconnectionComplete(b []byte) error {
+	ep := &evt.DisconnectionCompleteEP{}
+	if err := ep.Unmarshal(b); err != nil {
+		return err
+	}
+	hh := ep.ConnectionHandle
+	h.connsmu.Lock()
+	defer h.connsmu.Unlock()
+	c, found := h.conns[hh]
+	if !found {
+		// should not happen, just be cautious for now.
+		log.Printf("l2conn: disconnecting a disconnected 0x%04X connection", hh)
+		return nil
+	}
+	delete(h.conns, hh)
+	close(c.aclc)
+	h.setAdvertiseEnable(true)
+	return nil
+}
+
+func (h *HCI) handleLEMeta(b []byte) error {
+	code := evt.LEEventCode(b[0])
+	switch code {
+	case evt.LEConnectionComplete:
+		go h.handleConnection(b)
+	case evt.LEConnectionUpdateComplete:
+		// anything to do here?
+	case evt.LEAdvertisingReport:
+		go h.handleAdvertisement(b)
+	// case evt.LEReadRemoteUsedFeaturesComplete:
+	// case evt.LELTKRequest:
+	// case evt.LERemoteConnectionParameterRequest:
+	default:
+		return fmt.Errorf("Unhandled LE event: %s, [ % X ]", code, b)
+	}
+	return nil
+}
+
+func (h *HCI) handleL2CAP(b []byte) error {
+        a := &aclData{}
+	if err := a.unmarshal(b); err != nil {
+		return err
+	}
+	h.connsmu.Lock()
+	defer h.connsmu.Unlock()
+	c, found := h.conns[a.attr]
+
+        if a.flags != 0x002 {
+	    if !found {
+		    // should not happen, just be cautious for now.
+		    log.Printf("l2conn: got data for disconnected handle: 0x%04x", a.attr)
+		    return nil
+	        if len(a.b) < 4 {
+		    log.Printf("l2conn: l2cap packet is too short/corrupt, length is %d", len(a.b))
+		    return nil
+	        }
+	        cid := uint16(a.b[2]) | (uint16(a.b[3]) << 8)
+	        if cid == 5 {
+		    c.handleSignal(a)
+		    return nil
+	        }
+            }
+        }
+	c.aclc <- a
+	return nil
+}
+
+func (h *HCI) trace(fmt string, v ...interface{}) {
+	log.Printf(fmt, v)
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/l2cap.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/l2cap.go b/newtmgr/vendor/github.com/runtimeco/gatt/linux/l2cap.go
new file mode 100644
index 0000000..daca82f
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/l2cap.go
@@ -0,0 +1,174 @@
+package linux
+
+import (
+	"fmt"
+	"io"
+	"log"
+
+	"github.com/runtimeco/gatt/linux/cmd"
+)
+
+type aclData struct {
+	attr  uint16
+	flags uint8
+	dlen  uint16
+	b     []byte
+}
+
+func (a *aclData) unmarshal(b []byte) error {
+	if len(b) < 4 {
+		return fmt.Errorf("malformed acl packet")
+	}
+	attr := uint16(b[0]) | (uint16(b[1]&0x0f) << 8)
+	flags := b[1] >> 4
+	dlen := uint16(b[2]) | (uint16(b[3]) << 8)
+	if len(b) != 4+int(dlen) {
+		return fmt.Errorf("malformed acl packet")
+	}
+
+	*a = aclData{attr: attr, flags: flags, dlen: dlen, b: b[4:]}
+	return nil
+}
+
+type conn struct {
+	hci  *HCI
+	attr uint16
+	aclc chan *aclData
+}
+
+func newConn(hci *HCI, hh uint16) *conn {
+	return &conn{
+		hci:  hci,
+		attr: hh,
+		aclc: make(chan *aclData),
+	}
+}
+
+func (c *conn) updateConnection() (int, error) {
+	b := []byte{
+		0x12,       // Code (Connection Param Update)
+		0x02,       // ID
+		0x08, 0x00, // DataLength
+		0x08, 0x00, // IntervalMin
+		0x18, 0x00, // IntervalMax
+		0x00, 0x00, // SlaveLatency
+		0xC8, 0x00} // TimeoutMultiplier
+	return c.write(0x05, b)
+}
+
+// write writes the l2cap payload to the controller.
+// It first prepend the l2cap header (4-bytes), and diassemble the payload
+// if it is larger than the HCI LE buffer size that the conntroller can support.
+func (c *conn) write(cid int, b []byte) (int, error) {
+	flag := uint8(0) // ACL data continuation flag
+	tlen := len(b)   // Total length of the l2cap payload
+
+	// log.Printf("W: [ % X ]", b)
+	w := append(
+		[]byte{
+			0,    // packet type
+			0, 0, // attr
+			0, 0, // dlen
+			uint8(tlen), uint8(tlen >> 8), // l2cap header
+			uint8(cid), uint8(cid >> 8), // l2cap header
+		}, b...)
+
+	n := 4 + tlen // l2cap header + l2cap payload
+	for n > 0 {
+		dlen := n
+		if dlen > c.hci.bufSize {
+			dlen = c.hci.bufSize
+		}
+		w[0] = 0x02 // packetTypeACL
+		w[1] = uint8(c.attr)
+		w[2] = uint8(c.attr>>8) | flag
+		w[3] = uint8(dlen)
+		w[4] = uint8(dlen >> 8)
+
+		// make sure we don't send more buffers than the controller can handdle
+		c.hci.bufCnt <- struct{}{}
+
+		c.hci.d.Write(w[:5+dlen])
+		w = w[dlen:] // advance the pointer to the next segment, if any.
+		flag = 0x10  // the rest of iterations attr continued segments, if any.
+		n -= dlen
+	}
+
+	return len(b), nil
+}
+
+func (c *conn) Read(b []byte) (int, error) {
+	a, ok := <-c.aclc
+	if !ok {
+		return 0, io.EOF
+	}
+	tlen := int(uint16(a.b[0]) | uint16(a.b[1])<<8)
+	if tlen > len(b) {
+		return 0, io.ErrShortBuffer
+	}
+	d := a.b[4:] // skip l2cap header
+	copy(b, d)
+	n := len(d)
+
+	// Keep receiving and reassemble continued l2cap segments
+	for n != tlen {
+		if a, ok = <-c.aclc; !ok || (a.flags&0x1) == 0 {
+			return n, io.ErrUnexpectedEOF
+		}
+		copy(b[n:], a.b)
+		n += len(a.b)
+	}
+	// log.Printf("R: [ % X ]", b[:n])
+	return n, nil
+}
+
+func (c *conn) Write(b []byte) (int, error) {
+	return c.write(0x04, b)
+}
+
+// Close disconnects the connection by sending HCI disconnect command to the device.
+func (c *conn) Close() error {
+	h := c.hci
+	hh := c.attr
+	h.connsmu.Lock()
+	defer h.connsmu.Unlock()
+	_, found := h.conns[hh]
+	if !found {
+		// log.Printf("l2conn: 0x%04x already disconnected", hh)
+		return nil
+	}
+	if err, _ := h.c.Send(cmd.Disconnect{ConnectionHandle: hh, Reason: 0x13}); err != nil {
+		return fmt.Errorf("l2conn: failed to disconnect, %s", err)
+	}
+	return nil
+}
+
+// Signal Packets
+// 0x00 Reserved								Any
+// 0x01 Command reject							0x0001 and 0x0005
+// 0x02 Connection request						0x0001
+// 0x03 Connection response 					0x0001
+// 0x04 Configure request						0x0001
+// 0x05 Configure response						0x0001
+// 0x06 Disconnection request					0x0001 and 0x0005
+// 0x07 Disconnection response					0x0001 and 0x0005
+// 0x08 Echo request							0x0001
+// 0x09 Echo response							0x0001
+// 0x0A Information request						0x0001
+// 0x0B Information response					0x0001
+// 0x0C Create Channel request					0x0001
+// 0x0D Create Channel response					0x0001
+// 0x0E Move Channel request					0x0001
+// 0x0F Move Channel response					0x0001
+// 0x10 Move Channel Confirmation				0x0001
+// 0x11 Move Channel Confirmation response		0x0001
+// 0x12 Connection Parameter Update request		0x0005
+// 0x13 Connection Parameter Update response	0x0005
+// 0x14 LE Credit Based Connection request		0x0005
+// 0x15 LE Credit Based Connection response		0x0005
+// 0x16 LE Flow Control Credit					0x0005
+func (c *conn) handleSignal(a *aclData) error {
+	log.Printf("ignore l2cap signal:[ % X ]", a.b)
+	// FIXME: handle LE signaling channel (CID: 5)
+	return nil
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/asm.s
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/asm.s b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/asm.s
new file mode 100644
index 0000000..d4ca868
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/asm.s
@@ -0,0 +1,8 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "textflag.h"
+
+TEXT ·use(SB),NOSPLIT,$0
+	RET

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/asm_linux_386.s
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/asm_linux_386.s b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/asm_linux_386.s
new file mode 100644
index 0000000..5d3ad9a
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/asm_linux_386.s
@@ -0,0 +1,33 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "textflag.h"
+
+//
+// System calls for 386, Linux
+//
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT	·Syscall(SB),NOSPLIT,$0-28
+	JMP	syscall·Syscall(SB)
+
+TEXT	·Syscall6(SB),NOSPLIT,$0-40
+	JMP	syscall·Syscall6(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0-28
+	JMP	syscall·RawSyscall(SB)
+
+TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
+	JMP	syscall·RawSyscall6(SB)
+
+TEXT ·socketcall(SB),NOSPLIT,$0-36
+	JMP	syscall·socketcall(SB)
+
+TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
+	JMP	syscall·rawsocketcall(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-28
+	JMP	syscall·seek(SB)

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket.go b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket.go
new file mode 100644
index 0000000..ffc49a6
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket.go
@@ -0,0 +1,121 @@
+// Package socket implements a minimal set of function of the HCI Socket,
+// which is not yet supported by the Go standard library. Most of the code
+// follow suit the existing code in the standard library. Once it gets
+// supported officially, we can get rid of this package entirely.
+
+package socket
+
+import (
+	"errors"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+// Bluetooth Protocols
+const (
+	BTPROTO_L2CAP  = 0
+	BTPROTO_HCI    = 1
+	BTPROTO_SCO    = 2
+	BTPROTO_RFCOMM = 3
+	BTPROTO_BNEP   = 4
+	BTPROTO_CMTP   = 5
+	BTPROTO_HIDP   = 6
+	BTPROTO_AVDTP  = 7
+)
+
+const (
+	HCI_CHANNEL_RAW     = 0
+	HCI_CHANNEL_USER    = 1
+	HCI_CHANNEL_MONITOR = 2
+	HCI_CHANNEL_CONTROL = 3
+)
+
+var (
+	ErrSocketOpenFailed  = errors.New("unable to open bluetooth socket to device")
+	ErrSocketBindTimeout = errors.New("timeout occured binding to bluetooth device")
+)
+
+type _Socklen uint32
+
+type Sockaddr interface {
+	sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs
+}
+
+type rawSockaddrHCI struct {
+	Family  uint16
+	Dev     uint16
+	Channel uint16
+}
+
+type SockaddrHCI struct {
+	Dev     int
+	Channel uint16
+	raw     rawSockaddrHCI
+}
+
+const sizeofSockaddrHCI = unsafe.Sizeof(rawSockaddrHCI{})
+
+func (sa *SockaddrHCI) sockaddr() (unsafe.Pointer, _Socklen, error) {
+	if sa.Dev < 0 || sa.Dev > 0xFFFF {
+		return nil, 0, syscall.EINVAL
+	}
+	if sa.Channel < 0 || sa.Channel > 0xFFFF {
+		return nil, 0, syscall.EINVAL
+	}
+	sa.raw.Family = AF_BLUETOOTH
+	sa.raw.Dev = uint16(sa.Dev)
+	sa.raw.Channel = sa.Channel
+	return unsafe.Pointer(&sa.raw), _Socklen(sizeofSockaddrHCI), nil
+}
+
+func Socket(domain, typ, proto int) (int, error) {
+	for i := 0; i < 5; i++ {
+		if fd, err := syscall.Socket(domain, typ, proto); err == nil || err != syscall.EBUSY {
+			return fd, err
+		}
+		time.Sleep(time.Second)
+	}
+	return 0, ErrSocketOpenFailed
+}
+
+func Bind(fd int, sa Sockaddr) (err error) {
+	ptr, n, err := sa.sockaddr()
+	if err != nil {
+		return err
+	}
+	for i := 0; i < 5; i++ {
+		if err = bind(fd, ptr, n); err == nil || err != syscall.EBUSY {
+			return err
+		}
+		time.Sleep(time.Second)
+	}
+	return ErrSocketBindTimeout
+}
+
+// Socket Level
+const (
+	SOL_HCI    = 0
+	SOL_L2CAP  = 6
+	SOL_SCO    = 17
+	SOL_RFCOMM = 18
+
+	SOL_BLUETOOTH = 274
+)
+
+// HCI Socket options
+const (
+	HCI_DATA_DIR   = 1
+	HCI_FILTER     = 2
+	HCI_TIME_STAMP = 3
+)
+
+type HCIFilter struct {
+	TypeMask  uint32
+	EventMask [2]uint32
+	opcode    uint16
+}
+
+func SetsockoptFilter(fd int, f *HCIFilter) (err error) {
+	return setsockopt(fd, SOL_HCI, HCI_FILTER, unsafe.Pointer(f), unsafe.Sizeof(*f))
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_common.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_common.go b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_common.go
new file mode 100644
index 0000000..b01ceeb
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_common.go
@@ -0,0 +1,24 @@
+// +build !386
+
+package socket
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
+	_, _, e1 := syscall.Syscall(syscall.SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
+	_, _, e1 := syscall.Syscall6(syscall.SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_darwin.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_darwin.go b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_darwin.go
new file mode 100644
index 0000000..abb96a5
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_darwin.go
@@ -0,0 +1,6 @@
+// +build darwin
+
+package socket
+
+// For compile time compatibility
+const AF_BLUETOOTH = 0

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_linux.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_linux.go b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_linux.go
new file mode 100644
index 0000000..4793915
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_linux.go
@@ -0,0 +1,7 @@
+// +build linux
+
+package socket
+
+import "syscall"
+
+const AF_BLUETOOTH = syscall.AF_BLUETOOTH

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_linux_386.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_linux_386.go b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_linux_386.go
new file mode 100644
index 0000000..05ca65c
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/socket/socket_linux_386.go
@@ -0,0 +1,31 @@
+// +build linux,386
+
+package socket
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+const (
+	BIND         = 2
+	SETSOCKETOPT = 14
+)
+
+func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
+	_, e1 := socketcall(BIND, uintptr(s), uintptr(addr), uintptr(addrlen), 0, 0, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
+	_, e1 := socketcall(SETSOCKETOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), vallen, 0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
+func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno)

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/linux/util/util.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/linux/util/util.go b/newtmgr/vendor/github.com/runtimeco/gatt/linux/util/util.go
new file mode 100644
index 0000000..4933008
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/linux/util/util.go
@@ -0,0 +1,16 @@
+package util
+
+import "encoding/binary"
+
+type order struct{ binary.ByteOrder }
+
+var Order = order{binary.LittleEndian}
+
+func (o order) Int8(b []byte) int8   { return int8(b[0]) }
+func (o order) Uint8(b []byte) uint8 { return b[0] }
+func (o order) MAC(b []byte) [6]byte { return [6]byte{b[5], b[4], b[3], b[2], b[1], b[0]} }
+
+func (o order) PutUint8(b []byte, v uint8) { b[0] = v }
+func (o order) PutMAC(b []byte, m [6]byte) {
+	b[0], b[1], b[2], b[3], b[4], b[5] = m[5], m[4], m[3], m[2], m[1], m[0]
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/option_darwin.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/option_darwin.go b/newtmgr/vendor/github.com/runtimeco/gatt/option_darwin.go
new file mode 100644
index 0000000..617db21
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/option_darwin.go
@@ -0,0 +1,15 @@
+package gatt
+
+const (
+	CentralManager    = 0 // Client functions (default)
+	PeripheralManager = 1 // Server functions
+)
+
+// MacDeviceRole specify the XPC connection type to connect blued.
+// THis option can only be used with NewDevice on OS X implementation.
+func MacDeviceRole(r int) Option {
+	return func(d Device) error {
+		d.(*device).role = r
+		return nil
+	}
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/option_linux.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/option_linux.go b/newtmgr/vendor/github.com/runtimeco/gatt/option_linux.go
new file mode 100644
index 0000000..bf2360c
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/option_linux.go
@@ -0,0 +1,87 @@
+package gatt
+
+import (
+	"errors"
+	"io"
+
+	"github.com/runtimeco/gatt/linux/cmd"
+)
+
+// LnxDeviceID specifies which HCI device to use.
+// If n is set to -1, all the available HCI devices will be probed.
+// If chk is set to true, LnxDeviceID checks the LE support in the feature list of the HCI device.
+// This is to filter devices that does not support LE. In case some LE driver that doesn't correctly
+// set the LE support in its feature list, user can turn off the check.
+// This option can only be used with NewDevice on Linux implementation.
+func LnxDeviceID(n int, chk bool) Option {
+	return func(d Device) error {
+		d.(*device).devID = n
+		d.(*device).chkLE = chk
+		return nil
+	}
+}
+
+// LnxMaxConnections is an optional parameter.
+// If set, it overrides the default max connections supported.
+// This option can only be used with NewDevice on Linux implementation.
+func LnxMaxConnections(n int) Option {
+	return func(d Device) error {
+		d.(*device).maxConn = n
+		return nil
+	}
+}
+
+// LnxSetAdvertisingEnable sets the advertising data to the HCI device.
+// This option can be used with Option on Linux implementation.
+func LnxSetAdvertisingEnable(en bool) Option {
+	return func(d Device) error {
+		dd := d.(*device)
+		if dd == nil {
+			return errors.New("device is not initialized")
+		}
+		if err := dd.update(); err != nil {
+			return err
+		}
+		return dd.hci.SetAdvertiseEnable(en)
+	}
+}
+
+// LnxSetAdvertisingData sets the advertising data to the HCI device.
+// This option can be used with NewDevice or Option on Linux implementation.
+func LnxSetAdvertisingData(c *cmd.LESetAdvertisingData) Option {
+	return func(d Device) error {
+		d.(*device).advData = c
+		return nil
+	}
+}
+
+// LnxSetScanResponseData sets the scan response data to the HXI device.
+// This option can be used with NewDevice or Option on Linux implementation.
+func LnxSetScanResponseData(c *cmd.LESetScanResponseData) Option {
+	return func(d Device) error {
+		d.(*device).scanResp = c
+		return nil
+	}
+}
+
+// LnxSetAdvertisingParameters sets the advertising parameters to the HCI device.
+// This option can be used with NewDevice or Option on Linux implementation.
+func LnxSetAdvertisingParameters(c *cmd.LESetAdvertisingParameters) Option {
+	return func(d Device) error {
+		d.(*device).advParam = c
+		return nil
+	}
+}
+
+// LnxSendHCIRawCommand sends a raw command to the HCI device
+// This option can be used with NewDevice or Option on Linux implementation.
+func LnxSendHCIRawCommand(c cmd.CmdParam, rsp io.Writer) Option {
+	return func(d Device) error {
+		b, err := d.(*device).SendHCIRawCommand(c)
+		if rsp == nil {
+			return err
+		}
+		rsp.Write(b)
+		return err
+	}
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/peripheral.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/peripheral.go b/newtmgr/vendor/github.com/runtimeco/gatt/peripheral.go
new file mode 100644
index 0000000..36ad578
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/peripheral.go
@@ -0,0 +1,102 @@
+package gatt
+
+import (
+	"errors"
+	"sync"
+)
+
+// Peripheral is the interface that represent a remote peripheral device.
+type Peripheral interface {
+	// Device returns the underlying device.
+	Device() Device
+
+	// ID is the platform specific unique ID of the remote peripheral, e.g. MAC for Linux, Peripheral UUID for MacOS.
+	ID() string
+
+	// Name returns the name of the remote peripheral.
+	// This can be the advertised name, if exists, or the GAP device name, which takes priority
+	Name() string
+
+	// Services returnns the services of the remote peripheral which has been discovered.
+	Services() []*Service
+
+	// DiscoverServices discover the specified services of the remote peripheral.
+	// If the specified services is set to nil, all the available services of the remote peripheral are returned.
+	DiscoverServices(s []UUID) ([]*Service, error)
+
+	// DiscoverIncludedServices discovers the specified included services of a service.
+	// If the specified services is set to nil, all the included services of the service are returned.
+	DiscoverIncludedServices(ss []UUID, s *Service) ([]*Service, error)
+
+	// DiscoverCharacteristics discovers the specified characteristics of a service.
+	// If the specified characterstics is set to nil, all the characteristic of the service are returned.
+	DiscoverCharacteristics(c []UUID, s *Service) ([]*Characteristic, error)
+
+	// DiscoverDescriptors discovers the descriptors of a characteristic.
+	// If the specified descriptors is set to nil, all the descriptors of the characteristic are returned.
+	DiscoverDescriptors(d []UUID, c *Characteristic) ([]*Descriptor, error)
+
+	// ReadCharacteristic retrieves the value of a specified characteristic.
+	ReadCharacteristic(c *Characteristic) ([]byte, error)
+
+	// ReadLongCharacteristic retrieves the value of a specified characteristic that is longer than the
+	// MTU.
+	ReadLongCharacteristic(c *Characteristic) ([]byte, error)
+
+	// ReadDescriptor retrieves the value of a specified characteristic descriptor.
+	ReadDescriptor(d *Descriptor) ([]byte, error)
+
+	// WriteCharacteristic writes the value of a characteristic.
+	WriteCharacteristic(c *Characteristic, b []byte, noRsp bool) error
+
+	// WriteDescriptor writes the value of a characteristic descriptor.
+	WriteDescriptor(d *Descriptor, b []byte) error
+
+	// SetNotifyValue sets notifications for the value of a specified characteristic.
+	SetNotifyValue(c *Characteristic, f func(*Characteristic, []byte, error)) error
+
+	// SetIndicateValue sets indications for the value of a specified characteristic.
+	SetIndicateValue(c *Characteristic, f func(*Characteristic, []byte, error)) error
+
+	// ReadRSSI retrieves the current RSSI value for the remote peripheral.
+	ReadRSSI() int
+
+	// SetMTU sets the mtu for the remote peripheral.
+	SetMTU(mtu uint16) error
+}
+
+type subscriber struct {
+	sub map[uint16]subscribefn
+	mu  *sync.Mutex
+}
+
+type subscribefn func([]byte, error)
+
+func newSubscriber() *subscriber {
+	return &subscriber{
+		sub: make(map[uint16]subscribefn),
+		mu:  &sync.Mutex{},
+	}
+}
+
+func (s *subscriber) subscribe(h uint16, f subscribefn) {
+	s.mu.Lock()
+	s.sub[h] = f
+	s.mu.Unlock()
+}
+
+func (s *subscriber) unsubscribe(h uint16) {
+	s.mu.Lock()
+	delete(s.sub, h)
+	s.mu.Unlock()
+}
+
+func (s *subscriber) fn(h uint16) subscribefn {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.sub[h]
+}
+
+var (
+	ErrInvalidLength = errors.New("invalid length")
+)

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/peripheral_darwin.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/peripheral_darwin.go b/newtmgr/vendor/github.com/runtimeco/gatt/peripheral_darwin.go
new file mode 100644
index 0000000..9174e61
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/peripheral_darwin.go
@@ -0,0 +1,277 @@
+package gatt
+
+import (
+	"errors"
+	"log"
+
+	"github.com/runtimeco/gatt/xpc"
+)
+
+type peripheral struct {
+	// NameChanged is called whenever the peripheral GAP Device name has changed.
+	NameChanged func(Peripheral)
+
+	// ServicesModified is called when one or more service of a peripheral have changed.
+	// A list of invalid service is provided in the parameter.
+	ServicesModified func(Peripheral, []*Service)
+
+	d    *device
+	svcs []*Service
+
+	sub *subscriber
+
+	id   xpc.UUID
+	name string
+
+	reqc  chan message
+	rspc  chan message
+	quitc chan struct{}
+}
+
+func NewPeripheral(u UUID) Peripheral { return &peripheral{id: xpc.UUID(u.b)} }
+
+func (p *peripheral) Device() Device       { return p.d }
+func (p *peripheral) ID() string           { return p.id.String() }
+func (p *peripheral) Name() string         { return p.name }
+func (p *peripheral) Services() []*Service { return p.svcs }
+
+func (p *peripheral) DiscoverServices(ss []UUID) ([]*Service, error) {
+	rsp := p.sendReq(45, xpc.Dict{
+		"kCBMsgArgDeviceUUID": p.id,
+		"kCBMsgArgUUIDs":      uuidSlice(ss),
+	})
+	if res := rsp.MustGetInt("kCBMsgArgResult"); res != 0 {
+		return nil, attEcode(res)
+	}
+	svcs := []*Service{}
+	for _, xss := range rsp["kCBMsgArgServices"].(xpc.Array) {
+		xs := xss.(xpc.Dict)
+		u := MustParseUUID(xs.MustGetHexBytes("kCBMsgArgUUID"))
+		h := uint16(xs.MustGetInt("kCBMsgArgServiceStartHandle"))
+		endh := uint16(xs.MustGetInt("kCBMsgArgServiceEndHandle"))
+		svcs = append(svcs, &Service{uuid: u, h: h, endh: endh})
+	}
+	p.svcs = svcs
+	return svcs, nil
+}
+
+func (p *peripheral) DiscoverIncludedServices(ss []UUID, s *Service) ([]*Service, error) {
+	rsp := p.sendReq(60, xpc.Dict{
+		"kCBMsgArgDeviceUUID":         p.id,
+		"kCBMsgArgServiceStartHandle": s.h,
+		"kCBMsgArgServiceEndHandle":   s.endh,
+		"kCBMsgArgUUIDs":              uuidSlice(ss),
+	})
+	if res := rsp.MustGetInt("kCBMsgArgResult"); res != 0 {
+		return nil, attEcode(res)
+	}
+	// TODO
+	return nil, notImplemented
+}
+
+func (p *peripheral) DiscoverCharacteristics(cs []UUID, s *Service) ([]*Characteristic, error) {
+	rsp := p.sendReq(62, xpc.Dict{
+		"kCBMsgArgDeviceUUID":         p.id,
+		"kCBMsgArgServiceStartHandle": s.h,
+		"kCBMsgArgServiceEndHandle":   s.endh,
+		"kCBMsgArgUUIDs":              uuidSlice(cs),
+	})
+	if res := rsp.MustGetInt("kCBMsgArgResult"); res != 0 {
+		return nil, attEcode(res)
+	}
+	for _, xcs := range rsp.MustGetArray("kCBMsgArgCharacteristics") {
+		xc := xcs.(xpc.Dict)
+		u := MustParseUUID(xc.MustGetHexBytes("kCBMsgArgUUID"))
+		ch := uint16(xc.MustGetInt("kCBMsgArgCharacteristicHandle"))
+		vh := uint16(xc.MustGetInt("kCBMsgArgCharacteristicValueHandle"))
+		props := Property(xc.MustGetInt("kCBMsgArgCharacteristicProperties"))
+		c := &Characteristic{uuid: u, svc: s, props: props, h: ch, vh: vh}
+		s.chars = append(s.chars, c)
+	}
+	return s.chars, nil
+}
+
+func (p *peripheral) DiscoverDescriptors(ds []UUID, c *Characteristic) ([]*Descriptor, error) {
+	rsp := p.sendReq(70, xpc.Dict{
+		"kCBMsgArgDeviceUUID":                p.id,
+		"kCBMsgArgCharacteristicHandle":      c.h,
+		"kCBMsgArgCharacteristicValueHandle": c.vh,
+		"kCBMsgArgUUIDs":                     uuidSlice(ds),
+	})
+	for _, xds := range rsp.MustGetArray("kCBMsgArgDescriptors") {
+		xd := xds.(xpc.Dict)
+		u := MustParseUUID(xd.MustGetHexBytes("kCBMsgArgUUID"))
+		h := uint16(xd.MustGetInt("kCBMsgArgDescriptorHandle"))
+		d := &Descriptor{uuid: u, char: c, h: h}
+		c.descs = append(c.descs, d)
+	}
+	return c.descs, nil
+}
+
+func (p *peripheral) ReadCharacteristic(c *Characteristic) ([]byte, error) {
+	rsp := p.sendReq(65, xpc.Dict{
+		"kCBMsgArgDeviceUUID":                p.id,
+		"kCBMsgArgCharacteristicHandle":      c.h,
+		"kCBMsgArgCharacteristicValueHandle": c.vh,
+	})
+	if res := rsp.MustGetInt("kCBMsgArgResult"); res != 0 {
+		return nil, attEcode(res)
+	}
+	b := rsp.MustGetBytes("kCBMsgArgData")
+	return b, nil
+}
+
+func (p *peripheral) ReadLongCharacteristic(c *Characteristic) ([]byte, error) {
+	return nil, errors.New("Not implemented")
+}
+
+func (p *peripheral) WriteCharacteristic(c *Characteristic, b []byte, noRsp bool) error {
+	args := xpc.Dict{
+		"kCBMsgArgDeviceUUID":                p.id,
+		"kCBMsgArgCharacteristicHandle":      c.h,
+		"kCBMsgArgCharacteristicValueHandle": c.vh,
+		"kCBMsgArgData":                      b,
+		"kCBMsgArgType":                      map[bool]int{false: 0, true: 1}[noRsp],
+	}
+	if noRsp {
+		p.sendCmd(66, args)
+		return nil
+	}
+	rsp := p.sendReq(65, args)
+	if res := rsp.MustGetInt("kCBMsgArgResult"); res != 0 {
+		return attEcode(res)
+	}
+	return nil
+}
+
+func (p *peripheral) ReadDescriptor(d *Descriptor) ([]byte, error) {
+	rsp := p.sendReq(77, xpc.Dict{
+		"kCBMsgArgDeviceUUID":       p.id,
+		"kCBMsgArgDescriptorHandle": d.h,
+	})
+	if res := rsp.MustGetInt("kCBMsgArgResult"); res != 0 {
+		return nil, attEcode(res)
+	}
+	b := rsp.MustGetBytes("kCBMsgArgData")
+	return b, nil
+}
+
+func (p *peripheral) WriteDescriptor(d *Descriptor, b []byte) error {
+	rsp := p.sendReq(78, xpc.Dict{
+		"kCBMsgArgDeviceUUID":       p.id,
+		"kCBMsgArgDescriptorHandle": d.h,
+		"kCBMsgArgData":             b,
+	})
+	if res := rsp.MustGetInt("kCBMsgArgResult"); res != 0 {
+		return attEcode(res)
+	}
+	return nil
+}
+
+func (p *peripheral) SetNotifyValue(c *Characteristic, f func(*Characteristic, []byte, error)) error {
+	set := 1
+	if f == nil {
+		set = 0
+	}
+	// To avoid race condition, registeration is handled before requesting the server.
+	if f != nil {
+		// Note: when notified, core bluetooth reports characteristic handle, not value's handle.
+		p.sub.subscribe(c.h, func(b []byte, err error) { f(c, b, err) })
+	}
+	rsp := p.sendReq(68, xpc.Dict{
+		"kCBMsgArgDeviceUUID":                p.id,
+		"kCBMsgArgCharacteristicHandle":      c.h,
+		"kCBMsgArgCharacteristicValueHandle": c.vh,
+		"kCBMsgArgState":                     set,
+	})
+	if res := rsp.MustGetInt("kCBMsgArgResult"); res != 0 {
+		return attEcode(res)
+	}
+	// To avoid race condition, unregisteration is handled after server responses.
+	if f == nil {
+		p.sub.unsubscribe(c.h)
+	}
+	return nil
+}
+
+func (p *peripheral) SetIndicateValue(c *Characteristic,
+	f func(*Characteristic, []byte, error)) error {
+	// TODO: Implement set indications logic for darwin (https://github.com/runtimeco/gatt/issues/32)
+	return nil
+}
+
+func (p *peripheral) ReadRSSI() int {
+	rsp := p.sendReq(43, xpc.Dict{"kCBMsgArgDeviceUUID": p.id})
+	return rsp.MustGetInt("kCBMsgArgData")
+}
+
+func (p *peripheral) SetMTU(mtu uint16) error {
+	return errors.New("Not implemented")
+}
+
+func uuidSlice(uu []UUID) [][]byte {
+	us := [][]byte{}
+	for _, u := range uu {
+		us = append(us, reverse(u.b))
+	}
+	return us
+}
+
+type message struct {
+	id   int
+	args xpc.Dict
+	rspc chan xpc.Dict
+}
+
+func (p *peripheral) sendCmd(id int, args xpc.Dict) {
+	p.reqc <- message{id: id, args: args}
+}
+
+func (p *peripheral) sendReq(id int, args xpc.Dict) xpc.Dict {
+	m := message{id: id, args: args, rspc: make(chan xpc.Dict)}
+	p.reqc <- m
+	return <-m.rspc
+}
+
+func (p *peripheral) loop() {
+	rspc := make(chan message)
+
+	go func() {
+		for {
+			select {
+			case req := <-p.reqc:
+				p.d.sendCBMsg(req.id, req.args)
+				if req.rspc == nil {
+					break
+				}
+				m := <-rspc
+				req.rspc <- m.args
+			case <-p.quitc:
+				return
+			}
+		}
+	}()
+
+	for {
+		select {
+		case rsp := <-p.rspc:
+			// Notification
+			if rsp.id == 71 && rsp.args.GetInt("kCBMsgArgIsNotification", 0) != 0 {
+				// While we're notified with the value's handle, blued reports the characteristic handle.
+				ch := uint16(rsp.args.MustGetInt("kCBMsgArgCharacteristicHandle"))
+				b := rsp.args.MustGetBytes("kCBMsgArgData")
+				f := p.sub.fn(ch)
+				if f == nil {
+					log.Printf("notified by unsubscribed handle")
+					// FIXME: should terminate the connection?
+				} else {
+					go f(b, nil)
+				}
+				break
+			}
+			rspc <- rsp
+		case <-p.quitc:
+			return
+		}
+	}
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/peripheral_linux.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/peripheral_linux.go b/newtmgr/vendor/github.com/runtimeco/gatt/peripheral_linux.go
new file mode 100644
index 0000000..43ec067
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/peripheral_linux.go
@@ -0,0 +1,448 @@
+package gatt
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"strings"
+
+	"github.com/runtimeco/gatt/linux"
+)
+
+type peripheral struct {
+	// NameChanged is called whenever the peripheral GAP device name has changed.
+	NameChanged func(*peripheral)
+
+	// ServicedModified is called when one or more service of a peripheral have changed.
+	// A list of invalid service is provided in the parameter.
+	ServicesModified func(*peripheral, []*Service)
+
+	d    *device
+	svcs []*Service
+
+	sub *subscriber
+
+	mtu uint16
+	l2c io.ReadWriteCloser
+
+	reqc  chan message
+	quitc chan struct{}
+
+	pd *linux.PlatData // platform specific data
+}
+
+func (p *peripheral) Device() Device       { return p.d }
+func (p *peripheral) ID() string           { return strings.ToUpper(net.HardwareAddr(p.pd.Address[:]).String()) }
+func (p *peripheral) Name() string         { return p.pd.Name }
+func (p *peripheral) Services() []*Service { return p.svcs }
+
+func finish(op byte, h uint16, b []byte) bool {
+	done := b[0] == attOpError && b[1] == op && b[2] == byte(h) && b[3] == byte(h>>8)
+	e := attEcode(b[4])
+	if e != attEcodeAttrNotFound {
+		// log.Printf("unexpected protocol error: %s", e)
+		// FIXME: terminate the connection
+	}
+	return done
+}
+
+func (p *peripheral) DiscoverServices(s []UUID) ([]*Service, error) {
+	// TODO: implement the UUID filters
+	// p.pd.Conn.Write([]byte{0x02, 0x87, 0x00}) // MTU
+	done := false
+	start := uint16(0x0001)
+	for !done {
+		op := byte(attOpReadByGroupReq)
+		b := make([]byte, 7)
+		b[0] = op
+		binary.LittleEndian.PutUint16(b[1:3], start)
+		binary.LittleEndian.PutUint16(b[3:5], 0xFFFF)
+		binary.LittleEndian.PutUint16(b[5:7], 0x2800)
+
+		b = p.sendReq(op, b)
+		if finish(op, start, b) {
+			break
+		}
+		b = b[1:]
+		l, b := int(b[0]), b[1:]
+		switch {
+		case l == 6 && (len(b)%6 == 0):
+		case l == 20 && (len(b)%20 == 0):
+		default:
+			return nil, ErrInvalidLength
+		}
+
+		for len(b) != 0 {
+			h := binary.LittleEndian.Uint16(b[:2])
+			endh := binary.LittleEndian.Uint16(b[2:4])
+			s := &Service{
+				uuid: UUID{b[4:l]},
+				h:    h,
+				endh: endh,
+			}
+			p.svcs = append(p.svcs, s)
+			b = b[l:]
+			done = endh == 0xFFFF
+			start = endh + 1
+		}
+	}
+	return p.svcs, nil
+}
+
+func (p *peripheral) DiscoverIncludedServices(ss []UUID, s *Service) ([]*Service, error) {
+	// TODO
+	return nil, nil
+}
+
+func (p *peripheral) DiscoverCharacteristics(cs []UUID, s *Service) ([]*Characteristic, error) {
+	// TODO: implement the UUID filters
+	done := false
+	start := s.h
+	var prev *Characteristic
+	for !done {
+		op := byte(attOpReadByTypeReq)
+		b := make([]byte, 7)
+		b[0] = op
+		binary.LittleEndian.PutUint16(b[1:3], start)
+		binary.LittleEndian.PutUint16(b[3:5], s.endh)
+		binary.LittleEndian.PutUint16(b[5:7], 0x2803)
+
+		b = p.sendReq(op, b)
+		if finish(op, start, b) {
+			break
+		}
+		b = b[1:]
+
+		l, b := int(b[0]), b[1:]
+		switch {
+		case l == 7 && (len(b)%7 == 0):
+		case l == 21 && (len(b)%21 == 0):
+		default:
+			return nil, ErrInvalidLength
+		}
+
+		for len(b) != 0 {
+			h := binary.LittleEndian.Uint16(b[:2])
+			props := Property(b[2])
+			vh := binary.LittleEndian.Uint16(b[3:5])
+			u := UUID{b[5:l]}
+			s := searchService(p.svcs, h, vh)
+			if s == nil {
+				log.Printf("Can't find service range that contains 0x%04X - 0x%04X", h, vh)
+				return nil, fmt.Errorf("Can't find service range that contains 0x%04X - 0x%04X", h, vh)
+			}
+			c := &Characteristic{
+				uuid:  u,
+				svc:   s,
+				props: props,
+				h:     h,
+				vh:    vh,
+			}
+			s.chars = append(s.chars, c)
+			b = b[l:]
+			done = vh == s.endh
+			start = vh + 1
+			if prev != nil {
+				prev.endh = c.h - 1
+			}
+			prev = c
+		}
+	}
+	if len(s.chars) > 1 {
+		s.chars[len(s.chars)-1].endh = s.endh
+	}
+	return s.chars, nil
+}
+
+func (p *peripheral) DiscoverDescriptors(ds []UUID, c *Characteristic) ([]*Descriptor, error) {
+	// TODO: implement the UUID filters
+	done := false
+	start := c.vh + 1
+	for !done {
+		if c.endh == 0 {
+			c.endh = c.svc.endh
+		}
+		op := byte(attOpFindInfoReq)
+		b := make([]byte, 5)
+		b[0] = op
+		binary.LittleEndian.PutUint16(b[1:3], start)
+		binary.LittleEndian.PutUint16(b[3:5], c.endh)
+
+		b = p.sendReq(op, b)
+		if finish(attOpFindInfoReq, start, b) {
+			break
+		}
+		b = b[1:]
+
+		var l int
+		f, b := int(b[0]), b[1:]
+		switch {
+		case f == 1 && (len(b)%4 == 0):
+			l = 4
+		case f == 2 && (len(b)%18 == 0):
+			l = 18
+		default:
+			return nil, ErrInvalidLength
+		}
+
+		for len(b) != 0 {
+			h := binary.LittleEndian.Uint16(b[:2])
+			u := UUID{b[2:l]}
+			d := &Descriptor{uuid: u, h: h, char: c}
+			c.descs = append(c.descs, d)
+			if u.Equal(attrClientCharacteristicConfigUUID) {
+				c.cccd = d
+			}
+			b = b[l:]
+			done = h == c.endh
+			start = h + 1
+		}
+	}
+	return c.descs, nil
+}
+
+func (p *peripheral) ReadCharacteristic(c *Characteristic) ([]byte, error) {
+	b := make([]byte, 3)
+	op := byte(attOpReadReq)
+	b[0] = op
+	binary.LittleEndian.PutUint16(b[1:3], c.vh)
+
+	b = p.sendReq(op, b)
+	b = b[1:]
+	return b, nil
+}
+
+func (p *peripheral) ReadLongCharacteristic(c *Characteristic) ([]byte, error) {
+	// The spec says that a read blob request should fail if the characteristic
+	// is smaller than mtu - 1.  To simplify the API, the first read is done
+	// with a regular read request.  If the buffer received is equal to mtu -1,
+	// then we read the rest of the data using read blob.
+	firstRead, err := p.ReadCharacteristic(c)
+	if err != nil {
+		return nil, err
+	}
+	if len(firstRead) < int(p.mtu)-1 {
+		return firstRead, nil
+	}
+
+	var buf bytes.Buffer
+	buf.Write(firstRead)
+	off := uint16(len(firstRead))
+	for {
+		b := make([]byte, 5)
+		op := byte(attOpReadBlobReq)
+		b[0] = op
+		binary.LittleEndian.PutUint16(b[1:3], c.vh)
+		binary.LittleEndian.PutUint16(b[3:5], off)
+
+		b = p.sendReq(op, b)
+		b = b[1:]
+		if len(b) == 0 {
+			break
+		}
+		buf.Write(b)
+		off += uint16(len(b))
+		if len(b) < int(p.mtu)-1 {
+			break
+		}
+	}
+	return buf.Bytes(), nil
+}
+
+func (p *peripheral) WriteCharacteristic(c *Characteristic, value []byte, noRsp bool) error {
+	b := make([]byte, 3+len(value))
+	op := byte(attOpWriteReq)
+	b[0] = op
+	if noRsp {
+		b[0] = attOpWriteCmd
+	}
+	binary.LittleEndian.PutUint16(b[1:3], c.vh)
+	copy(b[3:], value)
+
+	if noRsp {
+		p.sendCmd(op, b)
+		return nil
+	}
+	b = p.sendReq(op, b)
+	// TODO: error handling
+	b = b[1:]
+	return nil
+}
+
+func (p *peripheral) ReadDescriptor(d *Descriptor) ([]byte, error) {
+	b := make([]byte, 3)
+	op := byte(attOpReadReq)
+	b[0] = op
+	binary.LittleEndian.PutUint16(b[1:3], d.h)
+
+	b = p.sendReq(op, b)
+	b = b[1:]
+	// TODO: error handling
+	return b, nil
+}
+
+func (p *peripheral) WriteDescriptor(d *Descriptor, value []byte) error {
+	b := make([]byte, 3+len(value))
+	op := byte(attOpWriteReq)
+	b[0] = op
+	binary.LittleEndian.PutUint16(b[1:3], d.h)
+	copy(b[3:], value)
+
+	b = p.sendReq(op, b)
+	b = b[1:]
+	// TODO: error handling
+	return nil
+}
+
+func (p *peripheral) setNotifyValue(c *Characteristic, flag uint16,
+	f func(*Characteristic, []byte, error)) error {
+/*
+	if c.cccd == nil {
+		return errors.New("no cccd") // FIXME
+	}
+	ccc := uint16(0)
+	if f != nil {
+		ccc = flag
+*/
+		p.sub.subscribe(c.vh, func(b []byte, err error) { f(c, b, err) })
+/*
+	}
+	b := make([]byte, 5)
+	op := byte(attOpWriteReq)
+	b[0] = op
+	binary.LittleEndian.PutUint16(b[1:3], c.cccd.h)
+	binary.LittleEndian.PutUint16(b[3:5], ccc)
+
+	b = p.sendReq(op, b)
+	b = b[1:]
+	// TODO: error handling
+	if f == nil {
+		p.sub.unsubscribe(c.vh)
+	}
+*/
+	return nil
+}
+
+func (p *peripheral) SetNotifyValue(c *Characteristic,
+	f func(*Characteristic, []byte, error)) error {
+	return p.setNotifyValue(c, gattCCCNotifyFlag, f)
+}
+
+func (p *peripheral) SetIndicateValue(c *Characteristic,
+	f func(*Characteristic, []byte, error)) error {
+	return p.setNotifyValue(c, gattCCCIndicateFlag, f)
+}
+
+func (p *peripheral) ReadRSSI() int {
+	// TODO: implement
+	return -1
+}
+
+func searchService(ss []*Service, start, end uint16) *Service {
+	for _, s := range ss {
+		if s.h < start && s.endh >= end {
+			return s
+		}
+	}
+	return nil
+}
+
+// TODO: unifiy the message with OS X pots and refactor
+type message struct {
+	op   byte
+	b    []byte
+	rspc chan []byte
+}
+
+func (p *peripheral) sendCmd(op byte, b []byte) {
+	p.reqc <- message{op: op, b: b}
+}
+
+func (p *peripheral) sendReq(op byte, b []byte) []byte {
+	m := message{op: op, b: b, rspc: make(chan []byte)}
+	p.reqc <- m
+	return <-m.rspc
+}
+
+func (p *peripheral) loop() {
+	// Serialize the request.
+	rspc := make(chan []byte)
+
+	// Dequeue request loop
+	go func() {
+		for {
+			select {
+			case req := <-p.reqc:
+				p.l2c.Write(req.b)
+				if req.rspc == nil {
+					break
+				}
+				r := <-rspc
+				switch reqOp, rspOp := req.b[0], r[0]; {
+				case rspOp == attRspFor[reqOp]:
+				case rspOp == attOpError && r[1] == reqOp:
+				default:
+					log.Printf("Request 0x%02x got a mismatched response: 0x%02x", reqOp, rspOp)
+					// FIXME: terminate the connection?
+				}
+				req.rspc <- r
+			case <-p.quitc:
+				return
+			}
+		}
+	}()
+
+	// L2CAP implementations shall support a minimum MTU size of 48 bytes.
+	// The default value is 672 bytes
+	buf := make([]byte, 672)
+
+	// Handling response or notification/indication
+	for {
+		n, err := p.l2c.Read(buf)
+		if n == 0 || err != nil {
+			close(p.quitc)
+			return
+		}
+
+		b := make([]byte, n)
+		copy(b, buf)
+
+		if (b[0] != attOpHandleNotify) && (b[0] != attOpHandleInd) {
+			rspc <- b
+			continue
+		}
+
+		h := binary.LittleEndian.Uint16(b[1:3])
+		f := p.sub.fn(h)
+		if f == nil {
+			log.Printf("notified by unsubscribed handle")
+			// FIXME: terminate the connection?
+		} else {
+			go f(b[3:], nil)
+		}
+
+		if b[0] == attOpHandleInd {
+			// write aknowledgement for indication
+			p.l2c.Write([]byte{attOpHandleCnf})
+		}
+
+	}
+}
+
+func (p *peripheral) SetMTU(mtu uint16) error {
+	b := make([]byte, 3)
+	op := byte(attOpMtuReq)
+	b[0] = op
+	binary.LittleEndian.PutUint16(b[1:3], uint16(mtu))
+
+	b = p.sendReq(op, b)
+	serverMTU := binary.LittleEndian.Uint16(b[1:3])
+	if serverMTU < mtu {
+		mtu = serverMTU
+	}
+	p.mtu = mtu
+	return nil
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/readme.md
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/readme.md b/newtmgr/vendor/github.com/runtimeco/gatt/readme.md
new file mode 100644
index 0000000..ea3a957
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/readme.md
@@ -0,0 +1,115 @@
+# Package gatt provides a Bluetooth Low Energy GATT implementation.
+
+Gatt (Generic Attribute Profile) is the protocol used to write BLE peripherals (servers) and centrals (clients).
+
+As a peripheral, you can create services, characteristics, and descriptors,
+advertise, accept connections, and handle requests.
+
+As a central, you can scan, connect, discover services, and make requests.
+
+## SETUP
+
+### gatt supports both Linux and OS X.
+
+### On Linux:
+To gain complete and exclusive control of the HCI device, gatt uses
+HCI_CHANNEL_USER (introduced in Linux v3.14) instead of HCI_CHANNEL_RAW.
+Those who must use an older kernel may patch in these relevant commits
+from Marcel Holtmann:
+
+    Bluetooth: Introduce new HCI socket channel for user operation
+    Bluetooth: Introduce user channel flag for HCI devices
+    Bluetooth: Refactor raw socket filter into more readable code
+
+Note that because gatt uses HCI_CHANNEL_USER, once gatt has opened the
+device no other program may access it.
+
+Before starting a gatt program, make sure that your BLE device is down:
+
+    sudo hciconfig
+    sudo hciconfig hci0 down  # or whatever hci device you want to use
+
+If you have BlueZ 5.14+ (or aren't sure), stop the built-in
+bluetooth server, which interferes with gatt, e.g.:
+
+    sudo service bluetooth stop
+
+Because gatt programs administer network devices, they must
+either be run as root, or be granted appropriate capabilities:
+
+    sudo <executable>
+    # OR
+    sudo setcap 'cap_net_raw,cap_net_admin=eip' <executable>
+    <executable>
+
+## Usage
+Please see [godoc.org](http://godoc.org/github.com/paypal/gatt) for documentation.
+
+## Examples
+
+### Build and run the examples on a native environment (Linux or OS X)
+
+Go is a compiled language, which means to run the examples you need to build them first.
+
+    # Build the sample server.
+    go build examples/server.go
+    # Start the sample server.
+    sudo ./server
+
+Alternatively, you can use "go run" to build and run the examples in a single step:
+
+    # Build and run the sample server.
+    sudo go run examples/server.go
+
+Discoverer and explorer demonstrates central (client) functions:
+
+    # Discover surrounding peripherals.
+    sudo go run examples/discoverer.go
+
+    # Connect to and explorer a peripheral device.
+    sudo go run examples/explorer.go <peripheral ID>
+
+### Cross-compile and deploy to a target device
+
+    # Build and run the server example on a ARMv5 target device.
+    GOARCH=arm GOARM=5 GOOS=linux go build examples/server.go
+    cp server <target device>
+    # Start the server on the target device
+    sudo ./server
+
+See the server.go, discoverer.go, and explorer.go in the examples/
+directory for writing server or client programs that run on Linux
+and OS X.
+
+Users, especially on Linux platforms, seeking finer-grained control
+over the devices can see the examples/server_lnx.go for the usage
+of Option, which are platform specific.
+
+See the rest of the docs for other options and finer-grained control.
+
+## Note
+Note that some BLE central devices, particularly iOS, may aggressively
+cache results from previous connections. If you change your services or
+characteristics, you may need to reboot the other device to pick up the
+changes. This is a common source of confusion and apparent bugs. For an
+OS X central, see http://stackoverflow.com/questions/20553957.
+
+## Known Issues
+
+Currently OS X vesion  does not support subscribing to indications. 
+Please check [#32](https://github.com/paypal/gatt/issues/32) for the status of this issue.
+
+## REFERENCES
+
+gatt started life as a port of bleno, to which it is indebted:
+https://github.com/sandeepmistry/bleno. If you are having
+problems with gatt, particularly around installation, issues
+filed with bleno might also be helpful references.
+
+To try out your GATT server, it is useful to experiment with a
+generic BLE client. LightBlue is a good choice. It is available
+free for both iOS and OS X.
+
+gatt is similar to [bleno](https://github.com/sandeepmistry/bleno) and [noble](https://github.com/sandeepmistry/noble), which offer BLE GATT implementations for node.js.
+
+Gatt is released under a [BSD-style license](./LICENSE.md).

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/uuid.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/uuid.go b/newtmgr/vendor/github.com/runtimeco/gatt/uuid.go
new file mode 100644
index 0000000..393e548
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/uuid.go
@@ -0,0 +1,86 @@
+package gatt
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"strings"
+)
+
+// A UUID is a BLE UUID.
+type UUID struct {
+	// Hide the bytes, so that we can enforce that they have length 2 or 16,
+	// and that they are immutable. This simplifies the code and API.
+	b []byte
+}
+
+// UUID16 converts a uint16 (such as 0x1800) to a UUID.
+func UUID16(i uint16) UUID {
+	b := make([]byte, 2)
+	binary.LittleEndian.PutUint16(b, i)
+	return UUID{b}
+}
+
+// ParseUUID parses a standard-format UUID string, such
+// as "1800" or "34DA3AD1-7110-41A1-B1EF-4430F509CDE7".
+func ParseUUID(s string) (UUID, error) {
+	s = strings.Replace(s, "-", "", -1)
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		return UUID{}, err
+	}
+	if err := lenErr(len(b)); err != nil {
+		return UUID{}, err
+	}
+	return UUID{reverse(b)}, nil
+}
+
+// MustParseUUID parses a standard-format UUID string,
+// like ParseUUID, but panics in case of error.
+func MustParseUUID(s string) UUID {
+	u, err := ParseUUID(s)
+	if err != nil {
+		panic(err)
+	}
+	return u
+}
+
+// lenErr returns an error if n is an invalid UUID length.
+func lenErr(n int) error {
+	switch n {
+	case 2, 16:
+		return nil
+	}
+	return fmt.Errorf("UUIDs must have length 2 or 16, got %d", n)
+}
+
+// Len returns the length of the UUID, in bytes.
+// BLE UUIDs are either 2 or 16 bytes.
+func (u UUID) Len() int {
+	return len(u.b)
+}
+
+// String hex-encodes a UUID.
+func (u UUID) String() string {
+	return fmt.Sprintf("%x", reverse(u.b))
+}
+
+// Equal returns a boolean reporting whether v represent the same UUID as u.
+func (u UUID) Equal(v UUID) bool {
+	return bytes.Equal(u.b, v.b)
+}
+
+// reverse returns a reversed copy of u.
+func reverse(u []byte) []byte {
+	// Special-case 16 bit UUIDS for speed.
+	l := len(u)
+	if l == 2 {
+		return []byte{u[1], u[0]}
+	}
+	b := make([]byte, l)
+	for i := 0; i < l/2+1; i++ {
+		b[i], b[l-i-1] = u[l-i-1], u[i]
+	}
+	return b
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/LICENSE
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/LICENSE b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/LICENSE
new file mode 100644
index 0000000..766a0a5
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) {{{year}}} {{{fullname}}}
+
+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.

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/doc.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/doc.go b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/doc.go
new file mode 100644
index 0000000..d292249
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/doc.go
@@ -0,0 +1,8 @@
+// Package xpc provides minimal OS X XPC support required for gatt
+//
+// This is adapted from [goble], by Raffaele Sena.
+//
+//     http://godoc.org/github.com/raff/goble
+//     https://github.com/raff/goble
+
+package xpc

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_darwin.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_darwin.go b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_darwin.go
new file mode 100644
index 0000000..2a85a99
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_darwin.go
@@ -0,0 +1,350 @@
+package xpc
+
+/*
+#include "xpc_wrapper_darwin.h"
+#include "sys/utsname.h"
+*/
+import "C"
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	r "reflect"
+	"unsafe"
+)
+
+type XPC struct {
+	conn C.xpc_connection_t
+}
+
+func (x *XPC) Send(msg interface{}, verbose bool) {
+	// verbose == true converts the type from bool to C._Bool
+	C.XpcSendMessage(x.conn, goToXpc(msg), true, verbose == true)
+}
+
+//
+// minimal XPC support required for BLE
+//
+
+// a dictionary of things
+type Dict map[string]interface{}
+
+func (d Dict) Contains(k string) bool {
+	_, ok := d[k]
+	return ok
+}
+
+func (d Dict) MustGetDict(k string) Dict {
+	return d[k].(Dict)
+}
+
+func (d Dict) MustGetArray(k string) Array {
+	return d[k].(Array)
+}
+
+func (d Dict) MustGetBytes(k string) []byte {
+	return d[k].([]byte)
+}
+
+func (d Dict) MustGetHexBytes(k string) string {
+	return fmt.Sprintf("%x", d[k].([]byte))
+}
+
+func (d Dict) MustGetInt(k string) int {
+	return int(d[k].(int64))
+}
+
+func (d Dict) MustGetUUID(k string) []byte {
+	u := d[k].(UUID)
+	return u[:]
+}
+
+func (d Dict) GetString(k, defv string) string {
+	if v := d[k]; v != nil {
+		//log.Printf("GetString %s %#v\n", k, v)
+		return v.(string)
+	} else {
+		//log.Printf("GetString %s default %#v\n", k, defv)
+		return defv
+	}
+}
+
+func (d Dict) GetBytes(k string, defv []byte) []byte {
+	if v := d[k]; v != nil {
+		//log.Printf("GetBytes %s %#v\n", k, v)
+		return v.([]byte)
+	} else {
+		//log.Printf("GetBytes %s default %#v\n", k, defv)
+		return defv
+	}
+}
+
+func (d Dict) GetInt(k string, defv int) int {
+	if v := d[k]; v != nil {
+		//log.Printf("GetString %s %#v\n", k, v)
+		return int(v.(int64))
+	} else {
+		//log.Printf("GetString %s default %#v\n", k, defv)
+		return defv
+	}
+}
+
+func (d Dict) GetUUID(k string) UUID {
+	return GetUUID(d[k])
+}
+
+// an array of things
+type Array []interface{}
+
+func (a Array) GetUUID(k int) UUID {
+	return GetUUID(a[k])
+}
+
+// a UUID
+type UUID []byte
+
+func MakeUUID(s string) UUID {
+	var sl []byte
+	fmt.Sscanf(s, "%32x", &sl)
+
+	var uuid [16]byte
+	copy(uuid[:], sl)
+	return UUID(uuid[:])
+}
+
+func (uuid UUID) String() string {
+	return fmt.Sprintf("%x", []byte(uuid))
+}
+
+func GetUUID(v interface{}) UUID {
+	if v == nil {
+		return UUID{}
+	}
+
+	if uuid, ok := v.(UUID); ok {
+		return uuid
+	}
+
+	if bytes, ok := v.([]byte); ok {
+		uuid := UUID{}
+
+		for i, b := range bytes {
+			uuid[i] = b
+		}
+
+		return uuid
+	}
+
+	if bytes, ok := v.([]uint8); ok {
+		uuid := UUID{}
+
+		for i, b := range bytes {
+			uuid[i] = b
+		}
+
+		return uuid
+	}
+
+	log.Fatalf("invalid type for UUID: %#v", v)
+	return UUID{}
+}
+
+var (
+	CONNECTION_INVALID     = errors.New("connection invalid")
+	CONNECTION_INTERRUPTED = errors.New("connection interrupted")
+	CONNECTION_TERMINATED  = errors.New("connection terminated")
+
+	TYPE_OF_UUID  = r.TypeOf(UUID{})
+	TYPE_OF_BYTES = r.TypeOf([]byte{})
+)
+
+type XpcEventHandler interface {
+	HandleXpcEvent(event Dict, err error)
+}
+
+func XpcConnect(service string, eh XpcEventHandler) XPC {
+	cservice := C.CString(service)
+	defer C.free(unsafe.Pointer(cservice))
+	return XPC{conn: C.XpcConnect(cservice, unsafe.Pointer(&eh))}
+}
+
+//export handleXpcEvent
+func handleXpcEvent(event C.xpc_object_t, p unsafe.Pointer) {
+	//log.Printf("handleXpcEvent %#v %#v\n", event, p)
+
+	t := C.xpc_get_type(event)
+	eh := *((*XpcEventHandler)(p))
+
+	if t == C.TYPE_ERROR {
+		if event == C.ERROR_CONNECTION_INVALID {
+			// The client process on the other end of the connection has either
+			// crashed or cancelled the connection. After receiving this error,
+			// the connection is in an invalid state, and you do not need to
+			// call xpc_connection_cancel(). Just tear down any associated state
+			// here.
+			//log.Println("connection invalid")
+			eh.HandleXpcEvent(nil, CONNECTION_INVALID)
+		} else if event == C.ERROR_CONNECTION_INTERRUPTED {
+			//log.Println("connection interrupted")
+			eh.HandleXpcEvent(nil, CONNECTION_INTERRUPTED)
+		} else if event == C.ERROR_CONNECTION_TERMINATED {
+			// Handle per-connection termination cleanup.
+			//log.Println("connection terminated")
+			eh.HandleXpcEvent(nil, CONNECTION_TERMINATED)
+		} else {
+			//log.Println("got some error", event)
+			eh.HandleXpcEvent(nil, fmt.Errorf("%v", event))
+		}
+	} else {
+		eh.HandleXpcEvent(xpcToGo(event).(Dict), nil)
+	}
+}
+
+// goToXpc converts a go object to an xpc object
+func goToXpc(o interface{}) C.xpc_object_t {
+	return valueToXpc(r.ValueOf(o))
+}
+
+// valueToXpc converts a go Value to an xpc object
+//
+// note that not all the types are supported, but only the subset required for Blued
+func valueToXpc(val r.Value) C.xpc_object_t {
+	if !val.IsValid() {
+		return nil
+	}
+
+	var xv C.xpc_object_t
+
+	switch val.Kind() {
+	case r.Int, r.Int8, r.Int16, r.Int32, r.Int64:
+		xv = C.xpc_int64_create(C.int64_t(val.Int()))
+
+	case r.Uint, r.Uint8, r.Uint16, r.Uint32:
+		xv = C.xpc_int64_create(C.int64_t(val.Uint()))
+
+	case r.String:
+		xv = C.xpc_string_create(C.CString(val.String()))
+
+	case r.Map:
+		xv = C.xpc_dictionary_create(nil, nil, 0)
+		for _, k := range val.MapKeys() {
+			v := valueToXpc(val.MapIndex(k))
+			C.xpc_dictionary_set_value(xv, C.CString(k.String()), v)
+			if v != nil {
+				C.xpc_release(v)
+			}
+		}
+
+	case r.Array, r.Slice:
+		if val.Type() == TYPE_OF_UUID {
+			// array of bytes
+			var uuid [16]byte
+			r.Copy(r.ValueOf(uuid[:]), val)
+			xv = C.xpc_uuid_create(C.ptr_to_uuid(unsafe.Pointer(&uuid[0])))
+		} else if val.Type() == TYPE_OF_BYTES {
+			// slice of bytes
+			xv = C.xpc_data_create(unsafe.Pointer(val.Pointer()), C.size_t(val.Len()))
+		} else {
+			xv = C.xpc_array_create(nil, 0)
+			l := val.Len()
+
+			for i := 0; i < l; i++ {
+				v := valueToXpc(val.Index(i))
+				C.xpc_array_append_value(xv, v)
+				if v != nil {
+					C.xpc_release(v)
+				}
+			}
+		}
+
+	case r.Interface, r.Ptr:
+		xv = valueToXpc(val.Elem())
+
+	default:
+		log.Fatalf("unsupported %#v", val.String())
+	}
+
+	return xv
+}
+
+//export arraySet
+func arraySet(u unsafe.Pointer, i C.int, v C.xpc_object_t) {
+	a := *(*Array)(u)
+	a[i] = xpcToGo(v)
+}
+
+//export dictSet
+func dictSet(u unsafe.Pointer, k *C.char, v C.xpc_object_t) {
+	d := *(*Dict)(u)
+	d[C.GoString(k)] = xpcToGo(v)
+}
+
+// xpcToGo converts an xpc object to a go object
+//
+// note that not all the types are supported, but only the subset required for Blued
+func xpcToGo(v C.xpc_object_t) interface{} {
+	t := C.xpc_get_type(v)
+
+	switch t {
+	case C.TYPE_ARRAY:
+		a := make(Array, C.int(C.xpc_array_get_count(v)))
+		C.XpcArrayApply(unsafe.Pointer(&a), v)
+		return a
+
+	case C.TYPE_DATA:
+		return C.GoBytes(C.xpc_data_get_bytes_ptr(v), C.int(C.xpc_data_get_length(v)))
+
+	case C.TYPE_DICT:
+		d := make(Dict)
+		C.XpcDictApply(unsafe.Pointer(&d), v)
+		return d
+
+	case C.TYPE_INT64:
+		return int64(C.xpc_int64_get_value(v))
+
+	case C.TYPE_STRING:
+		return C.GoString(C.xpc_string_get_string_ptr(v))
+
+	case C.TYPE_UUID:
+		a := [16]byte{}
+		C.XpcUUIDGetBytes(unsafe.Pointer(&a), v)
+		return UUID(a[:])
+
+	default:
+		log.Fatalf("unexpected type %#v, value %#v", t, v)
+	}
+
+	return nil
+}
+
+// xpc_release is needed by tests, since they can't use CGO
+func xpc_release(xv C.xpc_object_t) {
+	C.xpc_release(xv)
+}
+
+// this is used to check the OS version
+
+type Utsname struct {
+	Sysname  string
+	Nodename string
+	Release  string
+	Version  string
+	Machine  string
+}
+
+func Uname(utsname *Utsname) error {
+	var cstruct C.struct_utsname
+	if err := C.uname(&cstruct); err != 0 {
+		return errors.New("utsname error")
+	}
+
+	// XXX: this may crash if any value is exactly 256 characters (no 0 terminator)
+	utsname.Sysname = C.GoString(&cstruct.sysname[0])
+	utsname.Nodename = C.GoString(&cstruct.nodename[0])
+	utsname.Release = C.GoString(&cstruct.release[0])
+	utsname.Version = C.GoString(&cstruct.version[0])
+	utsname.Machine = C.GoString(&cstruct.machine[0])
+
+	return nil
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_wrapper_darwin.c
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_wrapper_darwin.c b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_wrapper_darwin.c
new file mode 100644
index 0000000..7bcb83d
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_wrapper_darwin.c
@@ -0,0 +1,85 @@
+#include <dispatch/dispatch.h>
+#include <xpc/xpc.h>
+#include <xpc/connection.h>
+#include <Block.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "_cgo_export.h"
+
+//
+// types and errors are implemented as macros
+// create some real objects to make them accessible to Go
+//
+xpc_type_t TYPE_ERROR = XPC_TYPE_ERROR;
+
+xpc_type_t TYPE_ARRAY = XPC_TYPE_ARRAY;
+xpc_type_t TYPE_DATA = XPC_TYPE_DATA;
+xpc_type_t TYPE_DICT = XPC_TYPE_DICTIONARY;
+xpc_type_t TYPE_INT64 = XPC_TYPE_INT64;
+xpc_type_t TYPE_STRING = XPC_TYPE_STRING;
+xpc_type_t TYPE_UUID = XPC_TYPE_UUID;
+
+xpc_object_t ERROR_CONNECTION_INVALID = (xpc_object_t) XPC_ERROR_CONNECTION_INVALID;
+xpc_object_t ERROR_CONNECTION_INTERRUPTED = (xpc_object_t) XPC_ERROR_CONNECTION_INTERRUPTED;
+xpc_object_t ERROR_CONNECTION_TERMINATED = (xpc_object_t) XPC_ERROR_TERMINATION_IMMINENT;
+
+const ptr_to_uuid_t ptr_to_uuid(void *p) { return (ptr_to_uuid_t)p; }
+
+
+//
+// connect to XPC service
+//
+xpc_connection_t XpcConnect(char *service, void *ctx) {
+    dispatch_queue_t queue = dispatch_queue_create(service, 0);
+    xpc_connection_t conn = xpc_connection_create_mach_service(service, queue, XPC_CONNECTION_MACH_SERVICE_PRIVILEGED);
+
+    // making a local copy, that should be made "persistent" with the following Block_copy
+    GoInterface ictx = *((GoInterface*)ctx);
+
+    xpc_connection_set_event_handler(conn,
+        Block_copy(^(xpc_object_t event) {
+            handleXpcEvent(event, (void *)&ictx);
+        })
+    );
+
+    xpc_connection_resume(conn);
+    return conn;
+}
+
+void XpcSendMessage(xpc_connection_t conn, xpc_object_t message, bool release, bool reportDelivery) {
+    xpc_connection_send_message(conn,  message);
+    xpc_connection_send_barrier(conn, ^{
+        // Block is invoked on connection's target queue
+        // when 'message' has been sent.
+        if (reportDelivery) { // maybe this could be a callback
+            puts("message delivered");
+        }
+    });
+    if (release) {
+        xpc_release(message);
+    }
+}
+
+void XpcArrayApply(void *v, xpc_object_t arr) {
+  xpc_array_apply(arr, ^bool(size_t index, xpc_object_t value) {
+    arraySet(v, index, value);
+    return true;
+  });
+}
+
+void XpcDictApply(void *v, xpc_object_t dict) {
+  xpc_dictionary_apply(dict, ^bool(const char *key, xpc_object_t value) {
+    dictSet(v, (char *)key, value);
+    return true;
+  });
+}
+
+void XpcUUIDGetBytes(void *v, xpc_object_t uuid) {
+   const uint8_t *src = xpc_uuid_get_bytes(uuid);
+   uint8_t *dest = (uint8_t *)v;
+
+   for (int i=0; i < sizeof(uuid_t); i++) {
+     dest[i] = src[i];
+   }
+}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_wrapper_darwin.h
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_wrapper_darwin.h b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_wrapper_darwin.h
new file mode 100644
index 0000000..e2cfb5c
--- /dev/null
+++ b/newtmgr/vendor/github.com/runtimeco/gatt/xpc/xpc_wrapper_darwin.h
@@ -0,0 +1,32 @@
+#ifndef _XPC_WRAPPER_H_
+#define _XPC_WRAPPER_H_
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <xpc/xpc.h>
+
+extern xpc_type_t TYPE_ERROR;
+
+extern xpc_type_t TYPE_ARRAY;
+extern xpc_type_t TYPE_DATA;
+extern xpc_type_t TYPE_DICT;
+extern xpc_type_t TYPE_INT64;
+extern xpc_type_t TYPE_STRING;
+extern xpc_type_t TYPE_UUID;
+
+extern xpc_object_t ERROR_CONNECTION_INVALID;
+extern xpc_object_t ERROR_CONNECTION_INTERRUPTED;
+extern xpc_object_t ERROR_CONNECTION_TERMINATED;
+
+extern xpc_connection_t XpcConnect(char *, void *);
+extern void XpcSendMessage(xpc_connection_t, xpc_object_t, bool, bool);
+extern void XpcArrayApply(void *, xpc_object_t);
+extern void XpcDictApply(void *, xpc_object_t);
+extern void XpcUUIDGetBytes(void *, xpc_object_t);
+
+// the input type for xpc_uuid_create should be uuid_t but CGO instists on unsigned char *
+// typedef uuid_t * ptr_to_uuid_t;
+typedef unsigned char * ptr_to_uuid_t;
+extern const ptr_to_uuid_t ptr_to_uuid(void *p);
+
+#endif

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeinc/gatt/.gitignore
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeinc/gatt/.gitignore b/newtmgr/vendor/github.com/runtimeinc/gatt/.gitignore
deleted file mode 100644
index 7ab0687..0000000
--- a/newtmgr/vendor/github.com/runtimeinc/gatt/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-c.out
-c/*-ble
-sample

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeinc/gatt/LICENSE.md
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeinc/gatt/LICENSE.md b/newtmgr/vendor/github.com/runtimeinc/gatt/LICENSE.md
deleted file mode 100644
index 51c07a6..0000000
--- a/newtmgr/vendor/github.com/runtimeinc/gatt/LICENSE.md
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2014 PayPal Inc. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * 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.
-   * Neither the name of PayPal Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-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
-OWNER 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.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeinc/gatt/adv.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeinc/gatt/adv.go b/newtmgr/vendor/github.com/runtimeinc/gatt/adv.go
deleted file mode 100644
index 3b8a747..0000000
--- a/newtmgr/vendor/github.com/runtimeinc/gatt/adv.go
+++ /dev/null
@@ -1,234 +0,0 @@
-package gatt
-
-import (
-	"errors"
-	"log"
-)
-
-// MaxEIRPacketLength is the maximum allowed AdvertisingPacket
-// and ScanResponsePacket length.
-const MaxEIRPacketLength = 31
-
-// ErrEIRPacketTooLong is the error returned when an AdvertisingPacket
-// or ScanResponsePacket is too long.
-var ErrEIRPacketTooLong = errors.New("max packet length is 31")
-
-// Advertising data field types
-const (
-	typeFlags             = 0x01 // Flags
-	typeSomeUUID16        = 0x02 // Incomplete List of 16-bit Service Class UUIDs
-	typeAllUUID16         = 0x03 // Complete List of 16-bit Service Class UUIDs
-	typeSomeUUID32        = 0x04 // Incomplete List of 32-bit Service Class UUIDs
-	typeAllUUID32         = 0x05 // Complete List of 32-bit Service Class UUIDs
-	typeSomeUUID128       = 0x06 // Incomplete List of 128-bit Service Class UUIDs
-	typeAllUUID128        = 0x07 // Complete List of 128-bit Service Class UUIDs
-	typeShortName         = 0x08 // Shortened Local Name
-	typeCompleteName      = 0x09 // Complete Local Name
-	typeTxPower           = 0x0A // Tx Power Level
-	typeClassOfDevice     = 0x0D // Class of Device
-	typeSimplePairingC192 = 0x0E // Simple Pairing Hash C-192
-	typeSimplePairingR192 = 0x0F // Simple Pairing Randomizer R-192
-	typeSecManagerTK      = 0x10 // Security Manager TK Value
-	typeSecManagerOOB     = 0x11 // Security Manager Out of Band Flags
-	typeSlaveConnInt      = 0x12 // Slave Connection Interval Range
-	typeServiceSol16      = 0x14 // List of 16-bit Service Solicitation UUIDs
-	typeServiceSol128     = 0x15 // List of 128-bit Service Solicitation UUIDs
-	typeServiceData16     = 0x16 // Service Data - 16-bit UUID
-	typePubTargetAddr     = 0x17 // Public Target Address
-	typeRandTargetAddr    = 0x18 // Random Target Address
-	typeAppearance        = 0x19 // Appearance
-	typeAdvInterval       = 0x1A // Advertising Interval
-	typeLEDeviceAddr      = 0x1B // LE Bluetooth Device Address
-	typeLERole            = 0x1C // LE Role
-	typeServiceSol32      = 0x1F // List of 32-bit Service Solicitation UUIDs
-	typeServiceData32     = 0x20 // Service Data - 32-bit UUID
-	typeServiceData128    = 0x21 // Service Data - 128-bit UUID
-	typeLESecConfirm      = 0x22 // LE Secure Connections Confirmation Value
-	typeLESecRandom       = 0x23 // LE Secure Connections Random Value
-	typeManufacturerData  = 0xFF // Manufacturer Specific Data
-)
-
-// Advertising type flags
-const (
-	flagLimitedDiscoverable = 0x01 // LE Limited Discoverable Mode
-	flagGeneralDiscoverable = 0x02 // LE General Discoverable Mode
-	flagLEOnly              = 0x04 // BR/EDR Not Supported. Bit 37 of LMP Feature Mask Definitions (Page 0)
-	flagBothController      = 0x08 // Simultaneous LE and BR/EDR to Same Device Capable (Controller).
-	flagBothHost            = 0x10 // Simultaneous LE and BR/EDR to Same Device Capable (Host).
-)
-
-// FIXME: check the unmarshalling of this data structure.
-type ServiceData struct {
-	UUID UUID
-	Data []byte
-}
-
-// This is borrowed from core bluetooth.
-// Embedded/Linux folks might be interested in more details.
-type Advertisement struct {
-	LocalName        string
-	ManufacturerData []byte
-	ServiceData      []ServiceData
-	Services         []UUID
-	OverflowService  []UUID
-	TxPowerLevel     int
-	Connectable      bool
-	SolicitedService []UUID
-	AddressType uint8
-	Address     [6]byte
-}
-
-// This is only used in Linux port.
-func (a *Advertisement) unmarshall(b []byte) error {
-
-	// Utility function for creating a list of uuids.
-	uuidList := func(u []UUID, d []byte, w int) []UUID {
-		for len(d) > 0 {
-			u = append(u, UUID{d[:w]})
-			d = d[w:]
-		}
-		return u
-	}
-
-	for len(b) > 0 {
-		if len(b) < 2 {
-			return errors.New("invalid advertise data")
-		}
-		l, t := b[0], b[1]
-		if len(b) < int(1+l) {
-			return errors.New("invalid advertise data")
-		}
-		d := b[2 : 1+l]
-		switch t {
-		case typeFlags:
-			// TODO: should we do anything about the discoverability here?
-		case typeSomeUUID16:
-			a.Services = uuidList(a.Services, d, 2)
-		case typeAllUUID16:
-			a.Services = uuidList(a.Services, d, 2)
-		case typeSomeUUID32:
-			a.Services = uuidList(a.Services, d, 4)
-		case typeAllUUID32:
-			a.Services = uuidList(a.Services, d, 4)
-		case typeSomeUUID128:
-			a.Services = uuidList(a.Services, d, 16)
-		case typeAllUUID128:
-			a.Services = uuidList(a.Services, d, 16)
-		case typeShortName:
-			a.LocalName = string(d)
-		case typeCompleteName:
-			a.LocalName = string(d)
-		case typeTxPower:
-			a.TxPowerLevel = int(d[0])
-		case typeServiceSol16:
-			a.SolicitedService = uuidList(a.SolicitedService, d, 2)
-		case typeServiceSol128:
-			a.SolicitedService = uuidList(a.SolicitedService, d, 16)
-		case typeServiceSol32:
-			a.SolicitedService = uuidList(a.SolicitedService, d, 4)
-		case typeManufacturerData:
-			a.ManufacturerData = make([]byte, len(d))
-			copy(a.ManufacturerData, d)
-		// case typeServiceData16,
-		// case typeServiceData32,
-		// case typeServiceData128:
-		default:
-			log.Printf("DATA: [ % X ]", d)
-		}
-		b = b[1+l:]
-	}
-	return nil
-}
-
-// AdvPacket is an utility to help crafting advertisment or scan response data.
-type AdvPacket struct {
-	b []byte
-}
-
-// Bytes returns an 31-byte array, which contains up to 31 bytes of the packet.
-func (a *AdvPacket) Bytes() [31]byte {
-	b := [31]byte{}
-	copy(b[:], a.b)
-	return b
-}
-
-// Len returns the length of the packets with a maximum of 31.
-func (a *AdvPacket) Len() int {
-	if len(a.b) > 31 {
-		return 31
-	}
-	return len(a.b)
-}
-
-// AppendField appends a BLE advertising packet field.
-// TODO: refuse to append field if it'd make the packet too long.
-func (a *AdvPacket) AppendField(typ byte, b []byte) *AdvPacket {
-	// A field consists of len, typ, b.
-	// Len is 1 byte for typ plus len(b).
-	if len(a.b)+2+len(b) > MaxEIRPacketLength {
-		b = b[:MaxEIRPacketLength-len(a.b)-2]
-	}
-	a.b = append(a.b, byte(len(b)+1))
-	a.b = append(a.b, typ)
-	a.b = append(a.b, b...)
-	return a
-}
-
-// AppendFlags appends a flag field to the packet.
-func (a *AdvPacket) AppendFlags(f byte) *AdvPacket {
-	return a.AppendField(typeFlags, []byte{f})
-}
-
-// AppendFlags appends a name field to the packet.
-// If the name fits in the space, it will be append as a complete name field, otherwise a short name field.
-func (a *AdvPacket) AppendName(n string) *AdvPacket {
-	typ := byte(typeCompleteName)
-	if len(a.b)+2+len(n) > MaxEIRPacketLength {
-		typ = byte(typeShortName)
-	}
-	return a.AppendField(typ, []byte(n))
-}
-
-// AppendManufacturerData appends a manufacturer data field to the packet.
-func (a *AdvPacket) AppendManufacturerData(id uint16, b []byte) *AdvPacket {
-	d := append([]byte{uint8(id), uint8(id >> 8)}, b...)
-	return a.AppendField(typeManufacturerData, d)
-}
-
-// AppendUUIDFit appends a BLE advertised service UUID
-// packet field if it fits in the packet, and reports whether the UUID fit.
-func (a *AdvPacket) AppendUUIDFit(uu []UUID) bool {
-	// Iterate all UUIDs to see if they fit in the packet or not.
-	fit, l := true, len(a.b)
-	for _, u := range uu {
-		if u.Equal(attrGAPUUID) || u.Equal(attrGATTUUID) {
-			continue
-		}
-		l += 2 + u.Len()
-		if l > MaxEIRPacketLength {
-			fit = false
-			break
-		}
-	}
-
-	// Append the UUIDs until they no longer fit.
-	for _, u := range uu {
-		if u.Equal(attrGAPUUID) || u.Equal(attrGATTUUID) {
-			continue
-		}
-		if len(a.b)+2+u.Len() > MaxEIRPacketLength {
-			break
-		}
-		switch l = u.Len(); {
-		case l == 2 && fit:
-			a.AppendField(typeAllUUID16, u.b)
-		case l == 16 && fit:
-			a.AppendField(typeAllUUID128, u.b)
-		case l == 2 && !fit:
-			a.AppendField(typeSomeUUID16, u.b)
-		case l == 16 && !fit:
-			a.AppendField(typeSomeUUID128, u.b)
-		}
-	}
-	return fit
-}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/abf65d3a/newtmgr/vendor/github.com/runtimeinc/gatt/attr.go
----------------------------------------------------------------------
diff --git a/newtmgr/vendor/github.com/runtimeinc/gatt/attr.go b/newtmgr/vendor/github.com/runtimeinc/gatt/attr.go
deleted file mode 100644
index d1ae09d..0000000
--- a/newtmgr/vendor/github.com/runtimeinc/gatt/attr.go
+++ /dev/null
@@ -1,160 +0,0 @@
-package gatt
-
-import "log"
-
-// attr is a BLE attribute. It is not exported;
-// managing attributes is an implementation detail.
-type attr struct {
-	h      uint16   // attribute handle
-	typ    UUID     // attribute type in UUID
-	props  Property // attripute property
-	secure Property // attribute secure (implementation specific usage)
-	value  []byte   // attribute value
-
-	pvt interface{} // point to the corresponsing Serveice/Characteristic/Descriptor
-}
-
-// A attrRange is a contiguous range of attributes.
-type attrRange struct {
-	aa   []attr
-	base uint16 // handle for first attr in aa
-}
-
-const (
-	tooSmall = -1
-	tooLarge = -2
-)
-
-// idx returns the index into aa corresponding to attr a.
-// If h is too small, idx returns tooSmall (-1).
-// If h is too large, idx returns tooLarge (-2).
-func (r *attrRange) idx(h int) int {
-	if h < int(r.base) {
-		return tooSmall
-	}
-	if int(h) >= int(r.base)+len(r.aa) {
-		return tooLarge
-	}
-	return h - int(r.base)
-}
-
-// At returns attr a.
-func (r *attrRange) At(h uint16) (a attr, ok bool) {
-	i := r.idx(int(h))
-	if i < 0 {
-		return attr{}, false
-	}
-	return r.aa[i], true
-}
-
-// Subrange returns attributes in range [start, end]; it may
-// return an empty slice. Subrange does not panic for
-// out-of-range start or end.
-func (r *attrRange) Subrange(start, end uint16) []attr {
-	startidx := r.idx(int(start))
-	switch startidx {
-	case tooSmall:
-		startidx = 0
-	case tooLarge:
-		return []attr{}
-	}
-
-	endidx := r.idx(int(end) + 1) // [start, end] includes its upper bound!
-	switch endidx {
-	case tooSmall:
-		return []attr{}
-	case tooLarge:
-		endidx = len(r.aa)
-	}
-	return r.aa[startidx:endidx]
-}
-
-func dumpAttributes(aa []attr) {
-	log.Printf("Generating attribute table:")
-	log.Printf("handle\ttype\tprops\tsecure\tpvt\tvalue")
-	for _, a := range aa {
-		log.Printf("0x%04X\t0x%s\t0x%02X\t0x%02x\t%T\t[ % X ]",
-			a.h, a.typ, int(a.props), int(a.secure), a.pvt, a.value)
-	}
-}
-
-func generateAttributes(ss []*Service, base uint16) *attrRange {
-	var aa []attr
-	h := base
-	last := len(ss) - 1
-	for i, s := range ss {
-		var a []attr
-		h, a = generateServiceAttributes(s, h, i == last)
-		aa = append(aa, a...)
-	}
-	dumpAttributes(aa)
-	return &attrRange{aa: aa, base: base}
-}
-
-func generateServiceAttributes(s *Service, h uint16, last bool) (uint16, []attr) {
-	s.h = h
-	// endh set later
-	a := attr{
-		h:     h,
-		typ:   attrPrimaryServiceUUID,
-		value: s.uuid.b,
-		props: CharRead,
-		pvt:   s,
-	}
-	aa := []attr{a}
-	h++
-
-	for _, c := range s.Characteristics() {
-		var a []attr
-		h, a = generateCharAttributes(c, h)
-		aa = append(aa, a...)
-	}
-
-	s.endh = h - 1
-	if last {
-		h = 0xFFFF
-		s.endh = h
-	}
-
-	return h, aa
-}
-
-func generateCharAttributes(c *Characteristic, h uint16) (uint16, []attr) {
-	c.h = h
-	c.vh = h + 1
-	ca := attr{
-		h:     c.h,
-		typ:   attrCharacteristicUUID,
-		value: append([]byte{byte(c.props), byte(c.vh), byte((c.vh) >> 8)}, c.uuid.b...),
-		props: c.props,
-		pvt:   c,
-	}
-	va := attr{
-		h:     c.vh,
-		typ:   c.uuid,
-		value: c.value,
-		props: c.props,
-		pvt:   c,
-	}
-	h += 2
-
-	aa := []attr{ca, va}
-	for _, d := range c.descs {
-		aa = append(aa, generateDescAttributes(d, h))
-		h++
-	}
-
-	return h, aa
-}
-
-func generateDescAttributes(d *Descriptor, h uint16) attr {
-	d.h = h
-	a := attr{
-		h:     h,
-		typ:   d.uuid,
-		value: d.value,
-		props: d.props,
-		pvt:   d,
-	}
-	return a
-}



Mime
View raw message