eqmk
/
qmkenc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

basic feature set

This commit is contained in:
Matthias Fulz 2022-06-26 23:58:14 +02:00
parent 4a1c86d80d
commit 473457ebb1
3 changed files with 204 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

295
qmk-cmd.go
View File

@ -3,11 +3,20 @@ package qmkenc
import (
"encoding/binary"
"fmt"
"math/rand"
"time"
)
var magicHeader = []byte{0x03, 0xFF}
type QEncCmd byte
type QEncInfoFct func(string)
type QEncEndFct func()
type QEncErrFct func(error)
var QEncInfoHandler QEncInfoFct
var QEncEndHandler QEncEndFct
var QEncErrHandler QEncErrFct
const (
QENC_CMD_RESET QEncCmd = 0x00
@ -24,8 +33,49 @@ const (
QENC_CMD_SET_KEYS QEncCmd = 0x0B
QENC_CMD_GET_CFG QEncCmd = 0x0C
QENC_CMD_INITIALIZE QEncCmd = 0x0D
QENC_CMD_NONE QEncCmd = 0x0E
QENC_CMD_SET_BUFFER QEncCmd = 0x0F
)
func (e QEncCmd) String() string {
switch e {
case QENC_CMD_RESET:
return "Reset cmd"
case QENC_CMD_ENCRYPT:
return "Encrypt cmd"
case QENC_CMD_DECRYPT:
return "Decrypt cmd"
case QENC_CMD_MORE_DATA:
return "More data cmd"
case QENC_CMD_UNLOCK:
return "Unlock cmd"
case QENC_CMD_LOCK:
return "Lock cmd"
case QENC_CMD_SET_CFG:
return "Set cfg cmd"
case QENC_CMD_GET_MODE:
return "Get mode cmd"
case QENC_CMD_GET_BUFFER:
return "Get buffer cmd"
case QENC_CMD_GET_KEYS:
return "Get keys cmd"
case QENC_CMD_GET_BUFFSIZE:
return "Get buffsize cmd"
case QENC_CMD_SET_KEYS:
return "Set keys cmd"
case QENC_CMD_GET_CFG:
return "Get cfg cmd"
case QENC_CMD_INITIALIZE:
return "Initialize cmd"
case QENC_CMD_NONE:
return "None cmd"
case QENC_CMD_SET_BUFFER:
return "Set buffer cmd"
default:
return "Unknown cmd"
}
}
type QEncMode byte
const (
@ -35,6 +85,21 @@ const (
QENC_MODE_INIT QEncMode = 0x03
)
func (e QEncMode) String() string {
switch e {
case QENC_MODE_CLOSED:
return "Closed"
case QENC_MODE_OPEN:
return "Open"
case QENC_MODE_LOAD:
return "Load"
case QENC_MODE_INIT:
return "Init"
default:
return "Unknown"
}
}
type QEncSubMode byte
const (
@ -44,6 +109,21 @@ const (
QENC_SUB_MODE_VERIFY_PASSWORD QEncSubMode = 0x03
)
func (e QEncSubMode) String() string {
switch e {
case QENC_SUB_MODE_NONE:
return "None"
case QENC_SUB_MODE_SEED:
return "Seed"
case QENC_SUB_MODE_PASSWORD:
return "Password"
case QENC_SUB_MODE_VERIFY_PASSWORD:
return "Verify Password"
default:
return "Unknown"
}
}
type QEncCfg byte
const (
@ -91,71 +171,55 @@ func (q *QCfg) Initialized() bool {
}
func QCmdReset(dev *QEncDevice) (err error) {
buf, err := initBuffer(dev, QENC_CMD_RESET)
if err != nil {
return err
}
_, err = dev.SendBuffer(buf)
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
_, err = sendDataWrapper(dev, []byte{}, QENC_CMD_RESET, id)
return err
}
func QCmdUnlock(dev *QEncDevice) (err error) {
buf, err := initBuffer(dev, QENC_CMD_UNLOCK)
if err != nil {
return err
}
_, err = dev.SendBuffer(buf)
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
_, err = sendDataWrapper(dev, []byte{}, QENC_CMD_UNLOCK, id)
return err
}
func QCmdLock(dev *QEncDevice) (err error) {
buf, err := initBuffer(dev, QENC_CMD_LOCK)
if err != nil {
return err
}
_, err = dev.SendBuffer(buf)
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
_, err = sendDataWrapper(dev, []byte{}, QENC_CMD_LOCK, id)
return err
}
func QCmdInitialize(dev *QEncDevice) (err error) {
buf, err := initBuffer(dev, QENC_CMD_INITIALIZE)
if err != nil {
return err
}
_, err = dev.SendBuffer(buf)
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
_, err = sendDataWrapper(dev, []byte{}, QENC_CMD_INITIALIZE, id)
return err
}
func QCmdEncrypt(dev *QEncDevice, data []byte) (err error) {
return sendData(dev, data, QENC_CMD_ENCRYPT)
func QCmdEncrypt(dev *QEncDevice, data []byte) (ret []byte, err error) {
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
return sendDataWrapper(dev, data, QENC_CMD_ENCRYPT, id)
}
func QCmdDecrypt(dev *QEncDevice, data []byte) (err error) {
return sendData(dev, data, QENC_CMD_DECRYPT)
func QCmdDecrypt(dev *QEncDevice, data []byte) (ret []byte, err error) {
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
return sendDataWrapper(dev, data, QENC_CMD_DECRYPT, id)
}
func QCmdGetMode(dev *QEncDevice) (retm QEncMode, retsm QEncSubMode, err error) {
buf, err := initBuffer(dev, QENC_CMD_GET_MODE)
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
rbuf, err := sendDataWrapper(dev, []byte{}, QENC_CMD_GET_MODE, id)
if err != nil {
return retm, retsm, err
}
rbuf, err := dev.SendBuffer(buf)
if err != nil {
return retm, retsm, err
}
dataLen := binary.LittleEndian.Uint16(rbuf)
if int(dataLen) != 2 {
return retm, retsm, fmt.Errorf("Invalid data")
}
retm = QEncMode(rbuf[3])
retsm = QEncSubMode(rbuf[4])
retm = QEncMode(rbuf[0])
retsm = QEncSubMode(rbuf[1])
return retm, retsm, nil
}
@ -184,119 +248,126 @@ func QCmdSetCfgTimeout(dev *QEncDevice, val uint8) (err error) {
return setCfg(dev, QENC_CFG_TIMEOUT, val)
}
func QCmdGetBuffer(dev *QEncDevice) (ret []byte, err error) {
return receiveData(dev, QENC_CMD_GET_BUFFER)
}
func QCmdGetKeys(dev *QEncDevice) (ret []byte, err error) {
return receiveData(dev, QENC_CMD_GET_KEYS)
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
return sendDataWrapper(dev, []byte{}, QENC_CMD_GET_KEYS, id)
}
func QCmdSetKeys(dev *QEncDevice, data []byte) (err error) {
return sendData(dev, data, QENC_CMD_SET_KEYS)
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
_, err = sendDataWrapper(dev, data, QENC_CMD_SET_KEYS, id)
return err
}
func QCmdGetCfg(dev *QEncDevice) (ret *QCfg, err error) {
buf, err := initBuffer(dev, QENC_CMD_GET_CFG)
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
rbuf, err := sendDataWrapper(dev, []byte{}, QENC_CMD_GET_CFG, id)
if err != nil {
return ret, err
}
rbuf, err := dev.SendBuffer(buf)
if err != nil {
return ret, err
}
dataLen := binary.LittleEndian.Uint16(rbuf)
if int(dataLen) != 6 {
return ret, fmt.Errorf("Invalid data")
}
ret = &QCfg{}
ret.val = make([]byte, 6)
copy(ret.val, rbuf[3:3+dataLen])
copy(ret.val, rbuf[0:6])
return ret, nil
}
func setCfg(dev *QEncDevice, cfg QEncCfg, val uint8) (err error) {
buf, err := initBuffer(dev, QENC_CMD_SET_CFG)
if err != nil {
return err
}
data := []byte{byte(cfg), val}
binary.LittleEndian.PutUint16(buf[3:], uint16(2))
buf[5] = byte(cfg)
buf[6] = val
if _, err = dev.SendBuffer(buf); err != nil {
return err
}
return nil
rand.Seed(time.Now().UnixNano())
id := rand.Uint32()
_, err = sendDataWrapper(dev, data, QENC_CMD_SET_CFG, id)
return err
}
func sendData(dev *QEncDevice, data []byte, cmd QEncCmd) (err error) {
buf, err := initBuffer(dev, cmd)
if err != nil {
return err
}
func sendDataWrapper(dev *QEncDevice, data []byte, cmd QEncCmd, id uint32) (ret []byte, err error) {
done := make(chan bool)
msgc := make(chan string)
dataLen := len(data)
binary.LittleEndian.PutUint16(buf[3:], uint16(dataLen))
if dataLen <= (int(dev.GetBufSize()) - 5) {
copy(buf[5:], data)
if _, err = dev.SendBuffer(buf); err != nil {
return err
go func() {
defer func() { done <- true }()
ret, err = sendData(dev, data, cmd, id, msgc)
if err != nil {
if QEncErrHandler != nil {
QEncErrHandler(err)
}
return
}
return nil
}
}()
dataPos := 0
copy(buf[5:], data[:dev.GetBufSize()-5])
if _, err := dev.SendBuffer(buf); err != nil {
return err
}
dataPos += int(dev.GetBufSize()) - 5
buf[2] = byte(QENC_CMD_MORE_DATA)
end := false
for {
copy(buf[3:], data[dataPos:])
if _, err := dev.SendBuffer(buf); err != nil {
return nil
if end {
if QEncEndHandler != nil {
QEncEndHandler()
}
break
}
if (dataLen - dataPos) <= (int(dev.GetBufSize()) - 3) {
return nil
select {
case <-done:
end = true
if err != nil {
return ret, err
}
case msg := <-msgc:
if QEncInfoHandler != nil {
QEncInfoHandler(msg)
}
default:
time.Sleep(500 * time.Millisecond)
}
dataPos += int(dev.GetBufSize()) - 3
}
return ret, err
}
func receiveData(dev *QEncDevice, cmd QEncCmd) (ret []byte, err error) {
func sendData(dev *QEncDevice, data []byte, cmd QEncCmd, id uint32, msg chan string) (ret []byte, err error) {
buf, err := initBuffer(dev, cmd)
if err != nil {
return ret, err
}
for {
rbuf, err := dev.SendBuffer(buf)
if err != nil {
return ret, err
}
dataLen := len(data)
binary.LittleEndian.PutUint16(buf[3:], uint16(dataLen))
binary.LittleEndian.PutUint32(buf[5:], id)
if rbuf[0] == 1 {
dataLen := binary.LittleEndian.Uint16(rbuf[1:3])
if int(dataLen) > int(dev.GetBufSize())-3 {
dataPos := 0
for {
copy(buf[9:], data[dataPos:])
rbuf, err := dev.SendBuffer(buf, msg)
qerr := ToQEncError(err)
if err != nil && qerr.errCode != QENC_ERR_MORE_DATA {
return ret, err
} else if qerr.errCode == QENC_ERR_MORE_DATA {
resDataLen := binary.LittleEndian.Uint16(rbuf[1:3])
if int(resDataLen) > int(dev.GetBufSize())-3 {
return ret, fmt.Errorf("Invalid data")
}
b := make([]byte, dataLen)
b := make([]byte, resDataLen)
copy(b, rbuf[3:])
ret = append(ret, b...)
return ret, nil
continue
}
ret = append(ret, rbuf[1:]...)
resDataLen := binary.LittleEndian.Uint16(rbuf[0:2])
if int(resDataLen) > int(dev.GetBufSize())-2 {
return ret, fmt.Errorf("Invalid data")
}
b := make([]byte, resDataLen)
copy(b, rbuf[2:])
ret = append(ret, b...)
if (dataLen - dataPos) <= (int(dev.GetBufSize()) - 9) {
return ret, err
}
dataPos += int(dev.GetBufSize()) - 9
}
}

14
qmk-dev.go
View File

@ -45,7 +45,7 @@ func (d *QEncDevice) Close() (err error) {
return d.dev.Close()
}
func (d *QEncDevice) SendBuffer(data []byte) (ret []byte, err error) {
func (d *QEncDevice) SendBuffer(data []byte, msg chan string) (ret []byte, err error) {
startTime := time.Now()
for {
ret = make([]byte, d.bufSize)
@ -62,12 +62,22 @@ func (d *QEncDevice) SendBuffer(data []byte) (ret []byte, err error) {
return ret, fmt.Errorf("Failed to read: '%w'", err)
}
var dataLen uint16
ret, err = QEncCheckResponse(ret)
if err != nil {
qerr := ToQEncError(err)
if qerr.errCode != QENC_ERR_RETRY {
return ret, err
}
fmt.Println("RETRY")
dataLen = binary.LittleEndian.Uint16(ret[:2])
if int(dataLen) == 5 {
if msg != nil {
timeout := binary.LittleEndian.Uint32(ret[4:8])
cmd := QEncCmd(ret[3])
msg <- fmt.Sprintf("Allow request for '%s' (timeout: %ds)", cmd, timeout)
}
}
time.Sleep(time.Second * time.Duration(d.retryWait))
} else {
return ret, err
@ -114,7 +124,7 @@ func (d *QEncDevice) setBufSize() (err error) {
return fmt.Errorf("Invalid data")
}
d.bufSize = buf[3]
d.bufSize = buf[2]
return nil
}
return fmt.Errorf("Unsupported device: '%w'", err)

9
qmk-err.go
View File

@ -10,6 +10,7 @@ const (
QENC_ERR_INVALID QEncErr = 0x04
QENC_ERR_RETRY QEncErr = 0x05
QENC_ERR_HW_SUPPORT QEncErr = 0x06
QENC_ERR_MORE_DATA QEncErr = 0x07
// device retry timeout
QENC_ERR_TIMEOUT QEncErr = 0xFF
)
@ -32,6 +33,8 @@ func (e *QEncError) Error() string {
return "Retry request"
case QENC_ERR_HW_SUPPORT:
return "Not supported by hardware"
case QENC_ERR_MORE_DATA:
return "More data available"
case QENC_ERR_TIMEOUT:
return "Timeout reached"
default:
@ -47,6 +50,12 @@ func QEncCheckResponse(data []byte) (ret []byte, err error) {
rerr := new(QEncError)
rerr.errCode = QEncErr(data[0])
if data[0] == byte(QENC_ERR_RETRY) {
ret = data[1:]
} else {
ret = data
}
return ret, rerr
}