mirror of
https://github.com/PeernetOfficial/core.git
synced 2026-07-17 02:47:51 +01:00
9ddca35277
udt: Improve error messages. Fix bug in udtSocketSend.processDataMsg, the header was not considered in the max size. webapi: New /file/view API which is useful for immediate testing of file transfer.
95 lines
2.8 KiB
Go
95 lines
2.8 KiB
Go
package packet
|
|
|
|
import "errors"
|
|
|
|
// MessageBoundary flags for where this packet falls within a message
|
|
type MessageBoundary uint8
|
|
|
|
const (
|
|
// MbFirst is the first packet in a multi-packet message
|
|
MbFirst MessageBoundary = 2
|
|
// MbLast is the last packet in a multi-packet message
|
|
MbLast MessageBoundary = 1
|
|
// MbOnly is the only packet in this message
|
|
MbOnly MessageBoundary = 3
|
|
// MbMiddle is neither the first nor last packet in a multi-packet message
|
|
MbMiddle MessageBoundary = 0
|
|
)
|
|
|
|
// DataPacket is a UDT packet containing message data
|
|
type DataPacket struct {
|
|
Seq PacketID // packet sequence number (top bit = 0)
|
|
msg uint32 // message sequence number (top three bits = message control)
|
|
ts uint32 // timestamp when message is sent
|
|
DstSockID uint32 // destination socket
|
|
Data []byte // payload
|
|
}
|
|
|
|
// PacketType returns the packetType associated with this packet
|
|
func (dp *DataPacket) PacketType() PacketType {
|
|
return ptData
|
|
}
|
|
|
|
// SetHeader sets the fields common to UDT data packets
|
|
func (dp *DataPacket) SetHeader(destSockID uint32, ts uint32) {
|
|
dp.DstSockID = destSockID
|
|
dp.ts = ts
|
|
}
|
|
|
|
// SocketID sets the Socket ID for this data packet
|
|
func (dp *DataPacket) SocketID() (sockID uint32) {
|
|
return dp.DstSockID
|
|
}
|
|
|
|
// SendTime sets the timestamp field for this data packet
|
|
func (dp *DataPacket) SendTime() (ts uint32) {
|
|
return dp.ts
|
|
}
|
|
|
|
// SetMessageData sets the message field for this data packet
|
|
func (dp *DataPacket) SetMessageData(boundary MessageBoundary, order bool, msg uint32) {
|
|
var iOrder uint32 = 0
|
|
if order {
|
|
iOrder = 0x20000000
|
|
}
|
|
dp.msg = (uint32(boundary) << 30) | iOrder | (msg & 0x1FFFFFFF)
|
|
}
|
|
|
|
// GetMessageData returns the message field for this data packet
|
|
func (dp *DataPacket) GetMessageData() (MessageBoundary, bool, uint32) {
|
|
return MessageBoundary(dp.msg >> 30), (dp.msg & 0x20000000) != 0, dp.msg & 0x1FFFFFFF
|
|
}
|
|
|
|
// WriteTo writes this packet to the provided buffer, returning the length of the packet
|
|
func (dp *DataPacket) WriteTo(buf []byte) (uint, error) {
|
|
l := len(buf)
|
|
ol := 16 + len(dp.Data)
|
|
if l < ol {
|
|
return 0, errors.New("write data packet too small")
|
|
}
|
|
endianness.PutUint32(buf[0:4], dp.Seq.Seq&0x7FFFFFFF)
|
|
endianness.PutUint32(buf[4:8], dp.msg)
|
|
endianness.PutUint32(buf[8:12], dp.ts)
|
|
endianness.PutUint32(buf[12:16], dp.DstSockID)
|
|
copy(buf[16:], dp.Data)
|
|
|
|
return uint(ol), nil
|
|
}
|
|
|
|
func (dp *DataPacket) readFrom(data []byte) (err error) {
|
|
l := len(data)
|
|
if l < 16 {
|
|
return errors.New("read data packet too small")
|
|
}
|
|
//dp.seq = endianness.Uint32(data[0:4])
|
|
dp.msg = endianness.Uint32(data[4:8])
|
|
dp.ts = endianness.Uint32(data[8:12])
|
|
dp.DstSockID = endianness.Uint32(data[12:16])
|
|
|
|
// The data is whatever is what comes after the 16 bytes of header
|
|
dp.Data = make([]byte, l-16)
|
|
copy(dp.Data, data[16:])
|
|
|
|
return
|
|
}
|