packet

package
v0.0.0-...-e544f28 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 22, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	VERSION310 byte = 0x3
	VERSION311 byte = 0x4
	VERSION500 byte = 0x5

	KB = 1024 * 1
	MB = 1024 * KB
)
View Source 
const MaximumPacketSize = 0x27
View Source 
const TopicAliasMaximum = 0x22

Variables

View Source 
var (
	// MQTTv3.1.1 specific bytes.
	Err3UnsupportedProtocolVersion = ReasonCode{Code: 0x01, Reason: "unsupported protocol version"}
	Err3ClientIdentifierNotValid   = ReasonCode{Code: 0x02, Reason: "client identifier not valid"}
	Err3ServerUnavailable          = ReasonCode{Code: 0x03, Reason: "server unavailable"}
	ErrMalformedUsernameOrPassword = ReasonCode{Code: 0x04, Reason: "malformed username or password"}
	Err3NotAuthorized              = ReasonCode{Code: 0x05, Reason: "not authorized"}

	// MQTT5
	CodeSuccessIgnore                         = ReasonCode{Code: 0x00, Reason: "ignore packet"}
	CodeSuccess                               = ReasonCode{Code: 0x00, Reason: "success", /* contains filtered or unexported fields */}       // CONNACK, PUBACK, PUBREC, PUBREL, PUBCOMP, UNSUBACK, AUTH
	CodeDisconnect                            = ReasonCode{Code: 0x00, Reason: "disconnected", /* contains filtered or unexported fields */}  // DISCONNECT
	CodeGrantedQos0                           = ReasonCode{Code: 0x00, Reason: "granted qos 0", /* contains filtered or unexported fields */} // SUBACK
	CodeGrantedQos1                           = ReasonCode{Code: 0x01, Reason: "granted qos 1"}                                               // SUBACK
	CodeGrantedQos2                           = ReasonCode{Code: 0x02, Reason: "granted qos 2"}                                               // SUBACK
	CodeDisconnectWillMessage                 = ReasonCode{Code: 0x04, Reason: "disconnect with will message"}                                // DISCONNECT
	CodeNoMatchingSubscribers                 = ReasonCode{Code: 0x10, Reason: "no matching subscribers"}
	CodeNoSubscriptionExisted                 = ReasonCode{Code: 0x11, Reason: "no subscription existed"}
	CodeContinueAuthentication                = ReasonCode{Code: 0x18, Reason: "continue authentication"}
	CodeReAuthenticate                        = ReasonCode{Code: 0x19, Reason: "re-authenticate"}
	ErrUnspecifiedError                       = ReasonCode{Code: 0x80, Reason: "unspecified error"}
	ErrMalformedPacket                        = ReasonCode{Code: 0x81, Reason: "malformed packet"}
	ErrMalformedProtocolName                  = ReasonCode{Code: 0x81, Reason: "malformed packet: protocol name"}
	ErrMalformedProtocolVersion               = ReasonCode{Code: 0x81, Reason: "malformed packet: protocol version"}
	ErrMalformedFlags                         = ReasonCode{Code: 0x81, Reason: "malformed packet: flags"}
	ErrMalformedKeepalive                     = ReasonCode{Code: 0x81, Reason: "malformed packet: keepalive"}
	ErrMalformedPacketID                      = ReasonCode{Code: 0x81, Reason: "malformed packet: packet identifier"}
	ErrMalformedTopic                         = ReasonCode{Code: 0x81, Reason: "malformed packet: topic"}
	ErrMalformedWillTopic                     = ReasonCode{Code: 0x81, Reason: "malformed packet: will topic"}
	ErrMalformedWillPayload                   = ReasonCode{Code: 0x81, Reason: "malformed packet: will message"}
	ErrMalformedUsername                      = ReasonCode{Code: 0x81, Reason: "malformed packet: username"}
	ErrMalformedPassword                      = ReasonCode{Code: 0x81, Reason: "malformed packet: password"}
	ErrMalformedQos                           = ReasonCode{Code: 0x81, Reason: "malformed packet: qos"}
	ErrMalformedOffsetUintOutOfRange          = ReasonCode{Code: 0x81, Reason: "malformed packet: offset uint out of range"}
	ErrMalformedOffsetBytesOutOfRange         = ReasonCode{Code: 0x81, Reason: "malformed packet: offset bytes out of range"}
	ErrMalformedOffsetByteOutOfRange          = ReasonCode{Code: 0x81, Reason: "malformed packet: offset byte out of range"}
	ErrMalformedOffsetBoolOutOfRange          = ReasonCode{Code: 0x81, Reason: "malformed packet: offset boolean out of range"}
	ErrMalformedInvalidUTF8                   = ReasonCode{Code: 0x81, Reason: "malformed packet: invalid utf-8 string"}
	ErrMalformedVariableByteInteger           = ReasonCode{Code: 0x81, Reason: "malformed packet: variable byte integer out of range"}
	ErrMalformedBadProperty                   = ReasonCode{Code: 0x81, Reason: "malformed packet: unknown property"}
	ErrMalformedProperties                    = ReasonCode{Code: 0x81, Reason: "malformed packet: properties"}
	ErrMalformedWillProperties                = ReasonCode{Code: 0x81, Reason: "malformed packet: will properties"}
	ErrMalformedSessionPresent                = ReasonCode{Code: 0x81, Reason: "malformed packet: session present"}
	ErrMalformedReasonCode                    = ReasonCode{Code: 0x81, Reason: "malformed packet: reason code"}
	ErrProtocolErr                            = ReasonCode{Code: 0x82, Reason: "protocol error"}
	ErrProtocolViolation                      = ReasonCode{Code: 0x82, Reason: "protocol violation"}
	ErrProtocolViolationProtocolName          = ReasonCode{Code: 0x82, Reason: "protocol violation: protocol name"}
	ErrProtocolViolationProtocolVersion       = ReasonCode{Code: 0x82, Reason: "protocol violation: protocol version"}
	ErrProtocolViolationReservedBit           = ReasonCode{Code: 0x82, Reason: "protocol violation: reserved bit not 0"}
	ErrProtocolViolationFlagNoUsername        = ReasonCode{Code: 0x82, Reason: "protocol violation: username flag set but no value"}
	ErrProtocolViolationFlagNoPassword        = ReasonCode{Code: 0x82, Reason: "protocol violation: password flag set but no value"}
	ErrProtocolViolationUsernameNoFlag        = ReasonCode{Code: 0x82, Reason: "protocol violation: username set but no flag"}
	ErrProtocolViolationPasswordNoFlag        = ReasonCode{Code: 0x82, Reason: "protocol violation: username set but no flag"}
	ErrProtocolViolationPasswordTooLong       = ReasonCode{Code: 0x82, Reason: "protocol violation: password too long"}
	ErrProtocolViolationUsernameTooLong       = ReasonCode{Code: 0x82, Reason: "protocol violation: username too long"}
	ErrProtocolViolationNoPacketID            = ReasonCode{Code: 0x82, Reason: "protocol violation: missing packet id"}
	ErrProtocolViolationSurplusPacketID       = ReasonCode{Code: 0x82, Reason: "protocol violation: surplus packet id"}
	ErrProtocolViolationQosOutOfRange         = ReasonCode{Code: 0x82, Reason: "protocol violation: qos out of range"}
	ErrProtocolViolationSecondConnect         = ReasonCode{Code: 0x82, Reason: "protocol violation: second connect packet"}
	ErrProtocolViolationZeroNonZeroExpiry     = ReasonCode{Code: 0x82, Reason: "protocol violation: non-zero expiry"}
	ErrProtocolViolationRequireFirstConnect   = ReasonCode{Code: 0x82, Reason: "protocol violation: first packet must be connect"}
	ErrProtocolViolationWillFlagNoPayload     = ReasonCode{Code: 0x82, Reason: "protocol violation: will flag no payload"}
	ErrProtocolViolationWillFlagSurplusRetain = ReasonCode{Code: 0x82, Reason: "protocol violation: will flag surplus retain"}
	ErrProtocolViolationSurplusWildcard       = ReasonCode{Code: 0x82, Reason: "protocol violation: topic contains wildcards"}
	ErrProtocolViolationSurplusSubID          = ReasonCode{Code: 0x82, Reason: "protocol violation: contained subscription identifier"}
	ErrProtocolViolationInvalidTopic          = ReasonCode{Code: 0x82, Reason: "protocol violation: invalid topic"}
	ErrProtocolViolationInvalidSharedNoLocal  = ReasonCode{Code: 0x82, Reason: "protocol violation: invalid shared no local"}
	ErrProtocolViolationNoFilters             = ReasonCode{Code: 0x82, Reason: "protocol violation: must contain at least one filter"}
	ErrProtocolViolationInvalidReason         = ReasonCode{Code: 0x82, Reason: "protocol violation: invalid reason"}
	ErrProtocolViolationOversizeSubID         = ReasonCode{Code: 0x82, Reason: "protocol violation: oversize subscription id"}
	ErrProtocolViolationDupNoQos              = ReasonCode{Code: 0x82, Reason: "protocol violation: dup true with no qos"}
	ErrProtocolViolationUnsupportedProperty   = ReasonCode{Code: 0x82, Reason: "protocol violation: unsupported property"}
	ErrProtocolViolationNoTopic               = ReasonCode{Code: 0x82, Reason: "protocol violation: no topic or alias"}
	ErrImplementationSpecificError            = ReasonCode{Code: 0x83, Reason: "implementation specific error"}
	ErrRejectPacket                           = ReasonCode{Code: 0x83, Reason: "packet rejected"}
	ErrUnsupportedProtocolVersion             = ReasonCode{Code: 0x84, Reason: "unsupported protocol version"}
	ErrClientIdentifierNotValid               = ReasonCode{Code: 0x85, Reason: "client identifier not valid"}
	ErrClientIdentifierTooLong                = ReasonCode{Code: 0x85, Reason: "client identifier too long"}
	ErrBadUsernameOrPassword                  = ReasonCode{Code: 0x86, Reason: "bad username or password"}
	ErrNotAuthorized                          = ReasonCode{Code: 0x87, Reason: "not authorized"}
	ErrServerUnavailable                      = ReasonCode{Code: 0x88, Reason: "server unavailable"}
	ErrServerBusy                             = ReasonCode{Code: 0x89, Reason: "server busy"}
	ErrBanned                                 = ReasonCode{Code: 0x8A, Reason: "banned"}
	ErrServerShuttingDown                     = ReasonCode{Code: 0x8B, Reason: "server shutting down"}
	ErrBadAuthenticationMethod                = ReasonCode{Code: 0x8C, Reason: "bad authentication method"}
	ErrKeepAliveTimeout                       = ReasonCode{Code: 0x8D, Reason: "keep alive timeout"}
	ErrSessionTakenOver                       = ReasonCode{Code: 0x8E, Reason: "session takeover"}
	ErrTopicFilterInvalid                     = ReasonCode{Code: 0x8F, Reason: "topic filter invalid"}
	ErrTopicNameInvalid                       = ReasonCode{Code: 0x90, Reason: "topic name invalid"}
	ErrPacketIdentifierInUse                  = ReasonCode{Code: 0x91, Reason: "packet identifier in use"}
	ErrPacketIdentifierNotFound               = ReasonCode{Code: 0x92, Reason: "packet identifier not found"}
	ErrReceiveMaximum                         = ReasonCode{Code: 0x93, Reason: "receive maximum exceeded"}
	ErrTopicAliasInvalid                      = ReasonCode{Code: 0x94, Reason: "topic alias invalid"}
	ErrPacketTooLarge                         = ReasonCode{Code: 0x95, Reason: "packet too large"}
	ErrMessageRateTooHigh                     = ReasonCode{Code: 0x96, Reason: "message rate too high"}
	ErrQuotaExceeded                          = ReasonCode{Code: 0x97, Reason: "quota exceeded"}
	ErrPendingClientWritesExceeded            = ReasonCode{Code: 0x97, Reason: "too many pending writes"}
	ErrAdministrativeAction                   = ReasonCode{Code: 0x98, Reason: "administrative action"}
	ErrPayloadFormatInvalid                   = ReasonCode{Code: 0x99, Reason: "payload format invalid"}
	ErrRetainNotSupported                     = ReasonCode{Code: 0x9A, Reason: "retain not supported"}
	ErrQosNotSupported                        = ReasonCode{Code: 0x9B, Reason: "qos not supported"}
	ErrUseAnotherServer                       = ReasonCode{Code: 0x9C, Reason: "use another server"}
	ErrServerMoved                            = ReasonCode{Code: 0x9D, Reason: "server moved"}
	ErrSharedSubscriptionsNotSupported        = ReasonCode{Code: 0x9E, Reason: "shared subscriptions not supported"}
	ErrConnectionRateExceeded                 = ReasonCode{Code: 0x9F, Reason: "connection rate exceeded"}               // CONNACK, DISCONNECT
	ErrMaxConnectTime                         = ReasonCode{Code: 0xA0, Reason: "maximum connect time"}                   // DISCONNECT
	ErrSubscriptionIdentifiersNotSupported    = ReasonCode{Code: 0xA1, Reason: "subscription identifiers not supported"} // SUBACK, DISCONNECT
	ErrWildcardSubscriptionsNotSupported      = ReasonCode{Code: 0xA2, Reason: "wildcard subscriptions not supported"}   // SUBACK, DISCONNECT
)
View Source 
var (
	ErrProtocolError = ReasonCode{Code: 0x82, Reason: "protocol error"}
)

Created by me.

View Source 
var Kind = map[byte]string{
	0x0: "[0x0]RESERVED",
	0x1: "[0x1]CONNECT",
	0x2: "[0x2]CONNACK",
	0x3: "[0x3]PUBLISH",
	0x4: "[0x4]PUBACK",
	0x5: "[0x5]PUBREC",
	0x6: "[0x6]PUBREL",
	0x7: "[0x7]PUBCOMP",
	0x8: "[0x8]SUBSCRIBE",
	0x9: "[0x9]SUBACK",
	0xA: "[0xA]UNSUBSCRIBE",
	0xB: "[0xB]UNSUBACK",
	0xC: "[0xC]PINGREQ",
	0xD: "[0xD]PINGRESP",
	0xE: "[0xE]DISCONNECT",
	0xF: "[0xF]AUTH",
}

Kind Control packet types. Position: byte 1, bits 7-4

View Source 
var NAME = []byte{0x00, 0x04, 'M', 'Q', 'T', 'T'}

Functions

func GetBuffer 

func GetBuffer() *bytes.Buffer

func PutBuffer 

func PutBuffer(buf *bytes.Buffer)

Types

type AUTH 

type AUTH struct {
	*FixedHeader
	AuthenticationReasonCode ReasonCode
	AuthProps                *AuthProperties
}

func (*AUTH) Kind 

func (pkt *AUTH) Kind() byte

func (*AUTH) Packet 

func (pkt *AUTH) Packet(w io.Writer) error

func (*AUTH) Unpack 

func (pkt *AUTH) Unpack(buf *bytes.Buffer) error

type AuthProperties 

type AuthProperties struct {
	AuthenticationMethod string
	AuthenticationData   []byte
	ReasonString         string

	UserProperty map[string][]string
}

func (*AuthProperties) Pack 

func (props *AuthProperties) Pack() ([]byte, error)

func (*AuthProperties) Unpack 

func (props *AuthProperties) Unpack(buf *bytes.Buffer) error

type Buffer 

type Buffer struct {
	// contains filtered or unexported fields
}

func (*Buffer) Get 

func (b *Buffer) Get() *bytes.Buffer

func (*Buffer) Put 

func (b *Buffer) Put(buf *bytes.Buffer)

type CONNACK 

type CONNACK struct {
	*FixedHeader

	// 可变报头
	SessionPresent uint8 // byte1.bits0, bits 7-6. Reserved,

	// ConnectReturnCode ConnectReturnCode
	// 如果服务端收到一个合法的CONNECT报文，但出于某些原因无法处理它，服务端应该尝试发送一个包含非零返回码（表格中的某一个）的 CONNACK 报文。
	// 如果服务端发送了一个包含非零返回码的 CONNACK 报文，那么它必须关闭网络连接 [MQTT-3.2.2-5].
	// 0x00 连接已接受 					连接已被服务端接受
	// 0x01 连接已拒绝，不支持的协议版本 	服务端不支持客户端请求的 MQTT 协议级别
	// 0x02 连接已拒绝，不合格的客户端标识符	客户端标识符是正确的 UTF-8 编码，但服务端不允许使用
	// 0x03 连接已拒绝，服务端不可用		网络连接已建立，但 MQTT 服务不可用
	// 0x04 连接已拒绝，无效的用户名或密码	用户名或密码的数据格式无效
	// 0x05 连接已拒绝，未授权
	// --
	// 如果认为上表中的所有连接返回码都不太合适，那么服务端必须关闭网络连接，不需要发送 CONNACK 报文 [MQTT-3.2.2-6]。
	ConnectReturnCode ReasonCode `json:"ConnectReturnCode,omitempty"` // ConnectReturnCode
	ConnackProps      *ConnackProps
}

func (*CONNACK) Kind 

func (pkt *CONNACK) Kind() byte

func (*CONNACK) Pack 

func (pkt *CONNACK) Pack(w io.Writer) error

func (*CONNACK) String 

func (pkt *CONNACK) String() string

func (*CONNACK) Unpack 

func (pkt *CONNACK) Unpack(buf *bytes.Buffer) error

type CONNECT 

type CONNECT struct {
	*FixedHeader

	// uint8 连接标志（Connect Flags）: 也是在报文处理的时候使用，不设置存储字段
	ConnectFlags ConnectFlags

	// 保持连接（Keep Alive）
	KeepAlive uint16

	// 属性（Properties）
	Props *ConnectProperties `json:"Properties,omitempty"`

	// Connect 载荷
	// CONNECT Payload
	ClientID string `json:"ClientID,omitempty"` // Client 客户端ID

	// 这个是v5独有的
	WillProperties *WillProperties `json:"Will,omitempty"`

	// 3.1.3.3 遗嘱主题
	//如果遗嘱标志（Will Flag）被设置为 1，遗嘱主题（Will Topic）为载荷中下一个字段。遗嘱主题（Will
	//1.5.4 节 所定义 [MQTT-3.1.3-11]。
	WillTopic string

	// 3.1.3.4 遗嘱载荷
	//如果遗嘱标志（Will Flag）被设置为 1，遗嘱载荷（Will Payload）为载荷中下一个字段。遗嘱载荷定义了
	//将要发布到遗嘱主题（Will Topic）的应用消息载荷，如 3.1.2.5 节 所定义。此字段为二进制数据。
	WillPayload []byte
	// 3.1.3.5 用户名
	//如果用户名标志（User Name Flag）被设置为 1，用户名（User Name）为载荷中下一个字段。用户名必
	//须是 1.5.4 节 定义的 UTF-8 编码字符串 [MQTT-3.1.3-12]。服务端可以将它用于身份验证和授权。
	Username string `json:"Username,omitempty"` // v311: 3.1.3.4 	v500: 3.1.3.5

	// 3.1.3.6 密码
	//如果密码标志（Password Flag）被设置为 1，密码（Password）为载荷中下一个字段。密码字段是二进
	//制数据，尽管被称为密码，但可以被用来承载任何认证信息。
	Password string `json:"Password,omitempty"` // v311: 3.1.3.5	v500: 3.1.3.6
}

func (*CONNECT) Kind 

func (pkt *CONNECT) Kind() byte

func (*CONNECT) Pack 

func (pkt *CONNECT) Pack(w io.Writer) error

func (*CONNECT) String 

func (pkt *CONNECT) String() string

func (*CONNECT) Unpack 

func (pkt *CONNECT) Unpack(buf *bytes.Buffer) error

type ConnackProps 

type ConnackProps struct {

	//3.2.2.3.2
	//会话过期间隔
	//17 (0x11)，会话过期间隔（Session Expiry Interval）标识符。
	//跟随其后的是用四字节整数表示的以秒为单位的会话过期间隔（Session Expiry Interval）。包含多个会话
	//过期间隔（Session Expiry Interval）将造成协议错误（Protocol Error）。
	//如果会话过期间隔（Session Expiry Interval）值未指定，则使用 CONNECT 报文中指定的会话过期时间间
	//隔。服务端使用此属性通知客户端它使用的会话过期时间间隔与客户端在 CONNECT 中发送的值不同。更
	//详细的关于会话过期时间的描述，请参考 3.1.2.11.2 节 。
	SessionExpiryInterval uint32

	// 3.2.2.3.3
	//接收最大值
	//33 (0x21)，接收最大值（Receive Maximum）描述符。
	//跟随其后的是由双字节整数表示的最大接收值。包含多个接收最大值或接收最大值为 0 将造成协议错误
	//（Protocol Error）。
	//服务端使用此值限制服务端愿意为该客户端同时处理的 QoS 为 1 和 QoS 为 2 的发布消息最大数量。没有
	//机制可以限制客户端试图发送的 QoS 为 0 的发布消息。
	// 如果没有设置最大接收值，将使用默认值 65535。
	//关于接收最大值的详细使用，参考 4.9 节 流控部分。
	ReceiveMaximum uint16

	// 3.2.2.3.4
	//最大服务质量
	//36 (0x24)，最大服务质量（Maximum QoS）标识符。
	//跟随其后的是用一个字节表示的 0 或 1。包含多个最大服务质量（Maximum QoS）或最大服务质量既不为
	//0 也不为 1 将造成协议错误。如果没有设置最大服务质量，客户端可使用最大 QoS 为 2。
	//如果服务端不支持 Qos 为 1 或 2 的 PUBLISH 报文，服务端必须在 CONNACK 报文中发送最大服务质量以
	//指定其支持的最大 QoS 值 [MQTT-3.2.2-9]。即使不支持 QoS 为 1 或 2 的 PUBLISH 报文，服务端也必须
	//接受请求 QoS 为 0、1 或 2 的 SUBSCRIBE 报文 [MQTT-3.2.2-10]。
	//如果从服务端接收到了最大 QoS 等级，则客户端不能发送超过最大 QoS 等级所指定的 QoS 等级的
	//PUBLISH 报文 [MQTT-3.2.2-11]。服务端接收到超过其指定的最大服务质量的 PUBLISH 报文将造成协议
	//错误（Protocol Error）。这种情况下应使用包含原因码为 0x9B（不支持的 QoS 等级）的 DISCONNECT
	//报文进行处理，如 4.13 节 所述。
	//如果服务端收到包含遗嘱的 QoS 超过服务端处理能力的 CONNECT 报文，服务端必须拒绝此连接。服务
	//端应该使用包含原因码为 0x9B（不支持的 QoS 等级）的 CONNACK 报文进行错误处理，随后必须关闭网
	//络连接。4.13 节 所述 [MQTT-3.2.2-12]。
	//非规范评注
	//客户端不必支持 QoS 为 1 和 2 的 PUBLISH 报文。客户端只需将其发送的任何 SUBSCRIBE 报文
	//中的 QoS 字段限制在其支持的最大服务质量以内即可。
	MaximumQoS uint8

	RetainAvailable uint8
	// 3.2.2.3.6
	//最大报文长度
	//39 (0x27)，最大报文长度（Maximum Packet Size）标识符。
	//跟随其后的是由四字节整数表示的服务端愿意接收的最大报文长度（Maximum Packet Size）。如果没有
	//设置最大报文长度，则按照协议由固定报头中的剩余长度可编码最大值和协议报头对数据包的大小做限制。
	//包含多个最大报文长度（Maximum Packet Size），或最大报文长度为 0 将造成协议错误（Protocol
	//Error）。
	//如 2.1.4 节 所述，最大报文长度是 MQTT 控制报文的总长度。服务端使用最大报文长度通知客户端其所能
	//处理的单个报文长度限制。
	//客户端不能发送超过最大报文长度（Maximum Packet Size）的报文给服务端 [MQTT-3.2.2-15]。收到长度
	//超过限制的报文将导致协议错误，此时服务端应该发送包含原因码 0x95（报文过长）的 DISCONNECT 报
	//文给客户端，详见 4.13 节。
	MaximumPacketSize uint32

	//3.2.2.3.7
	//分配客户标识符
	//18 (0x12)，分配客户标识符（Assigned Client Identifier）标识符。
	//跟随其后的是 UTF-8 编码的分配客户标识符（Assigned Client Identifier）字符串。包含多个分配客户标识
	//符将造成协议错误（Protocol Error）。
	//服务端分配客户标识符的原因是 CONNECT 报文中的客户标识符长度为 0。
	//如果客户端使用长度为 0 的客户标识符（ClientID），服务端必须回复包含分配客户标识符（Assigned
	//Client Identifier）的 CONNACK 报文。分配客户标识符必须是没有被服务端的其他会话所使用的新客户标
	//识符 [MQTT-3.2.2-16]。
	AssignedClientID string

	//3.2.2.3.8
	//主题别名最大值
	//34 (0x22)，主题别名最大值（Topic Alias Maximum）标识符。
	//跟随其后的是用双字节整数表示的主题别名最大值（Topic Alias Maximum）。包含多个主题别名最大值
	//（Topic Alias Maximum）将造成协议错误（Protocol Error）。没有设置主题别名最大值属性的情况下，主
	//题别名最大值默认为零。
	//此值指示了服务端能够接收的来自客户端的主题别名（Topic Alias）最大值。服务端使用此值来限制本次
	//连接可以拥有的主题别名的值。客户端在一个 PUBLISH 报文中发送的主题别名值不能超过服务端设置的主
	//题别名最大值（Topic Alias Maximum） [MQTT-3.2.2-17]。值为 0 表示本次连接服务端不接受任何主题别
	//名（Topic Alias）。如果主题别名最大值（Topic Alias）没有设置，或者设置为 0，则客户端不能向此服务
	//端发送任何主题别名（Topic Alias） [MQTT-3.2.2-18]。
	TopicAliasMaximum uint16

	//3.2.2.3.9
	//原因字符串
	//31 (0x1F)，原因字符串（Reason String）标识符。
	// 跟随其后的是 UTF-8 编码的字符串，表示此次响应相关的原因。此原因字符串（Reason String）是为诊断
	//而设计的可读字符串，不应该被客户端所解析。
	//服务端使用此值向客户端提供附加信息。如果加上原因字符串之后的 CONNACK 报文长度超出了客户端指
	//定的最大报文长度，则服务端不能发送此原因字符串 [MQTT-3.2.2-19]。包含多个原因字符串将造成协议错
	//误（Protocol Error）。
	//非规范评注
	//客户端对原因字符串的恰当使用包括：抛出异常时使用此字符串，或者将此字符串写入日志。
	ReasonString string

	//3.2.2.3.10
	//用户属性
	//38 (0x26)，用户属性（User Property）标识符。
	//跟随其后的是 UTF-8 字符串对。此属性可用于向客户端提供包括诊断信息在内的附加信息。如果加上用户
	//属性之后的 CONNACK 报文长度超出了客户端指定的最大报文长度，则服务端不能发送此属性 [MQTT-
	//3.2.2-20]。用户属性（User Property）允许出现多次，以表示多个名字/值对，且相同的名字可以多次出现。
	//用户属性的内容和意义本规范不做定义。CONNACK 报文的接收端可以选择忽略此属性。
	UserProperty map[string][]string
	//3.2.2.3.11
	//通配符订阅可用
	//40 (0x28)，通配符订阅可用（Wildcard Subscription Available）标识符。
	//跟随其后的是一个单字节字段，用来声明服务器是否支持通配符订阅（Wildcard Subscriptions）。值为 0
	//表示不支持通配符订阅，值为 1 表示支持通配符订阅。如果没有设置此值，则表示支持通配符订阅。包含
	//多个通配符订阅可用属性，或通配符订阅可用属性值不为 0 也不为 1 将造成协议错误（Protocol Error）。
	//如果服务端在不支持通配符订阅（Wildcard Subscription）的情况下收到了包含通配符订阅的 SUBSCRIBE
	//报文，将造成协议错误（Protocol Error）。此时服务端将发送包含原因码为 0xA2（通配符订阅不支持）的
	//DISCONNECT 报文，如 4.13 节 所述。
	//服务端在支持通配符订阅的情况下仍然可以拒绝特定的包含通配符订阅的订阅请求。这种情况下，服务端
	//可以发送一个包含原因码为 0xA2（通配符订阅不支持）的 SUBACK 报文。
	WildcardSubscriptionAvailable uint8

	//3.2.2.3.12
	//订阅标识符可用
	//41 (0x29)，订阅标识符可用（Subscription Identifier Available）标识符。
	//跟随其后的是一个单字节字段，用来声明服务端是否支持订阅标识符（Subscription Identifiers）。值为 0
	//表示不支持订阅标识符，值为 1 表示支持订阅标识符。如果没有设置此值，则表示支持订阅标识符。包含
	//多个订阅标识符可用属性，或订阅标识符可用属性值不为 0 也不为 1 将造成协议错误（Protocol Error）。
	//如果服务端在不支持订阅标识符（Subscription Identifier）的情况下收到了包含订阅标识符的 SUBSCRIBE
	//报文，将造成协议错误（Protocol Error）。此时服务端将发送包含原因码为 0xA1（订阅标识符不支持）的
	//DISCONNECT 报文，如 4.13 节 所述。
	SubscriptionIdentifierAvailable uint8

	// 3.2.2.3.13
	//共享订阅可用
	//42 (0x2A)，共享订阅可用（Shared Subscription Available）标识符。
	//跟随其后的是一个单字节字段，用来声明服务端是否支持共享订阅（Shared Subscription）。值为 0 表示
	//不支持共享订阅，值为 1 表示支持共享订阅。如果没有设置此值，则表示支持共享订阅。包含多个共享订
	//阅可用（Shared Subscription Available），或共享订阅可用属性值不为 0 也不为 1 将造成协议错误
	//（Protocol Error）。
	//如果服务端在不支持共享订阅（Shared Subscription）的情况下收到了包含共享订阅的 SUBSCRIBE 报文，
	//将造成协议错误（Protocol Error）。此时服务端将发送包含原因码为 0x9E（共享订阅不支持）的
	//DISCONNECT 报文，如 4.13 节 所述。
	SharedSubscriptionAvailable uint8

	//3.2.2.3.14
	//服务端保持连接
	//19 (0x13)，服务端保持连接（Server Keep Alive）标识符。
	//跟随其后的是由服务端分配的双字节整数表示的保持连接（Keep Alive）时间。如果服务端发送了服务端保
	//持连接（Server Keep Alive）属性，客户端必须使用此值代替其在 CONNECT 报文中发送的保持连接时间
	//值 [MQTT-3.2.2-21]。如果服务端没有发送服务端保持连接属性，服务端必须使用客户端在 CONNECT 报
	//文中设置的保持连接时间值 [MQTT-3.2.2-22]。包含多个服务端保持连接属性将造成协议错误（Protocol
	//Error）。
	//非规范评注
	//客户端。
	//服务端保持连接属性的主要作用是通知客户端它将会比客户端指定的保持连接更快的断开非活动的
	ServerKeepAlive uint16

	//3.2.2.3.15
	//响应信息
	//26 (0x1A)，响应信息（Response Information）标识符。
	//跟随其后的是一个以 UTF-8 编码的字符串，作为创建响应主题（Response Topic）的基本信息。关于客户
	//端如何根据响应信息（Response Information）创建响应主题不在本规范的定义范围内。包含多个响应信息
	//将造成协议错误（Protocol Error）。
	//如果客户端发送的请求响应信息（Request Response Information）值为 1，则服务端在 CONNACK 报文
	//中发送响应信息（Response Information）为可选项。
	//非规范评注
	//响应信息通常被用来传递主题订阅树的一个全局唯一分支，此分支至少在该客户端的会话生命周期
	//内为该客户端所保留。请求客户端和响应客户端的授权需要使用它，所以它通常不能仅仅是一个随
	//机字符串。一般把此分支作为特定客户端的订阅树根节点。通常此信息需要正确配置，以使得服务
	//器能返回信息。使用此机制时，具体的信息一般由服务端来进行统一配置，而非由各个客户端自己
	//配置。
	ResponseInformation string

	// ServerReference 3.2.2.3.16 28 (0x1C)，服务端参考（Server Reference）标识符。
	//跟随其后的是一个以 UTF-8 编码的字符串，可以被客户端用来标识其他可用的服务端。包含多个服务端参
	//考（Server Reference）将造成协议错误（Protocol Error）。
	//服务端在包含了原因码为 0x9C（（临时）使用其他服务端）或 0x9D（服务端已（永久）移动）的
	//CONNACK 报文或 DISCONNECT 报文中设置服务端参考，如 4.13 节 所述。
	//关于如何使用服务端参考，请参考 4.11 节 服务端重定向信息。
	ServerReference string

	// AuthenticationMethod 3.2.2.3.17 认证方法 21 (0x15)，认证方法（Authentication Method）标识符。
	// 跟随其后的是一个以 UTF-8 编码的字符串，包含了认证方法（Authentication Method）名。包含多个认证
	// 方法将造成协议错误（Protocol Error）。更多关于扩展认证的信息，请参考 4.12 节 。
	AuthenticationMethod string

	// AuthenticationData 22 (0x16) 认证数据 3.2.2.3.18
	// 跟随其后的是包含认证数据（Authentication Data）的二进制数据。
	// 此数据的内容由认证方法和已交换的认证数据状态定义。
	// 包含多个认证数据将造成协议错误（Protocol Error）。
	// 更多关于扩展认证的信息，请参考 4.12 节 。
	AuthenticationData []byte
}

func (*ConnackProps) Pack 

func (props *ConnackProps) Pack() ([]byte, error)

func (*ConnackProps) Unpack 

func (props *ConnackProps) Unpack(b *bytes.Buffer) error

type ConnectFlags 

type ConnectFlags uint8

func (ConnectFlags) CleanStart 

func (f ConnectFlags) CleanStart() bool

func (ConnectFlags) PasswordFlag 

func (f ConnectFlags) PasswordFlag() bool

func (ConnectFlags) Reserved 

func (f ConnectFlags) Reserved() uint8

func (ConnectFlags) UserNameFlag 

func (f ConnectFlags) UserNameFlag() bool

func (ConnectFlags) WillFlag 

func (f ConnectFlags) WillFlag() bool

func (ConnectFlags) WillQoS 

func (f ConnectFlags) WillQoS() uint8

func (ConnectFlags) WillRetain 

func (f ConnectFlags) WillRetain() bool

type ConnectProperties 

type ConnectProperties struct {
	// CONNECT 报文可变报头中的属性（Properties）长度被编码为变长字节整数。
	//PropertyLength int
	// 17 (0x11)，会话过期间隔（Session Expiry Interval）标识符。
	// 跟随其后的是用四字节整数表示的以秒为单位的会话过期间隔（Session Expiry Interval）。
	//包含多个会话过期间隔（Session Expiry Interval）将造成协议错误（Protocol Error）。
	//如果会话过期间隔（Session Expiry Interval）值未指定，则使用 0。
	//如果设置为 0 或者未指定，会话将在网络连接（Network Connection）关闭时结束。
	//如果会话过期间隔（Session Expiry Interval）为 0xFFFFFFFF (UINT_MAX)，则会话永不过期。
	//如果网络连接关闭时会话过期间隔（Session Expiry Interval）大于 0，则客户端与服务端必须存储会话状态 [MQTT-3.1.2-23]。
	SessionExpiryInterval uint32
	// 33 (0x21)，接收最大值（Receive Maximum）标识符。
	//跟随其后的是由双字节整数表示的最大接收值。包含多个接收最大值或接收最大值为 0 将造成协议错误
	//（Protocol Error）。
	//客户端使用此值限制客户端愿意同时处理的 QoS 等级 1 和 QoS 等级 2 的发布消息最大数量。没有机制可
	//以限制服务端试图发送的 QoS 为 0 的发布消息。
	//接收最大值只将被应用在当前网络连接。如果没有设置最大接收值，将使用默认值 65535。
	//关于接收最大值的详细使用，参考 4.9 节 流控。
	ReceiveMaximum uint16
	// 39 (0x27)，最大报文长度（Maximum Packet Size）标识符。
	//跟随其后的是由四字节整数表示的客户端愿意接收的最大报文长度（Maximum Packet Size），如果没有
	//设置最大报文长度（Maximum Packet Size），则按照协议由固定报头中的剩余长度可编码最大值和协议
	//报头对数据包的大小做限制。
	//包含多个最大报文长度（Maximum Packet Size）或者最大报文长度（Maximum Packet Size）值为 0 将
	//造成协议错误。
	//非规范评注
	//客户端如果选择了限制最大报文长度，应该为最大报文长度设置一个合理的值。
	//如 2.1.4 节 所述，最大报文长度是 MQTT 控制报文的总长度。客户端使用最大报文长度通知服务端其所能
	//处理的单个报文长度限制。
	// 服务端不能发送超过最大报文长度（Maximum Packet Size）的报文给客户端 [MQTT-3.1.2-24]。收到长度
	//超过限制的报文将导致协议错误，客户端发送包含原因码 0x95（报文过大）的 DISCONNECT 报文给服务
	//端，详见 4.13 节。
	//当报文过大而不能发送时，服务端必须丢弃这些报文，然后当做应用消息发送已完成处理 [MQTT-3.1.2-25]。
	//共享订阅的情况下，如果一条消息对于部分客户端来说太长而不能发送，服务端可以选择丢弃此消息或者
	//把消息发送给剩余能够接收此消息的客户端。
	//非规范评注
	//服务端可以把那些没有发送就被丢弃的报文放在死信队列 上，或者执行其他诊断操作。具体的操
	//作超出了本规范的范围。
	MaximumPacketSize uint32

	// 34 (0x22)，主题别名最大值（Topic Alias Maximum）标识符。
	//跟随其后的是用双字节整数表示的主题别名最大值（Topic Alias Maximum）。包含多个主题别名最大值
	//（Topic Alias Maximum）将造成协议错误（Protocol Error）。没有设置主题别名最大值属性的情况下，主
	//题别名最大值默认为零。
	//此值指示了客户端能够接收的来自服务端的主题别名（Topic Alias）最大数量。客户端使用此值来限制本
	//次连接可以拥有的主题别名的数量。服务端在一个 PUBLISH 报文中发送的主题别名不能超过客户端设置的
	//主题别名最大值（Topic Alias Maximum） [MQTT-3.1.2-26]。值为零表示本次连接客户端不接受任何主题
	//别名（Topic Alias）。如果主题别名最大值（Topic Alias）没有设置，或者设置为零，则服务端不能向此客
	//户端发送任何主题别名（Topic Alias） [MQTT-3.1.2-27]。
	TopicAliasMaximum uint16

	// 25 (0x19)，请求响应信息（Request Response Information）标识符。
	//跟随其后的是用一个字节表示的 0 或 1。包含多个请求响应信息（Request Response Information），或者
	//请求响应信息（Request Response Information）的值既不为 0 也不为 1 会造成协议错误（Protocol
	//Error）。如果没有请求响应信息（Request Response Information），则请求响应默认值为 0。
	//客户端使用此值向服务端请求 CONNACK 报文中的响应信息（Response Information）。值为 0，表示服
	//务端不能返回响应信息 [MQTT-3.1.2-28]。值为 1，表示服务端可以在 CONNACK 报文中返回响应信息。
	//非规范评注
	//即使客户端请求响应信息（Response Information），服务端也可以选择不发送响应信息
	//（Response Information）。
	//更多关于请求/响应信息的内容，请参考 4.10 节。
	RequestProblemInformation uint8
	// 23 (0x17)，请求问题信息（Request Problem Information）标识符。
	//跟随其后的是用一个字节表示的 0 或 1。包含多个请求问题信息（Request Problem Information），或者
	//请求问题信息（Request Problem Information）的值既不为 0 也不为 1 会造成协议错误（Protocol Error）。
	//如果没有请求问题信息（Request Problem Information），则请求问题默认值为 1。
	//客户端使用此值指示遇到错误时是否发送原因字符串（Reason String）或用户属性（User Properties）。
	//如果请求问题信息的值为 0，服务端可以选择在 CONNACK 或 DISCONNECT 报文中返回原因字符串
	//（Reason String）或用户属性（User Properties），但不能在除 PUBLISH，CONNACK 或
	//DISCONNECT 之外的报文中发送原因字符串（Reason String）或用户属性（User Properties） [MQTT-
	//3.1.2-29]。如果此值为 0，并且在除 PUBLISH，CONNACK 或 DISCONNECT 之外的报文中收到了原因字
	//符串（Reason String）或用户属性（User Properties），客户端将发送一个包含原因码 0x82（协议错误）
	//的 DISCONNECT 报文给服务端，如 4.13 节 所述。
	//如果此值为 1，服
	RequestResponseInformation uint8
	// 38 (0x26)，用户属性（User Property）标识符。
	//跟随其后的是 UTF-8 字符串对。
	//用户属性（User Property）可以出现多次，表示多个名字/值对。相同的名字可以出现多次。
	//非规范评注
	//本规范不做定义。
	//CONNECT 报文中的
	UserProperty map[string][]string

	// 3.1.2.11.9
	//认证方法
	//21 (0x15)，认证方法（Authentication Method）标识符。
	//跟随其后的是一个 UTF-8 编码的字符串，包含了扩展认证的认证方法（Authentication Method）名称。包
	//含多个认证方法将造成协议错误（协议错误）。
	//如果没有认证方法，则不进行扩展验证。参考 4.12 节。
	//如果客户端在 CONNECT 报文中设置了认证方法，则客户端在收到 CONNACK 报文之前不能发送除
	//AUTH 或 DISCONNECT 之外的报文 [MQTT-3.1.2-30]。
	AuthenticationMethod string

	// 3.1.2.11.10
	//认证数据
	//22 (0x16)，认证数据（Authentication Data）标识符。
	//跟随其后的是二进制的认证数据。没有认证方法却包含了认证数据（Authentication Data），或者包含多个
	//认证数据（Authentication Data）将造成协议错误（Protocol Error）。
	//认证数据的内容由认证方法定义，关于扩展认证的更多信息，请参考 4.12 节。
	AuthenticationData []byte
}

func (*ConnectProperties) Pack 

func (props *ConnectProperties) Pack() ([]byte, error)

func (*ConnectProperties) Unpack 

func (props *ConnectProperties) Unpack(buf *bytes.Buffer) error

type DISCONNECT 

type DISCONNECT struct {
	*FixedHeader `json:"FixedHeader,omitempty"`

	DisconnectReasonCode ReasonCode

	Props *DisconnectProperties
}

func (*DISCONNECT) Kind 

func (pkt *DISCONNECT) Kind() byte

func (*DISCONNECT) Pack 

func (pkt *DISCONNECT) Pack(w io.Writer) error

func (*DISCONNECT) Unpack 

func (pkt *DISCONNECT) Unpack(buf *bytes.Buffer) error

type DisconnectProperties 

type DisconnectProperties struct {
	SessionExpiryInterval uint32
	ReasonString          string
}

func (*DisconnectProperties) Pack 

func (props *DisconnectProperties) Pack() ([]byte, error)

func (*DisconnectProperties) Unpack 

func (props *DisconnectProperties) Unpack(buf *bytes.Buffer) error

type FixedHeader 

type FixedHeader struct {
	Version byte // 这是为了兼容多版本定义的字段!

	// Kind MQTT Control Packet type
	// Position: byte 1, bits 7-4.
	Kind byte `json:"Kind,omitempty"` // the type of the packet (PUBLISH, SUBSCRIBE, etc.) from bits 7 - 4 (byte 1).

	// Dup position: byte 1, bytes 3.
	Dup uint8 `json:"Dup,omitempty"` // indicates if the packet was already sent at an earlier time.

	// QoS position: byte1, bytes 2-1.
	QoS uint8 `json:"QoS,omitempty"` // indicates the quality of service expected.

	// Retain position: byte1, bytes 0.
	Retain uint8 `json:"Retain,omitempty"` // whether the message should be retained.

	// RemainingLength position: starts at byte 2.
	RemainingLength uint32 `json:"RemainingLength,omitempty"` // the number of remaining bytes in the payload.
}

FixedHeader contains the values of the fixed header portion of the MQTT pkt. Each MQTT Control Packet contains a fixed header. Bit | 7 | 6 | 5 4 3 2 1 0 byte1 | MQTT Control Packet type | Flags specific to each MQTT Control Packet type| byte2... | Remaining Length

func (*FixedHeader) Pack 

func (pkt *FixedHeader) Pack(w io.Writer) error

func (*FixedHeader) String 

func (pkt *FixedHeader) String() string

func (*FixedHeader) Unpack 

func (pkt *FixedHeader) Unpack(r io.Reader) error

type Message 

type Message struct {
	TopicName string
	// 包含零长度有效载荷的 Publish 报文是合法的。
	Content []byte
}

Message Publish message

func (*Message) String 

func (m *Message) String() string

type PINGREQ 

type PINGREQ struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
}

func (*PINGREQ) Kind 

func (pkt *PINGREQ) Kind() byte

func (*PINGREQ) Pack 

func (pkt *PINGREQ) Pack(w io.Writer) error

func (*PINGREQ) Unpack 

func (pkt *PINGREQ) Unpack(_ *bytes.Buffer) error

type PINGRESP 

type PINGRESP struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
}

func (*PINGRESP) Kind 

func (pkt *PINGRESP) Kind() byte

func (*PINGRESP) Pack 

func (pkt *PINGRESP) Pack(w io.Writer) error

func (*PINGRESP) Unpack 

func (pkt *PINGRESP) Unpack(_ *bytes.Buffer) error

type PUBACK 

type PUBACK struct {
	*FixedHeader

	// 可变报头
	PacketID    uint16 // 报文标识符
	ReasonCode  ReasonCode
	PubackProps *PubackProperties
}

func (*PUBACK) Kind 

func (pkt *PUBACK) Kind() byte

func (*PUBACK) Pack 

func (pkt *PUBACK) Pack(w io.Writer) error

func (*PUBACK) Unpack 

func (pkt *PUBACK) Unpack(buf *bytes.Buffer) error

type PUBCOMP 

type PUBCOMP struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
	PacketID     uint16 `json:"PacketID,omitempty"` // 报文标识符
	ReasonCode   ReasonCode
	Props        *PubcompProperties
}

func (*PUBCOMP) Kind 

func (pkt *PUBCOMP) Kind() byte

func (*PUBCOMP) Pack 

func (pkt *PUBCOMP) Pack(w io.Writer) error

func (*PUBCOMP) Unpack 

func (pkt *PUBCOMP) Unpack(buf *bytes.Buffer) error

type PUBLISH 

type PUBLISH struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
	PacketID     uint16             `json:"PacketID,omitempty"` // 报文标识符
	Message      *Message           `json:"message,omitempty"`
	Props        *PublishProperties `json:"properties,omitempty"`
}

func (*PUBLISH) Kind 

func (pkt *PUBLISH) Kind() byte

func (*PUBLISH) Pack 

func (pkt *PUBLISH) Pack(w io.Writer) error

func (*PUBLISH) Unpack 

func (pkt *PUBLISH) Unpack(buf *bytes.Buffer) error

type PUBREC 

type PUBREC struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
	PacketID     uint16 `json:"PacketID,omitempty"` // 报文标识符
	ReasonCode   ReasonCode
	Props        *PubrecProperties
}

func (*PUBREC) Kind 

func (pkt *PUBREC) Kind() byte

func (*PUBREC) Pack 

func (pkt *PUBREC) Pack(w io.Writer) error

func (*PUBREC) Unpack 

func (pkt *PUBREC) Unpack(buf *bytes.Buffer) error

type PUBREL 

type PUBREL struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
	PacketID     uint16 `json:"PacketID,omitempty"` // 报文标识符
	ReasonCode   ReasonCode
	Props        *PubrelProperties
}

func (*PUBREL) Kind 

func (pkt *PUBREL) Kind() byte

func (*PUBREL) Pack 

func (pkt *PUBREL) Pack(w io.Writer) error

func (*PUBREL) Unpack 

func (pkt *PUBREL) Unpack(buf *bytes.Buffer) error

type Packet 

type Packet interface {
	Kind() byte
	Unpack(*bytes.Buffer) error
	Pack(io.Writer) error
}

func Unpack 

func Unpack(version byte, r io.Reader) (Packet, error)

type PubackProperties 

type PubackProperties struct {
	ReasonString string
	UserProperty map[string][]string
}

func (*PubackProperties) Pack 

func (props *PubackProperties) Pack() ([]byte, error)

func (*PubackProperties) Unpack 

func (props *PubackProperties) Unpack(buf *bytes.Buffer) error

type PubcompProperties 

type PubcompProperties struct {
	ReasonString string
	UserProperty map[string][]string
}

func (*PubcompProperties) Pack 

func (props *PubcompProperties) Pack() ([]byte, error)

func (*PubcompProperties) Unpack 

func (props *PubcompProperties) Unpack(buf *bytes.Buffer) error

type PublishProperties 

type PublishProperties struct {
	PayloadFormatIndicator uint8
	MessageExpiryInterval  uint32
	TopicAlias             uint16
	ResponseTopic          string
	CorrelationData        []byte
	UserProperty           map[string][]string
	SubscriptionIdentifier []uint32
	ContentType            string
}

func (*PublishProperties) Pack 

func (props *PublishProperties) Pack() ([]byte, error)

func (*PublishProperties) Unpack 

func (props *PublishProperties) Unpack(b *bytes.Buffer) error

type PubrecProperties 

type PubrecProperties struct {
	ReasonString string
	UserProperty map[string][]string
}

func (*PubrecProperties) Pack 

func (props *PubrecProperties) Pack() ([]byte, error)

func (*PubrecProperties) Unpack 

func (props *PubrecProperties) Unpack(buf *bytes.Buffer) error

type PubrelProperties 

type PubrelProperties struct {
	ReasonString string
	UserProperty map[string][]string
}

func (*PubrelProperties) Pack 

func (props *PubrelProperties) Pack() ([]byte, error)

func (*PubrelProperties) Unpack 

func (props *PubrelProperties) Unpack(buf *bytes.Buffer) error

type RESERVED 

type RESERVED struct {
	*FixedHeader
}

func (*RESERVED) Kind 

func (pkt *RESERVED) Kind() byte

func (*RESERVED) Pack 

func (pkt *RESERVED) Pack(io.Writer) error

func (*RESERVED) Unpack 

func (pkt *RESERVED) Unpack(*bytes.Buffer) error

type ReasonCode 

type ReasonCode struct {
	Code   uint8
	Reason string
	// contains filtered or unexported fields
}

func (ReasonCode) Error 

func (rc ReasonCode) Error() string

type SUBACK 

type SUBACK struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
	PacketID     uint16 `json:"PacketID,omitempty"` // 报文标识符

	SubackProps *SubackProperties

	// payload
	// 0x00 - 最大 QoS 0
	// 0x01 - 成功 – 最大 QoS 1
	// 0x02 - 成功 – 最大 QoS 2
	// 0x80 - Failure 失败
	ReasonCode []ReasonCode `json:"ReasonCode,omitempty"`
}

func (*SUBACK) Kind 

func (pkt *SUBACK) Kind() byte

func (*SUBACK) Pack 

func (pkt *SUBACK) Pack(w io.Writer) error

func (*SUBACK) Unpack 

func (pkt *SUBACK) Unpack(buf *bytes.Buffer) error

type SUBSCRIBE 

type SUBSCRIBE struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
	PacketID     uint16 `json:"PacketID,omitempty"` // 报文标识符

	SubscribeProps *SubscribeProperties

	Subscriptions []Subscription `json:"Subscription,omitempty"`
}

func (*SUBSCRIBE) Kind 

func (pkt *SUBSCRIBE) Kind() byte

func (*SUBSCRIBE) Pack 

func (pkt *SUBSCRIBE) Pack(w io.Writer) error

func (*SUBSCRIBE) Unpack 

func (pkt *SUBSCRIBE) Unpack(buf *bytes.Buffer) error

type SubackProperties 

type SubackProperties struct {
	ReasonString string
	UserProperty map[string][]string
}

func (*SubackProperties) Pack 

func (props *SubackProperties) Pack() ([]byte, error)

func (*SubackProperties) Unpack 

func (props *SubackProperties) Unpack(buf *bytes.Buffer) error

type SubscribeProperties 

type SubscribeProperties struct {
	SubscriptionIdentifier uint32
	UserProperty           map[string][]string
}

func (*SubscribeProperties) Pack 

func (props *SubscribeProperties) Pack() ([]byte, error)

func (*SubscribeProperties) Unpack 

func (props *SubscribeProperties) Unpack(buf *bytes.Buffer) error

type Subscription 

type Subscription struct {
	TopicFilter       string
	MaximumQoS        uint8
	NoLocal           uint8
	RetainAsPublished uint8
	RetainHandling    uint8
}

func (*Subscription) String 

func (s *Subscription) String() string

type UNSUBACK 

type UNSUBACK struct {
	*FixedHeader `json:"FixedHeader,omitempty"`
	PacketID     uint16 `json:"PacketID,omitempty"` // 报文标识符

	UnsubackProps *UnsubackProperties
}

func (*UNSUBACK) Kind 

func (pkt *UNSUBACK) Kind() byte

func (*UNSUBACK) Pack 

func (pkt *UNSUBACK) Pack(w io.Writer) error

func (*UNSUBACK) Unpack 

func (pkt *UNSUBACK) Unpack(buf *bytes.Buffer) error

type UNSUBSCRIBE 

type UNSUBSCRIBE struct {
	*FixedHeader
	PacketID      uint16 // 报文标识符
	Subscriptions []Subscription

	UnsubscribeProps *UnsubscribeProperties
}

func (*UNSUBSCRIBE) Kind 

func (pkt *UNSUBSCRIBE) Kind() byte

func (*UNSUBSCRIBE) Pack 

func (pkt *UNSUBSCRIBE) Pack(w io.Writer) error

func (*UNSUBSCRIBE) Unpack 

func (pkt *UNSUBSCRIBE) Unpack(buf *bytes.Buffer) error

type UnsubackProperties 

type UnsubackProperties struct {
	ReasonString string
	UserProperty map[string][]string
}

func (*UnsubackProperties) Pack 

func (props *UnsubackProperties) Pack() ([]byte, error)

func (*UnsubackProperties) Unpack 

func (props *UnsubackProperties) Unpack(buf *bytes.Buffer) error

type UnsubscribeProperties 

type UnsubscribeProperties struct {
	UserProperty map[string][]string
}

func (*UnsubscribeProperties) Pack 

func (props *UnsubscribeProperties) Pack() ([]byte, error)

func (*UnsubscribeProperties) Unpack 

func (props *UnsubscribeProperties) Unpack(buf *bytes.Buffer) error

type Will 

type Will struct {
	TopicName string
	Message   []byte
	Retain    uint8 // 保留标志
	QoS       uint8 // 服务质量
}

type WillProperties 

type WillProperties struct {
	PropertyLength int32

	// 24 (0x18)，遗嘱延时间隔（Will Delay Interval）标识符。
	// 24 (0x18)，遗嘱延时间隔（Will Delay Interval）标识符。
	//跟随其后的是由四字节整数表示的以秒为单位的遗嘱延时间隔（Will Delay Interval）。包含多个遗嘱延时
	//间隔将造成协议错误（Protocol Error）。如果没有设置遗嘱延时间隔，遗嘱延时间隔默认值将为 0，即不
	//用延时发布遗嘱消息（Will Message）。
	//服务端将在遗嘱延时间隔（Will Delay Interval）到期或者会话（Session）结束时发布客户端的遗嘱消息
	//（Will Message），取决于两者谁先发生。如果某个会话在遗嘱延时间隔到期之前创建了新的网络连接，
	//则服务端不能发送遗嘱消息 [MQTT-3.1.3-9]。
	//非规范评注
	//遗嘱时间间隔的一个用途是避免在频繁的网络连接临时断开时发布遗嘱消息，因为客户端往往会很
	//快重新连上网络并继续之前的会话。
	//非规范评注
	//如果某个连接到服务端的网络连接使用已存在的客户标识符，此已存在的网络连接的遗嘱消息将会
	//被发布，除非新的网络连接设置了新开始（Clean Start）为 0 并且遗嘱延时大于 0。如果遗嘱延时
	//为 0，遗嘱消息将在网络连接断开时发布。如果新开始为 1，遗嘱消息也将被发布，因为此会话已
	//结束。
	WillDelayInterval uint32 `json:"WillDelayInterval,omitempty"`
	// 3.1.3.2.3
	//载荷格式指示
	//1 (0x01)，载荷格式指示（Payload Format Indicator）标识符。
	//跟随载荷格式指示（Payload Format Indicator ）之后的可能是：
	// 0 (0x00)，表示遗嘱消息（Will Message）是未指定的字节，等同于不发送载荷格式指示。
	// 1 (0x01)，表示遗嘱消息（Will Message）是 UTF-8 编码的字符数据。载荷中的 UTF-8 数据必须
	//按照 Unicode 规范[Unicode] 和 RFC 3629 [RFC3629]中的申明进行编码。
	//包含多个载荷格式指示（Payload Format Indicator）将造成协议错误（Protocol Error）。服务端可以按照
	//格式指示对遗嘱消息（Will Message）进行验证，如果验证失败发送一条包含原因码 0x99（载荷格式无效）
	//的 CONNACK 报文。如 4.13 节 所述。
	PayloadFormatIndicator uint8 `json:"PayloadFormatIndicator,omitempty"`
	// 3.1.3.2.4
	//消息过期间隔
	//2 (0x02)，消息过期间隔（Message Expiry Interval）标识符。
	//跟随其后的是表示消息过期间隔（Message Expiry Interval）的四字节整数。包含多个消息过期间隔将导致
	//协议错误（Protocol Error）。
	//如果设定了消息过期间隔（Message Expiry Interval），四字节整数描述了遗嘱消息的生命周期（秒），并
	//在服务端发布遗嘱消息时被当做发布过期间隔（Publication Expiry Interval）。
	//如果没有设定消息过期间隔，服务端发布遗嘱消息时将不发送消息过期间隔（Message Expiry Interval）。
	//3.1.3.
	MessageExpiryInterval uint32 `json:"MessageExpiryInterval,omitempty"`
	// 3.1.3.2.5
	//内容类型
	//3 (0x03)，内容类型（Content Type）标识符。
	//跟随其后的是一个以 UTF-8 格式编码的字符串，用来描述遗嘱消息（Will Message）的内容。包含多个内
	//容类型（Content Type）将造成协议错误（Protocol Error）。内容类型的值由发送应用程序和接收应用程
	//序确定。
	ContentType string `json:"ContentType,omitempty"`
	// 3.1.3.2.6
	//响应主题
	//8 (0x08)，响应主题（Response Topic）标识符。
	//跟随其后的是一个以 UTF-8 格式编码的字符串，用来表示响应消息的主题名（Topic Name）。包含多个响
	//应主题（Response Topic）将造成协议错误。响应主题的存在将遗嘱消息（Will Message）标识为一个请
	//求报文。
	ResponseTopic string `json:"ResponseTopic,omitempty"`
	// 9 (0x09)，对比数据（Correlation Data）标识符。
	//跟随其后的是二进制数据。对比数据被请求消息发送端在收到响应消息时用来标识相应的请求。包含多个
	//对比数据将造成协议错误（Protocol Error）。如果没有设置对比数据，则请求方（Requester）不需要任何
	//对比数据。
	//对比数据只对请求消息（Request Message）的发送端和响应消息（Response Message）的接收端有意
	//义。
	//更多关于请求/响应的内容，参考 4.10 节。
	CorrelationData []byte `json:"CorrelationData,omitempty"`
	//38 (0x26)，用户属性（User Property）标识符。
	//跟随其后的是一个 UTF-8 字符串对。用户属性（User Property）可以出现多次，表示多个名字/值对。相同
	//的名字可以出现多次。
	//服务端在发布遗嘱消息（Will Message）时必须维护用户属性（User Properties）的顺序 [MQTT-3.1.3-10]。
	//非规范评注
	// 此属性旨在提供一种传递应用层名称-值标签的方法，其含义和解释仅由负责发送和接收它们的应
	//用程序所有。
	UserProperty []byte
}

func (*WillProperties) Pack 

func (props *WillProperties) Pack() ([]byte, error)

func (*WillProperties) Unpack 

func (props *WillProperties) Unpack(b *bytes.Buffer) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.