diff options
Diffstat (limited to 'vendor/github.com/google/gopacket/layers/tcp.go')
-rw-r--r-- | vendor/github.com/google/gopacket/layers/tcp.go | 327 |
1 files changed, 0 insertions, 327 deletions
diff --git a/vendor/github.com/google/gopacket/layers/tcp.go b/vendor/github.com/google/gopacket/layers/tcp.go deleted file mode 100644 index fb731da..0000000 --- a/vendor/github.com/google/gopacket/layers/tcp.go +++ /dev/null @@ -1,327 +0,0 @@ -// 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)) -} |