dlt645-server/protocol/message.go

package protocol

import (
	"bytes"
	"dlt645-server/errors"
	"encoding/binary"
	"encoding/json"
	"github.com/gogf/gf/os/glog"
	"reflect"
	"strconv"
)

// 消息包
type Message struct {
	Header Header
	Body   Entity
}

type DHeader struct {
	MsgID MsgID
}

// 协议编码
func (message *Message) Encode() ([]byte, error) {
	// 编码消息体
	var err error
	var body []byte
	if message.Body != nil && !reflect.ValueOf(message.Body).IsNil() {
		body, err = message.Body.Encode()
		if err != nil {
			return nil, err
		}

	}

	// 二进制转义
	buffer := bytes.NewBuffer(nil)

	message.write(buffer, body)
	return buffer.Bytes(), nil
}

// 协议解码
func (message *Message) Decode(data []byte) error {
	// 检验标志位
	length := len(data)
	if length == 0 {
		return errors.ErrInvalidMessage
	}
	if data[0] != ReceiveByte && data[0] != RegisterByte {
		return errors.ErrInvalidMessage
	}
	if !message.checkSum(data) {
		return errors.ErrInvalidCheckSum
	}
	var header Header
	var err error
	//处理注册包
	if data[0] == RegisterByte {

		header := Header{}
		_ = json.Unmarshal(data, &header)

		//fmt.Println(header.Imei)
		//fmt.Println()

		header.IccID, err = strconv.ParseUint(header.Imei, 10, 64)
		header.MsgID = 0x0040 //消息ID
		if err != nil {
			if err != nil {
				glog.Errorf("解析报文失败:%s", err.Error())
			}
		}
		message.Body = nil
		message.Header = header
		return nil
	}
	if len(data) < 8 {
		if err != nil {
			glog.Errorf("解析报文失败:%s", errors.ErrInvalidBody)
		}
	}
	if data[7] == 0x93 {
		entity, _, err := message.decode(uint32(0x93), data[:])
		if err != nil {
			glog.Errorf("解析报文失败:%s", err.Error())
		}
		message.Body = entity
	} else {
		header.MsgID = MsgID(binary.BigEndian.Uint32(data[10:15]))      //消息ID
		entity, _, err := message.decode(uint32(header.MsgID), data[:]) //解析实体对象 entity     buffer : 为消息标识
		if err != nil {
			glog.Errorf("解析报文失败:%s", err.Error())
		}
		message.Body = entity
	}

	message.Header = header
	return nil
}

//--->
func (message *Message) decode(dataType uint32, data []byte) (Entity, int, error) {
	creator, ok := entityMapper[dataType]
	if !ok {
		return nil, 0, errors.ErrTypeNotRegistered
	}

	entity := creator()

	count, err := entity.Decode(data) //解析data数据
	if err != nil {
		return nil, 0, err
	}
	return entity, count, nil
}

// 写入二进制数据
func (message *Message) write(buffer *bytes.Buffer, data []byte) *Message {
	for _, b := range data {
		if b == PrefixID {
			buffer.WriteByte(EscapeByte)
			buffer.WriteByte(EscapeByteSufix2)
		} else if b == EscapeByte {
			buffer.WriteByte(EscapeByte)
			buffer.WriteByte(EscapeByteSufix1)
		} else {
			buffer.WriteByte(b)
		}
	}
	return message
}

// 和校验
func (message *Message) checkSum(data []byte) bool {
	var checkSum byte
	for _, b := range data[:len(data)-2] {
		checkSum += b
	}
	checkSum = checkSum & 0xFF

	if checkSum == data[len(data)-2] {
		return true
	}
	return false
}