Example #1
0
File: mach.go Project: ikravets/ev
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,
		func() gopacket.DecodingLayer { return &Mach{} },
	)
}
Example #2
0
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(
		LayerTypeMoldUDP64,
		func() gopacket.DecodingLayer { return &MoldUDP64{} },
	)

	MoldUDP64MessageBlockLayerFactory = packet.NewSingleDecodingLayerFactory(
		LayerTypeMoldUDP64MessageBlock,
		func() gopacket.DecodingLayer { return &MoldUDP64MessageBlock{} },
	)
}
Example #3
0
File: tom.go Project: ikravets/ev
func init() {
	layerTypes := make([]gopacket.LayerType, 0, 256)
	for i := 0; i < 256; i++ {
		if TomMessageTypeNames[i] == "" {
			continue
		}
		tomMessageType := TomMessageType(i)
		layerTypeMetadata := gopacket.LayerTypeMetadata{
			Name:    TomMessageTypeNames[i],
			Decoder: tomMessageType,
		}
		layerType := gopacket.RegisterLayerType(TOM_LAYERS_BASE_NUM+i, layerTypeMetadata)
		layerTypes = append(layerTypes, layerType)
		creator := TomMessageCreators[i]
		createLayer := func() TomMessage {
			m := creator()
			m.Base().Type = tomMessageType
			return m
		}
		TomMessageTypeMetadata[i] = EnumMessageTypeMetadata{
			Name:        TomMessageTypeNames[i],
			LayerType:   layerType,
			CreateLayer: createLayer,
		}
	}
	for i := 0; i < 256; i++ {
		if TomMessageTypeMetadata[i].Name == "" {
			// unknown message type
			TomMessageTypeMetadata[i] = TomMessageTypeMetadata[TomMessageTypeUnknown]
		}
	}
	LayerClassTom = gopacket.NewLayerClass(layerTypes)
}
Example #4
0
File: itto.go Project: ikravets/ev
func init() {
	layerTypes := make([]gopacket.LayerType, 0, 256)
	for i := 0; i < 256; i++ {
		if IttoMessageTypeNames[i] == "" {
			continue
		}
		ittoMessageType := IttoMessageType(i)
		layerTypeMetadata := gopacket.LayerTypeMetadata{
			Name:    IttoMessageTypeNames[i],
			Decoder: ittoMessageType,
		}
		layerType := gopacket.RegisterLayerType(ITTO_LAYERS_BASE_NUM+i, layerTypeMetadata)
		layerTypes = append(layerTypes, layerType)
		creator := IttoMessageCreators[i]
		createLayer := func() IttoMessage {
			m := creator()
			m.Base().Type = ittoMessageType
			return m
		}
		IttoMessageTypeMetadata[i] = EnumMessageTypeMetadata{
			Name:        IttoMessageTypeNames[i],
			IsShort:     IttoMessageIsShort[i],
			LayerType:   layerType,
			CreateLayer: createLayer,
		}
	}
	for i := 0; i < 256; i++ {
		if IttoMessageTypeMetadata[i].Name == "" {
			// unknown message type
			IttoMessageTypeMetadata[i] = IttoMessageTypeMetadata[IttoMessageTypeUnknown]
		}
	}
	LayerClassItto = gopacket.NewLayerClass(layerTypes)
}
Example #5
0
// Copyright 2012 Google, gopacket.LayerTypeMetadata{Inc. All rights reserved}.
//
// Use of this source code is governed by a BSD-style license
// that can be found in the LICENSE file in the root of the source
// tree.

package layers

import (
	"github.com/google/gopacket"
)

var (
	LayerTypeARP                         = gopacket.RegisterLayerType(10, gopacket.LayerTypeMetadata{Name: "ARP", Decoder: gopacket.DecodeFunc(decodeARP)})
	LayerTypeCiscoDiscovery              = gopacket.RegisterLayerType(11, gopacket.LayerTypeMetadata{Name: "CiscoDiscovery", Decoder: gopacket.DecodeFunc(decodeCiscoDiscovery)})
	LayerTypeEthernetCTP                 = gopacket.RegisterLayerType(12, gopacket.LayerTypeMetadata{Name: "EthernetCTP", Decoder: gopacket.DecodeFunc(decodeEthernetCTP)})
	LayerTypeEthernetCTPForwardData      = gopacket.RegisterLayerType(13, gopacket.LayerTypeMetadata{Name: "EthernetCTPForwardData", Decoder: nil})
	LayerTypeEthernetCTPReply            = gopacket.RegisterLayerType(14, gopacket.LayerTypeMetadata{Name: "EthernetCTPReply", Decoder: nil})
	LayerTypeDot1Q                       = gopacket.RegisterLayerType(15, gopacket.LayerTypeMetadata{Name: "Dot1Q", Decoder: gopacket.DecodeFunc(decodeDot1Q)})
	LayerTypeEtherIP                     = gopacket.RegisterLayerType(16, gopacket.LayerTypeMetadata{Name: "EtherIP", Decoder: gopacket.DecodeFunc(decodeEtherIP)})
	LayerTypeEthernet                    = gopacket.RegisterLayerType(17, gopacket.LayerTypeMetadata{Name: "Ethernet", Decoder: gopacket.DecodeFunc(decodeEthernet)})
	LayerTypeGRE                         = gopacket.RegisterLayerType(18, gopacket.LayerTypeMetadata{Name: "GRE", Decoder: gopacket.DecodeFunc(decodeGRE)})
	LayerTypeICMPv4                      = gopacket.RegisterLayerType(19, gopacket.LayerTypeMetadata{Name: "ICMPv4", Decoder: gopacket.DecodeFunc(decodeICMPv4)})
	LayerTypeIPv4                        = gopacket.RegisterLayerType(20, gopacket.LayerTypeMetadata{Name: "IPv4", Decoder: gopacket.DecodeFunc(decodeIPv4)})
	LayerTypeIPv6                        = gopacket.RegisterLayerType(21, gopacket.LayerTypeMetadata{Name: "IPv6", Decoder: gopacket.DecodeFunc(decodeIPv6)})
	LayerTypeLLC                         = gopacket.RegisterLayerType(22, gopacket.LayerTypeMetadata{Name: "LLC", Decoder: gopacket.DecodeFunc(decodeLLC)})
	LayerTypeSNAP                        = gopacket.RegisterLayerType(23, gopacket.LayerTypeMetadata{Name: "SNAP", Decoder: gopacket.DecodeFunc(decodeSNAP)})
	LayerTypeMPLS                        = gopacket.RegisterLayerType(24, gopacket.LayerTypeMetadata{Name: "MPLS", Decoder: gopacket.DecodeFunc(decodeMPLS)})
	LayerTypePPP                         = gopacket.RegisterLayerType(25, gopacket.LayerTypeMetadata{Name: "PPP", Decoder: gopacket.DecodeFunc(decodePPP)})
	LayerTypePPPoE                       = gopacket.RegisterLayerType(26, gopacket.LayerTypeMetadata{Name: "PPPoE", Decoder: gopacket.DecodeFunc(decodePPPoE)})
	LayerTypeRUDP                        = gopacket.RegisterLayerType(27, gopacket.LayerTypeMetadata{Name: "RUDP", Decoder: gopacket.DecodeFunc(decodeRUDP)})
Example #6
0
File: tom.go Project: ikravets/ev
// Copyright (c) Ilia Kravets, 2015. All rights reserved. PROVIDED "AS IS"
// WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED. See LICENSE file for details.

package miax

import (
	"encoding/binary"
	"time"

	"github.com/google/gopacket"
	"github.com/ikravets/errs"

	"my/ev/packet"
)

var LayerTypeTom = gopacket.RegisterLayerType(11002, gopacket.LayerTypeMetadata{"Tom", gopacket.DecodeFunc(decodeTom)})

func decodeTom(data []byte, p gopacket.PacketBuilder) error {
	tomMessageType := TomMessageType(data[0])
	return tomMessageType.Decode(data, p)
}

/************************************************************************/

type TomSide struct {
	Price                packet.Price
	Size                 int
	PriorityCustomerSize int
	Condition            byte
	Side                 packet.MarketSide // inferred from message type
}
Example #7
0
File: bsu.go Project: ikravets/ev
// Copyright (c) Ilia Kravets, 2015. All rights reserved. PROVIDED "AS IS"
// WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED. See LICENSE file for details.

package bats

import (
	"encoding/binary"

	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
	"github.com/ikravets/errs"

	"my/ev/packet"
)

var LayerTypeBSU = gopacket.RegisterLayerType(12000, gopacket.LayerTypeMetadata{"BatsSequencedUnit", nil /*FIXME*/})

type BSU struct {
	layers.BaseLayer
	Length   uint16
	Count    uint8
	Unit     uint8
	Sequence uint32
	tps      []packet.TypedPayload
}

var (
	_ packet.DecodingMultiLayer = &BSU{}
	_ gopacket.Layer            = &BSU{}
	_ gopacket.DecodingLayer    = &BSU{}
)
Example #8
0
File: pitch.go Project: ikravets/ev
package bats

import (
	"encoding/binary"
	"errors"

	"github.com/google/gopacket"
	"github.com/ikravets/errs"

	"my/ev/packet"
)

/************************************************************************/

var LayerTypePitch = gopacket.RegisterLayerType(12001, gopacket.LayerTypeMetadata{"Pitch", gopacket.DecodeFunc(decodePitch)})

func decodePitch(data []byte, p gopacket.PacketBuilder) error {
	if len(data) < 2 {
		return errors.New("message to short")
	}
	pitchMessageType := PitchMessageType(data[1])
	return pitchMessageType.Decode(data, p)
}

/************************************************************************/
type PitchMessageType uint8

func (a PitchMessageType) Decode(data []byte, p gopacket.PacketBuilder) error {
	layer := PitchMessageTypeMetadata[a].CreateLayer()
	if err := layer.DecodeFromBytes(data, p); err != nil {
Example #9
0
File: itto.go Project: ikravets/ev
package nasdaq

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"time"

	"github.com/google/gopacket"
	"github.com/ikravets/errs"

	"my/ev/packet"
)

var LayerTypeItto = gopacket.RegisterLayerType(10002, gopacket.LayerTypeMetadata{"Itto", gopacket.DecodeFunc(decodeItto)})

func decodeItto(data []byte, p gopacket.PacketBuilder) error {
	ittoMessageType := IttoMessageType(data[0])
	return ittoMessageType.Decode(data, p)
}

/************************************************************************/

type OrderSide struct {
	Side    packet.MarketSide
	RefNumD packet.OrderId
	Price   packet.Price
	Size    int
}
type ReplaceOrderSide struct {
Example #10
0
	layers.MPLSPayloadDecoder = gopacket.DecodeFunc(decodeMPLS)
	layers.EthernetTypeMetadata[ethernetTypeDot1QSTag] = layers.EthernetTypeMetadata[layers.EthernetTypeDot1Q]
	layers.EthernetTypeMetadata[ethernetTypeDot1QITag] = layers.EnumMetadata{
		DecodeWith: gopacket.DecodeFunc(decodePBB),
		Name:       "PBB",
		LayerType:  LayerTypePBB,
	}
	layers.EthernetTypeMetadata[ethernetTypeLwapp] = layers.EnumMetadata{
		DecodeWith: gopacket.DecodeFunc(decodeLwapp),
		Name:       "Lwapp",
		LayerType:  LayerTypeLwapp,
	}
}

var (
	LayerTypePBB                 = gopacket.RegisterLayerType(500, gopacket.LayerTypeMetadata{"PBB", gopacket.DecodeFunc(decodePBB)})
	LayerTypeLwapp               = gopacket.RegisterLayerType(501, gopacket.LayerTypeMetadata{"Lwapp", gopacket.DecodeFunc(decodeLwapp)})
	LayerTypeLwappControl        = gopacket.RegisterLayerType(502, gopacket.LayerTypeMetadata{"LwappControl", gopacket.DecodeFunc(decodeLwappControl)})
	LayerTypeCapwapControl       = gopacket.RegisterLayerType(503, gopacket.LayerTypeMetadata{"CapwapControl", gopacket.DecodeFunc(decodeCapwapControl)})
	LayerTypeCapwapData          = gopacket.RegisterLayerType(504, gopacket.LayerTypeMetadata{"CapwapData", gopacket.DecodeFunc(decodeCapwapData)})
	LayerTypeCapwapControlHeader = gopacket.RegisterLayerType(505, gopacket.LayerTypeMetadata{"CapwapControlHeader", gopacket.DecodeFunc(decodeCapwapControlHeader)})
	LayerTypeCapwapDataKeepAlive = gopacket.RegisterLayerType(506, gopacket.LayerTypeMetadata{"CapwapDataKeepAlive", gopacket.DecodeFunc(decodeCapwapDataKeepAlive)})
	LayerTypeDot11NoFCS          = gopacket.RegisterLayerType(507, gopacket.LayerTypeMetadata{"Dot11NoFCS", gopacket.DecodeFunc(decodeDot11NoFCS)})
)

func decodeMPLS(data []byte, p gopacket.PacketBuilder) error {
	g := layers.ProtocolGuessingDecoder{}
	if err := g.Decode(data, p); err != nil {
		return gopacket.DecodePayload.Decode(data, p)
	}
	return nil
Example #11
0
// by Kelly Lauren-Summer Becker-Neuding <*****@*****.**>, 2015

package packet

import (
	"encoding/binary"
	"fmt"
	"strconv"

	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
)

// LayerTypeUDP is a extensible UDP packet LayerType
var LayerTypeUDP = gopacket.RegisterLayerType(1045, gopacket.LayerTypeMetadata{
	Name: "UDP", Decoder: gopacket.DecodeFunc(decodeUDP),
})

// Replace the UDP Packet handler with out new custom one.
func init() {
	layers.IPProtocolMetadata[layers.IPProtocolUDP] = layers.EnumMetadata{
		DecodeWith: gopacket.DecodeFunc(decodeUDP),
		Name:       "UDP", LayerType: LayerTypeUDP,
	}
}

// UDP is the layer for UDP headers.
type UDP struct {
	layers.BaseLayer
	SrcPort, DstPort UDPPort
	Length           uint16
Example #12
0
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 */

package flow

import (
	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
)

// Create a layer type, should be unique and high, so it doesn't conflict,
// giving it a name and a decoder to use.
var LayerTypeInGRE = gopacket.RegisterLayerType(55555, gopacket.LayerTypeMetadata{Name: "LayerTypeInGRE", Decoder: gopacket.DecodeFunc(decodeInGRELayer)})

type InGRELayer struct {
	StrangeHeader []byte
	payload       []byte
}

func (m InGRELayer) LayerType() gopacket.LayerType {
	return LayerTypeInGRE
}

func (m InGRELayer) LayerContents() []byte {
	return m.StrangeHeader
}

func (m InGRELayer) LayerPayload() []byte {
Example #13
0
	"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(
		LayerTypeMoldUDP64,
		func() gopacket.DecodingLayer { return &MoldUDP64{} },
Example #14
0
// Create custom layer structure
type CustomLayer struct {
	// This layer just has two bytes at the front
	SomeByte    byte
	AnotherByte byte
	restOfData  []byte
}

// Register the layer type so we can use it
// The first argument is an ID. Use negative
// or 2000+ for custom layers. It must be unique
var CustomLayerType = gopacket.RegisterLayerType(
	2001,
	gopacket.LayerTypeMetadata{
		"CustomLayerType",
		gopacket.DecodeFunc(decodeCustomLayer),
	},
)

// When we inquire about the type, what type of layer should
// we say it is? We want it to return our custom layer type
func (l CustomLayer) LayerType() gopacket.LayerType {
	return CustomLayerType
}

// LayerContents returns the information that our layer
// provides. In this case it is a header layer so
// we return the header information
func (l CustomLayer) LayerContents() []byte {
	return []byte{l.SomeByte, l.AnotherByte}