329 lines
8.2 KiB
Go
329 lines
8.2 KiB
Go
// Copyright (C) 2014 Nippon Telegraph and Telephone Corporation.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
// implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package bgp
|
|
|
|
import (
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const AS_TRANS = 23456
|
|
|
|
const BGP_PORT = 179
|
|
|
|
//go:generate stringer -type=FSMState
|
|
type FSMState int
|
|
|
|
const (
|
|
BGP_FSM_IDLE FSMState = iota
|
|
BGP_FSM_CONNECT
|
|
BGP_FSM_ACTIVE
|
|
BGP_FSM_OPENSENT
|
|
BGP_FSM_OPENCONFIRM
|
|
BGP_FSM_ESTABLISHED
|
|
)
|
|
|
|
// partially taken from http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml
|
|
type Protocol int
|
|
|
|
const (
|
|
Unknown Protocol = iota
|
|
ICMP = 0x01
|
|
IGMP = 0x02
|
|
TCP = 0x06
|
|
EGP = 0x08
|
|
IGP = 0x09
|
|
UDP = 0x11
|
|
RSVP = 0x2e
|
|
GRE = 0x2f
|
|
OSPF = 0x59
|
|
IPIP = 0x5e
|
|
PIM = 0x67
|
|
SCTP = 0x84
|
|
)
|
|
|
|
var ProtocolNameMap = map[Protocol]string{
|
|
Unknown: "unknown",
|
|
ICMP: "icmp",
|
|
IGMP: "igmp",
|
|
TCP: "tcp",
|
|
EGP: "egp",
|
|
IGP: "igp",
|
|
UDP: "udp",
|
|
RSVP: "rsvp",
|
|
GRE: "gre",
|
|
OSPF: "ospf",
|
|
IPIP: "ipip",
|
|
PIM: "pim",
|
|
SCTP: "sctp",
|
|
}
|
|
|
|
func (p Protocol) String() string {
|
|
name, ok := ProtocolNameMap[p]
|
|
if !ok {
|
|
return strconv.Itoa(int(p))
|
|
}
|
|
return name
|
|
}
|
|
|
|
type TCPFlag int
|
|
|
|
const (
|
|
_ TCPFlag = iota
|
|
TCP_FLAG_FIN = 0x01
|
|
TCP_FLAG_SYN = 0x02
|
|
TCP_FLAG_RST = 0x04
|
|
TCP_FLAG_PUSH = 0x08
|
|
TCP_FLAG_ACK = 0x10
|
|
TCP_FLAG_URGENT = 0x20
|
|
TCP_FLAG_ECE = 0x40
|
|
TCP_FLAG_CWR = 0x80
|
|
)
|
|
|
|
var TCPFlagNameMap = map[TCPFlag]string{
|
|
TCP_FLAG_FIN: "F",
|
|
TCP_FLAG_SYN: "S",
|
|
TCP_FLAG_RST: "R",
|
|
TCP_FLAG_PUSH: "P",
|
|
TCP_FLAG_ACK: "A",
|
|
TCP_FLAG_URGENT: "U",
|
|
TCP_FLAG_CWR: "C",
|
|
TCP_FLAG_ECE: "E",
|
|
}
|
|
|
|
// Prepares a sorted list of flags because map iterations does not happen
|
|
// in a consistent order in Golang.
|
|
var TCPSortedFlags = []TCPFlag{
|
|
TCP_FLAG_FIN,
|
|
TCP_FLAG_SYN,
|
|
TCP_FLAG_RST,
|
|
TCP_FLAG_PUSH,
|
|
TCP_FLAG_ACK,
|
|
TCP_FLAG_URGENT,
|
|
TCP_FLAG_ECE,
|
|
TCP_FLAG_CWR,
|
|
}
|
|
|
|
func (f TCPFlag) String() string {
|
|
flags := make([]string, 0, len(TCPSortedFlags))
|
|
for _, v := range TCPSortedFlags {
|
|
if f&v > 0 {
|
|
flags = append(flags, TCPFlagNameMap[v])
|
|
}
|
|
}
|
|
return strings.Join(flags, "")
|
|
}
|
|
|
|
type BitmaskFlagOp uint8
|
|
|
|
const (
|
|
BITMASK_FLAG_OP_OR BitmaskFlagOp = iota
|
|
BITMASK_FLAG_OP_MATCH = 0x01
|
|
BITMASK_FLAG_OP_NOT = 0x02
|
|
BITMASK_FLAG_OP_NOT_MATCH = 0x03
|
|
BITMASK_FLAG_OP_AND = 0x40
|
|
BITMASK_FLAG_OP_END = 0x80
|
|
)
|
|
|
|
var BitmaskFlagOpNameMap = map[BitmaskFlagOp]string{
|
|
BITMASK_FLAG_OP_OR: " ",
|
|
BITMASK_FLAG_OP_AND: "&",
|
|
BITMASK_FLAG_OP_END: "E",
|
|
BITMASK_FLAG_OP_NOT: "!",
|
|
BITMASK_FLAG_OP_MATCH: "=",
|
|
}
|
|
|
|
// Note: Meaning of "" is different from that of the numeric operator because
|
|
// RFC5575 says if the Match bit in the bitmask operand is set, it should be
|
|
// "strictly" matching against the given value.
|
|
var BitmaskFlagOpValueMap = map[string]BitmaskFlagOp{
|
|
" ": BITMASK_FLAG_OP_OR,
|
|
"": BITMASK_FLAG_OP_OR,
|
|
"==": BITMASK_FLAG_OP_MATCH,
|
|
"=": BITMASK_FLAG_OP_MATCH,
|
|
"!": BITMASK_FLAG_OP_NOT,
|
|
"!=": BITMASK_FLAG_OP_NOT_MATCH,
|
|
"=!": BITMASK_FLAG_OP_NOT_MATCH, // For the backward compatibility
|
|
"&": BITMASK_FLAG_OP_AND,
|
|
"E": BITMASK_FLAG_OP_END,
|
|
}
|
|
|
|
func (f BitmaskFlagOp) String() string {
|
|
ops := make([]string, 0, 3)
|
|
if f&BITMASK_FLAG_OP_AND > 0 {
|
|
ops = append(ops, BitmaskFlagOpNameMap[BITMASK_FLAG_OP_AND])
|
|
} else {
|
|
ops = append(ops, BitmaskFlagOpNameMap[BITMASK_FLAG_OP_OR])
|
|
}
|
|
if f&BITMASK_FLAG_OP_NOT > 0 {
|
|
ops = append(ops, BitmaskFlagOpNameMap[BITMASK_FLAG_OP_NOT])
|
|
}
|
|
if f&BITMASK_FLAG_OP_MATCH > 0 {
|
|
ops = append(ops, BitmaskFlagOpNameMap[BITMASK_FLAG_OP_MATCH])
|
|
}
|
|
return strings.Join(ops, "")
|
|
}
|
|
|
|
type FragmentFlag int
|
|
|
|
const (
|
|
FRAG_FLAG_NOT FragmentFlag = iota
|
|
FRAG_FLAG_DONT = 0x01
|
|
FRAG_FLAG_IS = 0x02
|
|
FRAG_FLAG_FIRST = 0x04
|
|
FRAG_FLAG_LAST = 0x08
|
|
)
|
|
|
|
var FragmentFlagNameMap = map[FragmentFlag]string{
|
|
FRAG_FLAG_NOT: "not-a-fragment",
|
|
FRAG_FLAG_DONT: "dont-fragment",
|
|
FRAG_FLAG_IS: "is-fragment",
|
|
FRAG_FLAG_FIRST: "first-fragment",
|
|
FRAG_FLAG_LAST: "last-fragment",
|
|
}
|
|
|
|
// Prepares a sorted list of flags because map iterations does not happen
|
|
// in a consistent order in Golang.
|
|
var FragmentSortedFlags = []FragmentFlag{
|
|
FRAG_FLAG_NOT,
|
|
FRAG_FLAG_DONT,
|
|
FRAG_FLAG_IS,
|
|
FRAG_FLAG_FIRST,
|
|
FRAG_FLAG_LAST,
|
|
}
|
|
|
|
func (f FragmentFlag) String() string {
|
|
flags := make([]string, 0, len(FragmentSortedFlags))
|
|
for _, v := range FragmentSortedFlags {
|
|
if f&v > 0 {
|
|
flags = append(flags, FragmentFlagNameMap[v])
|
|
}
|
|
}
|
|
// Note: If multiple bits are set, joins them with "+".
|
|
return strings.Join(flags, "+")
|
|
}
|
|
|
|
type DECNumOp uint8
|
|
|
|
const (
|
|
DEC_NUM_OP_TRUE DECNumOp = iota // true always with END bit set
|
|
DEC_NUM_OP_EQ = 0x01
|
|
DEC_NUM_OP_GT = 0x02
|
|
DEC_NUM_OP_GT_EQ = 0x03
|
|
DEC_NUM_OP_LT = 0x04
|
|
DEC_NUM_OP_LT_EQ = 0x05
|
|
DEC_NUM_OP_NOT_EQ = 0x06
|
|
DEC_NUM_OP_FALSE = 0x07 // false always with END bit set
|
|
DEC_NUM_OP_OR = 0x00
|
|
DEC_NUM_OP_AND = 0x40
|
|
DEC_NUM_OP_END = 0x80
|
|
)
|
|
|
|
var DECNumOpNameMap = map[DECNumOp]string{
|
|
DEC_NUM_OP_TRUE: "true",
|
|
DEC_NUM_OP_EQ: "==",
|
|
DEC_NUM_OP_GT: ">",
|
|
DEC_NUM_OP_GT_EQ: ">=",
|
|
DEC_NUM_OP_LT: "<",
|
|
DEC_NUM_OP_LT_EQ: "<=",
|
|
DEC_NUM_OP_NOT_EQ: "!=",
|
|
DEC_NUM_OP_FALSE: "false",
|
|
//DEC_NUM_OP_OR: " ", // duplicate with DEC_NUM_OP_TRUE
|
|
DEC_NUM_OP_AND: "&",
|
|
DEC_NUM_OP_END: "E",
|
|
}
|
|
|
|
var DECNumOpValueMap = map[string]DECNumOp{
|
|
"true": DEC_NUM_OP_TRUE,
|
|
"": DEC_NUM_OP_EQ,
|
|
"==": DEC_NUM_OP_EQ,
|
|
"=": DEC_NUM_OP_EQ,
|
|
">": DEC_NUM_OP_GT,
|
|
">=": DEC_NUM_OP_GT_EQ,
|
|
"<": DEC_NUM_OP_LT,
|
|
"<=": DEC_NUM_OP_LT_EQ,
|
|
"!=": DEC_NUM_OP_NOT_EQ,
|
|
"=!": DEC_NUM_OP_NOT_EQ,
|
|
"!": DEC_NUM_OP_NOT_EQ,
|
|
"false": DEC_NUM_OP_FALSE,
|
|
" ": DEC_NUM_OP_OR,
|
|
"&": DEC_NUM_OP_AND,
|
|
"E": DEC_NUM_OP_END,
|
|
}
|
|
|
|
func (f DECNumOp) String() string {
|
|
ops := make([]string, 0)
|
|
logicFlag := DECNumOp(f & 0xc0) // higher 2 bits
|
|
if logicFlag&DEC_NUM_OP_AND > 0 {
|
|
ops = append(ops, DECNumOpNameMap[DEC_NUM_OP_AND])
|
|
} else {
|
|
ops = append(ops, " ") // DEC_NUM_OP_OR
|
|
}
|
|
// Omits DEC_NUM_OP_END
|
|
cmpFlag := DECNumOp(f & 0x7) // lower 3 bits
|
|
for v, s := range DECNumOpNameMap {
|
|
if cmpFlag == v {
|
|
ops = append(ops, s)
|
|
break
|
|
}
|
|
}
|
|
return strings.Join(ops, "")
|
|
}
|
|
|
|
// Potentially taken from https://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers.xhtml
|
|
type EthernetType int
|
|
|
|
const (
|
|
IPv4 EthernetType = 0x0800
|
|
ARP EthernetType = 0x0806
|
|
RARP EthernetType = 0x8035
|
|
VMTP EthernetType = 0x805B
|
|
APPLE_TALK EthernetType = 0x809B
|
|
AARP EthernetType = 0x80F3
|
|
IPX EthernetType = 0x8137
|
|
SNMP EthernetType = 0x814C
|
|
NET_BIOS EthernetType = 0x8191
|
|
XTP EthernetType = 0x817D
|
|
IPv6 EthernetType = 0x86DD
|
|
PPPoE_DISCOVERY EthernetType = 0x8863
|
|
PPPoE_SESSION EthernetType = 0x8864
|
|
LOOPBACK EthernetType = 0x9000
|
|
)
|
|
|
|
var EthernetTypeNameMap = map[EthernetType]string{
|
|
IPv4: "ipv4",
|
|
ARP: "arp",
|
|
RARP: "rarp",
|
|
VMTP: "vmtp",
|
|
APPLE_TALK: "apple-talk",
|
|
AARP: "aarp",
|
|
IPX: "ipx",
|
|
SNMP: "snmp",
|
|
NET_BIOS: "net-bios",
|
|
XTP: "xtp",
|
|
IPv6: "ipv6",
|
|
PPPoE_DISCOVERY: "pppoe-discovery",
|
|
PPPoE_SESSION: "pppoe-session",
|
|
LOOPBACK: "loopback",
|
|
}
|
|
|
|
func (t EthernetType) String() string {
|
|
if name, ok := EthernetTypeNameMap[t]; ok {
|
|
return name
|
|
}
|
|
return strconv.Itoa(int(t))
|
|
}
|