You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by ma...@apache.org on 2017/03/06 21:44:30 UTC
[30/41] incubator-mynewt-newt git commit: MYNEWT-653 Use runtimeco
gatt fork.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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/a1553084/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
-}