mirror of https://github.com/subgraph/fw-daemon
dma
7 years ago
parent
4babfbbd14
commit
70c21b0636
@ -0,0 +1,38 @@
|
||||
# Compiled Object files, Static and Dynamic libs (Shared Objects)
|
||||
*.o
|
||||
*.a
|
||||
*.so
|
||||
|
||||
# Folders
|
||||
_obj
|
||||
_test
|
||||
|
||||
# Architecture specific extensions/prefixes
|
||||
*.[568vq]
|
||||
[568vq].out
|
||||
|
||||
*.cgo1.go
|
||||
*.cgo2.c
|
||||
_cgo_defun.c
|
||||
_cgo_gotypes.go
|
||||
_cgo_export.*
|
||||
|
||||
_testmain.go
|
||||
|
||||
*.exe
|
||||
#*
|
||||
*~
|
||||
|
||||
# examples binaries
|
||||
examples/synscan/synscan
|
||||
examples/pfdump/pfdump
|
||||
examples/pcapdump/pcapdump
|
||||
examples/httpassembly/httpassembly
|
||||
examples/statsassembly/statsassembly
|
||||
examples/arpscan/arpscan
|
||||
examples/bidirectional/bidirectional
|
||||
examples/bytediff/bytediff
|
||||
examples/reassemblydump/reassemblydump
|
||||
layers/gen
|
||||
macs/gen
|
||||
pcap/pcap_tester
|
||||
@ -0,0 +1,7 @@
|
||||
#!/bin/bash
|
||||
|
||||
cd "$(dirname $0)"
|
||||
if [ -n "$(go fmt ./...)" ]; then
|
||||
echo "Go code is not formatted, run 'go fmt github.com/google/stenographer/...'" >&2
|
||||
exit 1
|
||||
fi
|
||||
@ -0,0 +1,25 @@
|
||||
#!/bin/bash
|
||||
|
||||
cd "$(dirname $0)"
|
||||
|
||||
go get github.com/golang/lint/golint
|
||||
DIRS=". tcpassembly tcpassembly/tcpreader ip4defrag reassembly macs pcapgo pcap afpacket pfring routing"
|
||||
# Add subdirectories here as we clean up golint on each.
|
||||
for subdir in $DIRS; do
|
||||
pushd $subdir
|
||||
if golint |
|
||||
grep -v CannotSetRFMon | # pcap exported error name
|
||||
grep -v DataLost | # tcpassembly/tcpreader exported error name
|
||||
grep .; then
|
||||
exit 1
|
||||
fi
|
||||
popd
|
||||
done
|
||||
|
||||
pushd layers
|
||||
for file in $(cat .linted); do
|
||||
if golint $file | grep .; then
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
popd
|
||||
@ -0,0 +1,10 @@
|
||||
#!/bin/bash
|
||||
|
||||
cd "$(dirname $0)"
|
||||
DIRS=". layers pcap pcapgo pfring tcpassembly tcpassembly/tcpreader routing ip4defrag bytediff macs"
|
||||
set -e
|
||||
for subdir in $DIRS; do
|
||||
pushd $subdir
|
||||
go vet
|
||||
popd
|
||||
done
|
||||
@ -0,0 +1,14 @@
|
||||
language: go
|
||||
install:
|
||||
- go get github.com/google/gopacket
|
||||
- go get github.com/google/gopacket/layers
|
||||
- go get github.com/google/gopacket/tcpassembly
|
||||
- go get github.com/google/gopacket/reassembly
|
||||
script:
|
||||
- go test github.com/google/gopacket
|
||||
- go test github.com/google/gopacket/layers
|
||||
- go test github.com/google/gopacket/tcpassembly
|
||||
- go test github.com/google/gopacket/reassembly
|
||||
- ./.travis.gofmt.sh
|
||||
- ./.travis.govet.sh
|
||||
- ./.travis.golint.sh
|
||||
@ -0,0 +1,46 @@
|
||||
AUTHORS AND MAINTAINERS:
|
||||
|
||||
MAIN DEVELOPERS:
|
||||
Graeme Connell <gconnell@google.com, gsconnell@gmail.com>
|
||||
|
||||
AUTHORS:
|
||||
Nigel Tao <nigeltao@google.com>
|
||||
Cole Mickens <cole.mickens@gmail.com>
|
||||
Ben Daglish <bdaglish@restorepoint.com>
|
||||
Luis Martinez <martinezlc99@gmail.com>
|
||||
Remco Verhoef <remco@dutchcoders.io>
|
||||
Hiroaki Kawai <Hiroaki.Kawai@gmail.com>
|
||||
Lukas Lueg <lukas.lueg@gmail.com>
|
||||
Laurent Hausermann <laurent.hausermann@gmail.com>
|
||||
Bill Green <bgreen@newrelic.com>
|
||||
|
||||
CONTRIBUTORS:
|
||||
Attila Oláh <attila@attilaolah.eu>
|
||||
Vittus Mikiassen <matt.miki.vimik@gmail.com>
|
||||
Matthias Radestock <matthias.radestock@gmail.com>
|
||||
Matthew Sackman <matthew@wellquite.org>
|
||||
Loic Prylli <loicp@google.com>
|
||||
Alexandre Fiori <fiorix@gmail.com>
|
||||
Adrian Tam <adrian.c.m.tam@gmail.com>
|
||||
Satoshi Matsumoto <kaorimatz@gmail.com>
|
||||
David Stainton <dstainton415@gmail.com>
|
||||
Jesse Ward <jesse@jesseward.com>
|
||||
Kane Mathers <kane@kanemathers.name>
|
||||
|
||||
-----------------------------------------------
|
||||
FORKED FROM github.com/akrennmair/gopcap
|
||||
ALL THE FOLLOWING ARE FOR THAT PROJECT
|
||||
|
||||
MAIN DEVELOPERS:
|
||||
Andreas Krennmair <ak@synflood.at>
|
||||
|
||||
CONTRIBUTORS:
|
||||
Andrea Nall <anall@andreanall.com>
|
||||
Daniel Arndt <danielarndt@gmail.com>
|
||||
Dustin Sallings <dustin@spy.net>
|
||||
Graeme Connell <gconnell@google.com, gsconnell@gmail.com>
|
||||
Guillaume Savary <guillaume@savary.name>
|
||||
Mark Smith <mark@qq.is>
|
||||
Miek Gieben <miek@miek.nl>
|
||||
Mike Bell <mike@mikebell.org>
|
||||
Trevor Strohman <strohman@google.com>
|
||||
@ -0,0 +1,215 @@
|
||||
Contributing To gopacket
|
||||
========================
|
||||
|
||||
So you've got some code and you'd like it to be part of gopacket... wonderful!
|
||||
We're happy to accept contributions, whether they're fixes to old protocols, new
|
||||
protocols entirely, or anything else you think would improve the gopacket
|
||||
library. This document is designed to help you to do just that.
|
||||
|
||||
The first section deals with the plumbing: how to actually get a change
|
||||
submitted.
|
||||
|
||||
The second section deals with coding style... Go is great in that it
|
||||
has a uniform style implemented by 'go fmt', but there's still some decisions
|
||||
we've made that go above and beyond, and if you follow them, they won't come up
|
||||
in your code review.
|
||||
|
||||
The third section deals with some of the implementation decisions we've made,
|
||||
which may help you to understand the current code and which we may ask you to
|
||||
conform to (or provide compelling reasons for ignoring).
|
||||
|
||||
Overall, we hope this document will help you to understand our system and write
|
||||
great code which fits in, and help us to turn around on your code review quickly
|
||||
so the code can make it into the master branch as quickly as possible.
|
||||
|
||||
|
||||
How To Submit Code
|
||||
------------------
|
||||
|
||||
We use github.com's Pull Request feature to receive code contributions from
|
||||
external contributors. See
|
||||
https://help.github.com/articles/creating-a-pull-request/ for details on
|
||||
how to create a request.
|
||||
|
||||
Also, there's a local script `gc` in the base directory of GoPacket that
|
||||
runs a local set of checks, which should give you relatively high confidence
|
||||
that your pull won't fail github pull checks.
|
||||
|
||||
```sh
|
||||
go get github.com/google/gopacket
|
||||
cd $GOROOT/src/pkg/github.com/google/gopacket
|
||||
git checkout -b <mynewfeature> # create a new branch to work from
|
||||
... code code code ...
|
||||
./gc # Run this to do local commits, it performs a number of checks
|
||||
```
|
||||
|
||||
To sum up:
|
||||
|
||||
* DO
|
||||
+ Pull down the latest version.
|
||||
+ Make a feature-specific branch.
|
||||
+ Code using the style and methods discussed in the rest of this document.
|
||||
+ Use the ./gc command to do local commits or check correctness.
|
||||
+ Push your new feature branch up to github.com, as a pull request.
|
||||
+ Handle comments and requests from reviewers, pushing new commits up to
|
||||
your feature branch as problems are addressed.
|
||||
+ Put interesting comments and discussions into commit comments.
|
||||
* DON'T
|
||||
+ Push to someone else's branch without their permission.
|
||||
|
||||
|
||||
Coding Style
|
||||
------------
|
||||
|
||||
* Go code must be run through `go fmt`, `go vet`, and `golint`
|
||||
* Follow http://golang.org/doc/effective_go.html as much as possible.
|
||||
+ In particular, http://golang.org/doc/effective_go.html#mixed-caps. Enums
|
||||
should be be CamelCase, with acronyms capitalized (TCPSourcePort, vs.
|
||||
TcpSourcePort or TCP_SOURCE_PORT).
|
||||
* Bonus points for giving enum types a String() field.
|
||||
* Any exported types or functions should have commentary
|
||||
(http://golang.org/doc/effective_go.html#commentary)
|
||||
|
||||
|
||||
Coding Methods And Implementation Notes
|
||||
---------------------------------------
|
||||
|
||||
### Error Handling
|
||||
|
||||
Many times, you'll be decoding a protocol and run across something bad, a packet
|
||||
corruption or the like. How do you handle this? First off, ALWAYS report the
|
||||
error. You can do this either by returning the error from the decode() function
|
||||
(most common), or if you're up for it you can implement and add an ErrorLayer
|
||||
through the packet builder (the first method is a simple shortcut that does
|
||||
exactly this, then stops any future decoding).
|
||||
|
||||
Often, you'll already have decode some part of your protocol by the time you hit
|
||||
your error. Use your own discretion to determine whether the stuff you've
|
||||
already decoded should be returned to the caller or not:
|
||||
|
||||
```go
|
||||
func decodeMyProtocol(data []byte, p gopacket.PacketBuilder) error {
|
||||
prot := &MyProtocol{}
|
||||
if len(data) < 10 {
|
||||
// This error occurred before we did ANYTHING, so there's nothing in my
|
||||
// protocol that the caller could possibly want. Just return the error.
|
||||
return fmt.Errorf("Length %d less than 10", len(data))
|
||||
}
|
||||
prot.ImportantField1 = data[:5]
|
||||
prot.ImportantField2 = data[5:10]
|
||||
// At this point, we've already got enough information in 'prot' to
|
||||
// warrant returning it to the caller, so we'll add it now.
|
||||
p.AddLayer(prot)
|
||||
if len(data) < 15 {
|
||||
// We encountered an error later in the packet, but the caller already
|
||||
// has the important info we've gleaned so far.
|
||||
return fmt.Errorf("Length %d less than 15", len(data))
|
||||
}
|
||||
prot.ImportantField3 = data[10:15]
|
||||
return nil // We've already added the layer, we can just return success.
|
||||
}
|
||||
```
|
||||
|
||||
In general, our code follows the approach of returning the first error it
|
||||
encounters. In general, we don't trust any bytes after the first error we see.
|
||||
|
||||
### What Is A Layer?
|
||||
|
||||
The definition of a layer is up to the discretion of the coder. It should be
|
||||
something important enough that it's actually useful to the caller (IE: every
|
||||
TLV value should probably NOT be a layer). However, it can be more granular
|
||||
than a single protocol... IPv6 and SCTP both implement many layers to handle the
|
||||
various parts of the protocol. Use your best judgement, and prepare to defend
|
||||
your decisions during code review. ;)
|
||||
|
||||
### Performance
|
||||
|
||||
We strive to make gopacket as fast as possible while still providing lots of
|
||||
features. In general, this means:
|
||||
|
||||
* Focus performance tuning on common protocols (IP4/6, TCP, etc), and optimize
|
||||
others on an as-needed basis (tons of MPLS on your network? Time to optimize
|
||||
MPLS!)
|
||||
* Use fast operations. See the toplevel benchmark_test for benchmarks of some
|
||||
of Go's underlying features and types.
|
||||
* Test your performance changes! You should use the ./gc script's --benchmark
|
||||
flag to submit any performance-related changes. Use pcap/gopacket_benchmark
|
||||
to test your change against a PCAP file based on your traffic patterns.
|
||||
* Don't be TOO hacky. Sometimes, removing an unused struct from a field causes
|
||||
a huge performance hit, due to the way that Go currently handles its segmented
|
||||
stack... don't be afraid to clean it up anyway. We'll trust the Go compiler
|
||||
to get good enough over time to handle this. Also, this type of
|
||||
compiler-specific optimization is very fragile; someone adding a field to an
|
||||
entirely different struct elsewhere in the codebase could reverse any gains
|
||||
you might achieve by aligning your allocations.
|
||||
* Try to minimize memory allocations. If possible, use []byte to reference
|
||||
pieces of the input, instead of using string, which requires copying the bytes
|
||||
into a new memory allocation.
|
||||
* Think hard about what should be evaluated lazily vs. not. In general, a
|
||||
layer's struct should almost exactly mirror the layer's frame. Anything
|
||||
that's more interesting should be a function. This may not always be
|
||||
possible, but it's a good rule of thumb.
|
||||
* Don't fear micro-optimizations. With the above in mind, we welcome
|
||||
micro-optimizations that we think will have positive/neutral impacts on the
|
||||
majority of workloads. A prime example of this is pre-allocating certain
|
||||
structs within a larger one:
|
||||
|
||||
```go
|
||||
type MyProtocol struct {
|
||||
// Most packets have 1-4 of VeryCommon, so we preallocate it here.
|
||||
initialAllocation [4]uint32
|
||||
VeryCommon []uint32
|
||||
}
|
||||
|
||||
func decodeMyProtocol(data []byte, p gopacket.PacketBuilder) error {
|
||||
prot := &MyProtocol{}
|
||||
prot.VeryCommon = proto.initialAllocation[:0]
|
||||
for len(data) > 4 {
|
||||
field := binary.BigEndian.Uint32(data[:4])
|
||||
data = data[4:]
|
||||
// Since we're using the underlying initialAllocation, we won't need to
|
||||
// allocate new memory for the following append unless we more than 16
|
||||
// bytes of data, which should be the uncommon case.
|
||||
prot.VeryCommon = append(prot.VeryCommon, field)
|
||||
}
|
||||
p.AddLayer(prot)
|
||||
if len(data) > 0 {
|
||||
return fmt.Errorf("MyProtocol packet has %d bytes left after decoding", len(data))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
```
|
||||
|
||||
### Slices And Data
|
||||
|
||||
If you're pulling a slice from the data you're decoding, don't copy it. Just
|
||||
use the slice itself.
|
||||
|
||||
```go
|
||||
type MyProtocol struct {
|
||||
A, B net.IP
|
||||
}
|
||||
func decodeMyProtocol(data []byte, p gopacket.PacketBuilder) error {
|
||||
p.AddLayer(&MyProtocol{
|
||||
A: data[:4],
|
||||
B: data[4:8],
|
||||
})
|
||||
return nil
|
||||
}
|
||||
```
|
||||
|
||||
The caller has already agreed, by using this library, that they won't modify the
|
||||
set of bytes they pass in to the decoder, or the library has already copied the
|
||||
set of bytes to a read-only location. See DecodeOptions.NoCopy for more
|
||||
information.
|
||||
|
||||
### Enums/Types
|
||||
|
||||
If a protocol has an integer field (uint8, uint16, etc) with a couple of known
|
||||
values that mean something special, make it a type. This allows us to do really
|
||||
nice things like adding a String() function to them, so we can more easily
|
||||
display those to users. Check out layers/enums.go for one example, as well as
|
||||
layers/icmp.go for layer-specific enums.
|
||||
|
||||
When naming things, try for descriptiveness over suscinctness. For example,
|
||||
choose DNSResponseRecord over DNSRR.
|
||||
@ -0,0 +1,28 @@
|
||||
Copyright (c) 2012 Google, Inc. All rights reserved.
|
||||
Copyright (c) 2009-2011 Andreas Krennmair. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following disclaimer
|
||||
in the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
* Neither the name of Andreas Krennmair, Google, nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
@ -0,0 +1,10 @@
|
||||
# GoPacket
|
||||
|
||||
This library provides packet decoding capabilities for Go.
|
||||
See [godoc](https://godoc.org/github.com/google/gopacket) for more details.
|
||||
|
||||
[](https://travis-ci.org/google/gopacket)
|
||||
[](https://godoc.org/github.com/google/gopacket)
|
||||
|
||||
Originally forked from the gopcap project written by Andreas
|
||||
Krennmair <ak@synflood.at> (http://github.com/akrennmair/gopcap).
|
||||
@ -0,0 +1,178 @@
|
||||
// Copyright 2012 Google, 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 gopacket
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// Layer represents a single decoded packet layer (using either the
|
||||
// OSI or TCP/IP definition of a layer). When decoding, a packet's data is
|
||||
// broken up into a number of layers. The caller may call LayerType() to
|
||||
// figure out which type of layer they've received from the packet. Optionally,
|
||||
// they may then use a type assertion to get the actual layer type for deep
|
||||
// inspection of the data.
|
||||
type Layer interface {
|
||||
// LayerType is the gopacket type for this layer.
|
||||
LayerType() LayerType
|
||||
// LayerContents returns the set of bytes that make up this layer.
|
||||
LayerContents() []byte
|
||||
// LayerPayload returns the set of bytes contained within this layer, not
|
||||
// including the layer itself.
|
||||
LayerPayload() []byte
|
||||
}
|
||||
|
||||
// Payload is a Layer containing the payload of a packet. The definition of
|
||||
// what constitutes the payload of a packet depends on previous layers; for
|
||||
// TCP and UDP, we stop decoding above layer 4 and return the remaining
|
||||
// bytes as a Payload. Payload is an ApplicationLayer.
|
||||
type Payload []byte
|
||||
|
||||
// LayerType returns LayerTypePayload
|
||||
func (p Payload) LayerType() LayerType { return LayerTypePayload }
|
||||
|
||||
// LayerContents returns the bytes making up this layer.
|
||||
func (p Payload) LayerContents() []byte { return []byte(p) }
|
||||
|
||||
// LayerPayload returns the payload within this layer.
|
||||
func (p Payload) LayerPayload() []byte { return nil }
|
||||
|
||||
// Payload returns this layer as bytes.
|
||||
func (p Payload) Payload() []byte { return []byte(p) }
|
||||
|
||||
// String implements fmt.Stringer.
|
||||
func (p Payload) String() string { return fmt.Sprintf("%d byte(s)", len(p)) }
|
||||
|
||||
// GoString implements fmt.GoStringer.
|
||||
func (p Payload) GoString() string { return LongBytesGoString([]byte(p)) }
|
||||
|
||||
// CanDecode implements DecodingLayer.
|
||||
func (p Payload) CanDecode() LayerClass { return LayerTypePayload }
|
||||
|
||||
// NextLayerType implements DecodingLayer.
|
||||
func (p Payload) NextLayerType() LayerType { return LayerTypeZero }
|
||||
|
||||
// DecodeFromBytes implements DecodingLayer.
|
||||
func (p *Payload) DecodeFromBytes(data []byte, df DecodeFeedback) error {
|
||||
*p = Payload(data)
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (p Payload) SerializeTo(b SerializeBuffer, opts SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(len(p))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
copy(bytes, p)
|
||||
return nil
|
||||
}
|
||||
|
||||
// decodePayload decodes data by returning it all in a Payload layer.
|
||||
func decodePayload(data []byte, p PacketBuilder) error {
|
||||
payload := &Payload{}
|
||||
if err := payload.DecodeFromBytes(data, p); err != nil {
|
||||
return nil
|
||||
}
|
||||
p.AddLayer(payload)
|
||||
p.SetApplicationLayer(payload)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Fragment is a Layer containing a fragment of a larger frame, used by layers
|
||||
// like IPv4 and IPv6 that allow for fragmentation of their payloads.
|
||||
type Fragment []byte
|
||||
|
||||
// LayerType returns LayerTypeFragment
|
||||
func (p *Fragment) LayerType() LayerType { return LayerTypeFragment }
|
||||
|
||||
// LayerContents implements Layer.
|
||||
func (p *Fragment) LayerContents() []byte { return []byte(*p) }
|
||||
|
||||
// LayerPayload implements Layer.
|
||||
func (p *Fragment) LayerPayload() []byte { return nil }
|
||||
|
||||
// Payload returns this layer as a byte slice.
|
||||
func (p *Fragment) Payload() []byte { return []byte(*p) }
|
||||
|
||||
// String implements fmt.Stringer.
|
||||
func (p *Fragment) String() string { return fmt.Sprintf("%d byte(s)", len(*p)) }
|
||||
|
||||
// CanDecode implements DecodingLayer.
|
||||
func (p *Fragment) CanDecode() LayerClass { return LayerTypeFragment }
|
||||
|
||||
// NextLayerType implements DecodingLayer.
|
||||
func (p *Fragment) NextLayerType() LayerType { return LayerTypeZero }
|
||||
|
||||
// DecodeFromBytes implements DecodingLayer.
|
||||
func (p *Fragment) DecodeFromBytes(data []byte, df DecodeFeedback) error {
|
||||
*p = Fragment(data)
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (p *Fragment) SerializeTo(b SerializeBuffer, opts SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(len(*p))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
copy(bytes, *p)
|
||||
return nil
|
||||
}
|
||||
|
||||
// decodeFragment decodes data by returning it all in a Fragment layer.
|
||||
func decodeFragment(data []byte, p PacketBuilder) error {
|
||||
payload := &Fragment{}
|
||||
if err := payload.DecodeFromBytes(data, p); err != nil {
|
||||
return nil
|
||||
}
|
||||
p.AddLayer(payload)
|
||||
p.SetApplicationLayer(payload)
|
||||
return nil
|
||||
}
|
||||
|
||||
// These layers correspond to Internet Protocol Suite (TCP/IP) layers, and their
|
||||
// corresponding OSI layers, as best as possible.
|
||||
|
||||
// LinkLayer is the packet layer corresponding to TCP/IP layer 1 (OSI layer 2)
|
||||
type LinkLayer interface {
|
||||
Layer
|
||||
LinkFlow() Flow
|
||||
}
|
||||
|
||||
// NetworkLayer is the packet layer corresponding to TCP/IP layer 2 (OSI
|
||||
// layer 3)
|
||||
type NetworkLayer interface {
|
||||
Layer
|
||||
NetworkFlow() Flow
|
||||
}
|
||||
|
||||
// TransportLayer is the packet layer corresponding to the TCP/IP layer 3 (OSI
|
||||
// layer 4)
|
||||
type TransportLayer interface {
|
||||
Layer
|
||||
TransportFlow() Flow
|
||||
}
|
||||
|
||||
// ApplicationLayer is the packet layer corresponding to the TCP/IP layer 4 (OSI
|
||||
// layer 7), also known as the packet payload.
|
||||
type ApplicationLayer interface {
|
||||
Layer
|
||||
Payload() []byte
|
||||
}
|
||||
|
||||
// ErrorLayer is a packet layer created when decoding of the packet has failed.
|
||||
// Its payload is all the bytes that we were unable to decode, and the returned
|
||||
// error details why the decoding failed.
|
||||
type ErrorLayer interface {
|
||||
Layer
|
||||
Error() error
|
||||
}
|
||||
@ -0,0 +1,157 @@
|
||||
// Copyright 2012 Google, 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 gopacket
|
||||
|
||||
import (
|
||||
"errors"
|
||||
)
|
||||
|
||||
// DecodeFeedback is used by DecodingLayer layers to provide decoding metadata.
|
||||
type DecodeFeedback interface {
|
||||
// SetTruncated should be called if during decoding you notice that a packet
|
||||
// is shorter than internal layer variables (HeaderLength, or the like) say it
|
||||
// should be. It sets packet.Metadata().Truncated.
|
||||
SetTruncated()
|
||||
}
|
||||
|
||||
type nilDecodeFeedback struct{}
|
||||
|
||||
func (nilDecodeFeedback) SetTruncated() {}
|
||||
|
||||
// NilDecodeFeedback implements DecodeFeedback by doing nothing.
|
||||
var NilDecodeFeedback DecodeFeedback = nilDecodeFeedback{}
|
||||
|
||||
// PacketBuilder is used by layer decoders to store the layers they've decoded,
|
||||
// and to defer future decoding via NextDecoder.
|
||||
// Typically, the pattern for use is:
|
||||
// func (m *myDecoder) Decode(data []byte, p PacketBuilder) error {
|
||||
// if myLayer, err := myDecodingLogic(data); err != nil {
|
||||
// return err
|
||||
// } else {
|
||||
// p.AddLayer(myLayer)
|
||||
// }
|
||||
// // maybe do this, if myLayer is a LinkLayer
|
||||
// p.SetLinkLayer(myLayer)
|
||||
// return p.NextDecoder(nextDecoder)
|
||||
// }
|
||||
type PacketBuilder interface {
|
||||
DecodeFeedback
|
||||
// AddLayer should be called by a decoder immediately upon successful
|
||||
// decoding of a layer.
|
||||
AddLayer(l Layer)
|
||||
// The following functions set the various specific layers in the final
|
||||
// packet. Note that if many layers call SetX, the first call is kept and all
|
||||
// other calls are ignored.
|
||||
SetLinkLayer(LinkLayer)
|
||||
SetNetworkLayer(NetworkLayer)
|
||||
SetTransportLayer(TransportLayer)
|
||||
SetApplicationLayer(ApplicationLayer)
|
||||
SetErrorLayer(ErrorLayer)
|
||||
// NextDecoder should be called by a decoder when they're done decoding a
|
||||
// packet layer but not done with decoding the entire packet. The next
|
||||
// decoder will be called to decode the last AddLayer's LayerPayload.
|
||||
// Because of this, NextDecoder must only be called once all other
|
||||
// PacketBuilder calls have been made. Set*Layer and AddLayer calls after
|
||||
// NextDecoder calls will behave incorrectly.
|
||||
NextDecoder(next Decoder) error
|
||||
// DumpPacketData is used solely for decoding. If you come across an error
|
||||
// you need to diagnose while processing a packet, call this and your packet's
|
||||
// data will be dumped to stderr so you can create a test. This should never
|
||||
// be called from a production decoder.
|
||||
DumpPacketData()
|
||||
// DecodeOptions returns the decode options
|
||||
DecodeOptions() *DecodeOptions
|
||||
}
|
||||
|
||||
// Decoder is an interface for logic to decode a packet layer. Users may
|
||||
// implement a Decoder to handle their own strange packet types, or may use one
|
||||
// of the many decoders available in the 'layers' subpackage to decode things
|
||||
// for them.
|
||||
type Decoder interface {
|
||||
// Decode decodes the bytes of a packet, sending decoded values and other
|
||||
// information to PacketBuilder, and returning an error if unsuccessful. See
|
||||
// the PacketBuilder documentation for more details.
|
||||
Decode([]byte, PacketBuilder) error
|
||||
}
|
||||
|
||||
// DecodeFunc wraps a function to make it a Decoder.
|
||||
type DecodeFunc func([]byte, PacketBuilder) error
|
||||
|
||||
// Decode implements Decoder by calling itself.
|
||||
func (d DecodeFunc) Decode(data []byte, p PacketBuilder) error {
|
||||
// function, call thyself.
|
||||
return d(data, p)
|
||||
}
|
||||
|
||||
// DecodePayload is a Decoder that returns a Payload layer containing all
|
||||
// remaining bytes.
|
||||
var DecodePayload Decoder = DecodeFunc(decodePayload)
|
||||
|
||||
// DecodeUnknown is a Decoder that returns an Unknown layer containing all
|
||||
// remaining bytes, useful if you run up against a layer that you're unable to
|
||||
// decode yet. This layer is considered an ErrorLayer.
|
||||
var DecodeUnknown Decoder = DecodeFunc(decodeUnknown)
|
||||
|
||||
// DecodeFragment is a Decoder that returns a Fragment layer containing all
|
||||
// remaining bytes.
|
||||
var DecodeFragment Decoder = DecodeFunc(decodeFragment)
|
||||
|
||||
// LayerTypeZero is an invalid layer type, but can be used to determine whether
|
||||
// layer type has actually been set correctly.
|
||||
var LayerTypeZero = RegisterLayerType(0, LayerTypeMetadata{Name: "Unknown", Decoder: DecodeUnknown})
|
||||
|
||||
// LayerTypeDecodeFailure is the layer type for the default error layer.
|
||||
var LayerTypeDecodeFailure = RegisterLayerType(1, LayerTypeMetadata{Name: "DecodeFailure", Decoder: DecodeUnknown})
|
||||
|
||||
// LayerTypePayload is the layer type for a payload that we don't try to decode
|
||||
// but treat as a success, IE: an application-level payload.
|
||||
var LayerTypePayload = RegisterLayerType(2, LayerTypeMetadata{Name: "Payload", Decoder: DecodePayload})
|
||||
|
||||
// LayerTypeFragment is the layer type for a fragment of a layer transported
|
||||
// by an underlying layer that supports fragmentation.
|
||||
var LayerTypeFragment = RegisterLayerType(3, LayerTypeMetadata{Name: "Fragment", Decoder: DecodeFragment})
|
||||
|
||||
// DecodeFailure is a packet layer created if decoding of the packet data failed
|
||||
// for some reason. It implements ErrorLayer. LayerContents will be the entire
|
||||
// set of bytes that failed to parse, and Error will return the reason parsing
|
||||
// failed.
|
||||
type DecodeFailure struct {
|
||||
data []byte
|
||||
err error
|
||||
stack []byte
|
||||
}
|
||||
|
||||
// Error returns the error encountered during decoding.
|
||||
func (d *DecodeFailure) Error() error { return d.err }
|
||||
|
||||
// LayerContents implements Layer.
|
||||
func (d *DecodeFailure) LayerContents() []byte { return d.data }
|
||||
|
||||
// LayerPayload implements Layer.
|
||||
func (d *DecodeFailure) LayerPayload() []byte { return nil }
|
||||
|
||||
// String implements fmt.Stringer.
|
||||
func (d *DecodeFailure) String() string {
|
||||
return "Packet decoding error: " + d.Error().Error()
|
||||
}
|
||||
|
||||
// Dump implements Dumper.
|
||||
func (d *DecodeFailure) Dump() (s string) {
|
||||
if d.stack != nil {
|
||||
s = string(d.stack)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeDecodeFailure
|
||||
func (d *DecodeFailure) LayerType() LayerType { return LayerTypeDecodeFailure }
|
||||
|
||||
// decodeUnknown "decodes" unsupported data types by returning an error.
|
||||
// This decoder will thus always return a DecodeFailure layer.
|
||||
func decodeUnknown(data []byte, p PacketBuilder) error {
|
||||
return errors.New("Layer type not currently supported")
|
||||
}
|
||||
@ -0,0 +1,365 @@
|
||||
// Copyright 2012 Google, 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 gopacket provides packet decoding for the Go language.
|
||||
|
||||
gopacket contains many sub-packages with additional functionality you may find
|
||||
useful, including:
|
||||
|
||||
* layers: You'll probably use this every time. This contains of the logic
|
||||
built into gopacket for decoding packet protocols. Note that all example
|
||||
code below assumes that you have imported both gopacket and
|
||||
gopacket/layers.
|
||||
* pcap: C bindings to use libpcap to read packets off the wire.
|
||||
* pfring: C bindings to use PF_RING to read packets off the wire.
|
||||
* afpacket: C bindings for Linux's AF_PACKET to read packets off the wire.
|
||||
* tcpassembly: TCP stream reassembly
|
||||
|
||||
Also, if you're looking to dive right into code, see the examples subdirectory
|
||||
for numerous simple binaries built using gopacket libraries.
|
||||
|
||||
Basic Usage
|
||||
|
||||
gopacket takes in packet data as a []byte and decodes it into a packet with
|
||||
a non-zero number of "layers". Each layer corresponds to a protocol
|
||||
within the bytes. Once a packet has been decoded, the layers of the packet
|
||||
can be requested from the packet.
|
||||
|
||||
// Decode a packet
|
||||
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Default)
|
||||
// Get the TCP layer from this packet
|
||||
if tcpLayer := packet.Layer(layers.LayerTypeTCP); tcpLayer != nil {
|
||||
fmt.Println("This is a TCP packet!")
|
||||
// Get actual TCP data from this layer
|
||||
tcp, _ := tcpLayer.(*layers.TCP)
|
||||
fmt.Printf("From src port %d to dst port %d\n", tcp.SrcPort, tcp.DstPort)
|
||||
}
|
||||
// Iterate over all layers, printing out each layer type
|
||||
for _, layer := range packet.Layers() {
|
||||
fmt.Println("PACKET LAYER:", layer.LayerType())
|
||||
}
|
||||
|
||||
Packets can be decoded from a number of starting points. Many of our base
|
||||
types implement Decoder, which allow us to decode packets for which
|
||||
we don't have full data.
|
||||
|
||||
// Decode an ethernet packet
|
||||
ethP := gopacket.NewPacket(p1, layers.LayerTypeEthernet, gopacket.Default)
|
||||
// Decode an IPv6 header and everything it contains
|
||||
ipP := gopacket.NewPacket(p2, layers.LayerTypeIPv6, gopacket.Default)
|
||||
// Decode a TCP header and its payload
|
||||
tcpP := gopacket.NewPacket(p3, layers.LayerTypeTCP, gopacket.Default)
|
||||
|
||||
|
||||
Reading Packets From A Source
|
||||
|
||||
Most of the time, you won't just have a []byte of packet data lying around.
|
||||
Instead, you'll want to read packets in from somewhere (file, interface, etc)
|
||||
and process them. To do that, you'll want to build a PacketSource.
|
||||
|
||||
First, you'll need to construct an object that implements the PacketDataSource
|
||||
interface. There are implementations of this interface bundled with gopacket
|
||||
in the gopacket/pcap and gopacket/pfring subpackages... see their documentation
|
||||
for more information on their usage. Once you have a PacketDataSource, you can
|
||||
pass it into NewPacketSource, along with a Decoder of your choice, to create
|
||||
a PacketSource.
|
||||
|
||||
Once you have a PacketSource, you can read packets from it in multiple ways.
|
||||
See the docs for PacketSource for more details. The easiest method is the
|
||||
Packets function, which returns a channel, then asynchronously writes new
|
||||
packets into that channel, closing the channel if the packetSource hits an
|
||||
end-of-file.
|
||||
|
||||
packetSource := ... // construct using pcap or pfring
|
||||
for packet := range packetSource.Packets() {
|
||||
handlePacket(packet) // do something with each packet
|
||||
}
|
||||
|
||||
You can change the decoding options of the packetSource by setting fields in
|
||||
packetSource.DecodeOptions... see the following sections for more details.
|
||||
|
||||
|
||||
Lazy Decoding
|
||||
|
||||
gopacket optionally decodes packet data lazily, meaning it
|
||||
only decodes a packet layer when it needs to handle a function call.
|
||||
|
||||
// Create a packet, but don't actually decode anything yet
|
||||
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy)
|
||||
// Now, decode the packet up to the first IPv4 layer found but no further.
|
||||
// If no IPv4 layer was found, the whole packet will be decoded looking for
|
||||
// it.
|
||||
ip4 := packet.Layer(layers.LayerTypeIPv4)
|
||||
// Decode all layers and return them. The layers up to the first IPv4 layer
|
||||
// are already decoded, and will not require decoding a second time.
|
||||
layers := packet.Layers()
|
||||
|
||||
Lazily-decoded packets are not concurrency-safe. Since layers have not all been
|
||||
decoded, each call to Layer() or Layers() has the potential to mutate the packet
|
||||
in order to decode the next layer. If a packet is used
|
||||
in multiple goroutines concurrently, don't use gopacket.Lazy. Then gopacket
|
||||
will decode the packet fully, and all future function calls won't mutate the
|
||||
object.
|
||||
|
||||
|
||||
NoCopy Decoding
|
||||
|
||||
By default, gopacket will copy the slice passed to NewPacket and store the
|
||||
copy within the packet, so future mutations to the bytes underlying the slice
|
||||
don't affect the packet and its layers. If you can guarantee that the
|
||||
underlying slice bytes won't be changed, you can use NoCopy to tell
|
||||
gopacket.NewPacket, and it'll use the passed-in slice itself.
|
||||
|
||||
// This channel returns new byte slices, each of which points to a new
|
||||
// memory location that's guaranteed immutable for the duration of the
|
||||
// packet.
|
||||
for data := range myByteSliceChannel {
|
||||
p := gopacket.NewPacket(data, layers.LayerTypeEthernet, gopacket.NoCopy)
|
||||
doSomethingWithPacket(p)
|
||||
}
|
||||
|
||||
The fastest method of decoding is to use both Lazy and NoCopy, but note from
|
||||
the many caveats above that for some implementations either or both may be
|
||||
dangerous.
|
||||
|
||||
|
||||
Pointers To Known Layers
|
||||
|
||||
During decoding, certain layers are stored in the packet as well-known
|
||||
layer types. For example, IPv4 and IPv6 are both considered NetworkLayer
|
||||
layers, while TCP and UDP are both TransportLayer layers. We support 4
|
||||
layers, corresponding to the 4 layers of the TCP/IP layering scheme (roughly
|
||||
anagalous to layers 2, 3, 4, and 7 of the OSI model). To access these,
|
||||
you can use the packet.LinkLayer, packet.NetworkLayer,
|
||||
packet.TransportLayer, and packet.ApplicationLayer functions. Each of
|
||||
these functions returns a corresponding interface
|
||||
(gopacket.{Link,Network,Transport,Application}Layer). The first three
|
||||
provide methods for getting src/dst addresses for that particular layer,
|
||||
while the final layer provides a Payload function to get payload data.
|
||||
This is helpful, for example, to get payloads for all packets regardless
|
||||
of their underlying data type:
|
||||
|
||||
// Get packets from some source
|
||||
for packet := range someSource {
|
||||
if app := packet.ApplicationLayer(); app != nil {
|
||||
if strings.Contains(string(app.Payload()), "magic string") {
|
||||
fmt.Println("Found magic string in a packet!")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
A particularly useful layer is ErrorLayer, which is set whenever there's
|
||||
an error parsing part of the packet.
|
||||
|
||||
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Default)
|
||||
if err := packet.ErrorLayer(); err != nil {
|
||||
fmt.Println("Error decoding some part of the packet:", err)
|
||||
}
|
||||
|
||||
Note that we don't return an error from NewPacket because we may have decoded
|
||||
a number of layers successfully before running into our erroneous layer. You
|
||||
may still be able to get your Ethernet and IPv4 layers correctly, even if
|
||||
your TCP layer is malformed.
|
||||
|
||||
|
||||
Flow And Endpoint
|
||||
|
||||
gopacket has two useful objects, Flow and Endpoint, for communicating in a protocol
|
||||
independent manner the fact that a packet is coming from A and going to B.
|
||||
The general layer types LinkLayer, NetworkLayer, and TransportLayer all provide
|
||||
methods for extracting their flow information, without worrying about the type
|
||||
of the underlying Layer.
|
||||
|
||||
A Flow is a simple object made up of a set of two Endpoints, one source and one
|
||||
destination. It details the sender and receiver of the Layer of the Packet.
|
||||
|
||||
An Endpoint is a hashable representation of a source or destination. For
|
||||
example, for LayerTypeIPv4, an Endpoint contains the IP address bytes for a v4
|
||||
IP packet. A Flow can be broken into Endpoints, and Endpoints can be combined
|
||||
into Flows:
|
||||
|
||||
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy)
|
||||
netFlow := packet.NetworkLayer().NetworkFlow()
|
||||
src, dst := netFlow.Endpoints()
|
||||
reverseFlow := gopacket.NewFlow(dst, src)
|
||||
|
||||
Both Endpoint and Flow objects can be used as map keys, and the equality
|
||||
operator can compare them, so you can easily group together all packets
|
||||
based on endpoint criteria:
|
||||
|
||||
flows := map[gopacket.Endpoint]chan gopacket.Packet
|
||||
packet := gopacket.NewPacket(myPacketData, layers.LayerTypeEthernet, gopacket.Lazy)
|
||||
// Send all TCP packets to channels based on their destination port.
|
||||
if tcp := packet.Layer(layers.LayerTypeTCP); tcp != nil {
|
||||
flows[tcp.TransportFlow().Dst()] <- packet
|
||||
}
|
||||
// Look for all packets with the same source and destination network address
|
||||
if net := packet.NetworkLayer(); net != nil {
|
||||
src, dst := net.NetworkFlow().Endpoints()
|
||||
if src == dst {
|
||||
fmt.Println("Fishy packet has same network source and dst: %s", src)
|
||||
}
|
||||
}
|
||||
// Find all packets coming from UDP port 1000 to UDP port 500
|
||||
interestingFlow := gopacket.NewFlow(layers.NewUDPPortEndpoint(1000), layers.NewUDPPortEndpoint(500))
|
||||
if t := packet.NetworkLayer(); t != nil && t.TransportFlow() == interestingFlow {
|
||||
fmt.Println("Found that UDP flow I was looking for!")
|
||||
}
|
||||
|
||||
For load-balancing purposes, both Flow and Endpoint have FastHash() functions,
|
||||
which provide quick, non-cryptographic hashes of their contents. Of particular
|
||||
importance is the fact that Flow FastHash() is symmetric: A->B will have the same
|
||||
hash as B->A. An example usage could be:
|
||||
|
||||
channels := [8]chan gopacket.Packet
|
||||
for i := 0; i < 8; i++ {
|
||||
channels[i] = make(chan gopacket.Packet)
|
||||
go packetHandler(channels[i])
|
||||
}
|
||||
for packet := range getPackets() {
|
||||
if net := packet.NetworkLayer(); net != nil {
|
||||
channels[int(net.NetworkFlow().FastHash()) & 0x7] <- packet
|
||||
}
|
||||
}
|
||||
|
||||
This allows us to split up a packet stream while still making sure that each
|
||||
stream sees all packets for a flow (and its bidirectional opposite).
|
||||
|
||||
|
||||
Implementing Your Own Decoder
|
||||
|
||||
If your network has some strange encapsulation, you can implement your own
|
||||
decoder. In this example, we handle Ethernet packets which are encapsulated
|
||||
in a 4-byte header.
|
||||
|
||||
// Create a layer type, should be unique and high, so it doesn't conflict,
|
||||
// giving it a name and a decoder to use.
|
||||
var MyLayerType = gopacket.RegisterLayerType(12345, "MyLayerType", gopacket.DecodeFunc(decodeMyLayer))
|
||||
|
||||
// Implement my layer
|
||||
type MyLayer struct {
|
||||
StrangeHeader []byte
|
||||
payload []byte
|
||||
}
|
||||
func (m MyLayer) LayerType() LayerType { return MyLayerType }
|
||||
func (m MyLayer) LayerContents() []byte { return m.StrangeHeader }
|
||||
func (m MyLayer) LayerPayload() []byte { return m.payload }
|
||||
|
||||
// Now implement a decoder... this one strips off the first 4 bytes of the
|
||||
// packet.
|
||||
func decodeMyLayer(data []byte, p gopacket.PacketBuilder) error {
|
||||
// Create my layer
|
||||
p.AddLayer(&MyLayer{data[:4], data[4:]})
|
||||
// Determine how to handle the rest of the packet
|
||||
return p.NextDecoder(layers.LayerTypeEthernet)
|
||||
}
|
||||
|
||||
// Finally, decode your packets:
|
||||
p := gopacket.NewPacket(data, MyLayerType, gopacket.Lazy)
|
||||
|
||||
See the docs for Decoder and PacketBuilder for more details on how coding
|
||||
decoders works, or look at RegisterLayerType and RegisterEndpointType to see how
|
||||
to add layer/endpoint types to gopacket.
|
||||
|
||||
|
||||
Fast Decoding With DecodingLayerParser
|
||||
|
||||
TLDR: DecodingLayerParser takes about 10% of the time as NewPacket to decode
|
||||
packet data, but only for known packet stacks.
|
||||
|
||||
Basic decoding using gopacket.NewPacket or PacketSource.Packets is somewhat slow
|
||||
due to its need to allocate a new packet and every respective layer. It's very
|
||||
versatile and can handle all known layer types, but sometimes you really only
|
||||
care about a specific set of layers regardless, so that versatility is wasted.
|
||||
|
||||
DecodingLayerParser avoids memory allocation altogether by decoding packet
|
||||
layers directly into preallocated objects, which you can then reference to get
|
||||
the packet's information. A quick example:
|
||||
|
||||
func main() {
|
||||
var eth layers.Ethernet
|
||||
var ip4 layers.IPv4
|
||||
var ip6 layers.IPv6
|
||||
var tcp layers.TCP
|
||||
parser := gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet, ð, &ip4, &ip6, &tcp)
|
||||
decoded := []gopacket.LayerType{}
|
||||
for packetData := range somehowGetPacketData() {
|
||||
err := parser.DecodeLayers(packetData, &decoded)
|
||||
for _, layerType := range decoded {
|
||||
switch layerType {
|
||||
case layers.LayerTypeIPv6:
|
||||
fmt.Println(" IP6 ", ip6.SrcIP, ip6.DstIP)
|
||||
case layers.LayerTypeIPv4:
|
||||
fmt.Println(" IP4 ", ip4.SrcIP, ip4.DstIP)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
The important thing to note here is that the parser is modifying the passed in
|
||||
layers (eth, ip4, ip6, tcp) instead of allocating new ones, thus greatly
|
||||
speeding up the decoding process. It's even branching based on layer type...
|
||||
it'll handle an (eth, ip4, tcp) or (eth, ip6, tcp) stack. However, it won't
|
||||
handle any other type... since no other decoders were passed in, an (eth, ip4,
|
||||
udp) stack will stop decoding after ip4, and only pass back [LayerTypeEthernet,
|
||||
LayerTypeIPv4] through the 'decoded' slice (along with an error saying it can't
|
||||
decode a UDP packet).
|
||||
|
||||
Unfortunately, not all layers can be used by DecodingLayerParser... only those
|
||||
implementing the DecodingLayer interface are usable. Also, it's possible to
|
||||
create DecodingLayers that are not themselves Layers... see
|
||||
layers.IPv6ExtensionSkipper for an example of this.
|
||||
|
||||
|
||||
Creating Packet Data
|
||||
|
||||
As well as offering the ability to decode packet data, gopacket will allow you
|
||||
to create packets from scratch, as well. A number of gopacket layers implement
|
||||
the SerializableLayer interface; these layers can be serialized to a []byte in
|
||||
the following manner:
|
||||
|
||||
ip := &layers.IPv4{
|
||||
SrcIP: net.IP{1, 2, 3, 4},
|
||||
DstIP: net.IP{5, 6, 7, 8},
|
||||
// etc...
|
||||
}
|
||||
buf := gopacket.NewSerializeBuffer()
|
||||
opts := gopacket.SerializeOptions{} // See SerializeOptions for more details.
|
||||
err := ip.SerializeTo(&buf, opts)
|
||||
if err != nil { panic(err) }
|
||||
fmt.Println(buf.Bytes()) // prints out a byte slice containing the serialized IPv4 layer.
|
||||
|
||||
SerializeTo PREPENDS the given layer onto the SerializeBuffer, and they treat
|
||||
the current buffer's Bytes() slice as the payload of the serializing layer.
|
||||
Therefore, you can serialize an entire packet by serializing a set of layers in
|
||||
reverse order (Payload, then TCP, then IP, then Ethernet, for example). The
|
||||
SerializeBuffer's SerializeLayers function is a helper that does exactly that.
|
||||
|
||||
To generate a (empty and useless, because no fields are set)
|
||||
Ethernet(IPv4(TCP(Payload))) packet, for example, you can run:
|
||||
|
||||
buf := gopacket.NewSerializeBuffer()
|
||||
opts := gopacket.SerializeOptions{}
|
||||
gopacket.SerializeLayers(buf, opts,
|
||||
&layers.Ethernet{},
|
||||
&layers.IPv4{},
|
||||
&layers.TCP{},
|
||||
gopacket.Payload([]byte{1, 2, 3, 4}))
|
||||
packetData := buf.Bytes()
|
||||
|
||||
A Final Note
|
||||
|
||||
If you use gopacket, you'll almost definitely want to make sure gopacket/layers
|
||||
is imported, since when imported it sets all the LayerType variables and fills
|
||||
in a lot of interesting variables/maps (DecodersByLayerName, etc). Therefore,
|
||||
it's recommended that even if you don't use any layers functions directly, you still import with:
|
||||
|
||||
import (
|
||||
_ "github.com/google/gopacket/layers"
|
||||
)
|
||||
*/
|
||||
package gopacket
|
||||
@ -0,0 +1,236 @@
|
||||
// Copyright 2012 Google, 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 gopacket
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// MaxEndpointSize determines the maximum size in bytes of an endpoint address.
|
||||
//
|
||||
// Endpoints/Flows have a problem: They need to be hashable. Therefore, they
|
||||
// can't use a byte slice. The two obvious choices are to use a string or a
|
||||
// byte array. Strings work great, but string creation requires memory
|
||||
// allocation, which can be slow. Arrays work great, but have a fixed size. We
|
||||
// originally used the former, now we've switched to the latter. Use of a fixed
|
||||
// byte-array doubles the speed of constructing a flow (due to not needing to
|
||||
// allocate). This is a huge increase... too much for us to pass up.
|
||||
//
|
||||
// The end result of this, though, is that an endpoint/flow can't be created
|
||||
// using more than MaxEndpointSize bytes per address.
|
||||
const MaxEndpointSize = 16
|
||||
|
||||
// Endpoint is the set of bytes used to address packets at various layers.
|
||||
// See LinkLayer, NetworkLayer, and TransportLayer specifications.
|
||||
// Endpoints are usable as map keys.
|
||||
type Endpoint struct {
|
||||
typ EndpointType
|
||||
len int
|
||||
raw [MaxEndpointSize]byte
|
||||
}
|
||||
|
||||
// EndpointType returns the endpoint type associated with this endpoint.
|
||||
func (a Endpoint) EndpointType() EndpointType { return a.typ }
|
||||
|
||||
// Raw returns the raw bytes of this endpoint. These aren't human-readable
|
||||
// most of the time, but they are faster than calling String.
|
||||
func (a Endpoint) Raw() []byte { return a.raw[:a.len] }
|
||||
|
||||
// LessThan provides a stable ordering for all endpoints. It sorts first based
|
||||
// on the EndpointType of an endpoint, then based on the raw bytes of that
|
||||
// endpoint.
|
||||
//
|
||||
// For some endpoints, the actual comparison may not make sense, however this
|
||||
// ordering does provide useful information for most Endpoint types.
|
||||
// Ordering is based first on endpoint type, then on raw endpoint bytes.
|
||||
// Endpoint bytes are sorted lexigraphically.
|
||||
func (a Endpoint) LessThan(b Endpoint) bool {
|
||||
return a.typ < b.typ || (a.typ == b.typ && bytes.Compare(a.raw[:a.len], b.raw[:b.len]) < 0)
|
||||
}
|
||||
|
||||
// fnvHash is used by our FastHash functions, and implements the FNV hash
|
||||
// created by Glenn Fowler, Landon Curt Noll, and Phong Vo.
|
||||
// See http://isthe.com/chongo/tech/comp/fnv/.
|
||||
func fnvHash(s []byte) (h uint64) {
|
||||
h = fnvBasis
|
||||
for i := 0; i < len(s); i++ {
|
||||
h ^= uint64(s[i])
|
||||
h *= fnvPrime
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
const fnvBasis = 14695981039346656037
|
||||
const fnvPrime = 1099511628211
|
||||
|
||||
// FastHash provides a quick hashing function for an endpoint, useful if you'd
|
||||
// like to split up endpoints by modulos or other load-balancing techniques.
|
||||
// It uses a variant of Fowler-Noll-Vo hashing.
|
||||
//
|
||||
// The output of FastHash is not guaranteed to remain the same through future
|
||||
// code revisions, so should not be used to key values in persistent storage.
|
||||
func (a Endpoint) FastHash() (h uint64) {
|
||||
h = fnvHash(a.raw[:a.len])
|
||||
h ^= uint64(a.typ)
|
||||
h *= fnvPrime
|
||||
return
|
||||
}
|
||||
|
||||
// NewEndpoint creates a new Endpoint object.
|
||||
//
|
||||
// The size of raw must be less than MaxEndpointSize, otherwise this function
|
||||
// will panic.
|
||||
func NewEndpoint(typ EndpointType, raw []byte) (e Endpoint) {
|
||||
e.len = len(raw)
|
||||
if e.len > MaxEndpointSize {
|
||||
panic("raw byte length greater than MaxEndpointSize")
|
||||
}
|
||||
e.typ = typ
|
||||
copy(e.raw[:], raw)
|
||||
return
|
||||
}
|
||||
|
||||
// EndpointTypeMetadata is used to register a new endpoint type.
|
||||
type EndpointTypeMetadata struct {
|
||||
// Name is the string returned by an EndpointType's String function.
|
||||
Name string
|
||||
// Formatter is called from an Endpoint's String function to format the raw
|
||||
// bytes in an Endpoint into a human-readable string.
|
||||
Formatter func([]byte) string
|
||||
}
|
||||
|
||||
// EndpointType is the type of a gopacket Endpoint. This type determines how
|
||||
// the bytes stored in the endpoint should be interpreted.
|
||||
type EndpointType int64
|
||||
|
||||
var endpointTypes = map[EndpointType]EndpointTypeMetadata{}
|
||||
|
||||
// RegisterEndpointType creates a new EndpointType and registers it globally.
|
||||
// It MUST be passed a unique number, or it will panic. Numbers 0-999 are
|
||||
// reserved for gopacket's use.
|
||||
func RegisterEndpointType(num int, meta EndpointTypeMetadata) EndpointType {
|
||||
t := EndpointType(num)
|
||||
if _, ok := endpointTypes[t]; ok {
|
||||
panic("Endpoint type number already in use")
|
||||
}
|
||||
endpointTypes[t] = meta
|
||||
return t
|
||||
}
|
||||
|
||||
func (e EndpointType) String() string {
|
||||
if t, ok := endpointTypes[e]; ok {
|
||||
return t.Name
|
||||
}
|
||||
return strconv.Itoa(int(e))
|
||||
}
|
||||
|
||||
func (a Endpoint) String() string {
|
||||
if t, ok := endpointTypes[a.typ]; ok && t.Formatter != nil {
|
||||
return t.Formatter(a.raw[:a.len])
|
||||
}
|
||||
return fmt.Sprintf("%v:%v", a.typ, a.raw)
|
||||
}
|
||||
|
||||
// Flow represents the direction of traffic for a packet layer, as a source and destination Endpoint.
|
||||
// Flows are usable as map keys.
|
||||
type Flow struct {
|
||||
typ EndpointType
|
||||
slen, dlen int
|
||||
src, dst [MaxEndpointSize]byte
|
||||
}
|
||||
|
||||
// FlowFromEndpoints creates a new flow by pasting together two endpoints.
|
||||
// The endpoints must have the same EndpointType, or this function will return
|
||||
// an error.
|
||||
func FlowFromEndpoints(src, dst Endpoint) (_ Flow, err error) {
|
||||
if src.typ != dst.typ {
|
||||
err = fmt.Errorf("Mismatched endpoint types: %v->%v", src.typ, dst.typ)
|
||||
return
|
||||
}
|
||||
return Flow{src.typ, src.len, dst.len, src.raw, dst.raw}, nil
|
||||
}
|
||||
|
||||
// FastHash provides a quick hashing function for a flow, useful if you'd
|
||||
// like to split up flows by modulos or other load-balancing techniques.
|
||||
// It uses a variant of Fowler-Noll-Vo hashing, and is guaranteed to collide
|
||||
// with its reverse flow. IE: the flow A->B will have the same hash as the flow
|
||||
// B->A.
|
||||
//
|
||||
// The output of FastHash is not guaranteed to remain the same through future
|
||||
// code revisions, so should not be used to key values in persistent storage.
|
||||
func (f Flow) FastHash() (h uint64) {
|
||||
// This combination must be commutative. We don't use ^, since that would
|
||||
// give the same hash for all A->A flows.
|
||||
h = fnvHash(f.src[:f.slen]) + fnvHash(f.dst[:f.dlen])
|
||||
h ^= uint64(f.typ)
|
||||
h *= fnvPrime
|
||||
return
|
||||
}
|
||||
|
||||
// String returns a human-readable representation of this flow, in the form
|
||||
// "Src->Dst"
|
||||
func (f Flow) String() string {
|
||||
s, d := f.Endpoints()
|
||||
return fmt.Sprintf("%v->%v", s, d)
|
||||
}
|
||||
|
||||
// EndpointType returns the EndpointType for this Flow.
|
||||
func (f Flow) EndpointType() EndpointType {
|
||||
return f.typ
|
||||
}
|
||||
|
||||
// Endpoints returns the two Endpoints for this flow.
|
||||
func (f Flow) Endpoints() (src, dst Endpoint) {
|
||||
return Endpoint{f.typ, f.slen, f.src}, Endpoint{f.typ, f.dlen, f.dst}
|
||||
}
|
||||
|
||||
// Src returns the source Endpoint for this flow.
|
||||
func (f Flow) Src() (src Endpoint) {
|
||||
src, _ = f.Endpoints()
|
||||
return
|
||||
}
|
||||
|
||||
// Dst returns the destination Endpoint for this flow.
|
||||
func (f Flow) Dst() (dst Endpoint) {
|
||||
_, dst = f.Endpoints()
|
||||
return
|
||||
}
|
||||
|
||||
// Reverse returns a new flow with endpoints reversed.
|
||||
func (f Flow) Reverse() Flow {
|
||||
return Flow{f.typ, f.dlen, f.slen, f.dst, f.src}
|
||||
}
|
||||
|
||||
// NewFlow creates a new flow.
|
||||
//
|
||||
// src and dst must have length <= MaxEndpointSize, otherwise NewFlow will
|
||||
// panic.
|
||||
func NewFlow(t EndpointType, src, dst []byte) (f Flow) {
|
||||
f.slen = len(src)
|
||||
f.dlen = len(dst)
|
||||
if f.slen > MaxEndpointSize || f.dlen > MaxEndpointSize {
|
||||
panic("flow raw byte length greater than MaxEndpointSize")
|
||||
}
|
||||
f.typ = t
|
||||
copy(f.src[:], src)
|
||||
copy(f.dst[:], dst)
|
||||
return
|
||||
}
|
||||
|
||||
// EndpointInvalid is an endpoint type used for invalid endpoints, IE endpoints
|
||||
// that are specified incorrectly during creation.
|
||||
var EndpointInvalid = RegisterEndpointType(0, EndpointTypeMetadata{Name: "invalid", Formatter: func(b []byte) string {
|
||||
return fmt.Sprintf("%v", b)
|
||||
}})
|
||||
|
||||
// InvalidEndpoint is a singleton Endpoint of type EndpointInvalid.
|
||||
var InvalidEndpoint = NewEndpoint(EndpointInvalid, nil)
|
||||
|
||||
// InvalidFlow is a singleton Flow of type EndpointInvalid.
|
||||
var InvalidFlow = NewFlow(EndpointInvalid, nil, nil)
|
||||
@ -0,0 +1,278 @@
|
||||
#!/bin/bash
|
||||
# Copyright 2012 Google, Inc. All rights reserved.
|
||||
|
||||
# This script provides a simple way to run benchmarks against previous code and
|
||||
# keep a log of how benchmarks change over time. When used with the --benchmark
|
||||
# flag, it runs benchmarks from the current code and from the last commit run
|
||||
# with --benchmark, then stores the results in the git commit description. We
|
||||
# rerun the old benchmarks along with the new ones, since there's no guarantee
|
||||
# that git commits will happen on the same machine, so machine differences could
|
||||
# cause wildly inaccurate results.
|
||||
#
|
||||
# If you're making changes to 'gopacket' which could cause performance changes,
|
||||
# you may be requested to use this commit script to make sure your changes don't
|
||||
# have large detrimental effects (or to show off how awesome your performance
|
||||
# improvements are).
|
||||
#
|
||||
# If not run with the --benchmark flag, this script is still very useful... it
|
||||
# makes sure all the correct go formatting, building, and testing work as
|
||||
# expected.
|
||||
|
||||
function Usage {
|
||||
cat <<EOF
|
||||
USAGE: $0 [--benchmark regexp] [--root] [--gen] <git commit flags...>
|
||||
|
||||
--benchmark: Run benchmark comparisons against last benchmark'd commit
|
||||
--root: Run tests that require root priviledges
|
||||
--gen: Generate code for MACs/ports by pulling down external data
|
||||
|
||||
Note, some 'git commit' flags are necessary, if all else fails, pass in -a
|
||||
EOF
|
||||
exit 1
|
||||
}
|
||||
|
||||
BENCH=""
|
||||
GEN=""
|
||||
ROOT=""
|
||||
while [ ! -z "$1" ]; do
|
||||
case "$1" in
|
||||
"--benchmark")
|
||||
BENCH="$2"
|
||||
shift
|
||||
shift
|
||||
;;
|
||||
"--gen")
|
||||
GEN="yes"
|
||||
shift
|
||||
;;
|
||||
"--root")
|
||||
ROOT="yes"
|
||||
shift
|
||||
;;
|
||||
"--help")
|
||||
Usage
|
||||
;;
|
||||
"-h")
|
||||
Usage
|
||||
;;
|
||||
"help")
|
||||
Usage
|
||||
;;
|
||||
*)
|
||||
break
|
||||
;;
|
||||
esac
|
||||
done
|
||||
|
||||
function Root {
|
||||
if [ ! -z "$ROOT" ]; then
|
||||
local exec="$1"
|
||||
# Some folks (like me) keep source code in places inaccessible by root (like
|
||||
# NFS), so to make sure things run smoothly we copy them to a /tmp location.
|
||||
local tmpfile="$(mktemp -t gopacket_XXXXXXXX)"
|
||||
echo "Running root test executable $exec as $tmpfile"
|
||||
cp "$exec" "$tmpfile"
|
||||
chmod a+x "$tmpfile"
|
||||
shift
|
||||
sudo "$tmpfile" "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
if [ "$#" -eq "0" ]; then
|
||||
Usage
|
||||
fi
|
||||
|
||||
cd $(dirname $0)
|
||||
|
||||
# Check for copyright notices.
|
||||
for filename in $(find ./ -type f -name '*.go'); do
|
||||
if ! head -n 1 "$filename" | grep -q Copyright; then
|
||||
echo "File '$filename' may not have copyright notice"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
|
||||
set -e
|
||||
set -x
|
||||
|
||||
if [ ! -z "$ROOT" ]; then
|
||||
echo "Running SUDO to get root priviledges for root tests"
|
||||
sudo echo "have root"
|
||||
fi
|
||||
|
||||
if [ ! -z "$GEN" ]; then
|
||||
pushd macs
|
||||
go run gen.go | gofmt > valid_mac_prefixes.go
|
||||
popd
|
||||
pushd layers
|
||||
go run gen.go | gofmt > iana_ports.go
|
||||
popd
|
||||
fi
|
||||
|
||||
# Make sure everything is formatted, compiles, and tests pass.
|
||||
go fmt ./...
|
||||
go test -i ./... 2>/dev/null >/dev/null || true
|
||||
go test
|
||||
go build
|
||||
pushd examples/bytediff
|
||||
go build
|
||||
popd
|
||||
if [ -f /usr/include/pcap.h ]; then
|
||||
pushd pcap
|
||||
go test ./...
|
||||
go build ./...
|
||||
go build pcap_tester.go
|
||||
Root pcap_tester --mode=basic
|
||||
Root pcap_tester --mode=filtered
|
||||
Root pcap_tester --mode=timestamp || echo "You might not support timestamp sources"
|
||||
popd
|
||||
pushd examples/pcapdump
|
||||
go build
|
||||
popd
|
||||
pushd examples/arpscan
|
||||
go build
|
||||
popd
|
||||
pushd examples/bidirectional
|
||||
go build
|
||||
popd
|
||||
pushd examples/synscan
|
||||
go build
|
||||
popd
|
||||
pushd examples/httpassembly
|
||||
go build
|
||||
popd
|
||||
pushd examples/statsassembly
|
||||
go build
|
||||
popd
|
||||
fi
|
||||
pushd macs
|
||||
go test ./...
|
||||
gofmt -w gen.go
|
||||
go build gen.go
|
||||
popd
|
||||
pushd tcpassembly
|
||||
go test ./...
|
||||
popd
|
||||
pushd reassembly
|
||||
go test ./...
|
||||
popd
|
||||
pushd layers
|
||||
gofmt -w gen.go
|
||||
go build gen.go
|
||||
go test ./...
|
||||
popd
|
||||
pushd pcapgo
|
||||
go test ./...
|
||||
go build ./...
|
||||
popd
|
||||
if [ -f /usr/include/linux/if_packet.h ]; then
|
||||
if grep -q TPACKET_V3 /usr/include/linux/if_packet.h; then
|
||||
pushd afpacket
|
||||
go build ./...
|
||||
go test ./...
|
||||
popd
|
||||
fi
|
||||
fi
|
||||
if [ -f /usr/include/pfring.h ]; then
|
||||
pushd pfring
|
||||
go test ./...
|
||||
go build ./...
|
||||
popd
|
||||
pushd examples/pfdump
|
||||
go build
|
||||
popd
|
||||
fi
|
||||
|
||||
for travis_script in `ls .travis.*.sh`; do
|
||||
./$travis_script
|
||||
done
|
||||
|
||||
# Run our initial commit
|
||||
git commit "$@"
|
||||
|
||||
if [ -z "$BENCH" ]; then
|
||||
set +x
|
||||
echo "We're not benchmarking and we've committed... we're done!"
|
||||
exit
|
||||
fi
|
||||
|
||||
### If we get here, we want to run benchmarks from current commit, and compare
|
||||
### then to benchmarks from the last --benchmark commit.
|
||||
|
||||
# Get our current branch.
|
||||
BRANCH="$(git branch | grep '^*' | awk '{print $2}')"
|
||||
|
||||
# File we're going to build our commit description in.
|
||||
COMMIT_FILE="$(mktemp /tmp/tmp.XXXXXXXX)"
|
||||
|
||||
# Add the word "BENCH" to the start of the git commit.
|
||||
echo -n "BENCH " > $COMMIT_FILE
|
||||
|
||||
# Get the current description... there must be an easier way.
|
||||
git log -n 1 | grep '^ ' | sed 's/^ //' >> $COMMIT_FILE
|
||||
|
||||
# Get the commit sha for the last benchmark commit
|
||||
PREV=$(git log -n 1 --grep='BENCHMARK_MARKER_DO_NOT_CHANGE' | head -n 1 | awk '{print $2}')
|
||||
|
||||
## Run current benchmarks
|
||||
|
||||
cat >> $COMMIT_FILE <<EOF
|
||||
|
||||
|
||||
----------------------------------------------------------
|
||||
BENCHMARK_MARKER_DO_NOT_CHANGE
|
||||
----------------------------------------------------------
|
||||
|
||||
Go version $(go version)
|
||||
|
||||
|
||||
TEST BENCHMARKS "$BENCH"
|
||||
EOF
|
||||
# go seems to have trouble with 'go test --bench=. ./...'
|
||||
go test --test.bench="$BENCH" 2>&1 | tee -a $COMMIT_FILE
|
||||
pushd layers
|
||||
go test --test.bench="$BENCH" 2>&1 | tee -a $COMMIT_FILE
|
||||
popd
|
||||
cat >> $COMMIT_FILE <<EOF
|
||||
|
||||
|
||||
PCAP BENCHMARK
|
||||
EOF
|
||||
if [ "$BENCH" -eq ".*" ]; then
|
||||
go run pcap/gopacket_benchmark/*.go 2>&1 | tee -a $COMMIT_FILE
|
||||
fi
|
||||
|
||||
|
||||
|
||||
## Reset to last benchmark commit, run benchmarks
|
||||
|
||||
git checkout $PREV
|
||||
|
||||
cat >> $COMMIT_FILE <<EOF
|
||||
----------------------------------------------------------
|
||||
BENCHMARKING AGAINST COMMIT $PREV
|
||||
----------------------------------------------------------
|
||||
|
||||
|
||||
OLD TEST BENCHMARKS
|
||||
EOF
|
||||
# go seems to have trouble with 'go test --bench=. ./...'
|
||||
go test --test.bench="$BENCH" 2>&1 | tee -a $COMMIT_FILE
|
||||
pushd layers
|
||||
go test --test.bench="$BENCH" 2>&1 | tee -a $COMMIT_FILE
|
||||
popd
|
||||
cat >> $COMMIT_FILE <<EOF
|
||||
|
||||
|
||||
OLD PCAP BENCHMARK
|
||||
EOF
|
||||
if [ "$BENCH" -eq ".*" ]; then
|
||||
go run pcap/gopacket_benchmark/*.go 2>&1 | tee -a $COMMIT_FILE
|
||||
fi
|
||||
|
||||
|
||||
|
||||
## Reset back to the most recent commit, edit the commit message by appending
|
||||
## benchmark results.
|
||||
git checkout $BRANCH
|
||||
git commit --amend -F $COMMIT_FILE
|
||||
@ -0,0 +1,107 @@
|
||||
// Copyright 2012 Google, 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 gopacket
|
||||
|
||||
// LayerClass is a set of LayerTypes, used for grabbing one of a number of
|
||||
// different types from a packet.
|
||||
type LayerClass interface {
|
||||
// Contains returns true if the given layer type should be considered part
|
||||
// of this layer class.
|
||||
Contains(LayerType) bool
|
||||
// LayerTypes returns the set of all layer types in this layer class.
|
||||
// Note that this may not be a fast operation on all LayerClass
|
||||
// implementations.
|
||||
LayerTypes() []LayerType
|
||||
}
|
||||
|
||||
// Contains implements LayerClass.
|
||||
func (l LayerType) Contains(a LayerType) bool {
|
||||
return l == a
|
||||
}
|
||||
|
||||
// LayerTypes implements LayerClass.
|
||||
func (l LayerType) LayerTypes() []LayerType {
|
||||
return []LayerType{l}
|
||||
}
|
||||
|
||||
// LayerClassSlice implements a LayerClass with a slice.
|
||||
type LayerClassSlice []bool
|
||||
|
||||
// Contains returns true if the given layer type should be considered part
|
||||
// of this layer class.
|
||||
func (s LayerClassSlice) Contains(t LayerType) bool {
|
||||
return int(t) < len(s) && s[t]
|
||||
}
|
||||
|
||||
// LayerTypes returns all layer types in this LayerClassSlice.
|
||||
// Because of LayerClassSlice's implementation, this could be quite slow.
|
||||
func (s LayerClassSlice) LayerTypes() (all []LayerType) {
|
||||
for i := 0; i < len(s); i++ {
|
||||
if s[i] {
|
||||
all = append(all, LayerType(i))
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// NewLayerClassSlice creates a new LayerClassSlice by creating a slice of
|
||||
// size max(types) and setting slice[t] to true for each type t. Note, if
|
||||
// you implement your own LayerType and give it a high value, this WILL create
|
||||
// a very large slice.
|
||||
func NewLayerClassSlice(types []LayerType) LayerClassSlice {
|
||||
var max LayerType
|
||||
for _, typ := range types {
|
||||
if typ > max {
|
||||
max = typ
|
||||
}
|
||||
}
|
||||
t := make([]bool, int(max+1))
|
||||
for _, typ := range types {
|
||||
t[typ] = true
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
// LayerClassMap implements a LayerClass with a map.
|
||||
type LayerClassMap map[LayerType]bool
|
||||
|
||||
// Contains returns true if the given layer type should be considered part
|
||||
// of this layer class.
|
||||
func (m LayerClassMap) Contains(t LayerType) bool {
|
||||
return m[t]
|
||||
}
|
||||
|
||||
// LayerTypes returns all layer types in this LayerClassMap.
|
||||
func (m LayerClassMap) LayerTypes() (all []LayerType) {
|
||||
for t := range m {
|
||||
all = append(all, t)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// NewLayerClassMap creates a LayerClassMap and sets map[t] to true for each
|
||||
// type in types.
|
||||
func NewLayerClassMap(types []LayerType) LayerClassMap {
|
||||
m := LayerClassMap{}
|
||||
for _, typ := range types {
|
||||
m[typ] = true
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// NewLayerClass creates a LayerClass, attempting to be smart about which type
|
||||
// it creates based on which types are passed in.
|
||||
func NewLayerClass(types []LayerType) LayerClass {
|
||||
for _, typ := range types {
|
||||
if typ > maxLayerType {
|
||||
// NewLayerClassSlice could create a very large object, so instead create
|
||||
// a map.
|
||||
return NewLayerClassMap(types)
|
||||
}
|
||||
}
|
||||
return NewLayerClassSlice(types)
|
||||
}
|
||||
@ -0,0 +1,40 @@
|
||||
arp.go
|
||||
base.go
|
||||
base_test.go
|
||||
cdp.go
|
||||
ctp.go
|
||||
decode_test.go
|
||||
dhcp_test.go
|
||||
dhcpv4.go
|
||||
dns.go
|
||||
dns_test.go
|
||||
doc.go
|
||||
dot11_test.go
|
||||
dot1q.go
|
||||
dot1q_test.go
|
||||
eapol.go
|
||||
etherip.go
|
||||
fddi.go
|
||||
gen.go
|
||||
gre.go
|
||||
gre_test.go
|
||||
iana_ports.go
|
||||
icmp6_test.go
|
||||
igmp_test.go
|
||||
ip4_test.go
|
||||
ipsec.go
|
||||
ipsec_test.go
|
||||
loopback.go
|
||||
mpls_test.go
|
||||
ntp_test.go
|
||||
ports.go
|
||||
ppp.go
|
||||
prism_test.go
|
||||
radiotap_test.go
|
||||
sflow_test.go
|
||||
tcp_test.go
|
||||
udp_test.go
|
||||
usb_test.go
|
||||
vrrp_test.go
|
||||
vxlan.go
|
||||
vxlan_test.go
|
||||
@ -0,0 +1,109 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// Potential values for ARP.Operation.
|
||||
const (
|
||||
ARPRequest = 1
|
||||
ARPReply = 2
|
||||
)
|
||||
|
||||
// ARP is a ARP packet header.
|
||||
type ARP struct {
|
||||
BaseLayer
|
||||
AddrType LinkType
|
||||
Protocol EthernetType
|
||||
HwAddressSize uint8
|
||||
ProtAddressSize uint8
|
||||
Operation uint16
|
||||
SourceHwAddress []byte
|
||||
SourceProtAddress []byte
|
||||
DstHwAddress []byte
|
||||
DstProtAddress []byte
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeARP
|
||||
func (arp *ARP) LayerType() gopacket.LayerType { return LayerTypeARP }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (arp *ARP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
arp.AddrType = LinkType(binary.BigEndian.Uint16(data[0:2]))
|
||||
arp.Protocol = EthernetType(binary.BigEndian.Uint16(data[2:4]))
|
||||
arp.HwAddressSize = data[4]
|
||||
arp.ProtAddressSize = data[5]
|
||||
arp.Operation = binary.BigEndian.Uint16(data[6:8])
|
||||
arp.SourceHwAddress = data[8 : 8+arp.HwAddressSize]
|
||||
arp.SourceProtAddress = data[8+arp.HwAddressSize : 8+arp.HwAddressSize+arp.ProtAddressSize]
|
||||
arp.DstHwAddress = data[8+arp.HwAddressSize+arp.ProtAddressSize : 8+2*arp.HwAddressSize+arp.ProtAddressSize]
|
||||
arp.DstProtAddress = data[8+2*arp.HwAddressSize+arp.ProtAddressSize : 8+2*arp.HwAddressSize+2*arp.ProtAddressSize]
|
||||
|
||||
arpLength := 8 + 2*arp.HwAddressSize + 2*arp.ProtAddressSize
|
||||
arp.Contents = data[:arpLength]
|
||||
arp.Payload = data[arpLength:]
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (arp *ARP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
size := 8 + len(arp.SourceHwAddress) + len(arp.SourceProtAddress) + len(arp.DstHwAddress) + len(arp.DstProtAddress)
|
||||
bytes, err := b.PrependBytes(size)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if opts.FixLengths {
|
||||
if len(arp.SourceHwAddress) != len(arp.DstHwAddress) {
|
||||
return errors.New("mismatched hardware address sizes")
|
||||
}
|
||||
arp.HwAddressSize = uint8(len(arp.SourceHwAddress))
|
||||
if len(arp.SourceProtAddress) != len(arp.DstProtAddress) {
|
||||
return errors.New("mismatched prot address sizes")
|
||||
}
|
||||
arp.ProtAddressSize = uint8(len(arp.SourceProtAddress))
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes, uint16(arp.AddrType))
|
||||
binary.BigEndian.PutUint16(bytes[2:], uint16(arp.Protocol))
|
||||
bytes[4] = arp.HwAddressSize
|
||||
bytes[5] = arp.ProtAddressSize
|
||||
binary.BigEndian.PutUint16(bytes[6:], arp.Operation)
|
||||
start := 8
|
||||
for _, addr := range [][]byte{
|
||||
arp.SourceHwAddress,
|
||||
arp.SourceProtAddress,
|
||||
arp.DstHwAddress,
|
||||
arp.DstProtAddress,
|
||||
} {
|
||||
copy(bytes[start:], addr)
|
||||
start += len(addr)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (arp *ARP) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeARP
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (arp *ARP) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
func decodeARP(data []byte, p gopacket.PacketBuilder) error {
|
||||
|
||||
arp := &ARP{}
|
||||
return decodingLayerDecoder(arp, data, p)
|
||||
}
|
||||
@ -0,0 +1,52 @@
|
||||
// Copyright 2012 Google, 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"
|
||||
)
|
||||
|
||||
// BaseLayer is a convenience struct which implements the LayerData and
|
||||
// LayerPayload functions of the Layer interface.
|
||||
type BaseLayer struct {
|
||||
// Contents is the set of bytes that make up this layer. IE: for an
|
||||
// Ethernet packet, this would be the set of bytes making up the
|
||||
// Ethernet frame.
|
||||
Contents []byte
|
||||
// Payload is the set of bytes contained by (but not part of) this
|
||||
// Layer. Again, to take Ethernet as an example, this would be the
|
||||
// set of bytes encapsulated by the Ethernet protocol.
|
||||
Payload []byte
|
||||
}
|
||||
|
||||
// LayerContents returns the bytes of the packet layer.
|
||||
func (b *BaseLayer) LayerContents() []byte { return b.Contents }
|
||||
|
||||
// LayerPayload returns the bytes contained within the packet layer.
|
||||
func (b *BaseLayer) LayerPayload() []byte { return b.Payload }
|
||||
|
||||
type layerDecodingLayer interface {
|
||||
gopacket.Layer
|
||||
DecodeFromBytes([]byte, gopacket.DecodeFeedback) error
|
||||
NextLayerType() gopacket.LayerType
|
||||
}
|
||||
|
||||
func decodingLayerDecoder(d layerDecodingLayer, data []byte, p gopacket.PacketBuilder) error {
|
||||
err := d.DecodeFromBytes(data, p)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p.AddLayer(d)
|
||||
next := d.NextLayerType()
|
||||
if next == gopacket.LayerTypeZero {
|
||||
return nil
|
||||
}
|
||||
return p.NextDecoder(next)
|
||||
}
|
||||
|
||||
// hacky way to zero out memory... there must be a better way?
|
||||
var lotsOfZeros [1024]byte
|
||||
@ -0,0 +1,651 @@
|
||||
// Copyright 2012 Google, 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.
|
||||
|
||||
// Enum types courtesy of...
|
||||
// http://search.cpan.org/~mchapman/Net-CDP-0.09/lib/Net/CDP.pm
|
||||
// https://code.google.com/p/ladvd/
|
||||
// http://anonsvn.wireshark.org/viewvc/releases/wireshark-1.8.6/epan/dissectors/packet-cdp.c
|
||||
|
||||
package layers
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"net"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// CDPTLVType is the type of each TLV value in a CiscoDiscovery packet.
|
||||
type CDPTLVType uint16
|
||||
|
||||
// CDPTLVType values.
|
||||
const (
|
||||
CDPTLVDevID CDPTLVType = 0x0001
|
||||
CDPTLVAddress CDPTLVType = 0x0002
|
||||
CDPTLVPortID CDPTLVType = 0x0003
|
||||
CDPTLVCapabilities CDPTLVType = 0x0004
|
||||
CDPTLVVersion CDPTLVType = 0x0005
|
||||
CDPTLVPlatform CDPTLVType = 0x0006
|
||||
CDPTLVIPPrefix CDPTLVType = 0x0007
|
||||
CDPTLVHello CDPTLVType = 0x0008
|
||||
CDPTLVVTPDomain CDPTLVType = 0x0009
|
||||
CDPTLVNativeVLAN CDPTLVType = 0x000a
|
||||
CDPTLVFullDuplex CDPTLVType = 0x000b
|
||||
CDPTLVVLANReply CDPTLVType = 0x000e
|
||||
CDPTLVVLANQuery CDPTLVType = 0x000f
|
||||
CDPTLVPower CDPTLVType = 0x0010
|
||||
CDPTLVMTU CDPTLVType = 0x0011
|
||||
CDPTLVExtendedTrust CDPTLVType = 0x0012
|
||||
CDPTLVUntrustedCOS CDPTLVType = 0x0013
|
||||
CDPTLVSysName CDPTLVType = 0x0014
|
||||
CDPTLVSysOID CDPTLVType = 0x0015
|
||||
CDPTLVMgmtAddresses CDPTLVType = 0x0016
|
||||
CDPTLVLocation CDPTLVType = 0x0017
|
||||
CDPTLVExternalPortID CDPTLVType = 0x0018
|
||||
CDPTLVPowerRequested CDPTLVType = 0x0019
|
||||
CDPTLVPowerAvailable CDPTLVType = 0x001a
|
||||
CDPTLVPortUnidirectional CDPTLVType = 0x001b
|
||||
CDPTLVEnergyWise CDPTLVType = 0x001d
|
||||
CDPTLVSparePairPOE CDPTLVType = 0x001f
|
||||
)
|
||||
|
||||
// CiscoDiscoveryValue is a TLV value inside a CiscoDiscovery packet layer.
|
||||
type CiscoDiscoveryValue struct {
|
||||
Type CDPTLVType
|
||||
Length uint16
|
||||
Value []byte
|
||||
}
|
||||
|
||||
// CiscoDiscovery is a packet layer containing the Cisco Discovery Protocol.
|
||||
// See http://www.cisco.com/univercd/cc/td/doc/product/lan/trsrb/frames.htm#31885
|
||||
type CiscoDiscovery struct {
|
||||
BaseLayer
|
||||
Version byte
|
||||
TTL byte
|
||||
Checksum uint16
|
||||
Values []CiscoDiscoveryValue
|
||||
}
|
||||
|
||||
// CDPCapability is the set of capabilities advertised by a CDP device.
|
||||
type CDPCapability uint32
|
||||
|
||||
// CDPCapability values.
|
||||
const (
|
||||
CDPCapMaskRouter CDPCapability = 0x0001
|
||||
CDPCapMaskTBBridge CDPCapability = 0x0002
|
||||
CDPCapMaskSPBridge CDPCapability = 0x0004
|
||||
CDPCapMaskSwitch CDPCapability = 0x0008
|
||||
CDPCapMaskHost CDPCapability = 0x0010
|
||||
CDPCapMaskIGMPFilter CDPCapability = 0x0020
|
||||
CDPCapMaskRepeater CDPCapability = 0x0040
|
||||
CDPCapMaskPhone CDPCapability = 0x0080
|
||||
CDPCapMaskRemote CDPCapability = 0x0100
|
||||
)
|
||||
|
||||
// CDPCapabilities represents the capabilities of a device
|
||||
type CDPCapabilities struct {
|
||||
L3Router bool
|
||||
TBBridge bool
|
||||
SPBridge bool
|
||||
L2Switch bool
|
||||
IsHost bool
|
||||
IGMPFilter bool
|
||||
L1Repeater bool
|
||||
IsPhone bool
|
||||
RemotelyManaged bool
|
||||
}
|
||||
|
||||
// CDP Power-over-Ethernet values.
|
||||
const (
|
||||
CDPPoEFourWire byte = 0x01
|
||||
CDPPoEPDArch byte = 0x02
|
||||
CDPPoEPDRequest byte = 0x04
|
||||
CDPPoEPSE byte = 0x08
|
||||
)
|
||||
|
||||
// CDPSparePairPoE provides information on PoE.
|
||||
type CDPSparePairPoE struct {
|
||||
PSEFourWire bool // Supported / Not supported
|
||||
PDArchShared bool // Shared / Independent
|
||||
PDRequestOn bool // On / Off
|
||||
PSEOn bool // On / Off
|
||||
}
|
||||
|
||||
// CDPVLANDialogue encapsulates a VLAN Query/Reply
|
||||
type CDPVLANDialogue struct {
|
||||
ID uint8
|
||||
VLAN uint16
|
||||
}
|
||||
|
||||
// CDPPowerDialogue encapsulates a Power Query/Reply
|
||||
type CDPPowerDialogue struct {
|
||||
ID uint16
|
||||
MgmtID uint16
|
||||
Values []uint32
|
||||
}
|
||||
|
||||
// CDPLocation provides location information for a CDP device.
|
||||
type CDPLocation struct {
|
||||
Type uint8 // Undocumented
|
||||
Location string
|
||||
}
|
||||
|
||||
// CDPHello is a Cisco Hello message (undocumented, hence the "Unknown" fields)
|
||||
type CDPHello struct {
|
||||
OUI []byte
|
||||
ProtocolID uint16
|
||||
ClusterMaster net.IP
|
||||
Unknown1 net.IP
|
||||
Version byte
|
||||
SubVersion byte
|
||||
Status byte
|
||||
Unknown2 byte
|
||||
ClusterCommander net.HardwareAddr
|
||||
SwitchMAC net.HardwareAddr
|
||||
Unknown3 byte
|
||||
ManagementVLAN uint16
|
||||
}
|
||||
|
||||
// CDPEnergyWiseSubtype is used within CDP to define TLV values.
|
||||
type CDPEnergyWiseSubtype uint32
|
||||
|
||||
// CDPEnergyWiseSubtype values.
|
||||
const (
|
||||
CDPEnergyWiseRole CDPEnergyWiseSubtype = 0x00000007
|
||||
CDPEnergyWiseDomain CDPEnergyWiseSubtype = 0x00000008
|
||||
CDPEnergyWiseName CDPEnergyWiseSubtype = 0x00000009
|
||||
CDPEnergyWiseReplyTo CDPEnergyWiseSubtype = 0x00000017
|
||||
)
|
||||
|
||||
// CDPEnergyWise is used by CDP to monitor and control power usage.
|
||||
type CDPEnergyWise struct {
|
||||
EncryptedData []byte
|
||||
Unknown1 uint32
|
||||
SequenceNumber uint32
|
||||
ModelNumber string
|
||||
Unknown2 uint16
|
||||
HardwareID string
|
||||
SerialNum string
|
||||
Unknown3 []byte
|
||||
Role string
|
||||
Domain string
|
||||
Name string
|
||||
ReplyUnknown1 []byte
|
||||
ReplyPort []byte
|
||||
ReplyAddress []byte
|
||||
ReplyUnknown2 []byte
|
||||
ReplyUnknown3 []byte
|
||||
}
|
||||
|
||||
// CiscoDiscoveryInfo represents the decoded details for a set of CiscoDiscoveryValues
|
||||
type CiscoDiscoveryInfo struct {
|
||||
BaseLayer
|
||||
CDPHello
|
||||
DeviceID string
|
||||
Addresses []net.IP
|
||||
PortID string
|
||||
Capabilities CDPCapabilities
|
||||
Version string
|
||||
Platform string
|
||||
IPPrefixes []net.IPNet
|
||||
VTPDomain string
|
||||
NativeVLAN uint16
|
||||
FullDuplex bool
|
||||
VLANReply CDPVLANDialogue
|
||||
VLANQuery CDPVLANDialogue
|
||||
PowerConsumption uint16
|
||||
MTU uint32
|
||||
ExtendedTrust uint8
|
||||
UntrustedCOS uint8
|
||||
SysName string
|
||||
SysOID string
|
||||
MgmtAddresses []net.IP
|
||||
Location CDPLocation
|
||||
PowerRequest CDPPowerDialogue
|
||||
PowerAvailable CDPPowerDialogue
|
||||
SparePairPoe CDPSparePairPoE
|
||||
EnergyWise CDPEnergyWise
|
||||
Unknown []CiscoDiscoveryValue
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeCiscoDiscovery.
|
||||
func (c *CiscoDiscovery) LayerType() gopacket.LayerType {
|
||||
return LayerTypeCiscoDiscovery
|
||||
}
|
||||
|
||||
func decodeCiscoDiscovery(data []byte, p gopacket.PacketBuilder) error {
|
||||
c := &CiscoDiscovery{
|
||||
Version: data[0],
|
||||
TTL: data[1],
|
||||
Checksum: binary.BigEndian.Uint16(data[2:4]),
|
||||
}
|
||||
if c.Version != 1 && c.Version != 2 {
|
||||
return fmt.Errorf("Invalid CiscoDiscovery version number %d", c.Version)
|
||||
}
|
||||
var err error
|
||||
c.Values, err = decodeCiscoDiscoveryTLVs(data[4:])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
c.Contents = data[0:4]
|
||||
c.Payload = data[4:]
|
||||
p.AddLayer(c)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeCiscoDiscoveryInfo))
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeCiscoDiscoveryInfo.
|
||||
func (c *CiscoDiscoveryInfo) LayerType() gopacket.LayerType {
|
||||
return LayerTypeCiscoDiscoveryInfo
|
||||
}
|
||||
|
||||
func decodeCiscoDiscoveryTLVs(data []byte) (values []CiscoDiscoveryValue, err error) {
|
||||
for len(data) > 0 {
|
||||
val := CiscoDiscoveryValue{
|
||||
Type: CDPTLVType(binary.BigEndian.Uint16(data[:2])),
|
||||
Length: binary.BigEndian.Uint16(data[2:4]),
|
||||
}
|
||||
if val.Length < 4 {
|
||||
err = fmt.Errorf("Invalid CiscoDiscovery value length %d", val.Length)
|
||||
break
|
||||
}
|
||||
val.Value = data[4:val.Length]
|
||||
values = append(values, val)
|
||||
data = data[val.Length:]
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func decodeCiscoDiscoveryInfo(data []byte, p gopacket.PacketBuilder) error {
|
||||
var err error
|
||||
info := &CiscoDiscoveryInfo{BaseLayer: BaseLayer{Contents: data}}
|
||||
p.AddLayer(info)
|
||||
values, err := decodeCiscoDiscoveryTLVs(data)
|
||||
if err != nil { // Unlikely, as parent decode will fail, but better safe...
|
||||
return err
|
||||
}
|
||||
for _, val := range values {
|
||||
switch val.Type {
|
||||
case CDPTLVDevID:
|
||||
info.DeviceID = string(val.Value)
|
||||
case CDPTLVAddress:
|
||||
if err = checkCDPTLVLen(val, 4); err != nil {
|
||||
return err
|
||||
}
|
||||
info.Addresses, err = decodeAddresses(val.Value)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case CDPTLVPortID:
|
||||
info.PortID = string(val.Value)
|
||||
case CDPTLVCapabilities:
|
||||
if err = checkCDPTLVLen(val, 4); err != nil {
|
||||
return err
|
||||
}
|
||||
val := CDPCapability(binary.BigEndian.Uint32(val.Value[0:4]))
|
||||
info.Capabilities.L3Router = (val&CDPCapMaskRouter > 0)
|
||||
info.Capabilities.TBBridge = (val&CDPCapMaskTBBridge > 0)
|
||||
info.Capabilities.SPBridge = (val&CDPCapMaskSPBridge > 0)
|
||||
info.Capabilities.L2Switch = (val&CDPCapMaskSwitch > 0)
|
||||
info.Capabilities.IsHost = (val&CDPCapMaskHost > 0)
|
||||
info.Capabilities.IGMPFilter = (val&CDPCapMaskIGMPFilter > 0)
|
||||
info.Capabilities.L1Repeater = (val&CDPCapMaskRepeater > 0)
|
||||
info.Capabilities.IsPhone = (val&CDPCapMaskPhone > 0)
|
||||
info.Capabilities.RemotelyManaged = (val&CDPCapMaskRemote > 0)
|
||||
case CDPTLVVersion:
|
||||
info.Version = string(val.Value)
|
||||
case CDPTLVPlatform:
|
||||
info.Platform = string(val.Value)
|
||||
case CDPTLVIPPrefix:
|
||||
v := val.Value
|
||||
l := len(v)
|
||||
if l%5 == 0 && l >= 5 {
|
||||
for len(v) > 0 {
|
||||
_, ipnet, _ := net.ParseCIDR(fmt.Sprintf("%d.%d.%d.%d/%d", v[0], v[1], v[2], v[3], v[4]))
|
||||
info.IPPrefixes = append(info.IPPrefixes, *ipnet)
|
||||
v = v[5:]
|
||||
}
|
||||
} else {
|
||||
return fmt.Errorf("Invalid TLV %v length %d", val.Type, len(val.Value))
|
||||
}
|
||||
case CDPTLVHello:
|
||||
if err = checkCDPTLVLen(val, 32); err != nil {
|
||||
return err
|
||||
}
|
||||
v := val.Value
|
||||
info.CDPHello.OUI = v[0:3]
|
||||
info.CDPHello.ProtocolID = binary.BigEndian.Uint16(v[3:5])
|
||||
info.CDPHello.ClusterMaster = v[5:9]
|
||||
info.CDPHello.Unknown1 = v[9:13]
|
||||
info.CDPHello.Version = v[13]
|
||||
info.CDPHello.SubVersion = v[14]
|
||||
info.CDPHello.Status = v[15]
|
||||
info.CDPHello.Unknown2 = v[16]
|
||||
info.CDPHello.ClusterCommander = v[17:23]
|
||||
info.CDPHello.SwitchMAC = v[23:29]
|
||||
info.CDPHello.Unknown3 = v[29]
|
||||
info.CDPHello.ManagementVLAN = binary.BigEndian.Uint16(v[30:32])
|
||||
case CDPTLVVTPDomain:
|
||||
info.VTPDomain = string(val.Value)
|
||||
case CDPTLVNativeVLAN:
|
||||
if err = checkCDPTLVLen(val, 2); err != nil {
|
||||
return err
|
||||
}
|
||||
info.NativeVLAN = binary.BigEndian.Uint16(val.Value[0:2])
|
||||
case CDPTLVFullDuplex:
|
||||
if err = checkCDPTLVLen(val, 1); err != nil {
|
||||
return err
|
||||
}
|
||||
info.FullDuplex = (val.Value[0] == 1)
|
||||
case CDPTLVVLANReply:
|
||||
if err = checkCDPTLVLen(val, 3); err != nil {
|
||||
return err
|
||||
}
|
||||
info.VLANReply.ID = uint8(val.Value[0])
|
||||
info.VLANReply.VLAN = binary.BigEndian.Uint16(val.Value[1:3])
|
||||
case CDPTLVVLANQuery:
|
||||
if err = checkCDPTLVLen(val, 3); err != nil {
|
||||
return err
|
||||
}
|
||||
info.VLANQuery.ID = uint8(val.Value[0])
|
||||
info.VLANQuery.VLAN = binary.BigEndian.Uint16(val.Value[1:3])
|
||||
case CDPTLVPower:
|
||||
if err = checkCDPTLVLen(val, 2); err != nil {
|
||||
return err
|
||||
}
|
||||
info.PowerConsumption = binary.BigEndian.Uint16(val.Value[0:2])
|
||||
case CDPTLVMTU:
|
||||
if err = checkCDPTLVLen(val, 4); err != nil {
|
||||
return err
|
||||
}
|
||||
info.MTU = binary.BigEndian.Uint32(val.Value[0:4])
|
||||
case CDPTLVExtendedTrust:
|
||||
if err = checkCDPTLVLen(val, 1); err != nil {
|
||||
return err
|
||||
}
|
||||
info.ExtendedTrust = uint8(val.Value[0])
|
||||
case CDPTLVUntrustedCOS:
|
||||
if err = checkCDPTLVLen(val, 1); err != nil {
|
||||
return err
|
||||
}
|
||||
info.UntrustedCOS = uint8(val.Value[0])
|
||||
case CDPTLVSysName:
|
||||
info.SysName = string(val.Value)
|
||||
case CDPTLVSysOID:
|
||||
info.SysOID = string(val.Value)
|
||||
case CDPTLVMgmtAddresses:
|
||||
if err = checkCDPTLVLen(val, 4); err != nil {
|
||||
return err
|
||||
}
|
||||
info.MgmtAddresses, err = decodeAddresses(val.Value)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
case CDPTLVLocation:
|
||||
if err = checkCDPTLVLen(val, 2); err != nil {
|
||||
return err
|
||||
}
|
||||
info.Location.Type = uint8(val.Value[0])
|
||||
info.Location.Location = string(val.Value[1:])
|
||||
|
||||
// case CDPTLVLExternalPortID:
|
||||
// Undocumented
|
||||
case CDPTLVPowerRequested:
|
||||
if err = checkCDPTLVLen(val, 4); err != nil {
|
||||
return err
|
||||
}
|
||||
info.PowerRequest.ID = binary.BigEndian.Uint16(val.Value[0:2])
|
||||
info.PowerRequest.MgmtID = binary.BigEndian.Uint16(val.Value[2:4])
|
||||
for n := 4; n < len(val.Value); n += 4 {
|
||||
info.PowerRequest.Values = append(info.PowerRequest.Values, binary.BigEndian.Uint32(val.Value[n:n+4]))
|
||||
}
|
||||
case CDPTLVPowerAvailable:
|
||||
if err = checkCDPTLVLen(val, 4); err != nil {
|
||||
return err
|
||||
}
|
||||
info.PowerAvailable.ID = binary.BigEndian.Uint16(val.Value[0:2])
|
||||
info.PowerAvailable.MgmtID = binary.BigEndian.Uint16(val.Value[2:4])
|
||||
for n := 4; n < len(val.Value); n += 4 {
|
||||
info.PowerAvailable.Values = append(info.PowerAvailable.Values, binary.BigEndian.Uint32(val.Value[n:n+4]))
|
||||
}
|
||||
// case CDPTLVPortUnidirectional
|
||||
// Undocumented
|
||||
case CDPTLVEnergyWise:
|
||||
if err = checkCDPTLVLen(val, 72); err != nil {
|
||||
return err
|
||||
}
|
||||
info.EnergyWise.EncryptedData = val.Value[0:20]
|
||||
info.EnergyWise.Unknown1 = binary.BigEndian.Uint32(val.Value[20:24])
|
||||
info.EnergyWise.SequenceNumber = binary.BigEndian.Uint32(val.Value[24:28])
|
||||
info.EnergyWise.ModelNumber = string(val.Value[28:44])
|
||||
info.EnergyWise.Unknown2 = binary.BigEndian.Uint16(val.Value[44:46])
|
||||
info.EnergyWise.HardwareID = string(val.Value[46:49])
|
||||
info.EnergyWise.SerialNum = string(val.Value[49:60])
|
||||
info.EnergyWise.Unknown3 = val.Value[60:68]
|
||||
tlvLen := binary.BigEndian.Uint16(val.Value[68:70])
|
||||
tlvNum := binary.BigEndian.Uint16(val.Value[70:72])
|
||||
data := val.Value[72:]
|
||||
if len(data) < int(tlvLen) {
|
||||
return fmt.Errorf("Invalid TLV length %d vs %d", tlvLen, len(data))
|
||||
}
|
||||
numSeen := 0
|
||||
for len(data) > 8 {
|
||||
numSeen++
|
||||
if numSeen > int(tlvNum) { // Too many TLV's ?
|
||||
return fmt.Errorf("Too many TLV's - wanted %d, saw %d", tlvNum, numSeen)
|
||||
}
|
||||
tType := CDPEnergyWiseSubtype(binary.BigEndian.Uint32(data[0:4]))
|
||||
tLen := int(binary.BigEndian.Uint32(data[4:8]))
|
||||
if tLen > len(data)-8 {
|
||||
return fmt.Errorf("Invalid TLV length %d vs %d", tLen, len(data)-8)
|
||||
}
|
||||
data = data[8:]
|
||||
switch tType {
|
||||
case CDPEnergyWiseRole:
|
||||
info.EnergyWise.Role = string(data[:])
|
||||
case CDPEnergyWiseDomain:
|
||||
info.EnergyWise.Domain = string(data[:])
|
||||
case CDPEnergyWiseName:
|
||||
info.EnergyWise.Name = string(data[:])
|
||||
case CDPEnergyWiseReplyTo:
|
||||
if len(data) >= 18 {
|
||||
info.EnergyWise.ReplyUnknown1 = data[0:2]
|
||||
info.EnergyWise.ReplyPort = data[2:4]
|
||||
info.EnergyWise.ReplyAddress = data[4:8]
|
||||
info.EnergyWise.ReplyUnknown2 = data[8:10]
|
||||
info.EnergyWise.ReplyUnknown3 = data[10:14]
|
||||
}
|
||||
}
|
||||
data = data[tLen:]
|
||||
}
|
||||
case CDPTLVSparePairPOE:
|
||||
if err = checkCDPTLVLen(val, 1); err != nil {
|
||||
return err
|
||||
}
|
||||
v := val.Value[0]
|
||||
info.SparePairPoe.PSEFourWire = (v&CDPPoEFourWire > 0)
|
||||
info.SparePairPoe.PDArchShared = (v&CDPPoEPDArch > 0)
|
||||
info.SparePairPoe.PDRequestOn = (v&CDPPoEPDRequest > 0)
|
||||
info.SparePairPoe.PSEOn = (v&CDPPoEPSE > 0)
|
||||
default:
|
||||
info.Unknown = append(info.Unknown, val)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CDP Protocol Types
|
||||
const (
|
||||
CDPProtocolTypeNLPID byte = 1
|
||||
CDPProtocolType802_2 byte = 2
|
||||
)
|
||||
|
||||
// CDPAddressType is used to define TLV values within CDP addresses.
|
||||
type CDPAddressType uint64
|
||||
|
||||
// CDP Address types.
|
||||
const (
|
||||
CDPAddressTypeCLNP CDPAddressType = 0x81
|
||||
CDPAddressTypeIPV4 CDPAddressType = 0xcc
|
||||
CDPAddressTypeIPV6 CDPAddressType = 0xaaaa030000000800
|
||||
CDPAddressTypeDECNET CDPAddressType = 0xaaaa030000006003
|
||||
CDPAddressTypeAPPLETALK CDPAddressType = 0xaaaa03000000809b
|
||||
CDPAddressTypeIPX CDPAddressType = 0xaaaa030000008137
|
||||
CDPAddressTypeVINES CDPAddressType = 0xaaaa0300000080c4
|
||||
CDPAddressTypeXNS CDPAddressType = 0xaaaa030000000600
|
||||
CDPAddressTypeAPOLLO CDPAddressType = 0xaaaa030000008019
|
||||
)
|
||||
|
||||
func decodeAddresses(v []byte) (addresses []net.IP, err error) {
|
||||
numaddr := int(binary.BigEndian.Uint32(v[0:4]))
|
||||
if numaddr < 1 {
|
||||
return nil, fmt.Errorf("Invalid Address TLV number %d", numaddr)
|
||||
}
|
||||
v = v[4:]
|
||||
if len(v) < numaddr*8 {
|
||||
return nil, fmt.Errorf("Invalid Address TLV length %d", len(v))
|
||||
}
|
||||
for i := 0; i < numaddr; i++ {
|
||||
prottype := v[0]
|
||||
if prottype != CDPProtocolTypeNLPID && prottype != CDPProtocolType802_2 { // invalid protocol type
|
||||
return nil, fmt.Errorf("Invalid Address Protocol %d", prottype)
|
||||
}
|
||||
protlen := int(v[1])
|
||||
if (prottype == CDPProtocolTypeNLPID && protlen != 1) ||
|
||||
(prottype == CDPProtocolType802_2 && protlen != 3 && protlen != 8) { // invalid length
|
||||
return nil, fmt.Errorf("Invalid Address Protocol length %d", protlen)
|
||||
}
|
||||
plen := make([]byte, 8)
|
||||
copy(plen[8-protlen:], v[2:2+protlen])
|
||||
protocol := CDPAddressType(binary.BigEndian.Uint64(plen))
|
||||
v = v[2+protlen:]
|
||||
addrlen := binary.BigEndian.Uint16(v[0:2])
|
||||
ab := v[2 : 2+addrlen]
|
||||
if protocol == CDPAddressTypeIPV4 && addrlen == 4 {
|
||||
addresses = append(addresses, net.IPv4(ab[0], ab[1], ab[2], ab[3]))
|
||||
} else if protocol == CDPAddressTypeIPV6 && addrlen == 16 {
|
||||
addresses = append(addresses, net.IP(ab))
|
||||
} else {
|
||||
// only handle IPV4 & IPV6 for now
|
||||
}
|
||||
v = v[2+addrlen:]
|
||||
if len(v) < 8 {
|
||||
break
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (t CDPTLVType) String() (s string) {
|
||||
switch t {
|
||||
case CDPTLVDevID:
|
||||
s = "Device ID"
|
||||
case CDPTLVAddress:
|
||||
s = "Addresses"
|
||||
case CDPTLVPortID:
|
||||
s = "Port ID"
|
||||
case CDPTLVCapabilities:
|
||||
s = "Capabilities"
|
||||
case CDPTLVVersion:
|
||||
s = "Software Version"
|
||||
case CDPTLVPlatform:
|
||||
s = "Platform"
|
||||
case CDPTLVIPPrefix:
|
||||
s = "IP Prefix"
|
||||
case CDPTLVHello:
|
||||
s = "Protocol Hello"
|
||||
case CDPTLVVTPDomain:
|
||||
s = "VTP Management Domain"
|
||||
case CDPTLVNativeVLAN:
|
||||
s = "Native VLAN"
|
||||
case CDPTLVFullDuplex:
|
||||
s = "Full Duplex"
|
||||
case CDPTLVVLANReply:
|
||||
s = "VoIP VLAN Reply"
|
||||
case CDPTLVVLANQuery:
|
||||
s = "VLANQuery"
|
||||
case CDPTLVPower:
|
||||
s = "Power consumption"
|
||||
case CDPTLVMTU:
|
||||
s = "MTU"
|
||||
case CDPTLVExtendedTrust:
|
||||
s = "Extended Trust Bitmap"
|
||||
case CDPTLVUntrustedCOS:
|
||||
s = "Untrusted Port CoS"
|
||||
case CDPTLVSysName:
|
||||
s = "System Name"
|
||||
case CDPTLVSysOID:
|
||||
s = "System OID"
|
||||
case CDPTLVMgmtAddresses:
|
||||
s = "Management Addresses"
|
||||
case CDPTLVLocation:
|
||||
s = "Location"
|
||||
case CDPTLVExternalPortID:
|
||||
s = "External Port ID"
|
||||
case CDPTLVPowerRequested:
|
||||
s = "Power Requested"
|
||||
case CDPTLVPowerAvailable:
|
||||
s = "Power Available"
|
||||
case CDPTLVPortUnidirectional:
|
||||
s = "Port Unidirectional"
|
||||
case CDPTLVEnergyWise:
|
||||
s = "Energy Wise"
|
||||
case CDPTLVSparePairPOE:
|
||||
s = "Spare Pair POE"
|
||||
default:
|
||||
s = "Unknown"
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (a CDPAddressType) String() (s string) {
|
||||
switch a {
|
||||
case CDPAddressTypeCLNP:
|
||||
s = "Connectionless Network Protocol"
|
||||
case CDPAddressTypeIPV4:
|
||||
s = "IPv4"
|
||||
case CDPAddressTypeIPV6:
|
||||
s = "IPv6"
|
||||
case CDPAddressTypeDECNET:
|
||||
s = "DECnet Phase IV"
|
||||
case CDPAddressTypeAPPLETALK:
|
||||
s = "Apple Talk"
|
||||
case CDPAddressTypeIPX:
|
||||
s = "Novell IPX"
|
||||
case CDPAddressTypeVINES:
|
||||
s = "Banyan VINES"
|
||||
case CDPAddressTypeXNS:
|
||||
s = "Xerox Network Systems"
|
||||
case CDPAddressTypeAPOLLO:
|
||||
s = "Apollo"
|
||||
default:
|
||||
s = "Unknown"
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (t CDPEnergyWiseSubtype) String() (s string) {
|
||||
switch t {
|
||||
case CDPEnergyWiseRole:
|
||||
s = "Role"
|
||||
case CDPEnergyWiseDomain:
|
||||
s = "Domain"
|
||||
case CDPEnergyWiseName:
|
||||
s = "Name"
|
||||
case CDPEnergyWiseReplyTo:
|
||||
s = "ReplyTo"
|
||||
default:
|
||||
s = "Unknown"
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func checkCDPTLVLen(v CiscoDiscoveryValue, l int) (err error) {
|
||||
if len(v.Value) < l {
|
||||
err = fmt.Errorf("Invalid TLV %v length %d", v.Type, len(v.Value))
|
||||
}
|
||||
return
|
||||
}
|
||||
@ -0,0 +1,109 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// EthernetCTPFunction is the function code used by the EthernetCTP protocol to identify each
|
||||
// EthernetCTP layer.
|
||||
type EthernetCTPFunction uint16
|
||||
|
||||
// EthernetCTPFunction values.
|
||||
const (
|
||||
EthernetCTPFunctionReply EthernetCTPFunction = 1
|
||||
EthernetCTPFunctionForwardData EthernetCTPFunction = 2
|
||||
)
|
||||
|
||||
// EthernetCTP implements the EthernetCTP protocol, see http://www.mit.edu/people/jhawk/ctp.html.
|
||||
// We split EthernetCTP up into the top-level EthernetCTP layer, followed by zero or more
|
||||
// EthernetCTPForwardData layers, followed by a final EthernetCTPReply layer.
|
||||
type EthernetCTP struct {
|
||||
BaseLayer
|
||||
SkipCount uint16
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeEthernetCTP.
|
||||
func (c *EthernetCTP) LayerType() gopacket.LayerType {
|
||||
return LayerTypeEthernetCTP
|
||||
}
|
||||
|
||||
// EthernetCTPForwardData is the ForwardData layer inside EthernetCTP. See EthernetCTP's docs for more
|
||||
// details.
|
||||
type EthernetCTPForwardData struct {
|
||||
BaseLayer
|
||||
Function EthernetCTPFunction
|
||||
ForwardAddress []byte
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeEthernetCTPForwardData.
|
||||
func (c *EthernetCTPForwardData) LayerType() gopacket.LayerType {
|
||||
return LayerTypeEthernetCTPForwardData
|
||||
}
|
||||
|
||||
// ForwardEndpoint returns the EthernetCTPForwardData ForwardAddress as an endpoint.
|
||||
func (c *EthernetCTPForwardData) ForwardEndpoint() gopacket.Endpoint {
|
||||
return gopacket.NewEndpoint(EndpointMAC, c.ForwardAddress)
|
||||
}
|
||||
|
||||
// EthernetCTPReply is the Reply layer inside EthernetCTP. See EthernetCTP's docs for more details.
|
||||
type EthernetCTPReply struct {
|
||||
BaseLayer
|
||||
Function EthernetCTPFunction
|
||||
ReceiptNumber uint16
|
||||
Data []byte
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeEthernetCTPReply.
|
||||
func (c *EthernetCTPReply) LayerType() gopacket.LayerType {
|
||||
return LayerTypeEthernetCTPReply
|
||||
}
|
||||
|
||||
// Payload returns the EthernetCTP reply's Data bytes.
|
||||
func (c *EthernetCTPReply) Payload() []byte { return c.Data }
|
||||
|
||||
func decodeEthernetCTP(data []byte, p gopacket.PacketBuilder) error {
|
||||
c := &EthernetCTP{
|
||||
SkipCount: binary.LittleEndian.Uint16(data[:2]),
|
||||
BaseLayer: BaseLayer{data[:2], data[2:]},
|
||||
}
|
||||
if c.SkipCount%2 != 0 {
|
||||
return fmt.Errorf("EthernetCTP skip count is odd: %d", c.SkipCount)
|
||||
}
|
||||
p.AddLayer(c)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeEthernetCTPFromFunctionType))
|
||||
}
|
||||
|
||||
// decodeEthernetCTPFromFunctionType reads in the first 2 bytes to determine the EthernetCTP
|
||||
// layer type to decode next, then decodes based on that.
|
||||
func decodeEthernetCTPFromFunctionType(data []byte, p gopacket.PacketBuilder) error {
|
||||
function := EthernetCTPFunction(binary.LittleEndian.Uint16(data[:2]))
|
||||
switch function {
|
||||
case EthernetCTPFunctionReply:
|
||||
reply := &EthernetCTPReply{
|
||||
Function: function,
|
||||
ReceiptNumber: binary.LittleEndian.Uint16(data[2:4]),
|
||||
Data: data[4:],
|
||||
BaseLayer: BaseLayer{data, nil},
|
||||
}
|
||||
p.AddLayer(reply)
|
||||
p.SetApplicationLayer(reply)
|
||||
return nil
|
||||
case EthernetCTPFunctionForwardData:
|
||||
forward := &EthernetCTPForwardData{
|
||||
Function: function,
|
||||
ForwardAddress: data[2:8],
|
||||
BaseLayer: BaseLayer{data[:8], data[8:]},
|
||||
}
|
||||
p.AddLayer(forward)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeEthernetCTPFromFunctionType))
|
||||
}
|
||||
return fmt.Errorf("Unknown EthernetCTP function type %v", function)
|
||||
}
|
||||
@ -0,0 +1,571 @@
|
||||
// Copyright 2016 Google, 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 (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// DHCPOp rerprents a bootp operation
|
||||
type DHCPOp byte
|
||||
|
||||
// bootp operations
|
||||
const (
|
||||
DHCPOpRequest DHCPOp = 1
|
||||
DHCPOpReply DHCPOp = 2
|
||||
)
|
||||
|
||||
// String returns a string version of a DHCPOp.
|
||||
func (o DHCPOp) String() string {
|
||||
switch o {
|
||||
case DHCPOpRequest:
|
||||
return "Request"
|
||||
case DHCPOpReply:
|
||||
return "Reply"
|
||||
default:
|
||||
return "Unknown"
|
||||
}
|
||||
}
|
||||
|
||||
// DHCPMsgType represents a DHCP operation
|
||||
type DHCPMsgType byte
|
||||
|
||||
// Constants that represent DHCP operations
|
||||
const (
|
||||
DHCPMsgTypeUnspecified DHCPMsgType = iota
|
||||
DHCPMsgTypeDiscover
|
||||
DHCPMsgTypeOffer
|
||||
DHCPMsgTypeRequest
|
||||
DHCPMsgTypeDecline
|
||||
DHCPMsgTypeAck
|
||||
DHCPMsgTypeNak
|
||||
DHCPMsgTypeRelease
|
||||
DHCPMsgTypeInform
|
||||
)
|
||||
|
||||
// String returns a string version of a DHCPMsgType.
|
||||
func (o DHCPMsgType) String() string {
|
||||
switch o {
|
||||
case DHCPMsgTypeUnspecified:
|
||||
return "Unspecified"
|
||||
case DHCPMsgTypeDiscover:
|
||||
return "Discover"
|
||||
case DHCPMsgTypeOffer:
|
||||
return "Offer"
|
||||
case DHCPMsgTypeRequest:
|
||||
return "Request"
|
||||
case DHCPMsgTypeDecline:
|
||||
return "Decline"
|
||||
case DHCPMsgTypeAck:
|
||||
return "Ack"
|
||||
case DHCPMsgTypeNak:
|
||||
return "Nak"
|
||||
case DHCPMsgTypeRelease:
|
||||
return "Release"
|
||||
case DHCPMsgTypeInform:
|
||||
return "Inform"
|
||||
default:
|
||||
return "Unknown"
|
||||
}
|
||||
}
|
||||
|
||||
//DHCPMagic is the RFC 2131 "magic cooke" for DHCP.
|
||||
var DHCPMagic uint32 = 0x63825363
|
||||
|
||||
// DHCPv4 contains data for a single DHCP packet.
|
||||
type DHCPv4 struct {
|
||||
BaseLayer
|
||||
Operation DHCPOp
|
||||
HardwareType LinkType
|
||||
HardwareLen uint8
|
||||
HardwareOpts uint8
|
||||
Xid uint32
|
||||
Secs uint16
|
||||
Flags uint16
|
||||
ClientIP net.IP
|
||||
YourClientIP net.IP
|
||||
NextServerIP net.IP
|
||||
RelayAgentIP net.IP
|
||||
ClientHWAddr net.HardwareAddr
|
||||
ServerName []byte
|
||||
File []byte
|
||||
Options DHCPOptions
|
||||
}
|
||||
|
||||
// DHCPOptions is used to get nicely printed option lists which would normally
|
||||
// be cut off after 5 options.
|
||||
type DHCPOptions []DHCPOption
|
||||
|
||||
// String returns a string version of the options list.
|
||||
func (o DHCPOptions) String() string {
|
||||
buf := &bytes.Buffer{}
|
||||
buf.WriteByte('[')
|
||||
for i, opt := range o {
|
||||
buf.WriteString(opt.String())
|
||||
if i+1 != len(o) {
|
||||
buf.WriteString(", ")
|
||||
}
|
||||
}
|
||||
buf.WriteByte(']')
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeDHCPv4
|
||||
func (d *DHCPv4) LayerType() gopacket.LayerType { return LayerTypeDHCPv4 }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (d *DHCPv4) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
d.Operation = DHCPOp(data[0])
|
||||
d.HardwareType = LinkType(data[1])
|
||||
d.HardwareLen = data[2]
|
||||
d.HardwareOpts = data[3]
|
||||
d.Xid = binary.BigEndian.Uint32(data[4:8])
|
||||
d.Secs = binary.BigEndian.Uint16(data[8:10])
|
||||
d.Flags = binary.BigEndian.Uint16(data[10:12])
|
||||
d.ClientIP = net.IP(data[12:16])
|
||||
d.YourClientIP = net.IP(data[16:20])
|
||||
d.NextServerIP = net.IP(data[20:24])
|
||||
d.RelayAgentIP = net.IP(data[24:28])
|
||||
d.ClientHWAddr = net.HardwareAddr(data[28 : 28+d.HardwareLen])
|
||||
d.ServerName = data[44:108]
|
||||
d.File = data[108:236]
|
||||
if binary.BigEndian.Uint32(data[236:240]) != DHCPMagic {
|
||||
return errors.New("Bad DHCP header")
|
||||
}
|
||||
|
||||
if len(data) <= 240 {
|
||||
// DHCP Packet could have no option (??)
|
||||
return nil
|
||||
}
|
||||
|
||||
options := data[240:]
|
||||
|
||||
stop := len(options)
|
||||
start := 0
|
||||
for start < stop {
|
||||
o := DHCPOption{}
|
||||
if err := o.decode(options[start:]); err != nil {
|
||||
return err
|
||||
}
|
||||
if o.Type == DHCPOptEnd {
|
||||
break
|
||||
}
|
||||
d.Options = append(d.Options, o)
|
||||
// Check if the option is a single byte pad
|
||||
if o.Type == DHCPOptPad {
|
||||
start++
|
||||
} else {
|
||||
start += int(o.Length) + 2
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Len returns the length of a DHCPv4 packet.
|
||||
func (d *DHCPv4) Len() uint16 {
|
||||
n := uint16(240)
|
||||
for _, o := range d.Options {
|
||||
if o.Type == DHCPOptPad {
|
||||
n++
|
||||
} else {
|
||||
n += uint16(o.Length) + 2
|
||||
}
|
||||
}
|
||||
n++ // for opt end
|
||||
return n
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (d *DHCPv4) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
plen := int(d.Len())
|
||||
|
||||
data, err := b.PrependBytes(plen)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
data[0] = byte(d.Operation)
|
||||
data[1] = byte(d.HardwareType)
|
||||
if opts.FixLengths {
|
||||
d.HardwareLen = uint8(len(d.ClientHWAddr))
|
||||
}
|
||||
data[2] = d.HardwareLen
|
||||
data[3] = d.HardwareOpts
|
||||
binary.BigEndian.PutUint32(data[4:8], d.Xid)
|
||||
binary.BigEndian.PutUint16(data[8:10], d.Secs)
|
||||
binary.BigEndian.PutUint16(data[10:12], d.Flags)
|
||||
copy(data[12:16], d.ClientIP.To4())
|
||||
copy(data[16:20], d.YourClientIP.To4())
|
||||
copy(data[20:24], d.NextServerIP.To4())
|
||||
copy(data[24:28], d.RelayAgentIP.To4())
|
||||
copy(data[28:44], d.ClientHWAddr)
|
||||
copy(data[44:108], d.ServerName)
|
||||
copy(data[108:236], d.File)
|
||||
binary.BigEndian.PutUint32(data[236:240], DHCPMagic)
|
||||
|
||||
if len(d.Options) > 0 {
|
||||
offset := 240
|
||||
for _, o := range d.Options {
|
||||
if err := o.encode(data[offset:]); err != nil {
|
||||
return err
|
||||
}
|
||||
// A pad option is only a single byte
|
||||
if o.Type == DHCPOptPad {
|
||||
offset++
|
||||
} else {
|
||||
offset += 2 + len(o.Data)
|
||||
}
|
||||
}
|
||||
optend := NewDHCPOption(DHCPOptEnd, nil)
|
||||
if err := optend.encode(data[offset:]); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (d *DHCPv4) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeDHCPv4
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (d *DHCPv4) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
func decodeDHCPv4(data []byte, p gopacket.PacketBuilder) error {
|
||||
dhcp := &DHCPv4{}
|
||||
err := dhcp.DecodeFromBytes(data, p)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p.AddLayer(dhcp)
|
||||
return p.NextDecoder(gopacket.LayerTypePayload)
|
||||
}
|
||||
|
||||
// DHCPOpt represents a DHCP option or parameter from RFC-2132
|
||||
type DHCPOpt byte
|
||||
|
||||
// Constants for the DHCPOpt options.
|
||||
const (
|
||||
DHCPOptPad DHCPOpt = 0
|
||||
DHCPOptSubnetMask DHCPOpt = 1 // 4, net.IP
|
||||
DHCPOptTimeOffset DHCPOpt = 2 // 4, int32 (signed seconds from UTC)
|
||||
DHCPOptRouter DHCPOpt = 3 // n*4, [n]net.IP
|
||||
DHCPOptTimeServer DHCPOpt = 4 // n*4, [n]net.IP
|
||||
DHCPOptNameServer DHCPOpt = 5 // n*4, [n]net.IP
|
||||
DHCPOptDNS DHCPOpt = 6 // n*4, [n]net.IP
|
||||
DHCPOptLogServer DHCPOpt = 7 // n*4, [n]net.IP
|
||||
DHCPOptCookieServer DHCPOpt = 8 // n*4, [n]net.IP
|
||||
DHCPOptLPRServer DHCPOpt = 9 // n*4, [n]net.IP
|
||||
DHCPOptImpressServer DHCPOpt = 10 // n*4, [n]net.IP
|
||||
DHCPOptResLocServer DHCPOpt = 11 // n*4, [n]net.IP
|
||||
DHCPOptHostname DHCPOpt = 12 // n, string
|
||||
DHCPOptBootfileSize DHCPOpt = 13 // 2, uint16
|
||||
DHCPOptMeritDumpFile DHCPOpt = 14 // >1, string
|
||||
DHCPOptDomainName DHCPOpt = 15 // n, string
|
||||
DHCPOptSwapServer DHCPOpt = 16 // n*4, [n]net.IP
|
||||
DHCPOptRootPath DHCPOpt = 17 // n, string
|
||||
DHCPOptExtensionsPath DHCPOpt = 18 // n, string
|
||||
DHCPOptIPForwarding DHCPOpt = 19 // 1, bool
|
||||
DHCPOptSourceRouting DHCPOpt = 20 // 1, bool
|
||||
DHCPOptPolicyFilter DHCPOpt = 21 // 8*n, [n]{net.IP/net.IP}
|
||||
DHCPOptDatagramMTU DHCPOpt = 22 // 2, uint16
|
||||
DHCPOptDefaultTTL DHCPOpt = 23 // 1, byte
|
||||
DHCPOptPathMTUAgingTimeout DHCPOpt = 24 // 4, uint32
|
||||
DHCPOptPathPlateuTableOption DHCPOpt = 25 // 2*n, []uint16
|
||||
DHCPOptInterfaceMTU DHCPOpt = 26 // 2, uint16
|
||||
DHCPOptAllSubsLocal DHCPOpt = 27 // 1, bool
|
||||
DHCPOptBroadcastAddr DHCPOpt = 28 // 4, net.IP
|
||||
DHCPOptMaskDiscovery DHCPOpt = 29 // 1, bool
|
||||
DHCPOptMaskSupplier DHCPOpt = 30 // 1, bool
|
||||
DHCPOptRouterDiscovery DHCPOpt = 31 // 1, bool
|
||||
DHCPOptSolicitAddr DHCPOpt = 32 // 4, net.IP
|
||||
DHCPOptStaticRoute DHCPOpt = 33 // n*8, [n]{net.IP/net.IP} -- note the 2nd is router not mask
|
||||
DHCPOptARPTrailers DHCPOpt = 34 // 1, bool
|
||||
DHCPOptARPTimeout DHCPOpt = 35 // 4, uint32
|
||||
DHCPOptEthernetEncap DHCPOpt = 36 // 1, bool
|
||||
DHCPOptTCPTTL DHCPOpt = 37 // 1, byte
|
||||
DHCPOptTCPKeepAliveInt DHCPOpt = 38 // 4, uint32
|
||||
DHCPOptTCPKeepAliveGarbage DHCPOpt = 39 // 1, bool
|
||||
DHCPOptNISDomain DHCPOpt = 40 // n, string
|
||||
DHCPOptNISServers DHCPOpt = 41 // 4*n, [n]net.IP
|
||||
DHCPOptNTPServers DHCPOpt = 42 // 4*n, [n]net.IP
|
||||
DHCPOptVendorOption DHCPOpt = 43 // n, [n]byte // may be encapsulated.
|
||||
DHCPOptNetBIOSTCPNS DHCPOpt = 44 // 4*n, [n]net.IP
|
||||
DHCPOptNetBIOSTCPDDS DHCPOpt = 45 // 4*n, [n]net.IP
|
||||
DHCPOptNETBIOSTCPNodeType DHCPOpt = 46 // 1, magic byte
|
||||
DHCPOptNetBIOSTCPScope DHCPOpt = 47 // n, string
|
||||
DHCPOptXFontServer DHCPOpt = 48 // n, string
|
||||
DHCPOptXDisplayManager DHCPOpt = 49 // n, string
|
||||
DHCPOptRequestIP DHCPOpt = 50 // 4, net.IP
|
||||
DHCPOptLeaseTime DHCPOpt = 51 // 4, uint32
|
||||
DHCPOptExtOptions DHCPOpt = 52 // 1, 1/2/3
|
||||
DHCPOptMessageType DHCPOpt = 53 // 1, 1-7
|
||||
DHCPOptServerID DHCPOpt = 54 // 4, net.IP
|
||||
DHCPOptParamsRequest DHCPOpt = 55 // n, []byte
|
||||
DHCPOptMessage DHCPOpt = 56 // n, 3
|
||||
DHCPOptMaxMessageSize DHCPOpt = 57 // 2, uint16
|
||||
DHCPOptT1 DHCPOpt = 58 // 4, uint32
|
||||
DHCPOptT2 DHCPOpt = 59 // 4, uint32
|
||||
DHCPOptClassID DHCPOpt = 60 // n, []byte
|
||||
DHCPOptClientID DHCPOpt = 61 // n >= 2, []byte
|
||||
DHCPOptDomainSearch DHCPOpt = 119 // n, string
|
||||
DHCPOptSIPServers DHCPOpt = 120 // n, url
|
||||
DHCPOptClasslessStaticRoute DHCPOpt = 121 //
|
||||
DHCPOptEnd DHCPOpt = 255
|
||||
)
|
||||
|
||||
// String returns a string version of a DHCPOpt.
|
||||
func (o DHCPOpt) String() string {
|
||||
switch o {
|
||||
case DHCPOptPad:
|
||||
return "(padding)"
|
||||
case DHCPOptSubnetMask:
|
||||
return "SubnetMask"
|
||||
case DHCPOptTimeOffset:
|
||||
return "TimeOffset"
|
||||
case DHCPOptRouter:
|
||||
return "Router"
|
||||
case DHCPOptTimeServer:
|
||||
return "rfc868" // old time server protocol stringified to dissuade confusion w. NTP
|
||||
case DHCPOptNameServer:
|
||||
return "ien116" // obscure nameserver protocol stringified to dissuade confusion w. DNS
|
||||
case DHCPOptDNS:
|
||||
return "DNS"
|
||||
case DHCPOptLogServer:
|
||||
return "mitLCS" // MIT LCS server protocol yada yada w. Syslog
|
||||
case DHCPOptCookieServer:
|
||||
return "CookieServer"
|
||||
case DHCPOptLPRServer:
|
||||
return "LPRServer"
|
||||
case DHCPOptImpressServer:
|
||||
return "ImpressServer"
|
||||
case DHCPOptResLocServer:
|
||||
return "ResourceLocationServer"
|
||||
case DHCPOptHostname:
|
||||
return "Hostname"
|
||||
case DHCPOptBootfileSize:
|
||||
return "BootfileSize"
|
||||
case DHCPOptMeritDumpFile:
|
||||
return "MeritDumpFile"
|
||||
case DHCPOptDomainName:
|
||||
return "DomainName"
|
||||
case DHCPOptSwapServer:
|
||||
return "SwapServer"
|
||||
case DHCPOptRootPath:
|
||||
return "RootPath"
|
||||
case DHCPOptExtensionsPath:
|
||||
return "ExtensionsPath"
|
||||
case DHCPOptIPForwarding:
|
||||
return "IPForwarding"
|
||||
case DHCPOptSourceRouting:
|
||||
return "SourceRouting"
|
||||
case DHCPOptPolicyFilter:
|
||||
return "PolicyFilter"
|
||||
case DHCPOptDatagramMTU:
|
||||
return "DatagramMTU"
|
||||
case DHCPOptDefaultTTL:
|
||||
return "DefaultTTL"
|
||||
case DHCPOptPathMTUAgingTimeout:
|
||||
return "PathMTUAgingTimeout"
|
||||
case DHCPOptPathPlateuTableOption:
|
||||
return "PathPlateuTableOption"
|
||||
case DHCPOptInterfaceMTU:
|
||||
return "InterfaceMTU"
|
||||
case DHCPOptAllSubsLocal:
|
||||
return "AllSubsLocal"
|
||||
case DHCPOptBroadcastAddr:
|
||||
return "BroadcastAddress"
|
||||
case DHCPOptMaskDiscovery:
|
||||
return "MaskDiscovery"
|
||||
case DHCPOptMaskSupplier:
|
||||
return "MaskSupplier"
|
||||
case DHCPOptRouterDiscovery:
|
||||
return "RouterDiscovery"
|
||||
case DHCPOptSolicitAddr:
|
||||
return "SolicitAddr"
|
||||
case DHCPOptStaticRoute:
|
||||
return "StaticRoute"
|
||||
case DHCPOptARPTrailers:
|
||||
return "ARPTrailers"
|
||||
case DHCPOptARPTimeout:
|
||||
return "ARPTimeout"
|
||||
case DHCPOptEthernetEncap:
|
||||
return "EthernetEncap"
|
||||
case DHCPOptTCPTTL:
|
||||
return "TCPTTL"
|
||||
case DHCPOptTCPKeepAliveInt:
|
||||
return "TCPKeepAliveInt"
|
||||
case DHCPOptTCPKeepAliveGarbage:
|
||||
return "TCPKeepAliveGarbage"
|
||||
case DHCPOptNISDomain:
|
||||
return "NISDomain"
|
||||
case DHCPOptNISServers:
|
||||
return "NISServers"
|
||||
case DHCPOptNTPServers:
|
||||
return "NTPServers"
|
||||
case DHCPOptVendorOption:
|
||||
return "VendorOption"
|
||||
case DHCPOptNetBIOSTCPNS:
|
||||
return "NetBIOSOverTCPNS"
|
||||
case DHCPOptNetBIOSTCPDDS:
|
||||
return "NetBiosOverTCPDDS"
|
||||
case DHCPOptNETBIOSTCPNodeType:
|
||||
return "NetBIOSOverTCPNodeType"
|
||||
case DHCPOptNetBIOSTCPScope:
|
||||
return "NetBIOSOverTCPScope"
|
||||
case DHCPOptXFontServer:
|
||||
return "XFontServer"
|
||||
case DHCPOptXDisplayManager:
|
||||
return "XDisplayManager"
|
||||
case DHCPOptEnd:
|
||||
return "(end)"
|
||||
case DHCPOptSIPServers:
|
||||
return "SipServers"
|
||||
case DHCPOptRequestIP:
|
||||
return "RequestIP"
|
||||
case DHCPOptLeaseTime:
|
||||
return "LeaseTime"
|
||||
case DHCPOptExtOptions:
|
||||
return "ExtOpts"
|
||||
case DHCPOptMessageType:
|
||||
return "MessageType"
|
||||
case DHCPOptServerID:
|
||||
return "ServerID"
|
||||
case DHCPOptParamsRequest:
|
||||
return "ParamsRequest"
|
||||
case DHCPOptMessage:
|
||||
return "Message"
|
||||
case DHCPOptMaxMessageSize:
|
||||
return "MaxDHCPSize"
|
||||
case DHCPOptT1:
|
||||
return "Timer1"
|
||||
case DHCPOptT2:
|
||||
return "Timer2"
|
||||
case DHCPOptClassID:
|
||||
return "ClassID"
|
||||
case DHCPOptClientID:
|
||||
return "ClientID"
|
||||
case DHCPOptDomainSearch:
|
||||
return "DomainSearch"
|
||||
case DHCPOptClasslessStaticRoute:
|
||||
return "ClasslessStaticRoute"
|
||||
default:
|
||||
return "Unknown"
|
||||
}
|
||||
}
|
||||
|
||||
// DHCPOption rerpresents a DHCP option.
|
||||
type DHCPOption struct {
|
||||
Type DHCPOpt
|
||||
Length uint8
|
||||
Data []byte
|
||||
}
|
||||
|
||||
// String returns a string version of a DHCP Option.
|
||||
func (o DHCPOption) String() string {
|
||||
switch o.Type {
|
||||
|
||||
case DHCPOptHostname, DHCPOptMeritDumpFile, DHCPOptDomainName, DHCPOptRootPath,
|
||||
DHCPOptExtensionsPath, DHCPOptNISDomain, DHCPOptNetBIOSTCPScope, DHCPOptXFontServer,
|
||||
DHCPOptXDisplayManager, DHCPOptMessage, DHCPOptDomainSearch: // string
|
||||
return fmt.Sprintf("Option(%s:%s)", o.Type, string(o.Data))
|
||||
|
||||
case DHCPOptMessageType:
|
||||
if len(o.Data) != 1 {
|
||||
return fmt.Sprintf("Option(%s:INVALID)", o.Type)
|
||||
}
|
||||
return fmt.Sprintf("Option(%s:%s)", o.Type, DHCPMsgType(o.Data[0]))
|
||||
|
||||
case DHCPOptSubnetMask, DHCPOptServerID, DHCPOptBroadcastAddr,
|
||||
DHCPOptSolicitAddr, DHCPOptRequestIP: // net.IP
|
||||
if len(o.Data) < 4 {
|
||||
return fmt.Sprintf("Option(%s:INVALID)", o.Type)
|
||||
}
|
||||
return fmt.Sprintf("Option(%s:%s)", o.Type, net.IP(o.Data))
|
||||
|
||||
case DHCPOptT1, DHCPOptT2, DHCPOptLeaseTime, DHCPOptPathMTUAgingTimeout,
|
||||
DHCPOptARPTimeout, DHCPOptTCPKeepAliveInt: // uint32
|
||||
if len(o.Data) != 4 {
|
||||
return fmt.Sprintf("Option(%s:INVALID)", o.Type)
|
||||
}
|
||||
return fmt.Sprintf("Option(%s:%d)", o.Type,
|
||||
uint32(o.Data[0])<<24|uint32(o.Data[1])<<16|uint32(o.Data[2])<<8|uint32(o.Data[3]))
|
||||
|
||||
case DHCPOptParamsRequest:
|
||||
buf := &bytes.Buffer{}
|
||||
buf.WriteString(fmt.Sprintf("Option(%s:", o.Type))
|
||||
for i, v := range o.Data {
|
||||
buf.WriteString(DHCPOpt(v).String())
|
||||
if i+1 != len(o.Data) {
|
||||
buf.WriteByte(',')
|
||||
}
|
||||
}
|
||||
buf.WriteString(")")
|
||||
return buf.String()
|
||||
|
||||
default:
|
||||
return fmt.Sprintf("Option(%s:%v)", o.Type, o.Data)
|
||||
}
|
||||
}
|
||||
|
||||
// NewDHCPOption constructs a new DHCPOption with a given type and data.
|
||||
func NewDHCPOption(t DHCPOpt, data []byte) DHCPOption {
|
||||
o := DHCPOption{Type: t}
|
||||
if data != nil {
|
||||
o.Data = data
|
||||
o.Length = uint8(len(data))
|
||||
}
|
||||
return o
|
||||
}
|
||||
|
||||
func (o *DHCPOption) encode(b []byte) error {
|
||||
switch o.Type {
|
||||
case DHCPOptPad, DHCPOptEnd:
|
||||
b[0] = byte(o.Type)
|
||||
default:
|
||||
if o.Length > 253 {
|
||||
return errors.New("data too long to encode")
|
||||
}
|
||||
b[0] = byte(o.Type)
|
||||
b[1] = o.Length
|
||||
copy(b[2:], o.Data)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (o *DHCPOption) decode(data []byte) error {
|
||||
if len(data) < 1 {
|
||||
// Pad/End have a length of 1
|
||||
return errors.New("Not enough data to decode")
|
||||
}
|
||||
o.Type = DHCPOpt(data[0])
|
||||
switch o.Type {
|
||||
case DHCPOptPad, DHCPOptEnd:
|
||||
o.Data = nil
|
||||
default:
|
||||
if len(data) < 3 {
|
||||
return errors.New("Not enough data to decode")
|
||||
}
|
||||
o.Length = data[1]
|
||||
if o.Length > 253 {
|
||||
return errors.New("data too long to decode")
|
||||
}
|
||||
o.Data = data[2 : 2+o.Length]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,894 @@
|
||||
// Copyright 2014 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// DNSClass defines the class associated with a request/response. Different DNS
|
||||
// classes can be thought of as an array of parallel namespace trees.
|
||||
type DNSClass uint16
|
||||
|
||||
// DNSClass known values.
|
||||
const (
|
||||
DNSClassIN DNSClass = 1 // Internet
|
||||
DNSClassCS DNSClass = 2 // the CSNET class (Obsolete)
|
||||
DNSClassCH DNSClass = 3 // the CHAOS class
|
||||
DNSClassHS DNSClass = 4 // Hesiod [Dyer 87]
|
||||
DNSClassAny DNSClass = 255 // AnyClass
|
||||
)
|
||||
|
||||
func (dc DNSClass) String() string {
|
||||
switch dc {
|
||||
default:
|
||||
return "Unknown"
|
||||
case DNSClassIN:
|
||||
return "IN"
|
||||
case DNSClassCS:
|
||||
return "CS"
|
||||
case DNSClassCH:
|
||||
return "CH"
|
||||
case DNSClassHS:
|
||||
return "HS"
|
||||
case DNSClassAny:
|
||||
return "Any"
|
||||
}
|
||||
}
|
||||
|
||||
// DNSType defines the type of data being requested/returned in a
|
||||
// question/answer.
|
||||
type DNSType uint16
|
||||
|
||||
// DNSType known values.
|
||||
const (
|
||||
DNSTypeA DNSType = 1 // a host address
|
||||
DNSTypeNS DNSType = 2 // an authoritative name server
|
||||
DNSTypeMD DNSType = 3 // a mail destination (Obsolete - use MX)
|
||||
DNSTypeMF DNSType = 4 // a mail forwarder (Obsolete - use MX)
|
||||
DNSTypeCNAME DNSType = 5 // the canonical name for an alias
|
||||
DNSTypeSOA DNSType = 6 // marks the start of a zone of authority
|
||||
DNSTypeMB DNSType = 7 // a mailbox domain name (EXPERIMENTAL)
|
||||
DNSTypeMG DNSType = 8 // a mail group member (EXPERIMENTAL)
|
||||
DNSTypeMR DNSType = 9 // a mail rename domain name (EXPERIMENTAL)
|
||||
DNSTypeNULL DNSType = 10 // a null RR (EXPERIMENTAL)
|
||||
DNSTypeWKS DNSType = 11 // a well known service description
|
||||
DNSTypePTR DNSType = 12 // a domain name pointer
|
||||
DNSTypeHINFO DNSType = 13 // host information
|
||||
DNSTypeMINFO DNSType = 14 // mailbox or mail list information
|
||||
DNSTypeMX DNSType = 15 // mail exchange
|
||||
DNSTypeTXT DNSType = 16 // text strings
|
||||
DNSTypeAAAA DNSType = 28 // a IPv6 host address [RFC3596]
|
||||
DNSTypeSRV DNSType = 33 // server discovery [RFC2782] [RFC6195]
|
||||
)
|
||||
|
||||
func (dt DNSType) String() string {
|
||||
switch dt {
|
||||
default:
|
||||
return "Unknown"
|
||||
case DNSTypeA:
|
||||
return "A"
|
||||
case DNSTypeNS:
|
||||
return "NS"
|
||||
case DNSTypeMD:
|
||||
return "MD"
|
||||
case DNSTypeMF:
|
||||
return "MF"
|
||||
case DNSTypeCNAME:
|
||||
return "CNAME"
|
||||
case DNSTypeSOA:
|
||||
return "SOA"
|
||||
case DNSTypeMB:
|
||||
return "MB"
|
||||
case DNSTypeMG:
|
||||
return "MG"
|
||||
case DNSTypeMR:
|
||||
return "MR"
|
||||
case DNSTypeNULL:
|
||||
return "NULL"
|
||||
case DNSTypeWKS:
|
||||
return "WKS"
|
||||
case DNSTypePTR:
|
||||
return "PTR"
|
||||
case DNSTypeHINFO:
|
||||
return "HINFO"
|
||||
case DNSTypeMINFO:
|
||||
return "MINFO"
|
||||
case DNSTypeMX:
|
||||
return "MX"
|
||||
case DNSTypeTXT:
|
||||
return "TXT"
|
||||
case DNSTypeAAAA:
|
||||
return "AAAA"
|
||||
case DNSTypeSRV:
|
||||
return "SRV"
|
||||
}
|
||||
}
|
||||
|
||||
// DNSResponseCode provides response codes for question answers.
|
||||
type DNSResponseCode uint8
|
||||
|
||||
// DNSResponseCode known values.
|
||||
const (
|
||||
DNSResponseCodeNoErr DNSResponseCode = 0 // No error
|
||||
DNSResponseCodeFormErr DNSResponseCode = 1 // Format Error [RFC1035]
|
||||
DNSResponseCodeServFail DNSResponseCode = 2 // Server Failure [RFC1035]
|
||||
DNSResponseCodeNXDomain DNSResponseCode = 3 // Non-Existent Domain [RFC1035]
|
||||
DNSResponseCodeNotImp DNSResponseCode = 4 // Not Implemented [RFC1035]
|
||||
DNSResponseCodeRefused DNSResponseCode = 5 // Query Refused [RFC1035]
|
||||
DNSResponseCodeYXDomain DNSResponseCode = 6 // Name Exists when it should not [RFC2136]
|
||||
DNSResponseCodeYXRRSet DNSResponseCode = 7 // RR Set Exists when it should not [RFC2136]
|
||||
DNSResponseCodeNXRRSet DNSResponseCode = 8 // RR Set that should exist does not [RFC2136]
|
||||
DNSResponseCodeNotAuth DNSResponseCode = 9 // Server Not Authoritative for zone [RFC2136]
|
||||
DNSResponseCodeNotZone DNSResponseCode = 10 // Name not contained in zone [RFC2136]
|
||||
DNSResponseCodeBadVers DNSResponseCode = 16 // Bad OPT Version [RFC2671]
|
||||
DNSResponseCodeBadSig DNSResponseCode = 16 // TSIG Signature Failure [RFC2845]
|
||||
DNSResponseCodeBadKey DNSResponseCode = 17 // Key not recognized [RFC2845]
|
||||
DNSResponseCodeBadTime DNSResponseCode = 18 // Signature out of time window [RFC2845]
|
||||
DNSResponseCodeBadMode DNSResponseCode = 19 // Bad TKEY Mode [RFC2930]
|
||||
DNSResponseCodeBadName DNSResponseCode = 20 // Duplicate key name [RFC2930]
|
||||
DNSResponseCodeBadAlg DNSResponseCode = 21 // Algorithm not supported [RFC2930]
|
||||
DNSResponseCodeBadTruc DNSResponseCode = 22 // Bad Truncation [RFC4635]
|
||||
)
|
||||
|
||||
func (drc DNSResponseCode) String() string {
|
||||
switch drc {
|
||||
default:
|
||||
return "Unknown"
|
||||
case DNSResponseCodeNoErr:
|
||||
return "No Error"
|
||||
case DNSResponseCodeFormErr:
|
||||
return "Format Error"
|
||||
case DNSResponseCodeServFail:
|
||||
return "Server Failure "
|
||||
case DNSResponseCodeNXDomain:
|
||||
return "Non-Existent Domain"
|
||||
case DNSResponseCodeNotImp:
|
||||
return "Not Implemented"
|
||||
case DNSResponseCodeRefused:
|
||||
return "Query Refused"
|
||||
case DNSResponseCodeYXDomain:
|
||||
return "Name Exists when it should not"
|
||||
case DNSResponseCodeYXRRSet:
|
||||
return "RR Set Exists when it should not"
|
||||
case DNSResponseCodeNXRRSet:
|
||||
return "RR Set that should exist does not"
|
||||
case DNSResponseCodeNotAuth:
|
||||
return "Server Not Authoritative for zone"
|
||||
case DNSResponseCodeNotZone:
|
||||
return "Name not contained in zone"
|
||||
case DNSResponseCodeBadVers:
|
||||
return "Bad OPT Version"
|
||||
case DNSResponseCodeBadKey:
|
||||
return "Key not recognized"
|
||||
case DNSResponseCodeBadTime:
|
||||
return "Signature out of time window"
|
||||
case DNSResponseCodeBadMode:
|
||||
return "Bad TKEY Mode"
|
||||
case DNSResponseCodeBadName:
|
||||
return "Duplicate key name"
|
||||
case DNSResponseCodeBadAlg:
|
||||
return "Algorithm not supported"
|
||||
case DNSResponseCodeBadTruc:
|
||||
return "Bad Truncation"
|
||||
}
|
||||
}
|
||||
|
||||
// DNSOpCode defines a set of different operation types.
|
||||
type DNSOpCode uint8
|
||||
|
||||
// DNSOpCode known values.
|
||||
const (
|
||||
DNSOpCodeQuery DNSOpCode = 0 // Query [RFC1035]
|
||||
DNSOpCodeIQuery DNSOpCode = 1 // Inverse Query Obsolete [RFC3425]
|
||||
DNSOpCodeStatus DNSOpCode = 2 // Status [RFC1035]
|
||||
DNSOpCodeNotify DNSOpCode = 4 // Notify [RFC1996]
|
||||
DNSOpCodeUpdate DNSOpCode = 5 // Update [RFC2136]
|
||||
)
|
||||
|
||||
func (doc DNSOpCode) String() string {
|
||||
switch doc {
|
||||
default:
|
||||
return "Unknown"
|
||||
case DNSOpCodeQuery:
|
||||
return "Query"
|
||||
case DNSOpCodeIQuery:
|
||||
return "Inverse Query"
|
||||
case DNSOpCodeStatus:
|
||||
return "Status"
|
||||
case DNSOpCodeNotify:
|
||||
return "Notify"
|
||||
case DNSOpCodeUpdate:
|
||||
return "Update"
|
||||
}
|
||||
}
|
||||
|
||||
// DNS is specified in RFC 1034 / RFC 1035
|
||||
// +---------------------+
|
||||
// | Header |
|
||||
// +---------------------+
|
||||
// | Question | the question for the name server
|
||||
// +---------------------+
|
||||
// | Answer | RRs answering the question
|
||||
// +---------------------+
|
||||
// | Authority | RRs pointing toward an authority
|
||||
// +---------------------+
|
||||
// | Additional | RRs holding additional information
|
||||
// +---------------------+
|
||||
//
|
||||
// DNS Header
|
||||
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | ID |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// |QR| Opcode |AA|TC|RD|RA| Z | RCODE |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | QDCOUNT |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | ANCOUNT |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | NSCOUNT |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | ARCOUNT |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
|
||||
// DNS contains data from a single Domain Name Service packet.
|
||||
type DNS struct {
|
||||
BaseLayer
|
||||
|
||||
// Header fields
|
||||
ID uint16
|
||||
QR bool
|
||||
OpCode DNSOpCode
|
||||
|
||||
AA bool // Authoritative answer
|
||||
TC bool // Truncated
|
||||
RD bool // Recursion desired
|
||||
RA bool // Recursion available
|
||||
Z uint8 // Resrved for future use
|
||||
|
||||
ResponseCode DNSResponseCode
|
||||
QDCount uint16 // Number of questions to expect
|
||||
ANCount uint16 // Number of answers to expect
|
||||
NSCount uint16 // Number of authorities to expect
|
||||
ARCount uint16 // Number of additional records to expect
|
||||
|
||||
// Entries
|
||||
Questions []DNSQuestion
|
||||
Answers []DNSResourceRecord
|
||||
Authorities []DNSResourceRecord
|
||||
Additionals []DNSResourceRecord
|
||||
|
||||
// buffer for doing name decoding. We use a single reusable buffer to avoid
|
||||
// name decoding on a single object via multiple DecodeFromBytes calls
|
||||
// requiring constant allocation of small byte slices.
|
||||
buffer []byte
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeDNS.
|
||||
func (d *DNS) LayerType() gopacket.LayerType { return LayerTypeDNS }
|
||||
|
||||
// decodeDNS decodes the byte slice into a DNS type. It also
|
||||
// setups the application Layer in PacketBuilder.
|
||||
func decodeDNS(data []byte, p gopacket.PacketBuilder) error {
|
||||
d := &DNS{}
|
||||
err := d.DecodeFromBytes(data, p)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p.AddLayer(d)
|
||||
p.SetApplicationLayer(d)
|
||||
return nil
|
||||
}
|
||||
|
||||
// DecodeFromBytes decodes the slice into the DNS struct.
|
||||
func (d *DNS) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
d.buffer = d.buffer[:0]
|
||||
|
||||
if len(data) < 12 {
|
||||
df.SetTruncated()
|
||||
return errors.New("DNS packet too short")
|
||||
}
|
||||
|
||||
// since there are no further layers, the baselayer's content is
|
||||
// pointing to this layer
|
||||
d.BaseLayer = BaseLayer{Contents: data[:len(data)]}
|
||||
d.ID = binary.BigEndian.Uint16(data[:2])
|
||||
d.QR = data[2]&0x80 != 0
|
||||
d.OpCode = DNSOpCode(data[2]>>3) & 0x0F
|
||||
d.AA = data[2]&0x04 != 0
|
||||
d.TC = data[2]&0x02 != 0
|
||||
d.RD = data[2]&0x01 != 0
|
||||
d.RA = data[3]&0x80 != 0
|
||||
d.Z = uint8(data[3]>>4) & 0x7
|
||||
d.ResponseCode = DNSResponseCode(data[3] & 0xF)
|
||||
d.QDCount = binary.BigEndian.Uint16(data[4:6])
|
||||
d.ANCount = binary.BigEndian.Uint16(data[6:8])
|
||||
d.NSCount = binary.BigEndian.Uint16(data[8:10])
|
||||
d.ARCount = binary.BigEndian.Uint16(data[10:12])
|
||||
|
||||
d.Questions = d.Questions[:0]
|
||||
d.Answers = d.Answers[:0]
|
||||
d.Authorities = d.Authorities[:0]
|
||||
d.Additionals = d.Additionals[:0]
|
||||
|
||||
offset := 12
|
||||
var err error
|
||||
for i := 0; i < int(d.QDCount); i++ {
|
||||
var q DNSQuestion
|
||||
if offset, err = q.decode(data, offset, df, &d.buffer); err != nil {
|
||||
return err
|
||||
}
|
||||
d.Questions = append(d.Questions, q)
|
||||
}
|
||||
|
||||
// For some horrible reason, if we do the obvious thing in this loop:
|
||||
// var r DNSResourceRecord
|
||||
// if blah := r.decode(blah); err != nil {
|
||||
// return err
|
||||
// }
|
||||
// d.Foo = append(d.Foo, r)
|
||||
// the Go compiler thinks that 'r' escapes to the heap, causing a malloc for
|
||||
// every Answer, Authority, and Additional. To get around this, we do
|
||||
// something really silly: we append an empty resource record to our slice,
|
||||
// then use the last value in the slice to call decode. Since the value is
|
||||
// already in the slice, there's no WAY it can escape... on the other hand our
|
||||
// code is MUCH uglier :(
|
||||
for i := 0; i < int(d.ANCount); i++ {
|
||||
d.Answers = append(d.Answers, DNSResourceRecord{})
|
||||
if offset, err = d.Answers[i].decode(data, offset, df, &d.buffer); err != nil {
|
||||
d.Answers = d.Answers[:i] // strip off erroneous value
|
||||
return err
|
||||
}
|
||||
}
|
||||
for i := 0; i < int(d.NSCount); i++ {
|
||||
d.Authorities = append(d.Authorities, DNSResourceRecord{})
|
||||
if offset, err = d.Authorities[i].decode(data, offset, df, &d.buffer); err != nil {
|
||||
d.Authorities = d.Authorities[:i] // strip off erroneous value
|
||||
return err
|
||||
}
|
||||
}
|
||||
for i := 0; i < int(d.ARCount); i++ {
|
||||
d.Additionals = append(d.Additionals, DNSResourceRecord{})
|
||||
if offset, err = d.Additionals[i].decode(data, offset, df, &d.buffer); err != nil {
|
||||
d.Additionals = d.Additionals[:i] // strip off erroneous value
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
if uint16(len(d.Questions)) != d.QDCount {
|
||||
return errors.New("Invalid query decoding, not the right number of questions")
|
||||
} else if uint16(len(d.Answers)) != d.ANCount {
|
||||
return errors.New("Invalid query decoding, not the right number of answers")
|
||||
} else if uint16(len(d.Authorities)) != d.NSCount {
|
||||
return errors.New("Invalid query decoding, not the right number of authorities")
|
||||
} else if uint16(len(d.Additionals)) != d.ARCount {
|
||||
return errors.New("Invalid query decoding, not the right number of additionals info")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode implements gopacket.DecodingLayer.
|
||||
func (d *DNS) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeDNS
|
||||
}
|
||||
|
||||
// NextLayerType implements gopacket.DecodingLayer.
|
||||
func (d *DNS) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
// Payload returns nil.
|
||||
func (d *DNS) Payload() []byte {
|
||||
return nil
|
||||
}
|
||||
|
||||
func b2i(b bool) int {
|
||||
if b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func recSize(rr *DNSResourceRecord) int {
|
||||
switch rr.Type {
|
||||
case DNSTypeA:
|
||||
return 4
|
||||
case DNSTypeAAAA:
|
||||
return 16
|
||||
case DNSTypeNS:
|
||||
return len(rr.NS) + 2
|
||||
case DNSTypeCNAME:
|
||||
return len(rr.CNAME) + 2
|
||||
case DNSTypePTR:
|
||||
return len(rr.PTR) + 2
|
||||
case DNSTypeSOA:
|
||||
return len(rr.SOA.MName) + 2 + len(rr.SOA.RName) + 2 + 20
|
||||
case DNSTypeMX:
|
||||
return 2 + len(rr.MX.Name) + 2
|
||||
case DNSTypeTXT:
|
||||
l := len(rr.TXTs)
|
||||
for _, txt := range rr.TXTs {
|
||||
l += len(txt)
|
||||
}
|
||||
return l
|
||||
case DNSTypeSRV:
|
||||
return 6 + len(rr.SRV.Name) + 2
|
||||
}
|
||||
|
||||
return 0
|
||||
}
|
||||
|
||||
func computeSize(recs []DNSResourceRecord) int {
|
||||
sz := 0
|
||||
for _, rr := range recs {
|
||||
sz += len(rr.Name) + 14
|
||||
sz += recSize(&rr)
|
||||
}
|
||||
return sz
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
func (d *DNS) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
dsz := 0
|
||||
for _, q := range d.Questions {
|
||||
dsz += len(q.Name) + 6
|
||||
}
|
||||
dsz += computeSize(d.Answers)
|
||||
dsz += computeSize(d.Authorities)
|
||||
dsz += computeSize(d.Additionals)
|
||||
|
||||
bytes, err := b.PrependBytes(12 + dsz)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes, d.ID)
|
||||
bytes[2] = byte((b2i(d.QR) << 7) | (int(d.OpCode) << 3) | (b2i(d.AA) << 2) | (b2i(d.TC) << 1) | b2i(d.RD))
|
||||
bytes[3] = byte((b2i(d.RA) << 7) | (int(d.Z) << 4) | int(d.ResponseCode))
|
||||
|
||||
if opts.FixLengths {
|
||||
d.QDCount = uint16(len(d.Questions))
|
||||
d.ANCount = uint16(len(d.Answers))
|
||||
d.NSCount = uint16(len(d.Authorities))
|
||||
d.ARCount = uint16(len(d.Additionals))
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[4:], d.QDCount)
|
||||
binary.BigEndian.PutUint16(bytes[6:], d.ANCount)
|
||||
binary.BigEndian.PutUint16(bytes[8:], d.NSCount)
|
||||
binary.BigEndian.PutUint16(bytes[10:], d.ARCount)
|
||||
|
||||
off := 12
|
||||
for _, qd := range d.Questions {
|
||||
n := qd.encode(bytes, off)
|
||||
off += n
|
||||
}
|
||||
|
||||
for i := range d.Answers {
|
||||
// done this way so we can modify DNSResourceRecord to fix
|
||||
// lengths if requested
|
||||
qa := &d.Answers[i]
|
||||
n, err := qa.encode(bytes, off, opts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
off += n
|
||||
}
|
||||
|
||||
for i := range d.Authorities {
|
||||
qa := &d.Authorities[i]
|
||||
n, err := qa.encode(bytes, off, opts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
off += n
|
||||
}
|
||||
for i := range d.Additionals {
|
||||
qa := &d.Additionals[i]
|
||||
n, err := qa.encode(bytes, off, opts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
off += n
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
var errMaxRecursion = errors.New("max DNS recursion level hit")
|
||||
|
||||
const maxRecursionLevel = 255
|
||||
|
||||
func decodeName(data []byte, offset int, buffer *[]byte, level int) ([]byte, int, error) {
|
||||
if level > maxRecursionLevel {
|
||||
return nil, 0, errMaxRecursion
|
||||
} else if offset >= len(data) {
|
||||
return nil, 0, errors.New("dns name offset too high")
|
||||
} else if offset < 0 {
|
||||
return nil, 0, errors.New("dns name offset is negative")
|
||||
}
|
||||
start := len(*buffer)
|
||||
index := offset
|
||||
if data[index] == 0x00 {
|
||||
return nil, index + 1, nil
|
||||
}
|
||||
loop:
|
||||
for data[index] != 0x00 {
|
||||
switch data[index] & 0xc0 {
|
||||
default:
|
||||
/* RFC 1035
|
||||
A domain name represented as a sequence of labels, where
|
||||
each label consists of a length octet followed by that
|
||||
number of octets. The domain name terminates with the
|
||||
zero length octet for the null label of the root. Note
|
||||
that this field may be an odd number of octets; no
|
||||
padding is used.
|
||||
*/
|
||||
index2 := index + int(data[index]) + 1
|
||||
if index2-offset > 255 {
|
||||
return nil, 0, errors.New("dns name is too long")
|
||||
} else if index2 < index+1 || index2 > len(data) {
|
||||
return nil, 0, errors.New("dns name uncomputable: invalid index")
|
||||
}
|
||||
*buffer = append(*buffer, '.')
|
||||
*buffer = append(*buffer, data[index+1:index2]...)
|
||||
index = index2
|
||||
|
||||
case 0xc0:
|
||||
/* RFC 1035
|
||||
The pointer takes the form of a two octet sequence.
|
||||
|
||||
The first two bits are ones. This allows a pointer to
|
||||
be distinguished from a label, since the label must
|
||||
begin with two zero bits because labels are restricted
|
||||
to 63 octets or less. (The 10 and 01 combinations are
|
||||
reserved for future use.) The OFFSET field specifies
|
||||
an offset from the start of the message (i.e., the
|
||||
first octet of the ID field in the domain header). A
|
||||
zero offset specifies the first byte of the ID field,
|
||||
etc.
|
||||
|
||||
The compression scheme allows a domain name in a message to be
|
||||
represented as either:
|
||||
- a sequence of labels ending in a zero octet
|
||||
- a pointer
|
||||
- a sequence of labels ending with a pointer
|
||||
*/
|
||||
if index+2 > len(data) {
|
||||
return nil, 0, errors.New("dns offset pointer too high")
|
||||
}
|
||||
offsetp := int(binary.BigEndian.Uint16(data[index:index+2]) & 0x3fff)
|
||||
if offsetp > len(data) {
|
||||
return nil, 0, errors.New("dns offset pointer too high")
|
||||
}
|
||||
// This looks a little tricky, but actually isn't. Because of how
|
||||
// decodeName is written, calling it appends the decoded name to the
|
||||
// current buffer. We already have the start of the buffer, then, so
|
||||
// once this call is done buffer[start:] will contain our full name.
|
||||
_, _, err := decodeName(data, offsetp, buffer, level+1)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
index++ // pointer is two bytes, so add an extra byte here.
|
||||
break loop
|
||||
/* EDNS, or other DNS option ? */
|
||||
case 0x40: // RFC 2673
|
||||
return nil, 0, fmt.Errorf("qname '0x40' - RFC 2673 unsupported yet (data=%x index=%d)",
|
||||
data[index], index)
|
||||
|
||||
case 0x80:
|
||||
return nil, 0, fmt.Errorf("qname '0x80' unsupported yet (data=%x index=%d)",
|
||||
data[index], index)
|
||||
}
|
||||
if index >= len(data) {
|
||||
return nil, 0, errors.New("dns index walked out of range")
|
||||
}
|
||||
}
|
||||
if len(*buffer) <= start {
|
||||
return nil, 0, errors.New("no dns data found for name")
|
||||
}
|
||||
return (*buffer)[start+1:], index + 1, nil
|
||||
}
|
||||
|
||||
// DNSQuestion wraps a single request (question) within a DNS query.
|
||||
type DNSQuestion struct {
|
||||
Name []byte
|
||||
Type DNSType
|
||||
Class DNSClass
|
||||
}
|
||||
|
||||
func (q *DNSQuestion) decode(data []byte, offset int, df gopacket.DecodeFeedback, buffer *[]byte) (int, error) {
|
||||
name, endq, err := decodeName(data, offset, buffer, 1)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
q.Name = name
|
||||
q.Type = DNSType(binary.BigEndian.Uint16(data[endq : endq+2]))
|
||||
q.Class = DNSClass(binary.BigEndian.Uint16(data[endq+2 : endq+4]))
|
||||
|
||||
return endq + 4, nil
|
||||
}
|
||||
|
||||
func (q *DNSQuestion) encode(data []byte, offset int) int {
|
||||
noff := encodeName(q.Name, data, offset)
|
||||
binary.BigEndian.PutUint16(data[noff:], uint16(q.Type))
|
||||
binary.BigEndian.PutUint16(data[noff+2:], uint16(q.Class))
|
||||
return len(q.Name) + 6
|
||||
}
|
||||
|
||||
// DNSResourceRecord
|
||||
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | |
|
||||
// / /
|
||||
// / NAME /
|
||||
// | |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | TYPE |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | CLASS |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | TTL |
|
||||
// | |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
// | RDLENGTH |
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--|
|
||||
// / RDATA /
|
||||
// / /
|
||||
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|
||||
|
||||
// DNSResourceRecord wraps the data from a single DNS resource within a
|
||||
// response.
|
||||
type DNSResourceRecord struct {
|
||||
// Header
|
||||
Name []byte
|
||||
Type DNSType
|
||||
Class DNSClass
|
||||
TTL uint32
|
||||
|
||||
// RDATA Raw Values
|
||||
DataLength uint16
|
||||
Data []byte
|
||||
|
||||
// RDATA Decoded Values
|
||||
IP net.IP
|
||||
NS, CNAME, PTR []byte
|
||||
TXTs [][]byte
|
||||
SOA DNSSOA
|
||||
SRV DNSSRV
|
||||
MX DNSMX
|
||||
|
||||
// Undecoded TXT for backward compatibility
|
||||
TXT []byte
|
||||
}
|
||||
|
||||
// decode decodes the resource record, returning the total length of the record.
|
||||
func (rr *DNSResourceRecord) decode(data []byte, offset int, df gopacket.DecodeFeedback, buffer *[]byte) (int, error) {
|
||||
name, endq, err := decodeName(data, offset, buffer, 1)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
rr.Name = name
|
||||
rr.Type = DNSType(binary.BigEndian.Uint16(data[endq : endq+2]))
|
||||
rr.Class = DNSClass(binary.BigEndian.Uint16(data[endq+2 : endq+4]))
|
||||
rr.TTL = binary.BigEndian.Uint32(data[endq+4 : endq+8])
|
||||
rr.DataLength = binary.BigEndian.Uint16(data[endq+8 : endq+10])
|
||||
end := endq + 10 + int(rr.DataLength)
|
||||
if end > len(data) {
|
||||
return 0, fmt.Errorf("resource record length exceeds data")
|
||||
}
|
||||
rr.Data = data[endq+10 : end]
|
||||
|
||||
if err = rr.decodeRData(data, endq+10, buffer); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
return endq + 10 + int(rr.DataLength), nil
|
||||
}
|
||||
|
||||
func encodeName(name []byte, data []byte, offset int) int {
|
||||
l := 0
|
||||
for i := range name {
|
||||
if name[i] == '.' {
|
||||
data[offset+i-l] = byte(l)
|
||||
l = 0
|
||||
} else {
|
||||
// skip one to write the length
|
||||
data[offset+i+1] = name[i]
|
||||
l++
|
||||
}
|
||||
}
|
||||
// length for final portion
|
||||
data[offset+len(name)-l] = byte(l)
|
||||
data[offset+len(name)+1] = 0x00 // terminal
|
||||
return offset + len(name) + 2
|
||||
}
|
||||
|
||||
func (rr *DNSResourceRecord) encode(data []byte, offset int, opts gopacket.SerializeOptions) (int, error) {
|
||||
|
||||
noff := encodeName(rr.Name, data, offset)
|
||||
|
||||
binary.BigEndian.PutUint16(data[noff:], uint16(rr.Type))
|
||||
binary.BigEndian.PutUint16(data[noff+2:], uint16(rr.Class))
|
||||
binary.BigEndian.PutUint32(data[noff+4:], uint32(rr.TTL))
|
||||
|
||||
switch rr.Type {
|
||||
case DNSTypeA:
|
||||
copy(data[noff+10:], rr.IP.To4())
|
||||
case DNSTypeAAAA:
|
||||
copy(data[noff+10:], rr.IP)
|
||||
case DNSTypeNS:
|
||||
encodeName(rr.NS, data, noff+10)
|
||||
case DNSTypeCNAME:
|
||||
encodeName(rr.CNAME, data, noff+10)
|
||||
case DNSTypePTR:
|
||||
encodeName(rr.PTR, data, noff+10)
|
||||
case DNSTypeSOA:
|
||||
noff2 := encodeName(rr.SOA.MName, data, noff+10)
|
||||
noff2 = encodeName(rr.SOA.RName, data, noff2)
|
||||
binary.BigEndian.PutUint32(data[noff2:], rr.SOA.Serial)
|
||||
binary.BigEndian.PutUint32(data[noff2+4:], rr.SOA.Refresh)
|
||||
binary.BigEndian.PutUint32(data[noff2+8:], rr.SOA.Retry)
|
||||
binary.BigEndian.PutUint32(data[noff2+12:], rr.SOA.Expire)
|
||||
binary.BigEndian.PutUint32(data[noff2+16:], rr.SOA.Minimum)
|
||||
case DNSTypeMX:
|
||||
binary.BigEndian.PutUint16(data[noff+10:], rr.MX.Preference)
|
||||
encodeName(rr.MX.Name, data, noff+12)
|
||||
case DNSTypeTXT:
|
||||
noff2 := noff + 10
|
||||
for _, txt := range rr.TXTs {
|
||||
data[noff2] = byte(len(txt))
|
||||
copy(data[noff2+1:], txt)
|
||||
noff2 += 1 + len(txt)
|
||||
}
|
||||
case DNSTypeSRV:
|
||||
binary.BigEndian.PutUint16(data[noff+10:], rr.SRV.Priority)
|
||||
binary.BigEndian.PutUint16(data[noff+12:], rr.SRV.Weight)
|
||||
binary.BigEndian.PutUint16(data[noff+14:], rr.SRV.Port)
|
||||
encodeName(rr.SRV.Name, data, noff+16)
|
||||
default:
|
||||
return 0, fmt.Errorf("serializing resource record of type %v not supported", rr.Type)
|
||||
}
|
||||
|
||||
// DataLength
|
||||
dSz := recSize(rr)
|
||||
binary.BigEndian.PutUint16(data[noff+8:], uint16(dSz))
|
||||
|
||||
if opts.FixLengths {
|
||||
rr.DataLength = uint16(dSz)
|
||||
}
|
||||
|
||||
return len(rr.Name) + 1 + 11 + dSz, nil
|
||||
}
|
||||
|
||||
func (rr *DNSResourceRecord) String() string {
|
||||
|
||||
if rr.Class == DNSClassIN {
|
||||
switch rr.Type {
|
||||
case DNSTypeA, DNSTypeAAAA:
|
||||
return rr.IP.String()
|
||||
case DNSTypeNS:
|
||||
return "NS " + string(rr.NS)
|
||||
case DNSTypeCNAME:
|
||||
return "CNAME " + string(rr.CNAME)
|
||||
case DNSTypePTR:
|
||||
return "PTR " + string(rr.PTR)
|
||||
case DNSTypeTXT:
|
||||
return "TXT " + string(rr.TXT)
|
||||
}
|
||||
}
|
||||
|
||||
return fmt.Sprintf("<%v, %v>", rr.Class, rr.Type)
|
||||
}
|
||||
|
||||
func decodeCharacterStrings(data []byte) ([][]byte, error) {
|
||||
strings := make([][]byte, 0, 1)
|
||||
end := len(data)
|
||||
for index, index2 := 0, 0; index != end; index = index2 {
|
||||
index2 = index + 1 + int(data[index]) // index increases by 1..256 and does not overflow
|
||||
if index2 > end {
|
||||
return nil, errors.New("Insufficient data for a <character-string>")
|
||||
}
|
||||
strings = append(strings, data[index+1:index2])
|
||||
}
|
||||
return strings, nil
|
||||
}
|
||||
|
||||
func (rr *DNSResourceRecord) decodeRData(data []byte, offset int, buffer *[]byte) error {
|
||||
switch rr.Type {
|
||||
case DNSTypeA:
|
||||
rr.IP = rr.Data
|
||||
case DNSTypeAAAA:
|
||||
rr.IP = rr.Data
|
||||
case DNSTypeTXT, DNSTypeHINFO:
|
||||
rr.TXT = rr.Data
|
||||
txts, err := decodeCharacterStrings(rr.Data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rr.TXTs = txts
|
||||
case DNSTypeNS:
|
||||
name, _, err := decodeName(data, offset, buffer, 1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rr.NS = name
|
||||
case DNSTypeCNAME:
|
||||
name, _, err := decodeName(data, offset, buffer, 1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rr.CNAME = name
|
||||
case DNSTypePTR:
|
||||
name, _, err := decodeName(data, offset, buffer, 1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rr.PTR = name
|
||||
case DNSTypeSOA:
|
||||
name, endq, err := decodeName(data, offset, buffer, 1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rr.SOA.MName = name
|
||||
name, endq, err = decodeName(data, endq, buffer, 1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rr.SOA.RName = name
|
||||
rr.SOA.Serial = binary.BigEndian.Uint32(data[endq : endq+4])
|
||||
rr.SOA.Refresh = binary.BigEndian.Uint32(data[endq+4 : endq+8])
|
||||
rr.SOA.Retry = binary.BigEndian.Uint32(data[endq+8 : endq+12])
|
||||
rr.SOA.Expire = binary.BigEndian.Uint32(data[endq+12 : endq+16])
|
||||
rr.SOA.Minimum = binary.BigEndian.Uint32(data[endq+16 : endq+20])
|
||||
case DNSTypeMX:
|
||||
rr.MX.Preference = binary.BigEndian.Uint16(data[offset : offset+2])
|
||||
name, _, err := decodeName(data, offset+2, buffer, 1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rr.MX.Name = name
|
||||
case DNSTypeSRV:
|
||||
rr.SRV.Priority = binary.BigEndian.Uint16(data[offset : offset+2])
|
||||
rr.SRV.Weight = binary.BigEndian.Uint16(data[offset+2 : offset+4])
|
||||
rr.SRV.Port = binary.BigEndian.Uint16(data[offset+4 : offset+6])
|
||||
name, _, err := decodeName(data, offset+6, buffer, 1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rr.SRV.Name = name
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DNSSOA is a Start of Authority record. Each domain requires a SOA record at
|
||||
// the cutover where a domain is delegated from its parent.
|
||||
type DNSSOA struct {
|
||||
MName, RName []byte
|
||||
Serial, Refresh, Retry, Expire, Minimum uint32
|
||||
}
|
||||
|
||||
// DNSSRV is a Service record, defining a location (hostname/port) of a
|
||||
// server/service.
|
||||
type DNSSRV struct {
|
||||
Priority, Weight, Port uint16
|
||||
Name []byte
|
||||
}
|
||||
|
||||
// DNSMX is a mail exchange record, defining a mail server for a recipient's
|
||||
// domain.
|
||||
type DNSMX struct {
|
||||
Preference uint16
|
||||
Name []byte
|
||||
}
|
||||
@ -0,0 +1,61 @@
|
||||
// Copyright 2012 Google, 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 provides decoding layers for many common protocols.
|
||||
|
||||
The layers package contains decode implementations for a number of different
|
||||
types of packet layers. Users of gopacket will almost always want to also use
|
||||
layers to actually decode packet data into useful pieces. To see the set of
|
||||
protocols that gopacket/layers is currently able to decode,
|
||||
look at the set of LayerTypes defined in the Variables sections. The
|
||||
layers package also defines endpoints for many of the common packet layers
|
||||
that have source/destination addresses associated with them, for example IPv4/6
|
||||
(IPs) and TCP/UDP (ports).
|
||||
Finally, layers contains a number of useful enumerations (IPProtocol,
|
||||
EthernetType, LinkType, PPPType, etc...). Many of these implement the
|
||||
gopacket.Decoder interface, so they can be passed into gopacket as decoders.
|
||||
|
||||
Most common protocol layers are named using acronyms or other industry-common
|
||||
names (IPv4, TCP, PPP). Some of the less common ones have their names expanded
|
||||
(CiscoDiscoveryProtocol).
|
||||
For certain protocols, sub-parts of the protocol are split out into their own
|
||||
layers (SCTP, for example). This is done mostly in cases where portions of the
|
||||
protocol may fulfill the capabilities of interesting layers (SCTPData implements
|
||||
ApplicationLayer, while base SCTP implements TransportLayer), or possibly
|
||||
because splitting a protocol into a few layers makes decoding easier.
|
||||
|
||||
This package is meant to be used with its parent,
|
||||
http://github.com/google/gopacket.
|
||||
|
||||
Port Types
|
||||
|
||||
Instead of using raw uint16 or uint8 values for ports, we use a different port
|
||||
type for every protocol, for example TCPPort and UDPPort. This allows us to
|
||||
override string behavior for each port, which we do by setting up port name
|
||||
maps (TCPPortNames, UDPPortNames, etc...). Well-known ports are annotated with
|
||||
their protocol names, and their String function displays these names:
|
||||
|
||||
p := TCPPort(80)
|
||||
fmt.Printf("Number: %d String: %v", p, p)
|
||||
// Prints: "Number: 80 String: 80(http)"
|
||||
|
||||
Modifying Decode Behavior
|
||||
|
||||
layers links together decoding through its enumerations. For example, after
|
||||
decoding layer type Ethernet, it uses Ethernet.EthernetType as its next decoder.
|
||||
All enumerations that act as decoders, like EthernetType, can be modified by
|
||||
users depending on their preferences. For example, if you have a spiffy new
|
||||
IPv4 decoder that works way better than the one built into layers, you can do
|
||||
this:
|
||||
|
||||
var mySpiffyIPv4Decoder gopacket.Decoder = ...
|
||||
layers.EthernetTypeMetadata[EthernetTypeIPv4].DecodeWith = mySpiffyIPv4Decoder
|
||||
|
||||
This will make all future ethernet packets use your new decoder to decode IPv4
|
||||
packets, instead of the built-in decoder used by gopacket.
|
||||
*/
|
||||
package layers
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,71 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// Dot1Q is the packet layer for 802.1Q VLAN headers.
|
||||
type Dot1Q struct {
|
||||
BaseLayer
|
||||
Priority uint8
|
||||
DropEligible bool
|
||||
VLANIdentifier uint16
|
||||
Type EthernetType
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeDot1Q
|
||||
func (d *Dot1Q) LayerType() gopacket.LayerType { return LayerTypeDot1Q }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (d *Dot1Q) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
d.Priority = (data[0] & 0xE0) >> 5
|
||||
d.DropEligible = data[0]&0x10 != 0
|
||||
d.VLANIdentifier = binary.BigEndian.Uint16(data[:2]) & 0x0FFF
|
||||
d.Type = EthernetType(binary.BigEndian.Uint16(data[2:4]))
|
||||
d.BaseLayer = BaseLayer{Contents: data[:4], Payload: data[4:]}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (d *Dot1Q) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeDot1Q
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (d *Dot1Q) NextLayerType() gopacket.LayerType {
|
||||
return d.Type.LayerType()
|
||||
}
|
||||
|
||||
func decodeDot1Q(data []byte, p gopacket.PacketBuilder) error {
|
||||
d := &Dot1Q{}
|
||||
return decodingLayerDecoder(d, data, p)
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (d *Dot1Q) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(4)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if d.VLANIdentifier > 0xFFF {
|
||||
return fmt.Errorf("vlan identifier %v is too high", d.VLANIdentifier)
|
||||
}
|
||||
firstBytes := uint16(d.Priority)<<13 | d.VLANIdentifier
|
||||
if d.DropEligible {
|
||||
firstBytes |= 0x1000
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes, firstBytes)
|
||||
binary.BigEndian.PutUint16(bytes[2:], uint16(d.Type))
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,106 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
type EAPCode uint8
|
||||
type EAPType uint8
|
||||
|
||||
const (
|
||||
EAPCodeRequest EAPCode = 1
|
||||
EAPCodeResponse EAPCode = 2
|
||||
EAPCodeSuccess EAPCode = 3
|
||||
EAPCodeFailure EAPCode = 4
|
||||
|
||||
// EAPTypeNone means that this EAP layer has no Type or TypeData.
|
||||
// Success and Failure EAPs will have this set.
|
||||
EAPTypeNone EAPType = 0
|
||||
|
||||
EAPTypeIdentity EAPType = 1
|
||||
EAPTypeNotification EAPType = 2
|
||||
EAPTypeNACK EAPType = 3
|
||||
EAPTypeOTP EAPType = 4
|
||||
EAPTypeTokenCard EAPType = 5
|
||||
)
|
||||
|
||||
// EAP defines an Extensible Authentication Protocol (rfc 3748) layer.
|
||||
type EAP struct {
|
||||
BaseLayer
|
||||
Code EAPCode
|
||||
Id uint8
|
||||
Length uint16
|
||||
Type EAPType
|
||||
TypeData []byte
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeEAP.
|
||||
func (e *EAP) LayerType() gopacket.LayerType { return LayerTypeEAP }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (e *EAP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
e.Code = EAPCode(data[0])
|
||||
e.Id = data[1]
|
||||
e.Length = binary.BigEndian.Uint16(data[2:4])
|
||||
switch {
|
||||
case e.Length > 4:
|
||||
e.Type = EAPType(data[4])
|
||||
e.TypeData = data[5:]
|
||||
case e.Length == 4:
|
||||
e.Type = 0
|
||||
e.TypeData = nil
|
||||
default:
|
||||
return fmt.Errorf("invalid EAP length %d", e.Length)
|
||||
}
|
||||
e.BaseLayer.Contents = data[:e.Length]
|
||||
e.BaseLayer.Payload = data[e.Length:] // Should be 0 bytes
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (e *EAP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
if opts.FixLengths {
|
||||
e.Length = uint16(len(e.TypeData) + 1)
|
||||
}
|
||||
size := len(e.TypeData) + 4
|
||||
if size > 4 {
|
||||
size++
|
||||
}
|
||||
bytes, err := b.PrependBytes(size)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = byte(e.Code)
|
||||
bytes[1] = e.Id
|
||||
binary.BigEndian.PutUint16(bytes[2:], e.Length)
|
||||
if size > 4 {
|
||||
bytes[4] = byte(e.Type)
|
||||
copy(bytes[5:], e.TypeData)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (e *EAP) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeEAP
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (e *EAP) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypeZero
|
||||
}
|
||||
|
||||
func decodeEAP(data []byte, p gopacket.PacketBuilder) error {
|
||||
e := &EAP{}
|
||||
return decodingLayerDecoder(e, data, p)
|
||||
}
|
||||
@ -0,0 +1,57 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// EAPOL defines an EAP over LAN (802.1x) layer.
|
||||
type EAPOL struct {
|
||||
BaseLayer
|
||||
Version uint8
|
||||
Type EAPOLType
|
||||
Length uint16
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeEAPOL.
|
||||
func (e *EAPOL) LayerType() gopacket.LayerType { return LayerTypeEAPOL }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (e *EAPOL) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
e.Version = data[0]
|
||||
e.Type = EAPOLType(data[1])
|
||||
e.Length = binary.BigEndian.Uint16(data[2:4])
|
||||
e.BaseLayer = BaseLayer{data[:4], data[4:]}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer
|
||||
func (e *EAPOL) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, _ := b.PrependBytes(4)
|
||||
bytes[0] = e.Version
|
||||
bytes[1] = byte(e.Type)
|
||||
binary.BigEndian.PutUint16(bytes[2:], e.Length)
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (e *EAPOL) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeEAPOL
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (e *EAPOL) NextLayerType() gopacket.LayerType {
|
||||
return e.Type.LayerType()
|
||||
}
|
||||
|
||||
func decodeEAPOL(data []byte, p gopacket.PacketBuilder) error {
|
||||
e := &EAPOL{}
|
||||
return decodingLayerDecoder(e, data, p)
|
||||
}
|
||||
@ -0,0 +1,97 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"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 {
|
||||
return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
|
||||
}})
|
||||
EndpointRUDPPort = gopacket.RegisterEndpointType(7, gopacket.EndpointTypeMetadata{Name: "RUDP", Formatter: func(b []byte) string {
|
||||
return strconv.Itoa(int(b[0]))
|
||||
}})
|
||||
EndpointUDPLitePort = gopacket.RegisterEndpointType(8, gopacket.EndpointTypeMetadata{Name: "UDPLite", Formatter: func(b []byte) string {
|
||||
return strconv.Itoa(int(binary.BigEndian.Uint16(b)))
|
||||
}})
|
||||
EndpointPPP = gopacket.RegisterEndpointType(9, gopacket.EndpointTypeMetadata{Name: "PPP", Formatter: func([]byte) string {
|
||||
return "point"
|
||||
}})
|
||||
)
|
||||
|
||||
// NewIPEndpoint creates a new IP (v4 or v6) endpoint from a net.IP address.
|
||||
// It returns gopacket.InvalidEndpoint if the IP address is invalid.
|
||||
func NewIPEndpoint(a net.IP) gopacket.Endpoint {
|
||||
ipv4 := a.To4()
|
||||
if ipv4 != nil {
|
||||
return gopacket.NewEndpoint(EndpointIPv4, []byte(ipv4))
|
||||
}
|
||||
|
||||
ipv6 := a.To16()
|
||||
if ipv6 != nil {
|
||||
return gopacket.NewEndpoint(EndpointIPv6, []byte(ipv6))
|
||||
}
|
||||
|
||||
return gopacket.InvalidEndpoint
|
||||
}
|
||||
|
||||
// NewMACEndpoint returns a new MAC address endpoint.
|
||||
func NewMACEndpoint(a net.HardwareAddr) gopacket.Endpoint {
|
||||
return gopacket.NewEndpoint(EndpointMAC, []byte(a))
|
||||
}
|
||||
func newPortEndpoint(t gopacket.EndpointType, p uint16) gopacket.Endpoint {
|
||||
return gopacket.NewEndpoint(t, []byte{byte(p >> 8), byte(p)})
|
||||
}
|
||||
|
||||
// NewTCPPortEndpoint returns an endpoint based on a TCP port.
|
||||
func NewTCPPortEndpoint(p TCPPort) gopacket.Endpoint {
|
||||
return newPortEndpoint(EndpointTCPPort, uint16(p))
|
||||
}
|
||||
|
||||
// NewUDPPortEndpoint returns an endpoint based on a UDP port.
|
||||
func NewUDPPortEndpoint(p UDPPort) gopacket.Endpoint {
|
||||
return newPortEndpoint(EndpointUDPPort, uint16(p))
|
||||
}
|
||||
|
||||
// NewSCTPPortEndpoint returns an endpoint based on a SCTP port.
|
||||
func NewSCTPPortEndpoint(p SCTPPort) gopacket.Endpoint {
|
||||
return newPortEndpoint(EndpointSCTPPort, uint16(p))
|
||||
}
|
||||
|
||||
// NewRUDPPortEndpoint returns an endpoint based on a RUDP port.
|
||||
func NewRUDPPortEndpoint(p RUDPPort) gopacket.Endpoint {
|
||||
return gopacket.NewEndpoint(EndpointRUDPPort, []byte{byte(p)})
|
||||
}
|
||||
|
||||
// NewUDPLitePortEndpoint returns an endpoint based on a UDPLite port.
|
||||
func NewUDPLitePortEndpoint(p UDPLitePort) gopacket.Endpoint {
|
||||
return newPortEndpoint(EndpointUDPLitePort, uint16(p))
|
||||
}
|
||||
@ -0,0 +1,562 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// EnumMetadata keeps track of a set of metadata for each enumeration value
|
||||
// for protocol enumerations.
|
||||
type EnumMetadata struct {
|
||||
// DecodeWith is the decoder to use to decode this protocol's data.
|
||||
DecodeWith gopacket.Decoder
|
||||
// Name is the name of the enumeration value.
|
||||
Name string
|
||||
// LayerType is the layer type implied by the given enum.
|
||||
LayerType gopacket.LayerType
|
||||
}
|
||||
|
||||
// errorFunc returns a decoder that spits out a specific error message.
|
||||
func errorFunc(msg string) gopacket.Decoder {
|
||||
var e = errors.New(msg)
|
||||
return gopacket.DecodeFunc(func([]byte, gopacket.PacketBuilder) error {
|
||||
return e
|
||||
})
|
||||
}
|
||||
|
||||
// EthernetType is an enumeration of ethernet type values, and acts as a decoder
|
||||
// for any type it supports.
|
||||
type EthernetType uint16
|
||||
|
||||
const (
|
||||
// EthernetTypeLLC is not an actual ethernet type. It is instead a
|
||||
// placeholder we use in Ethernet frames that use the 802.3 standard of
|
||||
// srcmac|dstmac|length|LLC instead of srcmac|dstmac|ethertype.
|
||||
EthernetTypeLLC EthernetType = 0
|
||||
EthernetTypeIPv4 EthernetType = 0x0800
|
||||
EthernetTypeARP EthernetType = 0x0806
|
||||
EthernetTypeIPv6 EthernetType = 0x86DD
|
||||
EthernetTypeCiscoDiscovery EthernetType = 0x2000
|
||||
EthernetTypeNortelDiscovery EthernetType = 0x01a2
|
||||
EthernetTypeTransparentEthernetBridging EthernetType = 0x6558
|
||||
EthernetTypeDot1Q EthernetType = 0x8100
|
||||
EthernetTypePPPoEDiscovery EthernetType = 0x8863
|
||||
EthernetTypePPPoESession EthernetType = 0x8864
|
||||
EthernetTypeMPLSUnicast EthernetType = 0x8847
|
||||
EthernetTypeMPLSMulticast EthernetType = 0x8848
|
||||
EthernetTypeEAPOL EthernetType = 0x888e
|
||||
EthernetTypeQinQ EthernetType = 0x88a8
|
||||
EthernetTypeLinkLayerDiscovery EthernetType = 0x88cc
|
||||
EthernetTypeEthernetCTP EthernetType = 0x9000
|
||||
)
|
||||
|
||||
// IPProtocol is an enumeration of IP protocol values, and acts as a decoder
|
||||
// for any type it supports.
|
||||
type IPProtocol uint8
|
||||
|
||||
const (
|
||||
IPProtocolIPv6HopByHop IPProtocol = 0
|
||||
IPProtocolICMPv4 IPProtocol = 1
|
||||
IPProtocolIGMP IPProtocol = 2
|
||||
IPProtocolIPv4 IPProtocol = 4
|
||||
IPProtocolTCP IPProtocol = 6
|
||||
IPProtocolUDP IPProtocol = 17
|
||||
IPProtocolRUDP IPProtocol = 27
|
||||
IPProtocolIPv6 IPProtocol = 41
|
||||
IPProtocolIPv6Routing IPProtocol = 43
|
||||
IPProtocolIPv6Fragment IPProtocol = 44
|
||||
IPProtocolGRE IPProtocol = 47
|
||||
IPProtocolESP IPProtocol = 50
|
||||
IPProtocolAH IPProtocol = 51
|
||||
IPProtocolICMPv6 IPProtocol = 58
|
||||
IPProtocolNoNextHeader IPProtocol = 59
|
||||
IPProtocolIPv6Destination IPProtocol = 60
|
||||
IPProtocolIPIP IPProtocol = 94
|
||||
IPProtocolEtherIP IPProtocol = 97
|
||||
IPProtocolVRRP IPProtocol = 112
|
||||
IPProtocolSCTP IPProtocol = 132
|
||||
IPProtocolUDPLite IPProtocol = 136
|
||||
IPProtocolMPLSInIP IPProtocol = 137
|
||||
)
|
||||
|
||||
// LinkType is an enumeration of link types, and acts as a decoder for any
|
||||
// link type it supports.
|
||||
type LinkType uint8
|
||||
|
||||
const (
|
||||
// According to pcap-linktype(7) and http://www.tcpdump.org/linktypes.html
|
||||
LinkTypeNull LinkType = 0
|
||||
LinkTypeEthernet LinkType = 1
|
||||
LinkTypeAX25 LinkType = 3
|
||||
LinkTypeTokenRing LinkType = 6
|
||||
LinkTypeArcNet LinkType = 7
|
||||
LinkTypeSLIP LinkType = 8
|
||||
LinkTypePPP LinkType = 9
|
||||
LinkTypeFDDI LinkType = 10
|
||||
LinkTypePPP_HDLC LinkType = 50
|
||||
LinkTypePPPEthernet LinkType = 51
|
||||
LinkTypeATM_RFC1483 LinkType = 100
|
||||
LinkTypeRaw LinkType = 101
|
||||
LinkTypeC_HDLC LinkType = 104
|
||||
LinkTypeIEEE802_11 LinkType = 105
|
||||
LinkTypeFRelay LinkType = 107
|
||||
LinkTypeLoop LinkType = 108
|
||||
LinkTypeLinuxSLL LinkType = 113
|
||||
LinkTypeLTalk LinkType = 114
|
||||
LinkTypePFLog LinkType = 117
|
||||
LinkTypePrismHeader LinkType = 119
|
||||
LinkTypeIPOverFC LinkType = 122
|
||||
LinkTypeSunATM LinkType = 123
|
||||
LinkTypeIEEE80211Radio LinkType = 127
|
||||
LinkTypeARCNetLinux LinkType = 129
|
||||
LinkTypeIPOver1394 LinkType = 138
|
||||
LinkTypeMTP2Phdr LinkType = 139
|
||||
LinkTypeMTP2 LinkType = 140
|
||||
LinkTypeMTP3 LinkType = 141
|
||||
LinkTypeSCCP LinkType = 142
|
||||
LinkTypeDOCSIS LinkType = 143
|
||||
LinkTypeLinuxIRDA LinkType = 144
|
||||
LinkTypeLinuxLAPD LinkType = 177
|
||||
LinkTypeLinuxUSB LinkType = 220
|
||||
LinkTypeIPv4 LinkType = 228
|
||||
LinkTypeIPv6 LinkType = 229
|
||||
)
|
||||
|
||||
// PPPoECode is the PPPoE code enum, taken from http://tools.ietf.org/html/rfc2516
|
||||
type PPPoECode uint8
|
||||
|
||||
const (
|
||||
PPPoECodePADI PPPoECode = 0x09
|
||||
PPPoECodePADO PPPoECode = 0x07
|
||||
PPPoECodePADR PPPoECode = 0x19
|
||||
PPPoECodePADS PPPoECode = 0x65
|
||||
PPPoECodePADT PPPoECode = 0xA7
|
||||
PPPoECodeSession PPPoECode = 0x00
|
||||
)
|
||||
|
||||
// PPPType is an enumeration of PPP type values, and acts as a decoder for any
|
||||
// type it supports.
|
||||
type PPPType uint16
|
||||
|
||||
const (
|
||||
PPPTypeIPv4 PPPType = 0x0021
|
||||
PPPTypeIPv6 PPPType = 0x0057
|
||||
PPPTypeMPLSUnicast PPPType = 0x0281
|
||||
PPPTypeMPLSMulticast PPPType = 0x0283
|
||||
)
|
||||
|
||||
// SCTPChunkType is an enumeration of chunk types inside SCTP packets.
|
||||
type SCTPChunkType uint8
|
||||
|
||||
const (
|
||||
SCTPChunkTypeData SCTPChunkType = 0
|
||||
SCTPChunkTypeInit SCTPChunkType = 1
|
||||
SCTPChunkTypeInitAck SCTPChunkType = 2
|
||||
SCTPChunkTypeSack SCTPChunkType = 3
|
||||
SCTPChunkTypeHeartbeat SCTPChunkType = 4
|
||||
SCTPChunkTypeHeartbeatAck SCTPChunkType = 5
|
||||
SCTPChunkTypeAbort SCTPChunkType = 6
|
||||
SCTPChunkTypeShutdown SCTPChunkType = 7
|
||||
SCTPChunkTypeShutdownAck SCTPChunkType = 8
|
||||
SCTPChunkTypeError SCTPChunkType = 9
|
||||
SCTPChunkTypeCookieEcho SCTPChunkType = 10
|
||||
SCTPChunkTypeCookieAck SCTPChunkType = 11
|
||||
SCTPChunkTypeShutdownComplete SCTPChunkType = 14
|
||||
)
|
||||
|
||||
// FDDIFrameControl is an enumeration of FDDI frame control bytes.
|
||||
type FDDIFrameControl uint8
|
||||
|
||||
const (
|
||||
FDDIFrameControlLLC FDDIFrameControl = 0x50
|
||||
)
|
||||
|
||||
// EAPOLType is an enumeration of EAPOL packet types.
|
||||
type EAPOLType uint8
|
||||
|
||||
const (
|
||||
EAPOLTypeEAP EAPOLType = 0
|
||||
EAPOLTypeStart EAPOLType = 1
|
||||
EAPOLTypeLogOff EAPOLType = 2
|
||||
EAPOLTypeKey EAPOLType = 3
|
||||
EAPOLTypeASFAlert EAPOLType = 4
|
||||
)
|
||||
|
||||
// ProtocolFamily is the set of values defined as PF_* in sys/socket.h
|
||||
type ProtocolFamily uint8
|
||||
|
||||
const (
|
||||
ProtocolFamilyIPv4 ProtocolFamily = 2
|
||||
// BSDs use different values for INET6... glory be. These values taken from
|
||||
// tcpdump 4.3.0.
|
||||
ProtocolFamilyIPv6BSD ProtocolFamily = 24
|
||||
ProtocolFamilyIPv6FreeBSD ProtocolFamily = 28
|
||||
ProtocolFamilyIPv6Darwin ProtocolFamily = 30
|
||||
ProtocolFamilyIPv6Linux ProtocolFamily = 10
|
||||
)
|
||||
|
||||
// Dot11Type is a combination of IEEE 802.11 frame's Type and Subtype fields.
|
||||
// By combining these two fields together into a single type, we're able to
|
||||
// provide a String function that correctly displays the subtype given the
|
||||
// top-level type.
|
||||
//
|
||||
// If you just care about the top-level type, use the MainType function.
|
||||
type Dot11Type uint8
|
||||
|
||||
// MainType strips the subtype information from the given type,
|
||||
// returning just the overarching type (Mgmt, Ctrl, Data, Reserved).
|
||||
func (d Dot11Type) MainType() Dot11Type {
|
||||
return d & dot11TypeMask
|
||||
}
|
||||
|
||||
const (
|
||||
Dot11TypeMgmt Dot11Type = 0x00
|
||||
Dot11TypeCtrl Dot11Type = 0x01
|
||||
Dot11TypeData Dot11Type = 0x02
|
||||
Dot11TypeReserved Dot11Type = 0x03
|
||||
dot11TypeMask = 0x03
|
||||
|
||||
// The following are type/subtype conglomerations.
|
||||
|
||||
// Management
|
||||
Dot11TypeMgmtAssociationReq Dot11Type = 0x00
|
||||
Dot11TypeMgmtAssociationResp Dot11Type = 0x04
|
||||
Dot11TypeMgmtReassociationReq Dot11Type = 0x08
|
||||
Dot11TypeMgmtReassociationResp Dot11Type = 0x0c
|
||||
Dot11TypeMgmtProbeReq Dot11Type = 0x10
|
||||
Dot11TypeMgmtProbeResp Dot11Type = 0x14
|
||||
Dot11TypeMgmtMeasurementPilot Dot11Type = 0x18
|
||||
Dot11TypeMgmtBeacon Dot11Type = 0x20
|
||||
Dot11TypeMgmtATIM Dot11Type = 0x24
|
||||
Dot11TypeMgmtDisassociation Dot11Type = 0x28
|
||||
Dot11TypeMgmtAuthentication Dot11Type = 0x2c
|
||||
Dot11TypeMgmtDeauthentication Dot11Type = 0x30
|
||||
Dot11TypeMgmtAction Dot11Type = 0x34
|
||||
Dot11TypeMgmtActionNoAck Dot11Type = 0x38
|
||||
|
||||
// Control
|
||||
Dot11TypeCtrlWrapper Dot11Type = 0x1d
|
||||
Dot11TypeCtrlBlockAckReq Dot11Type = 0x21
|
||||
Dot11TypeCtrlBlockAck Dot11Type = 0x25
|
||||
Dot11TypeCtrlPowersavePoll Dot11Type = 0x29
|
||||
Dot11TypeCtrlRTS Dot11Type = 0x2d
|
||||
Dot11TypeCtrlCTS Dot11Type = 0x31
|
||||
Dot11TypeCtrlAck Dot11Type = 0x35
|
||||
Dot11TypeCtrlCFEnd Dot11Type = 0x39
|
||||
Dot11TypeCtrlCFEndAck Dot11Type = 0x3d
|
||||
|
||||
// Data
|
||||
Dot11TypeDataCFAck Dot11Type = 0x06
|
||||
Dot11TypeDataCFPoll Dot11Type = 0x0a
|
||||
Dot11TypeDataCFAckPoll Dot11Type = 0x0e
|
||||
Dot11TypeDataNull Dot11Type = 0x12
|
||||
Dot11TypeDataCFAckNoData Dot11Type = 0x16
|
||||
Dot11TypeDataCFPollNoData Dot11Type = 0x1a
|
||||
Dot11TypeDataCFAckPollNoData Dot11Type = 0x1e
|
||||
Dot11TypeDataQOSData Dot11Type = 0x22
|
||||
Dot11TypeDataQOSDataCFAck Dot11Type = 0x26
|
||||
Dot11TypeDataQOSDataCFPoll Dot11Type = 0x2a
|
||||
Dot11TypeDataQOSDataCFAckPoll Dot11Type = 0x2e
|
||||
Dot11TypeDataQOSNull Dot11Type = 0x32
|
||||
Dot11TypeDataQOSCFPollNoData Dot11Type = 0x3a
|
||||
Dot11TypeDataQOSCFAckPollNoData Dot11Type = 0x3e
|
||||
)
|
||||
|
||||
var (
|
||||
// Each of the following arrays contains mappings of how to handle enum
|
||||
// values for various enum types in gopacket/layers.
|
||||
//
|
||||
// So, EthernetTypeMetadata[2] contains information on how to handle EthernetType
|
||||
// 2, including which name to give it and which decoder to use to decode
|
||||
// packet data of that type. These arrays are filled by default with all of the
|
||||
// protocols gopacket/layers knows how to handle, but users of the library can
|
||||
// add new decoders or override existing ones. For example, if you write a better
|
||||
// TCP decoder, you can override IPProtocolMetadata[IPProtocolTCP].DecodeWith
|
||||
// with your new decoder, and all gopacket/layers decoding will use your new
|
||||
// decoder whenever they encounter that IPProtocol.
|
||||
EthernetTypeMetadata [65536]EnumMetadata
|
||||
IPProtocolMetadata [256]EnumMetadata
|
||||
SCTPChunkTypeMetadata [256]EnumMetadata
|
||||
PPPTypeMetadata [65536]EnumMetadata
|
||||
PPPoECodeMetadata [256]EnumMetadata
|
||||
LinkTypeMetadata [256]EnumMetadata
|
||||
FDDIFrameControlMetadata [256]EnumMetadata
|
||||
EAPOLTypeMetadata [256]EnumMetadata
|
||||
ProtocolFamilyMetadata [256]EnumMetadata
|
||||
Dot11TypeMetadata [256]EnumMetadata
|
||||
USBTypeMetadata [256]EnumMetadata
|
||||
)
|
||||
|
||||
func (a EthernetType) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return EthernetTypeMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a EthernetType) String() string {
|
||||
return EthernetTypeMetadata[a].Name
|
||||
}
|
||||
func (a EthernetType) LayerType() gopacket.LayerType {
|
||||
return EthernetTypeMetadata[a].LayerType
|
||||
}
|
||||
func (a IPProtocol) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return IPProtocolMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a IPProtocol) String() string {
|
||||
return IPProtocolMetadata[a].Name
|
||||
}
|
||||
func (a IPProtocol) LayerType() gopacket.LayerType {
|
||||
return IPProtocolMetadata[a].LayerType
|
||||
}
|
||||
func (a SCTPChunkType) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return SCTPChunkTypeMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a SCTPChunkType) String() string {
|
||||
return SCTPChunkTypeMetadata[a].Name
|
||||
}
|
||||
func (a PPPType) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return PPPTypeMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a PPPType) String() string {
|
||||
return PPPTypeMetadata[a].Name
|
||||
}
|
||||
func (a LinkType) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return LinkTypeMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a LinkType) String() string {
|
||||
return LinkTypeMetadata[a].Name
|
||||
}
|
||||
func (a PPPoECode) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return PPPoECodeMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a PPPoECode) String() string {
|
||||
return PPPoECodeMetadata[a].Name
|
||||
}
|
||||
func (a FDDIFrameControl) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return FDDIFrameControlMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a FDDIFrameControl) String() string {
|
||||
return FDDIFrameControlMetadata[a].Name
|
||||
}
|
||||
func (a EAPOLType) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return EAPOLTypeMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a EAPOLType) String() string {
|
||||
return EAPOLTypeMetadata[a].Name
|
||||
}
|
||||
func (a EAPOLType) LayerType() gopacket.LayerType {
|
||||
return EAPOLTypeMetadata[a].LayerType
|
||||
}
|
||||
func (a ProtocolFamily) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return ProtocolFamilyMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a ProtocolFamily) String() string {
|
||||
return ProtocolFamilyMetadata[a].Name
|
||||
}
|
||||
func (a ProtocolFamily) LayerType() gopacket.LayerType {
|
||||
return ProtocolFamilyMetadata[a].LayerType
|
||||
}
|
||||
func (a Dot11Type) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
return Dot11TypeMetadata[a].DecodeWith.Decode(data, p)
|
||||
}
|
||||
func (a Dot11Type) String() string {
|
||||
return Dot11TypeMetadata[a].Name
|
||||
}
|
||||
func (a Dot11Type) LayerType() gopacket.LayerType {
|
||||
return Dot11TypeMetadata[a].LayerType
|
||||
}
|
||||
|
||||
// Decode a raw v4 or v6 IP packet.
|
||||
func decodeIPv4or6(data []byte, p gopacket.PacketBuilder) error {
|
||||
version := data[0] >> 4
|
||||
switch version {
|
||||
case 4:
|
||||
return decodeIPv4(data, p)
|
||||
case 6:
|
||||
return decodeIPv6(data, p)
|
||||
}
|
||||
return fmt.Errorf("Invalid IP packet version %v", version)
|
||||
}
|
||||
|
||||
func init() {
|
||||
// Here we link up all enumerations with their respective names and decoders.
|
||||
for i := 0; i < 65536; i++ {
|
||||
EthernetTypeMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode ethernet type %d", i)),
|
||||
Name: fmt.Sprintf("UnknownEthernetType(%d)", i),
|
||||
}
|
||||
PPPTypeMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode PPP type %d", i)),
|
||||
Name: fmt.Sprintf("UnknownPPPType(%d)", i),
|
||||
}
|
||||
}
|
||||
for i := 0; i < 256; i++ {
|
||||
IPProtocolMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode IP protocol %d", i)),
|
||||
Name: fmt.Sprintf("UnknownIPProtocol(%d)", i),
|
||||
}
|
||||
SCTPChunkTypeMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode SCTP chunk type %d", i)),
|
||||
Name: fmt.Sprintf("UnknownSCTPChunkType(%d)", i),
|
||||
}
|
||||
PPPoECodeMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode PPPoE code %d", i)),
|
||||
Name: fmt.Sprintf("UnknownPPPoECode(%d)", i),
|
||||
}
|
||||
LinkTypeMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode link type %d", i)),
|
||||
Name: fmt.Sprintf("UnknownLinkType(%d)", i),
|
||||
}
|
||||
FDDIFrameControlMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode FDDI frame control %d", i)),
|
||||
Name: fmt.Sprintf("UnknownFDDIFrameControl(%d)", i),
|
||||
}
|
||||
EAPOLTypeMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode EAPOL type %d", i)),
|
||||
Name: fmt.Sprintf("UnknownEAPOLType(%d)", i),
|
||||
}
|
||||
ProtocolFamilyMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode protocol family %d", i)),
|
||||
Name: fmt.Sprintf("UnknownProtocolFamily(%d)", i),
|
||||
}
|
||||
Dot11TypeMetadata[i] = EnumMetadata{
|
||||
DecodeWith: errorFunc(fmt.Sprintf("Unable to decode Dot11 type %d", i)),
|
||||
Name: fmt.Sprintf("UnknownDot11Type(%d)", i),
|
||||
}
|
||||
}
|
||||
|
||||
EthernetTypeMetadata[EthernetTypeLLC] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeLLC), Name: "LLC", LayerType: LayerTypeLLC}
|
||||
EthernetTypeMetadata[EthernetTypeIPv4] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv4), Name: "IPv4", LayerType: LayerTypeIPv4}
|
||||
EthernetTypeMetadata[EthernetTypeIPv6] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6), Name: "IPv6", LayerType: LayerTypeIPv6}
|
||||
EthernetTypeMetadata[EthernetTypeARP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeARP), Name: "ARP", LayerType: LayerTypeARP}
|
||||
EthernetTypeMetadata[EthernetTypeDot1Q] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot1Q), Name: "Dot1Q", LayerType: LayerTypeDot1Q}
|
||||
EthernetTypeMetadata[EthernetTypePPPoEDiscovery] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodePPPoE), Name: "PPPoEDiscovery", LayerType: LayerTypePPPoE}
|
||||
EthernetTypeMetadata[EthernetTypePPPoESession] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodePPPoE), Name: "PPPoESession", LayerType: LayerTypePPPoE}
|
||||
EthernetTypeMetadata[EthernetTypeEthernetCTP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeEthernetCTP), Name: "EthernetCTP", LayerType: LayerTypeEthernetCTP}
|
||||
EthernetTypeMetadata[EthernetTypeCiscoDiscovery] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeCiscoDiscovery), Name: "CiscoDiscovery", LayerType: LayerTypeCiscoDiscovery}
|
||||
EthernetTypeMetadata[EthernetTypeNortelDiscovery] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeNortelDiscovery), Name: "NortelDiscovery", LayerType: LayerTypeNortelDiscovery}
|
||||
EthernetTypeMetadata[EthernetTypeLinkLayerDiscovery] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeLinkLayerDiscovery), Name: "LinkLayerDiscovery", LayerType: LayerTypeLinkLayerDiscovery}
|
||||
EthernetTypeMetadata[EthernetTypeMPLSUnicast] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeMPLS), Name: "MPLSUnicast", LayerType: LayerTypeMPLS}
|
||||
EthernetTypeMetadata[EthernetTypeMPLSMulticast] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeMPLS), Name: "MPLSMulticast", LayerType: LayerTypeMPLS}
|
||||
EthernetTypeMetadata[EthernetTypeEAPOL] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeEAPOL), Name: "EAPOL", LayerType: LayerTypeEAPOL}
|
||||
EthernetTypeMetadata[EthernetTypeQinQ] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot1Q), Name: "Dot1Q", LayerType: LayerTypeDot1Q}
|
||||
EthernetTypeMetadata[EthernetTypeTransparentEthernetBridging] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeEthernet), Name: "TransparentEthernetBridging", LayerType: LayerTypeEthernet}
|
||||
|
||||
IPProtocolMetadata[IPProtocolIPv4] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv4), Name: "IPv4", LayerType: LayerTypeIPv4}
|
||||
IPProtocolMetadata[IPProtocolTCP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeTCP), Name: "TCP", LayerType: LayerTypeTCP}
|
||||
IPProtocolMetadata[IPProtocolUDP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeUDP), Name: "UDP", LayerType: LayerTypeUDP}
|
||||
IPProtocolMetadata[IPProtocolICMPv4] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeICMPv4), Name: "ICMPv4", LayerType: LayerTypeICMPv4}
|
||||
IPProtocolMetadata[IPProtocolICMPv6] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeICMPv6), Name: "ICMPv6", LayerType: LayerTypeICMPv6}
|
||||
IPProtocolMetadata[IPProtocolSCTP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTP), Name: "SCTP", LayerType: LayerTypeSCTP}
|
||||
IPProtocolMetadata[IPProtocolIPv6] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6), Name: "IPv6", LayerType: LayerTypeIPv6}
|
||||
IPProtocolMetadata[IPProtocolIPIP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv4), Name: "IPv4", LayerType: LayerTypeIPv4}
|
||||
IPProtocolMetadata[IPProtocolEtherIP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeEtherIP), Name: "EtherIP", LayerType: LayerTypeEtherIP}
|
||||
IPProtocolMetadata[IPProtocolRUDP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeRUDP), Name: "RUDP", LayerType: LayerTypeRUDP}
|
||||
IPProtocolMetadata[IPProtocolGRE] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeGRE), Name: "GRE", LayerType: LayerTypeGRE}
|
||||
IPProtocolMetadata[IPProtocolIPv6HopByHop] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6HopByHop), Name: "IPv6HopByHop", LayerType: LayerTypeIPv6HopByHop}
|
||||
IPProtocolMetadata[IPProtocolIPv6Routing] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6Routing), Name: "IPv6Routing", LayerType: LayerTypeIPv6Routing}
|
||||
IPProtocolMetadata[IPProtocolIPv6Fragment] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6Fragment), Name: "IPv6Fragment", LayerType: LayerTypeIPv6Fragment}
|
||||
IPProtocolMetadata[IPProtocolIPv6Destination] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6Destination), Name: "IPv6Destination", LayerType: LayerTypeIPv6Destination}
|
||||
IPProtocolMetadata[IPProtocolAH] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPSecAH), Name: "IPSecAH", LayerType: LayerTypeIPSecAH}
|
||||
IPProtocolMetadata[IPProtocolESP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPSecESP), Name: "IPSecESP", LayerType: LayerTypeIPSecESP}
|
||||
IPProtocolMetadata[IPProtocolUDPLite] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeUDPLite), Name: "UDPLite", LayerType: LayerTypeUDPLite}
|
||||
IPProtocolMetadata[IPProtocolMPLSInIP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeMPLS), Name: "MPLS", LayerType: LayerTypeMPLS}
|
||||
IPProtocolMetadata[IPProtocolNoNextHeader] = EnumMetadata{DecodeWith: gopacket.DecodePayload, Name: "NoNextHeader", LayerType: gopacket.LayerTypePayload}
|
||||
IPProtocolMetadata[IPProtocolIGMP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIGMP), Name: "IGMP", LayerType: LayerTypeIGMP}
|
||||
IPProtocolMetadata[IPProtocolVRRP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeVRRP), Name: "VRRP", LayerType: LayerTypeVRRP}
|
||||
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeData] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPData), Name: "Data"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeInit] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPInit), Name: "Init"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeInitAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPInit), Name: "InitAck"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeSack] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPSack), Name: "Sack"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeHeartbeat] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPHeartbeat), Name: "Heartbeat"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeHeartbeatAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPHeartbeat), Name: "HeartbeatAck"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeAbort] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPError), Name: "Abort"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeError] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPError), Name: "Error"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeShutdown] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPShutdown), Name: "Shutdown"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeShutdownAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPShutdownAck), Name: "ShutdownAck"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeCookieEcho] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPCookieEcho), Name: "CookieEcho"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeCookieAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPEmptyLayer), Name: "CookieAck"}
|
||||
SCTPChunkTypeMetadata[SCTPChunkTypeShutdownComplete] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeSCTPEmptyLayer), Name: "ShutdownComplete"}
|
||||
|
||||
PPPTypeMetadata[PPPTypeIPv4] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv4), Name: "IPv4"}
|
||||
PPPTypeMetadata[PPPTypeIPv6] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6), Name: "IPv6"}
|
||||
PPPTypeMetadata[PPPTypeMPLSUnicast] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeMPLS), Name: "MPLSUnicast"}
|
||||
PPPTypeMetadata[PPPTypeMPLSMulticast] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeMPLS), Name: "MPLSMulticast"}
|
||||
|
||||
PPPoECodeMetadata[PPPoECodeSession] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodePPP), Name: "PPP"}
|
||||
|
||||
LinkTypeMetadata[LinkTypeEthernet] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeEthernet), Name: "Ethernet"}
|
||||
LinkTypeMetadata[LinkTypePPP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodePPP), Name: "PPP"}
|
||||
LinkTypeMetadata[LinkTypeFDDI] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeFDDI), Name: "FDDI"}
|
||||
LinkTypeMetadata[LinkTypeNull] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeLoopback), Name: "Null"}
|
||||
LinkTypeMetadata[LinkTypeIEEE802_11] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11), Name: "Dot11"}
|
||||
LinkTypeMetadata[LinkTypeLoop] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeLoopback), Name: "Loop"}
|
||||
LinkTypeMetadata[LinkTypeIEEE802_11] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11), Name: "802.11"}
|
||||
LinkTypeMetadata[LinkTypeRaw] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv4or6), Name: "Raw"}
|
||||
LinkTypeMetadata[LinkTypePFLog] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodePFLog), Name: "PFLog"}
|
||||
LinkTypeMetadata[LinkTypeIEEE80211Radio] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeRadioTap), Name: "RadioTap"}
|
||||
LinkTypeMetadata[LinkTypeLinuxUSB] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeUSB), Name: "USB"}
|
||||
LinkTypeMetadata[LinkTypeLinuxSLL] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeLinuxSLL), Name: "Linux SLL"}
|
||||
LinkTypeMetadata[LinkTypePrismHeader] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodePrismHeader), Name: "Prism"}
|
||||
|
||||
FDDIFrameControlMetadata[FDDIFrameControlLLC] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeLLC), Name: "LLC"}
|
||||
|
||||
EAPOLTypeMetadata[EAPOLTypeEAP] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeEAP), Name: "EAP", LayerType: LayerTypeEAP}
|
||||
|
||||
ProtocolFamilyMetadata[ProtocolFamilyIPv4] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv4), Name: "IPv4", LayerType: LayerTypeIPv4}
|
||||
ProtocolFamilyMetadata[ProtocolFamilyIPv6BSD] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6), Name: "IPv6", LayerType: LayerTypeIPv6}
|
||||
ProtocolFamilyMetadata[ProtocolFamilyIPv6FreeBSD] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6), Name: "IPv6", LayerType: LayerTypeIPv6}
|
||||
ProtocolFamilyMetadata[ProtocolFamilyIPv6Darwin] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6), Name: "IPv6", LayerType: LayerTypeIPv6}
|
||||
ProtocolFamilyMetadata[ProtocolFamilyIPv6Linux] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeIPv6), Name: "IPv6", LayerType: LayerTypeIPv6}
|
||||
|
||||
Dot11TypeMetadata[Dot11TypeMgmtAssociationReq] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtAssociationReq), Name: "MgmtAssociationReq", LayerType: LayerTypeDot11MgmtAssociationReq}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtAssociationResp] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtAssociationResp), Name: "MgmtAssociationResp", LayerType: LayerTypeDot11MgmtAssociationResp}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtReassociationReq] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtReassociationReq), Name: "MgmtReassociationReq", LayerType: LayerTypeDot11MgmtReassociationReq}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtReassociationResp] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtReassociationResp), Name: "MgmtReassociationResp", LayerType: LayerTypeDot11MgmtReassociationResp}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtProbeReq] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtProbeReq), Name: "MgmtProbeReq", LayerType: LayerTypeDot11MgmtProbeReq}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtProbeResp] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtProbeResp), Name: "MgmtProbeResp", LayerType: LayerTypeDot11MgmtProbeResp}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtMeasurementPilot] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtMeasurementPilot), Name: "MgmtMeasurementPilot", LayerType: LayerTypeDot11MgmtMeasurementPilot}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtBeacon] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtBeacon), Name: "MgmtBeacon", LayerType: LayerTypeDot11MgmtBeacon}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtATIM] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtATIM), Name: "MgmtATIM", LayerType: LayerTypeDot11MgmtATIM}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtDisassociation] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtDisassociation), Name: "MgmtDisassociation", LayerType: LayerTypeDot11MgmtDisassociation}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtAuthentication] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtAuthentication), Name: "MgmtAuthentication", LayerType: LayerTypeDot11MgmtAuthentication}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtDeauthentication] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtDeauthentication), Name: "MgmtDeauthentication", LayerType: LayerTypeDot11MgmtDeauthentication}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtAction] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtAction), Name: "MgmtAction", LayerType: LayerTypeDot11MgmtAction}
|
||||
Dot11TypeMetadata[Dot11TypeMgmtActionNoAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11MgmtActionNoAck), Name: "MgmtActionNoAck", LayerType: LayerTypeDot11MgmtActionNoAck}
|
||||
Dot11TypeMetadata[Dot11TypeCtrl] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11Ctrl), Name: "Ctrl", LayerType: LayerTypeDot11Ctrl}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlWrapper] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11Ctrl), Name: "CtrlWrapper", LayerType: LayerTypeDot11Ctrl}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlBlockAckReq] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11CtrlBlockAckReq), Name: "CtrlBlockAckReq", LayerType: LayerTypeDot11CtrlBlockAckReq}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlBlockAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11CtrlBlockAck), Name: "CtrlBlockAck", LayerType: LayerTypeDot11CtrlBlockAck}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlPowersavePoll] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11CtrlPowersavePoll), Name: "CtrlPowersavePoll", LayerType: LayerTypeDot11CtrlPowersavePoll}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlRTS] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11CtrlRTS), Name: "CtrlRTS", LayerType: LayerTypeDot11CtrlRTS}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlCTS] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11CtrlCTS), Name: "CtrlCTS", LayerType: LayerTypeDot11CtrlCTS}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11CtrlAck), Name: "CtrlAck", LayerType: LayerTypeDot11CtrlAck}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlCFEnd] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11CtrlCFEnd), Name: "CtrlCFEnd", LayerType: LayerTypeDot11CtrlCFEnd}
|
||||
Dot11TypeMetadata[Dot11TypeCtrlCFEndAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11CtrlCFEndAck), Name: "CtrlCFEndAck", LayerType: LayerTypeDot11CtrlCFEndAck}
|
||||
Dot11TypeMetadata[Dot11TypeData] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11Data), Name: "Data", LayerType: LayerTypeDot11Data}
|
||||
Dot11TypeMetadata[Dot11TypeDataCFAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataCFAck), Name: "DataCFAck", LayerType: LayerTypeDot11DataCFAck}
|
||||
Dot11TypeMetadata[Dot11TypeDataCFPoll] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataCFPoll), Name: "DataCFPoll", LayerType: LayerTypeDot11DataCFPoll}
|
||||
Dot11TypeMetadata[Dot11TypeDataCFAckPoll] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataCFAckPoll), Name: "DataCFAckPoll", LayerType: LayerTypeDot11DataCFAckPoll}
|
||||
Dot11TypeMetadata[Dot11TypeDataNull] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataNull), Name: "DataNull", LayerType: LayerTypeDot11DataNull}
|
||||
Dot11TypeMetadata[Dot11TypeDataCFAckNoData] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataCFAckNoData), Name: "DataCFAckNoData", LayerType: LayerTypeDot11DataCFAckNoData}
|
||||
Dot11TypeMetadata[Dot11TypeDataCFPollNoData] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataCFPollNoData), Name: "DataCFPollNoData", LayerType: LayerTypeDot11DataCFPollNoData}
|
||||
Dot11TypeMetadata[Dot11TypeDataCFAckPollNoData] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataCFAckPollNoData), Name: "DataCFAckPollNoData", LayerType: LayerTypeDot11DataCFAckPollNoData}
|
||||
Dot11TypeMetadata[Dot11TypeDataQOSData] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataQOSData), Name: "DataQOSData", LayerType: LayerTypeDot11DataQOSData}
|
||||
Dot11TypeMetadata[Dot11TypeDataQOSDataCFAck] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataQOSDataCFAck), Name: "DataQOSDataCFAck", LayerType: LayerTypeDot11DataQOSDataCFAck}
|
||||
Dot11TypeMetadata[Dot11TypeDataQOSDataCFPoll] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataQOSDataCFPoll), Name: "DataQOSDataCFPoll", LayerType: LayerTypeDot11DataQOSDataCFPoll}
|
||||
Dot11TypeMetadata[Dot11TypeDataQOSDataCFAckPoll] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataQOSDataCFAckPoll), Name: "DataQOSDataCFAckPoll", LayerType: LayerTypeDot11DataQOSDataCFAckPoll}
|
||||
Dot11TypeMetadata[Dot11TypeDataQOSNull] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataQOSNull), Name: "DataQOSNull", LayerType: LayerTypeDot11DataQOSNull}
|
||||
Dot11TypeMetadata[Dot11TypeDataQOSCFPollNoData] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataQOSCFPollNoData), Name: "DataQOSCFPollNoData", LayerType: LayerTypeDot11DataQOSCFPollNoData}
|
||||
Dot11TypeMetadata[Dot11TypeDataQOSCFAckPollNoData] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeDot11DataQOSCFAckPollNoData), Name: "DataQOSCFAckPollNoData", LayerType: LayerTypeDot11DataQOSCFAckPollNoData}
|
||||
|
||||
USBTypeMetadata[USBTransportTypeInterrupt] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeUSBInterrupt), Name: "Interrupt", LayerType: LayerTypeUSBInterrupt}
|
||||
USBTypeMetadata[USBTransportTypeControl] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeUSBControl), Name: "Control", LayerType: LayerTypeUSBControl}
|
||||
USBTypeMetadata[USBTransportTypeBulk] = EnumMetadata{DecodeWith: gopacket.DecodeFunc(decodeUSBBulk), Name: "Bulk", LayerType: LayerTypeUSBBulk}
|
||||
}
|
||||
@ -0,0 +1,45 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// EtherIP is the struct for storing RFC 3378 EtherIP packet headers.
|
||||
type EtherIP struct {
|
||||
BaseLayer
|
||||
Version uint8
|
||||
Reserved uint16
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeEtherIP.
|
||||
func (e *EtherIP) LayerType() gopacket.LayerType { return LayerTypeEtherIP }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (e *EtherIP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
e.Version = data[0] >> 4
|
||||
e.Reserved = binary.BigEndian.Uint16(data[:2]) & 0x0fff
|
||||
e.BaseLayer = BaseLayer{data[:2], data[2:]}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (e *EtherIP) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeEtherIP
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (e *EtherIP) NextLayerType() gopacket.LayerType {
|
||||
return LayerTypeEthernet
|
||||
}
|
||||
|
||||
func decodeEtherIP(data []byte, p gopacket.PacketBuilder) error {
|
||||
e := &EtherIP{}
|
||||
return decodingLayerDecoder(e, data, p)
|
||||
}
|
||||
@ -0,0 +1,122 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"github.com/google/gopacket"
|
||||
"net"
|
||||
)
|
||||
|
||||
// EthernetBroadcast is the broadcast MAC address used by Ethernet.
|
||||
var EthernetBroadcast = net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
|
||||
|
||||
// Ethernet is the layer for Ethernet frame headers.
|
||||
type Ethernet struct {
|
||||
BaseLayer
|
||||
SrcMAC, DstMAC net.HardwareAddr
|
||||
EthernetType EthernetType
|
||||
// Length is only set if a length field exists within this header. Ethernet
|
||||
// headers follow two different standards, one that uses an EthernetType, the
|
||||
// other which defines a length the follows with a LLC header (802.3). If the
|
||||
// former is the case, we set EthernetType and Length stays 0. In the latter
|
||||
// case, we set Length and EthernetType = EthernetTypeLLC.
|
||||
Length uint16
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeEthernet
|
||||
func (e *Ethernet) LayerType() gopacket.LayerType { return LayerTypeEthernet }
|
||||
|
||||
func (e *Ethernet) LinkFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointMAC, e.SrcMAC, e.DstMAC)
|
||||
}
|
||||
|
||||
func (eth *Ethernet) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
if len(data) < 14 {
|
||||
return errors.New("Ethernet packet too small")
|
||||
}
|
||||
eth.DstMAC = net.HardwareAddr(data[0:6])
|
||||
eth.SrcMAC = net.HardwareAddr(data[6:12])
|
||||
eth.EthernetType = EthernetType(binary.BigEndian.Uint16(data[12:14]))
|
||||
eth.BaseLayer = BaseLayer{data[:14], data[14:]}
|
||||
if eth.EthernetType < 0x0600 {
|
||||
eth.Length = uint16(eth.EthernetType)
|
||||
eth.EthernetType = EthernetTypeLLC
|
||||
if cmp := len(eth.Payload) - int(eth.Length); cmp < 0 {
|
||||
df.SetTruncated()
|
||||
} else if cmp > 0 {
|
||||
// Strip off bytes at the end, since we have too many bytes
|
||||
eth.Payload = eth.Payload[:len(eth.Payload)-cmp]
|
||||
}
|
||||
// fmt.Println(eth)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (eth *Ethernet) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
if len(eth.DstMAC) != 6 {
|
||||
return fmt.Errorf("invalid dst MAC: %v", eth.DstMAC)
|
||||
}
|
||||
if len(eth.SrcMAC) != 6 {
|
||||
return fmt.Errorf("invalid src MAC: %v", eth.SrcMAC)
|
||||
}
|
||||
payload := b.Bytes()
|
||||
bytes, err := b.PrependBytes(14)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
copy(bytes, eth.DstMAC)
|
||||
copy(bytes[6:], eth.SrcMAC)
|
||||
if eth.Length != 0 || eth.EthernetType == EthernetTypeLLC {
|
||||
if opts.FixLengths {
|
||||
eth.Length = uint16(len(payload))
|
||||
}
|
||||
if eth.EthernetType != EthernetTypeLLC {
|
||||
return fmt.Errorf("ethernet type %v not compatible with length value %v", eth.EthernetType, eth.Length)
|
||||
} else if eth.Length > 0x0600 {
|
||||
return fmt.Errorf("invalid ethernet length %v", eth.Length)
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[12:], eth.Length)
|
||||
} else {
|
||||
binary.BigEndian.PutUint16(bytes[12:], uint16(eth.EthernetType))
|
||||
}
|
||||
length := len(b.Bytes())
|
||||
if length < 60 {
|
||||
// Pad out to 60 bytes.
|
||||
padding, err := b.AppendBytes(60 - length)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
copy(padding, lotsOfZeros[:])
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (eth *Ethernet) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeEthernet
|
||||
}
|
||||
|
||||
func (eth *Ethernet) NextLayerType() gopacket.LayerType {
|
||||
return eth.EthernetType.LayerType()
|
||||
}
|
||||
|
||||
func decodeEthernet(data []byte, p gopacket.PacketBuilder) error {
|
||||
eth := &Ethernet{}
|
||||
err := eth.DecodeFromBytes(data, p)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
p.AddLayer(eth)
|
||||
p.SetLinkLayer(eth)
|
||||
return p.NextDecoder(eth.EthernetType)
|
||||
}
|
||||
@ -0,0 +1,41 @@
|
||||
// Copyright 2012 Google, 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"
|
||||
"net"
|
||||
)
|
||||
|
||||
// FDDI contains the header for FDDI frames.
|
||||
type FDDI struct {
|
||||
BaseLayer
|
||||
FrameControl FDDIFrameControl
|
||||
Priority uint8
|
||||
SrcMAC, DstMAC net.HardwareAddr
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeFDDI.
|
||||
func (f *FDDI) LayerType() gopacket.LayerType { return LayerTypeFDDI }
|
||||
|
||||
// LinkFlow returns a new flow of type EndpointMAC.
|
||||
func (f *FDDI) LinkFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointMAC, f.SrcMAC, f.DstMAC)
|
||||
}
|
||||
|
||||
func decodeFDDI(data []byte, p gopacket.PacketBuilder) error {
|
||||
f := &FDDI{
|
||||
FrameControl: FDDIFrameControl(data[0] & 0xF8),
|
||||
Priority: data[0] & 0x07,
|
||||
SrcMAC: net.HardwareAddr(data[1:7]),
|
||||
DstMAC: net.HardwareAddr(data[7:13]),
|
||||
BaseLayer: BaseLayer{data[:13], data[13:]},
|
||||
}
|
||||
p.SetLinkLayer(f)
|
||||
p.AddLayer(f)
|
||||
return p.NextDecoder(f.FrameControl)
|
||||
}
|
||||
@ -0,0 +1,109 @@
|
||||
// Copyright 2012 Google, 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.
|
||||
|
||||
// +build ignore
|
||||
|
||||
// This binary pulls known ports from IANA, and uses them to populate
|
||||
// iana_ports.go's TCPPortNames and UDPPortNames maps.
|
||||
//
|
||||
// go run gen.go | gofmt > iana_ports.go
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/xml"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
const fmtString = `// Copyright 2012 Google, Inc. All rights reserved.
|
||||
|
||||
package layers
|
||||
|
||||
// Created by gen.go, don't edit manually
|
||||
// Generated at %s
|
||||
// Fetched from %q
|
||||
|
||||
// TCPPortNames contains the port names for all TCP ports.
|
||||
var TCPPortNames = tcpPortNames
|
||||
|
||||
// UDPPortNames contains the port names for all UDP ports.
|
||||
var UDPPortNames = udpPortNames
|
||||
|
||||
// SCTPPortNames contains the port names for all SCTP ports.
|
||||
var SCTPPortNames = sctpPortNames
|
||||
|
||||
var tcpPortNames = map[TCPPort]string{
|
||||
%s}
|
||||
var udpPortNames = map[UDPPort]string{
|
||||
%s}
|
||||
var sctpPortNames = map[SCTPPort]string{
|
||||
%s}
|
||||
`
|
||||
|
||||
var url = flag.String("url", "http://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xml", "URL to grab port numbers from")
|
||||
|
||||
func main() {
|
||||
fmt.Fprintf(os.Stderr, "Fetching ports from %q\n", *url)
|
||||
resp, err := http.Get(*url)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
body, err := ioutil.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
fmt.Fprintln(os.Stderr, "Parsing XML")
|
||||
var registry struct {
|
||||
Records []struct {
|
||||
Protocol string `xml:"protocol"`
|
||||
Number string `xml:"number"`
|
||||
Name string `xml:"name"`
|
||||
} `xml:"record"`
|
||||
}
|
||||
xml.Unmarshal(body, ®istry)
|
||||
var tcpPorts bytes.Buffer
|
||||
var udpPorts bytes.Buffer
|
||||
var sctpPorts bytes.Buffer
|
||||
done := map[string]map[int]bool{
|
||||
"tcp": map[int]bool{},
|
||||
"udp": map[int]bool{},
|
||||
"sctp": map[int]bool{},
|
||||
}
|
||||
for _, r := range registry.Records {
|
||||
port, err := strconv.Atoi(r.Number)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
if r.Name == "" {
|
||||
continue
|
||||
}
|
||||
var b *bytes.Buffer
|
||||
switch r.Protocol {
|
||||
case "tcp":
|
||||
b = &tcpPorts
|
||||
case "udp":
|
||||
b = &udpPorts
|
||||
case "sctp":
|
||||
b = &sctpPorts
|
||||
default:
|
||||
continue
|
||||
}
|
||||
if done[r.Protocol][port] {
|
||||
continue
|
||||
}
|
||||
done[r.Protocol][port] = true
|
||||
fmt.Fprintf(b, "\t%d: %q,\n", port, r.Name)
|
||||
}
|
||||
fmt.Fprintln(os.Stderr, "Writing results to stdout")
|
||||
fmt.Printf(fmtString, time.Now(), *url, tcpPorts.String(), udpPorts.String(), sctpPorts.String())
|
||||
}
|
||||
@ -0,0 +1,3 @@
|
||||
#!/bin/bash
|
||||
|
||||
for i in *.go; do golint $i | grep -q . || echo $i; done > .linted
|
||||
@ -0,0 +1,98 @@
|
||||
// Copyright 2016 Google, 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 (
|
||||
"encoding/binary"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// Geneve is specifed here https://tools.ietf.org/html/draft-ietf-nvo3-geneve-03
|
||||
// Geneve Header:
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// |Ver| Opt Len |O|C| Rsvd. | Protocol Type |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Virtual Network Identifier (VNI) | Reserved |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Variable Length Options |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
type Geneve struct {
|
||||
BaseLayer
|
||||
Version uint8 // 2 bits
|
||||
OptionsLength uint8 // 6 bits
|
||||
OAMPacket bool // 1 bits
|
||||
CriticalOption bool // 1 bits
|
||||
Protocol EthernetType // 16 bits
|
||||
VNI uint32 // 24bits
|
||||
Options []*GeneveOption
|
||||
}
|
||||
|
||||
// Geneve Tunnel Options
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Option Class | Type |R|R|R| Length |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Variable Option Data |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
type GeneveOption struct {
|
||||
Class uint16 // 16 bits
|
||||
Type uint8 // 8 bits
|
||||
Flags uint8 // 3 bits
|
||||
Length uint8 // 5 bits
|
||||
Data []byte
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeGeneve
|
||||
func (gn *Geneve) LayerType() gopacket.LayerType { return LayerTypeGeneve }
|
||||
|
||||
func decodeGeneveOption(data []byte, gn *Geneve) (*GeneveOption, uint8) {
|
||||
opt := &GeneveOption{}
|
||||
|
||||
opt.Class = binary.BigEndian.Uint16(data[0:1])
|
||||
opt.Type = data[2]
|
||||
opt.Flags = data[3] >> 4
|
||||
opt.Length = data[3] & 0xf
|
||||
|
||||
copy(opt.Data, data[4:opt.Length])
|
||||
|
||||
return opt, 4 + opt.Length
|
||||
}
|
||||
|
||||
func (gn *Geneve) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
gn.Version = data[0] >> 7
|
||||
gn.OptionsLength = data[0] & 0x3f
|
||||
|
||||
gn.OAMPacket = data[1]&0x80 > 0
|
||||
gn.CriticalOption = data[1]&0x40 > 0
|
||||
gn.Protocol = EthernetType(binary.BigEndian.Uint16(data[2:4]))
|
||||
|
||||
var buf [4]byte
|
||||
copy(buf[1:], data[4:7])
|
||||
gn.VNI = binary.BigEndian.Uint32(buf[:])
|
||||
|
||||
offset, length := uint8(8), gn.OptionsLength
|
||||
for length > 0 {
|
||||
opt, len := decodeGeneveOption(data[offset:], gn)
|
||||
gn.Options = append(gn.Options, opt)
|
||||
|
||||
length -= len
|
||||
offset += len
|
||||
}
|
||||
|
||||
gn.BaseLayer = BaseLayer{data[:offset], data[offset:]}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (gn *Geneve) NextLayerType() gopacket.LayerType {
|
||||
return gn.Protocol.LayerType()
|
||||
}
|
||||
|
||||
func decodeGeneve(data []byte, p gopacket.PacketBuilder) error {
|
||||
gn := &Geneve{}
|
||||
return decodingLayerDecoder(gn, data, p)
|
||||
}
|
||||
@ -0,0 +1,185 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// GRE is a Generic Routing Encapsulation header.
|
||||
type GRE struct {
|
||||
BaseLayer
|
||||
ChecksumPresent, RoutingPresent, KeyPresent, SeqPresent, StrictSourceRoute bool
|
||||
RecursionControl, Flags, Version uint8
|
||||
Protocol EthernetType
|
||||
Checksum, Offset uint16
|
||||
Key, Seq uint32
|
||||
*GRERouting
|
||||
}
|
||||
|
||||
// GRERouting is GRE routing information, present if the RoutingPresent flag is
|
||||
// set.
|
||||
type GRERouting struct {
|
||||
AddressFamily uint16
|
||||
SREOffset, SRELength uint8
|
||||
RoutingInformation []byte
|
||||
Next *GRERouting
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeGRE.
|
||||
func (g *GRE) LayerType() gopacket.LayerType { return LayerTypeGRE }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (g *GRE) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
g.ChecksumPresent = data[0]&0x80 != 0
|
||||
g.RoutingPresent = data[0]&0x40 != 0
|
||||
g.KeyPresent = data[0]&0x20 != 0
|
||||
g.SeqPresent = data[0]&0x10 != 0
|
||||
g.StrictSourceRoute = data[0]&0x08 != 0
|
||||
g.RecursionControl = data[0] & 0x7
|
||||
g.Flags = data[1] >> 3
|
||||
g.Version = data[1] & 0x7
|
||||
g.Protocol = EthernetType(binary.BigEndian.Uint16(data[2:4]))
|
||||
offset := 4
|
||||
if g.ChecksumPresent || g.RoutingPresent {
|
||||
g.Checksum = binary.BigEndian.Uint16(data[offset : offset+2])
|
||||
g.Offset = binary.BigEndian.Uint16(data[offset+2 : offset+4])
|
||||
offset += 4
|
||||
}
|
||||
if g.KeyPresent {
|
||||
g.Key = binary.BigEndian.Uint32(data[offset : offset+4])
|
||||
offset += 4
|
||||
}
|
||||
if g.SeqPresent {
|
||||
g.Seq = binary.BigEndian.Uint32(data[offset : offset+4])
|
||||
offset += 4
|
||||
}
|
||||
if g.RoutingPresent {
|
||||
tail := &g.GRERouting
|
||||
for {
|
||||
sre := &GRERouting{
|
||||
AddressFamily: binary.BigEndian.Uint16(data[offset : offset+2]),
|
||||
SREOffset: data[offset+2],
|
||||
SRELength: data[offset+3],
|
||||
}
|
||||
sre.RoutingInformation = data[offset+4 : offset+4+int(sre.SRELength)]
|
||||
offset += 4 + int(sre.SRELength)
|
||||
if sre.AddressFamily == 0 && sre.SRELength == 0 {
|
||||
break
|
||||
}
|
||||
(*tail) = sre
|
||||
tail = &sre.Next
|
||||
}
|
||||
}
|
||||
g.BaseLayer = BaseLayer{data[:offset], data[offset:]}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the SerializationBuffer,
|
||||
// implementing gopacket.SerializableLayer. See the docs for gopacket.SerializableLayer for more info.
|
||||
func (g *GRE) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
size := 4
|
||||
if g.ChecksumPresent || g.RoutingPresent {
|
||||
size += 4
|
||||
}
|
||||
if g.KeyPresent {
|
||||
size += 4
|
||||
}
|
||||
if g.SeqPresent {
|
||||
size += 4
|
||||
}
|
||||
if g.RoutingPresent {
|
||||
r := g.GRERouting
|
||||
for r != nil {
|
||||
size += 4 + int(r.SRELength)
|
||||
r = r.Next
|
||||
}
|
||||
size += 4
|
||||
}
|
||||
buf, err := b.PrependBytes(size)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// Reset any potentially dirty memory in the first 2 bytes, as these use OR to set flags.
|
||||
buf[0] = 0
|
||||
buf[1] = 0
|
||||
if g.ChecksumPresent {
|
||||
buf[0] |= 0x80
|
||||
}
|
||||
if g.RoutingPresent {
|
||||
buf[0] |= 0x40
|
||||
}
|
||||
if g.KeyPresent {
|
||||
buf[0] |= 0x20
|
||||
}
|
||||
if g.SeqPresent {
|
||||
buf[0] |= 0x10
|
||||
}
|
||||
if g.StrictSourceRoute {
|
||||
buf[0] |= 0x08
|
||||
}
|
||||
buf[0] |= g.RecursionControl
|
||||
buf[1] |= g.Flags << 3
|
||||
buf[1] |= g.Version
|
||||
binary.BigEndian.PutUint16(buf[2:4], uint16(g.Protocol))
|
||||
offset := 4
|
||||
if g.ChecksumPresent || g.RoutingPresent {
|
||||
// Don't write the checksum value yet, as we may need to compute it,
|
||||
// which requires the entire header be complete.
|
||||
// Instead we zeroize the memory in case it is dirty.
|
||||
buf[offset] = 0
|
||||
buf[offset+1] = 0
|
||||
binary.BigEndian.PutUint16(buf[offset+2:offset+4], g.Offset)
|
||||
offset += 4
|
||||
}
|
||||
if g.KeyPresent {
|
||||
binary.BigEndian.PutUint32(buf[offset:offset+4], g.Key)
|
||||
offset += 4
|
||||
}
|
||||
if g.SeqPresent {
|
||||
binary.BigEndian.PutUint32(buf[offset:offset+4], g.Seq)
|
||||
offset += 4
|
||||
}
|
||||
if g.RoutingPresent {
|
||||
sre := g.GRERouting
|
||||
for sre != nil {
|
||||
binary.BigEndian.PutUint16(buf[offset:offset+2], sre.AddressFamily)
|
||||
buf[offset+2] = sre.SREOffset
|
||||
buf[offset+3] = sre.SRELength
|
||||
copy(buf[offset+4:offset+4+int(sre.SRELength)], sre.RoutingInformation)
|
||||
offset += 4 + int(sre.SRELength)
|
||||
sre = sre.Next
|
||||
}
|
||||
// Terminate routing field with a "NULL" SRE.
|
||||
binary.BigEndian.PutUint32(buf[offset:offset+4], 0)
|
||||
}
|
||||
if g.ChecksumPresent {
|
||||
if opts.ComputeChecksums {
|
||||
g.Checksum = tcpipChecksum(b.Bytes(), 0)
|
||||
}
|
||||
|
||||
binary.BigEndian.PutUint16(buf[4:6], g.Checksum)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (g *GRE) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeGRE
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (g *GRE) NextLayerType() gopacket.LayerType {
|
||||
return g.Protocol.LayerType()
|
||||
}
|
||||
|
||||
func decodeGRE(data []byte, p gopacket.PacketBuilder) error {
|
||||
g := &GRE{}
|
||||
return decodingLayerDecoder(g, data, p)
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,267 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
const (
|
||||
ICMPv4TypeEchoReply = 0
|
||||
ICMPv4TypeDestinationUnreachable = 3
|
||||
ICMPv4TypeSourceQuench = 4
|
||||
ICMPv4TypeRedirect = 5
|
||||
ICMPv4TypeEchoRequest = 8
|
||||
ICMPv4TypeRouterAdvertisement = 9
|
||||
ICMPv4TypeRouterSolicitation = 10
|
||||
ICMPv4TypeTimeExceeded = 11
|
||||
ICMPv4TypeParameterProblem = 12
|
||||
ICMPv4TypeTimestampRequest = 13
|
||||
ICMPv4TypeTimestampReply = 14
|
||||
ICMPv4TypeInfoRequest = 15
|
||||
ICMPv4TypeInfoReply = 16
|
||||
ICMPv4TypeAddressMaskRequest = 17
|
||||
ICMPv4TypeAddressMaskReply = 18
|
||||
)
|
||||
|
||||
const (
|
||||
// DestinationUnreachable
|
||||
ICMPv4CodeNet = 0
|
||||
ICMPv4CodeHost = 1
|
||||
ICMPv4CodeProtocol = 2
|
||||
ICMPv4CodePort = 3
|
||||
ICMPv4CodeFragmentationNeeded = 4
|
||||
ICMPv4CodeSourceRoutingFailed = 5
|
||||
ICMPv4CodeNetUnknown = 6
|
||||
ICMPv4CodeHostUnknown = 7
|
||||
ICMPv4CodeSourceIsolated = 8
|
||||
ICMPv4CodeNetAdminProhibited = 9
|
||||
ICMPv4CodeHostAdminProhibited = 10
|
||||
ICMPv4CodeNetTOS = 11
|
||||
ICMPv4CodeHostTOS = 12
|
||||
ICMPv4CodeCommAdminProhibited = 13
|
||||
ICMPv4CodeHostPrecedence = 14
|
||||
ICMPv4CodePrecedenceCutoff = 15
|
||||
|
||||
// TimeExceeded
|
||||
ICMPv4CodeTTLExceeded = 0
|
||||
ICMPv4CodeFragmentReassemblyTimeExceeded = 1
|
||||
|
||||
// ParameterProblem
|
||||
ICMPv4CodePointerIndicatesError = 0
|
||||
ICMPv4CodeMissingOption = 1
|
||||
ICMPv4CodeBadLength = 2
|
||||
|
||||
// Redirect
|
||||
// ICMPv4CodeNet = same as for DestinationUnreachable
|
||||
// ICMPv4CodeHost = same as for DestinationUnreachable
|
||||
ICMPv4CodeTOSNet = 2
|
||||
ICMPv4CodeTOSHost = 3
|
||||
)
|
||||
|
||||
type icmpv4TypeCodeInfoStruct struct {
|
||||
typeStr string
|
||||
codeStr *map[uint8]string
|
||||
}
|
||||
|
||||
var (
|
||||
icmpv4TypeCodeInfo = map[uint8]icmpv4TypeCodeInfoStruct{
|
||||
ICMPv4TypeDestinationUnreachable: icmpv4TypeCodeInfoStruct{
|
||||
"DestinationUnreachable", &map[uint8]string{
|
||||
ICMPv4CodeNet: "Net",
|
||||
ICMPv4CodeHost: "Host",
|
||||
ICMPv4CodeProtocol: "Protocol",
|
||||
ICMPv4CodePort: "Port",
|
||||
ICMPv4CodeFragmentationNeeded: "FragmentationNeeded",
|
||||
ICMPv4CodeSourceRoutingFailed: "SourceRoutingFailed",
|
||||
ICMPv4CodeNetUnknown: "NetUnknown",
|
||||
ICMPv4CodeHostUnknown: "HostUnknown",
|
||||
ICMPv4CodeSourceIsolated: "SourceIsolated",
|
||||
ICMPv4CodeNetAdminProhibited: "NetAdminProhibited",
|
||||
ICMPv4CodeHostAdminProhibited: "HostAdminProhibited",
|
||||
ICMPv4CodeNetTOS: "NetTOS",
|
||||
ICMPv4CodeHostTOS: "HostTOS",
|
||||
ICMPv4CodeCommAdminProhibited: "CommAdminProhibited",
|
||||
ICMPv4CodeHostPrecedence: "HostPrecedence",
|
||||
ICMPv4CodePrecedenceCutoff: "PrecedenceCutoff",
|
||||
},
|
||||
},
|
||||
ICMPv4TypeTimeExceeded: icmpv4TypeCodeInfoStruct{
|
||||
"TimeExceeded", &map[uint8]string{
|
||||
ICMPv4CodeTTLExceeded: "TTLExceeded",
|
||||
ICMPv4CodeFragmentReassemblyTimeExceeded: "FragmentReassemblyTimeExceeded",
|
||||
},
|
||||
},
|
||||
ICMPv4TypeParameterProblem: icmpv4TypeCodeInfoStruct{
|
||||
"ParameterProblem", &map[uint8]string{
|
||||
ICMPv4CodePointerIndicatesError: "PointerIndicatesError",
|
||||
ICMPv4CodeMissingOption: "MissingOption",
|
||||
ICMPv4CodeBadLength: "BadLength",
|
||||
},
|
||||
},
|
||||
ICMPv4TypeSourceQuench: icmpv4TypeCodeInfoStruct{
|
||||
"SourceQuench", nil,
|
||||
},
|
||||
ICMPv4TypeRedirect: icmpv4TypeCodeInfoStruct{
|
||||
"Redirect", &map[uint8]string{
|
||||
ICMPv4CodeNet: "Net",
|
||||
ICMPv4CodeHost: "Host",
|
||||
ICMPv4CodeTOSNet: "TOS+Net",
|
||||
ICMPv4CodeTOSHost: "TOS+Host",
|
||||
},
|
||||
},
|
||||
ICMPv4TypeEchoRequest: icmpv4TypeCodeInfoStruct{
|
||||
"EchoRequest", nil,
|
||||
},
|
||||
ICMPv4TypeEchoReply: icmpv4TypeCodeInfoStruct{
|
||||
"EchoReply", nil,
|
||||
},
|
||||
ICMPv4TypeTimestampRequest: icmpv4TypeCodeInfoStruct{
|
||||
"TimestampRequest", nil,
|
||||
},
|
||||
ICMPv4TypeTimestampReply: icmpv4TypeCodeInfoStruct{
|
||||
"TimestampReply", nil,
|
||||
},
|
||||
ICMPv4TypeInfoRequest: icmpv4TypeCodeInfoStruct{
|
||||
"InfoRequest", nil,
|
||||
},
|
||||
ICMPv4TypeInfoReply: icmpv4TypeCodeInfoStruct{
|
||||
"InfoReply", nil,
|
||||
},
|
||||
ICMPv4TypeRouterSolicitation: icmpv4TypeCodeInfoStruct{
|
||||
"RouterSolicitation", nil,
|
||||
},
|
||||
ICMPv4TypeRouterAdvertisement: icmpv4TypeCodeInfoStruct{
|
||||
"RouterAdvertisement", nil,
|
||||
},
|
||||
ICMPv4TypeAddressMaskRequest: icmpv4TypeCodeInfoStruct{
|
||||
"AddressMaskRequest", nil,
|
||||
},
|
||||
ICMPv4TypeAddressMaskReply: icmpv4TypeCodeInfoStruct{
|
||||
"AddressMaskReply", nil,
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
type ICMPv4TypeCode uint16
|
||||
|
||||
// Type returns the ICMPv4 type field.
|
||||
func (a ICMPv4TypeCode) Type() uint8 {
|
||||
return uint8(a >> 8)
|
||||
}
|
||||
|
||||
// Code returns the ICMPv4 code field.
|
||||
func (a ICMPv4TypeCode) Code() uint8 {
|
||||
return uint8(a)
|
||||
}
|
||||
|
||||
func (a ICMPv4TypeCode) String() string {
|
||||
t, c := a.Type(), a.Code()
|
||||
strInfo, ok := icmpv4TypeCodeInfo[t]
|
||||
if !ok {
|
||||
// Unknown ICMPv4 type field
|
||||
return fmt.Sprintf("%d(%d)", t, c)
|
||||
}
|
||||
typeStr := strInfo.typeStr
|
||||
if strInfo.codeStr == nil && c == 0 {
|
||||
// The ICMPv4 type does not make use of the code field
|
||||
return fmt.Sprintf("%s", strInfo.typeStr)
|
||||
}
|
||||
if strInfo.codeStr == nil && c != 0 {
|
||||
// The ICMPv4 type does not make use of the code field, but it is present anyway
|
||||
return fmt.Sprintf("%s(Code: %d)", typeStr, c)
|
||||
}
|
||||
codeStr, ok := (*strInfo.codeStr)[c]
|
||||
if !ok {
|
||||
// We don't know this ICMPv4 code; print the numerical value
|
||||
return fmt.Sprintf("%s(Code: %d)", typeStr, c)
|
||||
}
|
||||
return fmt.Sprintf("%s(%s)", typeStr, codeStr)
|
||||
}
|
||||
|
||||
func (a ICMPv4TypeCode) GoString() string {
|
||||
t := reflect.TypeOf(a)
|
||||
return fmt.Sprintf("%s(%d, %d)", t.String(), a.Type(), a.Code())
|
||||
}
|
||||
|
||||
// SerializeTo writes the ICMPv4TypeCode value to the 'bytes' buffer.
|
||||
func (a ICMPv4TypeCode) SerializeTo(bytes []byte) {
|
||||
binary.BigEndian.PutUint16(bytes, uint16(a))
|
||||
}
|
||||
|
||||
// CreateICMPv4TypeCode is a convenience function to create an ICMPv4TypeCode
|
||||
// gopacket type from the ICMPv4 type and code values.
|
||||
func CreateICMPv4TypeCode(typ uint8, code uint8) ICMPv4TypeCode {
|
||||
return ICMPv4TypeCode(binary.BigEndian.Uint16([]byte{typ, code}))
|
||||
}
|
||||
|
||||
// ICMPv4 is the layer for IPv4 ICMP packet data.
|
||||
type ICMPv4 struct {
|
||||
BaseLayer
|
||||
TypeCode ICMPv4TypeCode
|
||||
Checksum uint16
|
||||
Id uint16
|
||||
Seq uint16
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeICMPv4.
|
||||
func (i *ICMPv4) LayerType() gopacket.LayerType { return LayerTypeICMPv4 }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (i *ICMPv4) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
if len(data) < 8 {
|
||||
df.SetTruncated()
|
||||
return errors.New("ICMP layer less then 8 bytes for ICMPv4 packet")
|
||||
}
|
||||
i.TypeCode = CreateICMPv4TypeCode(data[0], data[1])
|
||||
i.Checksum = binary.BigEndian.Uint16(data[2:4])
|
||||
i.Id = binary.BigEndian.Uint16(data[4:6])
|
||||
i.Seq = binary.BigEndian.Uint16(data[6:8])
|
||||
i.BaseLayer = BaseLayer{data[:8], data[8:]}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (i *ICMPv4) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(8)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
i.TypeCode.SerializeTo(bytes)
|
||||
binary.BigEndian.PutUint16(bytes[4:], i.Id)
|
||||
binary.BigEndian.PutUint16(bytes[6:], i.Seq)
|
||||
if opts.ComputeChecksums {
|
||||
bytes[2] = 0
|
||||
bytes[3] = 0
|
||||
i.Checksum = tcpipChecksum(b.Bytes(), 0)
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[2:], i.Checksum)
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (i *ICMPv4) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeICMPv4
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (i *ICMPv4) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
func decodeICMPv4(data []byte, p gopacket.PacketBuilder) error {
|
||||
i := &ICMPv4{}
|
||||
return decodingLayerDecoder(i, data, p)
|
||||
}
|
||||
@ -0,0 +1,231 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"reflect"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
const (
|
||||
// The following are from RFC 4443
|
||||
ICMPv6TypeDestinationUnreachable = 1
|
||||
ICMPv6TypePacketTooBig = 2
|
||||
ICMPv6TypeTimeExceeded = 3
|
||||
ICMPv6TypeParameterProblem = 4
|
||||
ICMPv6TypeEchoRequest = 128
|
||||
ICMPv6TypeEchoReply = 129
|
||||
// The following are from RFC 4861
|
||||
ICMPv6TypeRouterSolicitation = 133
|
||||
ICMPv6TypeRouterAdvertisement = 134
|
||||
ICMPv6TypeNeighborSolicitation = 135
|
||||
ICMPv6TypeNeighborAdvertisement = 136
|
||||
ICMPv6TypeRedirect = 137
|
||||
)
|
||||
|
||||
const (
|
||||
// DestinationUnreachable
|
||||
ICMPv6CodeNoRouteToDst = 0
|
||||
ICMPv6CodeAdminProhibited = 1
|
||||
ICMPv6CodeBeyondScopeOfSrc = 2
|
||||
ICMPv6CodeAddressUnreachable = 3
|
||||
ICMPv6CodePortUnreachable = 4
|
||||
ICMPv6CodeSrcAddressFailedPolicy = 5
|
||||
ICMPv6CodeRejectRouteToDst = 6
|
||||
|
||||
// TimeExceeded
|
||||
ICMPv6CodeHopLimitExceeded = 0
|
||||
ICMPv6CodeFragmentReassemblyTimeExceeded = 1
|
||||
|
||||
// ParameterProblem
|
||||
ICMPv6CodeErroneousHeaderField = 0
|
||||
ICMPv6CodeUnrecognizedNextHeader = 1
|
||||
ICMPv6CodeUnrecognizedIPv6Option = 2
|
||||
)
|
||||
|
||||
type icmpv6TypeCodeInfoStruct struct {
|
||||
typeStr string
|
||||
codeStr *map[uint8]string
|
||||
}
|
||||
|
||||
var (
|
||||
icmpv6TypeCodeInfo = map[uint8]icmpv6TypeCodeInfoStruct{
|
||||
ICMPv6TypeDestinationUnreachable: icmpv6TypeCodeInfoStruct{
|
||||
"DestinationUnreachable", &map[uint8]string{
|
||||
ICMPv6CodeNoRouteToDst: "NoRouteToDst",
|
||||
ICMPv6CodeAdminProhibited: "AdminProhibited",
|
||||
ICMPv6CodeBeyondScopeOfSrc: "BeyondScopeOfSrc",
|
||||
ICMPv6CodeAddressUnreachable: "AddressUnreachable",
|
||||
ICMPv6CodePortUnreachable: "PortUnreachable",
|
||||
ICMPv6CodeSrcAddressFailedPolicy: "SrcAddressFailedPolicy",
|
||||
ICMPv6CodeRejectRouteToDst: "RejectRouteToDst",
|
||||
},
|
||||
},
|
||||
ICMPv6TypePacketTooBig: icmpv6TypeCodeInfoStruct{
|
||||
"PacketTooBig", nil,
|
||||
},
|
||||
ICMPv6TypeTimeExceeded: icmpv6TypeCodeInfoStruct{
|
||||
"TimeExceeded", &map[uint8]string{
|
||||
ICMPv6CodeHopLimitExceeded: "HopLimitExceeded",
|
||||
ICMPv6CodeFragmentReassemblyTimeExceeded: "FragmentReassemblyTimeExceeded",
|
||||
},
|
||||
},
|
||||
ICMPv6TypeParameterProblem: icmpv6TypeCodeInfoStruct{
|
||||
"ParameterProblem", &map[uint8]string{
|
||||
ICMPv6CodeErroneousHeaderField: "ErroneousHeaderField",
|
||||
ICMPv6CodeUnrecognizedNextHeader: "UnrecognizedNextHeader",
|
||||
ICMPv6CodeUnrecognizedIPv6Option: "UnrecognizedIPv6Option",
|
||||
},
|
||||
},
|
||||
ICMPv6TypeEchoRequest: icmpv6TypeCodeInfoStruct{
|
||||
"EchoRequest", nil,
|
||||
},
|
||||
ICMPv6TypeEchoReply: icmpv6TypeCodeInfoStruct{
|
||||
"EchoReply", nil,
|
||||
},
|
||||
ICMPv6TypeRouterSolicitation: icmpv6TypeCodeInfoStruct{
|
||||
"RouterSolicitation", nil,
|
||||
},
|
||||
ICMPv6TypeRouterAdvertisement: icmpv6TypeCodeInfoStruct{
|
||||
"RouterAdvertisement", nil,
|
||||
},
|
||||
ICMPv6TypeNeighborSolicitation: icmpv6TypeCodeInfoStruct{
|
||||
"NeighborSolicitation", nil,
|
||||
},
|
||||
ICMPv6TypeNeighborAdvertisement: icmpv6TypeCodeInfoStruct{
|
||||
"NeighborAdvertisement", nil,
|
||||
},
|
||||
ICMPv6TypeRedirect: icmpv6TypeCodeInfoStruct{
|
||||
"Redirect", nil,
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
type ICMPv6TypeCode uint16
|
||||
|
||||
// Type returns the ICMPv6 type field.
|
||||
func (a ICMPv6TypeCode) Type() uint8 {
|
||||
return uint8(a >> 8)
|
||||
}
|
||||
|
||||
// Code returns the ICMPv6 code field.
|
||||
func (a ICMPv6TypeCode) Code() uint8 {
|
||||
return uint8(a)
|
||||
}
|
||||
|
||||
func (a ICMPv6TypeCode) String() string {
|
||||
t, c := a.Type(), a.Code()
|
||||
strInfo, ok := icmpv6TypeCodeInfo[t]
|
||||
if !ok {
|
||||
// Unknown ICMPv6 type field
|
||||
return fmt.Sprintf("%d(%d)", t, c)
|
||||
}
|
||||
typeStr := strInfo.typeStr
|
||||
if strInfo.codeStr == nil && c == 0 {
|
||||
// The ICMPv6 type does not make use of the code field
|
||||
return fmt.Sprintf("%s", strInfo.typeStr)
|
||||
}
|
||||
if strInfo.codeStr == nil && c != 0 {
|
||||
// The ICMPv6 type does not make use of the code field, but it is present anyway
|
||||
return fmt.Sprintf("%s(Code: %d)", typeStr, c)
|
||||
}
|
||||
codeStr, ok := (*strInfo.codeStr)[c]
|
||||
if !ok {
|
||||
// We don't know this ICMPv6 code; print the numerical value
|
||||
return fmt.Sprintf("%s(Code: %d)", typeStr, c)
|
||||
}
|
||||
return fmt.Sprintf("%s(%s)", typeStr, codeStr)
|
||||
}
|
||||
|
||||
func (a ICMPv6TypeCode) GoString() string {
|
||||
t := reflect.TypeOf(a)
|
||||
return fmt.Sprintf("%s(%d, %d)", t.String(), a.Type(), a.Code())
|
||||
}
|
||||
|
||||
// SerializeTo writes the ICMPv6TypeCode value to the 'bytes' buffer.
|
||||
func (a ICMPv6TypeCode) SerializeTo(bytes []byte) {
|
||||
binary.BigEndian.PutUint16(bytes, uint16(a))
|
||||
}
|
||||
|
||||
// CreateICMPv6TypeCode is a convenience function to create an ICMPv6TypeCode
|
||||
// gopacket type from the ICMPv6 type and code values.
|
||||
func CreateICMPv6TypeCode(typ uint8, code uint8) ICMPv6TypeCode {
|
||||
return ICMPv6TypeCode(binary.BigEndian.Uint16([]byte{typ, code}))
|
||||
}
|
||||
|
||||
// ICMPv6 is the layer for IPv6 ICMP packet data
|
||||
type ICMPv6 struct {
|
||||
BaseLayer
|
||||
TypeCode ICMPv6TypeCode
|
||||
Checksum uint16
|
||||
TypeBytes []byte
|
||||
tcpipchecksum
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeICMPv6.
|
||||
func (i *ICMPv6) LayerType() gopacket.LayerType { return LayerTypeICMPv6 }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (i *ICMPv6) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
if len(data) < 8 {
|
||||
df.SetTruncated()
|
||||
return errors.New("ICMP layer less then 8 bytes for ICMPv6 packet")
|
||||
}
|
||||
i.TypeCode = CreateICMPv6TypeCode(data[0], data[1])
|
||||
i.Checksum = binary.BigEndian.Uint16(data[2:4])
|
||||
i.TypeBytes = data[4:8]
|
||||
i.BaseLayer = BaseLayer{data[:8], data[8:]}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (i *ICMPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
if i.TypeBytes == nil {
|
||||
i.TypeBytes = lotsOfZeros[:4]
|
||||
} else if len(i.TypeBytes) != 4 {
|
||||
return fmt.Errorf("invalid type bytes for ICMPv6 packet: %v", i.TypeBytes)
|
||||
}
|
||||
bytes, err := b.PrependBytes(8)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
i.TypeCode.SerializeTo(bytes)
|
||||
copy(bytes[4:8], i.TypeBytes)
|
||||
if opts.ComputeChecksums {
|
||||
bytes[2] = 0
|
||||
bytes[3] = 0
|
||||
csum, err := i.computeChecksum(b.Bytes(), IPProtocolICMPv6)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
i.Checksum = csum
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[2:], i.Checksum)
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (i *ICMPv6) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeICMPv6
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (i *ICMPv6) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
func decodeICMPv6(data []byte, p gopacket.PacketBuilder) error {
|
||||
i := &ICMPv6{}
|
||||
return decodingLayerDecoder(i, data, p)
|
||||
}
|
||||
@ -0,0 +1,355 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"net"
|
||||
"time"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
type IGMPType uint8
|
||||
|
||||
const (
|
||||
IGMPMembershipQuery IGMPType = 0x11 // General or group specific query
|
||||
IGMPMembershipReportV1 IGMPType = 0x12 // Version 1 Membership Report
|
||||
IGMPMembershipReportV2 IGMPType = 0x16 // Version 2 Membership Report
|
||||
IGMPLeaveGroup IGMPType = 0x17 // Leave Group
|
||||
IGMPMembershipReportV3 IGMPType = 0x22 // Version 3 Membership Report
|
||||
)
|
||||
|
||||
// String conversions for IGMP message types
|
||||
func (i IGMPType) String() string {
|
||||
switch i {
|
||||
case IGMPMembershipQuery:
|
||||
return "IGMP Membership Query"
|
||||
case IGMPMembershipReportV1:
|
||||
return "IGMPv1 Membership Report"
|
||||
case IGMPMembershipReportV2:
|
||||
return "IGMPv2 Membership Report"
|
||||
case IGMPMembershipReportV3:
|
||||
return "IGMPv3 Membership Report"
|
||||
case IGMPLeaveGroup:
|
||||
return "Leave Group"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
type IGMPv3GroupRecordType uint8
|
||||
|
||||
const (
|
||||
IGMPIsIn IGMPv3GroupRecordType = 0x01 // Type MODE_IS_INCLUDE, source addresses x
|
||||
IGMPIsEx IGMPv3GroupRecordType = 0x02 // Type MODE_IS_EXCLUDE, source addresses x
|
||||
IGMPToIn IGMPv3GroupRecordType = 0x03 // Type CHANGE_TO_INCLUDE_MODE, source addresses x
|
||||
IGMPToEx IGMPv3GroupRecordType = 0x04 // Type CHANGE_TO_EXCLUDE_MODE, source addresses x
|
||||
IGMPAllow IGMPv3GroupRecordType = 0x05 // Type ALLOW_NEW_SOURCES, source addresses x
|
||||
IGMPBlock IGMPv3GroupRecordType = 0x06 // Type BLOCK_OLD_SOURCES, source addresses x
|
||||
)
|
||||
|
||||
func (i IGMPv3GroupRecordType) String() string {
|
||||
switch i {
|
||||
case IGMPIsIn:
|
||||
return "MODE_IS_INCLUDE"
|
||||
case IGMPIsEx:
|
||||
return "MODE_IS_EXCLUDE"
|
||||
case IGMPToIn:
|
||||
return "CHANGE_TO_INCLUDE_MODE"
|
||||
case IGMPToEx:
|
||||
return "CHANGE_TO_EXCLUDE_MODE"
|
||||
case IGMPAllow:
|
||||
return "ALLOW_NEW_SOURCES"
|
||||
case IGMPBlock:
|
||||
return "BLOCK_OLD_SOURCES"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
// IGMP represents an IGMPv3 message.
|
||||
type IGMP struct {
|
||||
BaseLayer
|
||||
Type IGMPType
|
||||
MaxResponseTime time.Duration
|
||||
Checksum uint16
|
||||
GroupAddress net.IP
|
||||
SupressRouterProcessing bool
|
||||
RobustnessValue uint8
|
||||
IntervalTime time.Duration
|
||||
SourceAddresses []net.IP
|
||||
NumberOfGroupRecords uint16
|
||||
NumberOfSources uint16
|
||||
GroupRecords []IGMPv3GroupRecord
|
||||
Version uint8 // IGMP protocol version
|
||||
}
|
||||
|
||||
// IGMPv1or2 stores header details for an IGMPv1 or IGMPv2 packet.
|
||||
//
|
||||
// 0 1 2 3
|
||||
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Type | Max Resp Time | Checksum |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Group Address |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
type IGMPv1or2 struct {
|
||||
BaseLayer
|
||||
Type IGMPType // IGMP message type
|
||||
MaxResponseTime time.Duration // meaningful only in Membership Query messages
|
||||
Checksum uint16 // 16-bit checksum of entire ip payload
|
||||
GroupAddress net.IP // either 0 or an IP multicast address
|
||||
Version uint8
|
||||
}
|
||||
|
||||
// decodeResponse dissects IGMPv1 or IGMPv2 packet.
|
||||
func (i *IGMPv1or2) decodeResponse(data []byte) error {
|
||||
if len(data) < 8 {
|
||||
return errors.New("IGMP packet too small")
|
||||
}
|
||||
|
||||
i.MaxResponseTime = igmpTimeDecode(data[1])
|
||||
i.Checksum = binary.BigEndian.Uint16(data[2:4])
|
||||
i.GroupAddress = net.IP(data[4:8])
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// 0 1 2 3
|
||||
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Type = 0x22 | Reserved | Checksum |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Reserved | Number of Group Records (M) |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// . Group Record [1] .
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// . Group Record [2] .
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// . Group Record [M] .
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Record Type | Aux Data Len | Number of Sources (N) |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Multicast Address |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Source Address [1] |
|
||||
// +- -+
|
||||
// | Source Address [2] |
|
||||
// +- -+
|
||||
// | Source Address [N] |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// . Auxiliary Data .
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
|
||||
// IGMPv3GroupRecord stores individual group records for a V3 Membership Report message.
|
||||
type IGMPv3GroupRecord struct {
|
||||
Type IGMPv3GroupRecordType
|
||||
AuxDataLen uint8 // this should always be 0 as per IGMPv3 spec.
|
||||
NumberOfSources uint16
|
||||
MulticastAddress net.IP
|
||||
SourceAddresses []net.IP
|
||||
AuxData uint32 // NOT USED
|
||||
}
|
||||
|
||||
func (i *IGMP) decodeIGMPv3MembershipReport(data []byte) error {
|
||||
if len(data) < 8 {
|
||||
return errors.New("IGMPv3 Membership Report too small #1")
|
||||
}
|
||||
|
||||
i.Checksum = binary.BigEndian.Uint16(data[2:4])
|
||||
i.NumberOfGroupRecords = binary.BigEndian.Uint16(data[6:8])
|
||||
|
||||
recordOffset := 8
|
||||
for j := 0; j < int(i.NumberOfGroupRecords); j++ {
|
||||
if len(data) < recordOffset+8 {
|
||||
return errors.New("IGMPv3 Membership Report too small #2")
|
||||
}
|
||||
|
||||
var gr IGMPv3GroupRecord
|
||||
gr.Type = IGMPv3GroupRecordType(data[recordOffset])
|
||||
gr.AuxDataLen = data[recordOffset+1]
|
||||
gr.NumberOfSources = binary.BigEndian.Uint16(data[recordOffset+2 : recordOffset+4])
|
||||
gr.MulticastAddress = net.IP(data[recordOffset+4 : recordOffset+8])
|
||||
|
||||
if len(data) < recordOffset+8+int(gr.NumberOfSources)*4 {
|
||||
return errors.New("IGMPv3 Membership Report too small #3")
|
||||
}
|
||||
|
||||
// append source address records.
|
||||
for i := 0; i < int(gr.NumberOfSources); i++ {
|
||||
sourceAddr := net.IP(data[recordOffset+8+i*4 : recordOffset+12+i*4])
|
||||
gr.SourceAddresses = append(gr.SourceAddresses, sourceAddr)
|
||||
}
|
||||
|
||||
i.GroupRecords = append(i.GroupRecords, gr)
|
||||
recordOffset += 8 + 4*int(gr.NumberOfSources)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// 0 1 2 3
|
||||
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Type = 0x11 | Max Resp Code | Checksum |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Group Address |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Resv |S| QRV | QQIC | Number of Sources (N) |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Source Address [1] |
|
||||
// +- -+
|
||||
// | Source Address [2] |
|
||||
// +- . -+
|
||||
// | Source Address [N] |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
//
|
||||
// decodeIGMPv3MembershipQuery parses the IGMPv3 message of type 0x11
|
||||
func (i *IGMP) decodeIGMPv3MembershipQuery(data []byte) error {
|
||||
if len(data) < 12 {
|
||||
return errors.New("IGMPv3 Membership Query too small #1")
|
||||
}
|
||||
|
||||
i.MaxResponseTime = igmpTimeDecode(data[1])
|
||||
i.Checksum = binary.BigEndian.Uint16(data[2:4])
|
||||
i.SupressRouterProcessing = data[8]&0x8 != 0
|
||||
i.GroupAddress = net.IP(data[4:8])
|
||||
i.RobustnessValue = data[8] & 0x7
|
||||
i.IntervalTime = igmpTimeDecode(data[9])
|
||||
i.NumberOfSources = binary.BigEndian.Uint16(data[10:12])
|
||||
|
||||
if len(data) < 12+int(i.NumberOfSources)*4 {
|
||||
return errors.New("IGMPv3 Membership Query too small #2")
|
||||
}
|
||||
|
||||
for j := 0; j < int(i.NumberOfSources); j++ {
|
||||
i.SourceAddresses = append(i.SourceAddresses, net.IP(data[12+j*4:16+j*4]))
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// igmpTimeDecode decodes the duration created by the given byte, using the
|
||||
// algorithm in http://www.rfc-base.org/txt/rfc-3376.txt section 4.1.1.
|
||||
func igmpTimeDecode(t uint8) time.Duration {
|
||||
if t&0x80 == 0 {
|
||||
return time.Millisecond * 100 * time.Duration(t)
|
||||
}
|
||||
mant := (t & 0x70) >> 4
|
||||
exp := t & 0x0F
|
||||
return time.Millisecond * 100 * time.Duration((mant|0x10)<<(exp+3))
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIGMP for the V1,2,3 message protocol formats.
|
||||
func (i *IGMP) LayerType() gopacket.LayerType { return LayerTypeIGMP }
|
||||
func (i *IGMPv1or2) LayerType() gopacket.LayerType { return LayerTypeIGMP }
|
||||
|
||||
func (i *IGMPv1or2) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
if len(data) < 8 {
|
||||
return errors.New("IGMP Packet too small")
|
||||
}
|
||||
|
||||
i.Type = IGMPType(data[0])
|
||||
i.MaxResponseTime = igmpTimeDecode(data[1])
|
||||
i.Checksum = binary.BigEndian.Uint16(data[2:4])
|
||||
i.GroupAddress = net.IP(data[4:8])
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (i *IGMPv1or2) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypeZero
|
||||
}
|
||||
|
||||
func (i *IGMPv1or2) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeIGMP
|
||||
}
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (i *IGMP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
if len(data) < 1 {
|
||||
return errors.New("IGMP packet is too small")
|
||||
}
|
||||
|
||||
// common IGMP header values between versions 1..3 of IGMP specification..
|
||||
i.Type = IGMPType(data[0])
|
||||
|
||||
switch i.Type {
|
||||
case IGMPMembershipQuery:
|
||||
i.decodeIGMPv3MembershipQuery(data)
|
||||
case IGMPMembershipReportV3:
|
||||
i.decodeIGMPv3MembershipReport(data)
|
||||
default:
|
||||
return errors.New("unsupported IGMP type")
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (i *IGMP) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeIGMP
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (i *IGMP) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypeZero
|
||||
}
|
||||
|
||||
// decodeIGMP will parse IGMP v1,2 or 3 protocols. Checks against the
|
||||
// IGMP type are performed against byte[0], logic then iniitalizes and
|
||||
// passes the appropriate struct (IGMP or IGMPv1or2) to
|
||||
// decodingLayerDecoder.
|
||||
func decodeIGMP(data []byte, p gopacket.PacketBuilder) error {
|
||||
if len(data) < 1 {
|
||||
return errors.New("IGMP packet is too small")
|
||||
}
|
||||
|
||||
// byte 0 contains IGMP message type.
|
||||
switch IGMPType(data[0]) {
|
||||
case IGMPMembershipQuery:
|
||||
// IGMPv3 Membership Query payload is >= 12
|
||||
if len(data) >= 12 {
|
||||
i := &IGMP{Version: 3}
|
||||
return decodingLayerDecoder(i, data, p)
|
||||
} else if len(data) == 8 {
|
||||
i := &IGMPv1or2{}
|
||||
if data[1] == 0x00 {
|
||||
i.Version = 1 // IGMPv1 has a query length of 8 and MaxResp = 0
|
||||
} else {
|
||||
i.Version = 2 // IGMPv2 has a query length of 8 and MaxResp != 0
|
||||
}
|
||||
|
||||
return decodingLayerDecoder(i, data, p)
|
||||
}
|
||||
case IGMPMembershipReportV3:
|
||||
i := &IGMP{Version: 3}
|
||||
return decodingLayerDecoder(i, data, p)
|
||||
case IGMPMembershipReportV1:
|
||||
i := &IGMPv1or2{Version: 1}
|
||||
return decodingLayerDecoder(i, data, p)
|
||||
case IGMPLeaveGroup, IGMPMembershipReportV2:
|
||||
// leave group and Query Report v2 used in IGMPv2 only.
|
||||
i := &IGMPv1or2{Version: 2}
|
||||
return decodingLayerDecoder(i, data, p)
|
||||
default:
|
||||
}
|
||||
|
||||
return errors.New("Unable to determine IGMP type.")
|
||||
}
|
||||
@ -0,0 +1,311 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"strings"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
type IPv4Flag uint8
|
||||
|
||||
const (
|
||||
IPv4EvilBit IPv4Flag = 1 << 2 // http://tools.ietf.org/html/rfc3514 ;)
|
||||
IPv4DontFragment IPv4Flag = 1 << 1
|
||||
IPv4MoreFragments IPv4Flag = 1 << 0
|
||||
)
|
||||
|
||||
func (f IPv4Flag) String() string {
|
||||
var s []string
|
||||
if f&IPv4EvilBit != 0 {
|
||||
s = append(s, "Evil")
|
||||
}
|
||||
if f&IPv4DontFragment != 0 {
|
||||
s = append(s, "DF")
|
||||
}
|
||||
if f&IPv4MoreFragments != 0 {
|
||||
s = append(s, "MF")
|
||||
}
|
||||
return strings.Join(s, "|")
|
||||
}
|
||||
|
||||
// IPv4 is the header of an IP packet.
|
||||
type IPv4 struct {
|
||||
BaseLayer
|
||||
Version uint8
|
||||
IHL uint8
|
||||
TOS uint8
|
||||
Length uint16
|
||||
Id uint16
|
||||
Flags IPv4Flag
|
||||
FragOffset uint16
|
||||
TTL uint8
|
||||
Protocol IPProtocol
|
||||
Checksum uint16
|
||||
SrcIP net.IP
|
||||
DstIP net.IP
|
||||
Options []IPv4Option
|
||||
Padding []byte
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIPv4
|
||||
func (i *IPv4) LayerType() gopacket.LayerType { return LayerTypeIPv4 }
|
||||
func (i *IPv4) NetworkFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointIPv4, i.SrcIP, i.DstIP)
|
||||
}
|
||||
|
||||
type IPv4Option struct {
|
||||
OptionType uint8
|
||||
OptionLength uint8
|
||||
OptionData []byte
|
||||
}
|
||||
|
||||
func (i IPv4Option) String() string {
|
||||
return fmt.Sprintf("IPv4Option(%v:%v)", i.OptionType, i.OptionData)
|
||||
}
|
||||
|
||||
// for the current ipv4 options, return the number of bytes (including
|
||||
// padding that the options used)
|
||||
func (ip *IPv4) getIPv4OptionSize() uint8 {
|
||||
optionSize := uint8(0)
|
||||
for _, opt := range ip.Options {
|
||||
switch opt.OptionType {
|
||||
case 0:
|
||||
// this is the end of option lists
|
||||
optionSize++
|
||||
case 1:
|
||||
// this is the padding
|
||||
optionSize++
|
||||
default:
|
||||
optionSize += opt.OptionLength
|
||||
|
||||
}
|
||||
}
|
||||
// make sure the options are aligned to 32 bit boundary
|
||||
if (optionSize % 4) != 0 {
|
||||
optionSize += 4 - (optionSize % 4)
|
||||
}
|
||||
return optionSize
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
func (ip *IPv4) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
optionLength := ip.getIPv4OptionSize()
|
||||
bytes, err := b.PrependBytes(20 + int(optionLength))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if opts.FixLengths {
|
||||
ip.IHL = 5 + (optionLength / 4)
|
||||
ip.Length = uint16(len(b.Bytes()))
|
||||
}
|
||||
bytes[0] = (ip.Version << 4) | ip.IHL
|
||||
bytes[1] = ip.TOS
|
||||
binary.BigEndian.PutUint16(bytes[2:], ip.Length)
|
||||
binary.BigEndian.PutUint16(bytes[4:], ip.Id)
|
||||
binary.BigEndian.PutUint16(bytes[6:], ip.flagsfrags())
|
||||
bytes[8] = ip.TTL
|
||||
bytes[9] = byte(ip.Protocol)
|
||||
if err := ip.AddressTo4(); err != nil {
|
||||
return err
|
||||
}
|
||||
copy(bytes[12:16], ip.SrcIP)
|
||||
copy(bytes[16:20], ip.DstIP)
|
||||
|
||||
curLocation := 20
|
||||
// Now, we will encode the options
|
||||
for _, opt := range ip.Options {
|
||||
switch opt.OptionType {
|
||||
case 0:
|
||||
// this is the end of option lists
|
||||
bytes[curLocation] = 0
|
||||
curLocation++
|
||||
case 1:
|
||||
// this is the padding
|
||||
bytes[curLocation] = 1
|
||||
curLocation++
|
||||
default:
|
||||
bytes[curLocation] = opt.OptionType
|
||||
bytes[curLocation+1] = opt.OptionLength
|
||||
|
||||
// sanity checking to protect us from buffer overrun
|
||||
if len(opt.OptionData) > int(opt.OptionLength-2) {
|
||||
return errors.New("option length is smaller than length of option data")
|
||||
}
|
||||
copy(bytes[curLocation+2:curLocation+int(opt.OptionLength)], opt.OptionData)
|
||||
curLocation += int(opt.OptionLength)
|
||||
}
|
||||
}
|
||||
|
||||
if opts.ComputeChecksums {
|
||||
ip.Checksum = checksum(bytes)
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[10:], ip.Checksum)
|
||||
return nil
|
||||
}
|
||||
|
||||
func checksum(bytes []byte) uint16 {
|
||||
// Clear checksum bytes
|
||||
bytes[10] = 0
|
||||
bytes[11] = 0
|
||||
|
||||
// Compute checksum
|
||||
var csum uint32
|
||||
for i := 0; i < len(bytes); i += 2 {
|
||||
csum += uint32(bytes[i]) << 8
|
||||
csum += uint32(bytes[i+1])
|
||||
}
|
||||
for {
|
||||
// Break when sum is less or equals to 0xFFFF
|
||||
if csum <= 65535 {
|
||||
break
|
||||
}
|
||||
// Add carry to the sum
|
||||
csum = (csum >> 16) + uint32(uint16(csum))
|
||||
}
|
||||
// Flip all the bits
|
||||
return ^uint16(csum)
|
||||
}
|
||||
|
||||
func (ip *IPv4) flagsfrags() (ff uint16) {
|
||||
ff |= uint16(ip.Flags) << 13
|
||||
ff |= ip.FragOffset
|
||||
return
|
||||
}
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (ip *IPv4) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
flagsfrags := binary.BigEndian.Uint16(data[6:8])
|
||||
|
||||
ip.Version = uint8(data[0]) >> 4
|
||||
ip.IHL = uint8(data[0]) & 0x0F
|
||||
ip.TOS = data[1]
|
||||
ip.Length = binary.BigEndian.Uint16(data[2:4])
|
||||
ip.Id = binary.BigEndian.Uint16(data[4:6])
|
||||
ip.Flags = IPv4Flag(flagsfrags >> 13)
|
||||
ip.FragOffset = flagsfrags & 0x1FFF
|
||||
ip.TTL = data[8]
|
||||
ip.Protocol = IPProtocol(data[9])
|
||||
ip.Checksum = binary.BigEndian.Uint16(data[10:12])
|
||||
ip.SrcIP = data[12:16]
|
||||
ip.DstIP = data[16:20]
|
||||
ip.Options = ip.Options[:0]
|
||||
// Set up an initial guess for contents/payload... we'll reset these soon.
|
||||
ip.BaseLayer = BaseLayer{Contents: data}
|
||||
|
||||
// This code is added for the following enviroment:
|
||||
// * Windows 10 with TSO option activated. ( tested on Hyper-V, RealTek ethernet driver )
|
||||
if ip.Length == 0 {
|
||||
// If using TSO(TCP Segmentation Offload), length is zero.
|
||||
// The actual packet length is the length of data.
|
||||
ip.Length = uint16(len(data))
|
||||
}
|
||||
|
||||
if ip.Length < 20 {
|
||||
return fmt.Errorf("Invalid (too small) IP length (%d < 20)", ip.Length)
|
||||
} else if ip.IHL < 5 {
|
||||
return fmt.Errorf("Invalid (too small) IP header length (%d < 5)", ip.IHL)
|
||||
} else if int(ip.IHL*4) > int(ip.Length) {
|
||||
return fmt.Errorf("Invalid IP header length > IP length (%d > %d)", ip.IHL, ip.Length)
|
||||
}
|
||||
if cmp := len(data) - int(ip.Length); cmp > 0 {
|
||||
data = data[:ip.Length]
|
||||
} else if cmp < 0 {
|
||||
df.SetTruncated()
|
||||
if int(ip.IHL)*4 > len(data) {
|
||||
return errors.New("Not all IP header bytes available")
|
||||
}
|
||||
}
|
||||
ip.Contents = data[:ip.IHL*4]
|
||||
ip.Payload = data[ip.IHL*4:]
|
||||
// From here on, data contains the header options.
|
||||
data = data[20 : ip.IHL*4]
|
||||
// Pull out IP options
|
||||
for len(data) > 0 {
|
||||
if ip.Options == nil {
|
||||
// Pre-allocate to avoid growing the slice too much.
|
||||
ip.Options = make([]IPv4Option, 0, 4)
|
||||
}
|
||||
opt := IPv4Option{OptionType: data[0]}
|
||||
switch opt.OptionType {
|
||||
case 0: // End of options
|
||||
opt.OptionLength = 1
|
||||
ip.Options = append(ip.Options, opt)
|
||||
ip.Padding = data[1:]
|
||||
break
|
||||
case 1: // 1 byte padding
|
||||
opt.OptionLength = 1
|
||||
default:
|
||||
opt.OptionLength = data[1]
|
||||
opt.OptionData = data[2:opt.OptionLength]
|
||||
}
|
||||
if len(data) >= int(opt.OptionLength) {
|
||||
data = data[opt.OptionLength:]
|
||||
} else {
|
||||
return fmt.Errorf("IP option length exceeds remaining IP header size, option type %v length %v", opt.OptionType, opt.OptionLength)
|
||||
}
|
||||
ip.Options = append(ip.Options, opt)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (i *IPv4) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeIPv4
|
||||
}
|
||||
|
||||
func (i *IPv4) NextLayerType() gopacket.LayerType {
|
||||
if i.Flags&IPv4MoreFragments != 0 || i.FragOffset != 0 {
|
||||
return gopacket.LayerTypeFragment
|
||||
}
|
||||
return i.Protocol.LayerType()
|
||||
}
|
||||
|
||||
func decodeIPv4(data []byte, p gopacket.PacketBuilder) error {
|
||||
ip := &IPv4{}
|
||||
err := ip.DecodeFromBytes(data, p)
|
||||
p.AddLayer(ip)
|
||||
p.SetNetworkLayer(ip)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return p.NextDecoder(ip.NextLayerType())
|
||||
}
|
||||
|
||||
func checkIPv4Address(addr net.IP) (net.IP, error) {
|
||||
if c := addr.To4(); c != nil {
|
||||
return c, nil
|
||||
}
|
||||
if len(addr) == net.IPv6len {
|
||||
return nil, errors.New("address is IPv6")
|
||||
}
|
||||
return nil, fmt.Errorf("wrong length of %d bytes instead of %d", len(addr), net.IPv4len)
|
||||
}
|
||||
|
||||
func (ip *IPv4) AddressTo4() error {
|
||||
var src, dst net.IP
|
||||
|
||||
if addr, err := checkIPv4Address(ip.SrcIP); err != nil {
|
||||
return fmt.Errorf("Invalid source IPv4 address (%s)", err)
|
||||
} else {
|
||||
src = addr
|
||||
}
|
||||
if addr, err := checkIPv4Address(ip.DstIP); err != nil {
|
||||
return fmt.Errorf("Invalid destination IPv4 address (%s)", err)
|
||||
} else {
|
||||
dst = addr
|
||||
}
|
||||
ip.SrcIP = src
|
||||
ip.DstIP = dst
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,650 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
const (
|
||||
IPv6HopByHopOptionJumbogram = 0xC2 // RFC 2675
|
||||
)
|
||||
|
||||
const (
|
||||
ipv6MaxPayloadLength = 65535
|
||||
)
|
||||
|
||||
// IPv6 is the layer for the IPv6 header.
|
||||
type IPv6 struct {
|
||||
// http://www.networksorcery.com/enp/protocol/ipv6.htm
|
||||
BaseLayer
|
||||
Version uint8
|
||||
TrafficClass uint8
|
||||
FlowLabel uint32
|
||||
Length uint16
|
||||
NextHeader IPProtocol
|
||||
HopLimit uint8
|
||||
SrcIP net.IP
|
||||
DstIP net.IP
|
||||
HopByHop *IPv6HopByHop
|
||||
// hbh will be pointed to by HopByHop if that layer exists.
|
||||
hbh IPv6HopByHop
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIPv6
|
||||
func (i *IPv6) LayerType() gopacket.LayerType { return LayerTypeIPv6 }
|
||||
|
||||
func (i *IPv6) NetworkFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointIPv6, i.SrcIP, i.DstIP)
|
||||
}
|
||||
|
||||
// Search for Jumbo Payload TLV in IPv6HopByHop and return (length, true) if found
|
||||
func getIPv6HopByHopJumboLength(hopopts *IPv6HopByHop) (uint32, bool, error) {
|
||||
var tlv *IPv6HopByHopOption
|
||||
|
||||
for _, t := range hopopts.Options {
|
||||
if t.OptionType == IPv6HopByHopOptionJumbogram {
|
||||
tlv = t
|
||||
break
|
||||
}
|
||||
}
|
||||
if tlv == nil {
|
||||
// Not found
|
||||
return 0, false, nil
|
||||
}
|
||||
if len(tlv.OptionData) != 4 {
|
||||
return 0, false, errors.New("Jumbo length TLV data must have length 4")
|
||||
}
|
||||
l := binary.BigEndian.Uint32(tlv.OptionData)
|
||||
if l <= ipv6MaxPayloadLength {
|
||||
return 0, false, fmt.Errorf("Jumbo length cannot be less than %d", ipv6MaxPayloadLength+1)
|
||||
}
|
||||
// Found
|
||||
return l, true, nil
|
||||
}
|
||||
|
||||
// Adds zero-valued Jumbo TLV to IPv6 header if it does not exist
|
||||
// (if necessary add hop-by-hop header)
|
||||
func addIPv6JumboOption(ip6 *IPv6) {
|
||||
var tlv *IPv6HopByHopOption
|
||||
|
||||
if ip6.HopByHop == nil {
|
||||
// Add IPv6 HopByHop
|
||||
ip6.HopByHop = &IPv6HopByHop{}
|
||||
ip6.HopByHop.NextHeader = ip6.NextHeader
|
||||
ip6.HopByHop.HeaderLength = 0
|
||||
ip6.NextHeader = IPProtocolIPv6HopByHop
|
||||
}
|
||||
for _, t := range ip6.HopByHop.Options {
|
||||
if t.OptionType == IPv6HopByHopOptionJumbogram {
|
||||
tlv = t
|
||||
break
|
||||
}
|
||||
}
|
||||
if tlv == nil {
|
||||
// Add Jumbo TLV
|
||||
tlv = &IPv6HopByHopOption{}
|
||||
ip6.HopByHop.Options = append(ip6.HopByHop.Options, tlv)
|
||||
}
|
||||
tlv.SetJumboLength(0)
|
||||
}
|
||||
|
||||
// Set jumbo length in serialized IPv6 payload (starting with HopByHop header)
|
||||
func setIPv6PayloadJumboLength(hbh []byte) error {
|
||||
pLen := len(hbh)
|
||||
if pLen < 8 {
|
||||
//HopByHop is minimum 8 bytes
|
||||
return fmt.Errorf("Invalid IPv6 payload (length %d)", pLen)
|
||||
}
|
||||
hbhLen := int((hbh[1] + 1) * 8)
|
||||
if hbhLen > pLen {
|
||||
return fmt.Errorf("Invalid hop-by-hop length (length: %d, payload: %d", hbhLen, pLen)
|
||||
}
|
||||
offset := 2 //start with options
|
||||
for offset < hbhLen {
|
||||
opt := hbh[offset]
|
||||
if opt == 0 {
|
||||
//Pad1
|
||||
offset += 1
|
||||
continue
|
||||
}
|
||||
optLen := int(hbh[offset+1])
|
||||
if opt == IPv6HopByHopOptionJumbogram {
|
||||
if optLen == 4 {
|
||||
binary.BigEndian.PutUint32(hbh[offset+2:], uint32(pLen))
|
||||
return nil
|
||||
}
|
||||
return fmt.Errorf("Jumbo TLV too short (%d bytes)", optLen)
|
||||
}
|
||||
offset += 2 + optLen
|
||||
}
|
||||
return errors.New("Jumbo TLV not found")
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (ip6 *IPv6) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var jumbo bool
|
||||
var err error
|
||||
|
||||
payload := b.Bytes()
|
||||
pLen := len(payload)
|
||||
if pLen > ipv6MaxPayloadLength {
|
||||
jumbo = true
|
||||
if opts.FixLengths {
|
||||
// We need to set the length later because the hop-by-hop header may
|
||||
// not exist or else need padding, so pLen may yet change
|
||||
addIPv6JumboOption(ip6)
|
||||
} else if ip6.HopByHop == nil {
|
||||
return fmt.Errorf("Cannot fit payload length of %d into IPv6 packet", pLen)
|
||||
} else {
|
||||
_, ok, err := getIPv6HopByHopJumboLength(ip6.HopByHop)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !ok {
|
||||
return errors.New("Missing jumbo length hop-by-hop option")
|
||||
}
|
||||
}
|
||||
}
|
||||
if ip6.HopByHop != nil {
|
||||
if ip6.NextHeader != IPProtocolIPv6HopByHop {
|
||||
// Just fix it instead of throwing an error
|
||||
ip6.NextHeader = IPProtocolIPv6HopByHop
|
||||
}
|
||||
err = ip6.HopByHop.SerializeTo(b, opts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
payload = b.Bytes()
|
||||
pLen = len(payload)
|
||||
if opts.FixLengths && jumbo {
|
||||
err := setIPv6PayloadJumboLength(payload)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
if !jumbo && pLen > ipv6MaxPayloadLength {
|
||||
return errors.New("Cannot fit payload into IPv6 header")
|
||||
}
|
||||
bytes, err := b.PrependBytes(40)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = (ip6.Version << 4) | (ip6.TrafficClass >> 4)
|
||||
bytes[1] = (ip6.TrafficClass << 4) | uint8(ip6.FlowLabel>>16)
|
||||
binary.BigEndian.PutUint16(bytes[2:], uint16(ip6.FlowLabel))
|
||||
if opts.FixLengths {
|
||||
if jumbo {
|
||||
ip6.Length = 0
|
||||
} else {
|
||||
ip6.Length = uint16(pLen)
|
||||
}
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[4:], ip6.Length)
|
||||
bytes[6] = byte(ip6.NextHeader)
|
||||
bytes[7] = byte(ip6.HopLimit)
|
||||
if err := ip6.AddressTo16(); err != nil {
|
||||
return err
|
||||
}
|
||||
copy(bytes[8:], ip6.SrcIP)
|
||||
copy(bytes[24:], ip6.DstIP)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (ip6 *IPv6) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
ip6.Version = uint8(data[0]) >> 4
|
||||
ip6.TrafficClass = uint8((binary.BigEndian.Uint16(data[0:2]) >> 4) & 0x00FF)
|
||||
ip6.FlowLabel = binary.BigEndian.Uint32(data[0:4]) & 0x000FFFFF
|
||||
ip6.Length = binary.BigEndian.Uint16(data[4:6])
|
||||
ip6.NextHeader = IPProtocol(data[6])
|
||||
ip6.HopLimit = data[7]
|
||||
ip6.SrcIP = data[8:24]
|
||||
ip6.DstIP = data[24:40]
|
||||
ip6.HopByHop = nil
|
||||
ip6.BaseLayer = BaseLayer{data[:40], data[40:]}
|
||||
|
||||
// We treat a HopByHop IPv6 option as part of the IPv6 packet, since its
|
||||
// options are crucial for understanding what's actually happening per packet.
|
||||
if ip6.NextHeader == IPProtocolIPv6HopByHop {
|
||||
err := ip6.hbh.DecodeFromBytes(ip6.Payload, df)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ip6.HopByHop = &ip6.hbh
|
||||
pEnd, jumbo, err := getIPv6HopByHopJumboLength(ip6.HopByHop)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if jumbo && ip6.Length == 0 {
|
||||
pEnd := int(pEnd)
|
||||
if pEnd > len(ip6.Payload) {
|
||||
df.SetTruncated()
|
||||
pEnd = len(ip6.Payload)
|
||||
}
|
||||
ip6.Payload = ip6.Payload[:pEnd]
|
||||
return nil
|
||||
} else if jumbo && ip6.Length != 0 {
|
||||
return errors.New("IPv6 has jumbo length and IPv6 length is not 0")
|
||||
} else if !jumbo && ip6.Length == 0 {
|
||||
return errors.New("IPv6 length 0, but HopByHop header does not have jumbogram option")
|
||||
}
|
||||
}
|
||||
|
||||
if ip6.Length == 0 {
|
||||
return fmt.Errorf("IPv6 length 0, but next header is %v, not HopByHop", ip6.NextHeader)
|
||||
} else {
|
||||
pEnd := int(ip6.Length)
|
||||
if pEnd > len(ip6.Payload) {
|
||||
df.SetTruncated()
|
||||
pEnd = len(ip6.Payload)
|
||||
}
|
||||
ip6.Payload = ip6.Payload[:pEnd]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (i *IPv6) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeIPv6
|
||||
}
|
||||
|
||||
func (i *IPv6) NextLayerType() gopacket.LayerType {
|
||||
if i.HopByHop != nil {
|
||||
return i.HopByHop.NextHeader.LayerType()
|
||||
}
|
||||
return i.NextHeader.LayerType()
|
||||
}
|
||||
|
||||
func decodeIPv6(data []byte, p gopacket.PacketBuilder) error {
|
||||
ip6 := &IPv6{}
|
||||
err := ip6.DecodeFromBytes(data, p)
|
||||
p.AddLayer(ip6)
|
||||
p.SetNetworkLayer(ip6)
|
||||
if ip6.HopByHop != nil {
|
||||
p.AddLayer(ip6.HopByHop)
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return p.NextDecoder(ip6.NextLayerType())
|
||||
}
|
||||
|
||||
type ipv6HeaderTLVOption struct {
|
||||
OptionType, OptionLength uint8
|
||||
ActualLength int
|
||||
OptionData []byte
|
||||
OptionAlignment [2]uint8 // Xn+Y = [2]uint8{X, Y}
|
||||
}
|
||||
|
||||
func (h *ipv6HeaderTLVOption) serializeTo(data []byte, fixLengths bool, dryrun bool) int {
|
||||
if fixLengths {
|
||||
h.OptionLength = uint8(len(h.OptionData))
|
||||
}
|
||||
length := int(h.OptionLength) + 2
|
||||
if !dryrun {
|
||||
data[0] = h.OptionType
|
||||
data[1] = h.OptionLength
|
||||
copy(data[2:], h.OptionData)
|
||||
}
|
||||
return length
|
||||
}
|
||||
|
||||
func decodeIPv6HeaderTLVOption(data []byte) (h *ipv6HeaderTLVOption) {
|
||||
h = &ipv6HeaderTLVOption{}
|
||||
if data[0] == 0 {
|
||||
h.ActualLength = 1
|
||||
return
|
||||
}
|
||||
h.OptionType = data[0]
|
||||
h.OptionLength = data[1]
|
||||
h.ActualLength = int(h.OptionLength) + 2
|
||||
h.OptionData = data[2:h.ActualLength]
|
||||
return
|
||||
}
|
||||
|
||||
func serializeTLVOptionPadding(data []byte, padLength int) {
|
||||
if padLength <= 0 {
|
||||
return
|
||||
}
|
||||
if padLength == 1 {
|
||||
data[0] = 0x0
|
||||
return
|
||||
}
|
||||
tlvLength := uint8(padLength) - 2
|
||||
data[0] = 0x1
|
||||
data[1] = tlvLength
|
||||
if tlvLength != 0 {
|
||||
for k := range data[2:] {
|
||||
data[k+2] = 0x0
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// If buf is 'nil' do a serialize dry run
|
||||
func serializeIPv6HeaderTLVOptions(buf []byte, options []*ipv6HeaderTLVOption, fixLengths bool) int {
|
||||
var l int
|
||||
|
||||
dryrun := buf == nil
|
||||
length := 2
|
||||
for _, opt := range options {
|
||||
if fixLengths {
|
||||
x := int(opt.OptionAlignment[0])
|
||||
y := int(opt.OptionAlignment[1])
|
||||
if x != 0 {
|
||||
n := length / x
|
||||
offset := x*n + y
|
||||
if offset < length {
|
||||
offset += x
|
||||
}
|
||||
if length != offset {
|
||||
pad := offset - length
|
||||
if !dryrun {
|
||||
serializeTLVOptionPadding(buf[length-2:], pad)
|
||||
}
|
||||
length += pad
|
||||
}
|
||||
}
|
||||
}
|
||||
if dryrun {
|
||||
l = opt.serializeTo(nil, fixLengths, true)
|
||||
} else {
|
||||
l = opt.serializeTo(buf[length-2:], fixLengths, false)
|
||||
}
|
||||
length += l
|
||||
}
|
||||
if fixLengths {
|
||||
pad := length % 8
|
||||
if pad != 0 {
|
||||
if !dryrun {
|
||||
serializeTLVOptionPadding(buf[length-2:], pad)
|
||||
}
|
||||
length += pad
|
||||
}
|
||||
}
|
||||
return length - 2
|
||||
}
|
||||
|
||||
type ipv6ExtensionBase struct {
|
||||
BaseLayer
|
||||
NextHeader IPProtocol
|
||||
HeaderLength uint8
|
||||
ActualLength int
|
||||
}
|
||||
|
||||
func decodeIPv6ExtensionBase(data []byte) (i ipv6ExtensionBase) {
|
||||
i.NextHeader = IPProtocol(data[0])
|
||||
i.HeaderLength = data[1]
|
||||
i.ActualLength = int(i.HeaderLength)*8 + 8
|
||||
i.Contents = data[:i.ActualLength]
|
||||
i.Payload = data[i.ActualLength:]
|
||||
return
|
||||
}
|
||||
|
||||
// IPv6ExtensionSkipper is a DecodingLayer which decodes and ignores v6
|
||||
// extensions. You can use it with a DecodingLayerParser to handle IPv6 stacks
|
||||
// which may or may not have extensions.
|
||||
type IPv6ExtensionSkipper struct {
|
||||
NextHeader IPProtocol
|
||||
BaseLayer
|
||||
}
|
||||
|
||||
func (i *IPv6ExtensionSkipper) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
extension := decodeIPv6ExtensionBase(data)
|
||||
i.BaseLayer = BaseLayer{data[:extension.ActualLength], data[extension.ActualLength:]}
|
||||
i.NextHeader = extension.NextHeader
|
||||
return nil
|
||||
}
|
||||
|
||||
func (i *IPv6ExtensionSkipper) CanDecode() gopacket.LayerClass {
|
||||
return LayerClassIPv6Extension
|
||||
}
|
||||
|
||||
func (i *IPv6ExtensionSkipper) NextLayerType() gopacket.LayerType {
|
||||
return i.NextHeader.LayerType()
|
||||
}
|
||||
|
||||
// IPv6HopByHopOption is a TLV option present in an IPv6 hop-by-hop extension.
|
||||
type IPv6HopByHopOption ipv6HeaderTLVOption
|
||||
|
||||
// IPv6HopByHop is the IPv6 hop-by-hop extension.
|
||||
type IPv6HopByHop struct {
|
||||
ipv6ExtensionBase
|
||||
Options []*IPv6HopByHopOption
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIPv6HopByHop.
|
||||
func (i *IPv6HopByHop) LayerType() gopacket.LayerType { return LayerTypeIPv6HopByHop }
|
||||
|
||||
func (i *IPv6HopByHop) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var bytes []byte
|
||||
var err error
|
||||
|
||||
o := make([]*ipv6HeaderTLVOption, 0, len(i.Options))
|
||||
for _, v := range i.Options {
|
||||
o = append(o, (*ipv6HeaderTLVOption)(v))
|
||||
}
|
||||
|
||||
l := serializeIPv6HeaderTLVOptions(nil, o, opts.FixLengths)
|
||||
bytes, err = b.PrependBytes(l)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
serializeIPv6HeaderTLVOptions(bytes, o, opts.FixLengths)
|
||||
|
||||
length := len(bytes) + 2
|
||||
if length%8 != 0 {
|
||||
return errors.New("IPv6HopByHop actual length must be multiple of 8")
|
||||
}
|
||||
bytes, err = b.PrependBytes(2)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(i.NextHeader)
|
||||
if opts.FixLengths {
|
||||
i.HeaderLength = uint8((length / 8) - 1)
|
||||
}
|
||||
bytes[1] = uint8(i.HeaderLength)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (i *IPv6HopByHop) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
i.ipv6ExtensionBase = decodeIPv6ExtensionBase(data)
|
||||
offset := 2
|
||||
for offset < i.ActualLength {
|
||||
opt := decodeIPv6HeaderTLVOption(data[offset:])
|
||||
i.Options = append(i.Options, (*IPv6HopByHopOption)(opt))
|
||||
offset += opt.ActualLength
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeIPv6HopByHop(data []byte, p gopacket.PacketBuilder) error {
|
||||
i := &IPv6HopByHop{}
|
||||
err := i.DecodeFromBytes(data, p)
|
||||
p.AddLayer(i)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return p.NextDecoder(i.NextHeader)
|
||||
}
|
||||
|
||||
func (o *IPv6HopByHopOption) SetJumboLength(len uint32) {
|
||||
o.OptionType = IPv6HopByHopOptionJumbogram
|
||||
o.OptionLength = 4
|
||||
o.ActualLength = 6
|
||||
if o.OptionData == nil {
|
||||
o.OptionData = make([]byte, 4)
|
||||
}
|
||||
binary.BigEndian.PutUint32(o.OptionData, len)
|
||||
o.OptionAlignment = [2]uint8{4, 2}
|
||||
}
|
||||
|
||||
// IPv6Routing is the IPv6 routing extension.
|
||||
type IPv6Routing struct {
|
||||
ipv6ExtensionBase
|
||||
RoutingType uint8
|
||||
SegmentsLeft uint8
|
||||
// This segment is supposed to be zero according to RFC2460, the second set of
|
||||
// 4 bytes in the extension.
|
||||
Reserved []byte
|
||||
// SourceRoutingIPs is the set of IPv6 addresses requested for source routing,
|
||||
// set only if RoutingType == 0.
|
||||
SourceRoutingIPs []net.IP
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIPv6Routing.
|
||||
func (i *IPv6Routing) LayerType() gopacket.LayerType { return LayerTypeIPv6Routing }
|
||||
|
||||
func decodeIPv6Routing(data []byte, p gopacket.PacketBuilder) error {
|
||||
i := &IPv6Routing{
|
||||
ipv6ExtensionBase: decodeIPv6ExtensionBase(data),
|
||||
RoutingType: data[2],
|
||||
SegmentsLeft: data[3],
|
||||
Reserved: data[4:8],
|
||||
}
|
||||
switch i.RoutingType {
|
||||
case 0: // Source routing
|
||||
if (i.ActualLength-8)%16 != 0 {
|
||||
return fmt.Errorf("Invalid IPv6 source routing, length of type 0 packet %d", i.ActualLength)
|
||||
}
|
||||
for d := i.Contents[8:]; len(d) >= 16; d = d[16:] {
|
||||
i.SourceRoutingIPs = append(i.SourceRoutingIPs, net.IP(d[:16]))
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("Unknown IPv6 routing header type %d", i.RoutingType)
|
||||
}
|
||||
p.AddLayer(i)
|
||||
return p.NextDecoder(i.NextHeader)
|
||||
}
|
||||
|
||||
// IPv6Fragment is the IPv6 fragment header, used for packet
|
||||
// fragmentation/defragmentation.
|
||||
type IPv6Fragment struct {
|
||||
BaseLayer
|
||||
NextHeader IPProtocol
|
||||
// Reserved1 is bits [8-16), from least to most significant, 0-indexed
|
||||
Reserved1 uint8
|
||||
FragmentOffset uint16
|
||||
// Reserved2 is bits [29-31), from least to most significant, 0-indexed
|
||||
Reserved2 uint8
|
||||
MoreFragments bool
|
||||
Identification uint32
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIPv6Fragment.
|
||||
func (i *IPv6Fragment) LayerType() gopacket.LayerType { return LayerTypeIPv6Fragment }
|
||||
|
||||
func decodeIPv6Fragment(data []byte, p gopacket.PacketBuilder) error {
|
||||
i := &IPv6Fragment{
|
||||
BaseLayer: BaseLayer{data[:8], data[8:]},
|
||||
NextHeader: IPProtocol(data[0]),
|
||||
Reserved1: data[1],
|
||||
FragmentOffset: binary.BigEndian.Uint16(data[2:4]) >> 3,
|
||||
Reserved2: data[3] & 0x6 >> 1,
|
||||
MoreFragments: data[3]&0x1 != 0,
|
||||
Identification: binary.BigEndian.Uint32(data[4:8]),
|
||||
}
|
||||
p.AddLayer(i)
|
||||
return p.NextDecoder(gopacket.DecodeFragment)
|
||||
}
|
||||
|
||||
// IPv6DestinationOption is a TLV option present in an IPv6 destination options extension.
|
||||
type IPv6DestinationOption ipv6HeaderTLVOption
|
||||
|
||||
// IPv6Destination is the IPv6 destination options header.
|
||||
type IPv6Destination struct {
|
||||
ipv6ExtensionBase
|
||||
Options []*IPv6DestinationOption
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIPv6Destination.
|
||||
func (i *IPv6Destination) LayerType() gopacket.LayerType { return LayerTypeIPv6Destination }
|
||||
|
||||
func (i *IPv6Destination) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
i.ipv6ExtensionBase = decodeIPv6ExtensionBase(data)
|
||||
offset := 2
|
||||
for offset < i.ActualLength {
|
||||
opt := decodeIPv6HeaderTLVOption(data[offset:])
|
||||
i.Options = append(i.Options, (*IPv6DestinationOption)(opt))
|
||||
offset += opt.ActualLength
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeIPv6Destination(data []byte, p gopacket.PacketBuilder) error {
|
||||
i := &IPv6Destination{}
|
||||
err := i.DecodeFromBytes(data, p)
|
||||
p.AddLayer(i)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return p.NextDecoder(i.NextHeader)
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (i *IPv6Destination) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var bytes []byte
|
||||
var err error
|
||||
|
||||
o := make([]*ipv6HeaderTLVOption, 0, len(i.Options))
|
||||
for _, v := range i.Options {
|
||||
o = append(o, (*ipv6HeaderTLVOption)(v))
|
||||
}
|
||||
|
||||
l := serializeIPv6HeaderTLVOptions(nil, o, opts.FixLengths)
|
||||
bytes, err = b.PrependBytes(l)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
serializeIPv6HeaderTLVOptions(bytes, o, opts.FixLengths)
|
||||
|
||||
length := len(bytes) + 2
|
||||
if length%8 != 0 {
|
||||
return errors.New("IPv6Destination actual length must be multiple of 8")
|
||||
}
|
||||
bytes, err = b.PrependBytes(2)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(i.NextHeader)
|
||||
if opts.FixLengths {
|
||||
i.HeaderLength = uint8((length / 8) - 1)
|
||||
}
|
||||
bytes[1] = uint8(i.HeaderLength)
|
||||
return nil
|
||||
}
|
||||
|
||||
func checkIPv6Address(addr net.IP) error {
|
||||
if len(addr) == net.IPv6len {
|
||||
return nil
|
||||
}
|
||||
if len(addr) == net.IPv4len {
|
||||
return errors.New("address is IPv4")
|
||||
}
|
||||
return fmt.Errorf("wrong length of %d bytes instead of %d", len(addr), net.IPv6len)
|
||||
}
|
||||
|
||||
func (ip *IPv6) AddressTo16() error {
|
||||
if err := checkIPv6Address(ip.SrcIP); err != nil {
|
||||
return fmt.Errorf("Invalid source IPv6 address (%s)", err)
|
||||
}
|
||||
if err := checkIPv6Address(ip.DstIP); err != nil {
|
||||
return fmt.Errorf("Invalid destination IPv6 address (%s)", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,68 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// IPSecAH is the authentication header for IPv4/6 defined in
|
||||
// http://tools.ietf.org/html/rfc2402
|
||||
type IPSecAH struct {
|
||||
// While the auth header can be used for both IPv4 and v6, its format is that of
|
||||
// an IPv6 extension (NextHeader, PayloadLength, etc...), so we use ipv6ExtensionBase
|
||||
// to build it.
|
||||
ipv6ExtensionBase
|
||||
Reserved uint16
|
||||
SPI, Seq uint32
|
||||
AuthenticationData []byte
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIPSecAH.
|
||||
func (i *IPSecAH) LayerType() gopacket.LayerType { return LayerTypeIPSecAH }
|
||||
|
||||
func decodeIPSecAH(data []byte, p gopacket.PacketBuilder) error {
|
||||
i := &IPSecAH{
|
||||
ipv6ExtensionBase: ipv6ExtensionBase{
|
||||
NextHeader: IPProtocol(data[0]),
|
||||
HeaderLength: data[1],
|
||||
},
|
||||
Reserved: binary.BigEndian.Uint16(data[2:4]),
|
||||
SPI: binary.BigEndian.Uint32(data[4:8]),
|
||||
Seq: binary.BigEndian.Uint32(data[8:12]),
|
||||
}
|
||||
i.ActualLength = (int(i.HeaderLength) + 2) * 4
|
||||
i.AuthenticationData = data[12:i.ActualLength]
|
||||
i.Contents = data[:i.ActualLength]
|
||||
i.Payload = data[i.ActualLength:]
|
||||
p.AddLayer(i)
|
||||
return p.NextDecoder(i.NextHeader)
|
||||
}
|
||||
|
||||
// IPSecESP is the encapsulating security payload defined in
|
||||
// http://tools.ietf.org/html/rfc2406
|
||||
type IPSecESP struct {
|
||||
BaseLayer
|
||||
SPI, Seq uint32
|
||||
// Encrypted contains the encrypted set of bytes sent in an ESP
|
||||
Encrypted []byte
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeIPSecESP.
|
||||
func (i *IPSecESP) LayerType() gopacket.LayerType { return LayerTypeIPSecESP }
|
||||
|
||||
func decodeIPSecESP(data []byte, p gopacket.PacketBuilder) error {
|
||||
i := &IPSecESP{
|
||||
BaseLayer: BaseLayer{data, nil},
|
||||
SPI: binary.BigEndian.Uint32(data[:4]),
|
||||
Seq: binary.BigEndian.Uint32(data[4:8]),
|
||||
Encrypted: data[8:],
|
||||
}
|
||||
p.AddLayer(i)
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,174 @@
|
||||
// Copyright 2012 Google, 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)})
|
||||
LayerTypeSCTP = gopacket.RegisterLayerType(28, gopacket.LayerTypeMetadata{Name: "SCTP", Decoder: gopacket.DecodeFunc(decodeSCTP)})
|
||||
LayerTypeSCTPUnknownChunkType = gopacket.RegisterLayerType(29, gopacket.LayerTypeMetadata{Name: "SCTPUnknownChunkType", Decoder: nil})
|
||||
LayerTypeSCTPData = gopacket.RegisterLayerType(30, gopacket.LayerTypeMetadata{Name: "SCTPData", Decoder: nil})
|
||||
LayerTypeSCTPInit = gopacket.RegisterLayerType(31, gopacket.LayerTypeMetadata{Name: "SCTPInit", Decoder: nil})
|
||||
LayerTypeSCTPSack = gopacket.RegisterLayerType(32, gopacket.LayerTypeMetadata{Name: "SCTPSack", Decoder: nil})
|
||||
LayerTypeSCTPHeartbeat = gopacket.RegisterLayerType(33, gopacket.LayerTypeMetadata{Name: "SCTPHeartbeat", Decoder: nil})
|
||||
LayerTypeSCTPError = gopacket.RegisterLayerType(34, gopacket.LayerTypeMetadata{Name: "SCTPError", Decoder: nil})
|
||||
LayerTypeSCTPShutdown = gopacket.RegisterLayerType(35, gopacket.LayerTypeMetadata{Name: "SCTPShutdown", Decoder: nil})
|
||||
LayerTypeSCTPShutdownAck = gopacket.RegisterLayerType(36, gopacket.LayerTypeMetadata{Name: "SCTPShutdownAck", Decoder: nil})
|
||||
LayerTypeSCTPCookieEcho = gopacket.RegisterLayerType(37, gopacket.LayerTypeMetadata{Name: "SCTPCookieEcho", Decoder: nil})
|
||||
LayerTypeSCTPEmptyLayer = gopacket.RegisterLayerType(38, gopacket.LayerTypeMetadata{Name: "SCTPEmptyLayer", Decoder: nil})
|
||||
LayerTypeSCTPInitAck = gopacket.RegisterLayerType(39, gopacket.LayerTypeMetadata{Name: "SCTPInitAck", Decoder: nil})
|
||||
LayerTypeSCTPHeartbeatAck = gopacket.RegisterLayerType(40, gopacket.LayerTypeMetadata{Name: "SCTPHeartbeatAck", Decoder: nil})
|
||||
LayerTypeSCTPAbort = gopacket.RegisterLayerType(41, gopacket.LayerTypeMetadata{Name: "SCTPAbort", Decoder: nil})
|
||||
LayerTypeSCTPShutdownComplete = gopacket.RegisterLayerType(42, gopacket.LayerTypeMetadata{Name: "SCTPShutdownComplete", Decoder: nil})
|
||||
LayerTypeSCTPCookieAck = gopacket.RegisterLayerType(43, gopacket.LayerTypeMetadata{Name: "SCTPCookieAck", Decoder: nil})
|
||||
LayerTypeTCP = gopacket.RegisterLayerType(44, gopacket.LayerTypeMetadata{Name: "TCP", Decoder: gopacket.DecodeFunc(decodeTCP)})
|
||||
LayerTypeUDP = gopacket.RegisterLayerType(45, gopacket.LayerTypeMetadata{Name: "UDP", Decoder: gopacket.DecodeFunc(decodeUDP)})
|
||||
LayerTypeIPv6HopByHop = gopacket.RegisterLayerType(46, gopacket.LayerTypeMetadata{Name: "IPv6HopByHop", Decoder: gopacket.DecodeFunc(decodeIPv6HopByHop)})
|
||||
LayerTypeIPv6Routing = gopacket.RegisterLayerType(47, gopacket.LayerTypeMetadata{Name: "IPv6Routing", Decoder: gopacket.DecodeFunc(decodeIPv6Routing)})
|
||||
LayerTypeIPv6Fragment = gopacket.RegisterLayerType(48, gopacket.LayerTypeMetadata{Name: "IPv6Fragment", Decoder: gopacket.DecodeFunc(decodeIPv6Fragment)})
|
||||
LayerTypeIPv6Destination = gopacket.RegisterLayerType(49, gopacket.LayerTypeMetadata{Name: "IPv6Destination", Decoder: gopacket.DecodeFunc(decodeIPv6Destination)})
|
||||
LayerTypeIPSecAH = gopacket.RegisterLayerType(50, gopacket.LayerTypeMetadata{Name: "IPSecAH", Decoder: gopacket.DecodeFunc(decodeIPSecAH)})
|
||||
LayerTypeIPSecESP = gopacket.RegisterLayerType(51, gopacket.LayerTypeMetadata{Name: "IPSecESP", Decoder: gopacket.DecodeFunc(decodeIPSecESP)})
|
||||
LayerTypeUDPLite = gopacket.RegisterLayerType(52, gopacket.LayerTypeMetadata{Name: "UDPLite", Decoder: gopacket.DecodeFunc(decodeUDPLite)})
|
||||
LayerTypeFDDI = gopacket.RegisterLayerType(53, gopacket.LayerTypeMetadata{Name: "FDDI", Decoder: gopacket.DecodeFunc(decodeFDDI)})
|
||||
LayerTypeLoopback = gopacket.RegisterLayerType(54, gopacket.LayerTypeMetadata{Name: "Loopback", Decoder: gopacket.DecodeFunc(decodeLoopback)})
|
||||
LayerTypeEAP = gopacket.RegisterLayerType(55, gopacket.LayerTypeMetadata{Name: "EAP", Decoder: gopacket.DecodeFunc(decodeEAP)})
|
||||
LayerTypeEAPOL = gopacket.RegisterLayerType(56, gopacket.LayerTypeMetadata{Name: "EAPOL", Decoder: gopacket.DecodeFunc(decodeEAPOL)})
|
||||
LayerTypeICMPv6 = gopacket.RegisterLayerType(57, gopacket.LayerTypeMetadata{Name: "ICMPv6", Decoder: gopacket.DecodeFunc(decodeICMPv6)})
|
||||
LayerTypeLinkLayerDiscovery = gopacket.RegisterLayerType(58, gopacket.LayerTypeMetadata{Name: "LinkLayerDiscovery", Decoder: gopacket.DecodeFunc(decodeLinkLayerDiscovery)})
|
||||
LayerTypeCiscoDiscoveryInfo = gopacket.RegisterLayerType(59, gopacket.LayerTypeMetadata{Name: "CiscoDiscoveryInfo", Decoder: gopacket.DecodeFunc(decodeCiscoDiscoveryInfo)})
|
||||
LayerTypeLinkLayerDiscoveryInfo = gopacket.RegisterLayerType(60, gopacket.LayerTypeMetadata{Name: "LinkLayerDiscoveryInfo", Decoder: nil})
|
||||
LayerTypeNortelDiscovery = gopacket.RegisterLayerType(61, gopacket.LayerTypeMetadata{Name: "NortelDiscovery", Decoder: gopacket.DecodeFunc(decodeNortelDiscovery)})
|
||||
LayerTypeIGMP = gopacket.RegisterLayerType(62, gopacket.LayerTypeMetadata{Name: "IGMP", Decoder: gopacket.DecodeFunc(decodeIGMP)})
|
||||
LayerTypePFLog = gopacket.RegisterLayerType(63, gopacket.LayerTypeMetadata{Name: "PFLog", Decoder: gopacket.DecodeFunc(decodePFLog)})
|
||||
LayerTypeRadioTap = gopacket.RegisterLayerType(64, gopacket.LayerTypeMetadata{Name: "RadioTap", Decoder: gopacket.DecodeFunc(decodeRadioTap)})
|
||||
LayerTypeDot11 = gopacket.RegisterLayerType(65, gopacket.LayerTypeMetadata{Name: "Dot11", Decoder: gopacket.DecodeFunc(decodeDot11)})
|
||||
LayerTypeDot11Ctrl = gopacket.RegisterLayerType(66, gopacket.LayerTypeMetadata{Name: "Dot11Ctrl", Decoder: gopacket.DecodeFunc(decodeDot11Ctrl)})
|
||||
LayerTypeDot11Data = gopacket.RegisterLayerType(67, gopacket.LayerTypeMetadata{Name: "Dot11Data", Decoder: gopacket.DecodeFunc(decodeDot11Data)})
|
||||
LayerTypeDot11DataCFAck = gopacket.RegisterLayerType(68, gopacket.LayerTypeMetadata{Name: "Dot11DataCFAck", Decoder: gopacket.DecodeFunc(decodeDot11DataCFAck)})
|
||||
LayerTypeDot11DataCFPoll = gopacket.RegisterLayerType(69, gopacket.LayerTypeMetadata{Name: "Dot11DataCFPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataCFPoll)})
|
||||
LayerTypeDot11DataCFAckPoll = gopacket.RegisterLayerType(70, gopacket.LayerTypeMetadata{Name: "Dot11DataCFAckPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataCFAckPoll)})
|
||||
LayerTypeDot11DataNull = gopacket.RegisterLayerType(71, gopacket.LayerTypeMetadata{Name: "Dot11DataNull", Decoder: gopacket.DecodeFunc(decodeDot11DataNull)})
|
||||
LayerTypeDot11DataCFAckNoData = gopacket.RegisterLayerType(72, gopacket.LayerTypeMetadata{Name: "Dot11DataCFAck", Decoder: gopacket.DecodeFunc(decodeDot11DataCFAck)})
|
||||
LayerTypeDot11DataCFPollNoData = gopacket.RegisterLayerType(73, gopacket.LayerTypeMetadata{Name: "Dot11DataCFPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataCFPoll)})
|
||||
LayerTypeDot11DataCFAckPollNoData = gopacket.RegisterLayerType(74, gopacket.LayerTypeMetadata{Name: "Dot11DataCFAckPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataCFAckPoll)})
|
||||
LayerTypeDot11DataQOSData = gopacket.RegisterLayerType(75, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSData", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSData)})
|
||||
LayerTypeDot11DataQOSDataCFAck = gopacket.RegisterLayerType(76, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSDataCFAck", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSDataCFAck)})
|
||||
LayerTypeDot11DataQOSDataCFPoll = gopacket.RegisterLayerType(77, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSDataCFPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSDataCFPoll)})
|
||||
LayerTypeDot11DataQOSDataCFAckPoll = gopacket.RegisterLayerType(78, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSDataCFAckPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSDataCFAckPoll)})
|
||||
LayerTypeDot11DataQOSNull = gopacket.RegisterLayerType(79, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSNull", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSNull)})
|
||||
LayerTypeDot11DataQOSCFPollNoData = gopacket.RegisterLayerType(80, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSCFPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSCFPollNoData)})
|
||||
LayerTypeDot11DataQOSCFAckPollNoData = gopacket.RegisterLayerType(81, gopacket.LayerTypeMetadata{Name: "Dot11DataQOSCFAckPoll", Decoder: gopacket.DecodeFunc(decodeDot11DataQOSCFAckPollNoData)})
|
||||
LayerTypeDot11InformationElement = gopacket.RegisterLayerType(82, gopacket.LayerTypeMetadata{Name: "Dot11InformationElement", Decoder: gopacket.DecodeFunc(decodeDot11InformationElement)})
|
||||
LayerTypeDot11CtrlCTS = gopacket.RegisterLayerType(83, gopacket.LayerTypeMetadata{Name: "Dot11CtrlCTS", Decoder: gopacket.DecodeFunc(decodeDot11CtrlCTS)})
|
||||
LayerTypeDot11CtrlRTS = gopacket.RegisterLayerType(84, gopacket.LayerTypeMetadata{Name: "Dot11CtrlRTS", Decoder: gopacket.DecodeFunc(decodeDot11CtrlRTS)})
|
||||
LayerTypeDot11CtrlBlockAckReq = gopacket.RegisterLayerType(85, gopacket.LayerTypeMetadata{Name: "Dot11CtrlBlockAckReq", Decoder: gopacket.DecodeFunc(decodeDot11CtrlBlockAckReq)})
|
||||
LayerTypeDot11CtrlBlockAck = gopacket.RegisterLayerType(86, gopacket.LayerTypeMetadata{Name: "Dot11CtrlBlockAck", Decoder: gopacket.DecodeFunc(decodeDot11CtrlBlockAck)})
|
||||
LayerTypeDot11CtrlPowersavePoll = gopacket.RegisterLayerType(87, gopacket.LayerTypeMetadata{Name: "Dot11CtrlPowersavePoll", Decoder: gopacket.DecodeFunc(decodeDot11CtrlPowersavePoll)})
|
||||
LayerTypeDot11CtrlAck = gopacket.RegisterLayerType(88, gopacket.LayerTypeMetadata{Name: "Dot11CtrlAck", Decoder: gopacket.DecodeFunc(decodeDot11CtrlAck)})
|
||||
LayerTypeDot11CtrlCFEnd = gopacket.RegisterLayerType(89, gopacket.LayerTypeMetadata{Name: "Dot11CtrlCFEnd", Decoder: gopacket.DecodeFunc(decodeDot11CtrlCFEnd)})
|
||||
LayerTypeDot11CtrlCFEndAck = gopacket.RegisterLayerType(90, gopacket.LayerTypeMetadata{Name: "Dot11CtrlCFEndAck", Decoder: gopacket.DecodeFunc(decodeDot11CtrlCFEndAck)})
|
||||
LayerTypeDot11MgmtAssociationReq = gopacket.RegisterLayerType(91, gopacket.LayerTypeMetadata{Name: "Dot11MgmtAssociationReq", Decoder: gopacket.DecodeFunc(decodeDot11MgmtAssociationReq)})
|
||||
LayerTypeDot11MgmtAssociationResp = gopacket.RegisterLayerType(92, gopacket.LayerTypeMetadata{Name: "Dot11MgmtAssociationResp", Decoder: gopacket.DecodeFunc(decodeDot11MgmtAssociationResp)})
|
||||
LayerTypeDot11MgmtReassociationReq = gopacket.RegisterLayerType(93, gopacket.LayerTypeMetadata{Name: "Dot11MgmtReassociationReq", Decoder: gopacket.DecodeFunc(decodeDot11MgmtReassociationReq)})
|
||||
LayerTypeDot11MgmtReassociationResp = gopacket.RegisterLayerType(94, gopacket.LayerTypeMetadata{Name: "Dot11MgmtReassociationResp", Decoder: gopacket.DecodeFunc(decodeDot11MgmtReassociationResp)})
|
||||
LayerTypeDot11MgmtProbeReq = gopacket.RegisterLayerType(95, gopacket.LayerTypeMetadata{Name: "Dot11MgmtProbeReq", Decoder: gopacket.DecodeFunc(decodeDot11MgmtProbeReq)})
|
||||
LayerTypeDot11MgmtProbeResp = gopacket.RegisterLayerType(96, gopacket.LayerTypeMetadata{Name: "Dot11MgmtProbeResp", Decoder: gopacket.DecodeFunc(decodeDot11MgmtProbeResp)})
|
||||
LayerTypeDot11MgmtMeasurementPilot = gopacket.RegisterLayerType(97, gopacket.LayerTypeMetadata{Name: "Dot11MgmtMeasurementPilot", Decoder: gopacket.DecodeFunc(decodeDot11MgmtMeasurementPilot)})
|
||||
LayerTypeDot11MgmtBeacon = gopacket.RegisterLayerType(98, gopacket.LayerTypeMetadata{Name: "Dot11MgmtBeacon", Decoder: gopacket.DecodeFunc(decodeDot11MgmtBeacon)})
|
||||
LayerTypeDot11MgmtATIM = gopacket.RegisterLayerType(99, gopacket.LayerTypeMetadata{Name: "Dot11MgmtATIM", Decoder: gopacket.DecodeFunc(decodeDot11MgmtATIM)})
|
||||
LayerTypeDot11MgmtDisassociation = gopacket.RegisterLayerType(100, gopacket.LayerTypeMetadata{Name: "Dot11MgmtDisassociation", Decoder: gopacket.DecodeFunc(decodeDot11MgmtDisassociation)})
|
||||
LayerTypeDot11MgmtAuthentication = gopacket.RegisterLayerType(101, gopacket.LayerTypeMetadata{Name: "Dot11MgmtAuthentication", Decoder: gopacket.DecodeFunc(decodeDot11MgmtAuthentication)})
|
||||
LayerTypeDot11MgmtDeauthentication = gopacket.RegisterLayerType(102, gopacket.LayerTypeMetadata{Name: "Dot11MgmtDeauthentication", Decoder: gopacket.DecodeFunc(decodeDot11MgmtDeauthentication)})
|
||||
LayerTypeDot11MgmtAction = gopacket.RegisterLayerType(103, gopacket.LayerTypeMetadata{Name: "Dot11MgmtAction", Decoder: gopacket.DecodeFunc(decodeDot11MgmtAction)})
|
||||
LayerTypeDot11MgmtActionNoAck = gopacket.RegisterLayerType(104, gopacket.LayerTypeMetadata{Name: "Dot11MgmtActionNoAck", Decoder: gopacket.DecodeFunc(decodeDot11MgmtActionNoAck)})
|
||||
LayerTypeDot11MgmtArubaWLAN = gopacket.RegisterLayerType(105, gopacket.LayerTypeMetadata{Name: "Dot11MgmtArubaWLAN", Decoder: gopacket.DecodeFunc(decodeDot11MgmtArubaWLAN)})
|
||||
LayerTypeDot11WEP = gopacket.RegisterLayerType(106, gopacket.LayerTypeMetadata{Name: "Dot11WEP", Decoder: gopacket.DecodeFunc(decodeDot11WEP)})
|
||||
LayerTypeDNS = gopacket.RegisterLayerType(107, gopacket.LayerTypeMetadata{Name: "DNS", Decoder: gopacket.DecodeFunc(decodeDNS)})
|
||||
LayerTypeUSB = gopacket.RegisterLayerType(108, gopacket.LayerTypeMetadata{Name: "USB", Decoder: gopacket.DecodeFunc(decodeUSB)})
|
||||
LayerTypeUSBRequestBlockSetup = gopacket.RegisterLayerType(109, gopacket.LayerTypeMetadata{Name: "USBRequestBlockSetup", Decoder: gopacket.DecodeFunc(decodeUSBRequestBlockSetup)})
|
||||
LayerTypeUSBControl = gopacket.RegisterLayerType(110, gopacket.LayerTypeMetadata{Name: "USBControl", Decoder: gopacket.DecodeFunc(decodeUSBControl)})
|
||||
LayerTypeUSBInterrupt = gopacket.RegisterLayerType(111, gopacket.LayerTypeMetadata{Name: "USBInterrupt", Decoder: gopacket.DecodeFunc(decodeUSBInterrupt)})
|
||||
LayerTypeUSBBulk = gopacket.RegisterLayerType(112, gopacket.LayerTypeMetadata{Name: "USBBulk", Decoder: gopacket.DecodeFunc(decodeUSBBulk)})
|
||||
LayerTypeLinuxSLL = gopacket.RegisterLayerType(113, gopacket.LayerTypeMetadata{Name: "Linux SLL", Decoder: gopacket.DecodeFunc(decodeLinuxSLL)})
|
||||
LayerTypeSFlow = gopacket.RegisterLayerType(114, gopacket.LayerTypeMetadata{Name: "SFlow", Decoder: gopacket.DecodeFunc(decodeSFlow)})
|
||||
LayerTypePrismHeader = gopacket.RegisterLayerType(115, gopacket.LayerTypeMetadata{Name: "Prism monitor mode header", Decoder: gopacket.DecodeFunc(decodePrismHeader)})
|
||||
LayerTypeVXLAN = gopacket.RegisterLayerType(116, gopacket.LayerTypeMetadata{Name: "VXLAN", Decoder: gopacket.DecodeFunc(decodeVXLAN)})
|
||||
LayerTypeNTP = gopacket.RegisterLayerType(117, gopacket.LayerTypeMetadata{Name: "NTP", Decoder: gopacket.DecodeFunc(decodeNTP)})
|
||||
LayerTypeDHCPv4 = gopacket.RegisterLayerType(118, gopacket.LayerTypeMetadata{Name: "DHCPv4", Decoder: gopacket.DecodeFunc(decodeDHCPv4)})
|
||||
LayerTypeVRRP = gopacket.RegisterLayerType(119, gopacket.LayerTypeMetadata{Name: "VRRP", Decoder: gopacket.DecodeFunc(decodeVRRP)})
|
||||
LayerTypeGeneve = gopacket.RegisterLayerType(120, gopacket.LayerTypeMetadata{Name: "Geneve", Decoder: gopacket.DecodeFunc(decodeGeneve)})
|
||||
)
|
||||
|
||||
var (
|
||||
// LayerClassIPNetwork contains TCP/IP network layer types.
|
||||
LayerClassIPNetwork = gopacket.NewLayerClass([]gopacket.LayerType{
|
||||
LayerTypeIPv4,
|
||||
LayerTypeIPv6,
|
||||
})
|
||||
// LayerClassIPTransport contains TCP/IP transport layer types.
|
||||
LayerClassIPTransport = gopacket.NewLayerClass([]gopacket.LayerType{
|
||||
LayerTypeTCP,
|
||||
LayerTypeUDP,
|
||||
LayerTypeSCTP,
|
||||
})
|
||||
// LayerClassIPControl contains TCP/IP control protocols.
|
||||
LayerClassIPControl = gopacket.NewLayerClass([]gopacket.LayerType{
|
||||
LayerTypeICMPv4,
|
||||
LayerTypeICMPv6,
|
||||
})
|
||||
// LayerClassSCTPChunk contains SCTP chunk types (not the top-level SCTP
|
||||
// layer).
|
||||
LayerClassSCTPChunk = gopacket.NewLayerClass([]gopacket.LayerType{
|
||||
LayerTypeSCTPUnknownChunkType,
|
||||
LayerTypeSCTPData,
|
||||
LayerTypeSCTPInit,
|
||||
LayerTypeSCTPSack,
|
||||
LayerTypeSCTPHeartbeat,
|
||||
LayerTypeSCTPError,
|
||||
LayerTypeSCTPShutdown,
|
||||
LayerTypeSCTPShutdownAck,
|
||||
LayerTypeSCTPCookieEcho,
|
||||
LayerTypeSCTPEmptyLayer,
|
||||
LayerTypeSCTPInitAck,
|
||||
LayerTypeSCTPHeartbeatAck,
|
||||
LayerTypeSCTPAbort,
|
||||
LayerTypeSCTPShutdownComplete,
|
||||
LayerTypeSCTPCookieAck,
|
||||
})
|
||||
// LayerClassIPv6Extension contains IPv6 extension headers.
|
||||
LayerClassIPv6Extension = gopacket.NewLayerClass([]gopacket.LayerType{
|
||||
LayerTypeIPv6HopByHop,
|
||||
LayerTypeIPv6Routing,
|
||||
LayerTypeIPv6Fragment,
|
||||
LayerTypeIPv6Destination,
|
||||
})
|
||||
LayerClassIPSec = gopacket.NewLayerClass([]gopacket.LayerType{
|
||||
LayerTypeIPSecAH,
|
||||
LayerTypeIPSecESP,
|
||||
})
|
||||
)
|
||||
@ -0,0 +1,96 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
type LinuxSLLPacketType uint16
|
||||
|
||||
const (
|
||||
LinuxSLLPacketTypeHost LinuxSLLPacketType = 0 // To us
|
||||
LinuxSLLPacketTypeBroadcast LinuxSLLPacketType = 1 // To all
|
||||
LinuxSLLPacketTypeMulticast LinuxSLLPacketType = 2 // To group
|
||||
LinuxSLLPacketTypeOtherhost LinuxSLLPacketType = 3 // To someone else
|
||||
LinuxSLLPacketTypeOutgoing LinuxSLLPacketType = 4 // Outgoing of any type
|
||||
// These ones are invisible by user level
|
||||
LinuxSLLPacketTypeLoopback LinuxSLLPacketType = 5 // MC/BRD frame looped back
|
||||
LinuxSLLPacketTypeFastroute LinuxSLLPacketType = 6 // Fastrouted frame
|
||||
)
|
||||
|
||||
func (l LinuxSLLPacketType) String() string {
|
||||
switch l {
|
||||
case LinuxSLLPacketTypeHost:
|
||||
return "host"
|
||||
case LinuxSLLPacketTypeBroadcast:
|
||||
return "broadcast"
|
||||
case LinuxSLLPacketTypeMulticast:
|
||||
return "multicast"
|
||||
case LinuxSLLPacketTypeOtherhost:
|
||||
return "otherhost"
|
||||
case LinuxSLLPacketTypeOutgoing:
|
||||
return "outgoing"
|
||||
case LinuxSLLPacketTypeLoopback:
|
||||
return "loopback"
|
||||
case LinuxSLLPacketTypeFastroute:
|
||||
return "fastroute"
|
||||
}
|
||||
return fmt.Sprintf("Unknown(%d)", int(l))
|
||||
}
|
||||
|
||||
type LinuxSLL struct {
|
||||
BaseLayer
|
||||
PacketType LinuxSLLPacketType
|
||||
AddrLen uint16
|
||||
Addr net.HardwareAddr
|
||||
EthernetType EthernetType
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeLinuxSLL.
|
||||
func (sll *LinuxSLL) LayerType() gopacket.LayerType { return LayerTypeLinuxSLL }
|
||||
|
||||
func (sll *LinuxSLL) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeLinuxSLL
|
||||
}
|
||||
|
||||
func (sll *LinuxSLL) LinkFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointMAC, sll.Addr, nil)
|
||||
}
|
||||
|
||||
func (sll *LinuxSLL) NextLayerType() gopacket.LayerType {
|
||||
return sll.EthernetType.LayerType()
|
||||
}
|
||||
|
||||
func (sll *LinuxSLL) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
if len(data) < 16 {
|
||||
return errors.New("Linux SLL packet too small")
|
||||
}
|
||||
sll.PacketType = LinuxSLLPacketType(binary.BigEndian.Uint16(data[0:2]))
|
||||
sll.AddrLen = binary.BigEndian.Uint16(data[4:6])
|
||||
|
||||
sll.Addr = net.HardwareAddr(data[6 : sll.AddrLen+6])
|
||||
sll.EthernetType = EthernetType(binary.BigEndian.Uint16(data[14:16]))
|
||||
sll.BaseLayer = BaseLayer{data[:16], data[16:]}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeLinuxSLL(data []byte, p gopacket.PacketBuilder) error {
|
||||
sll := &LinuxSLL{}
|
||||
if err := sll.DecodeFromBytes(data, p); err != nil {
|
||||
return err
|
||||
}
|
||||
p.AddLayer(sll)
|
||||
p.SetLinkLayer(sll)
|
||||
return p.NextDecoder(sll.EthernetType)
|
||||
}
|
||||
@ -0,0 +1,143 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// LLC is the layer used for 802.2 Logical Link Control headers.
|
||||
// See http://standards.ieee.org/getieee802/download/802.2-1998.pdf
|
||||
type LLC struct {
|
||||
BaseLayer
|
||||
DSAP uint8
|
||||
IG bool // true means group, false means individual
|
||||
SSAP uint8
|
||||
CR bool // true means response, false means command
|
||||
Control uint16
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeLLC.
|
||||
func (l *LLC) LayerType() gopacket.LayerType { return LayerTypeLLC }
|
||||
|
||||
// SNAP is used inside LLC. See
|
||||
// http://standards.ieee.org/getieee802/download/802-2001.pdf.
|
||||
// From http://en.wikipedia.org/wiki/Subnetwork_Access_Protocol:
|
||||
// "[T]he Subnetwork Access Protocol (SNAP) is a mechanism for multiplexing,
|
||||
// on networks using IEEE 802.2 LLC, more protocols than can be distinguished
|
||||
// by the 8-bit 802.2 Service Access Point (SAP) fields."
|
||||
type SNAP struct {
|
||||
BaseLayer
|
||||
OrganizationalCode []byte
|
||||
Type EthernetType
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeSNAP.
|
||||
func (s *SNAP) LayerType() gopacket.LayerType { return LayerTypeSNAP }
|
||||
|
||||
func decodeLLC(data []byte, p gopacket.PacketBuilder) error {
|
||||
l := &LLC{
|
||||
DSAP: data[0] & 0xFE,
|
||||
IG: data[0]&0x1 != 0,
|
||||
SSAP: data[1] & 0xFE,
|
||||
CR: data[1]&0x1 != 0,
|
||||
Control: uint16(data[2]),
|
||||
}
|
||||
if l.Control&0x1 == 0 || l.Control&0x3 == 0x1 {
|
||||
l.Control = l.Control<<8 | uint16(data[3])
|
||||
l.Contents = data[:4]
|
||||
l.Payload = data[4:]
|
||||
} else {
|
||||
l.Contents = data[:3]
|
||||
l.Payload = data[3:]
|
||||
}
|
||||
p.AddLayer(l)
|
||||
if l.DSAP == 0xAA && l.SSAP == 0xAA {
|
||||
return p.NextDecoder(LayerTypeSNAP)
|
||||
}
|
||||
return p.NextDecoder(gopacket.DecodeUnknown)
|
||||
}
|
||||
|
||||
func decodeSNAP(data []byte, p gopacket.PacketBuilder) error {
|
||||
s := &SNAP{
|
||||
OrganizationalCode: data[:3],
|
||||
Type: EthernetType(binary.BigEndian.Uint16(data[3:5])),
|
||||
BaseLayer: BaseLayer{data[:5], data[5:]},
|
||||
}
|
||||
p.AddLayer(s)
|
||||
// BUG(gconnell): When decoding SNAP, we treat the SNAP type as an Ethernet
|
||||
// type. This may not actually be an ethernet type in all cases,
|
||||
// depending on the organizational code. Right now, we don't check.
|
||||
return p.NextDecoder(s.Type)
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (l *LLC) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var ig_flag, cr_flag byte
|
||||
var length int
|
||||
|
||||
if l.Control&0xFF00 != 0 {
|
||||
length = 4
|
||||
} else {
|
||||
length = 3
|
||||
}
|
||||
|
||||
if l.DSAP&0x1 != 0 {
|
||||
return errors.New("DSAP value invalid, should not include IG flag bit")
|
||||
}
|
||||
|
||||
if l.SSAP&0x1 != 0 {
|
||||
return errors.New("SSAP value invalid, should not include CR flag bit")
|
||||
}
|
||||
|
||||
if buf, err := b.PrependBytes(length); err != nil {
|
||||
return err
|
||||
} else {
|
||||
ig_flag = 0
|
||||
if l.IG {
|
||||
ig_flag = 0x1
|
||||
}
|
||||
|
||||
cr_flag = 0
|
||||
if l.CR {
|
||||
cr_flag = 0x1
|
||||
}
|
||||
|
||||
buf[0] = l.DSAP + ig_flag
|
||||
buf[1] = l.SSAP + cr_flag
|
||||
|
||||
if length == 4 {
|
||||
buf[2] = uint8(l.Control >> 8)
|
||||
buf[3] = uint8(l.Control)
|
||||
} else {
|
||||
buf[2] = uint8(l.Control)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (s *SNAP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
if buf, err := b.PrependBytes(5); err != nil {
|
||||
return err
|
||||
} else {
|
||||
buf[0] = s.OrganizationalCode[0]
|
||||
buf[1] = s.OrganizationalCode[1]
|
||||
buf[2] = s.OrganizationalCode[2]
|
||||
binary.BigEndian.PutUint16(buf[3:5], uint16(s.Type))
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,80 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// Loopback contains the header for loopback encapsulation. This header is
|
||||
// used by both BSD and OpenBSD style loopback decoding (pcap's DLT_NULL
|
||||
// and DLT_LOOP, respectively).
|
||||
type Loopback struct {
|
||||
BaseLayer
|
||||
Family ProtocolFamily
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeLoopback.
|
||||
func (l *Loopback) LayerType() gopacket.LayerType { return LayerTypeLoopback }
|
||||
|
||||
// DecodeFromBytes decodes the given bytes into this layer.
|
||||
func (l *Loopback) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
if len(data) < 4 {
|
||||
return errors.New("Loopback packet too small")
|
||||
}
|
||||
|
||||
// The protocol could be either big-endian or little-endian, we're
|
||||
// not sure. But we're PRETTY sure that the value is less than
|
||||
// 256, so we can check the first two bytes.
|
||||
var prot uint32
|
||||
if data[0] == 0 && data[1] == 0 {
|
||||
prot = binary.BigEndian.Uint32(data[:4])
|
||||
} else {
|
||||
prot = binary.LittleEndian.Uint32(data[:4])
|
||||
}
|
||||
if prot > 0xFF {
|
||||
return fmt.Errorf("Invalid loopback protocol %q", data[:4])
|
||||
}
|
||||
|
||||
l.Family = ProtocolFamily(prot)
|
||||
l.BaseLayer = BaseLayer{data[:4], data[4:]}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode returns the set of layer types that this DecodingLayer can decode.
|
||||
func (l *Loopback) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeLoopback
|
||||
}
|
||||
|
||||
// NextLayerType returns the layer type contained by this DecodingLayer.
|
||||
func (l *Loopback) NextLayerType() gopacket.LayerType {
|
||||
return l.Family.LayerType()
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
func (l *Loopback) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(4)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
binary.LittleEndian.PutUint32(bytes, uint32(l.Family))
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeLoopback(data []byte, p gopacket.PacketBuilder) error {
|
||||
l := Loopback{}
|
||||
if err := l.DecodeFromBytes(data, gopacket.NilDecodeFeedback); err != nil {
|
||||
return err
|
||||
}
|
||||
p.AddLayer(&l)
|
||||
return p.NextDecoder(l.Family)
|
||||
}
|
||||
@ -0,0 +1,87 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// MPLS is the MPLS packet header.
|
||||
type MPLS struct {
|
||||
BaseLayer
|
||||
Label uint32
|
||||
TrafficClass uint8
|
||||
StackBottom bool
|
||||
TTL uint8
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeMPLS.
|
||||
func (m *MPLS) LayerType() gopacket.LayerType { return LayerTypeMPLS }
|
||||
|
||||
// ProtocolGuessingDecoder attempts to guess the protocol of the bytes it's
|
||||
// given, then decode the packet accordingly. Its algorithm for guessing is:
|
||||
// If the packet starts with byte 0x45-0x4F: IPv4
|
||||
// If the packet starts with byte 0x60-0x6F: IPv6
|
||||
// Otherwise: Error
|
||||
// See draft-hsmit-isis-aal5mux-00.txt for more detail on this approach.
|
||||
type ProtocolGuessingDecoder struct{}
|
||||
|
||||
func (ProtocolGuessingDecoder) Decode(data []byte, p gopacket.PacketBuilder) error {
|
||||
switch data[0] {
|
||||
// 0x40 | header_len, where header_len is at least 5.
|
||||
case 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f:
|
||||
return decodeIPv4(data, p)
|
||||
// IPv6 can start with any byte whose first 4 bits are 0x6.
|
||||
case 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f:
|
||||
return decodeIPv6(data, p)
|
||||
}
|
||||
return errors.New("Unable to guess protocol of packet data")
|
||||
}
|
||||
|
||||
// MPLSPayloadDecoder is the decoder used to data encapsulated by each MPLS
|
||||
// layer. MPLS contains no type information, so we have to explicitly decide
|
||||
// which decoder to use. This is initially set to ProtocolGuessingDecoder, our
|
||||
// simple attempt at guessing protocols based on the first few bytes of data
|
||||
// available to us. However, if you know that in your environment MPLS always
|
||||
// encapsulates a specific protocol, you may reset this.
|
||||
var MPLSPayloadDecoder gopacket.Decoder = ProtocolGuessingDecoder{}
|
||||
|
||||
func decodeMPLS(data []byte, p gopacket.PacketBuilder) error {
|
||||
decoded := binary.BigEndian.Uint32(data[:4])
|
||||
mpls := &MPLS{
|
||||
Label: decoded >> 12,
|
||||
TrafficClass: uint8(decoded>>9) & 0x7,
|
||||
StackBottom: decoded&0x100 != 0,
|
||||
TTL: uint8(decoded),
|
||||
BaseLayer: BaseLayer{data[:4], data[4:]},
|
||||
}
|
||||
p.AddLayer(mpls)
|
||||
if mpls.StackBottom {
|
||||
return p.NextDecoder(MPLSPayloadDecoder)
|
||||
}
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeMPLS))
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (m *MPLS) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(4)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
encoded := m.Label << 12
|
||||
encoded |= uint32(m.TrafficClass) << 9
|
||||
encoded |= uint32(m.TTL)
|
||||
if m.StackBottom {
|
||||
encoded |= 0x100
|
||||
}
|
||||
binary.BigEndian.PutUint32(bytes, encoded)
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,611 @@
|
||||
// Copyright 2012 Google, 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.
|
||||
|
||||
// Enum types courtesy of...
|
||||
// http://anonsvn.wireshark.org/wireshark/trunk/epan/dissectors/packet-ndp.c
|
||||
|
||||
package layers
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/google/gopacket"
|
||||
"net"
|
||||
)
|
||||
|
||||
type NDPChassisType uint8
|
||||
|
||||
// Nortel Chassis Types
|
||||
const (
|
||||
NDPChassisother NDPChassisType = 1
|
||||
NDPChassis3000 NDPChassisType = 2
|
||||
NDPChassis3030 NDPChassisType = 3
|
||||
NDPChassis2310 NDPChassisType = 4
|
||||
NDPChassis2810 NDPChassisType = 5
|
||||
NDPChassis2912 NDPChassisType = 6
|
||||
NDPChassis2914 NDPChassisType = 7
|
||||
NDPChassis271x NDPChassisType = 8
|
||||
NDPChassis2813 NDPChassisType = 9
|
||||
NDPChassis2814 NDPChassisType = 10
|
||||
NDPChassis2915 NDPChassisType = 11
|
||||
NDPChassis5000 NDPChassisType = 12
|
||||
NDPChassis2813SA NDPChassisType = 13
|
||||
NDPChassis2814SA NDPChassisType = 14
|
||||
NDPChassis810M NDPChassisType = 15
|
||||
NDPChassisEthercell NDPChassisType = 16
|
||||
NDPChassis5005 NDPChassisType = 17
|
||||
NDPChassisAlcatelEWC NDPChassisType = 18
|
||||
NDPChassis2715SA NDPChassisType = 20
|
||||
NDPChassis2486 NDPChassisType = 21
|
||||
NDPChassis28000series NDPChassisType = 22
|
||||
NDPChassis23000series NDPChassisType = 23
|
||||
NDPChassis5DN00xseries NDPChassisType = 24
|
||||
NDPChassisBayStackEthernet NDPChassisType = 25
|
||||
NDPChassis23100series NDPChassisType = 26
|
||||
NDPChassis100BaseTHub NDPChassisType = 27
|
||||
NDPChassis3000FastEthernet NDPChassisType = 28
|
||||
NDPChassisOrionSwitch NDPChassisType = 29
|
||||
NDPChassisDDS NDPChassisType = 31
|
||||
NDPChassisCentillion6slot NDPChassisType = 32
|
||||
NDPChassisCentillion12slot NDPChassisType = 33
|
||||
NDPChassisCentillion1slot NDPChassisType = 34
|
||||
NDPChassisBayStack301 NDPChassisType = 35
|
||||
NDPChassisBayStackTokenRingHub NDPChassisType = 36
|
||||
NDPChassisFVCMultimediaSwitch NDPChassisType = 37
|
||||
NDPChassisSwitchNode NDPChassisType = 38
|
||||
NDPChassisBayStack302Switch NDPChassisType = 39
|
||||
NDPChassisBayStack350Switch NDPChassisType = 40
|
||||
NDPChassisBayStack150EthernetHub NDPChassisType = 41
|
||||
NDPChassisCentillion50NSwitch NDPChassisType = 42
|
||||
NDPChassisCentillion50TSwitch NDPChassisType = 43
|
||||
NDPChassisBayStack303304Switches NDPChassisType = 44
|
||||
NDPChassisBayStack200EthernetHub NDPChassisType = 45
|
||||
NDPChassisBayStack25010100EthernetHub NDPChassisType = 46
|
||||
NDPChassisBayStack450101001000Switches NDPChassisType = 48
|
||||
NDPChassisBayStack41010100Switches NDPChassisType = 49
|
||||
NDPChassisPassport1200L3Switch NDPChassisType = 50
|
||||
NDPChassisPassport1250L3Switch NDPChassisType = 51
|
||||
NDPChassisPassport1100L3Switch NDPChassisType = 52
|
||||
NDPChassisPassport1150L3Switch NDPChassisType = 53
|
||||
NDPChassisPassport1050L3Switch NDPChassisType = 54
|
||||
NDPChassisPassport1051L3Switch NDPChassisType = 55
|
||||
NDPChassisPassport8610L3Switch NDPChassisType = 56
|
||||
NDPChassisPassport8606L3Switch NDPChassisType = 57
|
||||
NDPChassisPassport8010 NDPChassisType = 58
|
||||
NDPChassisPassport8006 NDPChassisType = 59
|
||||
NDPChassisBayStack670wirelessaccesspoint NDPChassisType = 60
|
||||
NDPChassisPassport740 NDPChassisType = 61
|
||||
NDPChassisPassport750 NDPChassisType = 62
|
||||
NDPChassisPassport790 NDPChassisType = 63
|
||||
NDPChassisBusinessPolicySwitch200010100Switches NDPChassisType = 64
|
||||
NDPChassisPassport8110L2Switch NDPChassisType = 65
|
||||
NDPChassisPassport8106L2Switch NDPChassisType = 66
|
||||
NDPChassisBayStack3580GigSwitch NDPChassisType = 67
|
||||
NDPChassisBayStack10PowerSupplyUnit NDPChassisType = 68
|
||||
NDPChassisBayStack42010100Switch NDPChassisType = 69
|
||||
NDPChassisOPTeraMetro1200EthernetServiceModule NDPChassisType = 70
|
||||
NDPChassisOPTera8010co NDPChassisType = 71
|
||||
NDPChassisOPTera8610coL3Switch NDPChassisType = 72
|
||||
NDPChassisOPTera8110coL2Switch NDPChassisType = 73
|
||||
NDPChassisOPTera8003 NDPChassisType = 74
|
||||
NDPChassisOPTera8603L3Switch NDPChassisType = 75
|
||||
NDPChassisOPTera8103L2Switch NDPChassisType = 76
|
||||
NDPChassisBayStack380101001000Switch NDPChassisType = 77
|
||||
NDPChassisEthernetSwitch47048T NDPChassisType = 78
|
||||
NDPChassisOPTeraMetro1450EthernetServiceModule NDPChassisType = 79
|
||||
NDPChassisOPTeraMetro1400EthernetServiceModule NDPChassisType = 80
|
||||
NDPChassisAlteonSwitchFamily NDPChassisType = 81
|
||||
NDPChassisEthernetSwitch46024TPWR NDPChassisType = 82
|
||||
NDPChassisOPTeraMetro8010OPML2Switch NDPChassisType = 83
|
||||
NDPChassisOPTeraMetro8010coOPML2Switch NDPChassisType = 84
|
||||
NDPChassisOPTeraMetro8006OPML2Switch NDPChassisType = 85
|
||||
NDPChassisOPTeraMetro8003OPML2Switch NDPChassisType = 86
|
||||
NDPChassisAlteon180e NDPChassisType = 87
|
||||
NDPChassisAlteonAD3 NDPChassisType = 88
|
||||
NDPChassisAlteon184 NDPChassisType = 89
|
||||
NDPChassisAlteonAD4 NDPChassisType = 90
|
||||
NDPChassisPassport1424L3Switch NDPChassisType = 91
|
||||
NDPChassisPassport1648L3Switch NDPChassisType = 92
|
||||
NDPChassisPassport1612L3Switch NDPChassisType = 93
|
||||
NDPChassisPassport1624L3Switch NDPChassisType = 94
|
||||
NDPChassisBayStack38024FFiber1000Switch NDPChassisType = 95
|
||||
NDPChassisEthernetRoutingSwitch551024T NDPChassisType = 96
|
||||
NDPChassisEthernetRoutingSwitch551048T NDPChassisType = 97
|
||||
NDPChassisEthernetSwitch47024T NDPChassisType = 98
|
||||
NDPChassisNortelNetworksWirelessLANAccessPoint2220 NDPChassisType = 99
|
||||
NDPChassisPassportRBS2402L3Switch NDPChassisType = 100
|
||||
NDPChassisAlteonApplicationSwitch2424 NDPChassisType = 101
|
||||
NDPChassisAlteonApplicationSwitch2224 NDPChassisType = 102
|
||||
NDPChassisAlteonApplicationSwitch2208 NDPChassisType = 103
|
||||
NDPChassisAlteonApplicationSwitch2216 NDPChassisType = 104
|
||||
NDPChassisAlteonApplicationSwitch3408 NDPChassisType = 105
|
||||
NDPChassisAlteonApplicationSwitch3416 NDPChassisType = 106
|
||||
NDPChassisNortelNetworksWirelessLANSecuritySwitch2250 NDPChassisType = 107
|
||||
NDPChassisEthernetSwitch42548T NDPChassisType = 108
|
||||
NDPChassisEthernetSwitch42524T NDPChassisType = 109
|
||||
NDPChassisNortelNetworksWirelessLANAccessPoint2221 NDPChassisType = 110
|
||||
NDPChassisNortelMetroEthernetServiceUnit24TSPFswitch NDPChassisType = 111
|
||||
NDPChassisNortelMetroEthernetServiceUnit24TLXDCswitch NDPChassisType = 112
|
||||
NDPChassisPassport830010slotchassis NDPChassisType = 113
|
||||
NDPChassisPassport83006slotchassis NDPChassisType = 114
|
||||
NDPChassisEthernetRoutingSwitch552024TPWR NDPChassisType = 115
|
||||
NDPChassisEthernetRoutingSwitch552048TPWR NDPChassisType = 116
|
||||
NDPChassisNortelNetworksVPNGateway3050 NDPChassisType = 117
|
||||
NDPChassisAlteonSSL31010100 NDPChassisType = 118
|
||||
NDPChassisAlteonSSL31010100Fiber NDPChassisType = 119
|
||||
NDPChassisAlteonSSL31010100FIPS NDPChassisType = 120
|
||||
NDPChassisAlteonSSL410101001000 NDPChassisType = 121
|
||||
NDPChassisAlteonSSL410101001000Fiber NDPChassisType = 122
|
||||
NDPChassisAlteonApplicationSwitch2424SSL NDPChassisType = 123
|
||||
NDPChassisEthernetSwitch32524T NDPChassisType = 124
|
||||
NDPChassisEthernetSwitch32524G NDPChassisType = 125
|
||||
NDPChassisNortelNetworksWirelessLANAccessPoint2225 NDPChassisType = 126
|
||||
NDPChassisNortelNetworksWirelessLANSecuritySwitch2270 NDPChassisType = 127
|
||||
NDPChassis24portEthernetSwitch47024TPWR NDPChassisType = 128
|
||||
NDPChassis48portEthernetSwitch47048TPWR NDPChassisType = 129
|
||||
NDPChassisEthernetRoutingSwitch553024TFD NDPChassisType = 130
|
||||
NDPChassisEthernetSwitch351024T NDPChassisType = 131
|
||||
NDPChassisNortelMetroEthernetServiceUnit12GACL3Switch NDPChassisType = 132
|
||||
NDPChassisNortelMetroEthernetServiceUnit12GDCL3Switch NDPChassisType = 133
|
||||
NDPChassisNortelSecureAccessSwitch NDPChassisType = 134
|
||||
NDPChassisNortelNetworksVPNGateway3070 NDPChassisType = 135
|
||||
NDPChassisOPTeraMetro3500 NDPChassisType = 136
|
||||
NDPChassisSMBBES101024T NDPChassisType = 137
|
||||
NDPChassisSMBBES101048T NDPChassisType = 138
|
||||
NDPChassisSMBBES102024TPWR NDPChassisType = 139
|
||||
NDPChassisSMBBES102048TPWR NDPChassisType = 140
|
||||
NDPChassisSMBBES201024T NDPChassisType = 141
|
||||
NDPChassisSMBBES201048T NDPChassisType = 142
|
||||
NDPChassisSMBBES202024TPWR NDPChassisType = 143
|
||||
NDPChassisSMBBES202048TPWR NDPChassisType = 144
|
||||
NDPChassisSMBBES11024T NDPChassisType = 145
|
||||
NDPChassisSMBBES11048T NDPChassisType = 146
|
||||
NDPChassisSMBBES12024TPWR NDPChassisType = 147
|
||||
NDPChassisSMBBES12048TPWR NDPChassisType = 148
|
||||
NDPChassisSMBBES21024T NDPChassisType = 149
|
||||
NDPChassisSMBBES21048T NDPChassisType = 150
|
||||
NDPChassisSMBBES22024TPWR NDPChassisType = 151
|
||||
NDPChassisSMBBES22048TPWR NDPChassisType = 152
|
||||
NDPChassisOME6500 NDPChassisType = 153
|
||||
NDPChassisEthernetRoutingSwitch4548GT NDPChassisType = 154
|
||||
NDPChassisEthernetRoutingSwitch4548GTPWR NDPChassisType = 155
|
||||
NDPChassisEthernetRoutingSwitch4550T NDPChassisType = 156
|
||||
NDPChassisEthernetRoutingSwitch4550TPWR NDPChassisType = 157
|
||||
NDPChassisEthernetRoutingSwitch4526FX NDPChassisType = 158
|
||||
NDPChassisEthernetRoutingSwitch250026T NDPChassisType = 159
|
||||
NDPChassisEthernetRoutingSwitch250026TPWR NDPChassisType = 160
|
||||
NDPChassisEthernetRoutingSwitch250050T NDPChassisType = 161
|
||||
NDPChassisEthernetRoutingSwitch250050TPWR NDPChassisType = 162
|
||||
)
|
||||
|
||||
type NDPBackplaneType uint8
|
||||
|
||||
// Nortel Backplane Types
|
||||
const (
|
||||
NDPBackplaneOther NDPBackplaneType = 1
|
||||
NDPBackplaneEthernet NDPBackplaneType = 2
|
||||
NDPBackplaneEthernetTokenring NDPBackplaneType = 3
|
||||
NDPBackplaneEthernetFDDI NDPBackplaneType = 4
|
||||
NDPBackplaneEthernetTokenringFDDI NDPBackplaneType = 5
|
||||
NDPBackplaneEthernetTokenringRedundantPower NDPBackplaneType = 6
|
||||
NDPBackplaneEthernetTokenringFDDIRedundantPower NDPBackplaneType = 7
|
||||
NDPBackplaneTokenRing NDPBackplaneType = 8
|
||||
NDPBackplaneEthernetTokenringFastEthernet NDPBackplaneType = 9
|
||||
NDPBackplaneEthernetFastEthernet NDPBackplaneType = 10
|
||||
NDPBackplaneEthernetTokenringFastEthernetRedundantPower NDPBackplaneType = 11
|
||||
NDPBackplaneEthernetFastEthernetGigabitEthernet NDPBackplaneType = 12
|
||||
)
|
||||
|
||||
type NDPState uint8
|
||||
|
||||
// Device State
|
||||
const (
|
||||
NDPStateTopology NDPState = 1
|
||||
NDPStateHeartbeat NDPState = 2
|
||||
NDPStateNew NDPState = 3
|
||||
)
|
||||
|
||||
// NortelDiscovery is a packet layer containing the Nortel Discovery Protocol.
|
||||
type NortelDiscovery struct {
|
||||
BaseLayer
|
||||
IPAddress net.IP
|
||||
SegmentID []byte
|
||||
Chassis NDPChassisType
|
||||
Backplane NDPBackplaneType
|
||||
State NDPState
|
||||
NumLinks uint8
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeNortelDiscovery.
|
||||
func (c *NortelDiscovery) LayerType() gopacket.LayerType {
|
||||
return LayerTypeNortelDiscovery
|
||||
}
|
||||
|
||||
func decodeNortelDiscovery(data []byte, p gopacket.PacketBuilder) error {
|
||||
c := &NortelDiscovery{}
|
||||
if len(data) < 11 {
|
||||
return fmt.Errorf("Invalid NortelDiscovery packet length %d", len(data))
|
||||
}
|
||||
c.IPAddress = data[0:4]
|
||||
c.SegmentID = data[4:7]
|
||||
c.Chassis = NDPChassisType(data[7])
|
||||
c.Backplane = NDPBackplaneType(data[8])
|
||||
c.State = NDPState(data[9])
|
||||
c.NumLinks = uint8(data[10])
|
||||
p.AddLayer(c)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t NDPChassisType) String() (s string) {
|
||||
switch t {
|
||||
case NDPChassisother:
|
||||
s = "other"
|
||||
case NDPChassis3000:
|
||||
s = "3000"
|
||||
case NDPChassis3030:
|
||||
s = "3030"
|
||||
case NDPChassis2310:
|
||||
s = "2310"
|
||||
case NDPChassis2810:
|
||||
s = "2810"
|
||||
case NDPChassis2912:
|
||||
s = "2912"
|
||||
case NDPChassis2914:
|
||||
s = "2914"
|
||||
case NDPChassis271x:
|
||||
s = "271x"
|
||||
case NDPChassis2813:
|
||||
s = "2813"
|
||||
case NDPChassis2814:
|
||||
s = "2814"
|
||||
case NDPChassis2915:
|
||||
s = "2915"
|
||||
case NDPChassis5000:
|
||||
s = "5000"
|
||||
case NDPChassis2813SA:
|
||||
s = "2813SA"
|
||||
case NDPChassis2814SA:
|
||||
s = "2814SA"
|
||||
case NDPChassis810M:
|
||||
s = "810M"
|
||||
case NDPChassisEthercell:
|
||||
s = "Ethercell"
|
||||
case NDPChassis5005:
|
||||
s = "5005"
|
||||
case NDPChassisAlcatelEWC:
|
||||
s = "Alcatel Ethernet workgroup conc."
|
||||
case NDPChassis2715SA:
|
||||
s = "2715SA"
|
||||
case NDPChassis2486:
|
||||
s = "2486"
|
||||
case NDPChassis28000series:
|
||||
s = "28000 series"
|
||||
case NDPChassis23000series:
|
||||
s = "23000 series"
|
||||
case NDPChassis5DN00xseries:
|
||||
s = "5DN00x series"
|
||||
case NDPChassisBayStackEthernet:
|
||||
s = "BayStack Ethernet"
|
||||
case NDPChassis23100series:
|
||||
s = "23100 series"
|
||||
case NDPChassis100BaseTHub:
|
||||
s = "100Base-T Hub"
|
||||
case NDPChassis3000FastEthernet:
|
||||
s = "3000 Fast Ethernet"
|
||||
case NDPChassisOrionSwitch:
|
||||
s = "Orion switch"
|
||||
case NDPChassisDDS:
|
||||
s = "DDS"
|
||||
case NDPChassisCentillion6slot:
|
||||
s = "Centillion (6 slot)"
|
||||
case NDPChassisCentillion12slot:
|
||||
s = "Centillion (12 slot)"
|
||||
case NDPChassisCentillion1slot:
|
||||
s = "Centillion (1 slot)"
|
||||
case NDPChassisBayStack301:
|
||||
s = "BayStack 301"
|
||||
case NDPChassisBayStackTokenRingHub:
|
||||
s = "BayStack TokenRing Hub"
|
||||
case NDPChassisFVCMultimediaSwitch:
|
||||
s = "FVC Multimedia Switch"
|
||||
case NDPChassisSwitchNode:
|
||||
s = "Switch Node"
|
||||
case NDPChassisBayStack302Switch:
|
||||
s = "BayStack 302 Switch"
|
||||
case NDPChassisBayStack350Switch:
|
||||
s = "BayStack 350 Switch"
|
||||
case NDPChassisBayStack150EthernetHub:
|
||||
s = "BayStack 150 Ethernet Hub"
|
||||
case NDPChassisCentillion50NSwitch:
|
||||
s = "Centillion 50N switch"
|
||||
case NDPChassisCentillion50TSwitch:
|
||||
s = "Centillion 50T switch"
|
||||
case NDPChassisBayStack303304Switches:
|
||||
s = "BayStack 303 and 304 Switches"
|
||||
case NDPChassisBayStack200EthernetHub:
|
||||
s = "BayStack 200 Ethernet Hub"
|
||||
case NDPChassisBayStack25010100EthernetHub:
|
||||
s = "BayStack 250 10/100 Ethernet Hub"
|
||||
case NDPChassisBayStack450101001000Switches:
|
||||
s = "BayStack 450 10/100/1000 Switches"
|
||||
case NDPChassisBayStack41010100Switches:
|
||||
s = "BayStack 410 10/100 Switches"
|
||||
case NDPChassisPassport1200L3Switch:
|
||||
s = "Passport 1200 L3 Switch"
|
||||
case NDPChassisPassport1250L3Switch:
|
||||
s = "Passport 1250 L3 Switch"
|
||||
case NDPChassisPassport1100L3Switch:
|
||||
s = "Passport 1100 L3 Switch"
|
||||
case NDPChassisPassport1150L3Switch:
|
||||
s = "Passport 1150 L3 Switch"
|
||||
case NDPChassisPassport1050L3Switch:
|
||||
s = "Passport 1050 L3 Switch"
|
||||
case NDPChassisPassport1051L3Switch:
|
||||
s = "Passport 1051 L3 Switch"
|
||||
case NDPChassisPassport8610L3Switch:
|
||||
s = "Passport 8610 L3 Switch"
|
||||
case NDPChassisPassport8606L3Switch:
|
||||
s = "Passport 8606 L3 Switch"
|
||||
case NDPChassisPassport8010:
|
||||
s = "Passport 8010"
|
||||
case NDPChassisPassport8006:
|
||||
s = "Passport 8006"
|
||||
case NDPChassisBayStack670wirelessaccesspoint:
|
||||
s = "BayStack 670 wireless access point"
|
||||
case NDPChassisPassport740:
|
||||
s = "Passport 740"
|
||||
case NDPChassisPassport750:
|
||||
s = "Passport 750"
|
||||
case NDPChassisPassport790:
|
||||
s = "Passport 790"
|
||||
case NDPChassisBusinessPolicySwitch200010100Switches:
|
||||
s = "Business Policy Switch 2000 10/100 Switches"
|
||||
case NDPChassisPassport8110L2Switch:
|
||||
s = "Passport 8110 L2 Switch"
|
||||
case NDPChassisPassport8106L2Switch:
|
||||
s = "Passport 8106 L2 Switch"
|
||||
case NDPChassisBayStack3580GigSwitch:
|
||||
s = "BayStack 3580 Gig Switch"
|
||||
case NDPChassisBayStack10PowerSupplyUnit:
|
||||
s = "BayStack 10 Power Supply Unit"
|
||||
case NDPChassisBayStack42010100Switch:
|
||||
s = "BayStack 420 10/100 Switch"
|
||||
case NDPChassisOPTeraMetro1200EthernetServiceModule:
|
||||
s = "OPTera Metro 1200 Ethernet Service Module"
|
||||
case NDPChassisOPTera8010co:
|
||||
s = "OPTera 8010co"
|
||||
case NDPChassisOPTera8610coL3Switch:
|
||||
s = "OPTera 8610co L3 switch"
|
||||
case NDPChassisOPTera8110coL2Switch:
|
||||
s = "OPTera 8110co L2 switch"
|
||||
case NDPChassisOPTera8003:
|
||||
s = "OPTera 8003"
|
||||
case NDPChassisOPTera8603L3Switch:
|
||||
s = "OPTera 8603 L3 switch"
|
||||
case NDPChassisOPTera8103L2Switch:
|
||||
s = "OPTera 8103 L2 switch"
|
||||
case NDPChassisBayStack380101001000Switch:
|
||||
s = "BayStack 380 10/100/1000 Switch"
|
||||
case NDPChassisEthernetSwitch47048T:
|
||||
s = "Ethernet Switch 470-48T"
|
||||
case NDPChassisOPTeraMetro1450EthernetServiceModule:
|
||||
s = "OPTera Metro 1450 Ethernet Service Module"
|
||||
case NDPChassisOPTeraMetro1400EthernetServiceModule:
|
||||
s = "OPTera Metro 1400 Ethernet Service Module"
|
||||
case NDPChassisAlteonSwitchFamily:
|
||||
s = "Alteon Switch Family"
|
||||
case NDPChassisEthernetSwitch46024TPWR:
|
||||
s = "Ethernet Switch 460-24T-PWR"
|
||||
case NDPChassisOPTeraMetro8010OPML2Switch:
|
||||
s = "OPTera Metro 8010 OPM L2 Switch"
|
||||
case NDPChassisOPTeraMetro8010coOPML2Switch:
|
||||
s = "OPTera Metro 8010co OPM L2 Switch"
|
||||
case NDPChassisOPTeraMetro8006OPML2Switch:
|
||||
s = "OPTera Metro 8006 OPM L2 Switch"
|
||||
case NDPChassisOPTeraMetro8003OPML2Switch:
|
||||
s = "OPTera Metro 8003 OPM L2 Switch"
|
||||
case NDPChassisAlteon180e:
|
||||
s = "Alteon 180e"
|
||||
case NDPChassisAlteonAD3:
|
||||
s = "Alteon AD3"
|
||||
case NDPChassisAlteon184:
|
||||
s = "Alteon 184"
|
||||
case NDPChassisAlteonAD4:
|
||||
s = "Alteon AD4"
|
||||
case NDPChassisPassport1424L3Switch:
|
||||
s = "Passport 1424 L3 switch"
|
||||
case NDPChassisPassport1648L3Switch:
|
||||
s = "Passport 1648 L3 switch"
|
||||
case NDPChassisPassport1612L3Switch:
|
||||
s = "Passport 1612 L3 switch"
|
||||
case NDPChassisPassport1624L3Switch:
|
||||
s = "Passport 1624 L3 switch"
|
||||
case NDPChassisBayStack38024FFiber1000Switch:
|
||||
s = "BayStack 380-24F Fiber 1000 Switch"
|
||||
case NDPChassisEthernetRoutingSwitch551024T:
|
||||
s = "Ethernet Routing Switch 5510-24T"
|
||||
case NDPChassisEthernetRoutingSwitch551048T:
|
||||
s = "Ethernet Routing Switch 5510-48T"
|
||||
case NDPChassisEthernetSwitch47024T:
|
||||
s = "Ethernet Switch 470-24T"
|
||||
case NDPChassisNortelNetworksWirelessLANAccessPoint2220:
|
||||
s = "Nortel Networks Wireless LAN Access Point 2220"
|
||||
case NDPChassisPassportRBS2402L3Switch:
|
||||
s = "Passport RBS 2402 L3 switch"
|
||||
case NDPChassisAlteonApplicationSwitch2424:
|
||||
s = "Alteon Application Switch 2424"
|
||||
case NDPChassisAlteonApplicationSwitch2224:
|
||||
s = "Alteon Application Switch 2224"
|
||||
case NDPChassisAlteonApplicationSwitch2208:
|
||||
s = "Alteon Application Switch 2208"
|
||||
case NDPChassisAlteonApplicationSwitch2216:
|
||||
s = "Alteon Application Switch 2216"
|
||||
case NDPChassisAlteonApplicationSwitch3408:
|
||||
s = "Alteon Application Switch 3408"
|
||||
case NDPChassisAlteonApplicationSwitch3416:
|
||||
s = "Alteon Application Switch 3416"
|
||||
case NDPChassisNortelNetworksWirelessLANSecuritySwitch2250:
|
||||
s = "Nortel Networks Wireless LAN SecuritySwitch 2250"
|
||||
case NDPChassisEthernetSwitch42548T:
|
||||
s = "Ethernet Switch 425-48T"
|
||||
case NDPChassisEthernetSwitch42524T:
|
||||
s = "Ethernet Switch 425-24T"
|
||||
case NDPChassisNortelNetworksWirelessLANAccessPoint2221:
|
||||
s = "Nortel Networks Wireless LAN Access Point 2221"
|
||||
case NDPChassisNortelMetroEthernetServiceUnit24TSPFswitch:
|
||||
s = "Nortel Metro Ethernet Service Unit 24-T SPF switch"
|
||||
case NDPChassisNortelMetroEthernetServiceUnit24TLXDCswitch:
|
||||
s = " Nortel Metro Ethernet Service Unit 24-T LX DC switch"
|
||||
case NDPChassisPassport830010slotchassis:
|
||||
s = "Passport 8300 10-slot chassis"
|
||||
case NDPChassisPassport83006slotchassis:
|
||||
s = "Passport 8300 6-slot chassis"
|
||||
case NDPChassisEthernetRoutingSwitch552024TPWR:
|
||||
s = "Ethernet Routing Switch 5520-24T-PWR"
|
||||
case NDPChassisEthernetRoutingSwitch552048TPWR:
|
||||
s = "Ethernet Routing Switch 5520-48T-PWR"
|
||||
case NDPChassisNortelNetworksVPNGateway3050:
|
||||
s = "Nortel Networks VPN Gateway 3050"
|
||||
case NDPChassisAlteonSSL31010100:
|
||||
s = "Alteon SSL 310 10/100"
|
||||
case NDPChassisAlteonSSL31010100Fiber:
|
||||
s = "Alteon SSL 310 10/100 Fiber"
|
||||
case NDPChassisAlteonSSL31010100FIPS:
|
||||
s = "Alteon SSL 310 10/100 FIPS"
|
||||
case NDPChassisAlteonSSL410101001000:
|
||||
s = "Alteon SSL 410 10/100/1000"
|
||||
case NDPChassisAlteonSSL410101001000Fiber:
|
||||
s = "Alteon SSL 410 10/100/1000 Fiber"
|
||||
case NDPChassisAlteonApplicationSwitch2424SSL:
|
||||
s = "Alteon Application Switch 2424-SSL"
|
||||
case NDPChassisEthernetSwitch32524T:
|
||||
s = "Ethernet Switch 325-24T"
|
||||
case NDPChassisEthernetSwitch32524G:
|
||||
s = "Ethernet Switch 325-24G"
|
||||
case NDPChassisNortelNetworksWirelessLANAccessPoint2225:
|
||||
s = "Nortel Networks Wireless LAN Access Point 2225"
|
||||
case NDPChassisNortelNetworksWirelessLANSecuritySwitch2270:
|
||||
s = "Nortel Networks Wireless LAN SecuritySwitch 2270"
|
||||
case NDPChassis24portEthernetSwitch47024TPWR:
|
||||
s = "24-port Ethernet Switch 470-24T-PWR"
|
||||
case NDPChassis48portEthernetSwitch47048TPWR:
|
||||
s = "48-port Ethernet Switch 470-48T-PWR"
|
||||
case NDPChassisEthernetRoutingSwitch553024TFD:
|
||||
s = "Ethernet Routing Switch 5530-24TFD"
|
||||
case NDPChassisEthernetSwitch351024T:
|
||||
s = "Ethernet Switch 3510-24T"
|
||||
case NDPChassisNortelMetroEthernetServiceUnit12GACL3Switch:
|
||||
s = "Nortel Metro Ethernet Service Unit 12G AC L3 switch"
|
||||
case NDPChassisNortelMetroEthernetServiceUnit12GDCL3Switch:
|
||||
s = "Nortel Metro Ethernet Service Unit 12G DC L3 switch"
|
||||
case NDPChassisNortelSecureAccessSwitch:
|
||||
s = "Nortel Secure Access Switch"
|
||||
case NDPChassisNortelNetworksVPNGateway3070:
|
||||
s = "Nortel Networks VPN Gateway 3070"
|
||||
case NDPChassisOPTeraMetro3500:
|
||||
s = "OPTera Metro 3500"
|
||||
case NDPChassisSMBBES101024T:
|
||||
s = "SMB BES 1010 24T"
|
||||
case NDPChassisSMBBES101048T:
|
||||
s = "SMB BES 1010 48T"
|
||||
case NDPChassisSMBBES102024TPWR:
|
||||
s = "SMB BES 1020 24T PWR"
|
||||
case NDPChassisSMBBES102048TPWR:
|
||||
s = "SMB BES 1020 48T PWR"
|
||||
case NDPChassisSMBBES201024T:
|
||||
s = "SMB BES 2010 24T"
|
||||
case NDPChassisSMBBES201048T:
|
||||
s = "SMB BES 2010 48T"
|
||||
case NDPChassisSMBBES202024TPWR:
|
||||
s = "SMB BES 2020 24T PWR"
|
||||
case NDPChassisSMBBES202048TPWR:
|
||||
s = "SMB BES 2020 48T PWR"
|
||||
case NDPChassisSMBBES11024T:
|
||||
s = "SMB BES 110 24T"
|
||||
case NDPChassisSMBBES11048T:
|
||||
s = "SMB BES 110 48T"
|
||||
case NDPChassisSMBBES12024TPWR:
|
||||
s = "SMB BES 120 24T PWR"
|
||||
case NDPChassisSMBBES12048TPWR:
|
||||
s = "SMB BES 120 48T PWR"
|
||||
case NDPChassisSMBBES21024T:
|
||||
s = "SMB BES 210 24T"
|
||||
case NDPChassisSMBBES21048T:
|
||||
s = "SMB BES 210 48T"
|
||||
case NDPChassisSMBBES22024TPWR:
|
||||
s = "SMB BES 220 24T PWR"
|
||||
case NDPChassisSMBBES22048TPWR:
|
||||
s = "SMB BES 220 48T PWR"
|
||||
case NDPChassisOME6500:
|
||||
s = "OME 6500"
|
||||
case NDPChassisEthernetRoutingSwitch4548GT:
|
||||
s = "Ethernet Routing Switch 4548GT"
|
||||
case NDPChassisEthernetRoutingSwitch4548GTPWR:
|
||||
s = "Ethernet Routing Switch 4548GT-PWR"
|
||||
case NDPChassisEthernetRoutingSwitch4550T:
|
||||
s = "Ethernet Routing Switch 4550T"
|
||||
case NDPChassisEthernetRoutingSwitch4550TPWR:
|
||||
s = "Ethernet Routing Switch 4550T-PWR"
|
||||
case NDPChassisEthernetRoutingSwitch4526FX:
|
||||
s = "Ethernet Routing Switch 4526FX"
|
||||
case NDPChassisEthernetRoutingSwitch250026T:
|
||||
s = "Ethernet Routing Switch 2500-26T"
|
||||
case NDPChassisEthernetRoutingSwitch250026TPWR:
|
||||
s = "Ethernet Routing Switch 2500-26T-PWR"
|
||||
case NDPChassisEthernetRoutingSwitch250050T:
|
||||
s = "Ethernet Routing Switch 2500-50T"
|
||||
case NDPChassisEthernetRoutingSwitch250050TPWR:
|
||||
s = "Ethernet Routing Switch 2500-50T-PWR"
|
||||
default:
|
||||
s = "Unknown"
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (t NDPBackplaneType) String() (s string) {
|
||||
switch t {
|
||||
case NDPBackplaneOther:
|
||||
s = "Other"
|
||||
case NDPBackplaneEthernet:
|
||||
s = "Ethernet"
|
||||
case NDPBackplaneEthernetTokenring:
|
||||
s = "Ethernet and Tokenring"
|
||||
case NDPBackplaneEthernetFDDI:
|
||||
s = "Ethernet and FDDI"
|
||||
case NDPBackplaneEthernetTokenringFDDI:
|
||||
s = "Ethernet, Tokenring and FDDI"
|
||||
case NDPBackplaneEthernetTokenringRedundantPower:
|
||||
s = "Ethernet and Tokenring with redundant power"
|
||||
case NDPBackplaneEthernetTokenringFDDIRedundantPower:
|
||||
s = "Ethernet, Tokenring, FDDI with redundant power"
|
||||
case NDPBackplaneTokenRing:
|
||||
s = "Token Ring"
|
||||
case NDPBackplaneEthernetTokenringFastEthernet:
|
||||
s = "Ethernet, Tokenring and Fast Ethernet"
|
||||
case NDPBackplaneEthernetFastEthernet:
|
||||
s = "Ethernet and Fast Ethernet"
|
||||
case NDPBackplaneEthernetTokenringFastEthernetRedundantPower:
|
||||
s = "Ethernet, Tokenring, Fast Ethernet with redundant power"
|
||||
case NDPBackplaneEthernetFastEthernetGigabitEthernet:
|
||||
s = "Ethernet, Fast Ethernet and Gigabit Ethernet"
|
||||
default:
|
||||
s = "Unknown"
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (t NDPState) String() (s string) {
|
||||
switch t {
|
||||
case NDPStateTopology:
|
||||
s = "Topology Change"
|
||||
case NDPStateHeartbeat:
|
||||
s = "Heartbeat"
|
||||
case NDPStateNew:
|
||||
s = "New"
|
||||
default:
|
||||
s = "Unknown"
|
||||
}
|
||||
return
|
||||
}
|
||||
@ -0,0 +1,416 @@
|
||||
// Copyright 2016 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
//******************************************************************************
|
||||
//
|
||||
// Network Time Protocol (NTP) Decoding Layer
|
||||
// ------------------------------------------
|
||||
// This file provides a GoPacket decoding layer for NTP.
|
||||
//
|
||||
//******************************************************************************
|
||||
//
|
||||
// About The Network Time Protocol (NTP)
|
||||
// -------------------------------------
|
||||
// NTP is a protocol that enables computers on the internet to set their
|
||||
// clocks to the correct time (or to a time that is acceptably close to the
|
||||
// correct time). NTP runs on top of UDP.
|
||||
//
|
||||
// There have been a series of versions of the NTP protocol. The latest
|
||||
// version is V4 and is specified in RFC 5905:
|
||||
// http://www.ietf.org/rfc/rfc5905.txt
|
||||
//
|
||||
//******************************************************************************
|
||||
//
|
||||
// References
|
||||
// ----------
|
||||
//
|
||||
// Wikipedia's NTP entry:
|
||||
// https://en.wikipedia.org/wiki/Network_Time_Protocol
|
||||
// This is the best place to get an overview of NTP.
|
||||
//
|
||||
// Network Time Protocol Home Website:
|
||||
// http://www.ntp.org/
|
||||
// This appears to be the official website of NTP.
|
||||
//
|
||||
// List of current NTP Protocol RFCs:
|
||||
// http://www.ntp.org/rfc.html
|
||||
//
|
||||
// RFC 958: "Network Time Protocol (NTP)" (1985)
|
||||
// https://tools.ietf.org/html/rfc958
|
||||
// This is the original NTP specification.
|
||||
//
|
||||
// RFC 1305: "Network Time Protocol (Version 3) Specification, Implementation and Analysis" (1992)
|
||||
// https://tools.ietf.org/html/rfc1305
|
||||
// The protocol was updated in 1992 yielding NTP V3.
|
||||
//
|
||||
// RFC 5905: "Network Time Protocol Version 4: Protocol and Algorithms Specification" (2010)
|
||||
// https://www.ietf.org/rfc/rfc5905.txt
|
||||
// The protocol was updated in 2010 yielding NTP V4.
|
||||
// V4 is backwards compatible with all previous versions of NTP.
|
||||
//
|
||||
// RFC 5906: "Network Time Protocol Version 4: Autokey Specification"
|
||||
// https://tools.ietf.org/html/rfc5906
|
||||
// This document addresses the security of the NTP protocol
|
||||
// and is probably not relevant to this package.
|
||||
//
|
||||
// RFC 5907: "Definitions of Managed Objects for Network Time Protocol Version 4 (NTPv4)"
|
||||
// https://tools.ietf.org/html/rfc5907
|
||||
// This document addresses the management of NTP servers and
|
||||
// is probably not relevant to this package.
|
||||
//
|
||||
// RFC 5908: "Network Time Protocol (NTP) Server Option for DHCPv6"
|
||||
// https://tools.ietf.org/html/rfc5908
|
||||
// This document addresses the use of NTP in DHCPv6 and is
|
||||
// probably not relevant to this package.
|
||||
//
|
||||
// "Let's make a NTP Client in C"
|
||||
// https://lettier.github.io/posts/2016-04-26-lets-make-a-ntp-client-in-c.html
|
||||
// This web page contains useful information about the details of NTP,
|
||||
// including an NTP record struture in C, and C code.
|
||||
//
|
||||
// "NTP Packet Header (NTP Reference Implementation) (Computer Network Time Synchronization)"
|
||||
// http://what-when-how.com/computer-network-time-synchronization/
|
||||
// ntp-packet-header-ntp-reference-implementation-computer-network-time-synchronization/
|
||||
// This web page contains useful information on the details of NTP.
|
||||
//
|
||||
// "Technical information - NTP Data Packet"
|
||||
// https://www.meinbergglobal.com/english/info/ntp-packet.htm
|
||||
// This page has a helpful diagram of an NTP V4 packet.
|
||||
//
|
||||
//******************************************************************************
|
||||
//
|
||||
// Obsolete References
|
||||
// -------------------
|
||||
//
|
||||
// RFC 1119: "RFC-1119 "Network Time Protocol (Version 2) Specification and Implementation" (1989)
|
||||
// https://tools.ietf.org/html/rfc1119
|
||||
// Version 2 was drafted in 1989.
|
||||
// It is unclear whether V2 was ever implememented or whether the
|
||||
// ideas ended up in V3 (which was implemented in 1992).
|
||||
//
|
||||
// RFC 1361: "Simple Network Time Protocol (SNTP)"
|
||||
// https://tools.ietf.org/html/rfc1361
|
||||
// This document is obsoleted by RFC 1769 and is included only for completeness.
|
||||
//
|
||||
// RFC 1769: "Simple Network Time Protocol (SNTP)"
|
||||
// https://tools.ietf.org/html/rfc1769
|
||||
// This document is obsoleted by RFC 2030 and RFC 4330 and is included only for completeness.
|
||||
//
|
||||
// RFC 2030: "Simple Network Time Protocol (SNTP) Version 4 for IPv4, IPv6 and OSI"
|
||||
// https://tools.ietf.org/html/rfc2030
|
||||
// This document is obsoleted by RFC 4330 and is included only for completeness.
|
||||
//
|
||||
// RFC 4330: "Simple Network Time Protocol (SNTP) Version 4 for IPv4, IPv6 and OSI"
|
||||
// https://tools.ietf.org/html/rfc4330
|
||||
// This document is obsoleted by RFC 5905 and is included only for completeness.
|
||||
//
|
||||
//******************************************************************************
|
||||
//
|
||||
// Endian And Bit Numbering Issues
|
||||
// -------------------------------
|
||||
//
|
||||
// Endian and bit numbering issues can be confusing. Here is some
|
||||
// clarification:
|
||||
//
|
||||
// ENDIAN: Values are sent big endian.
|
||||
// https://en.wikipedia.org/wiki/Endianness
|
||||
//
|
||||
// BIT NUMBERING: Bits are numbered 0 upwards from the most significant
|
||||
// bit to the least significant bit. This means that if there is a 32-bit
|
||||
// value, the most significant bit is called bit 0 and the least
|
||||
// significant bit is called bit 31.
|
||||
//
|
||||
// See RFC 791 Appendix B for more discussion.
|
||||
//
|
||||
//******************************************************************************
|
||||
//
|
||||
// NTP V3 and V4 Packet Format
|
||||
// ---------------------------
|
||||
// NTP packets are UDP packets whose payload contains an NTP record.
|
||||
//
|
||||
// The NTP RFC defines the format of the NTP record.
|
||||
//
|
||||
// There have been four versions of the protocol:
|
||||
//
|
||||
// V1 in 1985
|
||||
// V2 in 1989
|
||||
// V3 in 1992
|
||||
// V4 in 2010
|
||||
//
|
||||
// It is clear that V1 and V2 are obsolete, and there is no need to
|
||||
// cater for these formats.
|
||||
//
|
||||
// V3 and V4 essentially use the same format, with V4 adding some optional
|
||||
// fields on the end. So this package supports the V3 and V4 formats.
|
||||
//
|
||||
// The current version of NTP (NTP V4)'s RFC (V4 - RFC 5905) contains
|
||||
// the following diagram for the NTP record format:
|
||||
|
||||
// 0 1 2 3
|
||||
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// |LI | VN |Mode | Stratum | Poll | Precision |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Root Delay |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Root Dispersion |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Reference ID |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// + Reference Timestamp (64) +
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// + Origin Timestamp (64) +
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// + Receive Timestamp (64) +
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// + Transmit Timestamp (64) +
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// . .
|
||||
// . Extension Field 1 (variable) .
|
||||
// . .
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// . .
|
||||
// . Extension Field 2 (variable) .
|
||||
// . .
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | Key Identifier |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | |
|
||||
// | dgst (128) |
|
||||
// | |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// From http://www.ietf.org/rfc/rfc5905.txt
|
||||
//
|
||||
// The fields "Extension Field 1 (variable)" and later are optional fields,
|
||||
// and so we can set a minimum NTP record size of 48 bytes.
|
||||
//
|
||||
const ntpMinimumRecordSizeInBytes int = 48
|
||||
|
||||
//******************************************************************************
|
||||
|
||||
// NTP Type
|
||||
// --------
|
||||
// Type NTP implements the DecodingLayer interface. Each NTP object
|
||||
// represents in a structured form the NTP record present as the UDP
|
||||
// payload in an NTP UDP packet.
|
||||
//
|
||||
|
||||
type NTPLeapIndicator uint8
|
||||
type NTPVersion uint8
|
||||
type NTPMode uint8
|
||||
type NTPStratum uint8
|
||||
type NTPLog2Seconds int8
|
||||
type NTPFixed16Seconds uint32
|
||||
type NTPReferenceID uint32
|
||||
type NTPTimestamp uint64
|
||||
|
||||
type NTP struct {
|
||||
BaseLayer // Stores the packet bytes and payload bytes.
|
||||
|
||||
LeapIndicator NTPLeapIndicator // [0,3]. Indicates whether leap second(s) is to be added.
|
||||
Version NTPVersion // [0,7]. Version of the NTP protocol.
|
||||
Mode NTPMode // [0,7]. Mode.
|
||||
Stratum NTPStratum // [0,255]. Stratum of time server in the server tree.
|
||||
Poll NTPLog2Seconds // [-128,127]. The maximum interval between successive messages, in log2 seconds.
|
||||
Precision NTPLog2Seconds // [-128,127]. The precision of the system clock, in log2 seconds.
|
||||
RootDelay NTPFixed16Seconds // [0,2^32-1]. Total round trip delay to the reference clock in seconds times 2^16.
|
||||
RootDispersion NTPFixed16Seconds // [0,2^32-1]. Total dispersion to the reference clock, in seconds times 2^16.
|
||||
ReferenceID NTPReferenceID // ID code of reference clock [0,2^32-1].
|
||||
ReferenceTimestamp NTPTimestamp // Most recent timestamp from the reference clock.
|
||||
OriginTimestamp NTPTimestamp // Local time when request was sent from local host.
|
||||
ReceiveTimestamp NTPTimestamp // Local time (on server) that request arrived at server host.
|
||||
TransmitTimestamp NTPTimestamp // Local time (on server) that request departed server host.
|
||||
|
||||
// FIX: This package should analyse the extension fields and represent the extension fields too.
|
||||
ExtensionBytes []byte // Just put extensions in a byte slice.
|
||||
}
|
||||
|
||||
//******************************************************************************
|
||||
|
||||
// LayerType returns the layer type of the NTP object, which is LayerTypeNTP.
|
||||
func (d *NTP) LayerType() gopacket.LayerType {
|
||||
return LayerTypeNTP
|
||||
}
|
||||
|
||||
//******************************************************************************
|
||||
|
||||
// decodeNTP analyses a byte slice and attempts to decode it as an NTP
|
||||
// record of a UDP packet.
|
||||
//
|
||||
// If it succeeds, it loads p with information about the packet and returns nil.
|
||||
// If it fails, it returns an error (non nil).
|
||||
//
|
||||
// This function is employed in layertypes.go to register the NTP layer.
|
||||
func decodeNTP(data []byte, p gopacket.PacketBuilder) error {
|
||||
|
||||
// Attempt to decode the byte slice.
|
||||
d := &NTP{}
|
||||
err := d.DecodeFromBytes(data, p)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// If the decoding worked, add the layer to the packet and set it
|
||||
// as the application layer too, if there isn't already one.
|
||||
p.AddLayer(d)
|
||||
p.SetApplicationLayer(d)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
//******************************************************************************
|
||||
|
||||
// DecodeFromBytes analyses a byte slice and attempts to decode it as an NTP
|
||||
// record of a UDP packet.
|
||||
//
|
||||
// Upon succeeds, it loads the NTP object with information about the packet
|
||||
// and returns nil.
|
||||
// Upon failure, it returns an error (non nil).
|
||||
func (d *NTP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
|
||||
// If the data block is too short to be a NTP record, then return an error.
|
||||
if len(data) < ntpMinimumRecordSizeInBytes {
|
||||
df.SetTruncated()
|
||||
return errors.New("NTP packet too short")
|
||||
}
|
||||
|
||||
// RFC 5905 does not appear to define a maximum NTP record length.
|
||||
// The protocol allows "extension fields" to be included in the record,
|
||||
// and states about these fields:"
|
||||
//
|
||||
// "While the minimum field length containing required fields is
|
||||
// four words (16 octets), a maximum field length remains to be
|
||||
// established."
|
||||
//
|
||||
// For this reason, the packet length is not checked here for being too long.
|
||||
|
||||
// NTP type embeds type BaseLayer which contains two fields:
|
||||
// Contents is supposed to contain the bytes of the data at this level.
|
||||
// Payload is supposed to contain the payload of this level.
|
||||
// Here we set the baselayer to be the bytes of the NTP record.
|
||||
d.BaseLayer = BaseLayer{Contents: data[:len(data)]}
|
||||
|
||||
// Extract the fields from the block of bytes.
|
||||
// To make sense of this, refer to the packet diagram
|
||||
// above and the section on endian conventions.
|
||||
|
||||
// The first few fields are all packed into the first 32 bits. Unpack them.
|
||||
f := data[0]
|
||||
d.LeapIndicator = NTPLeapIndicator((f & 0xC0) >> 6)
|
||||
d.Version = NTPVersion((f & 0x38) >> 3)
|
||||
d.Mode = NTPMode(f & 0x07)
|
||||
d.Stratum = NTPStratum(data[1])
|
||||
d.Poll = NTPLog2Seconds(data[2])
|
||||
d.Precision = NTPLog2Seconds(data[3])
|
||||
|
||||
// The remaining fields can just be copied in big endian order.
|
||||
d.RootDelay = NTPFixed16Seconds(binary.BigEndian.Uint32(data[4:8]))
|
||||
d.RootDispersion = NTPFixed16Seconds(binary.BigEndian.Uint32(data[8:12]))
|
||||
d.ReferenceID = NTPReferenceID(binary.BigEndian.Uint32(data[12:16]))
|
||||
d.ReferenceTimestamp = NTPTimestamp(binary.BigEndian.Uint64(data[16:24]))
|
||||
d.OriginTimestamp = NTPTimestamp(binary.BigEndian.Uint64(data[24:32]))
|
||||
d.ReceiveTimestamp = NTPTimestamp(binary.BigEndian.Uint64(data[32:40]))
|
||||
d.TransmitTimestamp = NTPTimestamp(binary.BigEndian.Uint64(data[40:48]))
|
||||
|
||||
// This layer does not attempt to analyse the extension bytes.
|
||||
// But if there are any, we'd like the user to know. So we just
|
||||
// place them all in an ExtensionBytes field.
|
||||
d.ExtensionBytes = data[48:]
|
||||
|
||||
// Return no error.
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (d *NTP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
data, err := b.PrependBytes(ntpMinimumRecordSizeInBytes)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Pack the first few fields into the first 32 bits.
|
||||
h := uint8(0)
|
||||
h |= (uint8(d.LeapIndicator) << 6) & 0xC0
|
||||
h |= (uint8(d.Version) << 3) & 0x38
|
||||
h |= (uint8(d.Mode)) & 0x07
|
||||
data[0] = byte(h)
|
||||
data[1] = byte(d.Stratum)
|
||||
data[2] = byte(d.Poll)
|
||||
data[3] = byte(d.Precision)
|
||||
|
||||
// The remaining fields can just be copied in big endian order.
|
||||
binary.BigEndian.PutUint32(data[4:8], uint32(d.RootDelay))
|
||||
binary.BigEndian.PutUint32(data[8:12], uint32(d.RootDispersion))
|
||||
binary.BigEndian.PutUint32(data[12:16], uint32(d.ReferenceID))
|
||||
binary.BigEndian.PutUint64(data[16:24], uint64(d.ReferenceTimestamp))
|
||||
binary.BigEndian.PutUint64(data[24:32], uint64(d.OriginTimestamp))
|
||||
binary.BigEndian.PutUint64(data[32:40], uint64(d.ReceiveTimestamp))
|
||||
binary.BigEndian.PutUint64(data[40:48], uint64(d.TransmitTimestamp))
|
||||
|
||||
ex, err := b.AppendBytes(len(d.ExtensionBytes))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
copy(ex, d.ExtensionBytes)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
//******************************************************************************
|
||||
|
||||
// CanDecode returns a set of layers that NTP objects can decode.
|
||||
// As NTP objects can only decide the NTP layer, we can return just that layer.
|
||||
// Apparently a single layer type implements LayerClass.
|
||||
func (d *NTP) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeNTP
|
||||
}
|
||||
|
||||
//******************************************************************************
|
||||
|
||||
// NextLayerType specifies the next layer that GoPacket should attempt to
|
||||
// analyse after this (NTP) layer. As NTP packets do not contain any payload
|
||||
// bytes, there are no further layers to analyse.
|
||||
func (d *NTP) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypeZero
|
||||
}
|
||||
|
||||
//******************************************************************************
|
||||
|
||||
// NTP packets do not carry any data payload, so the empty byte slice is retured.
|
||||
// In Go, a nil slice is functionally identical to an empty slice, so we
|
||||
// return nil to avoid a heap allocation.
|
||||
func (d *NTP) Payload() []byte {
|
||||
return nil
|
||||
}
|
||||
|
||||
//******************************************************************************
|
||||
//* End Of NTP File *
|
||||
//******************************************************************************
|
||||
@ -0,0 +1,76 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
type PFDirection uint8
|
||||
|
||||
const (
|
||||
PFDirectionInOut PFDirection = 0
|
||||
PFDirectionIn PFDirection = 1
|
||||
PFDirectionOut PFDirection = 2
|
||||
)
|
||||
|
||||
// PFLog provides the layer for 'pf' packet-filter logging, as described at
|
||||
// http://www.freebsd.org/cgi/man.cgi?query=pflog&sektion=4
|
||||
type PFLog struct {
|
||||
BaseLayer
|
||||
Length uint8
|
||||
Family ProtocolFamily
|
||||
Action, Reason uint8
|
||||
IFName, Ruleset []byte
|
||||
RuleNum, SubruleNum uint32
|
||||
UID uint32
|
||||
PID int32
|
||||
RuleUID uint32
|
||||
RulePID int32
|
||||
Direction PFDirection
|
||||
// The remainder is padding
|
||||
}
|
||||
|
||||
func (pf *PFLog) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
pf.Length = data[0]
|
||||
pf.Family = ProtocolFamily(data[1])
|
||||
pf.Action = data[2]
|
||||
pf.Reason = data[3]
|
||||
pf.IFName = data[4:20]
|
||||
pf.Ruleset = data[20:36]
|
||||
pf.RuleNum = binary.BigEndian.Uint32(data[36:40])
|
||||
pf.SubruleNum = binary.BigEndian.Uint32(data[40:44])
|
||||
pf.UID = binary.BigEndian.Uint32(data[44:48])
|
||||
pf.PID = int32(binary.BigEndian.Uint32(data[48:52]))
|
||||
pf.RuleUID = binary.BigEndian.Uint32(data[52:56])
|
||||
pf.RulePID = int32(binary.BigEndian.Uint32(data[56:60]))
|
||||
pf.Direction = PFDirection(data[60])
|
||||
if pf.Length%4 != 1 {
|
||||
return errors.New("PFLog header length should be 3 less than multiple of 4")
|
||||
}
|
||||
actualLength := int(pf.Length) + 3
|
||||
pf.Contents = data[:actualLength]
|
||||
pf.Payload = data[actualLength:]
|
||||
return nil
|
||||
}
|
||||
|
||||
// LayerType returns layers.LayerTypePFLog
|
||||
func (pf *PFLog) LayerType() gopacket.LayerType { return LayerTypePFLog }
|
||||
|
||||
func (pf *PFLog) CanDecode() gopacket.LayerClass { return LayerTypePFLog }
|
||||
|
||||
func (pf *PFLog) NextLayerType() gopacket.LayerType {
|
||||
return pf.Family.LayerType()
|
||||
}
|
||||
|
||||
func decodePFLog(data []byte, p gopacket.PacketBuilder) error {
|
||||
pf := &PFLog{}
|
||||
return decodingLayerDecoder(pf, data, p)
|
||||
}
|
||||
@ -0,0 +1,139 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"fmt"
|
||||
"strconv"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// TCPPort is a port in a TCP layer.
|
||||
type TCPPort uint16
|
||||
|
||||
// UDPPort is a port in a UDP layer.
|
||||
type UDPPort uint16
|
||||
|
||||
// RUDPPort is a port in a RUDP layer.
|
||||
type RUDPPort uint8
|
||||
|
||||
// SCTPPort is a port in a SCTP layer.
|
||||
type SCTPPort uint16
|
||||
|
||||
// UDPLitePort is a port in a UDPLite layer.
|
||||
type UDPLitePort uint16
|
||||
|
||||
// RUDPPortNames contains the string names for all RUDP ports.
|
||||
var RUDPPortNames = map[RUDPPort]string{}
|
||||
|
||||
// UDPLitePortNames contains the string names for all UDPLite ports.
|
||||
var UDPLitePortNames = map[UDPLitePort]string{}
|
||||
|
||||
// {TCP,UDP,SCTP}PortNames can be found in iana_ports.go
|
||||
|
||||
// String returns the port as "number(name)" if there's a well-known port name,
|
||||
// or just "number" if there isn't. Well-known names are stored in
|
||||
// TCPPortNames.
|
||||
func (a TCPPort) String() string {
|
||||
if name, ok := TCPPortNames[a]; ok {
|
||||
return fmt.Sprintf("%d(%s)", a, name)
|
||||
}
|
||||
return strconv.Itoa(int(a))
|
||||
}
|
||||
|
||||
// LayerType returns a LayerType that would be able to decode the
|
||||
// application payload. It uses some well-known ports such as 53 for
|
||||
// DNS.
|
||||
//
|
||||
// Returns gopacket.LayerTypePayload for unknown/unsupported port numbers.
|
||||
func (a TCPPort) LayerType() gopacket.LayerType {
|
||||
lt := tcpPortLayerType[uint16(a)]
|
||||
if lt != 0 {
|
||||
return lt
|
||||
}
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
var tcpPortLayerType = [65536]gopacket.LayerType{
|
||||
53: LayerTypeDNS,
|
||||
}
|
||||
|
||||
// RegisterTCPPortLayerType creates a new mapping between a TCPPort
|
||||
// and an underlaying LayerType.
|
||||
func RegisterTCPPortLayerType(port TCPPort, layerType gopacket.LayerType) {
|
||||
tcpPortLayerType[port] = layerType
|
||||
}
|
||||
|
||||
// String returns the port as "number(name)" if there's a well-known port name,
|
||||
// or just "number" if there isn't. Well-known names are stored in
|
||||
// UDPPortNames.
|
||||
func (a UDPPort) String() string {
|
||||
if name, ok := UDPPortNames[a]; ok {
|
||||
return fmt.Sprintf("%d(%s)", a, name)
|
||||
}
|
||||
return strconv.Itoa(int(a))
|
||||
}
|
||||
|
||||
// LayerType returns a LayerType that would be able to decode the
|
||||
// application payload. It uses some well-known ports such as 53 for
|
||||
// DNS.
|
||||
//
|
||||
// Returns gopacket.LayerTypePayload for unknown/unsupported port numbers.
|
||||
func (a UDPPort) LayerType() gopacket.LayerType {
|
||||
lt := udpPortLayerType[uint16(a)]
|
||||
if lt != 0 {
|
||||
return lt
|
||||
}
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
var udpPortLayerType = [65536]gopacket.LayerType{
|
||||
53: LayerTypeDNS,
|
||||
123: LayerTypeNTP,
|
||||
4789: LayerTypeVXLAN,
|
||||
67: LayerTypeDHCPv4,
|
||||
68: LayerTypeDHCPv4,
|
||||
6343: LayerTypeSFlow,
|
||||
6081: LayerTypeGeneve,
|
||||
}
|
||||
|
||||
// RegisterUDPPortLayerType creates a new mapping between a UDPPort
|
||||
// and an underlaying LayerType.
|
||||
func RegisterUDPPortLayerType(port UDPPort, layerType gopacket.LayerType) {
|
||||
udpPortLayerType[port] = layerType
|
||||
}
|
||||
|
||||
// String returns the port as "number(name)" if there's a well-known port name,
|
||||
// or just "number" if there isn't. Well-known names are stored in
|
||||
// RUDPPortNames.
|
||||
func (a RUDPPort) String() string {
|
||||
if name, ok := RUDPPortNames[a]; ok {
|
||||
return fmt.Sprintf("%d(%s)", a, name)
|
||||
}
|
||||
return strconv.Itoa(int(a))
|
||||
}
|
||||
|
||||
// String returns the port as "number(name)" if there's a well-known port name,
|
||||
// or just "number" if there isn't. Well-known names are stored in
|
||||
// SCTPPortNames.
|
||||
func (a SCTPPort) String() string {
|
||||
if name, ok := SCTPPortNames[a]; ok {
|
||||
return fmt.Sprintf("%d(%s)", a, name)
|
||||
}
|
||||
return strconv.Itoa(int(a))
|
||||
}
|
||||
|
||||
// String returns the port as "number(name)" if there's a well-known port name,
|
||||
// or just "number" if there isn't. Well-known names are stored in
|
||||
// UDPLitePortNames.
|
||||
func (a UDPLitePort) String() string {
|
||||
if name, ok := UDPLitePortNames[a]; ok {
|
||||
return fmt.Sprintf("%d(%s)", a, name)
|
||||
}
|
||||
return strconv.Itoa(int(a))
|
||||
}
|
||||
@ -0,0 +1,74 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// PPP is the layer for PPP encapsulation headers.
|
||||
type PPP struct {
|
||||
BaseLayer
|
||||
PPPType PPPType
|
||||
}
|
||||
|
||||
// PPPEndpoint is a singleton endpoint for PPP. Since there is no actual
|
||||
// addressing for the two ends of a PPP connection, we use a singleton value
|
||||
// named 'point' for each endpoint.
|
||||
var PPPEndpoint = gopacket.NewEndpoint(EndpointPPP, nil)
|
||||
|
||||
// PPPFlow is a singleton flow for PPP. Since there is no actual addressing for
|
||||
// the two ends of a PPP connection, we use a singleton value to represent the
|
||||
// flow for all PPP connections.
|
||||
var PPPFlow = gopacket.NewFlow(EndpointPPP, nil, nil)
|
||||
|
||||
// LayerType returns LayerTypePPP
|
||||
func (p *PPP) LayerType() gopacket.LayerType { return LayerTypePPP }
|
||||
|
||||
// LinkFlow returns PPPFlow.
|
||||
func (p *PPP) LinkFlow() gopacket.Flow { return PPPFlow }
|
||||
|
||||
func decodePPP(data []byte, p gopacket.PacketBuilder) error {
|
||||
ppp := &PPP{}
|
||||
if data[0]&0x1 == 0 {
|
||||
if data[1]&0x1 == 0 {
|
||||
return errors.New("PPP has invalid type")
|
||||
}
|
||||
ppp.PPPType = PPPType(binary.BigEndian.Uint16(data[:2]))
|
||||
ppp.Contents = data[:2]
|
||||
ppp.Payload = data[2:]
|
||||
} else {
|
||||
ppp.PPPType = PPPType(data[0])
|
||||
ppp.Contents = data[:1]
|
||||
ppp.Payload = data[1:]
|
||||
}
|
||||
p.AddLayer(ppp)
|
||||
p.SetLinkLayer(ppp)
|
||||
return p.NextDecoder(ppp.PPPType)
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (p *PPP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
if p.PPPType&0x100 == 0 {
|
||||
bytes, err := b.PrependBytes(2)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes, uint16(p.PPPType))
|
||||
} else {
|
||||
bytes, err := b.PrependBytes(1)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(p.PPPType)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,60 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// PPPoE is the layer for PPPoE encapsulation headers.
|
||||
type PPPoE struct {
|
||||
BaseLayer
|
||||
Version uint8
|
||||
Type uint8
|
||||
Code PPPoECode
|
||||
SessionId uint16
|
||||
Length uint16
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypePPPoE.
|
||||
func (p *PPPoE) LayerType() gopacket.LayerType {
|
||||
return LayerTypePPPoE
|
||||
}
|
||||
|
||||
// decodePPPoE decodes the PPPoE header (see http://tools.ietf.org/html/rfc2516).
|
||||
func decodePPPoE(data []byte, p gopacket.PacketBuilder) error {
|
||||
pppoe := &PPPoE{
|
||||
Version: data[0] >> 4,
|
||||
Type: data[0] & 0x0F,
|
||||
Code: PPPoECode(data[1]),
|
||||
SessionId: binary.BigEndian.Uint16(data[2:4]),
|
||||
Length: binary.BigEndian.Uint16(data[4:6]),
|
||||
}
|
||||
pppoe.BaseLayer = BaseLayer{data[:6], data[6 : 6+pppoe.Length]}
|
||||
p.AddLayer(pppoe)
|
||||
return p.NextDecoder(pppoe.Code)
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (p *PPPoE) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
payload := b.Bytes()
|
||||
bytes, err := b.PrependBytes(6)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = (p.Version << 4) | p.Type
|
||||
bytes[1] = byte(p.Code)
|
||||
binary.BigEndian.PutUint16(bytes[2:], p.SessionId)
|
||||
if opts.FixLengths {
|
||||
p.Length = uint16(len(payload))
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[4:], p.Length)
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,146 @@
|
||||
// Copyright 2015 Google, 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.
|
||||
|
||||
// http://www.tcpdump.org/linktypes/LINKTYPE_IEEE802_11_PRISM.html
|
||||
|
||||
package layers
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
func decodePrismValue(data []byte, pv *PrismValue) {
|
||||
pv.DID = PrismDID(binary.LittleEndian.Uint32(data[0:4]))
|
||||
pv.Status = binary.LittleEndian.Uint16(data[4:6])
|
||||
pv.Length = binary.LittleEndian.Uint16(data[6:8])
|
||||
pv.Data = data[8 : 8+pv.Length]
|
||||
}
|
||||
|
||||
type PrismDID uint32
|
||||
|
||||
const (
|
||||
PrismDIDType1HostTime PrismDID = 0x10044
|
||||
PrismDIDType2HostTime PrismDID = 0x01041
|
||||
PrismDIDType1MACTime PrismDID = 0x20044
|
||||
PrismDIDType2MACTime PrismDID = 0x02041
|
||||
PrismDIDType1Channel PrismDID = 0x30044
|
||||
PrismDIDType2Channel PrismDID = 0x03041
|
||||
PrismDIDType1RSSI PrismDID = 0x40044
|
||||
PrismDIDType2RSSI PrismDID = 0x04041
|
||||
PrismDIDType1SignalQuality PrismDID = 0x50044
|
||||
PrismDIDType2SignalQuality PrismDID = 0x05041
|
||||
PrismDIDType1Signal PrismDID = 0x60044
|
||||
PrismDIDType2Signal PrismDID = 0x06041
|
||||
PrismDIDType1Noise PrismDID = 0x70044
|
||||
PrismDIDType2Noise PrismDID = 0x07041
|
||||
PrismDIDType1Rate PrismDID = 0x80044
|
||||
PrismDIDType2Rate PrismDID = 0x08041
|
||||
PrismDIDType1TransmittedFrameIndicator PrismDID = 0x90044
|
||||
PrismDIDType2TransmittedFrameIndicator PrismDID = 0x09041
|
||||
PrismDIDType1FrameLength PrismDID = 0xA0044
|
||||
PrismDIDType2FrameLength PrismDID = 0x0A041
|
||||
)
|
||||
|
||||
const (
|
||||
PrismType1MessageCode uint16 = 0x00000044
|
||||
PrismType2MessageCode uint16 = 0x00000041
|
||||
)
|
||||
|
||||
func (p PrismDID) String() string {
|
||||
dids := map[PrismDID]string{
|
||||
PrismDIDType1HostTime: "Host Time",
|
||||
PrismDIDType2HostTime: "Host Time",
|
||||
PrismDIDType1MACTime: "MAC Time",
|
||||
PrismDIDType2MACTime: "MAC Time",
|
||||
PrismDIDType1Channel: "Channel",
|
||||
PrismDIDType2Channel: "Channel",
|
||||
PrismDIDType1RSSI: "RSSI",
|
||||
PrismDIDType2RSSI: "RSSI",
|
||||
PrismDIDType1SignalQuality: "Signal Quality",
|
||||
PrismDIDType2SignalQuality: "Signal Quality",
|
||||
PrismDIDType1Signal: "Signal",
|
||||
PrismDIDType2Signal: "Signal",
|
||||
PrismDIDType1Noise: "Noise",
|
||||
PrismDIDType2Noise: "Noise",
|
||||
PrismDIDType1Rate: "Rate",
|
||||
PrismDIDType2Rate: "Rate",
|
||||
PrismDIDType1TransmittedFrameIndicator: "Transmitted Frame Indicator",
|
||||
PrismDIDType2TransmittedFrameIndicator: "Transmitted Frame Indicator",
|
||||
PrismDIDType1FrameLength: "Frame Length",
|
||||
PrismDIDType2FrameLength: "Frame Length",
|
||||
}
|
||||
|
||||
if str, ok := dids[p]; ok {
|
||||
return str
|
||||
}
|
||||
|
||||
return "Unknown DID"
|
||||
}
|
||||
|
||||
type PrismValue struct {
|
||||
DID PrismDID
|
||||
Status uint16
|
||||
Length uint16
|
||||
Data []byte
|
||||
}
|
||||
|
||||
func (pv *PrismValue) IsSupplied() bool {
|
||||
return pv.Status == 1
|
||||
}
|
||||
|
||||
var ErrPrismExpectedMoreData = errors.New("Expected more data.")
|
||||
var ErrPrismInvalidCode = errors.New("Invalid header code.")
|
||||
|
||||
func decodePrismHeader(data []byte, p gopacket.PacketBuilder) error {
|
||||
d := &PrismHeader{}
|
||||
return decodingLayerDecoder(d, data, p)
|
||||
}
|
||||
|
||||
type PrismHeader struct {
|
||||
BaseLayer
|
||||
Code uint16
|
||||
Length uint16
|
||||
DeviceName string
|
||||
Values []PrismValue
|
||||
}
|
||||
|
||||
func (m *PrismHeader) LayerType() gopacket.LayerType { return LayerTypePrismHeader }
|
||||
|
||||
func (m *PrismHeader) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
m.Code = binary.LittleEndian.Uint16(data[0:4])
|
||||
m.Length = binary.LittleEndian.Uint16(data[4:8])
|
||||
m.DeviceName = string(data[8:24])
|
||||
m.BaseLayer = BaseLayer{Contents: data[:m.Length], Payload: data[m.Length:len(data)]}
|
||||
|
||||
switch m.Code {
|
||||
case PrismType1MessageCode:
|
||||
fallthrough
|
||||
case PrismType2MessageCode:
|
||||
// valid message code
|
||||
default:
|
||||
return ErrPrismInvalidCode
|
||||
}
|
||||
|
||||
offset := uint16(24)
|
||||
|
||||
m.Values = make([]PrismValue, (m.Length-offset)/12)
|
||||
for i := 0; i < len(m.Values); i++ {
|
||||
decodePrismValue(data[offset:offset+12], &m.Values[i])
|
||||
offset += 12
|
||||
}
|
||||
|
||||
if offset != m.Length {
|
||||
return ErrPrismExpectedMoreData
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *PrismHeader) CanDecode() gopacket.LayerClass { return LayerTypePrismHeader }
|
||||
func (m *PrismHeader) NextLayerType() gopacket.LayerType { return LayerTypeDot11 }
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,93 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
type RUDP struct {
|
||||
BaseLayer
|
||||
SYN, ACK, EACK, RST, NUL bool
|
||||
Version uint8
|
||||
HeaderLength uint8
|
||||
SrcPort, DstPort RUDPPort
|
||||
DataLength uint16
|
||||
Seq, Ack, Checksum uint32
|
||||
VariableHeaderArea []byte
|
||||
// RUDPHeaderSyn contains SYN information for the RUDP packet,
|
||||
// if the SYN flag is set
|
||||
*RUDPHeaderSYN
|
||||
// RUDPHeaderEack contains EACK information for the RUDP packet,
|
||||
// if the EACK flag is set.
|
||||
*RUDPHeaderEACK
|
||||
}
|
||||
|
||||
type RUDPHeaderSYN struct {
|
||||
MaxOutstandingSegments, MaxSegmentSize, OptionFlags uint16
|
||||
}
|
||||
|
||||
type RUDPHeaderEACK struct {
|
||||
SeqsReceivedOK []uint32
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeRUDP.
|
||||
func (r *RUDP) LayerType() gopacket.LayerType { return LayerTypeRUDP }
|
||||
|
||||
func decodeRUDP(data []byte, p gopacket.PacketBuilder) error {
|
||||
r := &RUDP{
|
||||
SYN: data[0]&0x80 != 0,
|
||||
ACK: data[0]&0x40 != 0,
|
||||
EACK: data[0]&0x20 != 0,
|
||||
RST: data[0]&0x10 != 0,
|
||||
NUL: data[0]&0x08 != 0,
|
||||
Version: data[0] & 0x3,
|
||||
HeaderLength: data[1],
|
||||
SrcPort: RUDPPort(data[2]),
|
||||
DstPort: RUDPPort(data[3]),
|
||||
DataLength: binary.BigEndian.Uint16(data[4:6]),
|
||||
Seq: binary.BigEndian.Uint32(data[6:10]),
|
||||
Ack: binary.BigEndian.Uint32(data[10:14]),
|
||||
Checksum: binary.BigEndian.Uint32(data[14:18]),
|
||||
}
|
||||
if r.HeaderLength < 9 {
|
||||
return fmt.Errorf("RUDP packet with too-short header length %d", r.HeaderLength)
|
||||
}
|
||||
hlen := int(r.HeaderLength) * 2
|
||||
r.Contents = data[:hlen]
|
||||
r.Payload = data[hlen : hlen+int(r.DataLength)]
|
||||
r.VariableHeaderArea = data[18:hlen]
|
||||
headerData := r.VariableHeaderArea
|
||||
switch {
|
||||
case r.SYN:
|
||||
if len(headerData) != 6 {
|
||||
return fmt.Errorf("RUDP packet invalid SYN header length: %d", len(headerData))
|
||||
}
|
||||
r.RUDPHeaderSYN = &RUDPHeaderSYN{
|
||||
MaxOutstandingSegments: binary.BigEndian.Uint16(headerData[:2]),
|
||||
MaxSegmentSize: binary.BigEndian.Uint16(headerData[2:4]),
|
||||
OptionFlags: binary.BigEndian.Uint16(headerData[4:6]),
|
||||
}
|
||||
case r.EACK:
|
||||
if len(headerData)%4 != 0 {
|
||||
return fmt.Errorf("RUDP packet invalid EACK header length: %d", len(headerData))
|
||||
}
|
||||
r.RUDPHeaderEACK = &RUDPHeaderEACK{make([]uint32, len(headerData)/4)}
|
||||
for i := 0; i < len(headerData); i += 4 {
|
||||
r.SeqsReceivedOK[i/4] = binary.BigEndian.Uint32(headerData[i : i+4])
|
||||
}
|
||||
}
|
||||
p.AddLayer(r)
|
||||
p.SetTransportLayer(r)
|
||||
return p.NextDecoder(gopacket.LayerTypePayload)
|
||||
}
|
||||
|
||||
func (r *RUDP) TransportFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointRUDPPort, []byte{byte(r.SrcPort)}, []byte{byte(r.DstPort)})
|
||||
}
|
||||
@ -0,0 +1,746 @@
|
||||
// Copyright 2012 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"fmt"
|
||||
"hash/crc32"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// SCTP contains information on the top level of an SCTP packet.
|
||||
type SCTP struct {
|
||||
BaseLayer
|
||||
SrcPort, DstPort SCTPPort
|
||||
VerificationTag uint32
|
||||
Checksum uint32
|
||||
sPort, dPort []byte
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeSCTP
|
||||
func (s *SCTP) LayerType() gopacket.LayerType { return LayerTypeSCTP }
|
||||
|
||||
func decodeSCTP(data []byte, p gopacket.PacketBuilder) error {
|
||||
sctp := &SCTP{}
|
||||
err := sctp.DecodeFromBytes(data, p)
|
||||
p.AddLayer(sctp)
|
||||
p.SetTransportLayer(sctp)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return p.NextDecoder(sctpChunkTypePrefixDecoder)
|
||||
}
|
||||
|
||||
var sctpChunkTypePrefixDecoder = gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix)
|
||||
|
||||
// TransportFlow returns a flow based on the source and destination SCTP port.
|
||||
func (s *SCTP) TransportFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointSCTPPort, s.sPort, s.dPort)
|
||||
}
|
||||
|
||||
func decodeWithSCTPChunkTypePrefix(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunkType := SCTPChunkType(data[0])
|
||||
return chunkType.Decode(data, p)
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (s SCTP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(12)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[0:2], uint16(s.SrcPort))
|
||||
binary.BigEndian.PutUint16(bytes[2:4], uint16(s.DstPort))
|
||||
binary.BigEndian.PutUint32(bytes[4:8], s.VerificationTag)
|
||||
if opts.ComputeChecksums {
|
||||
// Note: MakeTable(Castagnoli) actually only creates the table once, then
|
||||
// passes back a singleton on every other call, so this shouldn't cause
|
||||
// excessive memory allocation.
|
||||
binary.LittleEndian.PutUint32(bytes[8:12], crc32.Checksum(b.Bytes(), crc32.MakeTable(crc32.Castagnoli)))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (sctp *SCTP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
if len(data) < 12 {
|
||||
return errors.New("Invalid SCTP common header length")
|
||||
}
|
||||
sctp.SrcPort = SCTPPort(binary.BigEndian.Uint16(data[:2]))
|
||||
sctp.sPort = data[:2]
|
||||
sctp.DstPort = SCTPPort(binary.BigEndian.Uint16(data[2:4]))
|
||||
sctp.dPort = data[2:4]
|
||||
sctp.VerificationTag = binary.BigEndian.Uint32(data[4:8])
|
||||
sctp.Checksum = binary.BigEndian.Uint32(data[8:12])
|
||||
sctp.BaseLayer = BaseLayer{data[:12], data[12:]}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *SCTP) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeSCTP
|
||||
}
|
||||
|
||||
func (t *SCTP) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
// SCTPChunk contains the common fields in all SCTP chunks.
|
||||
type SCTPChunk struct {
|
||||
BaseLayer
|
||||
Type SCTPChunkType
|
||||
Flags uint8
|
||||
Length uint16
|
||||
// ActualLength is the total length of an SCTP chunk, including padding.
|
||||
// SCTP chunks start and end on 4-byte boundaries. So if a chunk has a length
|
||||
// of 18, it means that it has data up to and including byte 18, then padding
|
||||
// up to the next 4-byte boundary, 20. In this case, Length would be 18, and
|
||||
// ActualLength would be 20.
|
||||
ActualLength int
|
||||
}
|
||||
|
||||
func roundUpToNearest4(i int) int {
|
||||
if i%4 == 0 {
|
||||
return i
|
||||
}
|
||||
return i + 4 - (i % 4)
|
||||
}
|
||||
|
||||
func decodeSCTPChunk(data []byte) (SCTPChunk, error) {
|
||||
length := binary.BigEndian.Uint16(data[2:4])
|
||||
if length < 4 {
|
||||
return SCTPChunk{}, errors.New("invalid SCTP chunk length")
|
||||
}
|
||||
actual := roundUpToNearest4(int(length))
|
||||
ct := SCTPChunkType(data[0])
|
||||
|
||||
// For SCTP Data, use a separate layer for the payload
|
||||
delta := 0
|
||||
if ct == SCTPChunkTypeData {
|
||||
delta = int(actual) - int(length)
|
||||
actual = 16
|
||||
}
|
||||
|
||||
return SCTPChunk{
|
||||
Type: ct,
|
||||
Flags: data[1],
|
||||
Length: length,
|
||||
ActualLength: actual,
|
||||
BaseLayer: BaseLayer{data[:actual], data[actual : len(data)-delta]},
|
||||
}, nil
|
||||
}
|
||||
|
||||
// SCTPParameter is a TLV parameter inside a SCTPChunk.
|
||||
type SCTPParameter struct {
|
||||
Type uint16
|
||||
Length uint16
|
||||
ActualLength int
|
||||
Value []byte
|
||||
}
|
||||
|
||||
func decodeSCTPParameter(data []byte) SCTPParameter {
|
||||
length := binary.BigEndian.Uint16(data[2:4])
|
||||
return SCTPParameter{
|
||||
Type: binary.BigEndian.Uint16(data[0:2]),
|
||||
Length: length,
|
||||
Value: data[4:length],
|
||||
ActualLength: roundUpToNearest4(int(length)),
|
||||
}
|
||||
}
|
||||
|
||||
func (p SCTPParameter) Bytes() []byte {
|
||||
length := 4 + len(p.Value)
|
||||
data := make([]byte, roundUpToNearest4(length))
|
||||
binary.BigEndian.PutUint16(data[0:2], p.Type)
|
||||
binary.BigEndian.PutUint16(data[2:4], uint16(length))
|
||||
copy(data[4:], p.Value)
|
||||
return data
|
||||
}
|
||||
|
||||
// SCTPUnknownChunkType is the layer type returned when we don't recognize the
|
||||
// chunk type. Since there's a length in a known location, we can skip over
|
||||
// it even if we don't know what it is, and continue parsing the rest of the
|
||||
// chunks. This chunk is stored as an ErrorLayer in the packet.
|
||||
type SCTPUnknownChunkType struct {
|
||||
SCTPChunk
|
||||
bytes []byte
|
||||
}
|
||||
|
||||
func decodeSCTPChunkTypeUnknown(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPUnknownChunkType{SCTPChunk: chunk}
|
||||
sc.bytes = data[:sc.ActualLength]
|
||||
p.AddLayer(sc)
|
||||
p.SetErrorLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (s SCTPUnknownChunkType) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(s.ActualLength)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
copy(bytes, s.bytes)
|
||||
return nil
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeSCTPUnknownChunkType.
|
||||
func (s *SCTPUnknownChunkType) LayerType() gopacket.LayerType { return LayerTypeSCTPUnknownChunkType }
|
||||
|
||||
// Payload returns all bytes in this header, including the decoded Type, Length,
|
||||
// and Flags.
|
||||
func (s *SCTPUnknownChunkType) Payload() []byte { return s.bytes }
|
||||
|
||||
// Error implements ErrorLayer.
|
||||
func (s *SCTPUnknownChunkType) Error() error {
|
||||
return fmt.Errorf("No decode method available for SCTP chunk type %s", s.Type)
|
||||
}
|
||||
|
||||
// SCTPData is the SCTP Data chunk layer.
|
||||
type SCTPData struct {
|
||||
SCTPChunk
|
||||
Unordered, BeginFragment, EndFragment bool
|
||||
TSN uint32
|
||||
StreamId uint16
|
||||
StreamSequence uint16
|
||||
PayloadProtocol SCTPPayloadProtocol
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeSCTPData.
|
||||
func (s *SCTPData) LayerType() gopacket.LayerType { return LayerTypeSCTPData }
|
||||
|
||||
// SCTPPayloadProtocol represents a payload protocol
|
||||
type SCTPPayloadProtocol uint32
|
||||
|
||||
// SCTPPayloadProtocol constonts from http://www.iana.org/assignments/sctp-parameters/sctp-parameters.xhtml
|
||||
const (
|
||||
SCTPProtocolReserved SCTPPayloadProtocol = 0
|
||||
SCTPPayloadUIA = 1
|
||||
SCTPPayloadM2UA = 2
|
||||
SCTPPayloadM3UA = 3
|
||||
SCTPPayloadSUA = 4
|
||||
SCTPPayloadM2PA = 5
|
||||
SCTPPayloadV5UA = 6
|
||||
SCTPPayloadH248 = 7
|
||||
SCTPPayloadBICC = 8
|
||||
SCTPPayloadTALI = 9
|
||||
SCTPPayloadDUA = 10
|
||||
SCTPPayloadASAP = 11
|
||||
SCTPPayloadENRP = 12
|
||||
SCTPPayloadH323 = 13
|
||||
SCTPPayloadQIPC = 14
|
||||
SCTPPayloadSIMCO = 15
|
||||
SCTPPayloadDDPSegment = 16
|
||||
SCTPPayloadDDPStream = 17
|
||||
SCTPPayloadS1AP = 18
|
||||
)
|
||||
|
||||
func (p SCTPPayloadProtocol) String() string {
|
||||
switch p {
|
||||
case SCTPProtocolReserved:
|
||||
return "Reserved"
|
||||
case SCTPPayloadUIA:
|
||||
return "UIA"
|
||||
case SCTPPayloadM2UA:
|
||||
return "M2UA"
|
||||
case SCTPPayloadM3UA:
|
||||
return "M3UA"
|
||||
case SCTPPayloadSUA:
|
||||
return "SUA"
|
||||
case SCTPPayloadM2PA:
|
||||
return "M2PA"
|
||||
case SCTPPayloadV5UA:
|
||||
return "V5UA"
|
||||
case SCTPPayloadH248:
|
||||
return "H.248"
|
||||
case SCTPPayloadBICC:
|
||||
return "BICC"
|
||||
case SCTPPayloadTALI:
|
||||
return "TALI"
|
||||
case SCTPPayloadDUA:
|
||||
return "DUA"
|
||||
case SCTPPayloadASAP:
|
||||
return "ASAP"
|
||||
case SCTPPayloadENRP:
|
||||
return "ENRP"
|
||||
case SCTPPayloadH323:
|
||||
return "H.323"
|
||||
case SCTPPayloadQIPC:
|
||||
return "QIPC"
|
||||
case SCTPPayloadSIMCO:
|
||||
return "SIMCO"
|
||||
case SCTPPayloadDDPSegment:
|
||||
return "DDPSegment"
|
||||
case SCTPPayloadDDPStream:
|
||||
return "DDPStream"
|
||||
case SCTPPayloadS1AP:
|
||||
return "S1AP"
|
||||
}
|
||||
return fmt.Sprintf("Unknown(%d)", p)
|
||||
}
|
||||
|
||||
func decodeSCTPData(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPData{
|
||||
SCTPChunk: chunk,
|
||||
Unordered: data[1]&0x4 != 0,
|
||||
BeginFragment: data[1]&0x2 != 0,
|
||||
EndFragment: data[1]&0x1 != 0,
|
||||
TSN: binary.BigEndian.Uint32(data[4:8]),
|
||||
StreamId: binary.BigEndian.Uint16(data[8:10]),
|
||||
StreamSequence: binary.BigEndian.Uint16(data[10:12]),
|
||||
PayloadProtocol: SCTPPayloadProtocol(binary.BigEndian.Uint32(data[12:16])),
|
||||
}
|
||||
// Length is the length in bytes of the data, INCLUDING the 16-byte header.
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.LayerTypePayload)
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPData) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
payload := b.Bytes()
|
||||
// Pad the payload to a 32 bit boundary
|
||||
if rem := len(payload) % 4; rem != 0 {
|
||||
b.AppendBytes(4 - rem)
|
||||
}
|
||||
length := 16
|
||||
bytes, err := b.PrependBytes(length)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
flags := uint8(0)
|
||||
if sc.Unordered {
|
||||
flags |= 0x4
|
||||
}
|
||||
if sc.BeginFragment {
|
||||
flags |= 0x2
|
||||
}
|
||||
if sc.EndFragment {
|
||||
flags |= 0x1
|
||||
}
|
||||
bytes[1] = flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], uint16(length+len(payload)))
|
||||
binary.BigEndian.PutUint32(bytes[4:8], sc.TSN)
|
||||
binary.BigEndian.PutUint16(bytes[8:10], sc.StreamId)
|
||||
binary.BigEndian.PutUint16(bytes[10:12], sc.StreamSequence)
|
||||
binary.BigEndian.PutUint32(bytes[12:16], uint32(sc.PayloadProtocol))
|
||||
return nil
|
||||
}
|
||||
|
||||
// SCTPInitParameter is a parameter for an SCTP Init or InitAck packet.
|
||||
type SCTPInitParameter SCTPParameter
|
||||
|
||||
// SCTPInit is used as the return value for both SCTPInit and SCTPInitAck
|
||||
// messages.
|
||||
type SCTPInit struct {
|
||||
SCTPChunk
|
||||
InitiateTag uint32
|
||||
AdvertisedReceiverWindowCredit uint32
|
||||
OutboundStreams, InboundStreams uint16
|
||||
InitialTSN uint32
|
||||
Parameters []SCTPInitParameter
|
||||
}
|
||||
|
||||
// LayerType returns either gopacket.LayerTypeSCTPInit or gopacket.LayerTypeSCTPInitAck.
|
||||
func (sc *SCTPInit) LayerType() gopacket.LayerType {
|
||||
if sc.Type == SCTPChunkTypeInitAck {
|
||||
return LayerTypeSCTPInitAck
|
||||
}
|
||||
// sc.Type == SCTPChunkTypeInit
|
||||
return LayerTypeSCTPInit
|
||||
}
|
||||
|
||||
func decodeSCTPInit(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPInit{
|
||||
SCTPChunk: chunk,
|
||||
InitiateTag: binary.BigEndian.Uint32(data[4:8]),
|
||||
AdvertisedReceiverWindowCredit: binary.BigEndian.Uint32(data[8:12]),
|
||||
OutboundStreams: binary.BigEndian.Uint16(data[12:14]),
|
||||
InboundStreams: binary.BigEndian.Uint16(data[14:16]),
|
||||
InitialTSN: binary.BigEndian.Uint32(data[16:20]),
|
||||
}
|
||||
paramData := data[20:sc.ActualLength]
|
||||
for len(paramData) > 0 {
|
||||
p := SCTPInitParameter(decodeSCTPParameter(paramData))
|
||||
paramData = paramData[p.ActualLength:]
|
||||
sc.Parameters = append(sc.Parameters, p)
|
||||
}
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPInit) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var payload []byte
|
||||
for _, param := range sc.Parameters {
|
||||
payload = append(payload, SCTPParameter(param).Bytes()...)
|
||||
}
|
||||
length := 20 + len(payload)
|
||||
bytes, err := b.PrependBytes(roundUpToNearest4(length))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
bytes[1] = sc.Flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], uint16(length))
|
||||
binary.BigEndian.PutUint32(bytes[4:8], sc.InitiateTag)
|
||||
binary.BigEndian.PutUint32(bytes[8:12], sc.AdvertisedReceiverWindowCredit)
|
||||
binary.BigEndian.PutUint16(bytes[12:14], sc.OutboundStreams)
|
||||
binary.BigEndian.PutUint16(bytes[14:16], sc.InboundStreams)
|
||||
binary.BigEndian.PutUint32(bytes[16:20], sc.InitialTSN)
|
||||
copy(bytes[20:], payload)
|
||||
return nil
|
||||
}
|
||||
|
||||
// SCTPSack is the SCTP Selective ACK chunk layer.
|
||||
type SCTPSack struct {
|
||||
SCTPChunk
|
||||
CumulativeTSNAck uint32
|
||||
AdvertisedReceiverWindowCredit uint32
|
||||
NumGapACKs, NumDuplicateTSNs uint16
|
||||
GapACKs []uint16
|
||||
DuplicateTSNs []uint32
|
||||
}
|
||||
|
||||
// LayerType return LayerTypeSCTPSack
|
||||
func (sc *SCTPSack) LayerType() gopacket.LayerType {
|
||||
return LayerTypeSCTPSack
|
||||
}
|
||||
|
||||
func decodeSCTPSack(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPSack{
|
||||
SCTPChunk: chunk,
|
||||
CumulativeTSNAck: binary.BigEndian.Uint32(data[4:8]),
|
||||
AdvertisedReceiverWindowCredit: binary.BigEndian.Uint32(data[8:12]),
|
||||
NumGapACKs: binary.BigEndian.Uint16(data[12:14]),
|
||||
NumDuplicateTSNs: binary.BigEndian.Uint16(data[14:16]),
|
||||
}
|
||||
// We maximize gapAcks and dupTSNs here so we're not allocating tons
|
||||
// of memory based on a user-controlable field. Our maximums are not exact,
|
||||
// but should give us sane defaults... we'll still hit slice boundaries and
|
||||
// fail if the user-supplied values are too high (in the for loops below), but
|
||||
// the amount of memory we'll have allocated because of that should be small
|
||||
// (< sc.ActualLength)
|
||||
gapAcks := sc.SCTPChunk.ActualLength / 2
|
||||
dupTSNs := (sc.SCTPChunk.ActualLength - gapAcks*2) / 4
|
||||
if gapAcks > int(sc.NumGapACKs) {
|
||||
gapAcks = int(sc.NumGapACKs)
|
||||
}
|
||||
if dupTSNs > int(sc.NumDuplicateTSNs) {
|
||||
dupTSNs = int(sc.NumDuplicateTSNs)
|
||||
}
|
||||
sc.GapACKs = make([]uint16, 0, gapAcks)
|
||||
sc.DuplicateTSNs = make([]uint32, 0, dupTSNs)
|
||||
bytesRemaining := data[16:]
|
||||
for i := 0; i < int(sc.NumGapACKs); i++ {
|
||||
sc.GapACKs = append(sc.GapACKs, binary.BigEndian.Uint16(bytesRemaining[:2]))
|
||||
bytesRemaining = bytesRemaining[2:]
|
||||
}
|
||||
for i := 0; i < int(sc.NumDuplicateTSNs); i++ {
|
||||
sc.DuplicateTSNs = append(sc.DuplicateTSNs, binary.BigEndian.Uint32(bytesRemaining[:4]))
|
||||
bytesRemaining = bytesRemaining[4:]
|
||||
}
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPSack) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
length := 16 + 2*len(sc.GapACKs) + 4*len(sc.DuplicateTSNs)
|
||||
bytes, err := b.PrependBytes(roundUpToNearest4(length))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
bytes[1] = sc.Flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], uint16(length))
|
||||
binary.BigEndian.PutUint32(bytes[4:8], sc.CumulativeTSNAck)
|
||||
binary.BigEndian.PutUint32(bytes[8:12], sc.AdvertisedReceiverWindowCredit)
|
||||
binary.BigEndian.PutUint16(bytes[12:14], uint16(len(sc.GapACKs)))
|
||||
binary.BigEndian.PutUint16(bytes[14:16], uint16(len(sc.DuplicateTSNs)))
|
||||
for i, v := range sc.GapACKs {
|
||||
binary.BigEndian.PutUint16(bytes[16+i*2:], v)
|
||||
}
|
||||
offset := 16 + 2*len(sc.GapACKs)
|
||||
for i, v := range sc.DuplicateTSNs {
|
||||
binary.BigEndian.PutUint32(bytes[offset+i*4:], v)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SCTPHeartbeatParameter is the parameter type used by SCTP heartbeat and
|
||||
// heartbeat ack layers.
|
||||
type SCTPHeartbeatParameter SCTPParameter
|
||||
|
||||
// SCTPHeartbeat is the SCTP heartbeat layer, also used for heatbeat ack.
|
||||
type SCTPHeartbeat struct {
|
||||
SCTPChunk
|
||||
Parameters []SCTPHeartbeatParameter
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeSCTPHeartbeat.
|
||||
func (sc *SCTPHeartbeat) LayerType() gopacket.LayerType {
|
||||
if sc.Type == SCTPChunkTypeHeartbeatAck {
|
||||
return LayerTypeSCTPHeartbeatAck
|
||||
}
|
||||
// sc.Type == SCTPChunkTypeHeartbeat
|
||||
return LayerTypeSCTPHeartbeat
|
||||
}
|
||||
|
||||
func decodeSCTPHeartbeat(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPHeartbeat{
|
||||
SCTPChunk: chunk,
|
||||
}
|
||||
paramData := data[4:sc.Length]
|
||||
for len(paramData) > 0 {
|
||||
p := SCTPHeartbeatParameter(decodeSCTPParameter(paramData))
|
||||
paramData = paramData[p.ActualLength:]
|
||||
sc.Parameters = append(sc.Parameters, p)
|
||||
}
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPHeartbeat) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var payload []byte
|
||||
for _, param := range sc.Parameters {
|
||||
payload = append(payload, SCTPParameter(param).Bytes()...)
|
||||
}
|
||||
length := 4 + len(payload)
|
||||
|
||||
bytes, err := b.PrependBytes(roundUpToNearest4(length))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
bytes[1] = sc.Flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], uint16(length))
|
||||
copy(bytes[4:], payload)
|
||||
return nil
|
||||
}
|
||||
|
||||
// SCTPErrorParameter is the parameter type used by SCTP Abort and Error layers.
|
||||
type SCTPErrorParameter SCTPParameter
|
||||
|
||||
// SCTPError is the SCTP error layer, also used for SCTP aborts.
|
||||
type SCTPError struct {
|
||||
SCTPChunk
|
||||
Parameters []SCTPErrorParameter
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeSCTPAbort or LayerTypeSCTPError.
|
||||
func (sc *SCTPError) LayerType() gopacket.LayerType {
|
||||
if sc.Type == SCTPChunkTypeAbort {
|
||||
return LayerTypeSCTPAbort
|
||||
}
|
||||
// sc.Type == SCTPChunkTypeError
|
||||
return LayerTypeSCTPError
|
||||
}
|
||||
|
||||
func decodeSCTPError(data []byte, p gopacket.PacketBuilder) error {
|
||||
// remarkably similar to decodeSCTPHeartbeat ;)
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPError{
|
||||
SCTPChunk: chunk,
|
||||
}
|
||||
paramData := data[4:sc.Length]
|
||||
for len(paramData) > 0 {
|
||||
p := SCTPErrorParameter(decodeSCTPParameter(paramData))
|
||||
paramData = paramData[p.ActualLength:]
|
||||
sc.Parameters = append(sc.Parameters, p)
|
||||
}
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPError) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var payload []byte
|
||||
for _, param := range sc.Parameters {
|
||||
payload = append(payload, SCTPParameter(param).Bytes()...)
|
||||
}
|
||||
length := 4 + len(payload)
|
||||
|
||||
bytes, err := b.PrependBytes(roundUpToNearest4(length))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
bytes[1] = sc.Flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], uint16(length))
|
||||
copy(bytes[4:], payload)
|
||||
return nil
|
||||
}
|
||||
|
||||
// SCTPShutdown is the SCTP shutdown layer.
|
||||
type SCTPShutdown struct {
|
||||
SCTPChunk
|
||||
CumulativeTSNAck uint32
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeSCTPShutdown.
|
||||
func (sc *SCTPShutdown) LayerType() gopacket.LayerType { return LayerTypeSCTPShutdown }
|
||||
|
||||
func decodeSCTPShutdown(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPShutdown{
|
||||
SCTPChunk: chunk,
|
||||
CumulativeTSNAck: binary.BigEndian.Uint32(data[4:8]),
|
||||
}
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPShutdown) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(8)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
bytes[1] = sc.Flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], 8)
|
||||
binary.BigEndian.PutUint32(bytes[4:8], sc.CumulativeTSNAck)
|
||||
return nil
|
||||
}
|
||||
|
||||
// SCTPShutdownAck is the SCTP shutdown layer.
|
||||
type SCTPShutdownAck struct {
|
||||
SCTPChunk
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeSCTPShutdownAck.
|
||||
func (sc *SCTPShutdownAck) LayerType() gopacket.LayerType { return LayerTypeSCTPShutdownAck }
|
||||
|
||||
func decodeSCTPShutdownAck(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPShutdownAck{
|
||||
SCTPChunk: chunk,
|
||||
}
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPShutdownAck) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(4)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
bytes[1] = sc.Flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], 4)
|
||||
return nil
|
||||
}
|
||||
|
||||
// SCTPCookieEcho is the SCTP Cookie Echo layer.
|
||||
type SCTPCookieEcho struct {
|
||||
SCTPChunk
|
||||
Cookie []byte
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeSCTPCookieEcho.
|
||||
func (sc *SCTPCookieEcho) LayerType() gopacket.LayerType { return LayerTypeSCTPCookieEcho }
|
||||
|
||||
func decodeSCTPCookieEcho(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPCookieEcho{
|
||||
SCTPChunk: chunk,
|
||||
}
|
||||
sc.Cookie = data[4:sc.Length]
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPCookieEcho) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
length := 4 + len(sc.Cookie)
|
||||
bytes, err := b.PrependBytes(roundUpToNearest4(length))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
bytes[1] = sc.Flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], uint16(length))
|
||||
copy(bytes[4:], sc.Cookie)
|
||||
return nil
|
||||
}
|
||||
|
||||
// This struct is used by all empty SCTP chunks (currently CookieAck and
|
||||
// ShutdownComplete).
|
||||
type SCTPEmptyLayer struct {
|
||||
SCTPChunk
|
||||
}
|
||||
|
||||
// LayerType returns either gopacket.LayerTypeSCTPShutdownComplete or
|
||||
// LayerTypeSCTPCookieAck.
|
||||
func (sc *SCTPEmptyLayer) LayerType() gopacket.LayerType {
|
||||
if sc.Type == SCTPChunkTypeShutdownComplete {
|
||||
return LayerTypeSCTPShutdownComplete
|
||||
}
|
||||
// sc.Type == SCTPChunkTypeCookieAck
|
||||
return LayerTypeSCTPCookieAck
|
||||
}
|
||||
|
||||
func decodeSCTPEmptyLayer(data []byte, p gopacket.PacketBuilder) error {
|
||||
chunk, err := decodeSCTPChunk(data)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
sc := &SCTPEmptyLayer{
|
||||
SCTPChunk: chunk,
|
||||
}
|
||||
p.AddLayer(sc)
|
||||
return p.NextDecoder(gopacket.DecodeFunc(decodeWithSCTPChunkTypePrefix))
|
||||
}
|
||||
|
||||
// SerializeTo is for gopacket.SerializableLayer.
|
||||
func (sc SCTPEmptyLayer) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(4)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
bytes[0] = uint8(sc.Type)
|
||||
bytes[1] = sc.Flags
|
||||
binary.BigEndian.PutUint16(bytes[2:4], 4)
|
||||
return nil
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,327 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// TCP is the layer for TCP headers.
|
||||
type TCP struct {
|
||||
BaseLayer
|
||||
SrcPort, DstPort TCPPort
|
||||
Seq uint32
|
||||
Ack uint32
|
||||
DataOffset uint8
|
||||
FIN, SYN, RST, PSH, ACK, URG, ECE, CWR, NS bool
|
||||
Window uint16
|
||||
Checksum uint16
|
||||
Urgent uint16
|
||||
sPort, dPort []byte
|
||||
Options []TCPOption
|
||||
Padding []byte
|
||||
opts [4]TCPOption
|
||||
tcpipchecksum
|
||||
}
|
||||
|
||||
// TCPOptionKind represents a TCP option code.
|
||||
type TCPOptionKind uint8
|
||||
|
||||
const (
|
||||
TCPOptionKindEndList = 0
|
||||
TCPOptionKindNop = 1
|
||||
TCPOptionKindMSS = 2 // len = 4
|
||||
TCPOptionKindWindowScale = 3 // len = 3
|
||||
TCPOptionKindSACKPermitted = 4 // len = 2
|
||||
TCPOptionKindSACK = 5 // len = n
|
||||
TCPOptionKindEcho = 6 // len = 6, obsolete
|
||||
TCPOptionKindEchoReply = 7 // len = 6, obsolete
|
||||
TCPOptionKindTimestamps = 8 // len = 10
|
||||
TCPOptionKindPartialOrderConnectionPermitted = 9 // len = 2, obsolete
|
||||
TCPOptionKindPartialOrderServiceProfile = 10 // len = 3, obsolete
|
||||
TCPOptionKindCC = 11 // obsolete
|
||||
TCPOptionKindCCNew = 12 // obsolete
|
||||
TCPOptionKindCCEcho = 13 // obsolete
|
||||
TCPOptionKindAltChecksum = 14 // len = 3, obsolete
|
||||
TCPOptionKindAltChecksumData = 15 // len = n, obsolete
|
||||
)
|
||||
|
||||
func (k TCPOptionKind) String() string {
|
||||
switch k {
|
||||
case TCPOptionKindEndList:
|
||||
return "EndList"
|
||||
case TCPOptionKindNop:
|
||||
return "NOP"
|
||||
case TCPOptionKindMSS:
|
||||
return "MSS"
|
||||
case TCPOptionKindWindowScale:
|
||||
return "WindowScale"
|
||||
case TCPOptionKindSACKPermitted:
|
||||
return "SACKPermitted"
|
||||
case TCPOptionKindSACK:
|
||||
return "SACK"
|
||||
case TCPOptionKindEcho:
|
||||
return "Echo"
|
||||
case TCPOptionKindEchoReply:
|
||||
return "EchoReply"
|
||||
case TCPOptionKindTimestamps:
|
||||
return "Timestamps"
|
||||
case TCPOptionKindPartialOrderConnectionPermitted:
|
||||
return "PartialOrderConnectionPermitted"
|
||||
case TCPOptionKindPartialOrderServiceProfile:
|
||||
return "PartialOrderServiceProfile"
|
||||
case TCPOptionKindCC:
|
||||
return "CC"
|
||||
case TCPOptionKindCCNew:
|
||||
return "CCNew"
|
||||
case TCPOptionKindCCEcho:
|
||||
return "CCEcho"
|
||||
case TCPOptionKindAltChecksum:
|
||||
return "AltChecksum"
|
||||
case TCPOptionKindAltChecksumData:
|
||||
return "AltChecksumData"
|
||||
default:
|
||||
return fmt.Sprintf("Unknown(%d)", k)
|
||||
}
|
||||
}
|
||||
|
||||
type TCPOption struct {
|
||||
OptionType TCPOptionKind
|
||||
OptionLength uint8
|
||||
OptionData []byte
|
||||
}
|
||||
|
||||
func (t TCPOption) String() string {
|
||||
hd := hex.EncodeToString(t.OptionData)
|
||||
if len(hd) > 0 {
|
||||
hd = " 0x" + hd
|
||||
}
|
||||
switch t.OptionType {
|
||||
case TCPOptionKindMSS:
|
||||
return fmt.Sprintf("TCPOption(%s:%v%s)",
|
||||
t.OptionType,
|
||||
binary.BigEndian.Uint16(t.OptionData),
|
||||
hd)
|
||||
|
||||
case TCPOptionKindTimestamps:
|
||||
if len(t.OptionData) == 8 {
|
||||
return fmt.Sprintf("TCPOption(%s:%v/%v%s)",
|
||||
t.OptionType,
|
||||
binary.BigEndian.Uint32(t.OptionData[:4]),
|
||||
binary.BigEndian.Uint32(t.OptionData[4:8]),
|
||||
hd)
|
||||
}
|
||||
}
|
||||
return fmt.Sprintf("TCPOption(%s:%s)", t.OptionType, hd)
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeTCP
|
||||
func (t *TCP) LayerType() gopacket.LayerType { return LayerTypeTCP }
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (t *TCP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var optionLength int
|
||||
for _, o := range t.Options {
|
||||
switch o.OptionType {
|
||||
case 0, 1:
|
||||
optionLength += 1
|
||||
default:
|
||||
optionLength += 2 + len(o.OptionData)
|
||||
}
|
||||
}
|
||||
if opts.FixLengths {
|
||||
if rem := optionLength % 4; rem != 0 {
|
||||
t.Padding = lotsOfZeros[:4-rem]
|
||||
}
|
||||
t.DataOffset = uint8((len(t.Padding) + optionLength + 20) / 4)
|
||||
}
|
||||
bytes, err := b.PrependBytes(20 + optionLength + len(t.Padding))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes, uint16(t.SrcPort))
|
||||
binary.BigEndian.PutUint16(bytes[2:], uint16(t.DstPort))
|
||||
binary.BigEndian.PutUint32(bytes[4:], t.Seq)
|
||||
binary.BigEndian.PutUint32(bytes[8:], t.Ack)
|
||||
binary.BigEndian.PutUint16(bytes[12:], t.flagsAndOffset())
|
||||
binary.BigEndian.PutUint16(bytes[14:], t.Window)
|
||||
binary.BigEndian.PutUint16(bytes[18:], t.Urgent)
|
||||
start := 20
|
||||
for _, o := range t.Options {
|
||||
bytes[start] = byte(o.OptionType)
|
||||
switch o.OptionType {
|
||||
case 0, 1:
|
||||
start++
|
||||
default:
|
||||
if opts.FixLengths {
|
||||
o.OptionLength = uint8(len(o.OptionData) + 2)
|
||||
}
|
||||
bytes[start+1] = o.OptionLength
|
||||
copy(bytes[start+2:start+len(o.OptionData)+2], o.OptionData)
|
||||
start += int(o.OptionLength)
|
||||
}
|
||||
}
|
||||
copy(bytes[start:], t.Padding)
|
||||
if opts.ComputeChecksums {
|
||||
// zero out checksum bytes in current serialization.
|
||||
bytes[16] = 0
|
||||
bytes[17] = 0
|
||||
csum, err := t.computeChecksum(b.Bytes(), IPProtocolTCP)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
t.Checksum = csum
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[16:], t.Checksum)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *TCP) ComputeChecksum() (uint16, error) {
|
||||
return t.computeChecksum(append(t.Contents, t.Payload...), IPProtocolTCP)
|
||||
}
|
||||
|
||||
func (t *TCP) flagsAndOffset() uint16 {
|
||||
f := uint16(t.DataOffset) << 12
|
||||
if t.FIN {
|
||||
f |= 0x0001
|
||||
}
|
||||
if t.SYN {
|
||||
f |= 0x0002
|
||||
}
|
||||
if t.RST {
|
||||
f |= 0x0004
|
||||
}
|
||||
if t.PSH {
|
||||
f |= 0x0008
|
||||
}
|
||||
if t.ACK {
|
||||
f |= 0x0010
|
||||
}
|
||||
if t.URG {
|
||||
f |= 0x0020
|
||||
}
|
||||
if t.ECE {
|
||||
f |= 0x0040
|
||||
}
|
||||
if t.CWR {
|
||||
f |= 0x0080
|
||||
}
|
||||
if t.NS {
|
||||
f |= 0x0100
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
||||
func (tcp *TCP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
tcp.SrcPort = TCPPort(binary.BigEndian.Uint16(data[0:2]))
|
||||
tcp.sPort = data[0:2]
|
||||
tcp.DstPort = TCPPort(binary.BigEndian.Uint16(data[2:4]))
|
||||
tcp.dPort = data[2:4]
|
||||
tcp.Seq = binary.BigEndian.Uint32(data[4:8])
|
||||
tcp.Ack = binary.BigEndian.Uint32(data[8:12])
|
||||
tcp.DataOffset = data[12] >> 4
|
||||
tcp.FIN = data[13]&0x01 != 0
|
||||
tcp.SYN = data[13]&0x02 != 0
|
||||
tcp.RST = data[13]&0x04 != 0
|
||||
tcp.PSH = data[13]&0x08 != 0
|
||||
tcp.ACK = data[13]&0x10 != 0
|
||||
tcp.URG = data[13]&0x20 != 0
|
||||
tcp.ECE = data[13]&0x40 != 0
|
||||
tcp.CWR = data[13]&0x80 != 0
|
||||
tcp.NS = data[12]&0x01 != 0
|
||||
tcp.Window = binary.BigEndian.Uint16(data[14:16])
|
||||
tcp.Checksum = binary.BigEndian.Uint16(data[16:18])
|
||||
tcp.Urgent = binary.BigEndian.Uint16(data[18:20])
|
||||
tcp.Options = tcp.opts[:0]
|
||||
if tcp.DataOffset < 5 {
|
||||
return fmt.Errorf("Invalid TCP data offset %d < 5", tcp.DataOffset)
|
||||
}
|
||||
dataStart := int(tcp.DataOffset) * 4
|
||||
if dataStart > len(data) {
|
||||
df.SetTruncated()
|
||||
tcp.Payload = nil
|
||||
tcp.Contents = data
|
||||
return errors.New("TCP data offset greater than packet length")
|
||||
}
|
||||
tcp.Contents = data[:dataStart]
|
||||
tcp.Payload = data[dataStart:]
|
||||
// From here on, data points just to the header options.
|
||||
data = data[20:dataStart]
|
||||
for len(data) > 0 {
|
||||
if tcp.Options == nil {
|
||||
// Pre-allocate to avoid allocating a slice.
|
||||
tcp.Options = tcp.opts[:0]
|
||||
}
|
||||
tcp.Options = append(tcp.Options, TCPOption{OptionType: TCPOptionKind(data[0])})
|
||||
opt := &tcp.Options[len(tcp.Options)-1]
|
||||
switch opt.OptionType {
|
||||
case TCPOptionKindEndList: // End of options
|
||||
opt.OptionLength = 1
|
||||
tcp.Padding = data[1:]
|
||||
break
|
||||
case TCPOptionKindNop: // 1 byte padding
|
||||
opt.OptionLength = 1
|
||||
default:
|
||||
opt.OptionLength = data[1]
|
||||
if opt.OptionLength < 2 {
|
||||
return fmt.Errorf("Invalid TCP option length %d < 2", opt.OptionLength)
|
||||
} else if int(opt.OptionLength) > len(data) {
|
||||
return fmt.Errorf("Invalid TCP option length %d exceeds remaining %d bytes", opt.OptionLength, len(data))
|
||||
}
|
||||
opt.OptionData = data[2:opt.OptionLength]
|
||||
}
|
||||
data = data[opt.OptionLength:]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (t *TCP) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeTCP
|
||||
}
|
||||
|
||||
func (t *TCP) NextLayerType() gopacket.LayerType {
|
||||
lt := t.DstPort.LayerType()
|
||||
if lt == gopacket.LayerTypePayload {
|
||||
lt = t.SrcPort.LayerType()
|
||||
}
|
||||
return lt
|
||||
}
|
||||
|
||||
func decodeTCP(data []byte, p gopacket.PacketBuilder) error {
|
||||
tcp := &TCP{}
|
||||
err := tcp.DecodeFromBytes(data, p)
|
||||
p.AddLayer(tcp)
|
||||
p.SetTransportLayer(tcp)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if p.DecodeOptions().DecodeStreamsAsDatagrams {
|
||||
return p.NextDecoder(tcp.NextLayerType())
|
||||
} else {
|
||||
return p.NextDecoder(gopacket.LayerTypePayload)
|
||||
}
|
||||
}
|
||||
|
||||
func (t *TCP) TransportFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointTCPPort, t.sPort, t.dPort)
|
||||
}
|
||||
|
||||
// For testing only
|
||||
func (t *TCP) SetInternalPortsForTesting() {
|
||||
t.sPort = make([]byte, 2)
|
||||
t.dPort = make([]byte, 2)
|
||||
binary.BigEndian.PutUint16(t.sPort, uint16(t.SrcPort))
|
||||
binary.BigEndian.PutUint16(t.dPort, uint16(t.DstPort))
|
||||
}
|
||||
@ -0,0 +1,104 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// Checksum computation for TCP/UDP.
|
||||
type tcpipchecksum struct {
|
||||
pseudoheader tcpipPseudoHeader
|
||||
}
|
||||
|
||||
type tcpipPseudoHeader interface {
|
||||
pseudoheaderChecksum() (uint32, error)
|
||||
}
|
||||
|
||||
func (ip *IPv4) pseudoheaderChecksum() (csum uint32, err error) {
|
||||
if err := ip.AddressTo4(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
csum += (uint32(ip.SrcIP[0]) + uint32(ip.SrcIP[2])) << 8
|
||||
csum += uint32(ip.SrcIP[1]) + uint32(ip.SrcIP[3])
|
||||
csum += (uint32(ip.DstIP[0]) + uint32(ip.DstIP[2])) << 8
|
||||
csum += uint32(ip.DstIP[1]) + uint32(ip.DstIP[3])
|
||||
return csum, nil
|
||||
}
|
||||
|
||||
func (ip *IPv6) pseudoheaderChecksum() (csum uint32, err error) {
|
||||
if err := ip.AddressTo16(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
for i := 0; i < 16; i += 2 {
|
||||
csum += uint32(ip.SrcIP[i]) << 8
|
||||
csum += uint32(ip.SrcIP[i+1])
|
||||
csum += uint32(ip.DstIP[i]) << 8
|
||||
csum += uint32(ip.DstIP[i+1])
|
||||
}
|
||||
return csum, nil
|
||||
}
|
||||
|
||||
// Calculate the TCP/IP checksum defined in rfc1071. The passed-in csum is any
|
||||
// initial checksum data that's already been computed.
|
||||
func tcpipChecksum(data []byte, csum uint32) uint16 {
|
||||
// to handle odd lengths, we loop to length - 1, incrementing by 2, then
|
||||
// handle the last byte specifically by checking against the original
|
||||
// length.
|
||||
length := len(data) - 1
|
||||
for i := 0; i < length; i += 2 {
|
||||
// For our test packet, doing this manually is about 25% faster
|
||||
// (740 ns vs. 1000ns) than doing it by calling binary.BigEndian.Uint16.
|
||||
csum += uint32(data[i]) << 8
|
||||
csum += uint32(data[i+1])
|
||||
}
|
||||
if len(data)%2 == 1 {
|
||||
csum += uint32(data[length]) << 8
|
||||
}
|
||||
for csum > 0xffff {
|
||||
csum = (csum >> 16) + (csum & 0xffff)
|
||||
}
|
||||
return ^uint16(csum)
|
||||
}
|
||||
|
||||
// computeChecksum computes a TCP or UDP checksum. headerAndPayload is the
|
||||
// serialized TCP or UDP header plus its payload, with the checksum zero'd
|
||||
// out. headerProtocol is the IP protocol number of the upper-layer header.
|
||||
func (c *tcpipchecksum) computeChecksum(headerAndPayload []byte, headerProtocol IPProtocol) (uint16, error) {
|
||||
if c.pseudoheader == nil {
|
||||
return 0, errors.New("TCP/IP layer 4 checksum cannot be computed without network layer... call SetNetworkLayerForChecksum to set which layer to use")
|
||||
}
|
||||
length := uint32(len(headerAndPayload))
|
||||
csum, err := c.pseudoheader.pseudoheaderChecksum()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
csum += uint32(headerProtocol)
|
||||
csum += length & 0xffff
|
||||
csum += length >> 16
|
||||
return tcpipChecksum(headerAndPayload, csum), nil
|
||||
}
|
||||
|
||||
// SetNetworkLayerForChecksum tells this layer which network layer is wrapping it.
|
||||
// This is needed for computing the checksum when serializing, since TCP/IP transport
|
||||
// layer checksums depends on fields in the IPv4 or IPv6 layer that contains it.
|
||||
// The passed in layer must be an *IPv4 or *IPv6.
|
||||
func (i *tcpipchecksum) SetNetworkLayerForChecksum(l gopacket.NetworkLayer) error {
|
||||
switch v := l.(type) {
|
||||
case *IPv4:
|
||||
i.pseudoheader = v
|
||||
case *IPv6:
|
||||
i.pseudoheader = v
|
||||
default:
|
||||
return fmt.Errorf("cannot use layer type %v for tcp checksum network layer", l.LayerType())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,103 @@
|
||||
#!/usr/bin/python
|
||||
# Copyright 2012 Google, Inc. All rights reserved.
|
||||
|
||||
"""TestCreator creates test templates from pcap files."""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import glob
|
||||
import re
|
||||
import string
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
|
||||
class Packet(object):
|
||||
"""Helper class encapsulating packet from a pcap file."""
|
||||
|
||||
def __init__(self, packet_lines):
|
||||
self.packet_lines = packet_lines
|
||||
self.data = self._DecodeText(packet_lines)
|
||||
|
||||
@classmethod
|
||||
def _DecodeText(cls, packet_lines):
|
||||
packet_bytes = []
|
||||
# First line is timestamp and stuff, skip it.
|
||||
# Format: 0x0010: 0000 0020 3aff 3ffe 0000 0000 0000 0000 ....:.?.........
|
||||
|
||||
for line in packet_lines[1:]:
|
||||
m = re.match(r'\s+0x[a-f\d]+:\s+((?:[\da-f]{2,4}\s)*)', line, re.IGNORECASE)
|
||||
if m is None: continue
|
||||
for hexpart in m.group(1).split():
|
||||
packet_bytes.append(base64.b16decode(hexpart.upper()))
|
||||
return ''.join(packet_bytes)
|
||||
|
||||
def Test(self, name, link_type):
|
||||
"""Yields a test using this packet, as a set of lines."""
|
||||
yield '// testPacket%s is the packet:' % name
|
||||
for line in self.packet_lines:
|
||||
yield '// ' + line
|
||||
yield 'var testPacket%s = []byte{' % name
|
||||
data = list(self.data)
|
||||
while data:
|
||||
linebytes, data = data[:16], data[16:]
|
||||
yield ''.join(['\t'] + ['0x%02x, ' % ord(c) for c in linebytes])
|
||||
yield '}'
|
||||
yield 'func TestPacket%s(t *testing.T) {' % name
|
||||
yield '\tp := gopacket.NewPacket(testPacket%s, LinkType%s, gopacket.Default)' % (name, link_type)
|
||||
yield '\tif p.ErrorLayer() != nil {'
|
||||
yield '\t\tt.Error("Failed to decode packet:", p.ErrorLayer().Error())'
|
||||
yield '\t}'
|
||||
yield '\tcheckLayers(p, []gopacket.LayerType{LayerType%s, FILL_ME_IN_WITH_ACTUAL_LAYERS}, t)' % link_type
|
||||
yield '}'
|
||||
yield 'func BenchmarkDecodePacket%s(b *testing.B) {' % name
|
||||
yield '\tfor i := 0; i < b.N; i++ {'
|
||||
yield '\t\tgopacket.NewPacket(testPacket%s, LinkType%s, gopacket.NoCopy)' % (name, link_type)
|
||||
yield '\t}'
|
||||
yield '}'
|
||||
|
||||
|
||||
|
||||
def GetTcpdumpOutput(filename):
|
||||
"""Runs tcpdump on the given file, returning output as string."""
|
||||
return subprocess.check_output(
|
||||
['tcpdump', '-XX', '-s', '0', '-n', '-r', filename])
|
||||
|
||||
|
||||
def TcpdumpOutputToPackets(output):
|
||||
"""Reads a pcap file with TCPDump, yielding Packet objects."""
|
||||
pdata = []
|
||||
for line in output.splitlines():
|
||||
if line[0] not in string.whitespace and pdata:
|
||||
yield Packet(pdata)
|
||||
pdata = []
|
||||
pdata.append(line)
|
||||
if pdata:
|
||||
yield Packet(pdata)
|
||||
|
||||
|
||||
def main():
|
||||
class CustomHelpFormatter(argparse.ArgumentDefaultsHelpFormatter):
|
||||
def _format_usage(self, usage, actions, groups, prefix=None):
|
||||
header =('TestCreator creates gopacket tests using a pcap file.\n\n'
|
||||
'Tests are written to standard out... they can then be \n'
|
||||
'copied into the file of your choice and modified as \n'
|
||||
'you see.\n\n')
|
||||
return header + argparse.ArgumentDefaultsHelpFormatter._format_usage(
|
||||
self, usage, actions, groups, prefix)
|
||||
|
||||
parser = argparse.ArgumentParser(formatter_class=CustomHelpFormatter)
|
||||
parser.add_argument('--link_type', default='Ethernet', help='the link type (default: %(default)s)')
|
||||
parser.add_argument('--name', default='Packet%d', help='the layer type, must have "%d" inside it')
|
||||
parser.add_argument('files', metavar='file.pcap', type=str, nargs='+', help='the files to process')
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
for arg in args.files:
|
||||
for path in glob.glob(arg):
|
||||
for i, packet in enumerate(TcpdumpOutputToPackets(GetTcpdumpOutput(path))):
|
||||
print '\n'.join(packet.Test(
|
||||
args.name % i, args.link_type))
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@ -0,0 +1,120 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// UDP is the layer for UDP headers.
|
||||
type UDP struct {
|
||||
BaseLayer
|
||||
SrcPort, DstPort UDPPort
|
||||
Length uint16
|
||||
Checksum uint16
|
||||
sPort, dPort []byte
|
||||
tcpipchecksum
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeUDP
|
||||
func (u *UDP) LayerType() gopacket.LayerType { return LayerTypeUDP }
|
||||
|
||||
func (udp *UDP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
udp.SrcPort = UDPPort(binary.BigEndian.Uint16(data[0:2]))
|
||||
udp.sPort = data[0:2]
|
||||
udp.DstPort = UDPPort(binary.BigEndian.Uint16(data[2:4]))
|
||||
udp.dPort = data[2:4]
|
||||
udp.Length = binary.BigEndian.Uint16(data[4:6])
|
||||
udp.Checksum = binary.BigEndian.Uint16(data[6:8])
|
||||
udp.BaseLayer = BaseLayer{Contents: data[:8]}
|
||||
switch {
|
||||
case udp.Length >= 8:
|
||||
hlen := int(udp.Length)
|
||||
if hlen > len(data) {
|
||||
df.SetTruncated()
|
||||
hlen = len(data)
|
||||
}
|
||||
udp.Payload = data[8:hlen]
|
||||
case udp.Length == 0: // Jumbogram, use entire rest of data
|
||||
udp.Payload = data[8:]
|
||||
default:
|
||||
return fmt.Errorf("UDP packet too small: %d bytes", udp.Length)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (u *UDP) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
var jumbo bool
|
||||
|
||||
payload := b.Bytes()
|
||||
if _, ok := u.pseudoheader.(*IPv6); ok {
|
||||
if len(payload)+8 > 65535 {
|
||||
jumbo = true
|
||||
}
|
||||
}
|
||||
bytes, err := b.PrependBytes(8)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes, uint16(u.SrcPort))
|
||||
binary.BigEndian.PutUint16(bytes[2:], uint16(u.DstPort))
|
||||
if opts.FixLengths {
|
||||
if jumbo {
|
||||
u.Length = 0
|
||||
} else {
|
||||
u.Length = uint16(len(payload)) + 8
|
||||
}
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[4:], u.Length)
|
||||
if opts.ComputeChecksums {
|
||||
// zero out checksum bytes
|
||||
bytes[6] = 0
|
||||
bytes[7] = 0
|
||||
csum, err := u.computeChecksum(b.Bytes(), IPProtocolUDP)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
u.Checksum = csum
|
||||
}
|
||||
binary.BigEndian.PutUint16(bytes[6:], u.Checksum)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (u *UDP) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeUDP
|
||||
}
|
||||
|
||||
// NextLayerType use the destination port to select the
|
||||
// right next decoder. It tries first to decode via the
|
||||
// destination port, then the source port.
|
||||
func (u *UDP) NextLayerType() gopacket.LayerType {
|
||||
if lt := u.DstPort.LayerType(); lt != gopacket.LayerTypePayload {
|
||||
return lt
|
||||
}
|
||||
return u.SrcPort.LayerType()
|
||||
}
|
||||
|
||||
func decodeUDP(data []byte, p gopacket.PacketBuilder) error {
|
||||
udp := &UDP{}
|
||||
err := udp.DecodeFromBytes(data, p)
|
||||
p.AddLayer(udp)
|
||||
p.SetTransportLayer(udp)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return p.NextDecoder(udp.NextLayerType())
|
||||
}
|
||||
|
||||
func (u *UDP) TransportFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointUDPPort, u.sPort, u.dPort)
|
||||
}
|
||||
@ -0,0 +1,44 @@
|
||||
// Copyright 2012 Google, Inc. All rights reserved.
|
||||
// Copyright 2009-2011 Andreas Krennmair. 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 (
|
||||
"encoding/binary"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// UDPLite is the layer for UDP-Lite headers (rfc 3828).
|
||||
type UDPLite struct {
|
||||
BaseLayer
|
||||
SrcPort, DstPort UDPLitePort
|
||||
ChecksumCoverage uint16
|
||||
Checksum uint16
|
||||
sPort, dPort []byte
|
||||
}
|
||||
|
||||
// LayerType returns gopacket.LayerTypeUDPLite
|
||||
func (u *UDPLite) LayerType() gopacket.LayerType { return LayerTypeUDPLite }
|
||||
|
||||
func decodeUDPLite(data []byte, p gopacket.PacketBuilder) error {
|
||||
udp := &UDPLite{
|
||||
SrcPort: UDPLitePort(binary.BigEndian.Uint16(data[0:2])),
|
||||
sPort: data[0:2],
|
||||
DstPort: UDPLitePort(binary.BigEndian.Uint16(data[2:4])),
|
||||
dPort: data[2:4],
|
||||
ChecksumCoverage: binary.BigEndian.Uint16(data[4:6]),
|
||||
Checksum: binary.BigEndian.Uint16(data[6:8]),
|
||||
BaseLayer: BaseLayer{data[:8], data[8:]},
|
||||
}
|
||||
p.AddLayer(udp)
|
||||
p.SetTransportLayer(udp)
|
||||
return p.NextDecoder(gopacket.LayerTypePayload)
|
||||
}
|
||||
|
||||
func (u *UDPLite) TransportFlow() gopacket.Flow {
|
||||
return gopacket.NewFlow(EndpointUDPLitePort, u.sPort, u.dPort)
|
||||
}
|
||||
@ -0,0 +1,308 @@
|
||||
// Copyright 2014 Google, 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 (
|
||||
"encoding/binary"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
type USBEventType uint8
|
||||
|
||||
const (
|
||||
USBEventTypeSubmit USBEventType = 'S'
|
||||
USBEventTypeComplete USBEventType = 'C'
|
||||
USBEventTypeError USBEventType = 'E'
|
||||
)
|
||||
|
||||
func (a USBEventType) String() string {
|
||||
switch a {
|
||||
case USBEventTypeSubmit:
|
||||
return "SUBMIT"
|
||||
case USBEventTypeComplete:
|
||||
return "COMPLETE"
|
||||
case USBEventTypeError:
|
||||
return "ERROR"
|
||||
default:
|
||||
return "Unknown event type"
|
||||
}
|
||||
}
|
||||
|
||||
type USBRequestBlockSetupRequest uint8
|
||||
|
||||
const (
|
||||
USBRequestBlockSetupRequestGetStatus USBRequestBlockSetupRequest = 0x00
|
||||
USBRequestBlockSetupRequestClearFeature USBRequestBlockSetupRequest = 0x01
|
||||
USBRequestBlockSetupRequestSetFeature USBRequestBlockSetupRequest = 0x03
|
||||
USBRequestBlockSetupRequestSetAddress USBRequestBlockSetupRequest = 0x05
|
||||
USBRequestBlockSetupRequestGetDescriptor USBRequestBlockSetupRequest = 0x06
|
||||
USBRequestBlockSetupRequestSetDescriptor USBRequestBlockSetupRequest = 0x07
|
||||
USBRequestBlockSetupRequestGetConfiguration USBRequestBlockSetupRequest = 0x08
|
||||
USBRequestBlockSetupRequestSetConfiguration USBRequestBlockSetupRequest = 0x09
|
||||
USBRequestBlockSetupRequestSetIdle USBRequestBlockSetupRequest = 0x0a
|
||||
)
|
||||
|
||||
func (a USBRequestBlockSetupRequest) String() string {
|
||||
switch a {
|
||||
case USBRequestBlockSetupRequestGetStatus:
|
||||
return "GET_STATUS"
|
||||
case USBRequestBlockSetupRequestClearFeature:
|
||||
return "CLEAR_FEATURE"
|
||||
case USBRequestBlockSetupRequestSetFeature:
|
||||
return "SET_FEATURE"
|
||||
case USBRequestBlockSetupRequestSetAddress:
|
||||
return "SET_ADDRESS"
|
||||
case USBRequestBlockSetupRequestGetDescriptor:
|
||||
return "GET_DESCRIPTOR"
|
||||
case USBRequestBlockSetupRequestSetDescriptor:
|
||||
return "SET_DESCRIPTOR"
|
||||
case USBRequestBlockSetupRequestGetConfiguration:
|
||||
return "GET_CONFIGURATION"
|
||||
case USBRequestBlockSetupRequestSetConfiguration:
|
||||
return "SET_CONFIGURATION"
|
||||
case USBRequestBlockSetupRequestSetIdle:
|
||||
return "SET_IDLE"
|
||||
default:
|
||||
return "UNKNOWN"
|
||||
}
|
||||
}
|
||||
|
||||
type USBTransportType uint8
|
||||
|
||||
const (
|
||||
USBTransportTypeTransferIn USBTransportType = 0x80 // Indicates send or receive
|
||||
USBTransportTypeIsochronous USBTransportType = 0x00 // Isochronous transfers occur continuously and periodically. They typically contain time sensitive information, such as an audio or video stream.
|
||||
USBTransportTypeInterrupt USBTransportType = 0x01 // Interrupt transfers are typically non-periodic, small device "initiated" communication requiring bounded latency, such as pointing devices or keyboards.
|
||||
USBTransportTypeControl USBTransportType = 0x02 // Control transfers are typically used for command and status operations.
|
||||
USBTransportTypeBulk USBTransportType = 0x03 // Bulk transfers can be used for large bursty data, using all remaining available bandwidth, no guarantees on bandwidth or latency, such as file transfers.
|
||||
)
|
||||
|
||||
func (a USBTransportType) LayerType() gopacket.LayerType {
|
||||
return USBTypeMetadata[a].LayerType
|
||||
}
|
||||
|
||||
func (a USBTransportType) String() string {
|
||||
switch a {
|
||||
case USBTransportTypeTransferIn:
|
||||
return "Transfer In"
|
||||
case USBTransportTypeIsochronous:
|
||||
return "Isochronous"
|
||||
case USBTransportTypeInterrupt:
|
||||
return "Interrupt"
|
||||
case USBTransportTypeControl:
|
||||
return "Control"
|
||||
case USBTransportTypeBulk:
|
||||
return "Bulk"
|
||||
default:
|
||||
return "Unknown transport type"
|
||||
}
|
||||
}
|
||||
|
||||
type USBDirectionType uint8
|
||||
|
||||
const (
|
||||
USBDirectionTypeUnknown USBDirectionType = iota
|
||||
USBDirectionTypeIn
|
||||
USBDirectionTypeOut
|
||||
)
|
||||
|
||||
func (a USBDirectionType) String() string {
|
||||
switch a {
|
||||
case USBDirectionTypeIn:
|
||||
return "In"
|
||||
case USBDirectionTypeOut:
|
||||
return "Out"
|
||||
default:
|
||||
return "Unknown direction type"
|
||||
}
|
||||
}
|
||||
|
||||
// The reference at http://www.beyondlogic.org/usbnutshell/usb1.shtml contains more information about the protocol.
|
||||
type USB struct {
|
||||
BaseLayer
|
||||
ID uint64
|
||||
EventType USBEventType
|
||||
TransferType USBTransportType
|
||||
Direction USBDirectionType
|
||||
EndpointNumber uint8
|
||||
DeviceAddress uint8
|
||||
BusID uint16
|
||||
TimestampSec int64
|
||||
TimestampUsec int32
|
||||
Setup bool
|
||||
Data bool
|
||||
Status int32
|
||||
UrbLength uint32
|
||||
UrbDataLength uint32
|
||||
|
||||
UrbInterval uint32
|
||||
UrbStartFrame uint32
|
||||
UrbCopyOfTransferFlags uint32
|
||||
IsoNumDesc uint32
|
||||
}
|
||||
|
||||
func (u *USB) LayerType() gopacket.LayerType { return LayerTypeUSB }
|
||||
|
||||
func (m *USB) NextLayerType() gopacket.LayerType {
|
||||
if m.Setup {
|
||||
return LayerTypeUSBRequestBlockSetup
|
||||
} else if m.Data {
|
||||
}
|
||||
|
||||
return m.TransferType.LayerType()
|
||||
}
|
||||
|
||||
func decodeUSB(data []byte, p gopacket.PacketBuilder) error {
|
||||
d := &USB{}
|
||||
|
||||
return decodingLayerDecoder(d, data, p)
|
||||
}
|
||||
|
||||
func (m *USB) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
m.ID = binary.LittleEndian.Uint64(data[0:8])
|
||||
m.EventType = USBEventType(data[8])
|
||||
m.TransferType = USBTransportType(data[9])
|
||||
|
||||
m.EndpointNumber = data[10] & 0x7f
|
||||
if data[10]&uint8(USBTransportTypeTransferIn) > 0 {
|
||||
m.Direction = USBDirectionTypeIn
|
||||
} else {
|
||||
m.Direction = USBDirectionTypeOut
|
||||
}
|
||||
|
||||
m.DeviceAddress = data[11]
|
||||
m.BusID = binary.LittleEndian.Uint16(data[12:14])
|
||||
|
||||
if uint(data[14]) == 0 {
|
||||
m.Setup = true
|
||||
}
|
||||
|
||||
if uint(data[15]) == 0 {
|
||||
m.Data = true
|
||||
}
|
||||
|
||||
m.TimestampSec = int64(binary.LittleEndian.Uint64(data[16:24]))
|
||||
m.TimestampUsec = int32(binary.LittleEndian.Uint32(data[24:28]))
|
||||
m.Status = int32(binary.LittleEndian.Uint32(data[28:32]))
|
||||
m.UrbLength = binary.LittleEndian.Uint32(data[32:36])
|
||||
m.UrbDataLength = binary.LittleEndian.Uint32(data[36:40])
|
||||
|
||||
m.Contents = data[:40]
|
||||
m.Payload = data[40:]
|
||||
|
||||
if m.Setup {
|
||||
m.Payload = data[40:]
|
||||
} else if m.Data {
|
||||
m.Payload = data[uint32(len(data))-m.UrbDataLength:]
|
||||
}
|
||||
|
||||
// if 64 bit, dissect_linux_usb_pseudo_header_ext
|
||||
if false {
|
||||
m.UrbInterval = binary.LittleEndian.Uint32(data[40:44])
|
||||
m.UrbStartFrame = binary.LittleEndian.Uint32(data[44:48])
|
||||
m.UrbDataLength = binary.LittleEndian.Uint32(data[48:52])
|
||||
m.IsoNumDesc = binary.LittleEndian.Uint32(data[52:56])
|
||||
m.Contents = data[:56]
|
||||
m.Payload = data[56:]
|
||||
}
|
||||
|
||||
// crc5 or crc16
|
||||
// eop (end of packet)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type USBRequestBlockSetup struct {
|
||||
BaseLayer
|
||||
RequestType uint8
|
||||
Request USBRequestBlockSetupRequest
|
||||
Value uint16
|
||||
Index uint16
|
||||
Length uint16
|
||||
}
|
||||
|
||||
func (u *USBRequestBlockSetup) LayerType() gopacket.LayerType { return LayerTypeUSBRequestBlockSetup }
|
||||
|
||||
func (m *USBRequestBlockSetup) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
func (m *USBRequestBlockSetup) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
m.RequestType = data[0]
|
||||
m.Request = USBRequestBlockSetupRequest(data[1])
|
||||
m.Value = binary.LittleEndian.Uint16(data[2:4])
|
||||
m.Index = binary.LittleEndian.Uint16(data[4:6])
|
||||
m.Length = binary.LittleEndian.Uint16(data[6:8])
|
||||
m.Contents = data[:8]
|
||||
m.Payload = data[8:]
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeUSBRequestBlockSetup(data []byte, p gopacket.PacketBuilder) error {
|
||||
d := &USBRequestBlockSetup{}
|
||||
return decodingLayerDecoder(d, data, p)
|
||||
}
|
||||
|
||||
type USBControl struct {
|
||||
BaseLayer
|
||||
}
|
||||
|
||||
func (u *USBControl) LayerType() gopacket.LayerType { return LayerTypeUSBControl }
|
||||
|
||||
func (m *USBControl) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
func (m *USBControl) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
m.Contents = data
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeUSBControl(data []byte, p gopacket.PacketBuilder) error {
|
||||
d := &USBControl{}
|
||||
return decodingLayerDecoder(d, data, p)
|
||||
}
|
||||
|
||||
type USBInterrupt struct {
|
||||
BaseLayer
|
||||
}
|
||||
|
||||
func (u *USBInterrupt) LayerType() gopacket.LayerType { return LayerTypeUSBInterrupt }
|
||||
|
||||
func (m *USBInterrupt) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
func (m *USBInterrupt) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
m.Contents = data
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeUSBInterrupt(data []byte, p gopacket.PacketBuilder) error {
|
||||
d := &USBInterrupt{}
|
||||
return decodingLayerDecoder(d, data, p)
|
||||
}
|
||||
|
||||
type USBBulk struct {
|
||||
BaseLayer
|
||||
}
|
||||
|
||||
func (u *USBBulk) LayerType() gopacket.LayerType { return LayerTypeUSBBulk }
|
||||
|
||||
func (m *USBBulk) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypePayload
|
||||
}
|
||||
|
||||
func (m *USBBulk) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
m.Contents = data
|
||||
return nil
|
||||
}
|
||||
|
||||
func decodeUSBBulk(data []byte, p gopacket.PacketBuilder) error {
|
||||
d := &USBBulk{}
|
||||
return decodingLayerDecoder(d, data, p)
|
||||
}
|
||||
@ -0,0 +1,156 @@
|
||||
// Copyright 2016 Google, 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 (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"net"
|
||||
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
/*
|
||||
This layer provides decoding for Virtual Router Redundancy Protocol (VRRP) v2.
|
||||
https://tools.ietf.org/html/rfc3768#section-5
|
||||
0 1 2 3
|
||||
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
|Version| Type | Virtual Rtr ID| Priority | Count IP Addrs|
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
| Auth Type | Adver Int | Checksum |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
| IP Address (1) |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
| . |
|
||||
| . |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
| IP Address (n) |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
| Authentication Data (1) |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
| Authentication Data (2) |
|
||||
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
*/
|
||||
|
||||
type VRRPv2Type uint8
|
||||
type VRRPv2AuthType uint8
|
||||
|
||||
const (
|
||||
VRRPv2Advertisement VRRPv2Type = 0x01 // router advertisement
|
||||
)
|
||||
|
||||
// String conversions for VRRP message types
|
||||
func (v VRRPv2Type) String() string {
|
||||
switch v {
|
||||
case VRRPv2Advertisement:
|
||||
return "VRRPv2 Advertisement"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
const (
|
||||
VRRPv2AuthNoAuth VRRPv2AuthType = 0x00 // No Authentication
|
||||
VRRPv2AuthReserved1 VRRPv2AuthType = 0x01 // Reserved field 1
|
||||
VRRPv2AuthReserved2 VRRPv2AuthType = 0x02 // Reserved field 2
|
||||
)
|
||||
|
||||
func (v VRRPv2AuthType) String() string {
|
||||
switch v {
|
||||
case VRRPv2AuthNoAuth:
|
||||
return "No Authentication"
|
||||
case VRRPv2AuthReserved1:
|
||||
return "Reserved"
|
||||
case VRRPv2AuthReserved2:
|
||||
return "Reserved"
|
||||
default:
|
||||
return ""
|
||||
}
|
||||
}
|
||||
|
||||
// VRRPv2 represents an VRRP v2 message.
|
||||
type VRRPv2 struct {
|
||||
BaseLayer
|
||||
Version uint8 // The version field specifies the VRRP protocol version of this packet (v2)
|
||||
Type VRRPv2Type // The type field specifies the type of this VRRP packet. The only type defined in v2 is ADVERTISEMENT
|
||||
VirtualRtrID uint8 // identifies the virtual router this packet is reporting status for
|
||||
Priority uint8 // specifies the sending VRRP router's priority for the virtual router (100 = default)
|
||||
CountIPAddr uint8 // The number of IP addresses contained in this VRRP advertisement.
|
||||
AuthType VRRPv2AuthType // identifies the authentication method being utilized
|
||||
AdverInt uint8 // The Advertisement interval indicates the time interval (in seconds) between ADVERTISEMENTS. The default is 1 second
|
||||
Checksum uint16 // used to detect data corruption in the VRRP message.
|
||||
IPAddress []net.IP // one or more IP addresses associated with the virtual router. Specified in the CountIPAddr field.
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeVRRP for VRRP v2 message.
|
||||
func (v *VRRPv2) LayerType() gopacket.LayerType { return LayerTypeVRRP }
|
||||
|
||||
func (v *VRRPv2) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
|
||||
|
||||
v.BaseLayer = BaseLayer{Contents: data[:len(data)]}
|
||||
v.Version = data[0] >> 4 // high nibble == VRRP version. We're expecting v2
|
||||
|
||||
v.Type = VRRPv2Type(data[0] & 0x0F) // low nibble == VRRP type. Expecting 1 (advertisement)
|
||||
if v.Type != 1 {
|
||||
// rfc3768: A packet with unknown type MUST be discarded.
|
||||
return errors.New("Unrecognized VRRPv2 type field.")
|
||||
}
|
||||
|
||||
v.VirtualRtrID = data[1]
|
||||
v.Priority = data[2]
|
||||
|
||||
v.CountIPAddr = data[3]
|
||||
if v.CountIPAddr < 1 {
|
||||
return errors.New("VRRPv2 number of IP addresses is not valid.")
|
||||
}
|
||||
|
||||
v.AuthType = VRRPv2AuthType(data[4])
|
||||
v.AdverInt = uint8(data[5])
|
||||
v.Checksum = binary.BigEndian.Uint16(data[6:8])
|
||||
|
||||
// populate the IPAddress field. The number of addresses is specified in the v.CountIPAddr field
|
||||
// offset references the starting byte containing the list of ip addresses
|
||||
offset := 8
|
||||
for i := uint8(0); i < v.CountIPAddr; i++ {
|
||||
v.IPAddress = append(v.IPAddress, data[offset:offset+4])
|
||||
offset += 4
|
||||
}
|
||||
|
||||
// any trailing packets here may be authentication data and *should* be ignored in v2 as per RFC
|
||||
//
|
||||
// 5.3.10. Authentication Data
|
||||
//
|
||||
// The authentication string is currently only used to maintain
|
||||
// backwards compatibility with RFC 2338. It SHOULD be set to zero on
|
||||
// transmission and ignored on reception.
|
||||
return nil
|
||||
}
|
||||
|
||||
// CanDecode specifies the layer type in which we are attempting to unwrap.
|
||||
func (v *VRRPv2) CanDecode() gopacket.LayerClass {
|
||||
return LayerTypeVRRP
|
||||
}
|
||||
|
||||
// NextLayerType specifies the next layer that should be decoded. VRRP does not contain any further payload, so we set to 0
|
||||
func (v *VRRPv2) NextLayerType() gopacket.LayerType {
|
||||
return gopacket.LayerTypeZero
|
||||
}
|
||||
|
||||
// The VRRP packet does not include payload data. Setting byte slice to nil
|
||||
func (v *VRRPv2) Payload() []byte {
|
||||
return nil
|
||||
}
|
||||
|
||||
// decodeVRRP will parse VRRP v2
|
||||
func decodeVRRP(data []byte, p gopacket.PacketBuilder) error {
|
||||
if len(data) < 8 {
|
||||
return errors.New("Not a valid VRRP packet. Packet length is too small.")
|
||||
}
|
||||
v := &VRRPv2{}
|
||||
return decodingLayerDecoder(v, data, p)
|
||||
}
|
||||
@ -0,0 +1,94 @@
|
||||
// Copyright 2016 Google, 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 (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"github.com/google/gopacket"
|
||||
)
|
||||
|
||||
// VXLAN is specifed in RFC 7348 https://tools.ietf.org/html/rfc7348
|
||||
// G, D, A, Group Policy ID from https://tools.ietf.org/html/draft-smith-vxlan-group-policy-00
|
||||
// 0 1 2 3
|
||||
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
|
||||
// 0 8 16 24 32
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// |G|R|R|R|I|R|R|R|R|D|R|R|A|R|R|R| Group Policy ID |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
// | 24 bit VXLAN Network Identifier | Reserved |
|
||||
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|
||||
|
||||
// VXLAN is a VXLAN packet header
|
||||
type VXLAN struct {
|
||||
BaseLayer
|
||||
ValidIDFlag bool // 'I' bit per RFC 7348
|
||||
VNI uint32 // 'VXLAN Network Identifier' 24 bits per RFC 7348
|
||||
GBPExtension bool // 'G' bit per Group Policy https://tools.ietf.org/html/draft-smith-vxlan-group-policy-00
|
||||
GBPDontLearn bool // 'D' bit per Group Policy
|
||||
GBPApplied bool // 'A' bit per Group Policy
|
||||
GBPGroupPolicyID uint16 // 'Group Policy ID' 16 bits per Group Policy
|
||||
}
|
||||
|
||||
// LayerType returns LayerTypeVXLAN
|
||||
func (vx *VXLAN) LayerType() gopacket.LayerType { return LayerTypeVXLAN }
|
||||
|
||||
func decodeVXLAN(data []byte, p gopacket.PacketBuilder) error {
|
||||
vx := &VXLAN{}
|
||||
|
||||
// VNI is a 24bit number, Uint32 requires 32 bits
|
||||
var buf [4]byte
|
||||
copy(buf[1:], data[4:7])
|
||||
|
||||
// RFC 7348 https://tools.ietf.org/html/rfc7348
|
||||
vx.ValidIDFlag = data[0]&0x08 > 0 // 'I' bit per RFC7348
|
||||
vx.VNI = binary.BigEndian.Uint32(buf[:]) // VXLAN Network Identifier per RFC7348
|
||||
|
||||
// Group Based Policy https://tools.ietf.org/html/draft-smith-vxlan-group-policy-00
|
||||
vx.GBPExtension = data[0]&0x80 > 0 // 'G' bit per the group policy draft
|
||||
vx.GBPDontLearn = data[1]&0x40 > 0 // 'D' bit - the egress VTEP MUST NOT learn the source address of the encapsulated frame.
|
||||
vx.GBPApplied = data[1]&0x80 > 0 // 'A' bit - indicates that the group policy has already been applied to this packet.
|
||||
vx.GBPGroupPolicyID = binary.BigEndian.Uint16(data[2:4]) // Policy ID as per the group policy draft
|
||||
|
||||
// Layer information
|
||||
const vxlanLength = 8
|
||||
vx.Contents = data[:vxlanLength]
|
||||
vx.Payload = data[vxlanLength:]
|
||||
|
||||
p.AddLayer(vx)
|
||||
return p.NextDecoder(LinkTypeEthernet)
|
||||
}
|
||||
|
||||
// SerializeTo writes the serialized form of this layer into the
|
||||
// SerializationBuffer, implementing gopacket.SerializableLayer.
|
||||
// See the docs for gopacket.SerializableLayer for more info.
|
||||
func (vx *VXLAN) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error {
|
||||
bytes, err := b.PrependBytes(8)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if vx.ValidIDFlag {
|
||||
bytes[0] |= 0x08
|
||||
}
|
||||
if vx.GBPExtension {
|
||||
bytes[0] |= 0x80
|
||||
}
|
||||
if vx.GBPDontLearn {
|
||||
bytes[1] |= 0x40
|
||||
}
|
||||
if vx.GBPApplied {
|
||||
bytes[1] |= 0x80
|
||||
}
|
||||
|
||||
binary.BigEndian.PutUint16(bytes[2:4], vx.GBPGroupPolicyID)
|
||||
if vx.VNI >= 1<<24 {
|
||||
return fmt.Errorf("Virtual Network Identifier = %x exceeds max for 24-bit uint", vx.VNI)
|
||||
}
|
||||
binary.BigEndian.PutUint32(bytes[4:8], vx.VNI<<8)
|
||||
return nil
|
||||
}
|
||||
@ -0,0 +1,111 @@
|
||||
// Copyright 2012 Google, 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 gopacket
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// LayerType is a unique identifier for each type of layer. This enumeration
|
||||
// does not match with any externally available numbering scheme... it's solely
|
||||
// usable/useful within this library as a means for requesting layer types
|
||||
// (see Packet.Layer) and determining which types of layers have been decoded.
|
||||
//
|
||||
// New LayerTypes may be created by calling gopacket.RegisterLayerType.
|
||||
type LayerType int64
|
||||
|
||||
// LayerTypeMetadata contains metadata associated with each LayerType.
|
||||
type LayerTypeMetadata struct {
|
||||
// Name is the string returned by each layer type's String method.
|
||||
Name string
|
||||
// Decoder is the decoder to use when the layer type is passed in as a
|
||||
// Decoder.
|
||||
Decoder Decoder
|
||||
}
|
||||
|
||||
type layerTypeMetadata struct {
|
||||
inUse bool
|
||||
LayerTypeMetadata
|
||||
}
|
||||
|
||||
// DecodersByLayerName maps layer names to decoders for those layers.
|
||||
// This allows users to specify decoders by name to a program and have that
|
||||
// program pick the correct decoder accordingly.
|
||||
var DecodersByLayerName = map[string]Decoder{}
|
||||
|
||||
const maxLayerType = 2000
|
||||
|
||||
var ltMeta [maxLayerType]layerTypeMetadata
|
||||
var ltMetaMap = map[LayerType]layerTypeMetadata{}
|
||||
|
||||
// RegisterLayerType creates a new layer type and registers it globally.
|
||||
// The number passed in must be unique, or a runtime panic will occur. Numbers
|
||||
// 0-999 are reserved for the gopacket library. Numbers 1000-1999 should be
|
||||
// used for common application-specific types, and are very fast. Any other
|
||||
// number (negative or >= 2000) may be used for uncommon application-specific
|
||||
// types, and are somewhat slower (they require a map lookup over an array
|
||||
// index).
|
||||
func RegisterLayerType(num int, meta LayerTypeMetadata) LayerType {
|
||||
if 0 <= num && num < maxLayerType {
|
||||
if ltMeta[num].inUse {
|
||||
panic("Layer type already exists")
|
||||
}
|
||||
} else {
|
||||
if ltMetaMap[LayerType(num)].inUse {
|
||||
panic("Layer type already exists")
|
||||
}
|
||||
}
|
||||
return OverrideLayerType(num, meta)
|
||||
}
|
||||
|
||||
// OverrideLayerType acts like RegisterLayerType, except that if the layer type
|
||||
// has already been registered, it overrides the metadata with the passed-in
|
||||
// metadata intead of panicing.
|
||||
func OverrideLayerType(num int, meta LayerTypeMetadata) LayerType {
|
||||
if 0 <= num && num < maxLayerType {
|
||||
ltMeta[num] = layerTypeMetadata{
|
||||
inUse: true,
|
||||
LayerTypeMetadata: meta,
|
||||
}
|
||||
} else {
|
||||
ltMetaMap[LayerType(num)] = layerTypeMetadata{
|
||||
inUse: true,
|
||||
LayerTypeMetadata: meta,
|
||||
}
|
||||
}
|
||||
DecodersByLayerName[meta.Name] = meta.Decoder
|
||||
return LayerType(num)
|
||||
}
|
||||
|
||||
// Decode decodes the given data using the decoder registered with the layer
|
||||
// type.
|
||||
func (t LayerType) Decode(data []byte, c PacketBuilder) error {
|
||||
var d Decoder
|
||||
if 0 <= int(t) && int(t) < maxLayerType {
|
||||
d = ltMeta[int(t)].Decoder
|
||||
} else {
|
||||
d = ltMetaMap[t].Decoder
|
||||
}
|
||||
if d != nil {
|
||||
return d.Decode(data, c)
|
||||
}
|
||||
return fmt.Errorf("Layer type %v has no associated decoder", t)
|
||||
}
|
||||
|
||||
// String returns the string associated with this layer type.
|
||||
func (t LayerType) String() (s string) {
|
||||
if 0 <= int(t) && int(t) < maxLayerType {
|
||||
s = ltMeta[int(t)].Name
|
||||
} else {
|
||||
s = ltMetaMap[t].Name
|
||||
}
|
||||
if s == "" {
|
||||
s = strconv.Itoa(int(t))
|
||||
}
|
||||
return
|
||||
}
|
||||
@ -0,0 +1,838 @@
|
||||
// Copyright 2012 Google, 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 gopacket
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"reflect"
|
||||
"runtime/debug"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// CaptureInfo provides standardized information about a packet captured off
|
||||
// the wire or read from a file.
|
||||
type CaptureInfo struct {
|
||||
// Timestamp is the time the packet was captured, if that is known.
|
||||
Timestamp time.Time
|
||||
// CaptureLength is the total number of bytes read off of the wire.
|
||||
CaptureLength int
|
||||
// Length is the size of the original packet. Should always be >=
|
||||
// CaptureLength.
|
||||
Length int
|
||||
// InterfaceIndex
|
||||
InterfaceIndex int
|
||||
}
|
||||
|
||||
// PacketMetadata contains metadata for a packet.
|
||||
type PacketMetadata struct {
|
||||
CaptureInfo
|
||||
// Truncated is true if packet decoding logic detects that there are fewer
|
||||
// bytes in the packet than are detailed in various headers (for example, if
|
||||
// the number of bytes in the IPv4 contents/payload is less than IPv4.Length).
|
||||
// This is also set automatically for packets captured off the wire if
|
||||
// CaptureInfo.CaptureLength < CaptureInfo.Length.
|
||||
Truncated bool
|
||||
}
|
||||
|
||||
// Packet is the primary object used by gopacket. Packets are created by a
|
||||
// Decoder's Decode call. A packet is made up of a set of Data, which
|
||||
// is broken into a number of Layers as it is decoded.
|
||||
type Packet interface {
|
||||
//// Functions for outputting the packet as a human-readable string:
|
||||
//// ------------------------------------------------------------------
|
||||
// String returns a human-readable string representation of the packet.
|
||||
// It uses LayerString on each layer to output the layer.
|
||||
String() string
|
||||
// Dump returns a verbose human-readable string representation of the packet,
|
||||
// including a hex dump of all layers. It uses LayerDump on each layer to
|
||||
// output the layer.
|
||||
Dump() string
|
||||
|
||||
//// Functions for accessing arbitrary packet layers:
|
||||
//// ------------------------------------------------------------------
|
||||
// Layers returns all layers in this packet, computing them as necessary
|
||||
Layers() []Layer
|
||||
// Layer returns the first layer in this packet of the given type, or nil
|
||||
Layer(LayerType) Layer
|
||||
// LayerClass returns the first layer in this packet of the given class,
|
||||
// or nil.
|
||||
LayerClass(LayerClass) Layer
|
||||
|
||||
//// Functions for accessing specific types of packet layers. These functions
|
||||
//// return the first layer of each type found within the packet.
|
||||
//// ------------------------------------------------------------------
|
||||
// LinkLayer returns the first link layer in the packet
|
||||
LinkLayer() LinkLayer
|
||||
// NetworkLayer returns the first network layer in the packet
|
||||
NetworkLayer() NetworkLayer
|
||||
// TransportLayer returns the first transport layer in the packet
|
||||
TransportLayer() TransportLayer
|
||||
// ApplicationLayer returns the first application layer in the packet
|
||||
ApplicationLayer() ApplicationLayer
|
||||
// ErrorLayer is particularly useful, since it returns nil if the packet
|
||||
// was fully decoded successfully, and non-nil if an error was encountered
|
||||
// in decoding and the packet was only partially decoded. Thus, its output
|
||||
// can be used to determine if the entire packet was able to be decoded.
|
||||
ErrorLayer() ErrorLayer
|
||||
|
||||
//// Functions for accessing data specific to the packet:
|
||||
//// ------------------------------------------------------------------
|
||||
// Data returns the set of bytes that make up this entire packet.
|
||||
Data() []byte
|
||||
// Metadata returns packet metadata associated with this packet.
|
||||
Metadata() *PacketMetadata
|
||||
}
|
||||
|
||||
// packet contains all the information we need to fulfill the Packet interface,
|
||||
// and its two "subclasses" (yes, no such thing in Go, bear with me),
|
||||
// eagerPacket and lazyPacket, provide eager and lazy decoding logic around the
|
||||
// various functions needed to access this information.
|
||||
type packet struct {
|
||||
// data contains the entire packet data for a packet
|
||||
data []byte
|
||||
// initialLayers is space for an initial set of layers already created inside
|
||||
// the packet.
|
||||
initialLayers [6]Layer
|
||||
// layers contains each layer we've already decoded
|
||||
layers []Layer
|
||||
// last is the last layer added to the packet
|
||||
last Layer
|
||||
// metadata is the PacketMetadata for this packet
|
||||
metadata PacketMetadata
|
||||
|
||||
decodeOptions DecodeOptions
|
||||
|
||||
// Pointers to the various important layers
|
||||
link LinkLayer
|
||||
network NetworkLayer
|
||||
transport TransportLayer
|
||||
application ApplicationLayer
|
||||
failure ErrorLayer
|
||||
}
|
||||
|
||||
func (p *packet) SetTruncated() {
|
||||
p.metadata.Truncated = true
|
||||
}
|
||||
|
||||
func (p *packet) SetLinkLayer(l LinkLayer) {
|
||||
if p.link == nil {
|
||||
p.link = l
|
||||
}
|
||||
}
|
||||
|
||||
func (p *packet) SetNetworkLayer(l NetworkLayer) {
|
||||
if p.network == nil {
|
||||
p.network = l
|
||||
}
|
||||
}
|
||||
|
||||
func (p *packet) SetTransportLayer(l TransportLayer) {
|
||||
if p.transport == nil {
|
||||
p.transport = l
|
||||
}
|
||||
}
|
||||
|
||||
func (p *packet) SetApplicationLayer(l ApplicationLayer) {
|
||||
if p.application == nil {
|
||||
p.application = l
|
||||
}
|
||||
}
|
||||
|
||||
func (p *packet) SetErrorLayer(l ErrorLayer) {
|
||||
if p.failure == nil {
|
||||
p.failure = l
|
||||
}
|
||||
}
|
||||
|
||||
func (p *packet) AddLayer(l Layer) {
|
||||
p.layers = append(p.layers, l)
|
||||
p.last = l
|
||||
}
|
||||
|
||||
func (p *packet) DumpPacketData() {
|
||||
fmt.Fprint(os.Stderr, p.packetDump())
|
||||
os.Stderr.Sync()
|
||||
}
|
||||
|
||||
func (p *packet) Metadata() *PacketMetadata {
|
||||
return &p.metadata
|
||||
}
|
||||
|
||||
func (p *packet) Data() []byte {
|
||||
return p.data
|
||||
}
|
||||
|
||||
func (p *packet) DecodeOptions() *DecodeOptions {
|
||||
return &p.decodeOptions
|
||||
}
|
||||
|
||||
func (p *packet) addFinalDecodeError(err error, stack []byte) {
|
||||
fail := &DecodeFailure{err: err, stack: stack}
|
||||
if p.last == nil {
|
||||
fail.data = p.data
|
||||
} else {
|
||||
fail.data = p.last.LayerPayload()
|
||||
}
|
||||
p.AddLayer(fail)
|
||||
p.SetErrorLayer(fail)
|
||||
}
|
||||
|
||||
func (p *packet) recoverDecodeError() {
|
||||
if !p.decodeOptions.SkipDecodeRecovery {
|
||||
if r := recover(); r != nil {
|
||||
p.addFinalDecodeError(fmt.Errorf("%v", r), debug.Stack())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// LayerString outputs an individual layer as a string. The layer is output
|
||||
// in a single line, with no trailing newline. This function is specifically
|
||||
// designed to do the right thing for most layers... it follows the following
|
||||
// rules:
|
||||
// * If the Layer has a String function, just output that.
|
||||
// * Otherwise, output all exported fields in the layer, recursing into
|
||||
// exported slices and structs.
|
||||
// NOTE: This is NOT THE SAME AS fmt's "%#v". %#v will output both exported
|
||||
// and unexported fields... many times packet layers contain unexported stuff
|
||||
// that would just mess up the output of the layer, see for example the
|
||||
// Payload layer and it's internal 'data' field, which contains a large byte
|
||||
// array that would really mess up formatting.
|
||||
func LayerString(l Layer) string {
|
||||
return fmt.Sprintf("%v\t%s", l.LayerType(), layerString(reflect.ValueOf(l), false, false))
|
||||
}
|
||||
|
||||
// Dumper dumps verbose information on a value. If a layer type implements
|
||||
// Dumper, then its LayerDump() string will include the results in its output.
|
||||
type Dumper interface {
|
||||
Dump() string
|
||||
}
|
||||
|
||||
// LayerDump outputs a very verbose string representation of a layer. Its
|
||||
// output is a concatenation of LayerString(l) and hex.Dump(l.LayerContents()).
|
||||
// It contains newlines and ends with a newline.
|
||||
func LayerDump(l Layer) string {
|
||||
var b bytes.Buffer
|
||||
b.WriteString(LayerString(l))
|
||||
b.WriteByte('\n')
|
||||
if d, ok := l.(Dumper); ok {
|
||||
dump := d.Dump()
|
||||
if dump != "" {
|
||||
b.WriteString(dump)
|
||||
if dump[len(dump)-1] != '\n' {
|
||||
b.WriteByte('\n')
|
||||
}
|
||||
}
|
||||
}
|
||||
b.WriteString(hex.Dump(l.LayerContents()))
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// layerString outputs, recursively, a layer in a "smart" way. See docs for
|
||||
// LayerString for more details.
|
||||
//
|
||||
// Params:
|
||||
// i - value to write out
|
||||
// anonymous: if we're currently recursing an anonymous member of a struct
|
||||
// writeSpace: if we've already written a value in a struct, and need to
|
||||
// write a space before writing more. This happens when we write various
|
||||
// anonymous values, and need to keep writing more.
|
||||
func layerString(v reflect.Value, anonymous bool, writeSpace bool) string {
|
||||
// Let String() functions take precedence.
|
||||
if v.CanInterface() {
|
||||
if s, ok := v.Interface().(fmt.Stringer); ok {
|
||||
return s.String()
|
||||
}
|
||||
}
|
||||
// Reflect, and spit out all the exported fields as key=value.
|
||||
switch v.Type().Kind() {
|
||||
case reflect.Interface, reflect.Ptr:
|
||||
if v.IsNil() {
|
||||
return "nil"
|
||||
}
|
||||
r := v.Elem()
|
||||
return layerString(r, anonymous, writeSpace)
|
||||
case reflect.Struct:
|
||||
var b bytes.Buffer
|
||||
typ := v.Type()
|
||||
if !anonymous {
|
||||
b.WriteByte('{')
|
||||
}
|
||||
for i := 0; i < v.NumField(); i++ {
|
||||
// Check if this is upper-case.
|
||||
ftype := typ.Field(i)
|
||||
f := v.Field(i)
|
||||
if ftype.Anonymous {
|
||||
anonStr := layerString(f, true, writeSpace)
|
||||
writeSpace = writeSpace || anonStr != ""
|
||||
b.WriteString(anonStr)
|
||||
} else if ftype.PkgPath == "" { // exported
|
||||
if writeSpace {
|
||||
b.WriteByte(' ')
|
||||
}
|
||||
writeSpace = true
|
||||
fmt.Fprintf(&b, "%s=%s", typ.Field(i).Name, layerString(f, false, writeSpace))
|
||||
}
|
||||
}
|
||||
if !anonymous {
|
||||
b.WriteByte('}')
|
||||
}
|
||||
return b.String()
|
||||
case reflect.Slice:
|
||||
var b bytes.Buffer
|
||||
b.WriteByte('[')
|
||||
if v.Len() > 4 {
|
||||
fmt.Fprintf(&b, "..%d..", v.Len())
|
||||
} else {
|
||||
for j := 0; j < v.Len(); j++ {
|
||||
if j != 0 {
|
||||
b.WriteString(", ")
|
||||
}
|
||||
b.WriteString(layerString(v.Index(j), false, false))
|
||||
}
|
||||
}
|
||||
b.WriteByte(']')
|
||||
return b.String()
|
||||
}
|
||||
return fmt.Sprintf("%v", v.Interface())
|
||||
}
|
||||
|
||||
const (
|
||||
longBytesLength = 128
|
||||
)
|
||||
|
||||
// LongBytesGoString returns a string representation of the byte slice shortened
|
||||
// using the format '<type>{<truncated slice> ... (<n> bytes)}' if it
|
||||
// exceeds a predetermined length. Can be used to avoid filling the display with
|
||||
// very long byte strings.
|
||||
func LongBytesGoString(buf []byte) string {
|
||||
if len(buf) < longBytesLength {
|
||||
return fmt.Sprintf("%#v", buf)
|
||||
}
|
||||
s := fmt.Sprintf("%#v", buf[:longBytesLength-1])
|
||||
s = strings.TrimSuffix(s, "}")
|
||||
return fmt.Sprintf("%s ... (%d bytes)}", s, len(buf))
|
||||
}
|
||||
|
||||
func baseLayerString(value reflect.Value) string {
|
||||
t := value.Type()
|
||||
content := value.Field(0)
|
||||
c := make([]byte, content.Len())
|
||||
for i := range c {
|
||||
c[i] = byte(content.Index(i).Uint())
|
||||
}
|
||||
payload := value.Field(1)
|
||||
p := make([]byte, payload.Len())
|
||||
for i := range p {
|
||||
p[i] = byte(payload.Index(i).Uint())
|
||||
}
|
||||
return fmt.Sprintf("%s{Contents:%s, Payload:%s}", t.String(),
|
||||
LongBytesGoString(c),
|
||||
LongBytesGoString(p))
|
||||
}
|
||||
|
||||
func layerGoString(i interface{}, b *bytes.Buffer) {
|
||||
if s, ok := i.(fmt.GoStringer); ok {
|
||||
b.WriteString(s.GoString())
|
||||
return
|
||||
}
|
||||
|
||||
var v reflect.Value
|
||||
var ok bool
|
||||
if v, ok = i.(reflect.Value); !ok {
|
||||
v = reflect.ValueOf(i)
|
||||
}
|
||||
switch v.Kind() {
|
||||
case reflect.Ptr, reflect.Interface:
|
||||
if v.Kind() == reflect.Ptr {
|
||||
b.WriteByte('&')
|
||||
}
|
||||
layerGoString(v.Elem().Interface(), b)
|
||||
case reflect.Struct:
|
||||
t := v.Type()
|
||||
b.WriteString(t.String())
|
||||
b.WriteByte('{')
|
||||
for i := 0; i < v.NumField(); i++ {
|
||||
if i > 0 {
|
||||
b.WriteString(", ")
|
||||
}
|
||||
if t.Field(i).Name == "BaseLayer" {
|
||||
fmt.Fprintf(b, "BaseLayer:%s", baseLayerString(v.Field(i)))
|
||||
} else if v.Field(i).Kind() == reflect.Struct {
|
||||
fmt.Fprintf(b, "%s:", t.Field(i).Name)
|
||||
layerGoString(v.Field(i), b)
|
||||
} else if v.Field(i).Kind() == reflect.Ptr {
|
||||
b.WriteByte('&')
|
||||
layerGoString(v.Field(i), b)
|
||||
} else {
|
||||
fmt.Fprintf(b, "%s:%#v", t.Field(i).Name, v.Field(i))
|
||||
}
|
||||
}
|
||||
b.WriteByte('}')
|
||||
default:
|
||||
fmt.Fprintf(b, "%#v", i)
|
||||
}
|
||||
}
|
||||
|
||||
// LayerGoString returns a representation of the layer in Go syntax,
|
||||
// taking care to shorten "very long" BaseLayer byte slices
|
||||
func LayerGoString(l Layer) string {
|
||||
b := new(bytes.Buffer)
|
||||
layerGoString(l, b)
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func (p *packet) packetString() string {
|
||||
var b bytes.Buffer
|
||||
fmt.Fprintf(&b, "PACKET: %d bytes", len(p.Data()))
|
||||
if p.metadata.Truncated {
|
||||
b.WriteString(", truncated")
|
||||
}
|
||||
if p.metadata.Length > 0 {
|
||||
fmt.Fprintf(&b, ", wire length %d cap length %d", p.metadata.Length, p.metadata.CaptureLength)
|
||||
}
|
||||
if !p.metadata.Timestamp.IsZero() {
|
||||
fmt.Fprintf(&b, " @ %v", p.metadata.Timestamp)
|
||||
}
|
||||
b.WriteByte('\n')
|
||||
for i, l := range p.layers {
|
||||
fmt.Fprintf(&b, "- Layer %d (%02d bytes) = %s\n", i+1, len(l.LayerContents()), LayerString(l))
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func (p *packet) packetDump() string {
|
||||
var b bytes.Buffer
|
||||
fmt.Fprintf(&b, "-- FULL PACKET DATA (%d bytes) ------------------------------------\n%s", len(p.data), hex.Dump(p.data))
|
||||
for i, l := range p.layers {
|
||||
fmt.Fprintf(&b, "--- Layer %d ---\n%s", i+1, LayerDump(l))
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// eagerPacket is a packet implementation that does eager decoding. Upon
|
||||
// initial construction, it decodes all the layers it can from packet data.
|
||||
// eagerPacket implements Packet and PacketBuilder.
|
||||
type eagerPacket struct {
|
||||
packet
|
||||
}
|
||||
|
||||
var errNilDecoder = errors.New("NextDecoder passed nil decoder, probably an unsupported decode type")
|
||||
|
||||
func (p *eagerPacket) NextDecoder(next Decoder) error {
|
||||
if next == nil {
|
||||
return errNilDecoder
|
||||
}
|
||||
if p.last == nil {
|
||||
return errors.New("NextDecoder called, but no layers added yet")
|
||||
}
|
||||
d := p.last.LayerPayload()
|
||||
if len(d) == 0 {
|
||||
return nil
|
||||
}
|
||||
// Since we're eager, immediately call the next decoder.
|
||||
return next.Decode(d, p)
|
||||
}
|
||||
func (p *eagerPacket) initialDecode(dec Decoder) {
|
||||
defer p.recoverDecodeError()
|
||||
err := dec.Decode(p.data, p)
|
||||
if err != nil {
|
||||
p.addFinalDecodeError(err, nil)
|
||||
}
|
||||
}
|
||||
func (p *eagerPacket) LinkLayer() LinkLayer {
|
||||
return p.link
|
||||
}
|
||||
func (p *eagerPacket) NetworkLayer() NetworkLayer {
|
||||
return p.network
|
||||
}
|
||||
func (p *eagerPacket) TransportLayer() TransportLayer {
|
||||
return p.transport
|
||||
}
|
||||
func (p *eagerPacket) ApplicationLayer() ApplicationLayer {
|
||||
return p.application
|
||||
}
|
||||
func (p *eagerPacket) ErrorLayer() ErrorLayer {
|
||||
return p.failure
|
||||
}
|
||||
func (p *eagerPacket) Layers() []Layer {
|
||||
return p.layers
|
||||
}
|
||||
func (p *eagerPacket) Layer(t LayerType) Layer {
|
||||
for _, l := range p.layers {
|
||||
if l.LayerType() == t {
|
||||
return l
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (p *eagerPacket) LayerClass(lc LayerClass) Layer {
|
||||
for _, l := range p.layers {
|
||||
if lc.Contains(l.LayerType()) {
|
||||
return l
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (p *eagerPacket) String() string { return p.packetString() }
|
||||
func (p *eagerPacket) Dump() string { return p.packetDump() }
|
||||
|
||||
// lazyPacket does lazy decoding on its packet data. On construction it does
|
||||
// no initial decoding. For each function call, it decodes only as many layers
|
||||
// as are necessary to compute the return value for that function.
|
||||
// lazyPacket implements Packet and PacketBuilder.
|
||||
type lazyPacket struct {
|
||||
packet
|
||||
next Decoder
|
||||
}
|
||||
|
||||
func (p *lazyPacket) NextDecoder(next Decoder) error {
|
||||
if next == nil {
|
||||
return errNilDecoder
|
||||
}
|
||||
p.next = next
|
||||
return nil
|
||||
}
|
||||
func (p *lazyPacket) decodeNextLayer() {
|
||||
if p.next == nil {
|
||||
return
|
||||
}
|
||||
d := p.data
|
||||
if p.last != nil {
|
||||
d = p.last.LayerPayload()
|
||||
}
|
||||
next := p.next
|
||||
p.next = nil
|
||||
// We've just set p.next to nil, so if we see we have no data, this should be
|
||||
// the final call we get to decodeNextLayer if we return here.
|
||||
if len(d) == 0 {
|
||||
return
|
||||
}
|
||||
defer p.recoverDecodeError()
|
||||
err := next.Decode(d, p)
|
||||
if err != nil {
|
||||
p.addFinalDecodeError(err, nil)
|
||||
}
|
||||
}
|
||||
func (p *lazyPacket) LinkLayer() LinkLayer {
|
||||
for p.link == nil && p.next != nil {
|
||||
p.decodeNextLayer()
|
||||
}
|
||||
return p.link
|
||||
}
|
||||
func (p *lazyPacket) NetworkLayer() NetworkLayer {
|
||||
for p.network == nil && p.next != nil {
|
||||
p.decodeNextLayer()
|
||||
}
|
||||
return p.network
|
||||
}
|
||||
func (p *lazyPacket) TransportLayer() TransportLayer {
|
||||
for p.transport == nil && p.next != nil {
|
||||
p.decodeNextLayer()
|
||||
}
|
||||
return p.transport
|
||||
}
|
||||
func (p *lazyPacket) ApplicationLayer() ApplicationLayer {
|
||||
for p.application == nil && p.next != nil {
|
||||
p.decodeNextLayer()
|
||||
}
|
||||
return p.application
|
||||
}
|
||||
func (p *lazyPacket) ErrorLayer() ErrorLayer {
|
||||
for p.failure == nil && p.next != nil {
|
||||
p.decodeNextLayer()
|
||||
}
|
||||
return p.failure
|
||||
}
|
||||
func (p *lazyPacket) Layers() []Layer {
|
||||
for p.next != nil {
|
||||
p.decodeNextLayer()
|
||||
}
|
||||
return p.layers
|
||||
}
|
||||
func (p *lazyPacket) Layer(t LayerType) Layer {
|
||||
for _, l := range p.layers {
|
||||
if l.LayerType() == t {
|
||||
return l
|
||||
}
|
||||
}
|
||||
numLayers := len(p.layers)
|
||||
for p.next != nil {
|
||||
p.decodeNextLayer()
|
||||
for _, l := range p.layers[numLayers:] {
|
||||
if l.LayerType() == t {
|
||||
return l
|
||||
}
|
||||
}
|
||||
numLayers = len(p.layers)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (p *lazyPacket) LayerClass(lc LayerClass) Layer {
|
||||
for _, l := range p.layers {
|
||||
if lc.Contains(l.LayerType()) {
|
||||
return l
|
||||
}
|
||||
}
|
||||
numLayers := len(p.layers)
|
||||
for p.next != nil {
|
||||
p.decodeNextLayer()
|
||||
for _, l := range p.layers[numLayers:] {
|
||||
if lc.Contains(l.LayerType()) {
|
||||
return l
|
||||
}
|
||||
}
|
||||
numLayers = len(p.layers)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (p *lazyPacket) String() string { p.Layers(); return p.packetString() }
|
||||
func (p *lazyPacket) Dump() string { p.Layers(); return p.packetDump() }
|
||||
|
||||
// DecodeOptions tells gopacket how to decode a packet.
|
||||
type DecodeOptions struct {
|
||||
// Lazy decoding decodes the minimum number of layers needed to return data
|
||||
// for a packet at each function call. Be careful using this with concurrent
|
||||
// packet processors, as each call to packet.* could mutate the packet, and
|
||||
// two concurrent function calls could interact poorly.
|
||||
Lazy bool
|
||||
// NoCopy decoding doesn't copy its input buffer into storage that's owned by
|
||||
// the packet. If you can guarantee that the bytes underlying the slice
|
||||
// passed into NewPacket aren't going to be modified, this can be faster. If
|
||||
// there's any chance that those bytes WILL be changed, this will invalidate
|
||||
// your packets.
|
||||
NoCopy bool
|
||||
// SkipDecodeRecovery skips over panic recovery during packet decoding.
|
||||
// Normally, when packets decode, if a panic occurs, that panic is captured
|
||||
// by a recover(), and a DecodeFailure layer is added to the packet detailing
|
||||
// the issue. If this flag is set, panics are instead allowed to continue up
|
||||
// the stack.
|
||||
SkipDecodeRecovery bool
|
||||
// DecodeStreamsAsDatagrams enables routing of application-level layers in the TCP
|
||||
// decoder. If true, we should try to decode layers after TCP in single packets.
|
||||
// This is disabled by default because the reassembly package drives the decoding
|
||||
// of TCP payload data after reassembly.
|
||||
DecodeStreamsAsDatagrams bool
|
||||
}
|
||||
|
||||
// Default decoding provides the safest (but slowest) method for decoding
|
||||
// packets. It eagerly processes all layers (so it's concurrency-safe) and it
|
||||
// copies its input buffer upon creation of the packet (so the packet remains
|
||||
// valid if the underlying slice is modified. Both of these take time,
|
||||
// though, so beware. If you can guarantee that the packet will only be used
|
||||
// by one goroutine at a time, set Lazy decoding. If you can guarantee that
|
||||
// the underlying slice won't change, set NoCopy decoding.
|
||||
var Default = DecodeOptions{}
|
||||
|
||||
// Lazy is a DecodeOptions with just Lazy set.
|
||||
var Lazy = DecodeOptions{Lazy: true}
|
||||
|
||||
// NoCopy is a DecodeOptions with just NoCopy set.
|
||||
var NoCopy = DecodeOptions{NoCopy: true}
|
||||
|
||||
// DecodeStreamsAsDatagrams is a DecodeOptions with just DecodeStreamsAsDatagrams set.
|
||||
var DecodeStreamsAsDatagrams = DecodeOptions{DecodeStreamsAsDatagrams: true}
|
||||
|
||||
// NewPacket creates a new Packet object from a set of bytes. The
|
||||
// firstLayerDecoder tells it how to interpret the first layer from the bytes,
|
||||
// future layers will be generated from that first layer automatically.
|
||||
func NewPacket(data []byte, firstLayerDecoder Decoder, options DecodeOptions) Packet {
|
||||
if !options.NoCopy {
|
||||
dataCopy := make([]byte, len(data))
|
||||
copy(dataCopy, data)
|
||||
data = dataCopy
|
||||
}
|
||||
if options.Lazy {
|
||||
p := &lazyPacket{
|
||||
packet: packet{data: data, decodeOptions: options},
|
||||
next: firstLayerDecoder,
|
||||
}
|
||||
p.layers = p.initialLayers[:0]
|
||||
// Crazy craziness:
|
||||
// If the following return statemet is REMOVED, and Lazy is FALSE, then
|
||||
// eager packet processing becomes 17% FASTER. No, there is no logical
|
||||
// explanation for this. However, it's such a hacky micro-optimization that
|
||||
// we really can't rely on it. It appears to have to do with the size the
|
||||
// compiler guesses for this function's stack space, since one symptom is
|
||||
// that with the return statement in place, we more than double calls to
|
||||
// runtime.morestack/runtime.lessstack. We'll hope the compiler gets better
|
||||
// over time and we get this optimization for free. Until then, we'll have
|
||||
// to live with slower packet processing.
|
||||
return p
|
||||
}
|
||||
p := &eagerPacket{
|
||||
packet: packet{data: data, decodeOptions: options},
|
||||
}
|
||||
p.layers = p.initialLayers[:0]
|
||||
p.initialDecode(firstLayerDecoder)
|
||||
return p
|
||||
}
|
||||
|
||||
// PacketDataSource is an interface for some source of packet data. Users may
|
||||
// create their own implementations, or use the existing implementations in
|
||||
// gopacket/pcap (libpcap, allows reading from live interfaces or from
|
||||
// pcap files) or gopacket/pfring (PF_RING, allows reading from live
|
||||
// interfaces).
|
||||
type PacketDataSource interface {
|
||||
// ReadPacketData returns the next packet available from this data source.
|
||||
// It returns:
|
||||
// data: The bytes of an individual packet.
|
||||
// ci: Metadata about the capture
|
||||
// err: An error encountered while reading packet data. If err != nil,
|
||||
// then data/ci will be ignored.
|
||||
ReadPacketData() (data []byte, ci CaptureInfo, err error)
|
||||
}
|
||||
|
||||
// ConcatFinitePacketDataSources returns a PacketDataSource that wraps a set
|
||||
// of internal PacketDataSources, each of which will stop with io.EOF after
|
||||
// reading a finite number of packets. The returned PacketDataSource will
|
||||
// return all packets from the first finite source, followed by all packets from
|
||||
// the second, etc. Once all finite sources have returned io.EOF, the returned
|
||||
// source will as well.
|
||||
func ConcatFinitePacketDataSources(pds ...PacketDataSource) PacketDataSource {
|
||||
c := concat(pds)
|
||||
return &c
|
||||
}
|
||||
|
||||
type concat []PacketDataSource
|
||||
|
||||
func (c *concat) ReadPacketData() (data []byte, ci CaptureInfo, err error) {
|
||||
for len(*c) > 0 {
|
||||
data, ci, err = (*c)[0].ReadPacketData()
|
||||
if err == io.EOF {
|
||||
*c = (*c)[1:]
|
||||
continue
|
||||
}
|
||||
return
|
||||
}
|
||||
return nil, CaptureInfo{}, io.EOF
|
||||
}
|
||||
|
||||
// ZeroCopyPacketDataSource is an interface to pull packet data from sources
|
||||
// that allow data to be returned without copying to a user-controlled buffer.
|
||||
// It's very similar to PacketDataSource, except that the caller must be more
|
||||
// careful in how the returned buffer is handled.
|
||||
type ZeroCopyPacketDataSource interface {
|
||||
// ZeroCopyReadPacketData returns the next packet available from this data source.
|
||||
// It returns:
|
||||
// data: The bytes of an individual packet. Unlike with
|
||||
// PacketDataSource's ReadPacketData, the slice returned here points
|
||||
// to a buffer owned by the data source. In particular, the bytes in
|
||||
// this buffer may be changed by future calls to
|
||||
// ZeroCopyReadPacketData. Do not use the returned buffer after
|
||||
// subsequent ZeroCopyReadPacketData calls.
|
||||
// ci: Metadata about the capture
|
||||
// err: An error encountered while reading packet data. If err != nil,
|
||||
// then data/ci will be ignored.
|
||||
ZeroCopyReadPacketData() (data []byte, ci CaptureInfo, err error)
|
||||
}
|
||||
|
||||
// PacketSource reads in packets from a PacketDataSource, decodes them, and
|
||||
// returns them.
|
||||
//
|
||||
// There are currently two different methods for reading packets in through
|
||||
// a PacketSource:
|
||||
//
|
||||
// Reading With Packets Function
|
||||
//
|
||||
// This method is the most convenient and easiest to code, but lacks
|
||||
// flexibility. Packets returns a 'chan Packet', then asynchronously writes
|
||||
// packets into that channel. Packets uses a blocking channel, and closes
|
||||
// it if an io.EOF is returned by the underlying PacketDataSource. All other
|
||||
// PacketDataSource errors are ignored and discarded.
|
||||
// for packet := range packetSource.Packets() {
|
||||
// ...
|
||||
// }
|
||||
//
|
||||
// Reading With NextPacket Function
|
||||
//
|
||||
// This method is the most flexible, and exposes errors that may be
|
||||
// encountered by the underlying PacketDataSource. It's also the fastest
|
||||
// in a tight loop, since it doesn't have the overhead of a channel
|
||||
// read/write. However, it requires the user to handle errors, most
|
||||
// importantly the io.EOF error in cases where packets are being read from
|
||||
// a file.
|
||||
// for {
|
||||
// packet, err := packetSource.NextPacket()
|
||||
// if err == io.EOF {
|
||||
// break
|
||||
// } else if err != nil {
|
||||
// log.Println("Error:", err)
|
||||
// continue
|
||||
// }
|
||||
// handlePacket(packet) // Do something with each packet.
|
||||
// }
|
||||
type PacketSource struct {
|
||||
source PacketDataSource
|
||||
decoder Decoder
|
||||
// DecodeOptions is the set of options to use for decoding each piece
|
||||
// of packet data. This can/should be changed by the user to reflect the
|
||||
// way packets should be decoded.
|
||||
DecodeOptions
|
||||
c chan Packet
|
||||
}
|
||||
|
||||
// NewPacketSource creates a packet data source.
|
||||
func NewPacketSource(source PacketDataSource, decoder Decoder) *PacketSource {
|
||||
return &PacketSource{
|
||||
source: source,
|
||||
decoder: decoder,
|
||||
}
|
||||
}
|
||||
|
||||
// NextPacket returns the next decoded packet from the PacketSource. On error,
|
||||
// it returns a nil packet and a non-nil error.
|
||||
func (p *PacketSource) NextPacket() (Packet, error) {
|
||||
data, ci, err := p.source.ReadPacketData()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
packet := NewPacket(data, p.decoder, p.DecodeOptions)
|
||||
m := packet.Metadata()
|
||||
m.CaptureInfo = ci
|
||||
m.Truncated = m.Truncated || ci.CaptureLength < ci.Length
|
||||
return packet, nil
|
||||
}
|
||||
|
||||
// packetsToChannel reads in all packets from the packet source and sends them
|
||||
// to the given channel. When it receives an error, it ignores it. When it
|
||||
// receives an io.EOF, it closes the channel.
|
||||
func (p *PacketSource) packetsToChannel() {
|
||||
defer close(p.c)
|
||||
for {
|
||||
packet, err := p.NextPacket()
|
||||
if err == io.EOF {
|
||||
return
|
||||
} else if err == nil {
|
||||
p.c <- packet
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Packets returns a channel of packets, allowing easy iterating over
|
||||
// packets. Packets will be asynchronously read in from the underlying
|
||||
// PacketDataSource and written to the returned channel. If the underlying
|
||||
// PacketDataSource returns an io.EOF error, the channel will be closed.
|
||||
// If any other error is encountered, it is ignored.
|
||||
//
|
||||
// for packet := range packetSource.Packets() {
|
||||
// handlePacket(packet) // Do something with each packet.
|
||||
// }
|
||||
//
|
||||
// If called more than once, returns the same channel.
|
||||
func (p *PacketSource) Packets() chan Packet {
|
||||
if p.c == nil {
|
||||
p.c = make(chan Packet, 1000)
|
||||
go p.packetsToChannel()
|
||||
}
|
||||
return p.c
|
||||
}
|
||||
@ -0,0 +1,198 @@
|
||||
// Copyright 2012 Google, 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 gopacket
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// DecodingLayer is an interface for packet layers that can decode themselves.
|
||||
//
|
||||
// The important part of DecodingLayer is that they decode themselves in-place.
|
||||
// Calling DecodeFromBytes on a DecodingLayer totally resets the entire layer to
|
||||
// the new state defined by the data passed in. A returned error leaves the
|
||||
// DecodingLayer in an unknown intermediate state, thus its fields should not be
|
||||
// trusted.
|
||||
//
|
||||
// Because the DecodingLayer is resetting its own fields, a call to
|
||||
// DecodeFromBytes should normally not require any memory allocation.
|
||||
type DecodingLayer interface {
|
||||
// DecodeFromBytes resets the internal state of this layer to the state
|
||||
// defined by the passed-in bytes. Slices in the DecodingLayer may
|
||||
// reference the passed-in data, so care should be taken to copy it
|
||||
// first should later modification of data be required before the
|
||||
// DecodingLayer is discarded.
|
||||
DecodeFromBytes(data []byte, df DecodeFeedback) error
|
||||
// CanDecode returns the set of LayerTypes this DecodingLayer can
|
||||
// decode. For Layers that are also DecodingLayers, this will most
|
||||
// often be that Layer's LayerType().
|
||||
CanDecode() LayerClass
|
||||
// NextLayerType returns the LayerType which should be used to decode
|
||||
// the LayerPayload.
|
||||
NextLayerType() LayerType
|
||||
// LayerPayload is the set of bytes remaining to decode after a call to
|
||||
// DecodeFromBytes.
|
||||
LayerPayload() []byte
|
||||
}
|
||||
|
||||
// DecodingLayerParser parses a given set of layer types. See DecodeLayers for
|
||||
// more information on how DecodingLayerParser should be used.
|
||||
type DecodingLayerParser struct {
|
||||
// DecodingLayerParserOptions is the set of options available to the
|
||||
// user to define the parser's behavior.
|
||||
DecodingLayerParserOptions
|
||||
first LayerType
|
||||
decoders map[LayerType]DecodingLayer
|
||||
df DecodeFeedback
|
||||
// Truncated is set when a decode layer detects that the packet has been
|
||||
// truncated.
|
||||
Truncated bool
|
||||
}
|
||||
|
||||
// AddDecodingLayer adds a decoding layer to the parser. This adds support for
|
||||
// the decoding layer's CanDecode layers to the parser... should they be
|
||||
// encountered, they'll be parsed.
|
||||
func (l *DecodingLayerParser) AddDecodingLayer(d DecodingLayer) {
|
||||
for _, typ := range d.CanDecode().LayerTypes() {
|
||||
l.decoders[typ] = d
|
||||
}
|
||||
}
|
||||
|
||||
// SetTruncated is used by DecodingLayers to set the Truncated boolean in the
|
||||
// DecodingLayerParser. Users should simply read Truncated after calling
|
||||
// DecodeLayers.
|
||||
func (l *DecodingLayerParser) SetTruncated() {
|
||||
l.Truncated = true
|
||||
}
|
||||
|
||||
// NewDecodingLayerParser creates a new DecodingLayerParser and adds in all
|
||||
// of the given DecodingLayers with AddDecodingLayer.
|
||||
//
|
||||
// Each call to DecodeLayers will attempt to decode the given bytes first by
|
||||
// treating them as a 'first'-type layer, then by using NextLayerType on
|
||||
// subsequently decoded layers to find the next relevant decoder. Should a
|
||||
// deoder not be available for the layer type returned by NextLayerType,
|
||||
// decoding will stop.
|
||||
func NewDecodingLayerParser(first LayerType, decoders ...DecodingLayer) *DecodingLayerParser {
|
||||
dlp := &DecodingLayerParser{
|
||||
decoders: make(map[LayerType]DecodingLayer),
|
||||
first: first,
|
||||
}
|
||||
dlp.df = dlp // Cast this once to the interface
|
||||
for _, d := range decoders {
|
||||
dlp.AddDecodingLayer(d)
|
||||
}
|
||||
return dlp
|
||||
}
|
||||
|
||||
// DecodeLayers decodes as many layers as possible from the given data. It
|
||||
// initially treats the data as layer type 'typ', then uses NextLayerType on
|
||||
// each subsequent decoded layer until it gets to a layer type it doesn't know
|
||||
// how to parse.
|
||||
//
|
||||
// For each layer successfully decoded, DecodeLayers appends the layer type to
|
||||
// the decoded slice. DecodeLayers truncates the 'decoded' slice initially, so
|
||||
// there's no need to empty it yourself.
|
||||
//
|
||||
// This decoding method is about an order of magnitude faster than packet
|
||||
// decoding, because it only decodes known layers that have already been
|
||||
// allocated. This means it doesn't need to allocate each layer it returns...
|
||||
// instead it overwrites the layers that already exist.
|
||||
//
|
||||
// Example usage:
|
||||
// func main() {
|
||||
// var eth layers.Ethernet
|
||||
// var ip4 layers.IPv4
|
||||
// var ip6 layers.IPv6
|
||||
// var tcp layers.TCP
|
||||
// var udp layers.UDP
|
||||
// var payload gopacket.Payload
|
||||
// parser := gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet, ð, &ip4, &ip6, &tcp, &udp, &payload)
|
||||
// var source gopacket.PacketDataSource = getMyDataSource()
|
||||
// decodedLayers := make([]gopacket.LayerType, 0, 10)
|
||||
// for {
|
||||
// data, _, err := source.ReadPacketData()
|
||||
// if err == nil {
|
||||
// fmt.Println("Error reading packet data: ", err)
|
||||
// continue
|
||||
// }
|
||||
// fmt.Println("Decoding packet")
|
||||
// err = parser.DecodeLayers(data, &decodedLayers)
|
||||
// for _, typ := range decodedLayers {
|
||||
// fmt.Println(" Successfully decoded layer type", typ)
|
||||
// switch typ {
|
||||
// case layers.LayerTypeEthernet:
|
||||
// fmt.Println(" Eth ", eth.SrcMAC, eth.DstMAC)
|
||||
// case layers.LayerTypeIPv4:
|
||||
// fmt.Println(" IP4 ", ip4.SrcIP, ip4.DstIP)
|
||||
// case layers.LayerTypeIPv6:
|
||||
// fmt.Println(" IP6 ", ip6.SrcIP, ip6.DstIP)
|
||||
// case layers.LayerTypeTCP:
|
||||
// fmt.Println(" TCP ", tcp.SrcPort, tcp.DstPort)
|
||||
// case layers.LayerTypeUDP:
|
||||
// fmt.Println(" UDP ", udp.SrcPort, udp.DstPort)
|
||||
// }
|
||||
// }
|
||||
// if decodedLayers.Truncated {
|
||||
// fmt.Println(" Packet has been truncated")
|
||||
// }
|
||||
// if err != nil {
|
||||
// fmt.Println(" Error encountered:", err)
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// If DecodeLayers is unable to decode the next layer type, it will return the
|
||||
// error UnsupportedLayerType.
|
||||
func (l *DecodingLayerParser) DecodeLayers(data []byte, decoded *[]LayerType) (err error) {
|
||||
l.Truncated = false
|
||||
if !l.IgnorePanic {
|
||||
defer panicToError(&err)
|
||||
}
|
||||
typ := l.first
|
||||
*decoded = (*decoded)[:0] // Truncated decoded layers.
|
||||
for len(data) > 0 {
|
||||
decoder, ok := l.decoders[typ]
|
||||
if !ok {
|
||||
return UnsupportedLayerType(typ)
|
||||
} else if err = decoder.DecodeFromBytes(data, l.df); err != nil {
|
||||
return err
|
||||
}
|
||||
*decoded = append(*decoded, typ)
|
||||
typ = decoder.NextLayerType()
|
||||
data = decoder.LayerPayload()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// UnsupportedLayerType is returned by DecodingLayerParser if DecodeLayers
|
||||
// encounters a layer type that the DecodingLayerParser has no decoder for.
|
||||
type UnsupportedLayerType LayerType
|
||||
|
||||
// Error implements the error interface, returning a string to say that the
|
||||
// given layer type is unsupported.
|
||||
func (e UnsupportedLayerType) Error() string {
|
||||
return fmt.Sprintf("No decoder for layer type %v", LayerType(e))
|
||||
}
|
||||
|
||||
func panicToError(e *error) {
|
||||
if r := recover(); r != nil {
|
||||
*e = fmt.Errorf("panic: %v", r)
|
||||
}
|
||||
}
|
||||
|
||||
// DecodingLayerParserOptions provides options to affect the behavior of a given
|
||||
// DecodingLayerParser.
|
||||
type DecodingLayerParserOptions struct {
|
||||
// IgnorePanic determines whether a DecodingLayerParser should stop
|
||||
// panics on its own (by returning them as an error from DecodeLayers)
|
||||
// or should allow them to raise up the stack. Handling errors does add
|
||||
// latency to the process of decoding layers, but is much safer for
|
||||
// callers. IgnorePanic defaults to false, thus if the caller does
|
||||
// nothing decode panics will be returned as errors.
|
||||
IgnorePanic bool
|
||||
}
|
||||
@ -0,0 +1,213 @@
|
||||
// Copyright 2012 Google, 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 gopacket
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// SerializableLayer allows its implementations to be written out as a set of bytes,
|
||||
// so those bytes may be sent on the wire or otherwise used by the caller.
|
||||
// SerializableLayer is implemented by certain Layer types, and can be encoded to
|
||||
// bytes using the LayerWriter object.
|
||||
type SerializableLayer interface {
|
||||
// SerializeTo writes this layer to a slice, growing that slice if necessary
|
||||
// to make it fit the layer's data.
|
||||
// Args:
|
||||
// b: SerializeBuffer to write this layer on to. When called, b.Bytes()
|
||||
// is the payload this layer should wrap, if any. Note that this
|
||||
// layer can either prepend itself (common), append itself
|
||||
// (uncommon), or both (sometimes padding or footers are required at
|
||||
// the end of packet data). It's also possible (though probably very
|
||||
// rarely needed) to overwrite any bytes in the current payload.
|
||||
// After this call, b.Bytes() should return the byte encoding of
|
||||
// this layer wrapping the original b.Bytes() payload.
|
||||
// opts: options to use while writing out data.
|
||||
// Returns:
|
||||
// error if a problem was encountered during encoding. If an error is
|
||||
// returned, the bytes in data should be considered invalidated, and
|
||||
// not used.
|
||||
//
|
||||
// SerializeTo calls SHOULD entirely ignore LayerContents and
|
||||
// LayerPayload. It just serializes based on struct fields, neither
|
||||
// modifying nor using contents/payload.
|
||||
SerializeTo(b SerializeBuffer, opts SerializeOptions) error
|
||||
}
|
||||
|
||||
// SerializeOptions provides options for behaviors that SerializableLayers may want to
|
||||
// implement.
|
||||
type SerializeOptions struct {
|
||||
// FixLengths determines whether, during serialization, layers should fix
|
||||
// the values for any length field that depends on the payload.
|
||||
FixLengths bool
|
||||
// ComputeChecksums determines whether, during serialization, layers
|
||||
// should recompute checksums based on their payloads.
|
||||
ComputeChecksums bool
|
||||
}
|
||||
|
||||
// SerializeBuffer is a helper used by gopacket for writing out packet layers.
|
||||
// SerializeBuffer starts off as an empty []byte. Subsequent calls to PrependBytes
|
||||
// return byte slices before the current Bytes(), AppendBytes returns byte
|
||||
// slices after.
|
||||
//
|
||||
// Byte slices returned by PrependBytes/AppendBytes are NOT zero'd out, so if
|
||||
// you want to make sure they're all zeros, set them as such.
|
||||
//
|
||||
// SerializeBuffer is specifically designed to handle packet writing, where unlike
|
||||
// with normal writes it's easier to start writing at the inner-most layer and
|
||||
// work out, meaning that we often need to prepend bytes. This runs counter to
|
||||
// typical writes to byte slices using append(), where we only write at the end
|
||||
// of the buffer.
|
||||
//
|
||||
// It can be reused via Clear. Note, however, that a Clear call will invalidate the
|
||||
// byte slices returned by any previous Bytes() call (the same buffer is
|
||||
// reused).
|
||||
//
|
||||
// 1) Reusing a write buffer is generally much faster than creating a new one,
|
||||
// and with the default implementation it avoids additional memory allocations.
|
||||
// 2) If a byte slice from a previous Bytes() call will continue to be used,
|
||||
// it's better to create a new SerializeBuffer.
|
||||
//
|
||||
// The Clear method is specifically designed to minimize memory allocations for
|
||||
// similar later workloads on the SerializeBuffer. IE: if you make a set of
|
||||
// Prepend/Append calls, then clear, then make the same calls with the same
|
||||
// sizes, the second round (and all future similar rounds) shouldn't allocate
|
||||
// any new memory.
|
||||
type SerializeBuffer interface {
|
||||
// Bytes returns the contiguous set of bytes collected so far by Prepend/Append
|
||||
// calls. The slice returned by Bytes will be modified by future Clear calls,
|
||||
// so if you're planning on clearing this SerializeBuffer, you may want to copy
|
||||
// Bytes somewhere safe first.
|
||||
Bytes() []byte
|
||||
// PrependBytes returns a set of bytes which prepends the current bytes in this
|
||||
// buffer. These bytes start in an indeterminate state, so they should be
|
||||
// overwritten by the caller. The caller must only call PrependBytes if they
|
||||
// know they're going to immediately overwrite all bytes returned.
|
||||
PrependBytes(num int) ([]byte, error)
|
||||
// AppendBytes returns a set of bytes which appends the current bytes in this
|
||||
// buffer. These bytes start in an indeterminate state, so they should be
|
||||
// overwritten by the caller. The caller must only call AppendBytes if they
|
||||
// know they're going to immediately overwrite all bytes returned.
|
||||
AppendBytes(num int) ([]byte, error)
|
||||
// Clear resets the SerializeBuffer to a new, empty buffer. After a call to clear,
|
||||
// the byte slice returned by any previous call to Bytes() for this buffer
|
||||
// should be considered invalidated.
|
||||
Clear() error
|
||||
}
|
||||
|
||||
type serializeBuffer struct {
|
||||
data []byte
|
||||
start int
|
||||
prepended, appended int
|
||||
}
|
||||
|
||||
// NewSerializeBuffer creates a new instance of the default implementation of
|
||||
// the SerializeBuffer interface.
|
||||
func NewSerializeBuffer() SerializeBuffer {
|
||||
return &serializeBuffer{}
|
||||
}
|
||||
|
||||
// NewSerializeBufferExpectedSize creates a new buffer for serialization, optimized for an
|
||||
// expected number of bytes prepended/appended. This tends to decrease the
|
||||
// number of memory allocations made by the buffer during writes.
|
||||
func NewSerializeBufferExpectedSize(expectedPrependLength, expectedAppendLength int) SerializeBuffer {
|
||||
return &serializeBuffer{
|
||||
data: make([]byte, expectedPrependLength, expectedPrependLength+expectedAppendLength),
|
||||
start: expectedPrependLength,
|
||||
prepended: expectedPrependLength,
|
||||
appended: expectedAppendLength,
|
||||
}
|
||||
}
|
||||
|
||||
func (w *serializeBuffer) Bytes() []byte {
|
||||
return w.data[w.start:]
|
||||
}
|
||||
|
||||
func (w *serializeBuffer) PrependBytes(num int) ([]byte, error) {
|
||||
if num < 0 {
|
||||
panic("num < 0")
|
||||
}
|
||||
if w.start < num {
|
||||
toPrepend := w.prepended
|
||||
if toPrepend < num {
|
||||
toPrepend = num
|
||||
}
|
||||
w.prepended += toPrepend
|
||||
length := cap(w.data) + toPrepend
|
||||
newData := make([]byte, length)
|
||||
newStart := w.start + toPrepend
|
||||
copy(newData[newStart:], w.data[w.start:])
|
||||
w.start = newStart
|
||||
w.data = newData[:toPrepend+len(w.data)]
|
||||
}
|
||||
w.start -= num
|
||||
return w.data[w.start : w.start+num], nil
|
||||
}
|
||||
|
||||
func (w *serializeBuffer) AppendBytes(num int) ([]byte, error) {
|
||||
if num < 0 {
|
||||
panic("num < 0")
|
||||
}
|
||||
initialLength := len(w.data)
|
||||
if cap(w.data)-initialLength < num {
|
||||
toAppend := w.appended
|
||||
if toAppend < num {
|
||||
toAppend = num
|
||||
}
|
||||
w.appended += toAppend
|
||||
newData := make([]byte, cap(w.data)+toAppend)
|
||||
copy(newData[w.start:], w.data[w.start:])
|
||||
w.data = newData[:initialLength]
|
||||
}
|
||||
// Grow the buffer. We know it'll be under capacity given above.
|
||||
w.data = w.data[:initialLength+num]
|
||||
return w.data[initialLength:], nil
|
||||
}
|
||||
|
||||
func (w *serializeBuffer) Clear() error {
|
||||
w.start = w.prepended
|
||||
w.data = w.data[:w.start]
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializeLayers clears the given write buffer, then writes all layers into it so
|
||||
// they correctly wrap each other. Note that by clearing the buffer, it
|
||||
// invalidates all slices previously returned by w.Bytes()
|
||||
//
|
||||
// Example:
|
||||
// buf := gopacket.NewSerializeBuffer()
|
||||
// opts := gopacket.SerializeOptions{}
|
||||
// gopacket.SerializeLayers(buf, opts, a, b, c)
|
||||
// firstPayload := buf.Bytes() // contains byte representation of a(b(c))
|
||||
// gopacket.SerializeLayers(buf, opts, d, e, f)
|
||||
// secondPayload := buf.Bytes() // contains byte representation of d(e(f)). firstPayload is now invalidated, since the SerializeLayers call Clears buf.
|
||||
func SerializeLayers(w SerializeBuffer, opts SerializeOptions, layers ...SerializableLayer) error {
|
||||
w.Clear()
|
||||
for i := len(layers) - 1; i >= 0; i-- {
|
||||
layer := layers[i]
|
||||
err := layer.SerializeTo(w, opts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SerializePacket is a convenience function that calls SerializeLayers
|
||||
// on packet's Layers().
|
||||
// It returns an error if one of the packet layers is not a SerializebleLayer.
|
||||
func SerializePacket(buf SerializeBuffer, opts SerializeOptions, packet Packet) error {
|
||||
sls := []SerializableLayer{}
|
||||
for _, layer := range packet.Layers() {
|
||||
sl, ok := layer.(SerializableLayer)
|
||||
if !ok {
|
||||
return fmt.Errorf("layer %s is not serializable", layer.LayerType().String())
|
||||
}
|
||||
sls = append(sls, sl)
|
||||
}
|
||||
return SerializeLayers(buf, opts, sls...)
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// Antialias is a representation of Cairo's cairo_antialias_t.
|
||||
type Antialias int
|
||||
|
||||
const (
|
||||
ANTIALIAS_DEFAULT Antialias = C.CAIRO_ANTIALIAS_DEFAULT
|
||||
ANTIALIAS_NONE Antialias = C.CAIRO_ANTIALIAS_NONE
|
||||
ANTIALIAS_GRAY Antialias = C.CAIRO_ANTIALIAS_GRAY
|
||||
ANTIALIAS_SUBPIXEL Antialias = C.CAIRO_ANTIALIAS_SUBPIXEL
|
||||
// ANTIALIAS_FAST Antialias = C.CAIRO_ANTIALIAS_FAST (since 1.12)
|
||||
// ANTIALIAS_GOOD Antialias = C.CAIRO_ANTIALIAS_GOOD (since 1.12)
|
||||
// ANTIALIAS_BEST Antialias = C.CAIRO_ANTIALIAS_BEST (since 1.12)
|
||||
)
|
||||
|
||||
func marshalAntialias(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return Antialias(c), nil
|
||||
}
|
||||
@ -1,65 +0,0 @@
|
||||
// Copyright (c) 2013-2014 Conformal Systems <info@conformal.com>
|
||||
//
|
||||
// This file originated from: http://opensource.conformal.com/
|
||||
//
|
||||
// Permission to use, copy, modify, and distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice appear in all copies.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
// Package cairo implements Go bindings for Cairo. Supports version 1.10 and
|
||||
// later.
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
|
||||
"github.com/gotk3/gotk3/glib"
|
||||
)
|
||||
|
||||
func init() {
|
||||
tm := []glib.TypeMarshaler{
|
||||
// Enums
|
||||
{glib.Type(C.cairo_gobject_antialias_get_type()), marshalAntialias},
|
||||
{glib.Type(C.cairo_gobject_content_get_type()), marshalContent},
|
||||
{glib.Type(C.cairo_gobject_fill_rule_get_type()), marshalFillRule},
|
||||
{glib.Type(C.cairo_gobject_line_cap_get_type()), marshalLineCap},
|
||||
{glib.Type(C.cairo_gobject_line_join_get_type()), marshalLineJoin},
|
||||
{glib.Type(C.cairo_gobject_operator_get_type()), marshalOperator},
|
||||
{glib.Type(C.cairo_gobject_status_get_type()), marshalStatus},
|
||||
{glib.Type(C.cairo_gobject_surface_type_get_type()), marshalSurfaceType},
|
||||
|
||||
// Boxed
|
||||
{glib.Type(C.cairo_gobject_context_get_type()), marshalContext},
|
||||
{glib.Type(C.cairo_gobject_surface_get_type()), marshalSurface},
|
||||
}
|
||||
glib.RegisterGValueMarshalers(tm)
|
||||
}
|
||||
|
||||
// Constants
|
||||
|
||||
// Content is a representation of Cairo's cairo_content_t.
|
||||
type Content int
|
||||
|
||||
const (
|
||||
CONTENT_COLOR Content = C.CAIRO_CONTENT_COLOR
|
||||
CONTENT_ALPHA Content = C.CAIRO_CONTENT_ALPHA
|
||||
CONTENT_COLOR_ALPHA Content = C.CAIRO_CONTENT_COLOR_ALPHA
|
||||
)
|
||||
|
||||
func marshalContent(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return Content(c), nil
|
||||
}
|
||||
@ -1,401 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"runtime"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// Context is a representation of Cairo's cairo_t.
|
||||
type Context struct {
|
||||
context *C.cairo_t
|
||||
}
|
||||
|
||||
// native returns a pointer to the underlying cairo_t.
|
||||
func (v *Context) native() *C.cairo_t {
|
||||
if v == nil {
|
||||
return nil
|
||||
}
|
||||
return v.context
|
||||
}
|
||||
|
||||
func (v *Context) GetCContext() *C.cairo_t {
|
||||
return v.native()
|
||||
}
|
||||
|
||||
// Native returns a pointer to the underlying cairo_t.
|
||||
func (v *Context) Native() uintptr {
|
||||
return uintptr(unsafe.Pointer(v.native()))
|
||||
}
|
||||
|
||||
func marshalContext(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p)))
|
||||
context := (*C.cairo_t)(unsafe.Pointer(c))
|
||||
return wrapContext(context), nil
|
||||
}
|
||||
|
||||
func wrapContext(context *C.cairo_t) *Context {
|
||||
return &Context{context}
|
||||
}
|
||||
|
||||
// Create is a wrapper around cairo_create().
|
||||
func Create(target *Surface) *Context {
|
||||
c := C.cairo_create(target.native())
|
||||
ctx := wrapContext(c)
|
||||
runtime.SetFinalizer(ctx, (*Context).destroy)
|
||||
return ctx
|
||||
}
|
||||
|
||||
// reference is a wrapper around cairo_reference().
|
||||
func (v *Context) reference() {
|
||||
v.context = C.cairo_reference(v.native())
|
||||
}
|
||||
|
||||
// destroy is a wrapper around cairo_destroy().
|
||||
func (v *Context) destroy() {
|
||||
C.cairo_destroy(v.native())
|
||||
}
|
||||
|
||||
// Status is a wrapper around cairo_status().
|
||||
func (v *Context) Status() Status {
|
||||
c := C.cairo_status(v.native())
|
||||
return Status(c)
|
||||
}
|
||||
|
||||
// Save is a wrapper around cairo_save().
|
||||
func (v *Context) Save() {
|
||||
C.cairo_save(v.native())
|
||||
}
|
||||
|
||||
// Restore is a wrapper around cairo_restore().
|
||||
func (v *Context) Restore() {
|
||||
C.cairo_restore(v.native())
|
||||
}
|
||||
|
||||
// GetTarget is a wrapper around cairo_get_target().
|
||||
func (v *Context) GetTarget() *Surface {
|
||||
c := C.cairo_get_target(v.native())
|
||||
s := wrapSurface(c)
|
||||
s.reference()
|
||||
runtime.SetFinalizer(s, (*Surface).destroy)
|
||||
return s
|
||||
}
|
||||
|
||||
// PushGroup is a wrapper around cairo_push_group().
|
||||
func (v *Context) PushGroup() {
|
||||
C.cairo_push_group(v.native())
|
||||
}
|
||||
|
||||
// PushGroupWithContent is a wrapper around cairo_push_group_with_content().
|
||||
func (v *Context) PushGroupWithContent(content Content) {
|
||||
C.cairo_push_group_with_content(v.native(), C.cairo_content_t(content))
|
||||
}
|
||||
|
||||
// TODO(jrick) PopGroup (depends on Pattern)
|
||||
|
||||
// PopGroupToSource is a wrapper around cairo_pop_group_to_source().
|
||||
func (v *Context) PopGroupToSource() {
|
||||
C.cairo_pop_group_to_source(v.native())
|
||||
}
|
||||
|
||||
// GetGroupTarget is a wrapper around cairo_get_group_target().
|
||||
func (v *Context) GetGroupTarget() *Surface {
|
||||
c := C.cairo_get_group_target(v.native())
|
||||
s := wrapSurface(c)
|
||||
s.reference()
|
||||
runtime.SetFinalizer(s, (*Surface).destroy)
|
||||
return s
|
||||
}
|
||||
|
||||
// SetSourceRGB is a wrapper around cairo_set_source_rgb().
|
||||
func (v *Context) SetSourceRGB(red, green, blue float64) {
|
||||
C.cairo_set_source_rgb(v.native(), C.double(red), C.double(green),
|
||||
C.double(blue))
|
||||
}
|
||||
|
||||
// SetSourceRGBA is a wrapper around cairo_set_source_rgba().
|
||||
func (v *Context) SetSourceRGBA(red, green, blue, alpha float64) {
|
||||
C.cairo_set_source_rgba(v.native(), C.double(red), C.double(green),
|
||||
C.double(blue), C.double(alpha))
|
||||
}
|
||||
|
||||
// TODO(jrick) SetSource (depends on Pattern)
|
||||
|
||||
// SetSourceSurface is a wrapper around cairo_set_source_surface().
|
||||
func (v *Context) SetSourceSurface(surface *Surface, x, y float64) {
|
||||
C.cairo_set_source_surface(v.native(), surface.native(), C.double(x),
|
||||
C.double(y))
|
||||
}
|
||||
|
||||
// TODO(jrick) GetSource (depends on Pattern)
|
||||
|
||||
// SetAntialias is a wrapper around cairo_set_antialias().
|
||||
func (v *Context) SetAntialias(antialias Antialias) {
|
||||
C.cairo_set_antialias(v.native(), C.cairo_antialias_t(antialias))
|
||||
}
|
||||
|
||||
// GetAntialias is a wrapper around cairo_get_antialias().
|
||||
func (v *Context) GetAntialias() Antialias {
|
||||
c := C.cairo_get_antialias(v.native())
|
||||
return Antialias(c)
|
||||
}
|
||||
|
||||
// SetDash is a wrapper around cairo_set_dash().
|
||||
func (v *Context) SetDash(dashes []float64, offset float64) {
|
||||
header := (*reflect.SliceHeader)(unsafe.Pointer(&dashes))
|
||||
cdashes := (*C.double)(unsafe.Pointer(header.Data))
|
||||
C.cairo_set_dash(v.native(), cdashes, C.int(header.Len),
|
||||
C.double(offset))
|
||||
}
|
||||
|
||||
// GetDashCount is a wrapper around cairo_get_dash_count().
|
||||
func (v *Context) GetDashCount() int {
|
||||
c := C.cairo_get_dash_count(v.native())
|
||||
return int(c)
|
||||
}
|
||||
|
||||
// GetDash is a wrapper around cairo_get_dash().
|
||||
func (v *Context) GetDash() (dashes []float64, offset float64) {
|
||||
dashCount := v.GetDashCount()
|
||||
cdashes := (*C.double)(C.calloc(8, C.size_t(dashCount)))
|
||||
var coffset C.double
|
||||
C.cairo_get_dash(v.native(), cdashes, &coffset)
|
||||
header := (*reflect.SliceHeader)((unsafe.Pointer(&dashes)))
|
||||
header.Data = uintptr(unsafe.Pointer(cdashes))
|
||||
header.Len = dashCount
|
||||
header.Cap = dashCount
|
||||
return dashes, float64(coffset)
|
||||
}
|
||||
|
||||
// SetFillRule is a wrapper around cairo_set_fill_rule().
|
||||
func (v *Context) SetFillRule(fillRule FillRule) {
|
||||
C.cairo_set_fill_rule(v.native(), C.cairo_fill_rule_t(fillRule))
|
||||
}
|
||||
|
||||
// GetFillRule is a wrapper around cairo_get_fill_rule().
|
||||
func (v *Context) GetFillRule() FillRule {
|
||||
c := C.cairo_get_fill_rule(v.native())
|
||||
return FillRule(c)
|
||||
}
|
||||
|
||||
// SetLineCap is a wrapper around cairo_set_line_cap().
|
||||
func (v *Context) SetLineCap(lineCap LineCap) {
|
||||
C.cairo_set_line_cap(v.native(), C.cairo_line_cap_t(lineCap))
|
||||
}
|
||||
|
||||
// GetLineCap is a wrapper around cairo_get_line_cap().
|
||||
func (v *Context) GetLineCap() LineCap {
|
||||
c := C.cairo_get_line_cap(v.native())
|
||||
return LineCap(c)
|
||||
}
|
||||
|
||||
// SetLineJoin is a wrapper around cairo_set_line_join().
|
||||
func (v *Context) SetLineJoin(lineJoin LineJoin) {
|
||||
C.cairo_set_line_join(v.native(), C.cairo_line_join_t(lineJoin))
|
||||
}
|
||||
|
||||
// GetLineJoin is a wrapper around cairo_get_line_join().
|
||||
func (v *Context) GetLineJoin() LineJoin {
|
||||
c := C.cairo_get_line_join(v.native())
|
||||
return LineJoin(c)
|
||||
}
|
||||
|
||||
// SetLineWidth is a wrapper around cairo_set_line_width().
|
||||
func (v *Context) SetLineWidth(width float64) {
|
||||
C.cairo_set_line_width(v.native(), C.double(width))
|
||||
}
|
||||
|
||||
// GetLineWidth is a wrapper cairo_get_line_width().
|
||||
func (v *Context) GetLineWidth() float64 {
|
||||
c := C.cairo_get_line_width(v.native())
|
||||
return float64(c)
|
||||
}
|
||||
|
||||
// SetMiterLimit is a wrapper around cairo_set_miter_limit().
|
||||
func (v *Context) SetMiterLimit(limit float64) {
|
||||
C.cairo_set_miter_limit(v.native(), C.double(limit))
|
||||
}
|
||||
|
||||
// GetMiterLimit is a wrapper around cairo_get_miter_limit().
|
||||
func (v *Context) GetMiterLimit() float64 {
|
||||
c := C.cairo_get_miter_limit(v.native())
|
||||
return float64(c)
|
||||
}
|
||||
|
||||
// SetOperator is a wrapper around cairo_set_operator().
|
||||
func (v *Context) SetOperator(op Operator) {
|
||||
C.cairo_set_operator(v.native(), C.cairo_operator_t(op))
|
||||
}
|
||||
|
||||
// GetOperator is a wrapper around cairo_get_operator().
|
||||
func (v *Context) GetOperator() Operator {
|
||||
c := C.cairo_get_operator(v.native())
|
||||
return Operator(c)
|
||||
}
|
||||
|
||||
// SetTolerance is a wrapper around cairo_set_tolerance().
|
||||
func (v *Context) SetTolerance(tolerance float64) {
|
||||
C.cairo_set_tolerance(v.native(), C.double(tolerance))
|
||||
}
|
||||
|
||||
// GetTolerance is a wrapper around cairo_get_tolerance().
|
||||
func (v *Context) GetTolerance() float64 {
|
||||
c := C.cairo_get_tolerance(v.native())
|
||||
return float64(c)
|
||||
}
|
||||
|
||||
// Clip is a wrapper around cairo_clip().
|
||||
func (v *Context) Clip() {
|
||||
C.cairo_clip(v.native())
|
||||
}
|
||||
|
||||
// ClipPreserve is a wrapper around cairo_clip_preserve().
|
||||
func (v *Context) ClipPreserve() {
|
||||
C.cairo_clip_preserve(v.native())
|
||||
}
|
||||
|
||||
// ClipExtents is a wrapper around cairo_clip_extents().
|
||||
func (v *Context) ClipExtents() (x1, y1, x2, y2 float64) {
|
||||
var cx1, cy1, cx2, cy2 C.double
|
||||
C.cairo_clip_extents(v.native(), &cx1, &cy1, &cx2, &cy2)
|
||||
return float64(cx1), float64(cy1), float64(cx2), float64(cy2)
|
||||
}
|
||||
|
||||
// InClip is a wrapper around cairo_in_clip().
|
||||
func (v *Context) InClip(x, y float64) bool {
|
||||
c := C.cairo_in_clip(v.native(), C.double(x), C.double(y))
|
||||
return gobool(c)
|
||||
}
|
||||
|
||||
// ResetClip is a wrapper around cairo_reset_clip().
|
||||
func (v *Context) ResetClip() {
|
||||
C.cairo_reset_clip(v.native())
|
||||
}
|
||||
|
||||
// Rectangle is a wrapper around cairo_rectangle().
|
||||
func (v *Context) Rectangle(x, y, w, h float64) {
|
||||
C.cairo_rectangle(v.native(), C.double(x), C.double(y), C.double(w), C.double(h))
|
||||
}
|
||||
|
||||
// Arc is a wrapper around cairo_arc().
|
||||
func (v *Context) Arc(xc, yc, radius, angle1, angle2 float64) {
|
||||
C.cairo_arc(v.native(), C.double(xc), C.double(yc), C.double(radius), C.double(angle1), C.double(angle2))
|
||||
}
|
||||
|
||||
// ArcNegative is a wrapper around cairo_arc_negative().
|
||||
func (v *Context) ArcNegative(xc, yc, radius, angle1, angle2 float64) {
|
||||
C.cairo_arc_negative(v.native(), C.double(xc), C.double(yc), C.double(radius), C.double(angle1), C.double(angle2))
|
||||
}
|
||||
|
||||
// LineTo is a wrapper around cairo_line_to().
|
||||
func (v *Context) LineTo(x, y float64) {
|
||||
C.cairo_line_to(v.native(), C.double(x), C.double(y))
|
||||
}
|
||||
|
||||
// CurveTo is a wrapper around cairo_curve_to().
|
||||
func (v *Context) CurveTo(x1, y1, x2, y2, x3, y3 float64) {
|
||||
C.cairo_curve_to(v.native(), C.double(x1), C.double(y1), C.double(x2), C.double(y2), C.double(x3), C.double(y3))
|
||||
}
|
||||
|
||||
// MoveTo is a wrapper around cairo_move_to().
|
||||
func (v *Context) MoveTo(x, y float64) {
|
||||
C.cairo_move_to(v.native(), C.double(x), C.double(y))
|
||||
}
|
||||
|
||||
// TODO(jrick) CopyRectangleList (depends on RectangleList)
|
||||
|
||||
// Fill is a wrapper around cairo_fill().
|
||||
func (v *Context) Fill() {
|
||||
C.cairo_fill(v.native())
|
||||
}
|
||||
|
||||
// ClosePath is a wrapper around cairo_close_path().
|
||||
func (v *Context) ClosePath() {
|
||||
C.cairo_close_path(v.native())
|
||||
}
|
||||
|
||||
// NewPath is a wrapper around cairo_new_path().
|
||||
func (v *Context) NewPath() {
|
||||
C.cairo_new_path(v.native())
|
||||
}
|
||||
|
||||
// GetCurrentPoint is a wrapper around cairo_get_current_point().
|
||||
func (v *Context) GetCurrentPoint() (x, y float64) {
|
||||
C.cairo_get_current_point(v.native(), (*C.double)(&x), (*C.double)(&y))
|
||||
return
|
||||
}
|
||||
|
||||
// FillPreserve is a wrapper around cairo_fill_preserve().
|
||||
func (v *Context) FillPreserve() {
|
||||
C.cairo_fill_preserve(v.native())
|
||||
}
|
||||
|
||||
// FillExtents is a wrapper around cairo_fill_extents().
|
||||
func (v *Context) FillExtents() (x1, y1, x2, y2 float64) {
|
||||
var cx1, cy1, cx2, cy2 C.double
|
||||
C.cairo_fill_extents(v.native(), &cx1, &cy1, &cx2, &cy2)
|
||||
return float64(cx1), float64(cy1), float64(cx2), float64(cy2)
|
||||
}
|
||||
|
||||
// InFill is a wrapper around cairo_in_fill().
|
||||
func (v *Context) InFill(x, y float64) bool {
|
||||
c := C.cairo_in_fill(v.native(), C.double(x), C.double(y))
|
||||
return gobool(c)
|
||||
}
|
||||
|
||||
// TODO(jrick) Mask (depends on Pattern)
|
||||
|
||||
// MaskSurface is a wrapper around cairo_mask_surface().
|
||||
func (v *Context) MaskSurface(surface *Surface, surfaceX, surfaceY float64) {
|
||||
C.cairo_mask_surface(v.native(), surface.native(), C.double(surfaceX),
|
||||
C.double(surfaceY))
|
||||
}
|
||||
|
||||
// Paint is a wrapper around cairo_paint().
|
||||
func (v *Context) Paint() {
|
||||
C.cairo_paint(v.native())
|
||||
}
|
||||
|
||||
// PaintWithAlpha is a wrapper around cairo_paint_with_alpha().
|
||||
func (v *Context) PaintWithAlpha(alpha float64) {
|
||||
C.cairo_paint_with_alpha(v.native(), C.double(alpha))
|
||||
}
|
||||
|
||||
// Stroke is a wrapper around cairo_stroke().
|
||||
func (v *Context) Stroke() {
|
||||
C.cairo_stroke(v.native())
|
||||
}
|
||||
|
||||
// StrokePreserve is a wrapper around cairo_stroke_preserve().
|
||||
func (v *Context) StrokePreserve() {
|
||||
C.cairo_stroke_preserve(v.native())
|
||||
}
|
||||
|
||||
// StrokeExtents is a wrapper around cairo_stroke_extents().
|
||||
func (v *Context) StrokeExtents() (x1, y1, x2, y2 float64) {
|
||||
var cx1, cy1, cx2, cy2 C.double
|
||||
C.cairo_stroke_extents(v.native(), &cx1, &cy1, &cx2, &cy2)
|
||||
return float64(cx1), float64(cy1), float64(cx2), float64(cy2)
|
||||
}
|
||||
|
||||
// InStroke is a wrapper around cairo_in_stroke().
|
||||
func (v *Context) InStroke(x, y float64) bool {
|
||||
c := C.cairo_in_stroke(v.native(), C.double(x), C.double(y))
|
||||
return gobool(c)
|
||||
}
|
||||
|
||||
// CopyPage is a wrapper around cairo_copy_page().
|
||||
func (v *Context) CopyPage() {
|
||||
C.cairo_copy_page(v.native())
|
||||
}
|
||||
|
||||
// ShowPage is a wrapper around cairo_show_page().
|
||||
func (v *Context) ShowPage() {
|
||||
C.cairo_show_page(v.native())
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
package cairo
|
||||
|
||||
type ErrorStatus Status
|
||||
|
||||
func (e ErrorStatus) Error() string {
|
||||
return StatusToString(Status(e))
|
||||
}
|
||||
@ -1,23 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// FillRule is a representation of Cairo's cairo_fill_rule_t.
|
||||
type FillRule int
|
||||
|
||||
const (
|
||||
FILL_RULE_WINDING FillRule = C.CAIRO_FILL_RULE_WINDING
|
||||
FILL_RULE_EVEN_ODD FillRule = C.CAIRO_FILL_RULE_EVEN_ODD
|
||||
)
|
||||
|
||||
func marshalFillRule(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return FillRule(c), nil
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// Format is a representation of Cairo's cairo_format_t.
|
||||
type Format int
|
||||
|
||||
const (
|
||||
FORMAT_INVALID Format = C.CAIRO_FORMAT_INVALID
|
||||
FORMAT_ARGB32 Format = C.CAIRO_FORMAT_ARGB32
|
||||
FORMAT_RGB24 Format = C.CAIRO_FORMAT_RGB24
|
||||
FORMAT_A8 Format = C.CAIRO_FORMAT_A8
|
||||
FORMAT_A1 Format = C.CAIRO_FORMAT_A1
|
||||
FORMAT_RGB16_565 Format = C.CAIRO_FORMAT_RGB16_565
|
||||
FORMAT_RGB30 Format = C.CAIRO_FORMAT_RGB30
|
||||
)
|
||||
|
||||
func marshalFormat(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return Format(c), nil
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// LineCap is a representation of Cairo's cairo_line_cap_t.
|
||||
type LineCap int
|
||||
|
||||
const (
|
||||
LINE_CAP_BUTT LineCap = C.CAIRO_LINE_CAP_BUTT
|
||||
LINE_CAP_ROUND LineCap = C.CAIRO_LINE_CAP_ROUND
|
||||
LINE_CAP_SQUARE LineCap = C.CAIRO_LINE_CAP_SQUARE
|
||||
)
|
||||
|
||||
func marshalLineCap(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return LineCap(c), nil
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// LineJoin is a representation of Cairo's cairo_line_join_t.
|
||||
type LineJoin int
|
||||
|
||||
const (
|
||||
LINE_JOIN_MITER LineJoin = C.CAIRO_LINE_JOIN_MITER
|
||||
LINE_JOIN_ROUND LineJoin = C.CAIRO_LINE_JOIN_ROUND
|
||||
LINE_JOIN_BEVEL LineJoin = C.CAIRO_LINE_JOIN_BEVEL
|
||||
)
|
||||
|
||||
func marshalLineJoin(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return LineJoin(c), nil
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// MimeType is a representation of Cairo's CAIRO_MIME_TYPE_*
|
||||
// preprocessor constants.
|
||||
type MimeType string
|
||||
|
||||
const (
|
||||
MIME_TYPE_JP2 MimeType = "image/jp2"
|
||||
MIME_TYPE_JPEG MimeType = "image/jpeg"
|
||||
MIME_TYPE_PNG MimeType = "image/png"
|
||||
MIME_TYPE_URI MimeType = "image/x-uri"
|
||||
MIME_TYPE_UNIQUE_ID MimeType = "application/x-cairo.uuid"
|
||||
)
|
||||
@ -1,50 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// Operator is a representation of Cairo's cairo_operator_t.
|
||||
type Operator int
|
||||
|
||||
const (
|
||||
OPERATOR_CLEAR Operator = C.CAIRO_OPERATOR_CLEAR
|
||||
OPERATOR_SOURCE Operator = C.CAIRO_OPERATOR_SOURCE
|
||||
OPERATOR_OVER Operator = C.CAIRO_OPERATOR_OVER
|
||||
OPERATOR_IN Operator = C.CAIRO_OPERATOR_IN
|
||||
OPERATOR_OUT Operator = C.CAIRO_OPERATOR_OUT
|
||||
OPERATOR_ATOP Operator = C.CAIRO_OPERATOR_ATOP
|
||||
OPERATOR_DEST Operator = C.CAIRO_OPERATOR_DEST
|
||||
OPERATOR_DEST_OVER Operator = C.CAIRO_OPERATOR_DEST_OVER
|
||||
OPERATOR_DEST_IN Operator = C.CAIRO_OPERATOR_DEST_IN
|
||||
OPERATOR_DEST_OUT Operator = C.CAIRO_OPERATOR_DEST_OUT
|
||||
OPERATOR_DEST_ATOP Operator = C.CAIRO_OPERATOR_DEST_ATOP
|
||||
OPERATOR_XOR Operator = C.CAIRO_OPERATOR_XOR
|
||||
OPERATOR_ADD Operator = C.CAIRO_OPERATOR_ADD
|
||||
OPERATOR_SATURATE Operator = C.CAIRO_OPERATOR_SATURATE
|
||||
OPERATOR_MULTIPLY Operator = C.CAIRO_OPERATOR_MULTIPLY
|
||||
OPERATOR_SCREEN Operator = C.CAIRO_OPERATOR_SCREEN
|
||||
OPERATOR_OVERLAY Operator = C.CAIRO_OPERATOR_OVERLAY
|
||||
OPERATOR_DARKEN Operator = C.CAIRO_OPERATOR_DARKEN
|
||||
OPERATOR_LIGHTEN Operator = C.CAIRO_OPERATOR_LIGHTEN
|
||||
OPERATOR_COLOR_DODGE Operator = C.CAIRO_OPERATOR_COLOR_DODGE
|
||||
OPERATOR_COLOR_BURN Operator = C.CAIRO_OPERATOR_COLOR_BURN
|
||||
OPERATOR_HARD_LIGHT Operator = C.CAIRO_OPERATOR_HARD_LIGHT
|
||||
OPERATOR_SOFT_LIGHT Operator = C.CAIRO_OPERATOR_SOFT_LIGHT
|
||||
OPERATOR_DIFFERENCE Operator = C.CAIRO_OPERATOR_DIFFERENCE
|
||||
OPERATOR_EXCLUSION Operator = C.CAIRO_OPERATOR_EXCLUSION
|
||||
OPERATOR_HSL_HUE Operator = C.CAIRO_OPERATOR_HSL_HUE
|
||||
OPERATOR_HSL_SATURATION Operator = C.CAIRO_OPERATOR_HSL_SATURATION
|
||||
OPERATOR_HSL_COLOR Operator = C.CAIRO_OPERATOR_HSL_COLOR
|
||||
OPERATOR_HSL_LUMINOSITY Operator = C.CAIRO_OPERATOR_HSL_LUMINOSITY
|
||||
)
|
||||
|
||||
func marshalOperator(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return Operator(c), nil
|
||||
}
|
||||
@ -1,109 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// Status is a representation of Cairo's cairo_status_t.
|
||||
type Status int
|
||||
|
||||
const (
|
||||
STATUS_SUCCESS Status = C.CAIRO_STATUS_SUCCESS
|
||||
STATUS_NO_MEMORY Status = C.CAIRO_STATUS_NO_MEMORY
|
||||
STATUS_INVALID_RESTORE Status = C.CAIRO_STATUS_INVALID_RESTORE
|
||||
STATUS_INVALID_POP_GROUP Status = C.CAIRO_STATUS_INVALID_POP_GROUP
|
||||
STATUS_NO_CURRENT_POINT Status = C.CAIRO_STATUS_NO_CURRENT_POINT
|
||||
STATUS_INVALID_MATRIX Status = C.CAIRO_STATUS_INVALID_MATRIX
|
||||
STATUS_INVALID_STATUS Status = C.CAIRO_STATUS_INVALID_STATUS
|
||||
STATUS_NULL_POINTER Status = C.CAIRO_STATUS_NULL_POINTER
|
||||
STATUS_INVALID_STRING Status = C.CAIRO_STATUS_INVALID_STRING
|
||||
STATUS_INVALID_PATH_DATA Status = C.CAIRO_STATUS_INVALID_PATH_DATA
|
||||
STATUS_READ_ERROR Status = C.CAIRO_STATUS_READ_ERROR
|
||||
STATUS_WRITE_ERROR Status = C.CAIRO_STATUS_WRITE_ERROR
|
||||
STATUS_SURFACE_FINISHED Status = C.CAIRO_STATUS_SURFACE_FINISHED
|
||||
STATUS_SURFACE_TYPE_MISMATCH Status = C.CAIRO_STATUS_SURFACE_TYPE_MISMATCH
|
||||
STATUS_PATTERN_TYPE_MISMATCH Status = C.CAIRO_STATUS_PATTERN_TYPE_MISMATCH
|
||||
STATUS_INVALID_CONTENT Status = C.CAIRO_STATUS_INVALID_CONTENT
|
||||
STATUS_INVALID_FORMAT Status = C.CAIRO_STATUS_INVALID_FORMAT
|
||||
STATUS_INVALID_VISUAL Status = C.CAIRO_STATUS_INVALID_VISUAL
|
||||
STATUS_FILE_NOT_FOUND Status = C.CAIRO_STATUS_FILE_NOT_FOUND
|
||||
STATUS_INVALID_DASH Status = C.CAIRO_STATUS_INVALID_DASH
|
||||
STATUS_INVALID_DSC_COMMENT Status = C.CAIRO_STATUS_INVALID_DSC_COMMENT
|
||||
STATUS_INVALID_INDEX Status = C.CAIRO_STATUS_INVALID_INDEX
|
||||
STATUS_CLIP_NOT_REPRESENTABLE Status = C.CAIRO_STATUS_CLIP_NOT_REPRESENTABLE
|
||||
STATUS_TEMP_FILE_ERROR Status = C.CAIRO_STATUS_TEMP_FILE_ERROR
|
||||
STATUS_INVALID_STRIDE Status = C.CAIRO_STATUS_INVALID_STRIDE
|
||||
STATUS_FONT_TYPE_MISMATCH Status = C.CAIRO_STATUS_FONT_TYPE_MISMATCH
|
||||
STATUS_USER_FONT_IMMUTABLE Status = C.CAIRO_STATUS_USER_FONT_IMMUTABLE
|
||||
STATUS_USER_FONT_ERROR Status = C.CAIRO_STATUS_USER_FONT_ERROR
|
||||
STATUS_NEGATIVE_COUNT Status = C.CAIRO_STATUS_NEGATIVE_COUNT
|
||||
STATUS_INVALID_CLUSTERS Status = C.CAIRO_STATUS_INVALID_CLUSTERS
|
||||
STATUS_INVALID_SLANT Status = C.CAIRO_STATUS_INVALID_SLANT
|
||||
STATUS_INVALID_WEIGHT Status = C.CAIRO_STATUS_INVALID_WEIGHT
|
||||
STATUS_INVALID_SIZE Status = C.CAIRO_STATUS_INVALID_SIZE
|
||||
STATUS_USER_FONT_NOT_IMPLEMENTED Status = C.CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED
|
||||
STATUS_DEVICE_TYPE_MISMATCH Status = C.CAIRO_STATUS_DEVICE_TYPE_MISMATCH
|
||||
STATUS_DEVICE_ERROR Status = C.CAIRO_STATUS_DEVICE_ERROR
|
||||
// STATUS_INVALID_MESH_CONSTRUCTION Status = C.CAIRO_STATUS_INVALID_MESH_CONSTRUCTION (since 1.12)
|
||||
// STATUS_DEVICE_FINISHED Status = C.CAIRO_STATUS_DEVICE_FINISHED (since 1.12)
|
||||
)
|
||||
|
||||
var key_Status = map[Status]string{
|
||||
|
||||
STATUS_SUCCESS: "CAIRO_STATUS_SUCCESS",
|
||||
STATUS_NO_MEMORY: "CAIRO_STATUS_NO_MEMORY",
|
||||
STATUS_INVALID_RESTORE: "CAIRO_STATUS_INVALID_RESTORE",
|
||||
STATUS_INVALID_POP_GROUP: "CAIRO_STATUS_INVALID_POP_GROUP",
|
||||
STATUS_NO_CURRENT_POINT: "CAIRO_STATUS_NO_CURRENT_POINT",
|
||||
STATUS_INVALID_MATRIX: "CAIRO_STATUS_INVALID_MATRIX",
|
||||
STATUS_INVALID_STATUS: "CAIRO_STATUS_INVALID_STATUS",
|
||||
STATUS_NULL_POINTER: "CAIRO_STATUS_NULL_POINTER",
|
||||
STATUS_INVALID_STRING: "CAIRO_STATUS_INVALID_STRING",
|
||||
STATUS_INVALID_PATH_DATA: "CAIRO_STATUS_INVALID_PATH_DATA",
|
||||
STATUS_READ_ERROR: "CAIRO_STATUS_READ_ERROR",
|
||||
STATUS_WRITE_ERROR: "CAIRO_STATUS_WRITE_ERROR",
|
||||
STATUS_SURFACE_FINISHED: "CAIRO_STATUS_SURFACE_FINISHED",
|
||||
STATUS_SURFACE_TYPE_MISMATCH: "CAIRO_STATUS_SURFACE_TYPE_MISMATCH",
|
||||
STATUS_PATTERN_TYPE_MISMATCH: "CAIRO_STATUS_PATTERN_TYPE_MISMATCH",
|
||||
STATUS_INVALID_CONTENT: "CAIRO_STATUS_INVALID_CONTENT",
|
||||
STATUS_INVALID_FORMAT: "CAIRO_STATUS_INVALID_FORMAT",
|
||||
STATUS_INVALID_VISUAL: "CAIRO_STATUS_INVALID_VISUAL",
|
||||
STATUS_FILE_NOT_FOUND: "CAIRO_STATUS_FILE_NOT_FOUND",
|
||||
STATUS_INVALID_DASH: "CAIRO_STATUS_INVALID_DASH",
|
||||
STATUS_INVALID_DSC_COMMENT: "CAIRO_STATUS_INVALID_DSC_COMMENT",
|
||||
STATUS_INVALID_INDEX: "CAIRO_STATUS_INVALID_INDEX",
|
||||
STATUS_CLIP_NOT_REPRESENTABLE: "CAIRO_STATUS_CLIP_NOT_REPRESENTABLE",
|
||||
STATUS_TEMP_FILE_ERROR: "CAIRO_STATUS_TEMP_FILE_ERROR",
|
||||
STATUS_INVALID_STRIDE: "CAIRO_STATUS_INVALID_STRIDE",
|
||||
STATUS_FONT_TYPE_MISMATCH: "CAIRO_STATUS_FONT_TYPE_MISMATCH",
|
||||
STATUS_USER_FONT_IMMUTABLE: "CAIRO_STATUS_USER_FONT_IMMUTABLE",
|
||||
STATUS_USER_FONT_ERROR: "CAIRO_STATUS_USER_FONT_ERROR",
|
||||
STATUS_NEGATIVE_COUNT: "CAIRO_STATUS_NEGATIVE_COUNT",
|
||||
STATUS_INVALID_CLUSTERS: "CAIRO_STATUS_INVALID_CLUSTERS",
|
||||
STATUS_INVALID_SLANT: "CAIRO_STATUS_INVALID_SLANT",
|
||||
STATUS_INVALID_WEIGHT: "CAIRO_STATUS_INVALID_WEIGHT",
|
||||
STATUS_INVALID_SIZE: "CAIRO_STATUS_INVALID_SIZE",
|
||||
STATUS_USER_FONT_NOT_IMPLEMENTED: "CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED",
|
||||
STATUS_DEVICE_TYPE_MISMATCH: "CAIRO_STATUS_DEVICE_TYPE_MISMATCH",
|
||||
STATUS_DEVICE_ERROR: "CAIRO_STATUS_DEVICE_ERROR",
|
||||
}
|
||||
|
||||
func StatusToString(status Status) string {
|
||||
|
||||
s, ok := key_Status[status]
|
||||
if !ok {
|
||||
s = "CAIRO_STATUS_UNDEFINED"
|
||||
}
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
func marshalStatus(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return Status(c), nil
|
||||
}
|
||||
@ -1,215 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
|
||||
import (
|
||||
"runtime"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// TODO(jrick) SetUserData (depends on UserDataKey and DestroyFunc)
|
||||
|
||||
// TODO(jrick) GetUserData (depends on UserDataKey)
|
||||
|
||||
/*
|
||||
* cairo_surface_t
|
||||
*/
|
||||
|
||||
// Surface is a representation of Cairo's cairo_surface_t.
|
||||
type Surface struct {
|
||||
surface *C.cairo_surface_t
|
||||
}
|
||||
|
||||
func NewSurfaceFromPNG(fileName string) (*Surface, error) {
|
||||
|
||||
cstr := C.CString(fileName)
|
||||
defer C.free(unsafe.Pointer(cstr))
|
||||
|
||||
surfaceNative := C.cairo_image_surface_create_from_png(cstr)
|
||||
|
||||
status := Status(C.cairo_surface_status(surfaceNative))
|
||||
if status != STATUS_SUCCESS {
|
||||
return nil, ErrorStatus(status)
|
||||
}
|
||||
|
||||
return &Surface{surfaceNative}, nil
|
||||
}
|
||||
|
||||
// CreateImageSurface is a wrapper around cairo_image_surface_create().
|
||||
func CreateImageSurface(format Format, width, height int) *Surface {
|
||||
c := C.cairo_image_surface_create(C.cairo_format_t(format),
|
||||
C.int(width), C.int(height))
|
||||
s := wrapSurface(c)
|
||||
runtime.SetFinalizer(s, (*Surface).destroy)
|
||||
return s
|
||||
}
|
||||
|
||||
// native returns a pointer to the underlying cairo_surface_t.
|
||||
func (v *Surface) native() *C.cairo_surface_t {
|
||||
if v == nil {
|
||||
return nil
|
||||
}
|
||||
return v.surface
|
||||
}
|
||||
|
||||
// Native returns a pointer to the underlying cairo_surface_t.
|
||||
func (v *Surface) Native() uintptr {
|
||||
return uintptr(unsafe.Pointer(v.native()))
|
||||
}
|
||||
|
||||
func marshalSurface(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_boxed((*C.GValue)(unsafe.Pointer(p)))
|
||||
surface := (*C.cairo_surface_t)(unsafe.Pointer(c))
|
||||
return wrapSurface(surface), nil
|
||||
}
|
||||
|
||||
func wrapSurface(surface *C.cairo_surface_t) *Surface {
|
||||
return &Surface{surface}
|
||||
}
|
||||
|
||||
// NewSurface creates a gotk3 cairo Surface from a pointer to a
|
||||
// C cairo_surface_t. This is primarily designed for use with other
|
||||
// gotk3 packages and should be avoided by applications.
|
||||
func NewSurface(s uintptr, needsRef bool) *Surface {
|
||||
ptr := (*C.cairo_surface_t)(unsafe.Pointer(s))
|
||||
surface := wrapSurface(ptr)
|
||||
if needsRef {
|
||||
surface.reference()
|
||||
}
|
||||
runtime.SetFinalizer(surface, (*Surface).destroy)
|
||||
return surface
|
||||
}
|
||||
|
||||
// CreateSimilar is a wrapper around cairo_surface_create_similar().
|
||||
func (v *Surface) CreateSimilar(content Content, width, height int) *Surface {
|
||||
c := C.cairo_surface_create_similar(v.native(),
|
||||
C.cairo_content_t(content), C.int(width), C.int(height))
|
||||
s := wrapSurface(c)
|
||||
runtime.SetFinalizer(s, (*Surface).destroy)
|
||||
return s
|
||||
}
|
||||
|
||||
// TODO cairo_surface_create_similar_image (since 1.12)
|
||||
|
||||
// CreateForRectangle is a wrapper around cairo_surface_create_for_rectangle().
|
||||
func (v *Surface) CreateForRectangle(x, y, width, height float64) *Surface {
|
||||
c := C.cairo_surface_create_for_rectangle(v.native(), C.double(x),
|
||||
C.double(y), C.double(width), C.double(height))
|
||||
s := wrapSurface(c)
|
||||
runtime.SetFinalizer(s, (*Surface).destroy)
|
||||
return s
|
||||
}
|
||||
|
||||
// reference is a wrapper around cairo_surface_reference().
|
||||
func (v *Surface) reference() {
|
||||
v.surface = C.cairo_surface_reference(v.native())
|
||||
}
|
||||
|
||||
// destroy is a wrapper around cairo_surface_destroy().
|
||||
func (v *Surface) destroy() {
|
||||
C.cairo_surface_destroy(v.native())
|
||||
}
|
||||
|
||||
// Status is a wrapper around cairo_surface_status().
|
||||
func (v *Surface) Status() Status {
|
||||
c := C.cairo_surface_status(v.native())
|
||||
return Status(c)
|
||||
}
|
||||
|
||||
// Flush is a wrapper around cairo_surface_flush().
|
||||
func (v *Surface) Flush() {
|
||||
C.cairo_surface_flush(v.native())
|
||||
}
|
||||
|
||||
// TODO(jrick) GetDevice (requires Device bindings)
|
||||
|
||||
// TODO(jrick) GetFontOptions (require FontOptions bindings)
|
||||
|
||||
// TODO(jrick) GetContent (requires Content bindings)
|
||||
|
||||
// MarkDirty is a wrapper around cairo_surface_mark_dirty().
|
||||
func (v *Surface) MarkDirty() {
|
||||
C.cairo_surface_mark_dirty(v.native())
|
||||
}
|
||||
|
||||
// MarkDirtyRectangle is a wrapper around cairo_surface_mark_dirty_rectangle().
|
||||
func (v *Surface) MarkDirtyRectangle(x, y, width, height int) {
|
||||
C.cairo_surface_mark_dirty_rectangle(v.native(), C.int(x), C.int(y),
|
||||
C.int(width), C.int(height))
|
||||
}
|
||||
|
||||
// SetDeviceOffset is a wrapper around cairo_surface_set_device_offset().
|
||||
func (v *Surface) SetDeviceOffset(x, y float64) {
|
||||
C.cairo_surface_set_device_offset(v.native(), C.double(x), C.double(y))
|
||||
}
|
||||
|
||||
// GetDeviceOffset is a wrapper around cairo_surface_get_device_offset().
|
||||
func (v *Surface) GetDeviceOffset() (x, y float64) {
|
||||
var xOffset, yOffset C.double
|
||||
C.cairo_surface_get_device_offset(v.native(), &xOffset, &yOffset)
|
||||
return float64(xOffset), float64(yOffset)
|
||||
}
|
||||
|
||||
// SetFallbackResolution is a wrapper around
|
||||
// cairo_surface_set_fallback_resolution().
|
||||
func (v *Surface) SetFallbackResolution(xPPI, yPPI float64) {
|
||||
C.cairo_surface_set_fallback_resolution(v.native(), C.double(xPPI),
|
||||
C.double(yPPI))
|
||||
}
|
||||
|
||||
// GetFallbackResolution is a wrapper around
|
||||
// cairo_surface_get_fallback_resolution().
|
||||
func (v *Surface) GetFallbackResolution() (xPPI, yPPI float64) {
|
||||
var x, y C.double
|
||||
C.cairo_surface_get_fallback_resolution(v.native(), &x, &y)
|
||||
return float64(x), float64(y)
|
||||
}
|
||||
|
||||
// GetType is a wrapper around cairo_surface_get_type().
|
||||
func (v *Surface) GetType() SurfaceType {
|
||||
c := C.cairo_surface_get_type(v.native())
|
||||
return SurfaceType(c)
|
||||
}
|
||||
|
||||
// TODO(jrick) SetUserData (depends on UserDataKey and DestroyFunc)
|
||||
|
||||
// TODO(jrick) GetUserData (depends on UserDataKey)
|
||||
|
||||
// CopyPage is a wrapper around cairo_surface_copy_page().
|
||||
func (v *Surface) CopyPage() {
|
||||
C.cairo_surface_copy_page(v.native())
|
||||
}
|
||||
|
||||
// ShowPage is a wrapper around cairo_surface_show_page().
|
||||
func (v *Surface) ShowPage() {
|
||||
C.cairo_surface_show_page(v.native())
|
||||
}
|
||||
|
||||
// HasShowTextGlyphs is a wrapper around cairo_surface_has_show_text_glyphs().
|
||||
func (v *Surface) HasShowTextGlyphs() bool {
|
||||
c := C.cairo_surface_has_show_text_glyphs(v.native())
|
||||
return gobool(c)
|
||||
}
|
||||
|
||||
// TODO(jrick) SetMimeData (depends on DestroyFunc)
|
||||
|
||||
// GetMimeData is a wrapper around cairo_surface_get_mime_data(). The
|
||||
// returned mimetype data is returned as a Go byte slice.
|
||||
func (v *Surface) GetMimeData(mimeType MimeType) []byte {
|
||||
cstr := C.CString(string(mimeType))
|
||||
defer C.free(unsafe.Pointer(cstr))
|
||||
var data *C.uchar
|
||||
var length C.ulong
|
||||
C.cairo_surface_get_mime_data(v.native(), cstr, &data, &length)
|
||||
return C.GoBytes(unsafe.Pointer(data), C.int(length))
|
||||
}
|
||||
|
||||
// TODO(jrick) SupportsMimeType (since 1.12)
|
||||
|
||||
// TODO(jrick) MapToImage (since 1.12)
|
||||
|
||||
// TODO(jrick) UnmapImage (since 1.12)
|
||||
@ -1,46 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// SurfaceType is a representation of Cairo's cairo_surface_type_t.
|
||||
type SurfaceType int
|
||||
|
||||
const (
|
||||
SURFACE_TYPE_IMAGE SurfaceType = C.CAIRO_SURFACE_TYPE_IMAGE
|
||||
SURFACE_TYPE_PDF SurfaceType = C.CAIRO_SURFACE_TYPE_PDF
|
||||
SURFACE_TYPE_PS SurfaceType = C.CAIRO_SURFACE_TYPE_PS
|
||||
SURFACE_TYPE_XLIB SurfaceType = C.CAIRO_SURFACE_TYPE_XLIB
|
||||
SURFACE_TYPE_XCB SurfaceType = C.CAIRO_SURFACE_TYPE_XCB
|
||||
SURFACE_TYPE_GLITZ SurfaceType = C.CAIRO_SURFACE_TYPE_GLITZ
|
||||
SURFACE_TYPE_QUARTZ SurfaceType = C.CAIRO_SURFACE_TYPE_QUARTZ
|
||||
SURFACE_TYPE_WIN32 SurfaceType = C.CAIRO_SURFACE_TYPE_WIN32
|
||||
SURFACE_TYPE_BEOS SurfaceType = C.CAIRO_SURFACE_TYPE_BEOS
|
||||
SURFACE_TYPE_DIRECTFB SurfaceType = C.CAIRO_SURFACE_TYPE_DIRECTFB
|
||||
SURFACE_TYPE_SVG SurfaceType = C.CAIRO_SURFACE_TYPE_SVG
|
||||
SURFACE_TYPE_OS2 SurfaceType = C.CAIRO_SURFACE_TYPE_OS2
|
||||
SURFACE_TYPE_WIN32_PRINTING SurfaceType = C.CAIRO_SURFACE_TYPE_WIN32_PRINTING
|
||||
SURFACE_TYPE_QUARTZ_IMAGE SurfaceType = C.CAIRO_SURFACE_TYPE_QUARTZ_IMAGE
|
||||
SURFACE_TYPE_SCRIPT SurfaceType = C.CAIRO_SURFACE_TYPE_SCRIPT
|
||||
SURFACE_TYPE_QT SurfaceType = C.CAIRO_SURFACE_TYPE_QT
|
||||
SURFACE_TYPE_RECORDING SurfaceType = C.CAIRO_SURFACE_TYPE_RECORDING
|
||||
SURFACE_TYPE_VG SurfaceType = C.CAIRO_SURFACE_TYPE_VG
|
||||
SURFACE_TYPE_GL SurfaceType = C.CAIRO_SURFACE_TYPE_GL
|
||||
SURFACE_TYPE_DRM SurfaceType = C.CAIRO_SURFACE_TYPE_DRM
|
||||
SURFACE_TYPE_TEE SurfaceType = C.CAIRO_SURFACE_TYPE_TEE
|
||||
SURFACE_TYPE_XML SurfaceType = C.CAIRO_SURFACE_TYPE_XML
|
||||
SURFACE_TYPE_SKIA SurfaceType = C.CAIRO_SURFACE_TYPE_SKIA
|
||||
SURFACE_TYPE_SUBSURFACE SurfaceType = C.CAIRO_SURFACE_TYPE_SUBSURFACE
|
||||
// SURFACE_TYPE_COGL SurfaceType = C.CAIRO_SURFACE_TYPE_COGL (since 1.12)
|
||||
)
|
||||
|
||||
func marshalSurfaceType(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
|
||||
return SurfaceType(c), nil
|
||||
}
|
||||
@ -1,127 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
|
||||
import (
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// FontSlant is a representation of Cairo's cairo_font_slant_t
|
||||
type FontSlant int
|
||||
|
||||
const (
|
||||
FONT_SLANT_NORMAL FontSlant = C.CAIRO_FONT_SLANT_NORMAL
|
||||
FONT_SLANT_ITALIC FontSlant = C.CAIRO_FONT_SLANT_ITALIC
|
||||
FONT_SLANT_OBLIQUE FontSlant = C.CAIRO_FONT_SLANT_OBLIQUE
|
||||
)
|
||||
|
||||
// FontWeight is a representation of Cairo's cairo_font_weight_t
|
||||
type FontWeight int
|
||||
|
||||
const (
|
||||
FONT_WEIGHT_NORMAL FontWeight = C.CAIRO_FONT_WEIGHT_NORMAL
|
||||
FONT_WEIGHT_BOLD FontWeight = C.CAIRO_FONT_WEIGHT_BOLD
|
||||
)
|
||||
|
||||
func (v *Context) SelectFontFace(family string, slant FontSlant, weight FontWeight) {
|
||||
cstr := C.CString(family)
|
||||
defer C.free(unsafe.Pointer(cstr))
|
||||
C.cairo_select_font_face(v.native(), (*C.char)(cstr), C.cairo_font_slant_t(slant), C.cairo_font_weight_t(weight))
|
||||
}
|
||||
|
||||
func (v *Context) SetFontSize(size float64) {
|
||||
C.cairo_set_font_size(v.native(), C.double(size))
|
||||
}
|
||||
|
||||
// TODO: cairo_set_font_matrix
|
||||
|
||||
// TODO: cairo_get_font_matrix
|
||||
|
||||
// TODO: cairo_set_font_options
|
||||
|
||||
// TODO: cairo_get_font_options
|
||||
|
||||
// TODO: cairo_set_font_face
|
||||
|
||||
// TODO: cairo_get_font_face
|
||||
|
||||
// TODO: cairo_set_scaled_font
|
||||
|
||||
// TODO: cairo_get_scaled_font
|
||||
|
||||
func (v *Context) ShowText(utf8 string) {
|
||||
cstr := C.CString(utf8)
|
||||
defer C.free(unsafe.Pointer(cstr))
|
||||
C.cairo_show_text(v.native(), (*C.char)(cstr))
|
||||
}
|
||||
|
||||
// TODO: cairo_show_glyphs
|
||||
|
||||
// TODO: cairo_show_text_glyphs
|
||||
|
||||
type FontExtents struct {
|
||||
Ascent float64
|
||||
Descent float64
|
||||
Height float64
|
||||
MaxXAdvance float64
|
||||
MaxYAdvance float64
|
||||
}
|
||||
|
||||
func (v *Context) FontExtents() FontExtents {
|
||||
var extents C.cairo_font_extents_t
|
||||
C.cairo_font_extents(v.native(), &extents)
|
||||
return FontExtents{
|
||||
Ascent: float64(extents.ascent),
|
||||
Descent: float64(extents.descent),
|
||||
Height: float64(extents.height),
|
||||
MaxXAdvance: float64(extents.max_x_advance),
|
||||
MaxYAdvance: float64(extents.max_y_advance),
|
||||
}
|
||||
}
|
||||
|
||||
type TextExtents struct {
|
||||
XBearing float64
|
||||
YBearing float64
|
||||
Width float64
|
||||
Height float64
|
||||
XAdvance float64
|
||||
YAdvance float64
|
||||
}
|
||||
|
||||
func (v *Context) TextExtents(utf8 string) TextExtents {
|
||||
cstr := C.CString(utf8)
|
||||
defer C.free(unsafe.Pointer(cstr))
|
||||
var extents C.cairo_text_extents_t
|
||||
C.cairo_text_extents(v.native(), (*C.char)(cstr), &extents)
|
||||
return TextExtents{
|
||||
XBearing: float64(extents.x_bearing),
|
||||
YBearing: float64(extents.y_bearing),
|
||||
Width: float64(extents.width),
|
||||
Height: float64(extents.height),
|
||||
XAdvance: float64(extents.x_advance),
|
||||
YAdvance: float64(extents.y_advance),
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: cairo_glyph_extents
|
||||
|
||||
// TODO: cairo_toy_font_face_create
|
||||
|
||||
// TODO: cairo_toy_font_face_get_family
|
||||
|
||||
// TODO: cairo_toy_font_face_get_slant
|
||||
|
||||
// TODO: cairo_toy_font_face_get_weight
|
||||
|
||||
// TODO: cairo_glyph_allocate
|
||||
|
||||
// TODO: cairo_glyph_free
|
||||
|
||||
// TODO: cairo_text_cluster_allocate
|
||||
|
||||
// TODO: cairo_text_cluster_free
|
||||
|
||||
@ -1,32 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
|
||||
// Translate is a wrapper around cairo_translate.
|
||||
func (v *Context) Translate(tx, ty float64) {
|
||||
C.cairo_translate(v.native(), C.double(tx), C.double(ty))
|
||||
}
|
||||
|
||||
// Scale is a wrapper around cairo_scale.
|
||||
func (v *Context) Scale(sx, sy float64) {
|
||||
C.cairo_scale(v.native(), C.double(sx), C.double(sy))
|
||||
}
|
||||
|
||||
// Rotate is a wrapper around cairo_rotate.
|
||||
func (v *Context) Rotate(angle float64) {
|
||||
C.cairo_rotate(v.native(), C.double(angle))
|
||||
}
|
||||
|
||||
// TODO: The following depend on cairo_matrix_t:
|
||||
//void cairo_transform ()
|
||||
//void cairo_set_matrix ()
|
||||
//void cairo_get_matrix ()
|
||||
//void cairo_identity_matrix ()
|
||||
//void cairo_user_to_device ()
|
||||
//void cairo_user_to_device_distance ()
|
||||
//void cairo_device_to_user ()
|
||||
//void cairo_device_to_user_distance ()
|
||||
@ -1,21 +0,0 @@
|
||||
package cairo
|
||||
|
||||
// #cgo pkg-config: cairo cairo-gobject
|
||||
// #include <stdlib.h>
|
||||
// #include <cairo.h>
|
||||
// #include <cairo-gobject.h>
|
||||
import "C"
|
||||
|
||||
func cairobool(b bool) C.cairo_bool_t {
|
||||
if b {
|
||||
return C.cairo_bool_t(1)
|
||||
}
|
||||
return C.cairo_bool_t(0)
|
||||
}
|
||||
|
||||
func gobool(b C.cairo_bool_t) bool {
|
||||
if b != 0 {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,100 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2014 Conformal Systems <info@conformal.com>
|
||||
*
|
||||
* This file originated from: http://opensource.conformal.com/
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
// Type Casting
|
||||
static GdkAtom
|
||||
toGdkAtom(void *p)
|
||||
{
|
||||
return ((GdkAtom)p);
|
||||
}
|
||||
|
||||
static GdkDevice *
|
||||
toGdkDevice(void *p)
|
||||
{
|
||||
return (GDK_DEVICE(p));
|
||||
}
|
||||
|
||||
static GdkCursor *
|
||||
toGdkCursor(void *p)
|
||||
{
|
||||
return (GDK_CURSOR(p));
|
||||
}
|
||||
|
||||
static GdkDeviceManager *
|
||||
toGdkDeviceManager(void *p)
|
||||
{
|
||||
return (GDK_DEVICE_MANAGER(p));
|
||||
}
|
||||
|
||||
static GdkDisplay *
|
||||
toGdkDisplay(void *p)
|
||||
{
|
||||
return (GDK_DISPLAY(p));
|
||||
}
|
||||
|
||||
static GdkDragContext *
|
||||
toGdkDragContext(void *p)
|
||||
{
|
||||
return (GDK_DRAG_CONTEXT(p));
|
||||
}
|
||||
|
||||
static GdkPixbuf *
|
||||
toGdkPixbuf(void *p)
|
||||
{
|
||||
return (GDK_PIXBUF(p));
|
||||
}
|
||||
|
||||
static gboolean
|
||||
_gdk_pixbuf_save_png(GdkPixbuf *pixbuf,
|
||||
const char *filename, GError ** err, const char *compression)
|
||||
{
|
||||
return gdk_pixbuf_save(pixbuf, filename, "png", err, "compression", compression, NULL);
|
||||
}
|
||||
|
||||
static gboolean
|
||||
_gdk_pixbuf_save_jpeg(GdkPixbuf *pixbuf,
|
||||
const char *filename, GError ** err, const char *quality)
|
||||
{
|
||||
return gdk_pixbuf_save(pixbuf, filename, "jpeg", err, "quality", quality, NULL);
|
||||
}
|
||||
|
||||
static GdkPixbufLoader *
|
||||
toGdkPixbufLoader(void *p)
|
||||
{
|
||||
return (GDK_PIXBUF_LOADER(p));
|
||||
}
|
||||
|
||||
static GdkScreen *
|
||||
toGdkScreen(void *p)
|
||||
{
|
||||
return (GDK_SCREEN(p));
|
||||
}
|
||||
|
||||
static GdkVisual *
|
||||
toGdkVisual(void *p)
|
||||
{
|
||||
return (GDK_VISUAL(p));
|
||||
}
|
||||
|
||||
static GdkWindow *
|
||||
toGdkWindow(void *p)
|
||||
{
|
||||
return (GDK_WINDOW(p));
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
// Copyright (c) 2013-2014 Conformal Systems <info@conformal.com>
|
||||
//
|
||||
// This file originated from: http://opensource.conformal.com/
|
||||
//
|
||||
// Permission to use, copy, modify, and distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice appear in all copies.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
// This file includes wrapers for symbols deprecated beginning with GTK 3.10,
|
||||
// and should only be included in a build targeted intended to target GTK
|
||||
// 3.8 or earlier. To target an earlier build build, use the build tag
|
||||
// gtk_MAJOR_MINOR. For example, to target GTK 3.8, run
|
||||
// 'go build -tags gtk_3_8'.
|
||||
// +build gtk_3_6 gtk_3_8
|
||||
|
||||
package gdk
|
||||
|
||||
// #cgo pkg-config: gdk-3.0
|
||||
// #include <gdk/gdk.h>
|
||||
import "C"
|
||||
|
||||
// GetNScreens is a wrapper around gdk_display_get_n_screens().
|
||||
func (v *Display) GetNScreens() int {
|
||||
c := C.gdk_display_get_n_screens(v.native())
|
||||
return int(c)
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
//+build gtk_3_6 gtk_3_8 gtk_3_10 gtk_3_12 gtk_3_14
|
||||
|
||||
package gdk
|
||||
|
||||
// #cgo pkg-config: gdk-3.0
|
||||
// #include <gdk/gdk.h>
|
||||
import "C"
|
||||
|
||||
// SupportsComposite() is a wrapper around gdk_display_supports_composite().
|
||||
func (v *Display) SupportsComposite() bool {
|
||||
c := C.gdk_display_supports_composite(v.native())
|
||||
return gobool(c)
|
||||
}
|
||||
@ -1,61 +0,0 @@
|
||||
package gdk
|
||||
|
||||
// #cgo pkg-config: gdk-3.0
|
||||
// #include <gdk/gdk.h>
|
||||
import "C"
|
||||
import (
|
||||
"unsafe"
|
||||
|
||||
"github.com/gotk3/gotk3/glib"
|
||||
)
|
||||
|
||||
type PixbufFormat struct {
|
||||
format *C.GdkPixbufFormat
|
||||
}
|
||||
|
||||
// native returns a pointer to the underlying GdkPixbuf.
|
||||
func (v *PixbufFormat) native() *C.GdkPixbufFormat {
|
||||
if v == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
return v.format
|
||||
}
|
||||
|
||||
// Native returns a pointer to the underlying GdkPixbuf.
|
||||
func (v *PixbufFormat) Native() uintptr {
|
||||
return uintptr(unsafe.Pointer(v.native()))
|
||||
}
|
||||
|
||||
func (f *PixbufFormat) GetName() (string, error) {
|
||||
c := C.gdk_pixbuf_format_get_name(f.native())
|
||||
return C.GoString((*C.char)(c)), nil
|
||||
}
|
||||
|
||||
func (f *PixbufFormat) GetDescription() (string, error) {
|
||||
c := C.gdk_pixbuf_format_get_description(f.native())
|
||||
return C.GoString((*C.char)(c)), nil
|
||||
}
|
||||
|
||||
func (f *PixbufFormat) GetLicense() (string, error) {
|
||||
c := C.gdk_pixbuf_format_get_license(f.native())
|
||||
return C.GoString((*C.char)(c)), nil
|
||||
}
|
||||
|
||||
func PixbufGetFormats() []*PixbufFormat {
|
||||
l := (*C.struct__GSList)(C.gdk_pixbuf_get_formats())
|
||||
formats := glib.WrapSList(uintptr(unsafe.Pointer(l)))
|
||||
if formats == nil {
|
||||
return nil // no error. A nil list is considered to be empty.
|
||||
}
|
||||
|
||||
// "The structures themselves are owned by GdkPixbuf". Free the list only.
|
||||
defer formats.Free()
|
||||
|
||||
ret := make([]*PixbufFormat, 0, formats.Length())
|
||||
formats.Foreach(func(ptr unsafe.Pointer) {
|
||||
ret = append(ret, &PixbufFormat{(*C.GdkPixbufFormat)(ptr)})
|
||||
})
|
||||
|
||||
return ret
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,198 +0,0 @@
|
||||
package gdk
|
||||
|
||||
// #cgo pkg-config: gdk-3.0
|
||||
// #include <gdk/gdk.h>
|
||||
// #include "gdk.go.h"
|
||||
import "C"
|
||||
import (
|
||||
"runtime"
|
||||
"unsafe"
|
||||
|
||||
"github.com/gotk3/gotk3/glib"
|
||||
)
|
||||
|
||||
/*
|
||||
* GdkScreen
|
||||
*/
|
||||
|
||||
// Screen is a representation of GDK's GdkScreen.
|
||||
type Screen struct {
|
||||
*glib.Object
|
||||
}
|
||||
|
||||
// native returns a pointer to the underlying GdkScreen.
|
||||
func (v *Screen) native() *C.GdkScreen {
|
||||
if v == nil || v.GObject == nil {
|
||||
return nil
|
||||
}
|
||||
p := unsafe.Pointer(v.GObject)
|
||||
return C.toGdkScreen(p)
|
||||
}
|
||||
|
||||
// Native returns a pointer to the underlying GdkScreen.
|
||||
func (v *Screen) Native() uintptr {
|
||||
return uintptr(unsafe.Pointer(v.native()))
|
||||
}
|
||||
|
||||
func marshalScreen(p uintptr) (interface{}, error) {
|
||||
c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p)))
|
||||
obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))}
|
||||
return &Screen{obj}, nil
|
||||
}
|
||||
|
||||
func toScreen(s *C.GdkScreen) (*Screen, error) {
|
||||
if s == nil {
|
||||
return nil, nilPtrErr
|
||||
}
|
||||
obj := &glib.Object{glib.ToGObject(unsafe.Pointer(s))}
|
||||
return &Screen{obj}, nil
|
||||
}
|
||||
|
||||
// GetRGBAVisual is a wrapper around gdk_screen_get_rgba_visual().
|
||||
func (v *Screen) GetRGBAVisual() (*Visual, error) {
|
||||
c := C.gdk_screen_get_rgba_visual(v.native())
|
||||
if c == nil {
|
||||
return nil, nilPtrErr
|
||||
}
|
||||
obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))}
|
||||
visual := &Visual{obj}
|
||||
obj.Ref()
|
||||
runtime.SetFinalizer(obj, (*glib.Object).Unref)
|
||||
return visual, nil
|
||||
}
|
||||
|
||||
// GetSystemVisual is a wrapper around gdk_screen_get_system_visual().
|
||||
func (v *Screen) GetSystemVisual() (*Visual, error) {
|
||||
c := C.gdk_screen_get_system_visual(v.native())
|
||||
if c == nil {
|
||||
return nil, nilPtrErr
|
||||
}
|
||||
obj := &glib.Object{glib.ToGObject(unsafe.Pointer(c))}
|
||||
visual := &Visual{obj}
|
||||
obj.Ref()
|
||||
runtime.SetFinalizer(obj, (*glib.Object).Unref)
|
||||
return visual, nil
|
||||
}
|
||||
|
||||
// GetWidth is a wrapper around gdk_screen_get_width().
|
||||
func (v *Screen) GetWidth() int {
|
||||
c := C.gdk_screen_get_width(v.native())
|
||||
return int(c)
|
||||
}
|
||||
|
||||
// GetHeight is a wrapper around gdk_screen_get_height().
|
||||
func (v *Screen) GetHeight() int {
|
||||
c := C.gdk_screen_get_height(v.native())
|
||||
return int(c)
|
||||
}
|
||||
|
||||
// ScreenGetDefault is a wrapper aroud gdk_screen_get_default().
|
||||
func ScreenGetDefault() (*Screen, error) {
|
||||
return toScreen(C.gdk_screen_get_default())
|
||||
}
|
||||
|
||||
// IsComposited is a wrapper around gdk_screen_is_composited().
|
||||
func (v *Screen) IsComposited() bool {
|
||||
return gobool(C.gdk_screen_is_composited(v.native()))
|
||||
}
|
||||
|
||||
// GetRootWindow is a wrapper around gdk_screen_get_root_window().
|
||||
func (v *Screen) GetRootWindow() (*Window, error) {
|
||||
return toWindow(C.gdk_screen_get_root_window(v.native()))
|
||||
}
|
||||
|
||||
// GetDisplay is a wrapper around gdk_screen_get_display().
|
||||
func (v *Screen) GetDisplay() (*Display, error) {
|
||||
return toDisplay(C.gdk_screen_get_display(v.native()))
|
||||
}
|
||||
|
||||
// GetNumber is a wrapper around gdk_screen_get_number().
|
||||
func (v *Screen) GetNumber() int {
|
||||
return int(C.gdk_screen_get_number(v.native()))
|
||||
}
|
||||
|
||||
// GetWidthMM is a wrapper around gdk_screen_get_width_mm().
|
||||
func (v *Screen) GetWidthMM() int {
|
||||
return int(C.gdk_screen_get_width_mm(v.native()))
|
||||
}
|
||||
|
||||
// GetHeightMM is a wrapper around gdk_screen_get_height_mm().
|
||||
func (v *Screen) GetHeightMM() int {
|
||||
return int(C.gdk_screen_get_height_mm(v.native()))
|
||||
}
|
||||
|
||||
func toString(c *C.gchar) (string, error) {
|
||||
if c == nil {
|
||||
return "", nilPtrErr
|
||||
}
|
||||
return C.GoString((*C.char)(c)), nil
|
||||
}
|
||||
|
||||
// MakeDisplayName is a wrapper around gdk_screen_make_display_name().
|
||||
func (v *Screen) MakeDisplayName() (string, error) {
|
||||
return toString(C.gdk_screen_make_display_name(v.native()))
|
||||
}
|
||||
|
||||
// GetNMonitors is a wrapper around gdk_screen_get_n_monitors().
|
||||
func (v *Screen) GetNMonitors() int {
|
||||
return int(C.gdk_screen_get_n_monitors(v.native()))
|
||||
}
|
||||
|
||||
// GetPrimaryMonitor is a wrapper around gdk_screen_get_primary_monitor().
|
||||
func (v *Screen) GetPrimaryMonitor() int {
|
||||
return int(C.gdk_screen_get_primary_monitor(v.native()))
|
||||
}
|
||||
|
||||
// GetMonitorAtPoint is a wrapper around gdk_screen_get_monitor_at_point().
|
||||
func (v *Screen) GetMonitorAtPoint(x, y int) int {
|
||||
return int(C.gdk_screen_get_monitor_at_point(v.native(), C.gint(x), C.gint(y)))
|
||||
}
|
||||
|
||||
// GetMonitorAtWindow is a wrapper around gdk_screen_get_monitor_at_window().
|
||||
func (v *Screen) GetMonitorAtWindow(w *Window) int {
|
||||
return int(C.gdk_screen_get_monitor_at_window(v.native(), w.native()))
|
||||
}
|
||||
|
||||
// GetMonitorHeightMM is a wrapper around gdk_screen_get_monitor_height_mm().
|
||||
func (v *Screen) GetMonitorHeightMM(m int) int {
|
||||
return int(C.gdk_screen_get_monitor_height_mm(v.native(), C.gint(m)))
|
||||
}
|
||||
|
||||
// GetMonitorWidthMM is a wrapper around gdk_screen_get_monitor_width_mm().
|
||||
func (v *Screen) GetMonitorWidthMM(m int) int {
|
||||
return int(C.gdk_screen_get_monitor_width_mm(v.native(), C.gint(m)))
|
||||
}
|
||||
|
||||
// GetMonitorPlugName is a wrapper around gdk_screen_get_monitor_plug_name().
|
||||
func (v *Screen) GetMonitorPlugName(m int) (string, error) {
|
||||
return toString(C.gdk_screen_get_monitor_plug_name(v.native(), C.gint(m)))
|
||||
}
|
||||
|
||||
// GetMonitorScaleFactor is a wrapper around gdk_screen_get_monitor_scale_factor().
|
||||
func (v *Screen) GetMonitorScaleFactor(m int) int {
|
||||
return int(C.gdk_screen_get_monitor_scale_factor(v.native(), C.gint(m)))
|
||||
}
|
||||
|
||||
// GetResolution is a wrapper around gdk_screen_get_resolution().
|
||||
func (v *Screen) GetResolution() float64 {
|
||||
return float64(C.gdk_screen_get_resolution(v.native()))
|
||||
}
|
||||
|
||||
// SetResolution is a wrapper around gdk_screen_set_resolution().
|
||||
func (v *Screen) SetResolution(r float64) {
|
||||
C.gdk_screen_set_resolution(v.native(), C.gdouble(r))
|
||||
}
|
||||
|
||||
// GetActiveWindow is a wrapper around gdk_screen_get_active_window().
|
||||
func (v *Screen) GetActiveWindow() (*Window, error) {
|
||||
return toWindow(C.gdk_screen_get_active_window(v.native()))
|
||||
}
|
||||
|
||||
// void gdk_screen_set_font_options ()
|
||||
// gboolean gdk_screen_get_setting ()
|
||||
// const cairo_font_options_t * gdk_screen_get_font_options ()
|
||||
// GList * gdk_screen_get_window_stack ()
|
||||
// GList * gdk_screen_list_visuals ()
|
||||
// GList * gdk_screen_get_toplevel_windows ()
|
||||
// void gdk_screen_get_monitor_geometry ()
|
||||
// void gdk_screen_get_monitor_workarea ()
|
||||
@ -1,25 +0,0 @@
|
||||
// +build !linux no_x11
|
||||
|
||||
package gdk
|
||||
|
||||
func WorkspaceControlSupported() bool {
|
||||
return false
|
||||
}
|
||||
|
||||
// GetScreenNumber is a wrapper around gdk_x11_screen_get_screen_number().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Screen) GetScreenNumber() int {
|
||||
return -1
|
||||
}
|
||||
|
||||
// GetNumberOfDesktops is a wrapper around gdk_x11_screen_get_number_of_desktops().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Screen) GetNumberOfDesktops() uint32 {
|
||||
return 0
|
||||
}
|
||||
|
||||
// GetCurrentDesktop is a wrapper around gdk_x11_screen_get_current_desktop().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Screen) GetCurrentDesktop() uint32 {
|
||||
return 0
|
||||
}
|
||||
@ -1,31 +0,0 @@
|
||||
// +build linux
|
||||
// +build !no_x11
|
||||
|
||||
package gdk
|
||||
|
||||
// #cgo pkg-config: gdk-x11-3.0
|
||||
// #include <gdk/gdk.h>
|
||||
// #include <gdk/gdkx.h>
|
||||
import "C"
|
||||
|
||||
func WorkspaceControlSupported() bool {
|
||||
return true
|
||||
}
|
||||
|
||||
// GetScreenNumber is a wrapper around gdk_x11_screen_get_screen_number().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Screen) GetScreenNumber() int {
|
||||
return int(C.gdk_x11_screen_get_screen_number(v.native()))
|
||||
}
|
||||
|
||||
// GetNumberOfDesktops is a wrapper around gdk_x11_screen_get_number_of_desktops().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Screen) GetNumberOfDesktops() uint32 {
|
||||
return uint32(C.gdk_x11_screen_get_number_of_desktops(v.native()))
|
||||
}
|
||||
|
||||
// GetCurrentDesktop is a wrapper around gdk_x11_screen_get_current_desktop().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Screen) GetCurrentDesktop() uint32 {
|
||||
return uint32(C.gdk_x11_screen_get_current_desktop(v.native()))
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
// +build !linux no_x11
|
||||
|
||||
package gdk
|
||||
|
||||
func (v *Window) MoveToCurrentDesktop() {
|
||||
}
|
||||
|
||||
// GetDesktop is a wrapper around gdk_x11_window_get_desktop().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Window) GetDesktop() uint32 {
|
||||
return 0
|
||||
}
|
||||
|
||||
// MoveToDesktop is a wrapper around gdk_x11_window_move_to_desktop().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Window) MoveToDesktop(d uint32) {
|
||||
}
|
||||
@ -1,27 +0,0 @@
|
||||
// +build linux
|
||||
// +build !no_x11
|
||||
|
||||
package gdk
|
||||
|
||||
// #cgo pkg-config: gdk-x11-3.0
|
||||
// #include <gdk/gdk.h>
|
||||
// #include <gdk/gdkx.h>
|
||||
import "C"
|
||||
|
||||
// MoveToCurrentDesktop is a wrapper around gdk_x11_window_move_to_current_desktop().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Window) MoveToCurrentDesktop() {
|
||||
C.gdk_x11_window_move_to_current_desktop(v.native())
|
||||
}
|
||||
|
||||
// GetDesktop is a wrapper around gdk_x11_window_get_desktop().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Window) GetDesktop() uint32 {
|
||||
return uint32(C.gdk_x11_window_get_desktop(v.native()))
|
||||
}
|
||||
|
||||
// MoveToDesktop is a wrapper around gdk_x11_window_move_to_desktop().
|
||||
// It only works on GDK versions compiled with X11 support - its return value can't be used if WorkspaceControlSupported returns false
|
||||
func (v *Window) MoveToDesktop(d uint32) {
|
||||
C.gdk_x11_window_move_to_desktop(v.native(), C.guint32(d))
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue