Documentation
¶
Overview ¶
Package packet provides types and implementations for the different SRT packet types
Index ¶
Constants ¶
View Source
const ( SRTFLAG_TSBPDSND uint32 = 1 << 0 SRTFLAG_TSBPDRCV uint32 = 1 << 1 SRTFLAG_CRYPT uint32 = 1 << 2 SRTFLAG_TLPKTDROP uint32 = 1 << 3 SRTFLAG_PERIODICNAK uint32 = 1 << 4 SRTFLAG_REXMITFLG uint32 = 1 << 5 SRTFLAG_STREAM uint32 = 1 << 6 SRTFLAG_PACKET_FILTER uint32 = 1 << 7 )
Table 6: Handshake Extension Message Flags
View Source
const ( KM_NOSECRET uint32 = 3 KM_BADSECRET uint32 = 4 )
View Source
const MAX_PAYLOAD_SIZE = 1456
View Source
const MAX_SEQUENCENUMBER uint32 = 0b01111111_11111111_11111111_11111111
View Source
const MAX_TIMESTAMP uint32 = 0b11111111_11111111_11111111_11111111
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type CIF ¶
type CIF interface {
// Marshal writes a byte representation of the CIF to the provided writer.
Marshal(w io.Writer)
// Unmarshal parses the provided bytes into the CIF. Returns a non nil error of failure.
Unmarshal(data []byte) error
// String returns a string representation of the CIF.
String() string
}
CIF reepresents a control information field
type CIFACK ¶
type CIFACK struct {
IsLite bool
IsSmall bool
LastACKPacketSequenceNumber circular.Number
RTT uint32 // microseconds
RTTVar uint32 // microseconds
AvailableBufferSize uint32 // bytes
PacketsReceivingRate uint32 // packets/s
EstimatedLinkCapacity uint32
ReceivingRate uint32 // bytes/s
}
CIFACK represents an ACK message.
type CIFHandshake ¶
type CIFHandshake struct {
IsRequest bool
Version uint32 // A base protocol version number. Currently used values are 4 and 5. Values greater than 5 are reserved for future use.
EncryptionField uint16 // Block cipher family and key size. The values of this field are described in Table 2. The default value is AES-128.
ExtensionField uint16 // This field is a message specific extension related to Handshake Type field. The value MUST be set to 0 except for the following cases. (1) If the handshake control packet is the INDUCTION message, this field is sent back by the Listener. (2) In the case of a CONCLUSION message, this field value should contain a combination of Extension Type values. For more details, see Section 4.3.1.
InitialPacketSequenceNumber circular.Number // The sequence number of the very first data packet to be sent.
MaxTransmissionUnitSize uint32 // This value is typically set to 1500, which is the default Maximum Transmission Unit (MTU) size for Ethernet, but can be less.
MaxFlowWindowSize uint32 // The value of this field is the maximum number of data packets allowed to be "in flight" (i.e. the number of sent packets for which an ACK control packet has not yet been received).
HandshakeType HandshakeType // This field indicates the handshake packet type. The possible values are described in Table 4. For more details refer to Section 4.3.
SRTSocketId uint32 // This field holds the ID of the source SRT socket from which a handshake packet is issued.
SynCookie uint32 // Randomized value for processing a handshake. The value of this field is specified by the handshake message type. See Section 4.3.
PeerIP srtnet.IP // IPv4 or IPv6 address of the packet's sender. The value consists of four 32-bit fields. In the case of IPv4 addresses, fields 2, 3 and 4 are filled with zeroes.
HasHS bool
HasKM bool
HasSID bool
HasCongestionCtl bool
// 3.2.1.1. Handshake Extension Message
SRTHS *CIFHandshakeExtension
// 3.2.1.2. Key Material Extension Message
SRTKM *CIFKeyMaterialExtension
// 3.2.1.3. Stream ID Extension Message
StreamId string
// ??? Congestion Control Extension message (handshake.md #### Congestion controller)
CongestionCtl string
}
CIFHandshake represents the SRT handshake messages.
func (*CIFHandshake) Marshal ¶
func (c *CIFHandshake) Marshal(w io.Writer)
func (CIFHandshake) String ¶
func (c CIFHandshake) String() string
func (*CIFHandshake) Unmarshal ¶
func (c *CIFHandshake) Unmarshal(data []byte) error
type CIFHandshakeExtension ¶
type CIFHandshakeExtension struct {
SRTVersion uint32
SRTFlags CIFHandshakeExtensionFlags
RecvTSBPDDelay uint16 // milliseconds, see "4.4. SRT Buffer Latency"
SendTSBPDDelay uint16 // milliseconds, see "4.4. SRT Buffer Latency"
}
CIFHandshakeExtension represents the Handshake Extension Message
func (*CIFHandshakeExtension) Marshal ¶
func (c *CIFHandshakeExtension) Marshal(w io.Writer)
func (CIFHandshakeExtension) String ¶
func (c CIFHandshakeExtension) String() string
func (*CIFHandshakeExtension) Unmarshal ¶
func (c *CIFHandshakeExtension) Unmarshal(data []byte) error
type CIFHandshakeExtensionFlags ¶
type CIFHandshakeExtensionFlags struct {
TSBPDSND bool // Defines if the TSBPD mechanism (Section 4.5) will be used for sending.
TSBPDRCV bool // Defines if the TSBPD mechanism (Section 4.5) will be used for receiving.
CRYPT bool // MUST be set. It is a legacy flag that indicates the party understands KK field of the SRT Packet (Figure 3).
TLPKTDROP bool // Should be set if too-late packet drop mechanism will be used during transmission. See Section 4.6.
PERIODICNAK bool // Indicates the peer will send periodic NAK packets. See Section 4.8.2.
REXMITFLG bool // MUST be set. It is a legacy flag that indicates the peer understands the R field of the SRT DATA Packet
STREAM bool // Identifies the transmission mode (Section 4.2) to be used in the connection. If the flag is set, the buffer mode (Section 4.2.2) is used. Otherwise, the message mode (Section 4.2.1) is used.
PACKET_FILTER bool // Indicates if the peer supports packet filter.
}
CIFHandshakeExtensionFlags represents the Handshake Extension Message Flags
type CIFKeyMaterialExtension ¶
type CIFKeyMaterialExtension struct {
Error uint32
S uint8 // This is a fixed-width field that is reserved for future usage. value = {0}
Version uint8 // This is a fixed-width field that indicates the SRT version. value = {1}
PacketType uint8 // This is a fixed-width field that indicates the Packet Type: 0: Reserved, 1: Media Stream Message (MSmsg), 2: Keying Material Message (KMmsg), 7: Reserved to discriminate MPEG-TS packet (0x47=sync byte). value = {2}
Sign uint16 // This is a fixed-width field that contains the signature 'HAI' encoded as a PnP Vendor ID [PNPID] (in big-endian order). value = {0x2029}
Resv1 uint8 // This is a fixed-width field reserved for flag extension or other usage. value = {0}
KeyBasedEncryption PacketEncryption // This is a fixed-width field that indicates which SEKs (odd and/or even) are provided in the extension: 00b: No SEK is provided (invalid extension format); 01b: Even key is provided; 10b: Odd key is provided; 11b: Both even and odd keys are provided.
KeyEncryptionKeyIndex uint32 // This is a fixed-width field for specifying the KEK index (big-endian order) was used to wrap (and optionally authenticate) the SEK(s). The value 0 is used to indicate the default key of the current stream. Other values are reserved for the possible use of a key management system in the future to retrieve a cryptographic context. 0: Default stream associated key (stream/system default); 1..255: Reserved for manually indexed keys. value = {0}
Cipher uint8 // This is a fixed-width field for specifying encryption cipher and mode: 0: None or KEKI indexed crypto context; 2: AES-CTR [SP800-38A].
Authentication uint8 // This is a fixed-width field for specifying a message authentication code algorithm: 0: None or KEKI indexed crypto context.
StreamEncapsulation uint8 // This is a fixed-width field for describing the stream encapsulation: 0: Unspecified or KEKI indexed crypto context; 1: MPEG-TS/UDP; 2: MPEG-TS/SRT. value = {2}
Resv2 uint8 // This is a fixed-width field reserved for future use. value = {0}
Resv3 uint16 // This is a fixed-width field reserved for future use. value = {0}
SLen uint16 // This is a fixed-width field for specifying salt length SLen in bytes divided by 4. Can be zero if no salt/IV present. The only valid length of salt defined is 128 bits.
KLen uint16 // This is a fixed-width field for specifying SEK length in bytes divided by 4. Size of one key even if two keys present. MUST match the key size specified in the Encryption Field of the handshake packet Table 2.
Salt []byte // This is a variable-width field that complements the keying material by specifying a salt key.
Wrap []byte // (64 + n * KLen * 8) bits. This is a variable- width field for specifying Wrapped key(s), where n = (KK + 1)/2 and the size of the wrap field is ((n * KLen) + 8) bytes.
}
CIFKeyMaterialExtension represents the Key Material message. It is used as part of the v5 handshake or on its own after a v4 handshake.
func (*CIFKeyMaterialExtension) Marshal ¶
func (c *CIFKeyMaterialExtension) Marshal(w io.Writer)
func (CIFKeyMaterialExtension) String ¶
func (c CIFKeyMaterialExtension) String() string
func (*CIFKeyMaterialExtension) Unmarshal ¶
func (c *CIFKeyMaterialExtension) Unmarshal(data []byte) error
type CIFShutdown ¶
type CIFShutdown struct{}
CIFShutdown represents a shutdown message.
func (*CIFShutdown) Marshal ¶
func (c *CIFShutdown) Marshal(w io.Writer)
func (CIFShutdown) String ¶
func (c CIFShutdown) String() string
func (*CIFShutdown) Unmarshal ¶
func (c *CIFShutdown) Unmarshal(data []byte) error
type CtrlSubType ¶
type CtrlSubType uint16
Table 5: Handshake Extension Type values
const ( CTRLSUBTYPE_NONE CtrlSubType = 0 EXTTYPE_HSREQ CtrlSubType = 1 EXTTYPE_HSRSP CtrlSubType = 2 EXTTYPE_KMREQ CtrlSubType = 3 EXTTYPE_KMRSP CtrlSubType = 4 EXTTYPE_SID CtrlSubType = 5 EXTTYPE_CONGESTION CtrlSubType = 6 EXTTYPE_FILTER CtrlSubType = 7 // unimplemented EXTTYPE_GROUP CtrlSubType = 8 // unimplemented )
func (CtrlSubType) String ¶
func (h CtrlSubType) String() string
func (CtrlSubType) Value ¶
func (h CtrlSubType) Value() uint16
type CtrlType ¶
type CtrlType uint16
Table 1: SRT Control Packet Types
const ( CTRLTYPE_HANDSHAKE CtrlType = 0x0000 CTRLTYPE_KEEPALIVE CtrlType = 0x0001 CTRLTYPE_ACK CtrlType = 0x0002 CTRLTYPE_NAK CtrlType = 0x0003 CTRLTYPE_WARN CtrlType = 0x0004 // unimplemented, receiver->sender CTRLTYPE_SHUTDOWN CtrlType = 0x0005 CTRLTYPE_ACKACK CtrlType = 0x0006 CRTLTYPE_DROPREQ CtrlType = 0x0007 // unimplemented, sender->receiver CRTLTYPE_PEERERROR CtrlType = 0x0008 // unimplemented, receiver->sender (only for file transfers) CTRLTYPE_USER CtrlType = 0x7FFF )
type HandshakeType ¶
type HandshakeType uint32
const ( HSTYPE_DONE HandshakeType = 0xFFFFFFFD HSTYPE_AGREEMENT HandshakeType = 0xFFFFFFFE HSTYPE_CONCLUSION HandshakeType = 0xFFFFFFFF HSTYPE_WAVEHAND HandshakeType = 0x00000000 HSTYPE_INDUCTION HandshakeType = 0x00000001 )
Table 4: Handshake Type
func (HandshakeType) IsHandshake ¶
func (h HandshakeType) IsHandshake() bool
func (HandshakeType) IsRejection ¶
func (h HandshakeType) IsRejection() bool
func (HandshakeType) String ¶
func (h HandshakeType) String() string
func (HandshakeType) Val ¶
func (h HandshakeType) Val() uint32
type Packet ¶
type Packet interface {
// String returns a string representation of the packet.
String() string
// Clone clones a packet.
Clone() Packet
// Header returns a pointer to the packet header.
Header() *PacketHeader
// Data returns the payload the packets holds. The packets stays the
// owner of the data, i.e. modifying the returned data will also
// modify the payload.
Data() []byte
// SetData replaces the payload of the packet with the provided one.
SetData([]byte)
// Len return the length of the payload in the packet.
Len() uint64
// Marshal writes the bytes representation of the packet to the provided writer.
Marshal(w io.Writer) error
// Unmarshal parses the given data into the packet header and its payload. Returns an error on failure.
Unmarshal(data []byte) error
// Dump returns the same as String with an additional hex-dump of the marshalled packet.
Dump() string
// MarshalCIF writes the byte representation of a control information field as payload
// of the packet. Only for control packets.
MarshalCIF(c CIF)
// UnmarshalCIF parses the payload into a control information field struct. Returns an error
// on failure.
UnmarshalCIF(c CIF) error
// Decommission frees the payload. The packet shouldn't be uses afterwards.
Decommission()
}
type PacketEncryption ¶
type PacketEncryption uint
const ( UnencryptedPacket PacketEncryption = 0 EvenKeyEncrypted PacketEncryption = 1 OddKeyEncrypted PacketEncryption = 2 EvenAndOddKey PacketEncryption = 3 )
func (PacketEncryption) IsValid ¶
func (p PacketEncryption) IsValid() bool
func (PacketEncryption) Opposite ¶
func (p PacketEncryption) Opposite() PacketEncryption
func (PacketEncryption) String ¶
func (p PacketEncryption) String() string
func (PacketEncryption) Val ¶
func (p PacketEncryption) Val() uint32
type PacketHeader ¶
type PacketHeader struct {
Addr net.Addr
IsControlPacket bool
PktTsbpdTime uint64 // microseconds
ControlType CtrlType // Control Packet Type. The use of these bits is determined by the control packet type definition.
SubType CtrlSubType // This field specifies an additional subtype for specific packets.
TypeSpecific uint32 // The use of this field depends on the particular control packet type. Handshake packets do not use this field.
PacketSequenceNumber circular.Number // The sequential number of the data packet.
PacketPositionFlag PacketPosition // This field indicates the position of the data packet in the message. The value "10b" (binary) means the first packet of the message. "00b" indicates a packet in the middle. "01b" designates the last packet. If a single data packet forms the whole message, the value is "11b".
OrderFlag bool // Indicates whether the message should be delivered by the receiver in order (1) or not (0). Certain restrictions apply depending on the data transmission mode used (Section 4.2).
KeyBaseEncryptionFlag PacketEncryption // The flag bits indicate whether or not data is encrypted. The value "00b" (binary) means data is not encrypted. "01b" indicates that data is encrypted with an even key, and "10b" is used for odd key encryption. Refer to Section 6. The value "11b" is only used in control packets.
RetransmittedPacketFlag bool // This flag is clear when a packet is transmitted the first time. The flag is set to "1" when a packet is retransmitted.
MessageNumber uint32 // The sequential number of consecutive data packets that form a message (see PP field).
Timestamp uint32 // microseconds
DestinationSocketId uint32
}
type PacketPosition ¶
type PacketPosition uint
const ( FirstPacket PacketPosition = 2 MiddlePacket PacketPosition = 0 LastPacket PacketPosition = 1 SinglePacket PacketPosition = 3 )
func (PacketPosition) IsValid ¶
func (p PacketPosition) IsValid() bool
func (PacketPosition) String ¶
func (p PacketPosition) String() string
func (PacketPosition) Val ¶
func (p PacketPosition) Val() uint32
Source Files
Click to show internal directories.
Click to hide internal directories.