First Commit of Voltha-Go-Controller from Radisys
Change-Id: I8e2e908e7ab09a4fe3d86849da18b6d69dcf4ab0
diff --git a/vendor/github.com/google/gopacket/layers/ports.go b/vendor/github.com/google/gopacket/layers/ports.go
new file mode 100644
index 0000000..7c20449
--- /dev/null
+++ b/vendor/github.com/google/gopacket/layers/ports.go
@@ -0,0 +1,201 @@
+// 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 {
+ if tcpPortLayerTypeOverride.has(uint16(a)) {
+ return tcpPortLayerType[a]
+ }
+ switch a {
+ case 53:
+ return LayerTypeDNS
+ case 443: // https
+ return LayerTypeTLS
+ case 502: // modbustcp
+ return LayerTypeModbusTCP
+ case 636: // ldaps
+ return LayerTypeTLS
+ case 989: // ftps-data
+ return LayerTypeTLS
+ case 990: // ftps
+ return LayerTypeTLS
+ case 992: // telnets
+ return LayerTypeTLS
+ case 993: // imaps
+ return LayerTypeTLS
+ case 994: // ircs
+ return LayerTypeTLS
+ case 995: // pop3s
+ return LayerTypeTLS
+ case 5061: // ips
+ return LayerTypeTLS
+ }
+ return gopacket.LayerTypePayload
+}
+
+var tcpPortLayerTypeOverride bitfield
+
+var tcpPortLayerType = map[TCPPort]gopacket.LayerType{}
+
+// RegisterTCPPortLayerType creates a new mapping between a TCPPort
+// and an underlaying LayerType.
+func RegisterTCPPortLayerType(port TCPPort, layerType gopacket.LayerType) {
+ tcpPortLayerTypeOverride.set(uint16(port))
+ 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 {
+ if udpPortLayerTypeOverride.has(uint16(a)) {
+ return udpPortLayerType[a]
+ }
+ switch a {
+ case 53:
+ return LayerTypeDNS
+ case 67:
+ return LayerTypeDHCPv4
+ case 68:
+ return LayerTypeDHCPv4
+ case 123:
+ return LayerTypeNTP
+ case 546:
+ return LayerTypeDHCPv6
+ case 547:
+ return LayerTypeDHCPv6
+ case 623:
+ return LayerTypeRMCP
+ case 1812:
+ return LayerTypeRADIUS
+ case 2152:
+ return LayerTypeGTPv1U
+ case 3784:
+ return LayerTypeBFD
+ case 4789:
+ return LayerTypeVXLAN
+ case 5060:
+ return LayerTypeSIP
+ case 6081:
+ return LayerTypeGeneve
+ case 6343:
+ return LayerTypeSFlow
+ }
+ return gopacket.LayerTypePayload
+}
+
+var udpPortLayerTypeOverride bitfield
+
+var udpPortLayerType = map[UDPPort]gopacket.LayerType{
+ 53: LayerTypeDNS,
+ 123: LayerTypeNTP,
+ 4789: LayerTypeVXLAN,
+ 67: LayerTypeDHCPv4,
+ 68: LayerTypeDHCPv4,
+ 546: LayerTypeDHCPv6,
+ 547: LayerTypeDHCPv6,
+ 5060: LayerTypeSIP,
+ 6343: LayerTypeSFlow,
+ 6081: LayerTypeGeneve,
+ 3784: LayerTypeBFD,
+ 2152: LayerTypeGTPv1U,
+ 623: LayerTypeRMCP,
+}
+
+// RegisterUDPPortLayerType creates a new mapping between a UDPPort
+// and an underlaying LayerType.
+func RegisterUDPPortLayerType(port UDPPort, layerType gopacket.LayerType) {
+ udpPortLayerTypeOverride.set(uint16(port))
+ 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))
+}