}
func (c *config) Addrs() []string {
return c.addrs
}
func (c *config) addAddr(addr string) {
c.addrs = append(c.addrs, addr)
return
}
func IPFlow(addr *net.UDPAddr) gopacket.Flow {
return gopacket.NewFlow(layers.EndpointIPv4, nil, addr.IP.To4())
}
func UDPFlow(addr *net.UDPAddr) gopacket.Flow {
portBytes := []byte{byte(addr.Port >> 8), byte(addr.Port)}
return gopacket.NewFlow(layers.EndpointUDPPort, nil, portBytes)
}
var EndpointSubchannelMetadata = gopacket.EndpointTypeMetadata{"subchannel", func(b []byte) string {
return strconv.Itoa(int(binary.LittleEndian.Uint32(b)))
}}
var EndpointSubchannel = gopacket.RegisterEndpointType(13000, EndpointSubchannelMetadata)
func SubchannelFlow(s int) gopacket.Flow {
b := make([]byte, 4)
binary.LittleEndian.PutUint32(b, uint32(s))
return gopacket.NewFlow(EndpointSubchannel, nil, b)
}
import (
"encoding/binary"
"strconv"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"github.com/ikravets/errs"
"my/ev/packet"
)
var EndpointMachSessionMetadata = gopacket.EndpointTypeMetadata{"Mach", func(b []byte) string {
return strconv.Itoa(int(b[0]))
}}
var EndpointMachSession = gopacket.RegisterEndpointType(10020, EndpointMachSessionMetadata)
// initialized in init() to avoid false detection of potential initialization loop
var LayerTypeMachTop, LayerTypeMach gopacket.LayerType
var MachTopLayerFactory, MachLayerFactory packet.DecodingLayerFactory
func init() {
LayerTypeMachTop = gopacket.RegisterLayerType(11000, gopacket.LayerTypeMetadata{"MachTop", gopacket.DecodeFunc(decodeMach)})
LayerTypeMach = gopacket.RegisterLayerType(11001, gopacket.LayerTypeMetadata{"Mach", gopacket.DecodeFunc(decodeMach)})
MachTopLayerFactory = packet.NewSingleDecodingLayerFactory(
LayerTypeMachTop,
func() gopacket.DecodingLayer { return &MachTop{} },
)
MachLayerFactory = packet.NewSingleDecodingLayerFactory(
LayerTypeMach,
package layers
import (
"encoding/binary"
"github.com/google/gopacket"
"net"
"strconv"
)
var (
// We use two different endpoint types for IPv4 vs IPv6 addresses, so that
// ordering with endpointA.LessThan(endpointB) sanely groups all IPv4
// addresses and all IPv6 addresses, such that IPv6 > IPv4 for all addresses.
EndpointIPv4 = gopacket.RegisterEndpointType(1, gopacket.EndpointTypeMetadata{Name: "IPv4", Formatter: func(b []byte) string {
return net.IP(b).String()
}})
EndpointIPv6 = gopacket.RegisterEndpointType(2, gopacket.EndpointTypeMetadata{Name: "IPv6", Formatter: func(b []byte) string {
return net.IP(b).String()
}})
EndpointMAC = gopacket.RegisterEndpointType(3, gopacket.EndpointTypeMetadata{Name: "MAC", Formatter: func(b []byte) string {
return net.HardwareAddr(b).String()
}})
EndpointTCPPort = gopacket.RegisterEndpointType(4, gopacket.EndpointTypeMetadata{Name: "TCP", Formatter: func(b []byte) string {
return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
}})
EndpointUDPPort = gopacket.RegisterEndpointType(5, gopacket.EndpointTypeMetadata{Name: "UDP", Formatter: func(b []byte) string {
return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
}})
EndpointSCTPPort = gopacket.RegisterEndpointType(6, gopacket.EndpointTypeMetadata{Name: "SCTP", Formatter: func(b []byte) string {
import (
"encoding/binary"
"errors"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"github.com/ikravets/errs"
"my/ev/packet"
)
var EndpointMoldUDP64SessionMetadata = gopacket.EndpointTypeMetadata{"MoldUDP64", func(b []byte) string {
return string(b[:10])
}}
var EndpointMoldUDP64Session = gopacket.RegisterEndpointType(10000, EndpointMoldUDP64SessionMetadata)
var LayerTypeMoldUDP64 = gopacket.RegisterLayerType(10000, gopacket.LayerTypeMetadata{"MoldUDP64", gopacket.DecodeFunc(decodeMoldUDP64)})
// must initialize in init() to avoid false detection of potential initialization loop
var LayerTypeMoldUDP64MessageBlock gopacket.LayerType
var LayerTypeMoldUDP64MessageBlockChained gopacket.LayerType
var MoldUDP64LayerFactory, MoldUDP64MessageBlockLayerFactory packet.DecodingLayerFactory
func init() {
LayerTypeMoldUDP64MessageBlock = gopacket.RegisterLayerType(10001, gopacket.LayerTypeMetadata{"MoldUDP64MessageBlock", gopacket.DecodeFunc(decodeMoldUDP64MessageBlock)})
LayerTypeMoldUDP64MessageBlockChained = gopacket.RegisterLayerType(10003, gopacket.LayerTypeMetadata{"MoldUDP64MessageBlockChained", gopacket.DecodeFunc(decodeMoldUDP64MessageBlockChained)})
MoldUDP64LayerFactory = packet.NewSingleDecodingLayerFactory(
