follow Standard Go Project Layout

https://github.com/golang-standards/project-layout

Now you can see clearly what are private and public library code.

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>

16 files changed, 0 insertions, 15182 deletions

diff --git a/packet/bgp/bgp.go b/packet/bgp/bgp.go
deleted file mode 100644
index 01251167..00000000
--- a/packet/bgp/bgp.go
+++ /dev/null
@@ -1,9674 +0,0 @@
-// 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 (
-	"bytes"
-	"encoding/binary"
-	"encoding/json"
-	"fmt"
-	"math"
-	"net"
-	"reflect"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-type MarshallingOption struct {
-	AddPath map[RouteFamily]BGPAddPathMode
-}
-
-func IsAddPathEnabled(decode bool, f RouteFamily, options []*MarshallingOption) bool {
-	for _, opt := range options {
-		if opt == nil {
-			continue
-		}
-		if o := opt.AddPath; o != nil {
-			if decode && o[f]&BGP_ADD_PATH_RECEIVE > 0 {
-				return true
-			} else if !decode && o[f]&BGP_ADD_PATH_SEND > 0 {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-const (
-	AFI_IP     = 1
-	AFI_IP6    = 2
-	AFI_L2VPN  = 25
-	AFI_OPAQUE = 16397
-)
-
-const (
-	SAFI_UNICAST                  = 1
-	SAFI_MULTICAST                = 2
-	SAFI_MPLS_LABEL               = 4
-	SAFI_ENCAPSULATION            = 7
-	SAFI_VPLS                     = 65
-	SAFI_EVPN                     = 70
-	SAFI_MPLS_VPN                 = 128
-	SAFI_MPLS_VPN_MULTICAST       = 129
-	SAFI_ROUTE_TARGET_CONSTRAINTS = 132
-	SAFI_FLOW_SPEC_UNICAST        = 133
-	SAFI_FLOW_SPEC_VPN            = 134
-	SAFI_KEY_VALUE                = 241
-)
-
-const (
-	BGP_ORIGIN_ATTR_TYPE_IGP        uint8 = 0
-	BGP_ORIGIN_ATTR_TYPE_EGP        uint8 = 1
-	BGP_ORIGIN_ATTR_TYPE_INCOMPLETE uint8 = 2
-)
-
-const (
-	BGP_ASPATH_ATTR_TYPE_SET        = 1
-	BGP_ASPATH_ATTR_TYPE_SEQ        = 2
-	BGP_ASPATH_ATTR_TYPE_CONFED_SEQ = 3
-	BGP_ASPATH_ATTR_TYPE_CONFED_SET = 4
-)
-
-// RFC7153 5.1. Registries for the "Type" Field
-// RANGE	REGISTRATION PROCEDURES
-// 0x00-0x3F	Transitive First Come First Served
-// 0x40-0x7F	Non-Transitive First Come First Served
-// 0x80-0x8F	Transitive Experimental Use
-// 0x90-0xBF	Transitive Standards Action
-// 0xC0-0xCF	Non-Transitive Experimental Use
-// 0xD0-0xFF	Non-Transitive Standards Action
-type ExtendedCommunityAttrType uint8
-
-const (
-	EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC      ExtendedCommunityAttrType = 0x00
-	EC_TYPE_TRANSITIVE_IP6_SPECIFIC               ExtendedCommunityAttrType = 0x00 // RFC5701
-	EC_TYPE_TRANSITIVE_IP4_SPECIFIC               ExtendedCommunityAttrType = 0x01
-	EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC     ExtendedCommunityAttrType = 0x02
-	EC_TYPE_TRANSITIVE_OPAQUE                     ExtendedCommunityAttrType = 0x03
-	EC_TYPE_TRANSITIVE_QOS_MARKING                ExtendedCommunityAttrType = 0x04
-	EC_TYPE_COS_CAPABILITY                        ExtendedCommunityAttrType = 0x05
-	EC_TYPE_EVPN                                  ExtendedCommunityAttrType = 0x06
-	EC_TYPE_FLOWSPEC_REDIRECT_MIRROR              ExtendedCommunityAttrType = 0x08
-	EC_TYPE_NON_TRANSITIVE_TWO_OCTET_AS_SPECIFIC  ExtendedCommunityAttrType = 0x40
-	EC_TYPE_NON_TRANSITIVE_IP6_SPECIFIC           ExtendedCommunityAttrType = 0x40 // RFC5701
-	EC_TYPE_NON_TRANSITIVE_IP4_SPECIFIC           ExtendedCommunityAttrType = 0x41
-	EC_TYPE_NON_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC ExtendedCommunityAttrType = 0x42
-	EC_TYPE_NON_TRANSITIVE_OPAQUE                 ExtendedCommunityAttrType = 0x43
-	EC_TYPE_NON_TRANSITIVE_QOS_MARKING            ExtendedCommunityAttrType = 0x44
-	EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL       ExtendedCommunityAttrType = 0x80
-	EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2      ExtendedCommunityAttrType = 0x81 // RFC7674
-	EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3      ExtendedCommunityAttrType = 0x82 // RFC7674
-)
-
-// RFC7153 5.2. Registries for the "Sub-Type" Field
-// RANGE	REGISTRATION PROCEDURES
-// 0x00-0xBF	First Come First Served
-// 0xC0-0xFF	IETF Review
-type ExtendedCommunityAttrSubType uint8
-
-const (
-	EC_SUBTYPE_ROUTE_TARGET            ExtendedCommunityAttrSubType = 0x02 // EC_TYPE: 0x00, 0x01, 0x02
-	EC_SUBTYPE_ROUTE_ORIGIN            ExtendedCommunityAttrSubType = 0x03 // EC_TYPE: 0x00, 0x01, 0x02
-	EC_SUBTYPE_LINK_BANDWIDTH          ExtendedCommunityAttrSubType = 0x04 // EC_TYPE: 0x40
-	EC_SUBTYPE_GENERIC                 ExtendedCommunityAttrSubType = 0x04 // EC_TYPE: 0x02, 0x42
-	EC_SUBTYPE_OSPF_DOMAIN_ID          ExtendedCommunityAttrSubType = 0x05 // EC_TYPE: 0x00, 0x01, 0x02
-	EC_SUBTYPE_OSPF_ROUTE_ID           ExtendedCommunityAttrSubType = 0x07 // EC_TYPE: 0x01
-	EC_SUBTYPE_BGP_DATA_COLLECTION     ExtendedCommunityAttrSubType = 0x08 // EC_TYPE: 0x00, 0x02
-	EC_SUBTYPE_SOURCE_AS               ExtendedCommunityAttrSubType = 0x09 // EC_TYPE: 0x00, 0x02
-	EC_SUBTYPE_L2VPN_ID                ExtendedCommunityAttrSubType = 0x0A // EC_TYPE: 0x00, 0x01
-	EC_SUBTYPE_VRF_ROUTE_IMPORT        ExtendedCommunityAttrSubType = 0x0B // EC_TYPE: 0x01
-	EC_SUBTYPE_CISCO_VPN_DISTINGUISHER ExtendedCommunityAttrSubType = 0x10 // EC_TYPE: 0x00, 0x01, 0x02
-
-	EC_SUBTYPE_OSPF_ROUTE_TYPE ExtendedCommunityAttrSubType = 0x06 // EC_TYPE: 0x03
-	EC_SUBTYPE_COLOR           ExtendedCommunityAttrSubType = 0x0B // EC_TYPE: 0x03
-	EC_SUBTYPE_ENCAPSULATION   ExtendedCommunityAttrSubType = 0x0C // EC_TYPE: 0x03
-	EC_SUBTYPE_DEFAULT_GATEWAY ExtendedCommunityAttrSubType = 0x0D // EC_TYPE: 0x03
-
-	EC_SUBTYPE_ORIGIN_VALIDATION ExtendedCommunityAttrSubType = 0x00 // EC_TYPE: 0x43
-
-	EC_SUBTYPE_FLOWSPEC_TRAFFIC_RATE   ExtendedCommunityAttrSubType = 0x06 // EC_TYPE: 0x80
-	EC_SUBTYPE_FLOWSPEC_TRAFFIC_ACTION ExtendedCommunityAttrSubType = 0x07 // EC_TYPE: 0x80
-	EC_SUBTYPE_FLOWSPEC_REDIRECT       ExtendedCommunityAttrSubType = 0x08 // EC_TYPE: 0x80
-	EC_SUBTYPE_FLOWSPEC_TRAFFIC_REMARK ExtendedCommunityAttrSubType = 0x09 // EC_TYPE: 0x80
-	EC_SUBTYPE_L2_INFO                 ExtendedCommunityAttrSubType = 0x0A // EC_TYPE: 0x80
-	EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6   ExtendedCommunityAttrSubType = 0x0B // EC_TYPE: 0x80
-
-	EC_SUBTYPE_MAC_MOBILITY ExtendedCommunityAttrSubType = 0x00 // EC_TYPE: 0x06
-	EC_SUBTYPE_ESI_LABEL    ExtendedCommunityAttrSubType = 0x01 // EC_TYPE: 0x06
-	EC_SUBTYPE_ES_IMPORT    ExtendedCommunityAttrSubType = 0x02 // EC_TYPE: 0x06
-	EC_SUBTYPE_ROUTER_MAC   ExtendedCommunityAttrSubType = 0x03 // EC_TYPE: 0x06
-
-	EC_SUBTYPE_UUID_BASED_RT ExtendedCommunityAttrSubType = 0x11
-)
-
-type TunnelType uint16
-
-const (
-	TUNNEL_TYPE_L2TP3       TunnelType = 1
-	TUNNEL_TYPE_GRE         TunnelType = 2
-	TUNNEL_TYPE_IP_IN_IP    TunnelType = 7
-	TUNNEL_TYPE_VXLAN       TunnelType = 8
-	TUNNEL_TYPE_NVGRE       TunnelType = 9
-	TUNNEL_TYPE_MPLS        TunnelType = 10
-	TUNNEL_TYPE_MPLS_IN_GRE TunnelType = 11
-	TUNNEL_TYPE_VXLAN_GRE   TunnelType = 12
-	TUNNEL_TYPE_MPLS_IN_UDP TunnelType = 13
-)
-
-func (p TunnelType) String() string {
-	switch p {
-	case TUNNEL_TYPE_L2TP3:
-		return "l2tp3"
-	case TUNNEL_TYPE_GRE:
-		return "gre"
-	case TUNNEL_TYPE_IP_IN_IP:
-		return "ip-in-ip"
-	case TUNNEL_TYPE_VXLAN:
-		return "vxlan"
-	case TUNNEL_TYPE_NVGRE:
-		return "nvgre"
-	case TUNNEL_TYPE_MPLS:
-		return "mpls"
-	case TUNNEL_TYPE_MPLS_IN_GRE:
-		return "mpls-in-gre"
-	case TUNNEL_TYPE_VXLAN_GRE:
-		return "vxlan-gre"
-	case TUNNEL_TYPE_MPLS_IN_UDP:
-		return "mpls-in-udp"
-	default:
-		return fmt.Sprintf("TunnelType(%d)", uint8(p))
-	}
-}
-
-type PmsiTunnelType uint8
-
-const (
-	PMSI_TUNNEL_TYPE_NO_TUNNEL      PmsiTunnelType = 0
-	PMSI_TUNNEL_TYPE_RSVP_TE_P2MP   PmsiTunnelType = 1
-	PMSI_TUNNEL_TYPE_MLDP_P2MP      PmsiTunnelType = 2
-	PMSI_TUNNEL_TYPE_PIM_SSM_TREE   PmsiTunnelType = 3
-	PMSI_TUNNEL_TYPE_PIM_SM_TREE    PmsiTunnelType = 4
-	PMSI_TUNNEL_TYPE_BIDIR_PIM_TREE PmsiTunnelType = 5
-	PMSI_TUNNEL_TYPE_INGRESS_REPL   PmsiTunnelType = 6
-	PMSI_TUNNEL_TYPE_MLDP_MP2MP     PmsiTunnelType = 7
-)
-
-func (p PmsiTunnelType) String() string {
-	switch p {
-	case PMSI_TUNNEL_TYPE_NO_TUNNEL:
-		return "no-tunnel"
-	case PMSI_TUNNEL_TYPE_RSVP_TE_P2MP:
-		return "rsvp-te-p2mp"
-	case PMSI_TUNNEL_TYPE_MLDP_P2MP:
-		return "mldp-p2mp"
-	case PMSI_TUNNEL_TYPE_PIM_SSM_TREE:
-		return "pim-ssm-tree"
-	case PMSI_TUNNEL_TYPE_PIM_SM_TREE:
-		return "pim-sm-tree"
-	case PMSI_TUNNEL_TYPE_BIDIR_PIM_TREE:
-		return "bidir-pim-tree"
-	case PMSI_TUNNEL_TYPE_INGRESS_REPL:
-		return "ingress-repl"
-	case PMSI_TUNNEL_TYPE_MLDP_MP2MP:
-		return "mldp-mp2mp"
-	default:
-		return fmt.Sprintf("PmsiTunnelType(%d)", uint8(p))
-	}
-}
-
-type EncapSubTLVType uint8
-
-const (
-	ENCAP_SUBTLV_TYPE_ENCAPSULATION EncapSubTLVType = 1
-	ENCAP_SUBTLV_TYPE_PROTOCOL      EncapSubTLVType = 2
-	ENCAP_SUBTLV_TYPE_COLOR         EncapSubTLVType = 4
-)
-
-const (
-	_ = iota
-	BGP_MSG_OPEN
-	BGP_MSG_UPDATE
-	BGP_MSG_NOTIFICATION
-	BGP_MSG_KEEPALIVE
-	BGP_MSG_ROUTE_REFRESH
-)
-
-const (
-	BGP_OPT_CAPABILITY = 2
-)
-
-type BGPCapabilityCode uint8
-
-const (
-	BGP_CAP_MULTIPROTOCOL               BGPCapabilityCode = 1
-	BGP_CAP_ROUTE_REFRESH               BGPCapabilityCode = 2
-	BGP_CAP_CARRYING_LABEL_INFO         BGPCapabilityCode = 4
-	BGP_CAP_EXTENDED_NEXTHOP            BGPCapabilityCode = 5
-	BGP_CAP_GRACEFUL_RESTART            BGPCapabilityCode = 64
-	BGP_CAP_FOUR_OCTET_AS_NUMBER        BGPCapabilityCode = 65
-	BGP_CAP_ADD_PATH                    BGPCapabilityCode = 69
-	BGP_CAP_ENHANCED_ROUTE_REFRESH      BGPCapabilityCode = 70
-	BGP_CAP_LONG_LIVED_GRACEFUL_RESTART BGPCapabilityCode = 71
-	BGP_CAP_ROUTE_REFRESH_CISCO         BGPCapabilityCode = 128
-)
-
-var CapNameMap = map[BGPCapabilityCode]string{
-	BGP_CAP_MULTIPROTOCOL:               "multiprotocol",
-	BGP_CAP_ROUTE_REFRESH:               "route-refresh",
-	BGP_CAP_CARRYING_LABEL_INFO:         "carrying-label-info",
-	BGP_CAP_GRACEFUL_RESTART:            "graceful-restart",
-	BGP_CAP_EXTENDED_NEXTHOP:            "extended-nexthop",
-	BGP_CAP_FOUR_OCTET_AS_NUMBER:        "4-octet-as",
-	BGP_CAP_ADD_PATH:                    "add-path",
-	BGP_CAP_ENHANCED_ROUTE_REFRESH:      "enhanced-route-refresh",
-	BGP_CAP_ROUTE_REFRESH_CISCO:         "cisco-route-refresh",
-	BGP_CAP_LONG_LIVED_GRACEFUL_RESTART: "long-lived-graceful-restart",
-}
-
-func (c BGPCapabilityCode) String() string {
-	if n, y := CapNameMap[c]; y {
-		return n
-	}
-	return fmt.Sprintf("UnknownCapability(%d)", c)
-}
-
-var (
-	// Used parsing RouteDistinguisher
-	_regexpRouteDistinguisher = regexp.MustCompile(`^((\d+)\.(\d+)\.(\d+)\.(\d+)|((\d+)\.)?(\d+)|([\w]+:[\w:]*:[\w]+)):(\d+)$`)
-
-	// Used for operator and value for the FlowSpec numeric type
-	// Example:
-	// re.FindStringSubmatch("&==80")
-	// >>> ["&==80" "&" "==" "80"]
-	_regexpFlowSpecNumericType = regexp.MustCompile(`(&?)(==|=|>|>=|<|<=|!|!=|=!)?(\d+|-\d|true|false)`)
-
-	// - "=!" is used in the old style format of "tcp-flags" and "fragment".
-	// - The value field should be one of the followings:
-	//     * Decimal value (e.g., 80)
-	//     * Combination of the small letters, decimals, "-" and "+"
-	//       (e.g., tcp, ipv4, is-fragment+first-fragment)
-	//     * Capital letters (e.g., SA)
-	_regexpFlowSpecOperator      = regexp.MustCompile(`&|=|>|<|!|[\w\-+]+`)
-	_regexpFlowSpecOperatorValue = regexp.MustCompile(`[\w\-+]+`)
-
-	// Note: "(-*)" and "(.*)" catch the invalid flags
-	// Example: In this case, "Z" is unsupported flag type.
-	// re.FindStringSubmatch("&==-SZU")
-	// >>> ["&==-SZU" "&" "==" "-" "S" "ZU"]
-	_regexpFlowSpecTCPFlag = regexp.MustCompile("(&?)(==|=|!|!=|=!)?(-*)([FSRPAUCE]+)(.*)")
-
-	// Note: "(.*)" catches the invalid flags
-	// re.FindStringSubmatch("&!=+first-fragment+last-fragment+invalid-fragment")
-	// >>> ["&!=+first-fragment+last-fragment+invalid-fragment" "&" "!=" "+first-fragment+last-fragment" "+last-fragment" "+" "last" "+invalid-fragment"]
-	_regexpFlowSpecFragment = regexp.MustCompile(`(&?)(==|=|!|!=|=!)?(((\+)?(dont|is|first|last|not-a)-fragment)+)(.*)`)
-
-	// re.FindStringSubmatch("192.168.0.0/24")
-	// >>> ["192.168.0.0/24" "192.168.0.0" "/24" "24"]
-	// re.FindStringSubmatch("192.168.0.1")
-	// >>> ["192.168.0.1" "192.168.0.1" "" ""]
-	_regexpFindIPv4Prefix = regexp.MustCompile(`^([\d.]+)(/(\d{1,2}))?`)
-
-	// re.FindStringSubmatch("2001:dB8::/64")
-	// >>> ["2001:dB8::/64" "2001:dB8::" "/64" "64" "" ""]
-	// re.FindStringSubmatch("2001:dB8::/64/8")
-	// >>> ["2001:dB8::/64/8" "2001:dB8::" "/64" "64" "/8" "8"]
-	// re.FindStringSubmatch("2001:dB8::1")
-	// >>> ["2001:dB8::1" "2001:dB8::1" "" "" "" ""]
-	_regexpFindIPv6Prefix = regexp.MustCompile(`^([a-fA-F\d:.]+)(/(\d{1,3}))?(/(\d{1,3}))?`)
-)
-
-type ParameterCapabilityInterface interface {
-	DecodeFromBytes([]byte) error
-	Serialize() ([]byte, error)
-	Len() int
-	Code() BGPCapabilityCode
-}
-
-type DefaultParameterCapability struct {
-	CapCode  BGPCapabilityCode `json:"code"`
-	CapLen   uint8             `json:"-"`
-	CapValue []byte            `json:"value,omitempty"`
-}
-
-func (c *DefaultParameterCapability) Code() BGPCapabilityCode {
-	return c.CapCode
-}
-
-func (c *DefaultParameterCapability) DecodeFromBytes(data []byte) error {
-	c.CapCode = BGPCapabilityCode(data[0])
-	c.CapLen = data[1]
-	if len(data) < 2+int(c.CapLen) {
-		return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all OptionParameterCapability bytes available")
-	}
-	if c.CapLen > 0 {
-		c.CapValue = data[2 : 2+c.CapLen]
-	}
-	return nil
-}
-
-func (c *DefaultParameterCapability) Serialize() ([]byte, error) {
-	c.CapLen = uint8(len(c.CapValue))
-	buf := make([]byte, 2)
-	buf[0] = uint8(c.CapCode)
-	buf[1] = c.CapLen
-	buf = append(buf, c.CapValue...)
-	return buf, nil
-}
-
-func (c *DefaultParameterCapability) Len() int {
-	return int(c.CapLen + 2)
-}
-
-type CapMultiProtocol struct {
-	DefaultParameterCapability
-	CapValue RouteFamily
-}
-
-func (c *CapMultiProtocol) DecodeFromBytes(data []byte) error {
-	c.DefaultParameterCapability.DecodeFromBytes(data)
-	data = data[2:]
-	if len(data) < 4 {
-		return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityMultiProtocol bytes available")
-	}
-	c.CapValue = AfiSafiToRouteFamily(binary.BigEndian.Uint16(data[0:2]), data[3])
-	return nil
-}
-
-func (c *CapMultiProtocol) Serialize() ([]byte, error) {
-	buf := make([]byte, 4)
-	afi, safi := RouteFamilyToAfiSafi(c.CapValue)
-	binary.BigEndian.PutUint16(buf[0:], afi)
-	buf[3] = safi
-	c.DefaultParameterCapability.CapValue = buf
-	return c.DefaultParameterCapability.Serialize()
-}
-
-func (c *CapMultiProtocol) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Code  BGPCapabilityCode `json:"code"`
-		Value RouteFamily       `json:"value"`
-	}{
-		Code:  c.Code(),
-		Value: c.CapValue,
-	})
-}
-
-func NewCapMultiProtocol(rf RouteFamily) *CapMultiProtocol {
-	return &CapMultiProtocol{
-		DefaultParameterCapability{
-			CapCode: BGP_CAP_MULTIPROTOCOL,
-		},
-		rf,
-	}
-}
-
-type CapRouteRefresh struct {
-	DefaultParameterCapability
-}
-
-func NewCapRouteRefresh() *CapRouteRefresh {
-	return &CapRouteRefresh{
-		DefaultParameterCapability{
-			CapCode: BGP_CAP_ROUTE_REFRESH,
-		},
-	}
-}
-
-type CapCarryingLabelInfo struct {
-	DefaultParameterCapability
-}
-
-func NewCapCarryingLabelInfo() *CapCarryingLabelInfo {
-	return &CapCarryingLabelInfo{
-		DefaultParameterCapability{
-			CapCode: BGP_CAP_CARRYING_LABEL_INFO,
-		},
-	}
-}
-
-type CapExtendedNexthopTuple struct {
-	NLRIAFI    uint16
-	NLRISAFI   uint16
-	NexthopAFI uint16
-}
-
-func (c *CapExtendedNexthopTuple) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		NLRIAddressFamily    RouteFamily `json:"nlri_address_family"`
-		NexthopAddressFamily uint16      `json:"nexthop_address_family"`
-	}{
-		NLRIAddressFamily:    AfiSafiToRouteFamily(c.NLRIAFI, uint8(c.NLRISAFI)),
-		NexthopAddressFamily: c.NexthopAFI,
-	})
-}
-
-func NewCapExtendedNexthopTuple(af RouteFamily, nexthop uint16) *CapExtendedNexthopTuple {
-	afi, safi := RouteFamilyToAfiSafi(af)
-	return &CapExtendedNexthopTuple{
-		NLRIAFI:    afi,
-		NLRISAFI:   uint16(safi),
-		NexthopAFI: nexthop,
-	}
-}
-
-type CapExtendedNexthop struct {
-	DefaultParameterCapability
-	Tuples []*CapExtendedNexthopTuple
-}
-
-func (c *CapExtendedNexthop) DecodeFromBytes(data []byte) error {
-	c.DefaultParameterCapability.DecodeFromBytes(data)
-	data = data[2:]
-	if len(data) < 6 {
-		return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityExtendedNexthop bytes available")
-	}
-	c.Tuples = []*CapExtendedNexthopTuple{}
-	for len(data) >= 6 {
-		t := &CapExtendedNexthopTuple{
-			binary.BigEndian.Uint16(data[0:2]),
-			binary.BigEndian.Uint16(data[2:4]),
-			binary.BigEndian.Uint16(data[4:6]),
-		}
-		c.Tuples = append(c.Tuples, t)
-		data = data[6:]
-	}
-	return nil
-}
-
-func (c *CapExtendedNexthop) Serialize() ([]byte, error) {
-	buf := make([]byte, len(c.Tuples)*6)
-	for i, t := range c.Tuples {
-		binary.BigEndian.PutUint16(buf[i*6:i*6+2], t.NLRIAFI)
-		binary.BigEndian.PutUint16(buf[i*6+2:i*6+4], t.NLRISAFI)
-		binary.BigEndian.PutUint16(buf[i*6+4:i*6+6], t.NexthopAFI)
-	}
-	c.DefaultParameterCapability.CapValue = buf
-	return c.DefaultParameterCapability.Serialize()
-}
-
-func (c *CapExtendedNexthop) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Code   BGPCapabilityCode          `json:"code"`
-		Tuples []*CapExtendedNexthopTuple `json:"tuples"`
-	}{
-		Code:   c.Code(),
-		Tuples: c.Tuples,
-	})
-}
-
-func NewCapExtendedNexthop(tuples []*CapExtendedNexthopTuple) *CapExtendedNexthop {
-	return &CapExtendedNexthop{
-		DefaultParameterCapability{
-			CapCode: BGP_CAP_EXTENDED_NEXTHOP,
-		},
-		tuples,
-	}
-}
-
-type CapGracefulRestartTuple struct {
-	AFI   uint16
-	SAFI  uint8
-	Flags uint8
-}
-
-func (c *CapGracefulRestartTuple) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		RouteFamily RouteFamily `json:"route_family"`
-		Flags       uint8       `json:"flags"`
-	}{
-		RouteFamily: AfiSafiToRouteFamily(c.AFI, c.SAFI),
-		Flags:       c.Flags,
-	})
-}
-
-func NewCapGracefulRestartTuple(rf RouteFamily, forward bool) *CapGracefulRestartTuple {
-	afi, safi := RouteFamilyToAfiSafi(rf)
-	flags := 0
-	if forward {
-		flags = 0x80
-	}
-	return &CapGracefulRestartTuple{
-		AFI:   afi,
-		SAFI:  safi,
-		Flags: uint8(flags),
-	}
-}
-
-type CapGracefulRestart struct {
-	DefaultParameterCapability
-	Flags  uint8
-	Time   uint16
-	Tuples []*CapGracefulRestartTuple
-}
-
-func (c *CapGracefulRestart) DecodeFromBytes(data []byte) error {
-	c.DefaultParameterCapability.DecodeFromBytes(data)
-	data = data[2:]
-	if len(data) < 2 {
-		return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityGracefulRestart bytes available")
-	}
-	restart := binary.BigEndian.Uint16(data[0:2])
-	c.Flags = uint8(restart >> 12)
-	c.Time = restart & 0xfff
-	data = data[2:]
-
-	valueLen := int(c.CapLen) - 2
-
-	if valueLen >= 4 && len(data) >= valueLen {
-		c.Tuples = make([]*CapGracefulRestartTuple, 0, valueLen/4)
-
-		for i := valueLen; i >= 4; i -= 4 {
-			t := &CapGracefulRestartTuple{binary.BigEndian.Uint16(data[0:2]),
-				data[2], data[3]}
-			c.Tuples = append(c.Tuples, t)
-			data = data[4:]
-		}
-	}
-	return nil
-}
-
-func (c *CapGracefulRestart) Serialize() ([]byte, error) {
-	buf := make([]byte, 2)
-	binary.BigEndian.PutUint16(buf[0:], uint16(c.Flags)<<12|c.Time)
-	for _, t := range c.Tuples {
-		tbuf := make([]byte, 4)
-		binary.BigEndian.PutUint16(tbuf[0:2], t.AFI)
-		tbuf[2] = t.SAFI
-		tbuf[3] = t.Flags
-		buf = append(buf, tbuf...)
-	}
-	c.DefaultParameterCapability.CapValue = buf
-	return c.DefaultParameterCapability.Serialize()
-}
-
-func (c *CapGracefulRestart) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Code   BGPCapabilityCode          `json:"code"`
-		Flags  uint8                      `json:"flags"`
-		Time   uint16                     `json:"time"`
-		Tuples []*CapGracefulRestartTuple `json:"tuples"`
-	}{
-		Code:   c.Code(),
-		Flags:  c.Flags,
-		Time:   c.Time,
-		Tuples: c.Tuples,
-	})
-}
-
-func NewCapGracefulRestart(restarting, notification bool, time uint16, tuples []*CapGracefulRestartTuple) *CapGracefulRestart {
-	flags := 0
-	if restarting {
-		flags = 0x08
-	}
-	if notification {
-		flags |= 0x04
-	}
-	return &CapGracefulRestart{
-		DefaultParameterCapability: DefaultParameterCapability{
-			CapCode: BGP_CAP_GRACEFUL_RESTART,
-		},
-		Flags:  uint8(flags),
-		Time:   time,
-		Tuples: tuples,
-	}
-}
-
-type CapFourOctetASNumber struct {
-	DefaultParameterCapability
-	CapValue uint32
-}
-
-func (c *CapFourOctetASNumber) DecodeFromBytes(data []byte) error {
-	c.DefaultParameterCapability.DecodeFromBytes(data)
-	data = data[2:]
-	if len(data) < 4 {
-		return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityFourOctetASNumber bytes available")
-	}
-	c.CapValue = binary.BigEndian.Uint32(data[0:4])
-	return nil
-}
-
-func (c *CapFourOctetASNumber) Serialize() ([]byte, error) {
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint32(buf, c.CapValue)
-	c.DefaultParameterCapability.CapValue = buf
-	return c.DefaultParameterCapability.Serialize()
-}
-
-func (c *CapFourOctetASNumber) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Code  BGPCapabilityCode `json:"code"`
-		Value uint32            `json:"value"`
-	}{
-		Code:  c.Code(),
-		Value: c.CapValue,
-	})
-}
-
-func NewCapFourOctetASNumber(asnum uint32) *CapFourOctetASNumber {
-	return &CapFourOctetASNumber{
-		DefaultParameterCapability{
-			CapCode: BGP_CAP_FOUR_OCTET_AS_NUMBER,
-		},
-		asnum,
-	}
-}
-
-type BGPAddPathMode uint8
-
-const (
-	BGP_ADD_PATH_NONE BGPAddPathMode = iota
-	BGP_ADD_PATH_RECEIVE
-	BGP_ADD_PATH_SEND
-	BGP_ADD_PATH_BOTH
-)
-
-func (m BGPAddPathMode) String() string {
-	switch m {
-	case BGP_ADD_PATH_NONE:
-		return "none"
-	case BGP_ADD_PATH_RECEIVE:
-		return "receive"
-	case BGP_ADD_PATH_SEND:
-		return "send"
-	case BGP_ADD_PATH_BOTH:
-		return "receive/send"
-	default:
-		return fmt.Sprintf("unknown(%d)", m)
-	}
-}
-
-type CapAddPathTuple struct {
-	RouteFamily RouteFamily
-	Mode        BGPAddPathMode
-}
-
-func (t *CapAddPathTuple) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		RouteFamily RouteFamily `json:"family"`
-		Mode        uint8       `json:"mode"`
-	}{
-		RouteFamily: t.RouteFamily,
-		Mode:        uint8(t.Mode),
-	})
-}
-
-func NewCapAddPathTuple(family RouteFamily, mode BGPAddPathMode) *CapAddPathTuple {
-	return &CapAddPathTuple{
-		RouteFamily: family,
-		Mode:        mode,
-	}
-}
-
-type CapAddPath struct {
-	DefaultParameterCapability
-	Tuples []*CapAddPathTuple
-}
-
-func (c *CapAddPath) DecodeFromBytes(data []byte) error {
-	c.DefaultParameterCapability.DecodeFromBytes(data)
-	data = data[2:]
-	if len(data) < 4 {
-		return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all CapabilityAddPath bytes available")
-	}
-	c.Tuples = []*CapAddPathTuple{}
-	for len(data) >= 4 {
-		t := &CapAddPathTuple{
-			RouteFamily: AfiSafiToRouteFamily(binary.BigEndian.Uint16(data[:2]), data[2]),
-			Mode:        BGPAddPathMode(data[3]),
-		}
-		c.Tuples = append(c.Tuples, t)
-		data = data[4:]
-	}
-	return nil
-}
-
-func (c *CapAddPath) Serialize() ([]byte, error) {
-	buf := make([]byte, len(c.Tuples)*4)
-	for i, t := range c.Tuples {
-		afi, safi := RouteFamilyToAfiSafi(t.RouteFamily)
-		binary.BigEndian.PutUint16(buf[i*4:i*4+2], afi)
-		buf[i*4+2] = safi
-		buf[i*4+3] = byte(t.Mode)
-	}
-	c.DefaultParameterCapability.CapValue = buf
-	return c.DefaultParameterCapability.Serialize()
-}
-
-func (c *CapAddPath) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Code   BGPCapabilityCode  `json:"code"`
-		Tuples []*CapAddPathTuple `json:"tuples"`
-	}{
-		Code:   c.Code(),
-		Tuples: c.Tuples,
-	})
-}
-
-func NewCapAddPath(tuples []*CapAddPathTuple) *CapAddPath {
-	return &CapAddPath{
-		DefaultParameterCapability: DefaultParameterCapability{
-			CapCode: BGP_CAP_ADD_PATH,
-		},
-		Tuples: tuples,
-	}
-}
-
-type CapEnhancedRouteRefresh struct {
-	DefaultParameterCapability
-}
-
-func NewCapEnhancedRouteRefresh() *CapEnhancedRouteRefresh {
-	return &CapEnhancedRouteRefresh{
-		DefaultParameterCapability{
-			CapCode: BGP_CAP_ENHANCED_ROUTE_REFRESH,
-		},
-	}
-}
-
-type CapRouteRefreshCisco struct {
-	DefaultParameterCapability
-}
-
-func NewCapRouteRefreshCisco() *CapRouteRefreshCisco {
-	return &CapRouteRefreshCisco{
-		DefaultParameterCapability{
-			CapCode: BGP_CAP_ROUTE_REFRESH_CISCO,
-		},
-	}
-}
-
-type CapLongLivedGracefulRestartTuple struct {
-	AFI         uint16
-	SAFI        uint8
-	Flags       uint8
-	RestartTime uint32
-}
-
-func (c *CapLongLivedGracefulRestartTuple) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		RouteFamily RouteFamily `json:"route_family"`
-		Flags       uint8       `json:"flags"`
-		RestartTime uint32      `json:"restart_time"`
-	}{
-		RouteFamily: AfiSafiToRouteFamily(c.AFI, c.SAFI),
-		Flags:       c.Flags,
-		RestartTime: c.RestartTime,
-	})
-}
-
-func NewCapLongLivedGracefulRestartTuple(rf RouteFamily, forward bool, restartTime uint32) *CapLongLivedGracefulRestartTuple {
-	afi, safi := RouteFamilyToAfiSafi(rf)
-	flags := 0
-	if forward {
-		flags = 0x80
-	}
-	return &CapLongLivedGracefulRestartTuple{
-		AFI:         afi,
-		SAFI:        safi,
-		Flags:       uint8(flags),
-		RestartTime: restartTime,
-	}
-}
-
-type CapLongLivedGracefulRestart struct {
-	DefaultParameterCapability
-	Tuples []*CapLongLivedGracefulRestartTuple
-}
-
-func (c *CapLongLivedGracefulRestart) DecodeFromBytes(data []byte) error {
-	c.DefaultParameterCapability.DecodeFromBytes(data)
-	data = data[2:]
-
-	valueLen := int(c.CapLen)
-	if valueLen%7 != 0 || len(data) < valueLen {
-		return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "invalid length of long lived graceful restart capablity")
-	}
-	for i := valueLen; i >= 7; i -= 7 {
-		t := &CapLongLivedGracefulRestartTuple{
-			binary.BigEndian.Uint16(data),
-			data[2],
-			data[3],
-			uint32(data[4])<<16 | uint32(data[5])<<8 | uint32(data[6]),
-		}
-		c.Tuples = append(c.Tuples, t)
-		data = data[7:]
-	}
-	return nil
-}
-
-func (c *CapLongLivedGracefulRestart) Serialize() ([]byte, error) {
-	buf := make([]byte, 7*len(c.Tuples))
-	for idx, t := range c.Tuples {
-		binary.BigEndian.PutUint16(buf[idx*7:], t.AFI)
-		buf[idx*7+2] = t.SAFI
-		buf[idx*7+3] = t.Flags
-		buf[idx*7+4] = uint8((t.RestartTime >> 16) & 0xff)
-		buf[idx*7+5] = uint8((t.RestartTime >> 8) & 0xff)
-		buf[idx*7+6] = uint8(t.RestartTime & 0xff)
-	}
-	c.DefaultParameterCapability.CapValue = buf
-	return c.DefaultParameterCapability.Serialize()
-}
-
-func (c *CapLongLivedGracefulRestart) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Code   BGPCapabilityCode                   `json:"code"`
-		Tuples []*CapLongLivedGracefulRestartTuple `json:"tuples"`
-	}{
-		Code:   c.Code(),
-		Tuples: c.Tuples,
-	})
-}
-
-func NewCapLongLivedGracefulRestart(tuples []*CapLongLivedGracefulRestartTuple) *CapLongLivedGracefulRestart {
-	return &CapLongLivedGracefulRestart{
-		DefaultParameterCapability: DefaultParameterCapability{
-			CapCode: BGP_CAP_LONG_LIVED_GRACEFUL_RESTART,
-		},
-		Tuples: tuples,
-	}
-}
-
-type CapUnknown struct {
-	DefaultParameterCapability
-}
-
-func NewCapUnknown(code BGPCapabilityCode, value []byte) *CapUnknown {
-	return &CapUnknown{
-		DefaultParameterCapability{
-			CapCode:  code,
-			CapValue: value,
-		},
-	}
-}
-
-func DecodeCapability(data []byte) (ParameterCapabilityInterface, error) {
-	if len(data) < 2 {
-		return nil, NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY, nil, "Not all ParameterCapability bytes available")
-	}
-	var c ParameterCapabilityInterface
-	switch BGPCapabilityCode(data[0]) {
-	case BGP_CAP_MULTIPROTOCOL:
-		c = &CapMultiProtocol{}
-	case BGP_CAP_ROUTE_REFRESH:
-		c = &CapRouteRefresh{}
-	case BGP_CAP_CARRYING_LABEL_INFO:
-		c = &CapCarryingLabelInfo{}
-	case BGP_CAP_EXTENDED_NEXTHOP:
-		c = &CapExtendedNexthop{}
-	case BGP_CAP_GRACEFUL_RESTART:
-		c = &CapGracefulRestart{}
-	case BGP_CAP_FOUR_OCTET_AS_NUMBER:
-		c = &CapFourOctetASNumber{}
-	case BGP_CAP_ADD_PATH:
-		c = &CapAddPath{}
-	case BGP_CAP_ENHANCED_ROUTE_REFRESH:
-		c = &CapEnhancedRouteRefresh{}
-	case BGP_CAP_ROUTE_REFRESH_CISCO:
-		c = &CapRouteRefreshCisco{}
-	case BGP_CAP_LONG_LIVED_GRACEFUL_RESTART:
-		c = &CapLongLivedGracefulRestart{}
-	default:
-		c = &CapUnknown{}
-	}
-	err := c.DecodeFromBytes(data)
-	return c, err
-}
-
-type OptionParameterInterface interface {
-	Serialize() ([]byte, error)
-}
-
-type OptionParameterCapability struct {
-	ParamType  uint8
-	ParamLen   uint8
-	Capability []ParameterCapabilityInterface
-}
-
-func (o *OptionParameterCapability) DecodeFromBytes(data []byte) error {
-	if uint8(len(data)) < o.ParamLen {
-		return NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_OPTIONAL_PARAMETER, nil, "Not all OptionParameterCapability bytes available")
-	}
-	for len(data) >= 2 {
-		c, err := DecodeCapability(data)
-		if err != nil {
-			return err
-		}
-		o.Capability = append(o.Capability, c)
-		data = data[c.Len():]
-	}
-	return nil
-}
-
-func (o *OptionParameterCapability) Serialize() ([]byte, error) {
-	buf := make([]byte, 2)
-	buf[0] = o.ParamType
-	for _, p := range o.Capability {
-		pbuf, err := p.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, pbuf...)
-	}
-	o.ParamLen = uint8(len(buf) - 2)
-	buf[1] = o.ParamLen
-	return buf, nil
-}
-
-func NewOptionParameterCapability(capability []ParameterCapabilityInterface) *OptionParameterCapability {
-	return &OptionParameterCapability{
-		ParamType:  BGP_OPT_CAPABILITY,
-		Capability: capability,
-	}
-}
-
-type OptionParameterUnknown struct {
-	ParamType uint8
-	ParamLen  uint8
-	Value     []byte
-}
-
-func (o *OptionParameterUnknown) Serialize() ([]byte, error) {
-	buf := make([]byte, 2)
-	buf[0] = o.ParamType
-	if o.ParamLen == 0 {
-		o.ParamLen = uint8(len(o.Value))
-	}
-	buf[1] = o.ParamLen
-	return append(buf, o.Value...), nil
-}
-
-type BGPOpen struct {
-	Version     uint8
-	MyAS        uint16
-	HoldTime    uint16
-	ID          net.IP
-	OptParamLen uint8
-	OptParams   []OptionParameterInterface
-}
-
-func (msg *BGPOpen) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if len(data) < 10 {
-		return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Not all BGP Open message bytes available")
-	}
-	msg.Version = data[0]
-	msg.MyAS = binary.BigEndian.Uint16(data[1:3])
-	msg.HoldTime = binary.BigEndian.Uint16(data[3:5])
-	msg.ID = net.IP(data[5:9]).To4()
-	msg.OptParamLen = data[9]
-	data = data[10:]
-	if len(data) < int(msg.OptParamLen) {
-		return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Not all BGP Open message bytes available")
-	}
-
-	msg.OptParams = []OptionParameterInterface{}
-	for rest := msg.OptParamLen; rest > 0; {
-		if rest < 2 {
-			return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Malformed BGP Open message")
-		}
-		paramtype := data[0]
-		paramlen := data[1]
-		if rest < paramlen+2 {
-			return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Malformed BGP Open message")
-		}
-		rest -= paramlen + 2
-
-		if paramtype == BGP_OPT_CAPABILITY {
-			p := &OptionParameterCapability{}
-			p.ParamType = paramtype
-			p.ParamLen = paramlen
-			p.DecodeFromBytes(data[2 : 2+paramlen])
-			msg.OptParams = append(msg.OptParams, p)
-		} else {
-			p := &OptionParameterUnknown{}
-			p.ParamType = paramtype
-			p.ParamLen = paramlen
-			p.Value = data[2 : 2+paramlen]
-			msg.OptParams = append(msg.OptParams, p)
-		}
-		data = data[2+paramlen:]
-	}
-	return nil
-}
-
-func (msg *BGPOpen) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 10)
-	buf[0] = msg.Version
-	binary.BigEndian.PutUint16(buf[1:3], msg.MyAS)
-	binary.BigEndian.PutUint16(buf[3:5], msg.HoldTime)
-	copy(buf[5:9], msg.ID.To4())
-	pbuf := make([]byte, 0)
-	for _, p := range msg.OptParams {
-		onepbuf, err := p.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		pbuf = append(pbuf, onepbuf...)
-	}
-	msg.OptParamLen = uint8(len(pbuf))
-	buf[9] = msg.OptParamLen
-	return append(buf, pbuf...), nil
-}
-
-func NewBGPOpenMessage(myas uint16, holdtime uint16, id string, optparams []OptionParameterInterface) *BGPMessage {
-	return &BGPMessage{
-		Header: BGPHeader{Type: BGP_MSG_OPEN},
-		Body:   &BGPOpen{4, myas, holdtime, net.ParseIP(id).To4(), 0, optparams},
-	}
-}
-
-type AddrPrefixInterface interface {
-	DecodeFromBytes([]byte, ...*MarshallingOption) error
-	Serialize(...*MarshallingOption) ([]byte, error)
-	AFI() uint16
-	SAFI() uint8
-	Len(...*MarshallingOption) int
-	String() string
-	MarshalJSON() ([]byte, error)
-	// Create a flat map to describe attributes and their
-	// values. This can be used to create structured outputs.
-	Flat() map[string]string
-	PathIdentifier() uint32
-	SetPathIdentifier(uint32)
-	PathLocalIdentifier() uint32
-	SetPathLocalIdentifier(uint32)
-}
-
-func LabelString(nlri AddrPrefixInterface) string {
-	label := ""
-	switch n := nlri.(type) {
-	case *LabeledIPAddrPrefix:
-		label = n.Labels.String()
-	case *LabeledIPv6AddrPrefix:
-		label = n.Labels.String()
-	case *LabeledVPNIPAddrPrefix:
-		label = n.Labels.String()
-	case *LabeledVPNIPv6AddrPrefix:
-		label = n.Labels.String()
-	case *EVPNNLRI:
-		switch route := n.RouteTypeData.(type) {
-		case *EVPNEthernetAutoDiscoveryRoute:
-			label = fmt.Sprintf("[%d]", route.Label)
-		case *EVPNMacIPAdvertisementRoute:
-			var l []string
-			for _, i := range route.Labels {
-				l = append(l, strconv.Itoa(int(i)))
-			}
-			label = fmt.Sprintf("[%s]", strings.Join(l, ","))
-		case *EVPNIPPrefixRoute:
-			label = fmt.Sprintf("[%d]", route.Label)
-		}
-	}
-	return label
-}
-
-type PrefixDefault struct {
-	id      uint32
-	localId uint32
-}
-
-func (p *PrefixDefault) PathIdentifier() uint32 {
-	return p.id
-}
-
-func (p *PrefixDefault) SetPathIdentifier(id uint32) {
-	p.id = id
-}
-
-func (p *PrefixDefault) PathLocalIdentifier() uint32 {
-	return p.localId
-}
-
-func (p *PrefixDefault) SetPathLocalIdentifier(id uint32) {
-	p.localId = id
-}
-
-func (p *PrefixDefault) decodePathIdentifier(data []byte) ([]byte, error) {
-	if len(data) < 4 {
-		code := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		subcode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-		return nil, NewMessageError(code, subcode, nil, "prefix misses path identifier field")
-	}
-	p.SetPathIdentifier(binary.BigEndian.Uint32(data[:4]))
-	return data[4:], nil
-}
-
-func (p *PrefixDefault) serializeIdentifier() ([]byte, error) {
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint32(buf, p.PathLocalIdentifier())
-	return buf, nil
-}
-
-type IPAddrPrefixDefault struct {
-	PrefixDefault
-	Length uint8
-	Prefix net.IP
-}
-
-func (r *IPAddrPrefixDefault) decodePrefix(data []byte, bitlen uint8, addrlen uint8) error {
-	bytelen := (int(bitlen) + 7) / 8
-	if len(data) < bytelen {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-		return NewMessageError(eCode, eSubCode, nil, "network bytes is short")
-	}
-	b := make([]byte, addrlen)
-	copy(b, data[:bytelen])
-	// clear trailing bits in the last byte. rfc doesn't require
-	// this but some bgp implementations need this...
-	rem := bitlen % 8
-	if rem != 0 {
-		mask := 0xff00 >> rem
-		lastByte := b[bytelen-1] & byte(mask)
-		b[bytelen-1] = lastByte
-	}
-	r.Prefix = b
-	return nil
-}
-
-func (r *IPAddrPrefixDefault) serializePrefix(bitLen uint8) ([]byte, error) {
-	byteLen := (int(bitLen) + 7) / 8
-	buf := make([]byte, byteLen)
-	copy(buf, r.Prefix)
-	return buf, nil
-}
-
-func (r *IPAddrPrefixDefault) String() string {
-	return fmt.Sprintf("%s/%d", r.Prefix.String(), r.Length)
-}
-
-func (r *IPAddrPrefixDefault) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Prefix string `json:"prefix"`
-	}{
-		Prefix: r.String(),
-	})
-}
-
-type IPAddrPrefix struct {
-	IPAddrPrefixDefault
-	addrlen uint8
-}
-
-func (r *IPAddrPrefix) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if r.addrlen == 0 {
-		r.addrlen = 4
-	}
-	f := RF_IPv4_UC
-	if r.addrlen == 16 {
-		f = RF_IPv6_UC
-	}
-	if IsAddPathEnabled(true, f, options) {
-		var err error
-		data, err = r.decodePathIdentifier(data)
-		if err != nil {
-			return err
-		}
-	}
-	if len(data) < 1 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-		return NewMessageError(eCode, eSubCode, nil, "prefix misses length field")
-	}
-	r.Length = data[0]
-	return r.decodePrefix(data[1:], r.Length, r.addrlen)
-}
-
-func (r *IPAddrPrefix) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	f := RF_IPv4_UC
-	if r.addrlen == 16 {
-		f = RF_IPv6_UC
-	}
-	var buf []byte
-	if IsAddPathEnabled(false, f, options) {
-		var err error
-		buf, err = r.serializeIdentifier()
-		if err != nil {
-			return nil, err
-		}
-	}
-	buf = append(buf, r.Length)
-	pbuf, err := r.serializePrefix(r.Length)
-	if err != nil {
-		return nil, err
-	}
-	return append(buf, pbuf...), nil
-}
-
-func (r *IPAddrPrefix) AFI() uint16 {
-	return AFI_IP
-}
-
-func (r *IPAddrPrefix) SAFI() uint8 {
-	return SAFI_UNICAST
-}
-
-func (r *IPAddrPrefix) Len(options ...*MarshallingOption) int {
-	return 1 + ((int(r.Length) + 7) / 8)
-}
-
-func NewIPAddrPrefix(length uint8, prefix string) *IPAddrPrefix {
-	p := &IPAddrPrefix{
-		IPAddrPrefixDefault{
-			Length: length,
-		},
-		4,
-	}
-	p.IPAddrPrefixDefault.decodePrefix(net.ParseIP(prefix).To4(), length, 4)
-	return p
-}
-
-func isIPv4MappedIPv6(ip net.IP) bool {
-	return len(ip) == net.IPv6len && ip.To4() != nil
-}
-
-type IPv6AddrPrefix struct {
-	IPAddrPrefix
-}
-
-func (r *IPv6AddrPrefix) AFI() uint16 {
-	return AFI_IP6
-}
-
-func (r *IPv6AddrPrefix) String() string {
-	prefix := r.Prefix.String()
-	if isIPv4MappedIPv6(r.Prefix) {
-		prefix = "::ffff:" + prefix
-	}
-	return fmt.Sprintf("%s/%d", prefix, r.Length)
-}
-
-func NewIPv6AddrPrefix(length uint8, prefix string) *IPv6AddrPrefix {
-	p := &IPv6AddrPrefix{
-		IPAddrPrefix{
-			IPAddrPrefixDefault{
-				Length: length,
-			},
-			16,
-		},
-	}
-	p.IPAddrPrefixDefault.decodePrefix(net.ParseIP(prefix), length, 16)
-	return p
-}
-
-const (
-	BGP_RD_TWO_OCTET_AS = iota
-	BGP_RD_IPV4_ADDRESS
-	BGP_RD_FOUR_OCTET_AS
-)
-
-type RouteDistinguisherInterface interface {
-	DecodeFromBytes([]byte) error
-	Serialize() ([]byte, error)
-	Len() int
-	String() string
-	MarshalJSON() ([]byte, error)
-}
-
-type DefaultRouteDistinguisher struct {
-	Type uint16
-}
-
-func (rd *DefaultRouteDistinguisher) serialize(value []byte) ([]byte, error) {
-	buf := make([]byte, 8)
-	binary.BigEndian.PutUint16(buf, rd.Type)
-	copy(buf[2:], value)
-	return buf, nil
-}
-
-func (rd *DefaultRouteDistinguisher) Len() int {
-	return 8
-}
-
-type RouteDistinguisherTwoOctetAS struct {
-	DefaultRouteDistinguisher
-	Admin    uint16
-	Assigned uint32
-}
-
-func (rd *RouteDistinguisherTwoOctetAS) DecodeFromBytes(data []byte) error {
-	rd.Admin = binary.BigEndian.Uint16(data[0:2])
-	rd.Assigned = binary.BigEndian.Uint32(data[2:6])
-	return nil
-}
-
-func (rd *RouteDistinguisherTwoOctetAS) Serialize() ([]byte, error) {
-	buf := make([]byte, 6)
-	binary.BigEndian.PutUint16(buf[0:2], rd.Admin)
-	binary.BigEndian.PutUint32(buf[2:6], rd.Assigned)
-	return rd.serialize(buf)
-}
-
-func (rd *RouteDistinguisherTwoOctetAS) String() string {
-	return fmt.Sprintf("%d:%d", rd.Admin, rd.Assigned)
-}
-
-func (rd *RouteDistinguisherTwoOctetAS) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type     uint16 `json:"type"`
-		Admin    uint16 `json:"admin"`
-		Assigned uint32 `json:"assigned"`
-	}{
-		Type:     rd.Type,
-		Admin:    rd.Admin,
-		Assigned: rd.Assigned,
-	})
-}
-
-func NewRouteDistinguisherTwoOctetAS(admin uint16, assigned uint32) *RouteDistinguisherTwoOctetAS {
-	return &RouteDistinguisherTwoOctetAS{
-		DefaultRouteDistinguisher: DefaultRouteDistinguisher{
-			Type: BGP_RD_TWO_OCTET_AS,
-		},
-		Admin:    admin,
-		Assigned: assigned,
-	}
-}
-
-type RouteDistinguisherIPAddressAS struct {
-	DefaultRouteDistinguisher
-	Admin    net.IP
-	Assigned uint16
-}
-
-func (rd *RouteDistinguisherIPAddressAS) DecodeFromBytes(data []byte) error {
-	rd.Admin = data[0:4]
-	rd.Assigned = binary.BigEndian.Uint16(data[4:6])
-	return nil
-}
-
-func (rd *RouteDistinguisherIPAddressAS) Serialize() ([]byte, error) {
-	buf := make([]byte, 6)
-	copy(buf[0:4], rd.Admin.To4())
-	binary.BigEndian.PutUint16(buf[4:6], rd.Assigned)
-	return rd.serialize(buf)
-}
-
-func (rd *RouteDistinguisherIPAddressAS) String() string {
-	return fmt.Sprintf("%s:%d", rd.Admin.String(), rd.Assigned)
-}
-
-func (rd *RouteDistinguisherIPAddressAS) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type     uint16 `json:"type"`
-		Admin    string `json:"admin"`
-		Assigned uint16 `json:"assigned"`
-	}{
-		Type:     rd.Type,
-		Admin:    rd.Admin.String(),
-		Assigned: rd.Assigned,
-	})
-}
-
-func NewRouteDistinguisherIPAddressAS(admin string, assigned uint16) *RouteDistinguisherIPAddressAS {
-	return &RouteDistinguisherIPAddressAS{
-		DefaultRouteDistinguisher: DefaultRouteDistinguisher{
-			Type: BGP_RD_IPV4_ADDRESS,
-		},
-		Admin:    net.ParseIP(admin).To4(),
-		Assigned: assigned,
-	}
-}
-
-type RouteDistinguisherFourOctetAS struct {
-	DefaultRouteDistinguisher
-	Admin    uint32
-	Assigned uint16
-}
-
-func (rd *RouteDistinguisherFourOctetAS) DecodeFromBytes(data []byte) error {
-	rd.Admin = binary.BigEndian.Uint32(data[0:4])
-	rd.Assigned = binary.BigEndian.Uint16(data[4:6])
-	return nil
-}
-
-func (rd *RouteDistinguisherFourOctetAS) Serialize() ([]byte, error) {
-	buf := make([]byte, 6)
-	binary.BigEndian.PutUint32(buf[0:4], rd.Admin)
-	binary.BigEndian.PutUint16(buf[4:6], rd.Assigned)
-	return rd.serialize(buf)
-}
-
-func (rd *RouteDistinguisherFourOctetAS) String() string {
-	fst := rd.Admin >> 16 & 0xffff
-	snd := rd.Admin & 0xffff
-	return fmt.Sprintf("%d.%d:%d", fst, snd, rd.Assigned)
-}
-
-func (rd *RouteDistinguisherFourOctetAS) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type     uint16 `json:"type"`
-		Admin    uint32 `json:"admin"`
-		Assigned uint16 `json:"assigned"`
-	}{
-		Type:     rd.Type,
-		Admin:    rd.Admin,
-		Assigned: rd.Assigned,
-	})
-}
-
-func NewRouteDistinguisherFourOctetAS(admin uint32, assigned uint16) *RouteDistinguisherFourOctetAS {
-	return &RouteDistinguisherFourOctetAS{
-		DefaultRouteDistinguisher: DefaultRouteDistinguisher{
-			Type: BGP_RD_FOUR_OCTET_AS,
-		},
-		Admin:    admin,
-		Assigned: assigned,
-	}
-}
-
-type RouteDistinguisherUnknown struct {
-	DefaultRouteDistinguisher
-	Value []byte
-}
-
-func (rd *RouteDistinguisherUnknown) DecodeFromBytes(data []byte) error {
-	rd.Value = data[0:6]
-	return nil
-}
-
-func (rd *RouteDistinguisherUnknown) Serialize() ([]byte, error) {
-	return rd.DefaultRouteDistinguisher.serialize(rd.Value)
-}
-
-func (rd *RouteDistinguisherUnknown) String() string {
-	return fmt.Sprintf("%v", rd.Value)
-}
-
-func (rd *RouteDistinguisherUnknown) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  uint16 `json:"type"`
-		Value []byte `json:"value"`
-	}{
-		Type:  rd.Type,
-		Value: rd.Value,
-	})
-}
-
-func GetRouteDistinguisher(data []byte) RouteDistinguisherInterface {
-	typ := binary.BigEndian.Uint16(data[0:2])
-	switch typ {
-	case BGP_RD_TWO_OCTET_AS:
-		return NewRouteDistinguisherTwoOctetAS(binary.BigEndian.Uint16(data[2:4]), binary.BigEndian.Uint32(data[4:8]))
-	case BGP_RD_IPV4_ADDRESS:
-		return NewRouteDistinguisherIPAddressAS(net.IP(data[2:6]).String(), binary.BigEndian.Uint16(data[6:8]))
-	case BGP_RD_FOUR_OCTET_AS:
-		return NewRouteDistinguisherFourOctetAS(binary.BigEndian.Uint32(data[2:6]), binary.BigEndian.Uint16(data[6:8]))
-	}
-	rd := &RouteDistinguisherUnknown{
-		DefaultRouteDistinguisher: DefaultRouteDistinguisher{
-			Type: typ,
-		},
-	}
-	return rd
-}
-
-func parseRdAndRt(input string) ([]string, error) {
-	elems := _regexpRouteDistinguisher.FindStringSubmatch(input)
-	if len(elems) != 11 {
-		return nil, fmt.Errorf("failed to parse")
-	}
-	return elems, nil
-}
-
-func ParseRouteDistinguisher(rd string) (RouteDistinguisherInterface, error) {
-	elems, err := parseRdAndRt(rd)
-	if err != nil {
-		return nil, err
-	}
-	assigned, _ := strconv.ParseUint(elems[10], 10, 32)
-	ip := net.ParseIP(elems[1])
-	switch {
-	case ip.To4() != nil:
-		return NewRouteDistinguisherIPAddressAS(elems[1], uint16(assigned)), nil
-	case elems[6] == "" && elems[7] == "":
-		asn, _ := strconv.ParseUint(elems[8], 10, 16)
-		return NewRouteDistinguisherTwoOctetAS(uint16(asn), uint32(assigned)), nil
-	default:
-		fst, _ := strconv.ParseUint(elems[7], 10, 16)
-		snd, _ := strconv.ParseUint(elems[8], 10, 16)
-		asn := fst<<16 | snd
-		return NewRouteDistinguisherFourOctetAS(uint32(asn), uint16(assigned)), nil
-	}
-}
-
-//
-// RFC3107 Carrying Label Information in BGP-4
-//
-// 3. Carrying Label Mapping Information
-//
-// b) Label:
-//
-// The Label field carries one or more labels (that corresponds to
-// the stack of labels [MPLS-ENCAPS(RFC3032)]). Each label is encoded as
-// 4 octets, where the high-order 20 bits contain the label value, and
-// the low order bit contains "Bottom of Stack"
-//
-// RFC3032 MPLS Label Stack Encoding
-//
-// 2.1. Encoding the Label Stack
-//
-//  0       1       2               3
-//  0 ... 9 0 ... 9 0 1 2 3 4 ... 9 0 1
-// +-----+-+-+---+-+-+-+-+-+-----+-+-+-+
-// |     Label     | Exp |S|    TTL    |
-// +-----+-+-+---+-+-+-+-+-+-----+-+-+-+
-//
-
-// RFC3107 Carrying Label Information in BGP-4
-//
-// 3. Carrying Label Mapping Information
-//
-// The label information carried (as part of NLRI) in the Withdrawn
-// Routes field should be set to 0x800000.
-const WITHDRAW_LABEL = uint32(0x800000)
-const ZERO_LABEL = uint32(0) // some platform uses this as withdraw label
-
-type MPLSLabelStack struct {
-	Labels []uint32
-}
-
-func (l *MPLSLabelStack) DecodeFromBytes(data []byte) error {
-	labels := []uint32{}
-	foundBottom := false
-	for len(data) >= 3 {
-		label := uint32(data[0])<<16 | uint32(data[1])<<8 | uint32(data[2])
-		if label == WITHDRAW_LABEL || label == ZERO_LABEL {
-			l.Labels = []uint32{label}
-			return nil
-		}
-		data = data[3:]
-		labels = append(labels, label>>4)
-		if label&1 == 1 {
-			foundBottom = true
-			break
-		}
-	}
-
-	if !foundBottom {
-		l.Labels = []uint32{}
-		return nil
-	}
-	l.Labels = labels
-	return nil
-}
-
-func (l *MPLSLabelStack) Serialize() ([]byte, error) {
-	buf := make([]byte, len(l.Labels)*3)
-	for i, label := range l.Labels {
-		if label == WITHDRAW_LABEL {
-			return []byte{128, 0, 0}, nil
-		}
-		label = label << 4
-		buf[i*3] = byte((label >> 16) & 0xff)
-		buf[i*3+1] = byte((label >> 8) & 0xff)
-		buf[i*3+2] = byte(label & 0xff)
-	}
-	buf[len(buf)-1] |= 1
-	return buf, nil
-}
-
-func (l *MPLSLabelStack) Len() int { return 3 * len(l.Labels) }
-
-func (l *MPLSLabelStack) String() string {
-	if len(l.Labels) == 0 {
-		return ""
-	}
-	s := bytes.NewBuffer(make([]byte, 0, 64))
-	s.WriteString("[")
-	ss := make([]string, 0, len(l.Labels))
-	for _, label := range l.Labels {
-		ss = append(ss, fmt.Sprintf("%d", label))
-	}
-	s.WriteString(strings.Join(ss, ", "))
-	s.WriteString("]")
-	return s.String()
-}
-
-func NewMPLSLabelStack(labels ...uint32) *MPLSLabelStack {
-	if len(labels) == 0 {
-		labels = []uint32{0}
-	}
-	return &MPLSLabelStack{labels}
-}
-
-func ParseMPLSLabelStack(buf string) (*MPLSLabelStack, error) {
-	elems := strings.Split(buf, "/")
-	labels := make([]uint32, 0, len(elems))
-	if len(elems) == 0 {
-		goto ERR
-	}
-	for _, elem := range elems {
-		i, err := strconv.ParseUint(elem, 10, 32)
-		if err != nil {
-			goto ERR
-		}
-		if i > ((1 << 20) - 1) {
-			goto ERR
-		}
-		labels = append(labels, uint32(i))
-	}
-	return NewMPLSLabelStack(labels...), nil
-ERR:
-	return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "invalid mpls label stack format")
-}
-
-//
-// RFC3107 Carrying Label Information in BGP-4
-//
-// 3. Carrying Label Mapping Information
-//
-// +----------------------+
-// |   Length (1 octet)   |
-// +----------------------+
-// |   Label (3 octets)   |
-// +----------------------+
-// .......................
-// +----------------------+
-// |   Prefix (variable)  |
-// +----------------------+
-//
-// RFC4364 BGP/MPLS IP VPNs
-//
-// 4.3.4. How VPN-IPv4 NLRI Is Carried in BGP
-//
-// The labeled VPN-IPv4 NLRI itself is encoded as specified in
-// [MPLS-BGP(RFC3107)], where the prefix consists of an 8-byte RD
-// followed by an IPv4 prefix.
-//
-
-type LabeledVPNIPAddrPrefix struct {
-	IPAddrPrefixDefault
-	Labels  MPLSLabelStack
-	RD      RouteDistinguisherInterface
-	addrlen uint8
-}
-
-func (l *LabeledVPNIPAddrPrefix) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	f := RF_IPv4_VPN
-	if l.addrlen == 16 {
-		f = RF_IPv6_VPN
-	}
-	if IsAddPathEnabled(true, f, options) {
-		var err error
-		data, err = l.decodePathIdentifier(data)
-		if err != nil {
-			return err
-		}
-	}
-	if len(data) < 1 {
-		return NewMessageError(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST), nil, "prefix misses length field")
-	}
-	l.Length = uint8(data[0])
-	data = data[1:]
-	l.Labels.DecodeFromBytes(data)
-	if int(l.Length)-8*(l.Labels.Len()) < 0 {
-		l.Labels.Labels = []uint32{}
-	}
-	data = data[l.Labels.Len():]
-	l.RD = GetRouteDistinguisher(data)
-	data = data[l.RD.Len():]
-	restbits := int(l.Length) - 8*(l.Labels.Len()+l.RD.Len())
-	return l.decodePrefix(data, uint8(restbits), l.addrlen)
-}
-
-func (l *LabeledVPNIPAddrPrefix) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	f := RF_IPv4_VPN
-	if l.addrlen == 16 {
-		f = RF_IPv6_VPN
-	}
-	var buf []byte
-	if IsAddPathEnabled(false, f, options) {
-		var err error
-		buf, err = l.serializeIdentifier()
-		if err != nil {
-			return nil, err
-		}
-	}
-	buf = append(buf, l.Length)
-	lbuf, err := l.Labels.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, lbuf...)
-	rbuf, err := l.RD.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, rbuf...)
-	restbits := int(l.Length) - 8*(l.Labels.Len()+l.RD.Len())
-	pbuf, err := l.serializePrefix(uint8(restbits))
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, pbuf...)
-	return buf, nil
-}
-
-func (l *LabeledVPNIPAddrPrefix) AFI() uint16 {
-	return AFI_IP
-}
-
-func (l *LabeledVPNIPAddrPrefix) SAFI() uint8 {
-	return SAFI_MPLS_VPN
-}
-
-func (l *LabeledVPNIPAddrPrefix) IPPrefixLen() uint8 {
-	return l.Length - 8*uint8(l.Labels.Len()+l.RD.Len())
-}
-
-func (l *LabeledVPNIPAddrPrefix) Len(options ...*MarshallingOption) int {
-	return 1 + l.Labels.Len() + l.RD.Len() + int((l.IPPrefixLen()+7)/8)
-}
-
-func (l *LabeledVPNIPAddrPrefix) String() string {
-	return fmt.Sprintf("%s:%s", l.RD, l.IPPrefix())
-}
-
-func (l *LabeledVPNIPAddrPrefix) IPPrefix() string {
-	masklen := l.IPAddrPrefixDefault.Length - uint8(8*(l.Labels.Len()+l.RD.Len()))
-	return fmt.Sprintf("%s/%d", l.IPAddrPrefixDefault.Prefix, masklen)
-}
-
-func (l *LabeledVPNIPAddrPrefix) MarshalJSON() ([]byte, error) {
-	masklen := l.IPAddrPrefixDefault.Length - uint8(8*(l.Labels.Len()+l.RD.Len()))
-	return json.Marshal(struct {
-		Prefix string                      `json:"prefix"`
-		Labels []uint32                    `json:"labels"`
-		RD     RouteDistinguisherInterface `json:"rd"`
-	}{
-		Prefix: fmt.Sprintf("%s/%d", l.IPAddrPrefixDefault.Prefix, masklen),
-		Labels: l.Labels.Labels,
-		RD:     l.RD,
-	})
-}
-
-func NewLabeledVPNIPAddrPrefix(length uint8, prefix string, label MPLSLabelStack, rd RouteDistinguisherInterface) *LabeledVPNIPAddrPrefix {
-	rdlen := 0
-	if rd != nil {
-		rdlen = rd.Len()
-	}
-	return &LabeledVPNIPAddrPrefix{
-		IPAddrPrefixDefault{
-			Length: length + uint8(8*(label.Len()+rdlen)),
-			Prefix: net.ParseIP(prefix).To4(),
-		},
-		label,
-		rd,
-		4,
-	}
-}
-
-type LabeledVPNIPv6AddrPrefix struct {
-	LabeledVPNIPAddrPrefix
-}
-
-func (l *LabeledVPNIPv6AddrPrefix) AFI() uint16 {
-	return AFI_IP6
-}
-
-func NewLabeledVPNIPv6AddrPrefix(length uint8, prefix string, label MPLSLabelStack, rd RouteDistinguisherInterface) *LabeledVPNIPv6AddrPrefix {
-	rdlen := 0
-	if rd != nil {
-		rdlen = rd.Len()
-	}
-	return &LabeledVPNIPv6AddrPrefix{
-		LabeledVPNIPAddrPrefix{
-			IPAddrPrefixDefault{
-				Length: length + uint8(8*(label.Len()+rdlen)),
-				Prefix: net.ParseIP(prefix),
-			},
-			label,
-			rd,
-			16,
-		},
-	}
-}
-
-type LabeledIPAddrPrefix struct {
-	IPAddrPrefixDefault
-	Labels  MPLSLabelStack
-	addrlen uint8
-}
-
-func (r *LabeledIPAddrPrefix) AFI() uint16 {
-	return AFI_IP
-}
-
-func (r *LabeledIPAddrPrefix) SAFI() uint8 {
-	return SAFI_MPLS_LABEL
-}
-
-func (l *LabeledIPAddrPrefix) IPPrefixLen() uint8 {
-	return l.Length - 8*uint8(l.Labels.Len())
-}
-
-func (l *LabeledIPAddrPrefix) Len(options ...*MarshallingOption) int {
-	return 1 + l.Labels.Len() + int((l.IPPrefixLen()+7)/8)
-}
-
-func (l *LabeledIPAddrPrefix) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	f := RF_IPv4_MPLS
-	if l.addrlen == 16 {
-		f = RF_IPv6_MPLS
-	}
-	if IsAddPathEnabled(true, f, options) {
-		var err error
-		data, err = l.decodePathIdentifier(data)
-		if err != nil {
-			return err
-		}
-	}
-	l.Length = uint8(data[0])
-	data = data[1:]
-	l.Labels.DecodeFromBytes(data)
-
-	if int(l.Length)-8*(l.Labels.Len()) < 0 {
-		l.Labels.Labels = []uint32{}
-	}
-	restbits := int(l.Length) - 8*(l.Labels.Len())
-	data = data[l.Labels.Len():]
-	return l.decodePrefix(data, uint8(restbits), l.addrlen)
-}
-
-func (l *LabeledIPAddrPrefix) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	f := RF_IPv4_MPLS
-	if l.addrlen == 16 {
-		f = RF_IPv6_MPLS
-	}
-	var buf []byte
-	if IsAddPathEnabled(false, f, options) {
-		var err error
-		buf, err = l.serializeIdentifier()
-		if err != nil {
-			return nil, err
-		}
-	}
-	buf = append(buf, l.Length)
-	restbits := int(l.Length) - 8*(l.Labels.Len())
-	lbuf, err := l.Labels.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, lbuf...)
-	pbuf, err := l.serializePrefix(uint8(restbits))
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, pbuf...)
-	return buf, nil
-}
-
-func (l *LabeledIPAddrPrefix) String() string {
-	prefix := l.Prefix.String()
-	if isIPv4MappedIPv6(l.Prefix) {
-		prefix = "::ffff:" + prefix
-	}
-	return fmt.Sprintf("%s/%d", prefix, int(l.Length)-l.Labels.Len()*8)
-}
-
-func (l *LabeledIPAddrPrefix) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Prefix string   `json:"prefix"`
-		Labels []uint32 `json:"labels"`
-	}{
-		Prefix: l.String(),
-		Labels: l.Labels.Labels,
-	})
-}
-
-func NewLabeledIPAddrPrefix(length uint8, prefix string, label MPLSLabelStack) *LabeledIPAddrPrefix {
-	return &LabeledIPAddrPrefix{
-		IPAddrPrefixDefault{
-			Length: length + uint8(label.Len()*8),
-			Prefix: net.ParseIP(prefix).To4(),
-		},
-		label,
-		4,
-	}
-}
-
-type LabeledIPv6AddrPrefix struct {
-	LabeledIPAddrPrefix
-}
-
-func (l *LabeledIPv6AddrPrefix) AFI() uint16 {
-	return AFI_IP6
-}
-
-func NewLabeledIPv6AddrPrefix(length uint8, prefix string, label MPLSLabelStack) *LabeledIPv6AddrPrefix {
-	return &LabeledIPv6AddrPrefix{
-		LabeledIPAddrPrefix{
-			IPAddrPrefixDefault{
-				Length: length + uint8(label.Len()*8),
-				Prefix: net.ParseIP(prefix),
-			},
-			label,
-			16,
-		},
-	}
-}
-
-type RouteTargetMembershipNLRI struct {
-	PrefixDefault
-	Length      uint8
-	AS          uint32
-	RouteTarget ExtendedCommunityInterface
-}
-
-func (n *RouteTargetMembershipNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if IsAddPathEnabled(true, RF_RTC_UC, options) {
-		var err error
-		data, err = n.decodePathIdentifier(data)
-		if err != nil {
-			return err
-		}
-	}
-	if len(data) < 1 {
-		return NewMessageError(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST), nil, "prefix misses length field")
-	}
-	n.Length = data[0]
-	data = data[1 : n.Length/8+1]
-	if len(data) == 0 {
-		return nil
-	} else if len(data) != 12 {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all RouteTargetMembershipNLRI bytes available")
-	}
-	n.AS = binary.BigEndian.Uint32(data[0:4])
-	rt, err := ParseExtended(data[4:])
-	n.RouteTarget = rt
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (n *RouteTargetMembershipNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	var buf []byte
-	if IsAddPathEnabled(false, RF_RTC_UC, options) {
-		var err error
-		buf, err = n.serializeIdentifier()
-		if err != nil {
-			return nil, err
-		}
-	}
-	if n.RouteTarget == nil {
-		return append(buf, 0), nil
-	}
-	offset := len(buf)
-	buf = append(buf, make([]byte, 5)...)
-	buf[offset] = 96
-	binary.BigEndian.PutUint32(buf[offset+1:], n.AS)
-	ebuf, err := n.RouteTarget.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	return append(buf, ebuf...), nil
-}
-
-func (n *RouteTargetMembershipNLRI) AFI() uint16 {
-	return AFI_IP
-}
-
-func (n *RouteTargetMembershipNLRI) SAFI() uint8 {
-	return SAFI_ROUTE_TARGET_CONSTRAINTS
-}
-
-func (n *RouteTargetMembershipNLRI) Len(options ...*MarshallingOption) int {
-	if n.AS == 0 && n.RouteTarget == nil {
-		return 1
-	}
-	return 13
-}
-
-func (n *RouteTargetMembershipNLRI) String() string {
-	target := "default"
-	if n.RouteTarget != nil {
-		target = n.RouteTarget.String()
-	}
-	return fmt.Sprintf("%d:%s", n.AS, target)
-}
-
-func (n *RouteTargetMembershipNLRI) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Prefix string `json:"prefix"`
-	}{
-		Prefix: n.String(),
-	})
-}
-
-func NewRouteTargetMembershipNLRI(as uint32, target ExtendedCommunityInterface) *RouteTargetMembershipNLRI {
-	l := 12 * 8
-	if as == 0 && target == nil {
-		l = 1
-	}
-	return &RouteTargetMembershipNLRI{
-		Length:      uint8(l),
-		AS:          as,
-		RouteTarget: target,
-	}
-}
-
-type ESIType uint8
-
-const (
-	ESI_ARBITRARY ESIType = iota
-	ESI_LACP
-	ESI_MSTP
-	ESI_MAC
-	ESI_ROUTERID
-	ESI_AS
-)
-
-type EthernetSegmentIdentifier struct {
-	Type  ESIType
-	Value []byte
-}
-
-func (esi *EthernetSegmentIdentifier) DecodeFromBytes(data []byte) error {
-	esi.Type = ESIType(data[0])
-	esi.Value = data[1:10]
-	switch esi.Type {
-	case ESI_LACP, ESI_MSTP, ESI_ROUTERID, ESI_AS:
-		if esi.Value[8] != 0x00 {
-			return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("invalid %s. last octet must be 0x00 (0x%02x)", esi.Type.String(), esi.Value[8]))
-		}
-	}
-	return nil
-}
-
-func (esi *EthernetSegmentIdentifier) Serialize() ([]byte, error) {
-	buf := make([]byte, 10)
-	buf[0] = uint8(esi.Type)
-	copy(buf[1:], esi.Value)
-	return buf, nil
-}
-
-func isZeroBuf(buf []byte) bool {
-	for _, b := range buf {
-		if b != 0 {
-			return false
-		}
-	}
-	return true
-}
-
-func (esi *EthernetSegmentIdentifier) String() string {
-	toHexArray := func(data []byte) string {
-		// Converts byte slice into the colon separated hex values and the
-		// number of elements are 9 at most (excluding Type field).
-		values := make([]string, 0, 9)
-		for _, v := range data {
-			values = append(values, fmt.Sprintf("%02x", v))
-		}
-		return strings.Join(values, ":")
-	}
-
-	s := bytes.NewBuffer(make([]byte, 0, 64))
-	s.WriteString(fmt.Sprintf("%s | ", esi.Type.String()))
-	switch esi.Type {
-	case ESI_LACP:
-		s.WriteString(fmt.Sprintf("system mac %s, ", net.HardwareAddr(esi.Value[:6]).String()))
-		s.WriteString(fmt.Sprintf("port key %d", binary.BigEndian.Uint16(esi.Value[6:8])))
-	case ESI_MSTP:
-		s.WriteString(fmt.Sprintf("bridge mac %s, ", net.HardwareAddr(esi.Value[:6]).String()))
-		s.WriteString(fmt.Sprintf("priority %d", binary.BigEndian.Uint16(esi.Value[6:8])))
-	case ESI_MAC:
-		s.WriteString(fmt.Sprintf("system mac %s, ", net.HardwareAddr(esi.Value[:6]).String()))
-		s.WriteString(fmt.Sprintf("local discriminator %d", uint32(esi.Value[6])<<16|uint32(esi.Value[7])<<8|uint32(esi.Value[8])))
-	case ESI_ROUTERID:
-		s.WriteString(fmt.Sprintf("router id %s, ", net.IP(esi.Value[:4])))
-		s.WriteString(fmt.Sprintf("local discriminator %d", binary.BigEndian.Uint32(esi.Value[4:8])))
-	case ESI_AS:
-		s.WriteString(fmt.Sprintf("as %d, ", binary.BigEndian.Uint32(esi.Value[:4])))
-		s.WriteString(fmt.Sprintf("local discriminator %d", binary.BigEndian.Uint32(esi.Value[4:8])))
-	case ESI_ARBITRARY:
-		if isZeroBuf(esi.Value) {
-			return "single-homed"
-		}
-		fallthrough
-	default:
-		s.WriteString(toHexArray(esi.Value))
-	}
-	return s.String()
-}
-
-// Decode Ethernet Segment Identifier (ESI) from string slice.
-//
-// The first element of args should be the Type field (e.g., "ARBITRARY",
-// "arbitrary", "ESI_ARBITRARY" or "esi_arbitrary") and "single-homed" is
-// the special keyword for all zeroed ESI.
-// For the "ARBITRARY" Value field (Type 0), it should be the colon separated
-// hex values and the number of elements should be 9 at most.
-//   e.g.) args := []string{"ARBITRARY", "11:22:33:44:55:66:77:88:99"}
-// For the other types, the Value field format is the similar to the string
-// format of ESI.
-//   e.g.) args := []string{"lacp", "aa:bb:cc:dd:ee:ff", "100"}
-func ParseEthernetSegmentIdentifier(args []string) (EthernetSegmentIdentifier, error) {
-	esi := EthernetSegmentIdentifier{}
-	argLen := len(args)
-	if argLen == 0 || args[0] == "single-homed" {
-		return esi, nil
-	}
-
-	typeStr := strings.TrimPrefix(strings.ToUpper(args[0]), "ESI_")
-	switch typeStr {
-	case "ARBITRARY":
-		esi.Type = ESI_ARBITRARY
-	case "LACP":
-		esi.Type = ESI_LACP
-	case "MSTP":
-		esi.Type = ESI_MSTP
-	case "MAC":
-		esi.Type = ESI_MAC
-	case "ROUTERID":
-		esi.Type = ESI_ROUTERID
-	case "AS":
-		esi.Type = ESI_AS
-	default:
-		typ, err := strconv.ParseUint(args[0], 10, 8)
-		if err != nil {
-			return esi, fmt.Errorf("invalid esi type: %s", args[0])
-		}
-		esi.Type = ESIType(typ)
-	}
-
-	invalidEsiValuesError := fmt.Errorf("invalid esi values for type %s: %s", esi.Type.String(), args[1:])
-	esi.Value = make([]byte, 9)
-	switch esi.Type {
-	case ESI_LACP:
-		fallthrough
-	case ESI_MSTP:
-		if argLen < 3 {
-			return esi, invalidEsiValuesError
-		}
-		// MAC
-		mac, err := net.ParseMAC(args[1])
-		if err != nil {
-			return esi, invalidEsiValuesError
-		}
-		copy(esi.Value[0:6], mac)
-		// Port Key or Bridge Priority
-		i, err := strconv.ParseUint(args[2], 10, 16)
-		if err != nil {
-			return esi, invalidEsiValuesError
-		}
-		binary.BigEndian.PutUint16(esi.Value[6:8], uint16(i))
-	case ESI_MAC:
-		if argLen < 3 {
-			return esi, invalidEsiValuesError
-		}
-		// MAC
-		mac, err := net.ParseMAC(args[1])
-		if err != nil {
-			return esi, invalidEsiValuesError
-		}
-		copy(esi.Value[0:6], mac)
-		// Local Discriminator
-		i, err := strconv.ParseUint(args[2], 10, 32)
-		if err != nil {
-			return esi, invalidEsiValuesError
-		}
-		iBuf := make([]byte, 4)
-		binary.BigEndian.PutUint32(iBuf, uint32(i))
-		copy(esi.Value[6:9], iBuf[1:4])
-	case ESI_ROUTERID:
-		if argLen < 3 {
-			return esi, invalidEsiValuesError
-		}
-		// Router ID
-		ip := net.ParseIP(args[1])
-		if ip == nil || ip.To4() == nil {
-			return esi, invalidEsiValuesError
-		}
-		copy(esi.Value[0:4], ip.To4())
-		// Local Discriminator
-		i, err := strconv.ParseUint(args[2], 10, 32)
-		if err != nil {
-			return esi, invalidEsiValuesError
-		}
-		binary.BigEndian.PutUint32(esi.Value[4:8], uint32(i))
-	case ESI_AS:
-		if argLen < 3 {
-			return esi, invalidEsiValuesError
-		}
-		// AS
-		as, err := strconv.ParseUint(args[1], 10, 32)
-		if err != nil {
-			return esi, invalidEsiValuesError
-		}
-		binary.BigEndian.PutUint32(esi.Value[0:4], uint32(as))
-		// Local Discriminator
-		i, err := strconv.ParseUint(args[2], 10, 32)
-		if err != nil {
-			return esi, invalidEsiValuesError
-		}
-		binary.BigEndian.PutUint32(esi.Value[4:8], uint32(i))
-	case ESI_ARBITRARY:
-		fallthrough
-	default:
-		if argLen < 2 {
-			// Assumes the Value field is omitted
-			break
-		}
-		values := make([]byte, 0, 9)
-		for _, e := range strings.SplitN(args[1], ":", 9) {
-			v, err := strconv.ParseUint(e, 16, 16)
-			if err != nil {
-				return esi, invalidEsiValuesError
-			}
-			values = append(values, byte(v))
-		}
-		copy(esi.Value, values)
-	}
-
-	return esi, nil
-}
-
-//
-// I-D bess-evpn-overlay-01
-//
-// 5.1.3 Constructing EVPN BGP Routes
-//
-// For the balance of this memo, the MPLS label field will be
-// referred to as the VNI/VSID field. The VNI/VSID field is used for
-// both local and global VNIs/VSIDs, and for either case the entire 24-
-// bit field is used to encode the VNI/VSID value.
-//
-// We can't use type MPLSLabelStack for EVPN NLRI, because EVPN NLRI's MPLS
-// field can be filled with VXLAN VNI. In that case, we must avoid modifying
-// bottom of stack bit.
-//
-
-func labelDecode(data []byte) (uint32, error) {
-	if len(data) < 3 {
-		return 0, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all Label bytes available")
-	}
-	return uint32(data[0])<<16 | uint32(data[1])<<8 | uint32(data[2]), nil
-}
-
-func labelSerialize(label uint32) ([]byte, error) {
-	if label > 0xffffff {
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Out of range Label: %d", label))
-	}
-	buf := make([]byte, 3)
-	buf[0] = byte((label >> 16) & 0xff)
-	buf[1] = byte((label >> 8) & 0xff)
-	buf[2] = byte(label & 0xff)
-	return buf, nil
-}
-
-type EVPNEthernetAutoDiscoveryRoute struct {
-	RD    RouteDistinguisherInterface
-	ESI   EthernetSegmentIdentifier
-	ETag  uint32
-	Label uint32
-}
-
-func (er *EVPNEthernetAutoDiscoveryRoute) Len() int {
-	// RD(8) + ESI(10) + ETag(4) + Label(3)
-	return 25
-}
-
-func (er *EVPNEthernetAutoDiscoveryRoute) DecodeFromBytes(data []byte) error {
-	er.RD = GetRouteDistinguisher(data)
-	data = data[er.RD.Len():]
-	err := er.ESI.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	data = data[10:]
-	er.ETag = binary.BigEndian.Uint32(data[0:4])
-	data = data[4:]
-	if er.Label, err = labelDecode(data); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (er *EVPNEthernetAutoDiscoveryRoute) Serialize() ([]byte, error) {
-	var buf []byte
-	var err error
-	if er.RD != nil {
-		buf, err = er.RD.Serialize()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		buf = make([]byte, 8)
-	}
-	tbuf, err := er.ESI.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, tbuf...)
-
-	tbuf = make([]byte, 4)
-	binary.BigEndian.PutUint32(tbuf, er.ETag)
-	buf = append(buf, tbuf...)
-
-	tbuf, err = labelSerialize(er.Label)
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, tbuf...)
-
-	return buf, nil
-}
-
-func (er *EVPNEthernetAutoDiscoveryRoute) String() string {
-	// RFC7432: BGP MPLS-Based Ethernet VPN
-	// 7.1. Ethernet Auto-discovery Route
-	// For the purpose of BGP route key processing, only the Ethernet
-	// Segment Identifier and the Ethernet Tag ID are considered to be part
-	// of the prefix in the NLRI.  The MPLS Label field is to be treated as
-	// a route attribute as opposed to being part of the route.
-	return fmt.Sprintf("[type:A-D][rd:%s][esi:%s][etag:%d]", er.RD, er.ESI.String(), er.ETag)
-}
-
-func (er *EVPNEthernetAutoDiscoveryRoute) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		RD    RouteDistinguisherInterface `json:"rd"`
-		ESI   string                      `json:"esi"`
-		Etag  uint32                      `json:"etag"`
-		Label uint32                      `json:"label"`
-	}{
-		RD:    er.RD,
-		ESI:   er.ESI.String(),
-		Etag:  er.ETag,
-		Label: er.Label,
-	})
-}
-
-func (er *EVPNEthernetAutoDiscoveryRoute) rd() RouteDistinguisherInterface {
-	return er.RD
-}
-
-func NewEVPNEthernetAutoDiscoveryRoute(rd RouteDistinguisherInterface, esi EthernetSegmentIdentifier, etag uint32, label uint32) *EVPNNLRI {
-	return NewEVPNNLRI(EVPN_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY, &EVPNEthernetAutoDiscoveryRoute{
-		RD:    rd,
-		ESI:   esi,
-		ETag:  etag,
-		Label: label,
-	})
-}
-
-type EVPNMacIPAdvertisementRoute struct {
-	RD               RouteDistinguisherInterface
-	ESI              EthernetSegmentIdentifier
-	ETag             uint32
-	MacAddressLength uint8
-	MacAddress       net.HardwareAddr
-	IPAddressLength  uint8
-	IPAddress        net.IP
-	Labels           []uint32
-}
-
-func (er *EVPNMacIPAdvertisementRoute) Len() int {
-	// RD(8) + ESI(10) + ETag(4) + MacAddressLength(1) + MacAddress(6)
-	// + IPAddressLength(1) + IPAddress(0, 4 or 16) + Labels(3 or 6)
-	return 30 + int(er.IPAddressLength)/8 + len(er.Labels)*3
-}
-
-func (er *EVPNMacIPAdvertisementRoute) DecodeFromBytes(data []byte) error {
-	er.RD = GetRouteDistinguisher(data)
-	data = data[er.RD.Len():]
-	err := er.ESI.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	data = data[10:]
-	er.ETag = binary.BigEndian.Uint32(data[0:4])
-	data = data[4:]
-	er.MacAddressLength = data[0]
-	er.MacAddress = net.HardwareAddr(data[1:7])
-	er.IPAddressLength = data[7]
-	data = data[8:]
-	if er.IPAddressLength == 32 || er.IPAddressLength == 128 {
-		er.IPAddress = net.IP(data[0:((er.IPAddressLength) / 8)])
-	} else if er.IPAddressLength != 0 {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid IP address length: %d", er.IPAddressLength))
-	}
-	data = data[(er.IPAddressLength / 8):]
-	var label uint32
-	if label, err = labelDecode(data); err != nil {
-		return err
-	}
-	er.Labels = append(er.Labels, label)
-	data = data[3:]
-	if len(data) == 3 {
-		if label, err = labelDecode(data); err != nil {
-			return err
-		}
-		er.Labels = append(er.Labels, label)
-	}
-	return nil
-}
-
-func (er *EVPNMacIPAdvertisementRoute) Serialize() ([]byte, error) {
-	var buf []byte
-	var err error
-	if er.RD != nil {
-		buf, err = er.RD.Serialize()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		buf = make([]byte, 8)
-	}
-
-	tbuf, err := er.ESI.Serialize()
-	if err != nil {
-		return nil, err
-	}
-
-	buf = append(buf, tbuf...)
-	tbuf = make([]byte, 4)
-	binary.BigEndian.PutUint32(tbuf, er.ETag)
-	buf = append(buf, tbuf...)
-	tbuf = make([]byte, 7)
-	tbuf[0] = er.MacAddressLength
-	copy(tbuf[1:], er.MacAddress)
-	buf = append(buf, tbuf...)
-
-	buf = append(buf, er.IPAddressLength)
-	switch er.IPAddressLength {
-	case 0:
-		// IP address omitted
-	case 32:
-		buf = append(buf, []byte(er.IPAddress.To4())...)
-	case 128:
-		buf = append(buf, []byte(er.IPAddress.To16())...)
-	default:
-		return nil, fmt.Errorf("Invalid IP address length: %d", er.IPAddressLength)
-	}
-
-	for _, l := range er.Labels {
-		tbuf, err = labelSerialize(l)
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, tbuf...)
-	}
-	return buf, nil
-}
-
-func (er *EVPNMacIPAdvertisementRoute) String() string {
-	// RFC7432: BGP MPLS-Based Ethernet VPN
-	// 7.2. MAC/IP Advertisement Route
-	// For the purpose of BGP route key processing, only the Ethernet Tag
-	// ID, MAC Address Length, MAC Address, IP Address Length, and IP
-	// Address fields are considered to be part of the prefix in the NLRI.
-	// The Ethernet Segment Identifier, MPLS Label1, and MPLS Label2 fields
-	// are to be treated as route attributes as opposed to being part of the
-	// "route".
-	return fmt.Sprintf("[type:macadv][rd:%s][etag:%d][mac:%s][ip:%s]", er.RD, er.ETag, er.MacAddress, er.IPAddress)
-}
-
-func (er *EVPNMacIPAdvertisementRoute) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		RD         RouteDistinguisherInterface `json:"rd"`
-		ESI        string                      `json:"esi"`
-		Etag       uint32                      `json:"etag"`
-		MacAddress string                      `json:"mac"`
-		IPAddress  string                      `json:"ip"`
-		Labels     []uint32                    `json:"labels"`
-	}{
-		RD:         er.RD,
-		ESI:        er.ESI.String(),
-		Etag:       er.ETag,
-		MacAddress: er.MacAddress.String(),
-		IPAddress:  er.IPAddress.String(),
-		Labels:     er.Labels,
-	})
-}
-
-func (er *EVPNMacIPAdvertisementRoute) rd() RouteDistinguisherInterface {
-	return er.RD
-}
-
-func NewEVPNMacIPAdvertisementRoute(rd RouteDistinguisherInterface, esi EthernetSegmentIdentifier, etag uint32, macAddress string, ipAddress string, labels []uint32) *EVPNNLRI {
-	mac, _ := net.ParseMAC(macAddress)
-	var ipLen uint8
-	ip := net.ParseIP(ipAddress)
-	if ip != nil {
-		if ipv4 := ip.To4(); ipv4 != nil {
-			ipLen = 32
-			ip = ipv4
-		} else {
-			ipLen = 128
-		}
-	}
-	return NewEVPNNLRI(EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT, &EVPNMacIPAdvertisementRoute{
-		RD:               rd,
-		ESI:              esi,
-		ETag:             etag,
-		MacAddressLength: 6,
-		MacAddress:       mac,
-		IPAddressLength:  ipLen,
-		IPAddress:        ip,
-		Labels:           labels,
-	})
-}
-
-type EVPNMulticastEthernetTagRoute struct {
-	RD              RouteDistinguisherInterface
-	ETag            uint32
-	IPAddressLength uint8
-	IPAddress       net.IP
-}
-
-func (er *EVPNMulticastEthernetTagRoute) Len() int {
-	// RD(8) + ETag(4) + IPAddressLength(1) + IPAddress(4 or 16)
-	return 13 + int(er.IPAddressLength)/8
-}
-
-func (er *EVPNMulticastEthernetTagRoute) DecodeFromBytes(data []byte) error {
-	er.RD = GetRouteDistinguisher(data)
-	data = data[er.RD.Len():]
-	er.ETag = binary.BigEndian.Uint32(data[0:4])
-	er.IPAddressLength = data[4]
-	data = data[5:]
-	if er.IPAddressLength == 32 || er.IPAddressLength == 128 {
-		er.IPAddress = net.IP(data[:er.IPAddressLength/8])
-	} else {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid IP address length: %d", er.IPAddressLength))
-	}
-	return nil
-}
-
-func (er *EVPNMulticastEthernetTagRoute) Serialize() ([]byte, error) {
-	var buf []byte
-	var err error
-	if er.RD != nil {
-		buf, err = er.RD.Serialize()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		buf = make([]byte, 8)
-	}
-	tbuf := make([]byte, 4)
-	binary.BigEndian.PutUint32(tbuf, er.ETag)
-	buf = append(buf, tbuf...)
-	buf = append(buf, er.IPAddressLength)
-	switch er.IPAddressLength {
-	case 32:
-		buf = append(buf, []byte(er.IPAddress.To4())...)
-	case 128:
-		buf = append(buf, []byte(er.IPAddress.To16())...)
-	default:
-		return nil, fmt.Errorf("Invalid IP address length: %d", er.IPAddressLength)
-	}
-	if err != nil {
-		return nil, err
-	}
-	return buf, nil
-}
-
-func (er *EVPNMulticastEthernetTagRoute) String() string {
-	// RFC7432: BGP MPLS-Based Ethernet VPN
-	// 7.3. Inclusive Multicast Ethernet Tag Route
-	// ...(snip)... For the purpose of BGP route key
-	// processing, only the Ethernet Tag ID, IP Address Length, and
-	// Originating Router's IP Address fields are considered to be part of
-	// the prefix in the NLRI.
-	return fmt.Sprintf("[type:multicast][rd:%s][etag:%d][ip:%s]", er.RD, er.ETag, er.IPAddress)
-}
-
-func (er *EVPNMulticastEthernetTagRoute) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		RD        RouteDistinguisherInterface `json:"rd"`
-		Etag      uint32                      `json:"etag"`
-		IPAddress string                      `json:"ip"`
-	}{
-		RD:        er.RD,
-		Etag:      er.ETag,
-		IPAddress: er.IPAddress.String(),
-	})
-}
-
-func (er *EVPNMulticastEthernetTagRoute) rd() RouteDistinguisherInterface {
-	return er.RD
-}
-
-func NewEVPNMulticastEthernetTagRoute(rd RouteDistinguisherInterface, etag uint32, ipAddress string) *EVPNNLRI {
-	ipLen := uint8(32)
-	ip := net.ParseIP(ipAddress)
-	if ipv4 := ip.To4(); ipv4 != nil {
-		ip = ipv4
-	} else {
-		ipLen = 128
-	}
-	return NewEVPNNLRI(EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG, &EVPNMulticastEthernetTagRoute{
-		RD:              rd,
-		ETag:            etag,
-		IPAddressLength: ipLen,
-		IPAddress:       ip,
-	})
-}
-
-type EVPNEthernetSegmentRoute struct {
-	RD              RouteDistinguisherInterface
-	ESI             EthernetSegmentIdentifier
-	IPAddressLength uint8
-	IPAddress       net.IP
-}
-
-func (er *EVPNEthernetSegmentRoute) Len() int {
-	// RD(8) + ESI(10) + IPAddressLength(1) + IPAddress(4 or 16)
-	return 19 + int(er.IPAddressLength)/8
-}
-
-func (er *EVPNEthernetSegmentRoute) DecodeFromBytes(data []byte) error {
-	er.RD = GetRouteDistinguisher(data)
-	data = data[er.RD.Len():]
-	er.ESI.DecodeFromBytes(data)
-	data = data[10:]
-	er.IPAddressLength = data[0]
-	data = data[1:]
-	if er.IPAddressLength == 32 || er.IPAddressLength == 128 {
-		er.IPAddress = net.IP(data[:er.IPAddressLength/8])
-	} else {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid IP address length: %d", er.IPAddressLength))
-	}
-	return nil
-}
-
-func (er *EVPNEthernetSegmentRoute) Serialize() ([]byte, error) {
-	var buf []byte
-	var err error
-	if er.RD != nil {
-		buf, err = er.RD.Serialize()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		buf = make([]byte, 8)
-	}
-	tbuf, err := er.ESI.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, tbuf...)
-	buf = append(buf, er.IPAddressLength)
-	switch er.IPAddressLength {
-	case 32:
-		buf = append(buf, []byte(er.IPAddress.To4())...)
-	case 128:
-		buf = append(buf, []byte(er.IPAddress.To16())...)
-	default:
-		return nil, fmt.Errorf("Invalid IP address length: %d", er.IPAddressLength)
-	}
-	return buf, nil
-}
-
-func (er *EVPNEthernetSegmentRoute) String() string {
-	// RFC7432: BGP MPLS-Based Ethernet VPN
-	// 7.4. Ethernet Segment Route
-	// For the purpose of BGP route key processing, only the Ethernet
-	// Segment ID, IP Address Length, and Originating Router's IP Address
-	// fields are considered to be part of the prefix in the NLRI.
-	return fmt.Sprintf("[type:esi][rd:%s][esi:%s][ip:%s]", er.RD, er.ESI.String(), er.IPAddress)
-}
-
-func (er *EVPNEthernetSegmentRoute) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		RD        RouteDistinguisherInterface `json:"rd"`
-		ESI       string                      `json:"esi"`
-		IPAddress string                      `json:"ip"`
-	}{
-		RD:        er.RD,
-		ESI:       er.ESI.String(),
-		IPAddress: er.IPAddress.String(),
-	})
-}
-
-func (er *EVPNEthernetSegmentRoute) rd() RouteDistinguisherInterface {
-	return er.RD
-}
-
-func NewEVPNEthernetSegmentRoute(rd RouteDistinguisherInterface, esi EthernetSegmentIdentifier, ipAddress string) *EVPNNLRI {
-	ipLen := uint8(32)
-	ip := net.ParseIP(ipAddress)
-	if ipv4 := ip.To4(); ipv4 != nil {
-		ip = ipv4
-	} else {
-		ipLen = 128
-	}
-	return NewEVPNNLRI(EVPN_ETHERNET_SEGMENT_ROUTE, &EVPNEthernetSegmentRoute{
-		RD:              rd,
-		ESI:             esi,
-		IPAddressLength: ipLen,
-		IPAddress:       ip,
-	})
-}
-
-type EVPNIPPrefixRoute struct {
-	RD             RouteDistinguisherInterface
-	ESI            EthernetSegmentIdentifier
-	ETag           uint32
-	IPPrefixLength uint8
-	IPPrefix       net.IP
-	GWIPAddress    net.IP
-	Label          uint32
-}
-
-func (er *EVPNIPPrefixRoute) Len() int {
-	if er.IPPrefix.To4() != nil {
-		return 34
-	}
-	return 58
-}
-
-func (er *EVPNIPPrefixRoute) DecodeFromBytes(data []byte) error {
-	addrLen := net.IPv4len
-	switch len(data) {
-	case 34:
-		// RD(8) + ESI(10) + ETag(4) + IPPrefixLength(1) + IPv4 Prefix(4) + GW IPv4(4) + Label(3)
-	case 58:
-		// RD(8) + ESI(10) + ETag(4) + IPPrefixLength(1) + IPv6 Prefix(16) + GW IPv6(16) + Label(3)
-		addrLen = net.IPv6len
-	default:
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all EVPN IP Prefix Route bytes available")
-	}
-
-	er.RD = GetRouteDistinguisher(data[0:8])
-
-	err := er.ESI.DecodeFromBytes(data[8:18])
-	if err != nil {
-		return err
-	}
-
-	er.ETag = binary.BigEndian.Uint32(data[18:22])
-
-	er.IPPrefixLength = data[22]
-
-	offset := 23 // RD(8) + ESI(10) + ETag(4) + IPPrefixLength(1)
-	er.IPPrefix = data[offset : offset+addrLen]
-	offset += addrLen
-
-	er.GWIPAddress = data[offset : offset+addrLen]
-	offset += addrLen
-
-	if er.Label, err = labelDecode(data[offset : offset+3]); err != nil {
-		return err
-	}
-	//offset += 3
-
-	return nil
-}
-
-func (er *EVPNIPPrefixRoute) Serialize() ([]byte, error) {
-	buf := make([]byte, 23) // RD(8) + ESI(10) + ETag(4) + IPPrefixLength(1)
-
-	if er.RD != nil {
-		tbuf, err := er.RD.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		copy(buf[0:8], tbuf)
-	}
-
-	tbuf, err := er.ESI.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	copy(buf[8:18], tbuf)
-
-	binary.BigEndian.PutUint32(buf[18:22], er.ETag)
-
-	buf[22] = er.IPPrefixLength
-
-	if er.IPPrefix == nil {
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("IP Prefix is nil"))
-	} else if er.IPPrefix.To4() != nil {
-		buf = append(buf, er.IPPrefix.To4()...)
-		if er.GWIPAddress == nil {
-			// draft-ietf-bess-evpn-prefix-advertisement: IP Prefix Advertisement in EVPN
-			// The GW IP field SHOULD be zero if it is not used as an Overlay Index.
-			er.GWIPAddress = net.IPv4zero
-		}
-		buf = append(buf, er.GWIPAddress.To4()...)
-	} else {
-		buf = append(buf, er.IPPrefix.To16()...)
-		if er.GWIPAddress == nil {
-			er.GWIPAddress = net.IPv6zero
-		}
-		buf = append(buf, er.GWIPAddress.To16()...)
-	}
-
-	tbuf, err = labelSerialize(er.Label)
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, tbuf...)
-
-	return buf, nil
-}
-
-func (er *EVPNIPPrefixRoute) String() string {
-	// draft-ietf-bess-evpn-prefix-advertisement: IP Prefix Advertisement in EVPN
-	// 3.1 IP Prefix Route Encoding
-	// The RD, Eth-Tag ID, IP Prefix Length and IP Prefix will be part of
-	// the route key used by BGP to compare routes. The rest of the fields
-	// will not be part of the route key.
-	return fmt.Sprintf("[type:Prefix][rd:%s][etag:%d][prefix:%s/%d]", er.RD, er.ETag, er.IPPrefix, er.IPPrefixLength)
-}
-
-func (er *EVPNIPPrefixRoute) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		RD      RouteDistinguisherInterface `json:"rd"`
-		ESI     string                      `json:"esi"`
-		Etag    uint32                      `json:"etag"`
-		Prefix  string                      `json:"prefix"`
-		Gateway string                      `json:"gateway"`
-		Label   uint32                      `json:"label"`
-	}{
-		RD:      er.RD,
-		ESI:     er.ESI.String(),
-		Etag:    er.ETag,
-		Prefix:  fmt.Sprintf("%s/%d", er.IPPrefix, er.IPPrefixLength),
-		Gateway: er.GWIPAddress.String(),
-		Label:   er.Label,
-	})
-}
-
-func (er *EVPNIPPrefixRoute) rd() RouteDistinguisherInterface {
-	return er.RD
-}
-
-func NewEVPNIPPrefixRoute(rd RouteDistinguisherInterface, esi EthernetSegmentIdentifier, etag uint32, ipPrefixLength uint8, ipPrefix string, gateway string, label uint32) *EVPNNLRI {
-	ip := net.ParseIP(ipPrefix)
-	gw := net.ParseIP(gateway)
-	if ipv4 := ip.To4(); ipv4 != nil {
-		ip = ipv4
-		gw = gw.To4()
-	}
-	return NewEVPNNLRI(EVPN_IP_PREFIX, &EVPNIPPrefixRoute{
-		RD:             rd,
-		ESI:            esi,
-		ETag:           etag,
-		IPPrefixLength: ipPrefixLength,
-		IPPrefix:       ip,
-		GWIPAddress:    gw,
-		Label:          label,
-	})
-}
-
-type EVPNRouteTypeInterface interface {
-	Len() int
-	DecodeFromBytes([]byte) error
-	Serialize() ([]byte, error)
-	String() string
-	rd() RouteDistinguisherInterface
-	MarshalJSON() ([]byte, error)
-}
-
-func getEVPNRouteType(t uint8) (EVPNRouteTypeInterface, error) {
-	switch t {
-	case EVPN_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY:
-		return &EVPNEthernetAutoDiscoveryRoute{}, nil
-	case EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT:
-		return &EVPNMacIPAdvertisementRoute{}, nil
-	case EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG:
-		return &EVPNMulticastEthernetTagRoute{}, nil
-	case EVPN_ETHERNET_SEGMENT_ROUTE:
-		return &EVPNEthernetSegmentRoute{}, nil
-	case EVPN_IP_PREFIX:
-		return &EVPNIPPrefixRoute{}, nil
-	}
-	return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Unknown EVPN Route type: %d", t))
-}
-
-const (
-	EVPN_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY = 1
-	EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT    = 2
-	EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG   = 3
-	EVPN_ETHERNET_SEGMENT_ROUTE             = 4
-	EVPN_IP_PREFIX                          = 5
-)
-
-type EVPNNLRI struct {
-	PrefixDefault
-	RouteType     uint8
-	Length        uint8
-	RouteTypeData EVPNRouteTypeInterface
-}
-
-func (n *EVPNNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if IsAddPathEnabled(true, RF_EVPN, options) {
-		var err error
-		data, err = n.decodePathIdentifier(data)
-		if err != nil {
-			return err
-		}
-	}
-	if len(data) < 2 {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all EVPNNLRI bytes available")
-	}
-	n.RouteType = data[0]
-	n.Length = data[1]
-	data = data[2:]
-	if len(data) < int(n.Length) {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all EVPNNLRI Route type bytes available")
-	}
-	r, err := getEVPNRouteType(n.RouteType)
-	if err != nil {
-		return err
-	}
-	n.RouteTypeData = r
-	return n.RouteTypeData.DecodeFromBytes(data[:n.Length])
-}
-
-func (n *EVPNNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	var buf []byte
-	if IsAddPathEnabled(false, RF_EVPN, options) {
-		var err error
-		buf, err = n.serializeIdentifier()
-		if err != nil {
-			return nil, err
-		}
-	}
-	offset := len(buf)
-	buf = append(buf, make([]byte, 2)...)
-	buf[offset] = n.RouteType
-	tbuf, err := n.RouteTypeData.Serialize()
-	buf[offset+1] = n.Length
-	if err != nil {
-		return nil, err
-	}
-	return append(buf, tbuf...), nil
-}
-
-func (n *EVPNNLRI) AFI() uint16 {
-	return AFI_L2VPN
-}
-
-func (n *EVPNNLRI) SAFI() uint8 {
-	return SAFI_EVPN
-}
-
-func (n *EVPNNLRI) Len(options ...*MarshallingOption) int {
-	return int(n.Length) + 2
-}
-
-func (n *EVPNNLRI) String() string {
-	if n.RouteTypeData != nil {
-		return n.RouteTypeData.String()
-	}
-	return fmt.Sprintf("%d:%d", n.RouteType, n.Length)
-}
-
-func (n *EVPNNLRI) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  uint8                  `json:"type"`
-		Value EVPNRouteTypeInterface `json:"value"`
-	}{
-		Type:  n.RouteType,
-		Value: n.RouteTypeData,
-	})
-}
-
-func (n *EVPNNLRI) RD() RouteDistinguisherInterface {
-	return n.RouteTypeData.rd()
-}
-
-func NewEVPNNLRI(routeType uint8, routeTypeData EVPNRouteTypeInterface) *EVPNNLRI {
-	var l uint8
-	if routeTypeData != nil {
-		l = uint8(routeTypeData.Len())
-	}
-	return &EVPNNLRI{
-		RouteType:     routeType,
-		Length:        l,
-		RouteTypeData: routeTypeData,
-	}
-}
-
-type EncapNLRI struct {
-	IPAddrPrefixDefault
-	addrlen uint8
-}
-
-func (n *EncapNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if n.addrlen == 0 {
-		n.addrlen = 4
-	}
-	f := RF_IPv4_ENCAP
-	if n.addrlen == 16 {
-		f = RF_IPv6_ENCAP
-	}
-	if IsAddPathEnabled(true, f, options) {
-		var err error
-		data, err = n.decodePathIdentifier(data)
-		if err != nil {
-			return err
-		}
-	}
-	if len(data) < 4 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-		return NewMessageError(eCode, eSubCode, nil, "prefix misses length field")
-	}
-	n.Length = data[0]
-	if n.addrlen == 0 {
-		n.addrlen = 4
-	}
-	return n.decodePrefix(data[1:], n.Length, n.addrlen)
-}
-
-func (n *EncapNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	var buf []byte
-	f := RF_IPv4_ENCAP
-	if n.addrlen == 16 {
-		f = RF_IPv6_ENCAP
-	}
-	if IsAddPathEnabled(false, f, options) {
-		var err error
-		buf, err = n.serializeIdentifier()
-		if err != nil {
-			return nil, err
-		}
-	}
-	if n.Prefix.To4() != nil {
-		buf = append(buf, net.IPv4len*8)
-		n.Prefix = n.Prefix.To4()
-	} else {
-		buf = append(buf, net.IPv6len*8)
-	}
-	n.Length = buf[len(buf)-1]
-	pbuf, err := n.serializePrefix(n.Length)
-	if err != nil {
-		return nil, err
-	}
-	return append(buf, pbuf...), nil
-}
-
-func (n *EncapNLRI) String() string {
-	return n.Prefix.String()
-}
-
-func (n *EncapNLRI) AFI() uint16 {
-	return AFI_IP
-}
-
-func (n *EncapNLRI) SAFI() uint8 {
-	return SAFI_ENCAPSULATION
-}
-
-func (n *EncapNLRI) Len(options ...*MarshallingOption) int {
-	return 1 + len(n.Prefix)
-}
-
-func NewEncapNLRI(endpoint string) *EncapNLRI {
-	return &EncapNLRI{
-		IPAddrPrefixDefault{Length: 32, Prefix: net.ParseIP(endpoint).To4()},
-		4,
-	}
-}
-
-type Encapv6NLRI struct {
-	EncapNLRI
-}
-
-func (n *Encapv6NLRI) AFI() uint16 {
-	return AFI_IP6
-}
-
-func NewEncapv6NLRI(endpoint string) *Encapv6NLRI {
-	return &Encapv6NLRI{
-		EncapNLRI{
-			IPAddrPrefixDefault{Length: 128, Prefix: net.ParseIP(endpoint)},
-			16,
-		},
-	}
-}
-
-type BGPFlowSpecType uint8
-
-const (
-	FLOW_SPEC_TYPE_UNKNOWN BGPFlowSpecType = iota
-	FLOW_SPEC_TYPE_DST_PREFIX
-	FLOW_SPEC_TYPE_SRC_PREFIX
-	FLOW_SPEC_TYPE_IP_PROTO
-	FLOW_SPEC_TYPE_PORT
-	FLOW_SPEC_TYPE_DST_PORT
-	FLOW_SPEC_TYPE_SRC_PORT
-	FLOW_SPEC_TYPE_ICMP_TYPE
-	FLOW_SPEC_TYPE_ICMP_CODE
-	FLOW_SPEC_TYPE_TCP_FLAG
-	FLOW_SPEC_TYPE_PKT_LEN
-	FLOW_SPEC_TYPE_DSCP
-	FLOW_SPEC_TYPE_FRAGMENT
-	FLOW_SPEC_TYPE_LABEL
-	FLOW_SPEC_TYPE_ETHERNET_TYPE // 14
-	FLOW_SPEC_TYPE_SRC_MAC
-	FLOW_SPEC_TYPE_DST_MAC
-	FLOW_SPEC_TYPE_LLC_DSAP
-	FLOW_SPEC_TYPE_LLC_SSAP
-	FLOW_SPEC_TYPE_LLC_CONTROL
-	FLOW_SPEC_TYPE_SNAP
-	FLOW_SPEC_TYPE_VID
-	FLOW_SPEC_TYPE_COS
-	FLOW_SPEC_TYPE_INNER_VID
-	FLOW_SPEC_TYPE_INNER_COS
-)
-
-var FlowSpecNameMap = map[BGPFlowSpecType]string{
-	FLOW_SPEC_TYPE_UNKNOWN:       "unknown",
-	FLOW_SPEC_TYPE_DST_PREFIX:    "destination",
-	FLOW_SPEC_TYPE_SRC_PREFIX:    "source",
-	FLOW_SPEC_TYPE_IP_PROTO:      "protocol",
-	FLOW_SPEC_TYPE_PORT:          "port",
-	FLOW_SPEC_TYPE_DST_PORT:      "destination-port",
-	FLOW_SPEC_TYPE_SRC_PORT:      "source-port",
-	FLOW_SPEC_TYPE_ICMP_TYPE:     "icmp-type",
-	FLOW_SPEC_TYPE_ICMP_CODE:     "icmp-code",
-	FLOW_SPEC_TYPE_TCP_FLAG:      "tcp-flags",
-	FLOW_SPEC_TYPE_PKT_LEN:       "packet-length",
-	FLOW_SPEC_TYPE_DSCP:          "dscp",
-	FLOW_SPEC_TYPE_FRAGMENT:      "fragment",
-	FLOW_SPEC_TYPE_LABEL:         "label",
-	FLOW_SPEC_TYPE_ETHERNET_TYPE: "ether-type",
-	FLOW_SPEC_TYPE_SRC_MAC:       "source-mac",
-	FLOW_SPEC_TYPE_DST_MAC:       "destination-mac",
-	FLOW_SPEC_TYPE_LLC_DSAP:      "llc-dsap",
-	FLOW_SPEC_TYPE_LLC_SSAP:      "llc-ssap",
-	FLOW_SPEC_TYPE_LLC_CONTROL:   "llc-control",
-	FLOW_SPEC_TYPE_SNAP:          "snap",
-	FLOW_SPEC_TYPE_VID:           "vid",
-	FLOW_SPEC_TYPE_COS:           "cos",
-	FLOW_SPEC_TYPE_INNER_VID:     "inner-vid",
-	FLOW_SPEC_TYPE_INNER_COS:     "inner-cos",
-}
-
-var FlowSpecValueMap = map[string]BGPFlowSpecType{
-	FlowSpecNameMap[FLOW_SPEC_TYPE_DST_PREFIX]:    FLOW_SPEC_TYPE_DST_PREFIX,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_SRC_PREFIX]:    FLOW_SPEC_TYPE_SRC_PREFIX,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_IP_PROTO]:      FLOW_SPEC_TYPE_IP_PROTO,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_PORT]:          FLOW_SPEC_TYPE_PORT,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_DST_PORT]:      FLOW_SPEC_TYPE_DST_PORT,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_SRC_PORT]:      FLOW_SPEC_TYPE_SRC_PORT,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_ICMP_TYPE]:     FLOW_SPEC_TYPE_ICMP_TYPE,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_ICMP_CODE]:     FLOW_SPEC_TYPE_ICMP_CODE,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_TCP_FLAG]:      FLOW_SPEC_TYPE_TCP_FLAG,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_PKT_LEN]:       FLOW_SPEC_TYPE_PKT_LEN,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_DSCP]:          FLOW_SPEC_TYPE_DSCP,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_FRAGMENT]:      FLOW_SPEC_TYPE_FRAGMENT,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_LABEL]:         FLOW_SPEC_TYPE_LABEL,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_ETHERNET_TYPE]: FLOW_SPEC_TYPE_ETHERNET_TYPE,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_SRC_MAC]:       FLOW_SPEC_TYPE_SRC_MAC,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_DST_MAC]:       FLOW_SPEC_TYPE_DST_MAC,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_LLC_DSAP]:      FLOW_SPEC_TYPE_LLC_DSAP,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_LLC_SSAP]:      FLOW_SPEC_TYPE_LLC_SSAP,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_LLC_CONTROL]:   FLOW_SPEC_TYPE_LLC_CONTROL,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_SNAP]:          FLOW_SPEC_TYPE_SNAP,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_VID]:           FLOW_SPEC_TYPE_VID,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_COS]:           FLOW_SPEC_TYPE_COS,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_INNER_VID]:     FLOW_SPEC_TYPE_INNER_VID,
-	FlowSpecNameMap[FLOW_SPEC_TYPE_INNER_COS]:     FLOW_SPEC_TYPE_INNER_COS,
-}
-
-// Joins the given and args into a single string and normalize it.
-// Example:
-// args := []string{"  &  <=80", " tcp  != udp ", " =!   SA   & =U!  F", " =  is-fragment+last-fragment"}
-// fmt.Printf("%q", normalizeFlowSpecOpValues(args))
-// >>> ["<=80" "tcp" "!=udp" "=!SA" "&=U" "!F" "=is-fragment+last-fragment"]
-func normalizeFlowSpecOpValues(args []string) []string {
-	// Extracts keywords from the given args.
-	sub := ""
-	subs := make([]string, 0)
-	for _, s := range _regexpFlowSpecOperator.FindAllString(strings.Join(args, " "), -1) {
-		sub += s
-		if _regexpFlowSpecOperatorValue.MatchString(s) {
-			subs = append(subs, sub)
-			sub = ""
-		}
-	}
-
-	// RFC5575 says "It should be unset in the first operator byte of a
-	// sequence".
-	if len(subs) > 0 {
-		subs[0] = strings.TrimPrefix(subs[0], "&")
-	}
-
-	return subs
-}
-
-// Parses the FlowSpec numeric operator using the given submatch which should be
-// the return value of func (*Regexp) FindStringSubmatch.
-func parseFlowSpecNumericOperator(submatch []string) (operator uint8, err error) {
-	if submatch[1] == "&" {
-		operator = DEC_NUM_OP_AND
-	}
-	value, ok := DECNumOpValueMap[submatch[2]]
-	if !ok {
-		return 0, fmt.Errorf("invalid numeric operator: %s%s", submatch[1], submatch[2])
-	}
-	operator |= uint8(value)
-	return operator, nil
-}
-
-// Parses the pairs of operator and value for the FlowSpec numeric type. The
-// given validationFunc is applied to evaluate whether the parsed value is
-// valid or not (e.g., if exceeds range or not).
-// Note: Each of the args should be formatted in single pair of operator and
-// value before calling this function.
-// e.g.) "&==100", ">=200" or "&<300"
-func parseFlowSpecNumericOpValues(typ BGPFlowSpecType, args []string, validationFunc func(uint64) error) (FlowSpecComponentInterface, error) {
-	argsLen := len(args)
-	items := make([]*FlowSpecComponentItem, 0, argsLen)
-	for idx, arg := range args {
-		m := _regexpFlowSpecNumericType.FindStringSubmatch(arg)
-		if len(m) < 4 {
-			return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args)
-		}
-		operator, err := parseFlowSpecNumericOperator(m)
-		if err != nil {
-			return nil, err
-		}
-		// "true" and "false" is operator, but here handles them as value.
-		var value uint64
-		switch m[3] {
-		case "true", "false":
-			if idx != argsLen-1 {
-				return nil, fmt.Errorf("%s should be the last of each rule", m[3])
-			}
-			operator = uint8(DECNumOpValueMap[m[3]])
-		default:
-			if value, err = strconv.ParseUint(m[3], 10, 64); err != nil {
-				return nil, fmt.Errorf("invalid numeric value: %s", m[3])
-			}
-			if err = validationFunc(value); err != nil {
-				return nil, err
-			}
-		}
-		items = append(items, NewFlowSpecComponentItem(operator, value))
-	}
-
-	// Marks end-of-list bit
-	items[argsLen-1].Op |= uint8(DEC_NUM_OP_END)
-
-	return NewFlowSpecComponent(typ, items), nil
-}
-
-func flowSpecNumeric1ByteParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	args = normalizeFlowSpecOpValues(args)
-
-	f := func(i uint64) error {
-		if i <= 0xff { // 1 byte
-			return nil
-		}
-		return fmt.Errorf("%s range exceeded", typ.String())
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-func flowSpecNumeric2BytesParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	args = normalizeFlowSpecOpValues(args)
-
-	f := func(i uint64) error {
-		if i <= 0xffff { // 2 bytes
-			return nil
-		}
-		return fmt.Errorf("%s range exceeded", typ.String())
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-// Parses the FlowSpec bitmask operand using the given submatch which should be
-// the return value of func (*Regexp) FindStringSubmatch.
-func parseFlowSpecBitmaskOperand(submatch []string) (operand uint8, err error) {
-	if submatch[1] == "&" {
-		operand = BITMASK_FLAG_OP_AND
-	}
-	value, ok := BitmaskFlagOpValueMap[submatch[2]]
-	if !ok {
-		return 0, fmt.Errorf("invalid bitmask operand: %s%s", submatch[1], submatch[2])
-	}
-	operand |= uint8(value)
-	return operand, nil
-}
-
-func flowSpecPrefixParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	// args[0]: IP Prefix or IP Address (suppose prefix length is 32)
-	// args[1]: Offset in bit (IPv6 only)
-	//
-	// Example:
-	// - IPv4 Prefix
-	//   args := []string{"192.168.0.0/24"}
-	// - IPv4 Address
-	//   args := []string{"192.168.0.1"}
-	// - IPv6 Prefix
-	//   args := []string{"2001:db8:1::/64"}
-	// - IPv6 Prefix with offset
-	//   args := []string{"0:db8:1::/64/16"}
-	//   args := []string{"0:db8:1::/64", "16"}
-	// - IPv6 Address
-	//   args := []string{"2001:db8:1::1"}
-	// - IPv6 Address with offset
-	//   args := []string{"0:db8:1::1", "16"}
-	afi, _ := RouteFamilyToAfiSafi(rf)
-	switch afi {
-	case AFI_IP:
-		if len(args) > 1 {
-			return nil, fmt.Errorf("cannot specify offset for ipv4 prefix")
-		}
-		invalidIPv4PrefixError := fmt.Errorf("invalid ipv4 prefix: %s", args[0])
-		m := _regexpFindIPv4Prefix.FindStringSubmatch(args[0])
-		if len(m) < 4 {
-			return nil, invalidIPv4PrefixError
-		}
-		prefix := net.ParseIP(m[1])
-		if prefix.To4() == nil {
-			return nil, invalidIPv4PrefixError
-		}
-		var prefixLen uint64 = 32
-		if m[3] != "" {
-			var err error
-			prefixLen, err = strconv.ParseUint(m[3], 10, 8)
-			if err != nil || prefixLen > 32 {
-				return nil, invalidIPv4PrefixError
-			}
-		}
-		switch typ {
-		case FLOW_SPEC_TYPE_DST_PREFIX:
-			return NewFlowSpecDestinationPrefix(NewIPAddrPrefix(uint8(prefixLen), prefix.String())), nil
-		case FLOW_SPEC_TYPE_SRC_PREFIX:
-			return NewFlowSpecSourcePrefix(NewIPAddrPrefix(uint8(prefixLen), prefix.String())), nil
-		}
-		return nil, fmt.Errorf("invalid traffic filtering rule type: %s", typ.String())
-	case AFI_IP6:
-		if len(args) > 2 {
-			return nil, fmt.Errorf("invalid arguments for ipv6 prefix: %q", args)
-		}
-		invalidIPv6PrefixError := fmt.Errorf("invalid ipv6 prefix: %s", args[0])
-		m := _regexpFindIPv6Prefix.FindStringSubmatch(args[0])
-		if len(m) < 4 {
-			return nil, invalidIPv6PrefixError
-		}
-		prefix := net.ParseIP(m[1])
-		if prefix.To16() == nil {
-			return nil, invalidIPv6PrefixError
-		}
-		var prefixLen uint64 = 128
-		if m[3] != "" {
-			var err error
-			prefixLen, err = strconv.ParseUint(m[3], 10, 8)
-			if err != nil || prefixLen > 128 {
-				return nil, invalidIPv6PrefixError
-			}
-		}
-		var offset uint64
-		if len(args) == 1 && m[5] != "" {
-			var err error
-			offset, err = strconv.ParseUint(m[5], 10, 8)
-			if err != nil || offset > 128 {
-				return nil, fmt.Errorf("invalid ipv6 prefix offset: %s", m[5])
-			}
-		} else if len(args) == 2 {
-			if m[5] != "" {
-				return nil, fmt.Errorf("multiple ipv6 prefix offset arguments detected: %q", args)
-			}
-			var err error
-			offset, err = strconv.ParseUint(args[1], 10, 8)
-			if err != nil || offset > 128 {
-				return nil, fmt.Errorf("invalid ipv6 prefix offset: %s", args[1])
-			}
-		}
-		switch typ {
-		case FLOW_SPEC_TYPE_DST_PREFIX:
-			return NewFlowSpecDestinationPrefix6(NewIPv6AddrPrefix(uint8(prefixLen), prefix.String()), uint8(offset)), nil
-		case FLOW_SPEC_TYPE_SRC_PREFIX:
-			return NewFlowSpecSourcePrefix6(NewIPv6AddrPrefix(uint8(prefixLen), prefix.String()), uint8(offset)), nil
-		}
-		return nil, fmt.Errorf("invalid traffic filtering rule type: %s", typ.String())
-	}
-	return nil, fmt.Errorf("invalid address family: %s", rf.String())
-}
-
-func flowSpecIpProtoParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	// args: List of pairs of Operator and IP protocol type
-	//
-	// Example:
-	// - TCP or UDP
-	//   args := []string{"tcp", "==udp"}
-	// - Not TCP and not UDP
-	//   args := []string{"!=tcp", "&!=udp"}
-	args = normalizeFlowSpecOpValues(args)
-	s := strings.Join(args, " ")
-	for i, name := range ProtocolNameMap {
-		s = strings.Replace(s, name, fmt.Sprintf("%d", i), -1)
-	}
-	args = strings.Split(s, " ")
-
-	f := func(i uint64) error {
-		if i <= 0xff { // 1 byte
-			return nil
-		}
-		return fmt.Errorf("%s range exceeded", typ.String())
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-func flowSpecTcpFlagParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	// args: List of pairs of Operand and TCP Flags
-	//
-	// Example:
-	// - SYN or SYN/ACK
-	//   args := []string{"==S", "==SA"}
-	// - Not FIN and not URG
-	//   args := []string{"!=F", "&!=U"}
-	args = normalizeFlowSpecOpValues(args)
-
-	argsLen := len(args)
-	items := make([]*FlowSpecComponentItem, 0, argsLen)
-
-	for _, arg := range args {
-		m := _regexpFlowSpecTCPFlag.FindStringSubmatch(arg)
-		if len(m) < 6 {
-			return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args)
-		} else if mLast := m[len(m)-1]; mLast != "" || m[3] != "" {
-			return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args)
-		}
-		operand, err := parseFlowSpecBitmaskOperand(m)
-		if err != nil {
-			return nil, err
-		}
-		var value uint64
-		for flag, name := range TCPFlagNameMap {
-			if strings.Contains(m[4], name) {
-				value |= uint64(flag)
-			}
-		}
-		items = append(items, NewFlowSpecComponentItem(operand, value))
-	}
-
-	// Marks end-of-list bit
-	items[argsLen-1].Op |= BITMASK_FLAG_OP_END
-
-	return NewFlowSpecComponent(typ, items), nil
-}
-
-func flowSpecDscpParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	args = normalizeFlowSpecOpValues(args)
-
-	f := func(i uint64) error {
-		if i < 64 { // 6 bits
-			return nil
-		}
-		return fmt.Errorf("%s range exceeded", typ.String())
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-func flowSpecFragmentParser(_ RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	// args: List of pairs of Operator and Fragment flags
-	//
-	// Example:
-	// - is-fragment or last-fragment
-	//   args := []string{"==is-fragment", "==last-fragment"}
-	// - is-fragment and last-fragment (exact match)
-	//   args := []string{"==is-fragment+last-fragment"}
-	args = normalizeFlowSpecOpValues(args)
-
-	argsLen := len(args)
-	items := make([]*FlowSpecComponentItem, 0, argsLen)
-
-	for _, arg := range args {
-		m := _regexpFlowSpecFragment.FindStringSubmatch(arg)
-		if len(m) < 4 {
-			return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args)
-		} else if mLast := m[len(m)-1]; mLast != "" {
-			return nil, fmt.Errorf("invalid argument for %s: %s in %q", typ.String(), arg, args)
-		}
-		operand, err := parseFlowSpecBitmaskOperand(m)
-		if err != nil {
-			return nil, err
-		}
-		var value uint64
-		// Example:
-		// m[3] = "first-fragment+last-fragment"
-		for flag, name := range FragmentFlagNameMap {
-			if strings.Contains(m[3], name) {
-				value |= uint64(flag)
-			}
-		}
-		items = append(items, NewFlowSpecComponentItem(operand, value))
-	}
-
-	// Marks end-of-list bit
-	items[argsLen-1].Op |= BITMASK_FLAG_OP_END
-
-	return NewFlowSpecComponent(typ, items), nil
-}
-
-func flowSpecLabelParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	afi, _ := RouteFamilyToAfiSafi(rf)
-	if afi == AFI_IP {
-		return nil, fmt.Errorf("%s is not supported for ipv4", typ.String())
-	}
-
-	args = normalizeFlowSpecOpValues(args)
-
-	f := func(i uint64) error {
-		if i <= 0xfffff { // 20 bits
-			return nil
-		}
-		return fmt.Errorf("flow label range exceeded")
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-func flowSpecEtherTypeParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	// args: List of pairs of Operator and Ether Types
-	//
-	// Example:
-	// - ARP or IPv4
-	//   args := []string{"==arp", "==ipv4"}
-	// - Not IPv4 and not IPv6
-	//   args := []string{"!=ipv4", "&!=ipv6"}
-	if rf != RF_FS_L2_VPN {
-		return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String())
-	}
-
-	args = normalizeFlowSpecOpValues(args)
-	s := strings.Join(args, " ")
-	for i, name := range EthernetTypeNameMap {
-		s = strings.Replace(s, name, fmt.Sprintf("%d", i), -1)
-	}
-	args = strings.Split(s, " ")
-
-	f := func(i uint64) error {
-		if i <= 0xffff { // 2 bytes
-			return nil
-		}
-		return fmt.Errorf("%s range exceeded", typ.String())
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-func flowSpecMacParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	// args[0]: MAC address
-	if rf != RF_FS_L2_VPN {
-		return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String())
-	}
-
-	mac, err := net.ParseMAC(args[0])
-	if err != nil {
-		return nil, fmt.Errorf("invalid mac address: %s", args[0])
-	}
-
-	switch typ {
-	case FLOW_SPEC_TYPE_DST_MAC:
-		return NewFlowSpecDestinationMac(mac), nil
-	case FLOW_SPEC_TYPE_SRC_MAC:
-		return NewFlowSpecSourceMac(mac), nil
-	}
-	return nil, fmt.Errorf("invalid traffic filtering rule type: %s", typ.String())
-}
-
-func flowSpecLlcParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	if rf != RF_FS_L2_VPN {
-		return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String())
-	}
-
-	return flowSpecNumeric1ByteParser(rf, typ, args)
-}
-
-func flowSpecSnapParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	if rf != RF_FS_L2_VPN {
-		return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String())
-	}
-
-	args = normalizeFlowSpecOpValues(args)
-
-	f := func(i uint64) error {
-		if i <= 0xffffffffff { // 5 bytes
-			return nil
-		}
-		return fmt.Errorf("%s range exceeded", typ.String())
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-func flowSpecVlanIDParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	if rf != RF_FS_L2_VPN {
-		return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String())
-	}
-
-	args = normalizeFlowSpecOpValues(args)
-	s := strings.Join(args, " ")
-	for i, name := range EthernetTypeNameMap {
-		s = strings.Replace(s, name, fmt.Sprintf("%d", i), -1)
-	}
-	args = strings.Split(s, " ")
-
-	f := func(i uint64) error {
-		if i <= 4095 { // 12 bits
-			return nil
-		}
-		return fmt.Errorf("%s range exceeded", typ.String())
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-func flowSpecVlanCosParser(rf RouteFamily, typ BGPFlowSpecType, args []string) (FlowSpecComponentInterface, error) {
-	if rf != RF_FS_L2_VPN {
-		return nil, fmt.Errorf("%s is supported for only l2vpn", typ.String())
-	}
-
-	args = normalizeFlowSpecOpValues(args)
-	s := strings.Join(args, " ")
-	for i, name := range EthernetTypeNameMap {
-		s = strings.Replace(s, name, fmt.Sprintf("%d", i), -1)
-	}
-	args = strings.Split(s, " ")
-
-	f := func(i uint64) error {
-		if i <= 7 { // 3 bits
-			return nil
-		}
-		return fmt.Errorf("%s range exceeded", typ.String())
-	}
-
-	return parseFlowSpecNumericOpValues(typ, args, f)
-}
-
-var flowSpecParserMap = map[BGPFlowSpecType]func(RouteFamily, BGPFlowSpecType, []string) (FlowSpecComponentInterface, error){
-	FLOW_SPEC_TYPE_DST_PREFIX:    flowSpecPrefixParser,
-	FLOW_SPEC_TYPE_SRC_PREFIX:    flowSpecPrefixParser,
-	FLOW_SPEC_TYPE_IP_PROTO:      flowSpecIpProtoParser,
-	FLOW_SPEC_TYPE_PORT:          flowSpecNumeric2BytesParser,
-	FLOW_SPEC_TYPE_DST_PORT:      flowSpecNumeric2BytesParser,
-	FLOW_SPEC_TYPE_SRC_PORT:      flowSpecNumeric2BytesParser,
-	FLOW_SPEC_TYPE_ICMP_TYPE:     flowSpecNumeric1ByteParser,
-	FLOW_SPEC_TYPE_ICMP_CODE:     flowSpecNumeric1ByteParser,
-	FLOW_SPEC_TYPE_TCP_FLAG:      flowSpecTcpFlagParser,
-	FLOW_SPEC_TYPE_PKT_LEN:       flowSpecNumeric2BytesParser,
-	FLOW_SPEC_TYPE_DSCP:          flowSpecDscpParser,
-	FLOW_SPEC_TYPE_FRAGMENT:      flowSpecFragmentParser,
-	FLOW_SPEC_TYPE_LABEL:         flowSpecLabelParser,
-	FLOW_SPEC_TYPE_ETHERNET_TYPE: flowSpecEtherTypeParser,
-	FLOW_SPEC_TYPE_DST_MAC:       flowSpecMacParser,
-	FLOW_SPEC_TYPE_SRC_MAC:       flowSpecMacParser,
-	FLOW_SPEC_TYPE_LLC_DSAP:      flowSpecLlcParser,
-	FLOW_SPEC_TYPE_LLC_SSAP:      flowSpecLlcParser,
-	FLOW_SPEC_TYPE_LLC_CONTROL:   flowSpecLlcParser,
-	FLOW_SPEC_TYPE_SNAP:          flowSpecSnapParser,
-	FLOW_SPEC_TYPE_VID:           flowSpecVlanIDParser,
-	FLOW_SPEC_TYPE_COS:           flowSpecVlanCosParser,
-	FLOW_SPEC_TYPE_INNER_VID:     flowSpecVlanIDParser,
-	FLOW_SPEC_TYPE_INNER_COS:     flowSpecVlanCosParser,
-}
-
-func extractFlowSpecArgs(args []string) map[BGPFlowSpecType][]string {
-	m := make(map[BGPFlowSpecType][]string, len(FlowSpecValueMap))
-	var typ BGPFlowSpecType
-	for _, arg := range args {
-		if t, ok := FlowSpecValueMap[arg]; ok {
-			typ = t
-			m[typ] = make([]string, 0)
-		} else {
-			m[typ] = append(m[typ], arg)
-		}
-	}
-	return m
-}
-
-func ParseFlowSpecComponents(rf RouteFamily, arg string) ([]FlowSpecComponentInterface, error) {
-	_, safi := RouteFamilyToAfiSafi(rf)
-	switch safi {
-	case SAFI_FLOW_SPEC_UNICAST, SAFI_FLOW_SPEC_VPN:
-		// Valid
-	default:
-		return nil, fmt.Errorf("invalid address family: %s", rf.String())
-	}
-
-	typeArgs := extractFlowSpecArgs(strings.Split(arg, " "))
-	rules := make([]FlowSpecComponentInterface, 0, len(typeArgs))
-	for typ, args := range typeArgs {
-		parser, ok := flowSpecParserMap[typ]
-		if !ok {
-			return nil, fmt.Errorf("unsupported traffic filtering rule type: %s", typ.String())
-		}
-		if len(args) == 0 {
-			return nil, fmt.Errorf("specify traffic filtering rules for %s", typ.String())
-		}
-		rule, err := parser(rf, typ, args)
-		if err != nil {
-			return nil, err
-		}
-		rules = append(rules, rule)
-	}
-	return rules, nil
-}
-
-func (t BGPFlowSpecType) String() string {
-	name, ok := FlowSpecNameMap[t]
-	if !ok {
-		return fmt.Sprintf("%s(%d)", FlowSpecNameMap[FLOW_SPEC_TYPE_UNKNOWN], t)
-	}
-	return name
-}
-
-type FlowSpecComponentInterface interface {
-	DecodeFromBytes([]byte, ...*MarshallingOption) error
-	Serialize(...*MarshallingOption) ([]byte, error)
-	Len(...*MarshallingOption) int
-	Type() BGPFlowSpecType
-	String() string
-}
-
-type flowSpecPrefix struct {
-	Prefix AddrPrefixInterface
-	typ    BGPFlowSpecType
-}
-
-func (p *flowSpecPrefix) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	p.typ = BGPFlowSpecType(data[0])
-	return p.Prefix.DecodeFromBytes(data[1:], options...)
-}
-
-func (p *flowSpecPrefix) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := []byte{byte(p.Type())}
-	bbuf, err := p.Prefix.Serialize(options...)
-	if err != nil {
-		return nil, err
-	}
-	return append(buf, bbuf...), nil
-}
-
-func (p *flowSpecPrefix) Len(options ...*MarshallingOption) int {
-	buf, _ := p.Serialize(options...)
-	return len(buf)
-}
-
-func (p *flowSpecPrefix) Type() BGPFlowSpecType {
-	return p.typ
-}
-
-func (p *flowSpecPrefix) String() string {
-	return fmt.Sprintf("[%s: %s]", p.Type(), p.Prefix.String())
-}
-
-func (p *flowSpecPrefix) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPFlowSpecType     `json:"type"`
-		Value AddrPrefixInterface `json:"value"`
-	}{
-		Type:  p.Type(),
-		Value: p.Prefix,
-	})
-}
-
-type flowSpecPrefix6 struct {
-	Prefix AddrPrefixInterface
-	Offset uint8
-	typ    BGPFlowSpecType
-}
-
-// draft-ietf-idr-flow-spec-v6-06
-// <type (1 octet), prefix length (1 octet), prefix offset(1 octet), prefix>
-func (p *flowSpecPrefix6) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	p.typ = BGPFlowSpecType(data[0])
-	p.Offset = data[2]
-	prefix := append([]byte{data[1]}, data[3:]...)
-	return p.Prefix.DecodeFromBytes(prefix, options...)
-}
-
-func (p *flowSpecPrefix6) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := []byte{byte(p.Type())}
-	bbuf, err := p.Prefix.Serialize(options...)
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, bbuf[0])
-	buf = append(buf, p.Offset)
-	return append(buf, bbuf[1:]...), nil
-}
-
-func (p *flowSpecPrefix6) Len(options ...*MarshallingOption) int {
-	buf, _ := p.Serialize(options...)
-	return len(buf)
-}
-
-func (p *flowSpecPrefix6) Type() BGPFlowSpecType {
-	return p.typ
-}
-
-func (p *flowSpecPrefix6) String() string {
-	return fmt.Sprintf("[%s: %s/%d]", p.Type(), p.Prefix.String(), p.Offset)
-}
-
-func (p *flowSpecPrefix6) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type   BGPFlowSpecType     `json:"type"`
-		Value  AddrPrefixInterface `json:"value"`
-		Offset uint8               `json:"offset"`
-	}{
-		Type:   p.Type(),
-		Value:  p.Prefix,
-		Offset: p.Offset,
-	})
-}
-
-type FlowSpecDestinationPrefix struct {
-	flowSpecPrefix
-}
-
-func NewFlowSpecDestinationPrefix(prefix AddrPrefixInterface) *FlowSpecDestinationPrefix {
-	return &FlowSpecDestinationPrefix{flowSpecPrefix{prefix, FLOW_SPEC_TYPE_DST_PREFIX}}
-}
-
-type FlowSpecSourcePrefix struct {
-	flowSpecPrefix
-}
-
-func NewFlowSpecSourcePrefix(prefix AddrPrefixInterface) *FlowSpecSourcePrefix {
-	return &FlowSpecSourcePrefix{flowSpecPrefix{prefix, FLOW_SPEC_TYPE_SRC_PREFIX}}
-}
-
-type FlowSpecDestinationPrefix6 struct {
-	flowSpecPrefix6
-}
-
-func NewFlowSpecDestinationPrefix6(prefix AddrPrefixInterface, offset uint8) *FlowSpecDestinationPrefix6 {
-	return &FlowSpecDestinationPrefix6{flowSpecPrefix6{prefix, offset, FLOW_SPEC_TYPE_DST_PREFIX}}
-}
-
-type FlowSpecSourcePrefix6 struct {
-	flowSpecPrefix6
-}
-
-func NewFlowSpecSourcePrefix6(prefix AddrPrefixInterface, offset uint8) *FlowSpecSourcePrefix6 {
-	return &FlowSpecSourcePrefix6{flowSpecPrefix6{prefix, offset, FLOW_SPEC_TYPE_SRC_PREFIX}}
-}
-
-type flowSpecMac struct {
-	Mac net.HardwareAddr
-	typ BGPFlowSpecType
-}
-
-func (p *flowSpecMac) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if len(data) < 2 || len(data) < 2+int(data[1]) {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all mac bits available")
-	}
-	p.typ = BGPFlowSpecType(data[0])
-	p.Mac = net.HardwareAddr(data[2 : 2+int(data[1])])
-	return nil
-}
-
-func (p *flowSpecMac) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	if len(p.Mac) == 0 {
-		return nil, fmt.Errorf("mac unset")
-	}
-	buf := []byte{byte(p.Type()), byte(len(p.Mac))}
-	return append(buf, []byte(p.Mac)...), nil
-}
-
-func (p *flowSpecMac) Len(options ...*MarshallingOption) int {
-	return 2 + len(p.Mac)
-}
-
-func (p *flowSpecMac) Type() BGPFlowSpecType {
-	return p.typ
-}
-
-func (p *flowSpecMac) String() string {
-	return fmt.Sprintf("[%s: %s]", p.Type(), p.Mac.String())
-}
-
-func (p *flowSpecMac) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPFlowSpecType `json:"type"`
-		Value string          `json:"value"`
-	}{
-		Type:  p.Type(),
-		Value: p.Mac.String(),
-	})
-}
-
-type FlowSpecSourceMac struct {
-	flowSpecMac
-}
-
-func NewFlowSpecSourceMac(mac net.HardwareAddr) *FlowSpecSourceMac {
-	return &FlowSpecSourceMac{flowSpecMac{Mac: mac, typ: FLOW_SPEC_TYPE_SRC_MAC}}
-}
-
-type FlowSpecDestinationMac struct {
-	flowSpecMac
-}
-
-func NewFlowSpecDestinationMac(mac net.HardwareAddr) *FlowSpecDestinationMac {
-	return &FlowSpecDestinationMac{flowSpecMac{Mac: mac, typ: FLOW_SPEC_TYPE_DST_MAC}}
-}
-
-type FlowSpecComponentItem struct {
-	Op    uint8  `json:"op"`
-	Value uint64 `json:"value"`
-}
-
-func (v *FlowSpecComponentItem) Len() int {
-	return 1 << ((uint32(v.Op) >> 4) & 0x3)
-}
-
-func (v *FlowSpecComponentItem) Serialize() ([]byte, error) {
-	if v.Op > math.MaxUint8 {
-		return nil, fmt.Errorf("invalid op size: %d", v.Op)
-	}
-
-	order := uint32(math.Log2(float64(v.Len())))
-	buf := make([]byte, 1+(1<<order))
-	buf[0] = byte(uint32(v.Op) | order<<4)
-	switch order {
-	case 0:
-		buf[1] = byte(v.Value)
-	case 1:
-		binary.BigEndian.PutUint16(buf[1:], uint16(v.Value))
-	case 2:
-		binary.BigEndian.PutUint32(buf[1:], uint32(v.Value))
-	case 3:
-		binary.BigEndian.PutUint64(buf[1:], uint64(v.Value))
-	default:
-		return nil, fmt.Errorf("invalid value size(too big): %d", v.Value)
-	}
-	return buf, nil
-}
-
-func NewFlowSpecComponentItem(op uint8, value uint64) *FlowSpecComponentItem {
-	v := &FlowSpecComponentItem{op, value}
-	order := uint32(math.Log2(float64(v.Len())))
-	// we don't know if not initialized properly or initialized to
-	// zero...
-	if order == 0 {
-		order = func() uint32 {
-			for i := 0; i < 3; i++ {
-				if v.Value < (1 << ((1 << uint(i)) * 8)) {
-					return uint32(i)
-				}
-			}
-			// return invalid order
-			return 4
-		}()
-	}
-	if order > 3 {
-		return nil
-	}
-	v.Op = uint8(uint32(v.Op) | order<<4)
-	return v
-}
-
-type FlowSpecComponent struct {
-	Items []*FlowSpecComponentItem
-	typ   BGPFlowSpecType
-}
-
-func (p *FlowSpecComponent) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	p.typ = BGPFlowSpecType(data[0])
-	data = data[1:]
-	p.Items = make([]*FlowSpecComponentItem, 0)
-	for {
-		if len(data) < 2 {
-			return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all flowspec component bytes available")
-		}
-		op := data[0]
-		end := op & 0x80
-		l := 1 << ((op >> 4) & 0x3) // (min, max) = (1, 8)
-		v := make([]byte, 8)
-		copy(v[8-l:], data[1:1+l])
-		i := binary.BigEndian.Uint64(v)
-		item := &FlowSpecComponentItem{op, i}
-		p.Items = append(p.Items, item)
-		if end > 0 {
-			break
-		}
-		data = data[1+l:]
-	}
-	return nil
-}
-
-func (p *FlowSpecComponent) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := []byte{byte(p.Type())}
-	for _, v := range p.Items {
-		bbuf, err := v.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, bbuf...)
-	}
-	return buf, nil
-}
-
-func (p *FlowSpecComponent) Len(options ...*MarshallingOption) int {
-	l := 1
-	for _, item := range p.Items {
-		l += item.Len() + 1
-	}
-	return l
-}
-
-func (p *FlowSpecComponent) Type() BGPFlowSpecType {
-	return p.typ
-}
-
-func formatRaw(op uint8, value uint64) string {
-	return fmt.Sprintf("op:%b,value:%d", op, value)
-}
-
-func formatNumeric(op uint8, value uint64) string {
-	cmpFlag := DECNumOp(op & 0x7) // lower 3 bits
-	if cmpFlag == DEC_NUM_OP_TRUE || cmpFlag == DEC_NUM_OP_FALSE {
-		// Omit value field
-		return DECNumOp(op).String()
-	}
-	return fmt.Sprint(DECNumOp(op).String(), value)
-}
-
-func formatProto(op uint8, value uint64) string {
-	cmpFlag := DECNumOp(op & 0x7) // lower 3 bits
-	if cmpFlag == DEC_NUM_OP_TRUE || cmpFlag == DEC_NUM_OP_FALSE {
-		// Omit value field
-		return DECNumOp(op).String()
-	}
-	return fmt.Sprint(DECNumOp(op).String(), Protocol(value).String())
-}
-
-func formatTCPFlag(op uint8, value uint64) string {
-	return fmt.Sprint(BitmaskFlagOp(op).String(), TCPFlag(value).String())
-}
-
-func formatFragment(op uint8, value uint64) string {
-	return fmt.Sprint(BitmaskFlagOp(op).String(), FragmentFlag(value).String())
-}
-
-func formatEtherType(op uint8, value uint64) string {
-	cmpFlag := DECNumOp(op & 0x7) // lower 3 bits
-	if cmpFlag == DEC_NUM_OP_TRUE || cmpFlag == DEC_NUM_OP_FALSE {
-		// Omit value field
-		return DECNumOp(op).String()
-	}
-	return fmt.Sprint(DECNumOp(op).String(), EthernetType(value).String())
-}
-
-var flowSpecFormatMap = map[BGPFlowSpecType]func(op uint8, value uint64) string{
-	FLOW_SPEC_TYPE_UNKNOWN:       formatRaw,
-	FLOW_SPEC_TYPE_IP_PROTO:      formatProto,
-	FLOW_SPEC_TYPE_PORT:          formatNumeric,
-	FLOW_SPEC_TYPE_DST_PORT:      formatNumeric,
-	FLOW_SPEC_TYPE_SRC_PORT:      formatNumeric,
-	FLOW_SPEC_TYPE_ICMP_TYPE:     formatNumeric,
-	FLOW_SPEC_TYPE_ICMP_CODE:     formatNumeric,
-	FLOW_SPEC_TYPE_TCP_FLAG:      formatTCPFlag,
-	FLOW_SPEC_TYPE_PKT_LEN:       formatNumeric,
-	FLOW_SPEC_TYPE_DSCP:          formatNumeric,
-	FLOW_SPEC_TYPE_FRAGMENT:      formatFragment,
-	FLOW_SPEC_TYPE_LABEL:         formatNumeric,
-	FLOW_SPEC_TYPE_ETHERNET_TYPE: formatEtherType,
-	FLOW_SPEC_TYPE_LLC_DSAP:      formatNumeric,
-	FLOW_SPEC_TYPE_LLC_SSAP:      formatNumeric,
-	FLOW_SPEC_TYPE_LLC_CONTROL:   formatNumeric,
-	FLOW_SPEC_TYPE_SNAP:          formatNumeric,
-	FLOW_SPEC_TYPE_VID:           formatNumeric,
-	FLOW_SPEC_TYPE_COS:           formatNumeric,
-	FLOW_SPEC_TYPE_INNER_VID:     formatNumeric,
-	FLOW_SPEC_TYPE_INNER_COS:     formatNumeric,
-}
-
-func (p *FlowSpecComponent) String() string {
-	f := flowSpecFormatMap[FLOW_SPEC_TYPE_UNKNOWN]
-	if _, ok := flowSpecFormatMap[p.typ]; ok {
-		f = flowSpecFormatMap[p.typ]
-	}
-
-	items := make([]string, 0, len(p.Items))
-	for _, i := range p.Items {
-		items = append(items, f(i.Op, i.Value))
-	}
-	// Removes leading and tailing spaces
-	value := strings.TrimSpace(strings.Join(items, ""))
-
-	return fmt.Sprintf("[%s: %s]", p.typ, value)
-}
-
-func (p *FlowSpecComponent) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPFlowSpecType          `json:"type"`
-		Value []*FlowSpecComponentItem `json:"value"`
-	}{
-		Type:  p.Type(),
-		Value: p.Items,
-	})
-}
-
-func NewFlowSpecComponent(typ BGPFlowSpecType, items []*FlowSpecComponentItem) *FlowSpecComponent {
-	// Set end-of-list bit on the last item and unset them on the others.
-	for i, v := range items {
-		if i == len(items)-1 {
-			v.Op |= 0x80
-		} else {
-			v.Op &^= 0x80
-		}
-
-	}
-	return &FlowSpecComponent{
-		Items: items,
-		typ:   typ,
-	}
-}
-
-type FlowSpecUnknown struct {
-	Value []byte
-}
-
-func (p *FlowSpecUnknown) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	p.Value = data
-	return nil
-}
-
-func (p *FlowSpecUnknown) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	return p.Value, nil
-}
-
-func (p *FlowSpecUnknown) Len(options ...*MarshallingOption) int {
-	return len(p.Value)
-}
-
-func (p *FlowSpecUnknown) Type() BGPFlowSpecType {
-	if len(p.Value) > 0 {
-		return BGPFlowSpecType(p.Value[0])
-	}
-	return FLOW_SPEC_TYPE_UNKNOWN
-}
-
-func (p *FlowSpecUnknown) String() string {
-	return fmt.Sprintf("[unknown:%v]", p.Value)
-}
-
-func (p *FlowSpecUnknown) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPFlowSpecType `json:"type"`
-		Value string          `json:"value"`
-	}{
-		Type:  p.Type(),
-		Value: string(p.Value),
-	})
-}
-
-type FlowSpecNLRI struct {
-	PrefixDefault
-	Value []FlowSpecComponentInterface
-	rf    RouteFamily
-	rd    RouteDistinguisherInterface
-}
-
-func (n *FlowSpecNLRI) AFI() uint16 {
-	afi, _ := RouteFamilyToAfiSafi(n.rf)
-	return afi
-}
-
-func (n *FlowSpecNLRI) SAFI() uint8 {
-	_, safi := RouteFamilyToAfiSafi(n.rf)
-	return safi
-}
-
-func (n *FlowSpecNLRI) RD() RouteDistinguisherInterface {
-	return n.rd
-}
-
-func (n *FlowSpecNLRI) decodeFromBytes(rf RouteFamily, data []byte, options ...*MarshallingOption) error {
-	if IsAddPathEnabled(true, rf, options) {
-		var err error
-		data, err = n.decodePathIdentifier(data)
-		if err != nil {
-			return err
-		}
-	}
-	var length int
-	if (data[0]>>4) == 0xf && len(data) > 2 {
-		length = int(binary.BigEndian.Uint16(data[0:2]))
-		data = data[2:]
-	} else if len(data) > 1 {
-		length = int(data[0])
-		data = data[1:]
-	} else {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all flowspec component bytes available")
-	}
-
-	n.rf = rf
-
-	if n.SAFI() == SAFI_FLOW_SPEC_VPN {
-		if length < 8 {
-			return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all flowspec component bytes available")
-		}
-		n.rd = GetRouteDistinguisher(data[:8])
-		data = data[8:]
-		length -= 8
-	}
-
-	for l := length; l > 0; {
-		if len(data) == 0 {
-			return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all flowspec component bytes available")
-		}
-		t := BGPFlowSpecType(data[0])
-		var i FlowSpecComponentInterface
-		switch t {
-		case FLOW_SPEC_TYPE_DST_PREFIX:
-			switch {
-			case rf>>16 == AFI_IP:
-				i = NewFlowSpecDestinationPrefix(NewIPAddrPrefix(0, ""))
-			case rf>>16 == AFI_IP6:
-				i = NewFlowSpecDestinationPrefix6(NewIPv6AddrPrefix(0, ""), 0)
-			default:
-				return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid address family: %v", rf))
-			}
-		case FLOW_SPEC_TYPE_SRC_PREFIX:
-			switch {
-			case rf>>16 == AFI_IP:
-				i = NewFlowSpecSourcePrefix(NewIPAddrPrefix(0, ""))
-			case rf>>16 == AFI_IP6:
-				i = NewFlowSpecSourcePrefix6(NewIPv6AddrPrefix(0, ""), 0)
-			default:
-				return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid address family: %v", rf))
-			}
-		case FLOW_SPEC_TYPE_SRC_MAC:
-			switch rf {
-			case RF_FS_L2_VPN:
-				i = NewFlowSpecSourceMac(nil)
-			default:
-				return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid address family: %v", rf))
-			}
-		case FLOW_SPEC_TYPE_DST_MAC:
-			switch rf {
-			case RF_FS_L2_VPN:
-				i = NewFlowSpecDestinationMac(nil)
-			default:
-				return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Invalid address family: %v", rf))
-			}
-		case FLOW_SPEC_TYPE_IP_PROTO, FLOW_SPEC_TYPE_PORT, FLOW_SPEC_TYPE_DST_PORT, FLOW_SPEC_TYPE_SRC_PORT,
-			FLOW_SPEC_TYPE_ICMP_TYPE, FLOW_SPEC_TYPE_ICMP_CODE, FLOW_SPEC_TYPE_TCP_FLAG, FLOW_SPEC_TYPE_PKT_LEN,
-			FLOW_SPEC_TYPE_DSCP, FLOW_SPEC_TYPE_FRAGMENT, FLOW_SPEC_TYPE_LABEL, FLOW_SPEC_TYPE_ETHERNET_TYPE,
-			FLOW_SPEC_TYPE_LLC_DSAP, FLOW_SPEC_TYPE_LLC_SSAP, FLOW_SPEC_TYPE_LLC_CONTROL, FLOW_SPEC_TYPE_SNAP,
-			FLOW_SPEC_TYPE_VID, FLOW_SPEC_TYPE_COS, FLOW_SPEC_TYPE_INNER_VID, FLOW_SPEC_TYPE_INNER_COS:
-			i = NewFlowSpecComponent(t, nil)
-		default:
-			i = &FlowSpecUnknown{}
-		}
-
-		err := i.DecodeFromBytes(data, options...)
-		if err != nil {
-			i = &FlowSpecUnknown{data}
-		}
-		l -= i.Len(options...)
-		data = data[i.Len(options...):]
-		n.Value = append(n.Value, i)
-	}
-
-	// Sort Traffic Filtering Rules in types order to avoid the unordered rules
-	// are determined different.
-	sort.SliceStable(n.Value, func(i, j int) bool { return n.Value[i].Type() < n.Value[j].Type() })
-
-	return nil
-}
-
-func (n *FlowSpecNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 0, 32)
-	if n.SAFI() == SAFI_FLOW_SPEC_VPN {
-		if n.rd == nil {
-			return nil, fmt.Errorf("RD is nil")
-		}
-		b, err := n.rd.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, b...)
-	}
-	for _, v := range n.Value {
-		b, err := v.Serialize(options...)
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, b...)
-	}
-	length := n.Len(options...)
-	if length > 0xfff {
-		return nil, fmt.Errorf("Too large: %d", length)
-	} else if length < 0xf0 {
-		length -= 1
-		buf = append([]byte{byte(length)}, buf...)
-	} else {
-		length -= 2
-		b := make([]byte, 2)
-		binary.BigEndian.PutUint16(buf, uint16(length))
-		buf = append(b, buf...)
-	}
-
-	if IsAddPathEnabled(false, n.rf, options) {
-		id, err := n.serializeIdentifier()
-		if err != nil {
-			return nil, err
-		}
-		return append(id, buf...), nil
-	}
-	return buf, nil
-}
-
-func (n *FlowSpecNLRI) Len(options ...*MarshallingOption) int {
-	l := 0
-	if n.SAFI() == SAFI_FLOW_SPEC_VPN {
-		l += n.RD().Len()
-	}
-	for _, v := range n.Value {
-		l += v.Len(options...)
-	}
-	if l < 0xf0 {
-		return l + 1
-	} else {
-		return l + 2
-	}
-}
-
-func (n *FlowSpecNLRI) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0, 32))
-	if n.SAFI() == SAFI_FLOW_SPEC_VPN {
-		buf.WriteString(fmt.Sprintf("[rd: %s]", n.rd))
-	}
-	for _, v := range n.Value {
-		buf.WriteString(v.String())
-	}
-	return buf.String()
-}
-
-func (n *FlowSpecNLRI) MarshalJSON() ([]byte, error) {
-	if n.rd != nil {
-		return json.Marshal(struct {
-			RD    RouteDistinguisherInterface  `json:"rd"`
-			Value []FlowSpecComponentInterface `json:"value"`
-		}{
-			RD:    n.rd,
-			Value: n.Value,
-		})
-	}
-	return json.Marshal(struct {
-		Value []FlowSpecComponentInterface `json:"value"`
-	}{
-		Value: n.Value,
-	})
-
-}
-
-//
-// CompareFlowSpecNLRI(n, m) returns
-// -1 when m has precedence
-//  0 when n and m have same precedence
-//  1 when n has precedence
-//
-func CompareFlowSpecNLRI(n, m *FlowSpecNLRI) (int, error) {
-	family := AfiSafiToRouteFamily(n.AFI(), n.SAFI())
-	if family != AfiSafiToRouteFamily(m.AFI(), m.SAFI()) {
-		return 0, fmt.Errorf("address family mismatch")
-	}
-	longer := n.Value
-	shorter := m.Value
-	invert := 1
-	if n.SAFI() == SAFI_FLOW_SPEC_VPN {
-		k, _ := n.Serialize()
-		l, _ := m.Serialize()
-		if result := bytes.Compare(k, l); result != 0 {
-			return result, nil
-		}
-	}
-	if len(n.Value) < len(m.Value) {
-		longer = m.Value
-		shorter = n.Value
-		invert = -1
-	}
-	for idx, v := range longer {
-		if len(shorter) < idx+1 {
-			return invert, nil
-		}
-		w := shorter[idx]
-		if v.Type() < w.Type() {
-			return invert, nil
-		} else if v.Type() > w.Type() {
-			return invert * -1, nil
-		} else if v.Type() == FLOW_SPEC_TYPE_DST_PREFIX || v.Type() == FLOW_SPEC_TYPE_SRC_PREFIX {
-			// RFC5575 5.1
-			//
-			// For IP prefix values (IP destination and source prefix) precedence is
-			// given to the lowest IP value of the common prefix length; if the
-			// common prefix is equal, then the most specific prefix has precedence.
-			var p, q *IPAddrPrefixDefault
-			var pCommon, qCommon uint64
-			if n.AFI() == AFI_IP {
-				if v.Type() == FLOW_SPEC_TYPE_DST_PREFIX {
-					p = &v.(*FlowSpecDestinationPrefix).Prefix.(*IPAddrPrefix).IPAddrPrefixDefault
-					q = &w.(*FlowSpecDestinationPrefix).Prefix.(*IPAddrPrefix).IPAddrPrefixDefault
-				} else {
-					p = &v.(*FlowSpecSourcePrefix).Prefix.(*IPAddrPrefix).IPAddrPrefixDefault
-					q = &w.(*FlowSpecSourcePrefix).Prefix.(*IPAddrPrefix).IPAddrPrefixDefault
-				}
-				min := p.Length
-				if q.Length < p.Length {
-					min = q.Length
-				}
-				pCommon = uint64(binary.BigEndian.Uint32([]byte(p.Prefix.To4())) >> (32 - min))
-				qCommon = uint64(binary.BigEndian.Uint32([]byte(q.Prefix.To4())) >> (32 - min))
-			} else if n.AFI() == AFI_IP6 {
-				if v.Type() == FLOW_SPEC_TYPE_DST_PREFIX {
-					p = &v.(*FlowSpecDestinationPrefix6).Prefix.(*IPv6AddrPrefix).IPAddrPrefixDefault
-					q = &w.(*FlowSpecDestinationPrefix6).Prefix.(*IPv6AddrPrefix).IPAddrPrefixDefault
-				} else {
-					p = &v.(*FlowSpecSourcePrefix6).Prefix.(*IPv6AddrPrefix).IPAddrPrefixDefault
-					q = &w.(*FlowSpecSourcePrefix6).Prefix.(*IPv6AddrPrefix).IPAddrPrefixDefault
-				}
-				min := uint(p.Length)
-				if q.Length < p.Length {
-					min = uint(q.Length)
-				}
-				var mask uint
-				if min-64 > 0 {
-					mask = min - 64
-				}
-				pCommon = binary.BigEndian.Uint64([]byte(p.Prefix.To16()[:8])) >> mask
-				qCommon = binary.BigEndian.Uint64([]byte(q.Prefix.To16()[:8])) >> mask
-				if pCommon == qCommon && mask == 0 {
-					mask = 64 - min
-					pCommon = binary.BigEndian.Uint64([]byte(p.Prefix.To16()[8:])) >> mask
-					qCommon = binary.BigEndian.Uint64([]byte(q.Prefix.To16()[8:])) >> mask
-				}
-			}
-
-			if pCommon < qCommon {
-				return invert, nil
-			} else if pCommon > qCommon {
-				return invert * -1, nil
-			} else if p.Length > q.Length {
-				return invert, nil
-			} else if p.Length < q.Length {
-				return invert * -1, nil
-			}
-
-		} else {
-			// RFC5575 5.1
-			//
-			// For all other component types, unless otherwise specified, the
-			// comparison is performed by comparing the component data as a binary
-			// string using the memcmp() function as defined by the ISO C standard.
-			// For strings of different lengths, the common prefix is compared.  If
-			// equal, the longest string is considered to have higher precedence
-			// than the shorter one.
-			p, _ := v.Serialize()
-			q, _ := w.Serialize()
-			min := len(p)
-			if len(q) < len(p) {
-				min = len(q)
-			}
-			if result := bytes.Compare(p[:min], q[:min]); result < 0 {
-				return invert, nil
-			} else if result > 0 {
-				return invert * -1, nil
-			} else if len(p) > len(q) {
-				return invert, nil
-			} else if len(q) > len(p) {
-				return invert * -1, nil
-			}
-		}
-	}
-	return 0, nil
-}
-
-type FlowSpecIPv4Unicast struct {
-	FlowSpecNLRI
-}
-
-func (n *FlowSpecIPv4Unicast) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data, options...)
-}
-
-func NewFlowSpecIPv4Unicast(value []FlowSpecComponentInterface) *FlowSpecIPv4Unicast {
-	sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() })
-	return &FlowSpecIPv4Unicast{
-		FlowSpecNLRI: FlowSpecNLRI{
-			Value: value,
-			rf:    RF_FS_IPv4_UC,
-		},
-	}
-}
-
-type FlowSpecIPv4VPN struct {
-	FlowSpecNLRI
-}
-
-func (n *FlowSpecIPv4VPN) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data, options...)
-}
-
-func NewFlowSpecIPv4VPN(rd RouteDistinguisherInterface, value []FlowSpecComponentInterface) *FlowSpecIPv4VPN {
-	sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() })
-	return &FlowSpecIPv4VPN{
-		FlowSpecNLRI: FlowSpecNLRI{
-			Value: value,
-			rf:    RF_FS_IPv4_VPN,
-			rd:    rd,
-		},
-	}
-}
-
-type FlowSpecIPv6Unicast struct {
-	FlowSpecNLRI
-}
-
-func (n *FlowSpecIPv6Unicast) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data, options...)
-}
-
-func NewFlowSpecIPv6Unicast(value []FlowSpecComponentInterface) *FlowSpecIPv6Unicast {
-	sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() })
-	return &FlowSpecIPv6Unicast{
-		FlowSpecNLRI: FlowSpecNLRI{
-			Value: value,
-			rf:    RF_FS_IPv6_UC,
-		},
-	}
-}
-
-type FlowSpecIPv6VPN struct {
-	FlowSpecNLRI
-}
-
-func (n *FlowSpecIPv6VPN) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data, options...)
-}
-
-func NewFlowSpecIPv6VPN(rd RouteDistinguisherInterface, value []FlowSpecComponentInterface) *FlowSpecIPv6VPN {
-	sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() })
-	return &FlowSpecIPv6VPN{
-		FlowSpecNLRI: FlowSpecNLRI{
-			Value: value,
-			rf:    RF_FS_IPv6_VPN,
-			rd:    rd,
-		},
-	}
-}
-
-type FlowSpecL2VPN struct {
-	FlowSpecNLRI
-}
-
-func (n *FlowSpecL2VPN) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	return n.decodeFromBytes(AfiSafiToRouteFamily(n.AFI(), n.SAFI()), data)
-}
-
-func NewFlowSpecL2VPN(rd RouteDistinguisherInterface, value []FlowSpecComponentInterface) *FlowSpecL2VPN {
-	sort.SliceStable(value, func(i, j int) bool { return value[i].Type() < value[j].Type() })
-	return &FlowSpecL2VPN{
-		FlowSpecNLRI: FlowSpecNLRI{
-			Value: value,
-			rf:    RF_FS_L2_VPN,
-			rd:    rd,
-		},
-	}
-}
-
-type OpaqueNLRI struct {
-	PrefixDefault
-	Length uint16
-	Key    []byte
-	Value  []byte
-}
-
-func (n *OpaqueNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if len(data) < 2 {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all OpaqueNLRI bytes available")
-	}
-	if IsAddPathEnabled(true, RF_OPAQUE, options) {
-		var err error
-		data, err = n.decodePathIdentifier(data)
-		if err != nil {
-			return err
-		}
-	}
-	n.Length = binary.BigEndian.Uint16(data[0:2])
-	if len(data)-2 < int(n.Length) {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all OpaqueNLRI bytes available")
-	}
-	n.Key = data[2 : 2+n.Length]
-	n.Value = data[2+n.Length:]
-	return nil
-}
-
-func (n *OpaqueNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	if len(n.Key) > math.MaxUint16 {
-		return nil, fmt.Errorf("Key length too big")
-	}
-	buf := make([]byte, 2)
-	binary.BigEndian.PutUint16(buf, uint16(len(n.Key)))
-	buf = append(buf, n.Key...)
-	buf = append(buf, n.Value...)
-	if IsAddPathEnabled(false, RF_OPAQUE, options) {
-		id, err := n.serializeIdentifier()
-		if err != nil {
-			return nil, err
-		}
-		return append(id, buf...), nil
-	}
-	return buf, nil
-}
-
-func (n *OpaqueNLRI) AFI() uint16 {
-	return AFI_OPAQUE
-}
-
-func (n *OpaqueNLRI) SAFI() uint8 {
-	return SAFI_KEY_VALUE
-}
-
-func (n *OpaqueNLRI) Len(options ...*MarshallingOption) int {
-	return 2 + len(n.Key) + len(n.Value)
-}
-
-func (n *OpaqueNLRI) String() string {
-	return fmt.Sprintf("%s", n.Key)
-}
-
-func (n *OpaqueNLRI) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Key   string `json:"key"`
-		Value string `json:"value"`
-	}{
-		Key:   string(n.Key),
-		Value: string(n.Value),
-	})
-}
-
-func NewOpaqueNLRI(key, value []byte) *OpaqueNLRI {
-	return &OpaqueNLRI{
-		Key:   key,
-		Value: value,
-	}
-}
-
-func AfiSafiToRouteFamily(afi uint16, safi uint8) RouteFamily {
-	return RouteFamily(int(afi)<<16 | int(safi))
-}
-
-func RouteFamilyToAfiSafi(rf RouteFamily) (uint16, uint8) {
-	return uint16(int(rf) >> 16), uint8(int(rf) & 0xff)
-}
-
-type RouteFamily int
-
-func (f RouteFamily) String() string {
-	if n, y := AddressFamilyNameMap[f]; y {
-		return n
-	}
-	return fmt.Sprintf("UnknownFamily(%d)", f)
-}
-
-const (
-	RF_IPv4_UC     RouteFamily = AFI_IP<<16 | SAFI_UNICAST
-	RF_IPv6_UC     RouteFamily = AFI_IP6<<16 | SAFI_UNICAST
-	RF_IPv4_MC     RouteFamily = AFI_IP<<16 | SAFI_MULTICAST
-	RF_IPv6_MC     RouteFamily = AFI_IP6<<16 | SAFI_MULTICAST
-	RF_IPv4_VPN    RouteFamily = AFI_IP<<16 | SAFI_MPLS_VPN
-	RF_IPv6_VPN    RouteFamily = AFI_IP6<<16 | SAFI_MPLS_VPN
-	RF_IPv4_VPN_MC RouteFamily = AFI_IP<<16 | SAFI_MPLS_VPN_MULTICAST
-	RF_IPv6_VPN_MC RouteFamily = AFI_IP6<<16 | SAFI_MPLS_VPN_MULTICAST
-	RF_IPv4_MPLS   RouteFamily = AFI_IP<<16 | SAFI_MPLS_LABEL
-	RF_IPv6_MPLS   RouteFamily = AFI_IP6<<16 | SAFI_MPLS_LABEL
-	RF_VPLS        RouteFamily = AFI_L2VPN<<16 | SAFI_VPLS
-	RF_EVPN        RouteFamily = AFI_L2VPN<<16 | SAFI_EVPN
-	RF_RTC_UC      RouteFamily = AFI_IP<<16 | SAFI_ROUTE_TARGET_CONSTRAINTS
-	RF_IPv4_ENCAP  RouteFamily = AFI_IP<<16 | SAFI_ENCAPSULATION
-	RF_IPv6_ENCAP  RouteFamily = AFI_IP6<<16 | SAFI_ENCAPSULATION
-	RF_FS_IPv4_UC  RouteFamily = AFI_IP<<16 | SAFI_FLOW_SPEC_UNICAST
-	RF_FS_IPv4_VPN RouteFamily = AFI_IP<<16 | SAFI_FLOW_SPEC_VPN
-	RF_FS_IPv6_UC  RouteFamily = AFI_IP6<<16 | SAFI_FLOW_SPEC_UNICAST
-	RF_FS_IPv6_VPN RouteFamily = AFI_IP6<<16 | SAFI_FLOW_SPEC_VPN
-	RF_FS_L2_VPN   RouteFamily = AFI_L2VPN<<16 | SAFI_FLOW_SPEC_VPN
-	RF_OPAQUE      RouteFamily = AFI_OPAQUE<<16 | SAFI_KEY_VALUE
-)
-
-var AddressFamilyNameMap = map[RouteFamily]string{
-	RF_IPv4_UC:     "ipv4-unicast",
-	RF_IPv6_UC:     "ipv6-unicast",
-	RF_IPv4_MC:     "ipv4-multicast",
-	RF_IPv6_MC:     "ipv6-multicast",
-	RF_IPv4_MPLS:   "ipv4-labelled-unicast",
-	RF_IPv6_MPLS:   "ipv6-labelled-unicast",
-	RF_IPv4_VPN:    "l3vpn-ipv4-unicast",
-	RF_IPv6_VPN:    "l3vpn-ipv6-unicast",
-	RF_IPv4_VPN_MC: "l3vpn-ipv4-multicast",
-	RF_IPv6_VPN_MC: "l3vpn-ipv6-multicast",
-	RF_VPLS:        "l2vpn-vpls",
-	RF_EVPN:        "l2vpn-evpn",
-	RF_RTC_UC:      "rtc",
-	RF_IPv4_ENCAP:  "ipv4-encap",
-	RF_IPv6_ENCAP:  "ipv6-encap",
-	RF_FS_IPv4_UC:  "ipv4-flowspec",
-	RF_FS_IPv4_VPN: "l3vpn-ipv4-flowspec",
-	RF_FS_IPv6_UC:  "ipv6-flowspec",
-	RF_FS_IPv6_VPN: "l3vpn-ipv6-flowspec",
-	RF_FS_L2_VPN:   "l2vpn-flowspec",
-	RF_OPAQUE:      "opaque",
-}
-
-var AddressFamilyValueMap = map[string]RouteFamily{
-	AddressFamilyNameMap[RF_IPv4_UC]:     RF_IPv4_UC,
-	AddressFamilyNameMap[RF_IPv6_UC]:     RF_IPv6_UC,
-	AddressFamilyNameMap[RF_IPv4_MC]:     RF_IPv4_MC,
-	AddressFamilyNameMap[RF_IPv6_MC]:     RF_IPv6_MC,
-	AddressFamilyNameMap[RF_IPv4_MPLS]:   RF_IPv4_MPLS,
-	AddressFamilyNameMap[RF_IPv6_MPLS]:   RF_IPv6_MPLS,
-	AddressFamilyNameMap[RF_IPv4_VPN]:    RF_IPv4_VPN,
-	AddressFamilyNameMap[RF_IPv6_VPN]:    RF_IPv6_VPN,
-	AddressFamilyNameMap[RF_IPv4_VPN_MC]: RF_IPv4_VPN_MC,
-	AddressFamilyNameMap[RF_IPv6_VPN_MC]: RF_IPv6_VPN_MC,
-	AddressFamilyNameMap[RF_VPLS]:        RF_VPLS,
-	AddressFamilyNameMap[RF_EVPN]:        RF_EVPN,
-	AddressFamilyNameMap[RF_RTC_UC]:      RF_RTC_UC,
-	AddressFamilyNameMap[RF_IPv4_ENCAP]:  RF_IPv4_ENCAP,
-	AddressFamilyNameMap[RF_IPv6_ENCAP]:  RF_IPv6_ENCAP,
-	AddressFamilyNameMap[RF_FS_IPv4_UC]:  RF_FS_IPv4_UC,
-	AddressFamilyNameMap[RF_FS_IPv4_VPN]: RF_FS_IPv4_VPN,
-	AddressFamilyNameMap[RF_FS_IPv6_UC]:  RF_FS_IPv6_UC,
-	AddressFamilyNameMap[RF_FS_IPv6_VPN]: RF_FS_IPv6_VPN,
-	AddressFamilyNameMap[RF_FS_L2_VPN]:   RF_FS_L2_VPN,
-	AddressFamilyNameMap[RF_OPAQUE]:      RF_OPAQUE,
-}
-
-func GetRouteFamily(name string) (RouteFamily, error) {
-	if v, ok := AddressFamilyValueMap[name]; ok {
-		return v, nil
-	}
-	return RouteFamily(0), fmt.Errorf("%s isn't a valid route family name", name)
-}
-
-func NewPrefixFromRouteFamily(afi uint16, safi uint8, prefixStr ...string) (prefix AddrPrefixInterface, err error) {
-	family := AfiSafiToRouteFamily(afi, safi)
-
-	f := func(s string) AddrPrefixInterface {
-		addr, net, _ := net.ParseCIDR(s)
-		len, _ := net.Mask.Size()
-		switch family {
-		case RF_IPv4_UC, RF_IPv4_MC:
-			return NewIPAddrPrefix(uint8(len), addr.String())
-		}
-		return NewIPv6AddrPrefix(uint8(len), addr.String())
-	}
-
-	switch family {
-	case RF_IPv4_UC, RF_IPv4_MC:
-		if len(prefixStr) > 0 {
-			prefix = f(prefixStr[0])
-		} else {
-			prefix = NewIPAddrPrefix(0, "")
-		}
-	case RF_IPv6_UC, RF_IPv6_MC:
-		if len(prefixStr) > 0 {
-			prefix = f(prefixStr[0])
-		} else {
-			prefix = NewIPv6AddrPrefix(0, "")
-		}
-	case RF_IPv4_VPN:
-		prefix = NewLabeledVPNIPAddrPrefix(0, "", *NewMPLSLabelStack(), nil)
-	case RF_IPv6_VPN:
-		prefix = NewLabeledVPNIPv6AddrPrefix(0, "", *NewMPLSLabelStack(), nil)
-	case RF_IPv4_MPLS:
-		prefix = NewLabeledIPAddrPrefix(0, "", *NewMPLSLabelStack())
-	case RF_IPv6_MPLS:
-		prefix = NewLabeledIPv6AddrPrefix(0, "", *NewMPLSLabelStack())
-	case RF_EVPN:
-		prefix = NewEVPNNLRI(0, nil)
-	case RF_RTC_UC:
-		prefix = &RouteTargetMembershipNLRI{}
-	case RF_IPv4_ENCAP:
-		prefix = NewEncapNLRI("")
-	case RF_IPv6_ENCAP:
-		prefix = NewEncapv6NLRI("")
-	case RF_FS_IPv4_UC:
-		prefix = &FlowSpecIPv4Unicast{FlowSpecNLRI{rf: RF_FS_IPv4_UC}}
-	case RF_FS_IPv4_VPN:
-		prefix = &FlowSpecIPv4VPN{FlowSpecNLRI{rf: RF_FS_IPv4_VPN}}
-	case RF_FS_IPv6_UC:
-		prefix = &FlowSpecIPv6Unicast{FlowSpecNLRI{rf: RF_FS_IPv6_UC}}
-	case RF_FS_IPv6_VPN:
-		prefix = &FlowSpecIPv6VPN{FlowSpecNLRI{rf: RF_FS_IPv6_VPN}}
-	case RF_FS_L2_VPN:
-		prefix = &FlowSpecL2VPN{FlowSpecNLRI{rf: RF_FS_L2_VPN}}
-	case RF_OPAQUE:
-		prefix = &OpaqueNLRI{}
-	default:
-		err = fmt.Errorf("unknown route family. AFI: %d, SAFI: %d", afi, safi)
-	}
-	return prefix, err
-}
-
-type BGPAttrFlag uint8
-
-const (
-	BGP_ATTR_FLAG_EXTENDED_LENGTH BGPAttrFlag = 1 << 4
-	BGP_ATTR_FLAG_PARTIAL         BGPAttrFlag = 1 << 5
-	BGP_ATTR_FLAG_TRANSITIVE      BGPAttrFlag = 1 << 6
-	BGP_ATTR_FLAG_OPTIONAL        BGPAttrFlag = 1 << 7
-)
-
-func (f BGPAttrFlag) String() string {
-	strs := make([]string, 0, 4)
-	if f&BGP_ATTR_FLAG_EXTENDED_LENGTH > 0 {
-		strs = append(strs, "EXTENDED_LENGTH")
-	}
-	if f&BGP_ATTR_FLAG_PARTIAL > 0 {
-		strs = append(strs, "PARTIAL")
-	}
-	if f&BGP_ATTR_FLAG_TRANSITIVE > 0 {
-		strs = append(strs, "TRANSITIVE")
-	}
-	if f&BGP_ATTR_FLAG_OPTIONAL > 0 {
-		strs = append(strs, "OPTIONAL")
-	}
-	return strings.Join(strs, "|")
-}
-
-type BGPAttrType uint8
-
-const (
-	_ BGPAttrType = iota
-	BGP_ATTR_TYPE_ORIGIN
-	BGP_ATTR_TYPE_AS_PATH
-	BGP_ATTR_TYPE_NEXT_HOP
-	BGP_ATTR_TYPE_MULTI_EXIT_DISC
-	BGP_ATTR_TYPE_LOCAL_PREF
-	BGP_ATTR_TYPE_ATOMIC_AGGREGATE
-	BGP_ATTR_TYPE_AGGREGATOR
-	BGP_ATTR_TYPE_COMMUNITIES
-	BGP_ATTR_TYPE_ORIGINATOR_ID
-	BGP_ATTR_TYPE_CLUSTER_LIST
-	_
-	_
-	_
-	BGP_ATTR_TYPE_MP_REACH_NLRI // = 14
-	BGP_ATTR_TYPE_MP_UNREACH_NLRI
-	BGP_ATTR_TYPE_EXTENDED_COMMUNITIES
-	BGP_ATTR_TYPE_AS4_PATH
-	BGP_ATTR_TYPE_AS4_AGGREGATOR
-	_
-	_
-	_
-	BGP_ATTR_TYPE_PMSI_TUNNEL // = 22
-	BGP_ATTR_TYPE_TUNNEL_ENCAP
-	_
-	BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES             // = 25
-	BGP_ATTR_TYPE_AIGP                                 // = 26
-	BGP_ATTR_TYPE_LARGE_COMMUNITY          BGPAttrType = 32
-)
-
-// NOTIFICATION Error Code  RFC 4271 4.5.
-const (
-	_ = iota
-	BGP_ERROR_MESSAGE_HEADER_ERROR
-	BGP_ERROR_OPEN_MESSAGE_ERROR
-	BGP_ERROR_UPDATE_MESSAGE_ERROR
-	BGP_ERROR_HOLD_TIMER_EXPIRED
-	BGP_ERROR_FSM_ERROR
-	BGP_ERROR_CEASE
-	BGP_ERROR_ROUTE_REFRESH_MESSAGE_ERROR
-)
-
-// NOTIFICATION Error Subcode for BGP_ERROR_MESSAGE_HEADER_ERROR
-const (
-	_ = iota
-	BGP_ERROR_SUB_CONNECTION_NOT_SYNCHRONIZED
-	BGP_ERROR_SUB_BAD_MESSAGE_LENGTH
-	BGP_ERROR_SUB_BAD_MESSAGE_TYPE
-)
-
-// NOTIFICATION Error Subcode for BGP_ERROR_OPEN_MESSAGE_ERROR
-const (
-	_ = iota
-	BGP_ERROR_SUB_UNSUPPORTED_VERSION_NUMBER
-	BGP_ERROR_SUB_BAD_PEER_AS
-	BGP_ERROR_SUB_BAD_BGP_IDENTIFIER
-	BGP_ERROR_SUB_UNSUPPORTED_OPTIONAL_PARAMETER
-	BGP_ERROR_SUB_DEPRECATED_AUTHENTICATION_FAILURE
-	BGP_ERROR_SUB_UNACCEPTABLE_HOLD_TIME
-	BGP_ERROR_SUB_UNSUPPORTED_CAPABILITY
-)
-
-// NOTIFICATION Error Subcode for BGP_ERROR_UPDATE_MESSAGE_ERROR
-const (
-	_ = iota
-	BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST
-	BGP_ERROR_SUB_UNRECOGNIZED_WELL_KNOWN_ATTRIBUTE
-	BGP_ERROR_SUB_MISSING_WELL_KNOWN_ATTRIBUTE
-	BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR
-	BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR
-	BGP_ERROR_SUB_INVALID_ORIGIN_ATTRIBUTE
-	BGP_ERROR_SUB_DEPRECATED_ROUTING_LOOP
-	BGP_ERROR_SUB_INVALID_NEXT_HOP_ATTRIBUTE
-	BGP_ERROR_SUB_OPTIONAL_ATTRIBUTE_ERROR
-	BGP_ERROR_SUB_INVALID_NETWORK_FIELD
-	BGP_ERROR_SUB_MALFORMED_AS_PATH
-)
-
-// NOTIFICATION Error Subcode for BGP_ERROR_HOLD_TIMER_EXPIRED
-const (
-	_ = iota
-	BGP_ERROR_SUB_HOLD_TIMER_EXPIRED
-)
-
-// NOTIFICATION Error Subcode for BGP_ERROR_FSM_ERROR
-const (
-	_ = iota
-	BGP_ERROR_SUB_RECEIVE_UNEXPECTED_MESSAGE_IN_OPENSENT_STATE
-	BGP_ERROR_SUB_RECEIVE_UNEXPECTED_MESSAGE_IN_OPENCONFIRM_STATE
-	BGP_ERROR_SUB_RECEIVE_UNEXPECTED_MESSAGE_IN_ESTABLISHED_STATE
-)
-
-// NOTIFICATION Error Subcode for BGP_ERROR_CEASE  (RFC 4486)
-const (
-	_ = iota
-	BGP_ERROR_SUB_MAXIMUM_NUMBER_OF_PREFIXES_REACHED
-	BGP_ERROR_SUB_ADMINISTRATIVE_SHUTDOWN
-	BGP_ERROR_SUB_PEER_DECONFIGURED
-	BGP_ERROR_SUB_ADMINISTRATIVE_RESET
-	BGP_ERROR_SUB_CONNECTION_REJECTED
-	BGP_ERROR_SUB_OTHER_CONFIGURATION_CHANGE
-	BGP_ERROR_SUB_CONNECTION_COLLISION_RESOLUTION
-	BGP_ERROR_SUB_OUT_OF_RESOURCES
-	BGP_ERROR_SUB_HARD_RESET //draft-ietf-idr-bgp-gr-notification-07
-)
-
-// Constants for BGP_ERROR_SUB_ADMINISTRATIVE_SHUTDOWN and BGP_ERROR_SUB_ADMINISTRATIVE_RESET
-const (
-	BGP_ERROR_ADMINISTRATIVE_COMMUNICATION_MAX = 128
-)
-
-// NOTIFICATION Error Subcode for BGP_ERROR_ROUTE_REFRESH
-const (
-	_ = iota
-	BGP_ERROR_SUB_INVALID_MESSAGE_LENGTH
-)
-
-type NotificationErrorCode uint16
-
-func (c NotificationErrorCode) String() string {
-	code := uint8(uint16(c) >> 8)
-	subcode := uint8(uint16(c) & 0xff)
-	UNDEFINED := "undefined"
-	codeStr := UNDEFINED
-	subcodeList := []string{}
-	switch code {
-	case BGP_ERROR_MESSAGE_HEADER_ERROR:
-		codeStr = "header"
-		subcodeList = []string{
-			UNDEFINED,
-			"connection not synchronized",
-			"bad message length",
-			"bad message type"}
-	case BGP_ERROR_OPEN_MESSAGE_ERROR:
-		codeStr = "open"
-		subcodeList = []string{
-			UNDEFINED,
-			"unsupported version number",
-			"bad peer as",
-			"bad bgp identifier",
-			"unsupported optional parameter",
-			"deprecated authentication failure",
-			"unacceptable hold time",
-			"unsupported capability"}
-	case BGP_ERROR_UPDATE_MESSAGE_ERROR:
-		codeStr = "update"
-		subcodeList = []string{
-			UNDEFINED,
-			"malformed attribute list",
-			"unrecognized well known attribute",
-			"missing well known attribute",
-			"attribute flags error",
-			"attribute length error",
-			"invalid origin attribute",
-			"deprecated routing loop",
-			"invalid next hop attribute",
-			"optional attribute error",
-			"invalid network field",
-			"sub malformed as path"}
-	case BGP_ERROR_HOLD_TIMER_EXPIRED:
-		codeStr = "hold timer expired"
-		subcodeList = []string{
-			UNDEFINED,
-			"hold timer expired"}
-	case BGP_ERROR_FSM_ERROR:
-		codeStr = "fsm"
-		subcodeList = []string{
-			UNDEFINED,
-			"receive unexpected message in opensent state",
-			"receive unexpected message in openconfirm state",
-			"receive unexpected message in established state"}
-	case BGP_ERROR_CEASE:
-		codeStr = "cease"
-		subcodeList = []string{
-			UNDEFINED,
-			"maximum number of prefixes reached",
-			"administrative shutdown",
-			"peer deconfigured",
-			"administrative reset",
-			"connection rejected",
-			"other configuration change",
-			"connection collision resolution",
-			"out of resources"}
-	case BGP_ERROR_ROUTE_REFRESH_MESSAGE_ERROR:
-		codeStr = "route refresh"
-		subcodeList = []string{"invalid message length"}
-	}
-	subcodeStr := func(idx uint8, l []string) string {
-		if len(l) == 0 || int(idx) > len(l)-1 {
-			return UNDEFINED
-		}
-		return l[idx]
-	}(subcode, subcodeList)
-	return fmt.Sprintf("code %v(%v) subcode %v(%v)", code, codeStr, subcode, subcodeStr)
-}
-
-func NewNotificationErrorCode(code, subcode uint8) NotificationErrorCode {
-	return NotificationErrorCode(uint16(code)<<8 | uint16(subcode))
-}
-
-var PathAttrFlags map[BGPAttrType]BGPAttrFlag = map[BGPAttrType]BGPAttrFlag{
-	BGP_ATTR_TYPE_ORIGIN:                   BGP_ATTR_FLAG_TRANSITIVE,
-	BGP_ATTR_TYPE_AS_PATH:                  BGP_ATTR_FLAG_TRANSITIVE,
-	BGP_ATTR_TYPE_NEXT_HOP:                 BGP_ATTR_FLAG_TRANSITIVE,
-	BGP_ATTR_TYPE_MULTI_EXIT_DISC:          BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_LOCAL_PREF:               BGP_ATTR_FLAG_TRANSITIVE,
-	BGP_ATTR_TYPE_ATOMIC_AGGREGATE:         BGP_ATTR_FLAG_TRANSITIVE,
-	BGP_ATTR_TYPE_AGGREGATOR:               BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_COMMUNITIES:              BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_ORIGINATOR_ID:            BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_CLUSTER_LIST:             BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_MP_REACH_NLRI:            BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_MP_UNREACH_NLRI:          BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_EXTENDED_COMMUNITIES:     BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_AS4_PATH:                 BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_AS4_AGGREGATOR:           BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_PMSI_TUNNEL:              BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_TUNNEL_ENCAP:             BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES: BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_AIGP:                     BGP_ATTR_FLAG_OPTIONAL,
-	BGP_ATTR_TYPE_LARGE_COMMUNITY:          BGP_ATTR_FLAG_TRANSITIVE | BGP_ATTR_FLAG_OPTIONAL,
-}
-
-// getPathAttrFlags returns BGP Path Attribute flags value from its type and
-// length (byte length of value field).
-func getPathAttrFlags(typ BGPAttrType, length int) BGPAttrFlag {
-	flags := PathAttrFlags[typ]
-	if length > 255 {
-		flags |= BGP_ATTR_FLAG_EXTENDED_LENGTH
-	}
-	return flags
-}
-
-type PathAttributeInterface interface {
-	DecodeFromBytes([]byte, ...*MarshallingOption) error
-	Serialize(...*MarshallingOption) ([]byte, error)
-	Len(...*MarshallingOption) int
-	GetFlags() BGPAttrFlag
-	GetType() BGPAttrType
-	String() string
-	MarshalJSON() ([]byte, error)
-	Flat() map[string]string
-}
-
-type PathAttribute struct {
-	Flags  BGPAttrFlag
-	Type   BGPAttrType
-	Length uint16 // length of Value
-}
-
-func (p *PathAttribute) Len(options ...*MarshallingOption) int {
-	if p.Flags&BGP_ATTR_FLAG_EXTENDED_LENGTH != 0 {
-		return 4 + int(p.Length)
-	}
-	return 3 + int(p.Length)
-}
-
-func (p *PathAttribute) GetFlags() BGPAttrFlag {
-	return p.Flags
-}
-
-func (p *PathAttribute) GetType() BGPAttrType {
-	return p.Type
-}
-
-func (p *PathAttribute) DecodeFromBytes(data []byte, options ...*MarshallingOption) (value []byte, err error) {
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-	if len(data) < 2 {
-		return nil, NewMessageError(eCode, eSubCode, data, "attribute header length is short")
-	}
-	p.Flags = BGPAttrFlag(data[0])
-	p.Type = BGPAttrType(data[1])
-	if eMsg := validatePathAttributeFlags(p.Type, p.Flags); eMsg != "" {
-		return nil, NewMessageError(eCode, BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR, data, eMsg)
-	}
-
-	if p.Flags&BGP_ATTR_FLAG_EXTENDED_LENGTH != 0 {
-		if len(data) < 4 {
-			return nil, NewMessageError(eCode, eSubCode, data, "attribute header length is short")
-		}
-		p.Length = binary.BigEndian.Uint16(data[2:4])
-		data = data[4:]
-	} else {
-		if len(data) < 3 {
-			return nil, NewMessageError(eCode, eSubCode, data, "attribute header length is short")
-		}
-		p.Length = uint16(data[2])
-		data = data[3:]
-	}
-	if len(data) < int(p.Length) {
-		return nil, NewMessageError(eCode, eSubCode, data, "attribute value length is short")
-	}
-
-	return data[:p.Length], nil
-}
-
-func (p *PathAttribute) Serialize(value []byte, options ...*MarshallingOption) ([]byte, error) {
-	// Note: Do not update "p.Flags" and "p.Length" to avoid data race.
-	flags := p.Flags
-	length := uint16(len(value))
-	if flags&BGP_ATTR_FLAG_EXTENDED_LENGTH == 0 && length > 255 {
-		flags |= BGP_ATTR_FLAG_EXTENDED_LENGTH
-	}
-	var buf []byte
-	if flags&BGP_ATTR_FLAG_EXTENDED_LENGTH != 0 {
-		buf = append(make([]byte, 4), value...)
-		binary.BigEndian.PutUint16(buf[2:4], length)
-	} else {
-		buf = append(make([]byte, 3), value...)
-		buf[2] = byte(length)
-	}
-	buf[0] = uint8(flags)
-	buf[1] = uint8(p.Type)
-	return buf, nil
-}
-
-type PathAttributeOrigin struct {
-	PathAttribute
-	Value uint8
-}
-
-func (p *PathAttributeOrigin) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length != 1 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-		return NewMessageError(eCode, eSubCode, nil, "Origin attribute length is incorrect")
-	}
-	p.Value = value[0]
-	return nil
-}
-
-func (p *PathAttributeOrigin) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	return p.PathAttribute.Serialize([]byte{p.Value}, options...)
-}
-
-func (p *PathAttributeOrigin) String() string {
-	typ := "-"
-	switch p.Value {
-	case BGP_ORIGIN_ATTR_TYPE_IGP:
-		typ = "i"
-	case BGP_ORIGIN_ATTR_TYPE_EGP:
-		typ = "e"
-	case BGP_ORIGIN_ATTR_TYPE_INCOMPLETE:
-		typ = "?"
-	}
-	return fmt.Sprintf("{Origin: %s}", typ)
-}
-
-func (p *PathAttributeOrigin) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType `json:"type"`
-		Value uint8       `json:"value"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeOrigin(value uint8) *PathAttributeOrigin {
-	t := BGP_ATTR_TYPE_ORIGIN
-	return &PathAttributeOrigin{
-		PathAttribute: PathAttribute{
-			Flags:  PathAttrFlags[t],
-			Type:   t,
-			Length: 1,
-		},
-		Value: value,
-	}
-}
-
-type AsPathParamFormat struct {
-	start     string
-	end       string
-	separator string
-}
-
-var asPathParamFormatMap = map[uint8]*AsPathParamFormat{
-	BGP_ASPATH_ATTR_TYPE_SET:        {"{", "}", ","},
-	BGP_ASPATH_ATTR_TYPE_SEQ:        {"", "", " "},
-	BGP_ASPATH_ATTR_TYPE_CONFED_SET: {"(", ")", " "},
-	BGP_ASPATH_ATTR_TYPE_CONFED_SEQ: {"[", "]", ","},
-}
-
-type AsPathParamInterface interface {
-	GetType() uint8
-	GetAS() []uint32
-	Serialize() ([]byte, error)
-	DecodeFromBytes([]byte) error
-	Len() int
-	ASLen() int
-	MarshalJSON() ([]byte, error)
-	String() string
-}
-
-func AsPathString(aspath *PathAttributeAsPath) string {
-	s := bytes.NewBuffer(make([]byte, 0, 64))
-	for i, param := range aspath.Value {
-		segType := param.GetType()
-		asList := param.GetAS()
-		if i != 0 {
-			s.WriteString(" ")
-		}
-
-		sep := " "
-		switch segType {
-		case BGP_ASPATH_ATTR_TYPE_CONFED_SEQ:
-			s.WriteString("(")
-		case BGP_ASPATH_ATTR_TYPE_CONFED_SET:
-			s.WriteString("[")
-			sep = ","
-		case BGP_ASPATH_ATTR_TYPE_SET:
-			s.WriteString("{")
-			sep = ","
-		}
-		for j, as := range asList {
-			s.WriteString(fmt.Sprintf("%d", as))
-			if j != len(asList)-1 {
-				s.WriteString(sep)
-			}
-		}
-		switch segType {
-		case BGP_ASPATH_ATTR_TYPE_CONFED_SEQ:
-			s.WriteString(")")
-		case BGP_ASPATH_ATTR_TYPE_CONFED_SET:
-			s.WriteString("]")
-		case BGP_ASPATH_ATTR_TYPE_SET:
-			s.WriteString("}")
-		}
-	}
-	return s.String()
-}
-
-type AsPathParam struct {
-	Type uint8
-	Num  uint8
-	AS   []uint16
-}
-
-func (a *AsPathParam) GetType() uint8 {
-	return a.Type
-}
-
-func (a *AsPathParam) GetAS() []uint32 {
-	nums := make([]uint32, 0, len(a.AS))
-	for _, as := range a.AS {
-		nums = append(nums, uint32(as))
-	}
-	return nums
-}
-
-func (a *AsPathParam) Serialize() ([]byte, error) {
-	buf := make([]byte, 2+len(a.AS)*2)
-	buf[0] = uint8(a.Type)
-	buf[1] = a.Num
-	for j, as := range a.AS {
-		binary.BigEndian.PutUint16(buf[2+j*2:], as)
-	}
-	return buf, nil
-}
-
-func (a *AsPathParam) DecodeFromBytes(data []byte) error {
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH)
-	if len(data) < 2 {
-		return NewMessageError(eCode, eSubCode, nil, "AS param header length is short")
-	}
-	a.Type = data[0]
-	a.Num = data[1]
-	data = data[2:]
-	if len(data) < int(a.Num*2) {
-		return NewMessageError(eCode, eSubCode, nil, "AS param data length is short")
-	}
-	for i := 0; i < int(a.Num); i++ {
-		a.AS = append(a.AS, binary.BigEndian.Uint16(data))
-		data = data[2:]
-	}
-	return nil
-}
-
-func (a *AsPathParam) Len() int {
-	return 2 + len(a.AS)*2
-}
-
-func (a *AsPathParam) ASLen() int {
-	switch a.Type {
-	case BGP_ASPATH_ATTR_TYPE_SEQ:
-		return len(a.AS)
-	case BGP_ASPATH_ATTR_TYPE_SET:
-		return 1
-	case BGP_ASPATH_ATTR_TYPE_CONFED_SET, BGP_ASPATH_ATTR_TYPE_CONFED_SEQ:
-		return 0
-	}
-	return 0
-}
-
-func (a *AsPathParam) String() string {
-	format, ok := asPathParamFormatMap[a.Type]
-	if !ok {
-		return fmt.Sprintf("%v", a.AS)
-	}
-	aspath := make([]string, 0, len(a.AS))
-	for _, asn := range a.AS {
-		aspath = append(aspath, fmt.Sprintf("%d", asn))
-	}
-	s := bytes.NewBuffer(make([]byte, 0, 32))
-	s.WriteString(format.start)
-	s.WriteString(strings.Join(aspath, format.separator))
-	s.WriteString(format.end)
-	return s.String()
-}
-
-func (a *AsPathParam) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type uint8    `json:"segment_type"`
-		Num  uint8    `json:"num"`
-		AS   []uint16 `json:"asns"`
-	}{
-		Type: a.Type,
-		Num:  a.Num,
-		AS:   a.AS,
-	})
-}
-
-func NewAsPathParam(segType uint8, as []uint16) *AsPathParam {
-	return &AsPathParam{
-		Type: segType,
-		Num:  uint8(len(as)),
-		AS:   as,
-	}
-}
-
-type As4PathParam struct {
-	Type uint8
-	Num  uint8
-	AS   []uint32
-}
-
-func (a *As4PathParam) GetType() uint8 {
-	return a.Type
-}
-
-func (a *As4PathParam) GetAS() []uint32 {
-	return a.AS
-}
-
-func (a *As4PathParam) Serialize() ([]byte, error) {
-	buf := make([]byte, 2+len(a.AS)*4)
-	buf[0] = a.Type
-	buf[1] = a.Num
-	for j, as := range a.AS {
-		binary.BigEndian.PutUint32(buf[2+j*4:], as)
-	}
-	return buf, nil
-}
-
-func (a *As4PathParam) DecodeFromBytes(data []byte) error {
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH)
-	if len(data) < 2 {
-		return NewMessageError(eCode, eSubCode, nil, "AS4 param header length is short")
-	}
-	a.Type = data[0]
-	a.Num = data[1]
-	data = data[2:]
-	if len(data) < int(a.Num)*4 {
-		return NewMessageError(eCode, eSubCode, nil, "AS4 param data length is short")
-	}
-	for i := 0; i < int(a.Num); i++ {
-		a.AS = append(a.AS, binary.BigEndian.Uint32(data))
-		data = data[4:]
-	}
-	return nil
-}
-
-func (a *As4PathParam) Len() int {
-	return 2 + len(a.AS)*4
-}
-
-func (a *As4PathParam) ASLen() int {
-	switch a.Type {
-	case BGP_ASPATH_ATTR_TYPE_SEQ:
-		return len(a.AS)
-	case BGP_ASPATH_ATTR_TYPE_SET:
-		return 1
-	case BGP_ASPATH_ATTR_TYPE_CONFED_SET, BGP_ASPATH_ATTR_TYPE_CONFED_SEQ:
-		return 0
-	}
-	return 0
-}
-
-func (a *As4PathParam) String() string {
-	format, ok := asPathParamFormatMap[a.Type]
-	if !ok {
-		return fmt.Sprintf("%v", a.AS)
-	}
-	aspath := make([]string, 0, len(a.AS))
-	for _, asn := range a.AS {
-		aspath = append(aspath, fmt.Sprintf("%d", asn))
-	}
-	s := bytes.NewBuffer(make([]byte, 0, 32))
-	s.WriteString(format.start)
-	s.WriteString(strings.Join(aspath, format.separator))
-	s.WriteString(format.end)
-	return s.String()
-}
-
-func (a *As4PathParam) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type uint8    `json:"segment_type"`
-		Num  uint8    `json:"num"`
-		AS   []uint32 `json:"asns"`
-	}{
-		Type: a.Type,
-		Num:  a.Num,
-		AS:   a.AS,
-	})
-}
-
-func NewAs4PathParam(segType uint8, as []uint32) *As4PathParam {
-	return &As4PathParam{
-		Type: segType,
-		Num:  uint8(len(as)),
-		AS:   as,
-	}
-}
-
-type PathAttributeAsPath struct {
-	PathAttribute
-	Value []AsPathParamInterface
-}
-
-func (p *PathAttributeAsPath) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length == 0 {
-		// ibgp or something
-		return nil
-	}
-	isAs4, err := validateAsPathValueBytes(value)
-	if err != nil {
-		err.(*MessageError).Data, _ = p.PathAttribute.Serialize(value, options...)
-		return err
-	}
-	for len(value) > 0 {
-		var tuple AsPathParamInterface
-		if isAs4 {
-			tuple = &As4PathParam{}
-		} else {
-			tuple = &AsPathParam{}
-		}
-		err := tuple.DecodeFromBytes(value)
-		if err != nil {
-			return err
-		}
-		p.Value = append(p.Value, tuple)
-		value = value[tuple.Len():]
-	}
-	return nil
-}
-
-func (p *PathAttributeAsPath) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, v := range p.Value {
-		vbuf, err := v.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, vbuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeAsPath) String() string {
-	params := make([]string, 0, len(p.Value))
-	for _, param := range p.Value {
-		params = append(params, param.String())
-	}
-	return strings.Join(params, " ")
-}
-
-func (p *PathAttributeAsPath) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType            `json:"type"`
-		Value []AsPathParamInterface `json:"as_paths"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeAsPath(value []AsPathParamInterface) *PathAttributeAsPath {
-	var l int
-	for _, v := range value {
-		l += v.Len()
-	}
-	t := BGP_ATTR_TYPE_AS_PATH
-	return &PathAttributeAsPath{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Value: value,
-	}
-}
-
-type PathAttributeNextHop struct {
-	PathAttribute
-	Value net.IP
-}
-
-func (p *PathAttributeNextHop) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length != 4 && p.Length != 16 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "nexthop length isn't correct")
-	}
-	p.Value = value
-	return nil
-}
-
-func (p *PathAttributeNextHop) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	return p.PathAttribute.Serialize(p.Value, options...)
-}
-
-func (p *PathAttributeNextHop) String() string {
-	return fmt.Sprintf("{Nexthop: %s}", p.Value)
-}
-
-func (p *PathAttributeNextHop) MarshalJSON() ([]byte, error) {
-	value := "0.0.0.0"
-	if p.Value != nil {
-		value = p.Value.String()
-	}
-	return json.Marshal(struct {
-		Type  BGPAttrType `json:"type"`
-		Value string      `json:"nexthop"`
-	}{
-		Type:  p.GetType(),
-		Value: value,
-	})
-}
-
-func NewPathAttributeNextHop(value string) *PathAttributeNextHop {
-	t := BGP_ATTR_TYPE_NEXT_HOP
-	return &PathAttributeNextHop{
-		PathAttribute: PathAttribute{
-			Flags:  PathAttrFlags[t],
-			Type:   t,
-			Length: 4,
-		},
-		Value: net.ParseIP(value).To4(),
-	}
-}
-
-type PathAttributeMultiExitDisc struct {
-	PathAttribute
-	Value uint32
-}
-
-func (p *PathAttributeMultiExitDisc) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length != 4 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "med length isn't correct")
-	}
-	p.Value = binary.BigEndian.Uint32(value)
-	return nil
-}
-
-func (p *PathAttributeMultiExitDisc) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint32(buf, p.Value)
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeMultiExitDisc) String() string {
-	return fmt.Sprintf("{Med: %d}", p.Value)
-}
-
-func (p *PathAttributeMultiExitDisc) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType `json:"type"`
-		Value uint32      `json:"metric"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeMultiExitDisc(value uint32) *PathAttributeMultiExitDisc {
-	t := BGP_ATTR_TYPE_MULTI_EXIT_DISC
-	return &PathAttributeMultiExitDisc{
-		PathAttribute: PathAttribute{
-			Flags:  PathAttrFlags[t],
-			Type:   t,
-			Length: 4,
-		},
-		Value: value,
-	}
-}
-
-type PathAttributeLocalPref struct {
-	PathAttribute
-	Value uint32
-}
-
-func (p *PathAttributeLocalPref) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length != 4 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "local pref length isn't correct")
-	}
-	p.Value = binary.BigEndian.Uint32(value)
-	return nil
-}
-
-func (p *PathAttributeLocalPref) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint32(buf, p.Value)
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeLocalPref) String() string {
-	return fmt.Sprintf("{LocalPref: %d}", p.Value)
-}
-
-func (p *PathAttributeLocalPref) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType `json:"type"`
-		Value uint32      `json:"value"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeLocalPref(value uint32) *PathAttributeLocalPref {
-	t := BGP_ATTR_TYPE_LOCAL_PREF
-	return &PathAttributeLocalPref{
-		PathAttribute: PathAttribute{
-			Flags:  PathAttrFlags[t],
-			Type:   t,
-			Length: 4,
-		},
-		Value: value,
-	}
-}
-
-type PathAttributeAtomicAggregate struct {
-	PathAttribute
-}
-
-func (p *PathAttributeAtomicAggregate) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	_, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length != 0 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "atomic aggregate should have no value")
-	}
-	return nil
-}
-
-func (p *PathAttributeAtomicAggregate) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	return p.PathAttribute.Serialize(nil, options...)
-}
-
-func (p *PathAttributeAtomicAggregate) String() string {
-	return "{AtomicAggregate}"
-}
-
-func (p *PathAttributeAtomicAggregate) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type BGPAttrType `json:"type"`
-	}{
-		Type: p.GetType(),
-	})
-}
-
-func NewPathAttributeAtomicAggregate() *PathAttributeAtomicAggregate {
-	t := BGP_ATTR_TYPE_ATOMIC_AGGREGATE
-	return &PathAttributeAtomicAggregate{
-		PathAttribute: PathAttribute{
-			Flags:  PathAttrFlags[t],
-			Type:   t,
-			Length: 0,
-		},
-	}
-}
-
-type PathAttributeAggregatorParam struct {
-	AS      uint32
-	Askind  reflect.Kind
-	Address net.IP
-}
-
-type PathAttributeAggregator struct {
-	PathAttribute
-	Value PathAttributeAggregatorParam
-}
-
-func (p *PathAttributeAggregator) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	switch p.Length {
-	case 6:
-		p.Value.Askind = reflect.Uint16
-		p.Value.AS = uint32(binary.BigEndian.Uint16(value[0:2]))
-		p.Value.Address = value[2:]
-	case 8:
-		p.Value.Askind = reflect.Uint32
-		p.Value.AS = binary.BigEndian.Uint32(value[0:4])
-		p.Value.Address = value[4:]
-	default:
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "aggregator length isn't correct")
-	}
-	return nil
-}
-
-func (p *PathAttributeAggregator) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	var buf []byte
-	switch p.Value.Askind {
-	case reflect.Uint16:
-		buf = make([]byte, 6)
-		binary.BigEndian.PutUint16(buf, uint16(p.Value.AS))
-		copy(buf[2:], p.Value.Address)
-	case reflect.Uint32:
-		buf = make([]byte, 8)
-		binary.BigEndian.PutUint32(buf, p.Value.AS)
-		copy(buf[4:], p.Value.Address)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeAggregator) String() string {
-	return fmt.Sprintf("{Aggregate: {AS: %d, Address: %s}}", p.Value.AS, p.Value.Address)
-}
-
-func (p *PathAttributeAggregator) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type    BGPAttrType `json:"type"`
-		AS      uint32      `json:"as"`
-		Address string      `json:"address"`
-	}{
-		Type:    p.GetType(),
-		AS:      p.Value.AS,
-		Address: p.Value.Address.String(),
-	})
-}
-
-func NewPathAttributeAggregator(as interface{}, address string) *PathAttributeAggregator {
-	v := reflect.ValueOf(as)
-	asKind := v.Kind()
-	var l uint16
-	switch asKind {
-	case reflect.Uint16:
-		l = 6
-	case reflect.Uint32:
-		l = 8
-	default:
-		// Invalid type
-		return nil
-	}
-	t := BGP_ATTR_TYPE_AGGREGATOR
-	return &PathAttributeAggregator{
-		PathAttribute: PathAttribute{
-			Flags:  PathAttrFlags[t],
-			Type:   t,
-			Length: l,
-		},
-		Value: PathAttributeAggregatorParam{
-			AS:      uint32(v.Uint()),
-			Askind:  asKind,
-			Address: net.ParseIP(address).To4(),
-		},
-	}
-}
-
-type PathAttributeCommunities struct {
-	PathAttribute
-	Value []uint32
-}
-
-func (p *PathAttributeCommunities) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length%4 != 0 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "communities length isn't correct")
-	}
-	for len(value) >= 4 {
-		p.Value = append(p.Value, binary.BigEndian.Uint32(value))
-		value = value[4:]
-	}
-	return nil
-}
-
-func (p *PathAttributeCommunities) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, len(p.Value)*4)
-	for i, v := range p.Value {
-		binary.BigEndian.PutUint32(buf[i*4:], v)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-type WellKnownCommunity uint32
-
-const (
-	COMMUNITY_INTERNET                   WellKnownCommunity = 0x00000000
-	COMMUNITY_PLANNED_SHUT               WellKnownCommunity = 0xffff0000
-	COMMUNITY_ACCEPT_OWN                 WellKnownCommunity = 0xffff0001
-	COMMUNITY_ROUTE_FILTER_TRANSLATED_v4 WellKnownCommunity = 0xffff0002
-	COMMUNITY_ROUTE_FILTER_v4            WellKnownCommunity = 0xffff0003
-	COMMUNITY_ROUTE_FILTER_TRANSLATED_v6 WellKnownCommunity = 0xffff0004
-	COMMUNITY_ROUTE_FILTER_v6            WellKnownCommunity = 0xffff0005
-	COMMUNITY_LLGR_STALE                 WellKnownCommunity = 0xffff0006
-	COMMUNITY_NO_LLGR                    WellKnownCommunity = 0xffff0007
-	COMMUNITY_BLACKHOLE                  WellKnownCommunity = 0xffff029a
-	COMMUNITY_NO_EXPORT                  WellKnownCommunity = 0xffffff01
-	COMMUNITY_NO_ADVERTISE               WellKnownCommunity = 0xffffff02
-	COMMUNITY_NO_EXPORT_SUBCONFED        WellKnownCommunity = 0xffffff03
-	COMMUNITY_NO_PEER                    WellKnownCommunity = 0xffffff04
-)
-
-var WellKnownCommunityNameMap = map[WellKnownCommunity]string{
-	COMMUNITY_INTERNET:                   "internet",
-	COMMUNITY_PLANNED_SHUT:               "planned-shut",
-	COMMUNITY_ACCEPT_OWN:                 "accept-own",
-	COMMUNITY_ROUTE_FILTER_TRANSLATED_v4: "route-filter-translated-v4",
-	COMMUNITY_ROUTE_FILTER_v4:            "route-filter-v4",
-	COMMUNITY_ROUTE_FILTER_TRANSLATED_v6: "route-filter-translated-v6",
-	COMMUNITY_ROUTE_FILTER_v6:            "route-filter-v6",
-	COMMUNITY_LLGR_STALE:                 "llgr-stale",
-	COMMUNITY_NO_LLGR:                    "no-llgr",
-	COMMUNITY_BLACKHOLE:                  "blackhole",
-	COMMUNITY_NO_EXPORT:                  "no-export",
-	COMMUNITY_NO_ADVERTISE:               "no-advertise",
-	COMMUNITY_NO_EXPORT_SUBCONFED:        "no-export-subconfed",
-	COMMUNITY_NO_PEER:                    "no-peer",
-}
-
-var WellKnownCommunityValueMap = map[string]WellKnownCommunity{
-	WellKnownCommunityNameMap[COMMUNITY_INTERNET]:                   COMMUNITY_INTERNET,
-	WellKnownCommunityNameMap[COMMUNITY_PLANNED_SHUT]:               COMMUNITY_PLANNED_SHUT,
-	WellKnownCommunityNameMap[COMMUNITY_ACCEPT_OWN]:                 COMMUNITY_ACCEPT_OWN,
-	WellKnownCommunityNameMap[COMMUNITY_ROUTE_FILTER_TRANSLATED_v4]: COMMUNITY_ROUTE_FILTER_TRANSLATED_v4,
-	WellKnownCommunityNameMap[COMMUNITY_ROUTE_FILTER_v4]:            COMMUNITY_ROUTE_FILTER_v4,
-	WellKnownCommunityNameMap[COMMUNITY_ROUTE_FILTER_TRANSLATED_v6]: COMMUNITY_ROUTE_FILTER_TRANSLATED_v6,
-	WellKnownCommunityNameMap[COMMUNITY_ROUTE_FILTER_v6]:            COMMUNITY_ROUTE_FILTER_v6,
-	WellKnownCommunityNameMap[COMMUNITY_LLGR_STALE]:                 COMMUNITY_LLGR_STALE,
-	WellKnownCommunityNameMap[COMMUNITY_NO_LLGR]:                    COMMUNITY_NO_LLGR,
-	WellKnownCommunityNameMap[COMMUNITY_NO_EXPORT]:                  COMMUNITY_NO_EXPORT,
-	WellKnownCommunityNameMap[COMMUNITY_BLACKHOLE]:                  COMMUNITY_BLACKHOLE,
-	WellKnownCommunityNameMap[COMMUNITY_NO_ADVERTISE]:               COMMUNITY_NO_ADVERTISE,
-	WellKnownCommunityNameMap[COMMUNITY_NO_EXPORT_SUBCONFED]:        COMMUNITY_NO_EXPORT_SUBCONFED,
-	WellKnownCommunityNameMap[COMMUNITY_NO_PEER]:                    COMMUNITY_NO_PEER,
-}
-
-func (p *PathAttributeCommunities) String() string {
-	l := []string{}
-	for _, v := range p.Value {
-		n, ok := WellKnownCommunityNameMap[WellKnownCommunity(v)]
-		if ok {
-			l = append(l, n)
-		} else {
-			l = append(l, fmt.Sprintf("%d:%d", (0xffff0000&v)>>16, 0xffff&v))
-		}
-	}
-	return fmt.Sprintf("{Communities: %s}", strings.Join(l, ", "))
-}
-
-func (p *PathAttributeCommunities) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType `json:"type"`
-		Value []uint32    `json:"communities"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeCommunities(value []uint32) *PathAttributeCommunities {
-	l := len(value) * 4
-	t := BGP_ATTR_TYPE_COMMUNITIES
-	return &PathAttributeCommunities{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Value: value,
-	}
-}
-
-type PathAttributeOriginatorId struct {
-	PathAttribute
-	Value net.IP
-}
-
-func (p *PathAttributeOriginatorId) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length != 4 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "originator id length isn't correct")
-	}
-	p.Value = value
-	return nil
-}
-
-func (p *PathAttributeOriginatorId) String() string {
-	return fmt.Sprintf("{Originator: %s}", p.Value)
-}
-
-func (p *PathAttributeOriginatorId) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType `json:"type"`
-		Value string      `json:"value"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value.String(),
-	})
-}
-
-func (p *PathAttributeOriginatorId) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 4)
-	copy(buf, p.Value)
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func NewPathAttributeOriginatorId(value string) *PathAttributeOriginatorId {
-	t := BGP_ATTR_TYPE_ORIGINATOR_ID
-	return &PathAttributeOriginatorId{
-		PathAttribute: PathAttribute{
-			Flags:  PathAttrFlags[t],
-			Type:   t,
-			Length: 4,
-		},
-		Value: net.ParseIP(value).To4(),
-	}
-}
-
-type PathAttributeClusterList struct {
-	PathAttribute
-	Value []net.IP
-}
-
-func (p *PathAttributeClusterList) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length%4 != 0 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "clusterlist length isn't correct")
-	}
-	for len(value) >= 4 {
-		p.Value = append(p.Value, value[:4])
-		value = value[4:]
-	}
-	return nil
-}
-
-func (p *PathAttributeClusterList) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, len(p.Value)*4)
-	for i, v := range p.Value {
-		copy(buf[i*4:], v)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeClusterList) String() string {
-	return fmt.Sprintf("{ClusterList: %v}", p.Value)
-}
-
-func (p *PathAttributeClusterList) MarshalJSON() ([]byte, error) {
-	value := make([]string, 0, len(p.Value))
-	for _, v := range p.Value {
-		value = append(value, v.String())
-	}
-	return json.Marshal(struct {
-		Type  BGPAttrType `json:"type"`
-		Value []string    `json:"value"`
-	}{
-		Type:  p.GetType(),
-		Value: value,
-	})
-}
-
-func NewPathAttributeClusterList(value []string) *PathAttributeClusterList {
-	l := len(value) * 4
-	list := make([]net.IP, len(value))
-	for i, v := range value {
-		list[i] = net.ParseIP(v).To4()
-	}
-	t := BGP_ATTR_TYPE_CLUSTER_LIST
-	return &PathAttributeClusterList{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Value: list,
-	}
-}
-
-type PathAttributeMpReachNLRI struct {
-	PathAttribute
-	Nexthop          net.IP
-	LinkLocalNexthop net.IP
-	AFI              uint16
-	SAFI             uint8
-	Value            []AddrPrefixInterface
-}
-
-func (p *PathAttributeMpReachNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-	eData, _ := p.PathAttribute.Serialize(value, options...)
-	if p.Length < 3 {
-		return NewMessageError(eCode, eSubCode, value, "mpreach header length is short")
-	}
-	afi := binary.BigEndian.Uint16(value[0:2])
-	safi := value[2]
-	p.AFI = afi
-	p.SAFI = safi
-	_, err = NewPrefixFromRouteFamily(afi, safi)
-	if err != nil {
-		return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, eData, err.Error())
-	}
-	nexthoplen := int(value[3])
-	if len(value) < 4+nexthoplen {
-		return NewMessageError(eCode, eSubCode, value, "mpreach nexthop length is short")
-	}
-	nexthopbin := value[4 : 4+nexthoplen]
-	if nexthoplen > 0 {
-		v4addrlen := 4
-		v6addrlen := 16
-		offset := 0
-		if safi == SAFI_MPLS_VPN {
-			offset = 8
-		}
-		switch nexthoplen {
-		case 2 * (offset + v6addrlen):
-			p.LinkLocalNexthop = nexthopbin[offset+v6addrlen+offset : 2*(offset+v6addrlen)]
-			fallthrough
-		case offset + v6addrlen:
-			p.Nexthop = nexthopbin[offset : offset+v6addrlen]
-		case offset + v4addrlen:
-			p.Nexthop = nexthopbin[offset : offset+v4addrlen]
-		default:
-			return NewMessageError(eCode, eSubCode, value, "mpreach nexthop length is incorrect")
-		}
-	}
-	value = value[4+nexthoplen:]
-	// skip reserved
-	if len(value) == 0 {
-		return NewMessageError(eCode, eSubCode, value, "no skip byte")
-	}
-	value = value[1:]
-	addpathLen := 0
-	if IsAddPathEnabled(true, AfiSafiToRouteFamily(afi, safi), options) {
-		addpathLen = 4
-	}
-	for len(value) > 0 {
-		prefix, err := NewPrefixFromRouteFamily(afi, safi)
-		if err != nil {
-			return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, eData, err.Error())
-		}
-		err = prefix.DecodeFromBytes(value, options...)
-		if err != nil {
-			return err
-		}
-		if prefix.Len(options...)+addpathLen > len(value) {
-			return NewMessageError(eCode, eSubCode, value, "prefix length is incorrect")
-		}
-		value = value[prefix.Len(options...)+addpathLen:]
-		p.Value = append(p.Value, prefix)
-	}
-	return nil
-}
-
-func (p *PathAttributeMpReachNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	afi := p.AFI
-	safi := p.SAFI
-	nexthoplen := 4
-	if afi == AFI_IP6 || p.Nexthop.To4() == nil {
-		nexthoplen = 16
-	}
-	offset := 0
-	switch safi {
-	case SAFI_MPLS_VPN:
-		offset = 8
-		nexthoplen += offset
-	case SAFI_FLOW_SPEC_VPN, SAFI_FLOW_SPEC_UNICAST:
-		nexthoplen = 0
-	}
-	if p.LinkLocalNexthop != nil {
-		nexthoplen *= 2
-	}
-	buf := make([]byte, 4+nexthoplen)
-	binary.BigEndian.PutUint16(buf[0:], afi)
-	buf[2] = safi
-	buf[3] = uint8(nexthoplen)
-	if nexthoplen != 0 {
-		if p.Nexthop.To4() == nil {
-			copy(buf[4+offset:], p.Nexthop.To16())
-			if p.LinkLocalNexthop != nil {
-				copy(buf[4+offset+16:], p.LinkLocalNexthop.To16())
-			}
-		} else {
-			copy(buf[4+offset:], p.Nexthop)
-		}
-	}
-	buf = append(buf, make([]byte, 1)...)
-	for _, prefix := range p.Value {
-		pbuf, err := prefix.Serialize(options...)
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, pbuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeMpReachNLRI) MarshalJSON() ([]byte, error) {
-	nexthop := p.Nexthop.String()
-	if p.Nexthop == nil {
-		switch p.AFI {
-		case AFI_IP:
-			nexthop = "0.0.0.0"
-		case AFI_IP6:
-			nexthop = "::"
-		default:
-			nexthop = "fictitious"
-		}
-	}
-	return json.Marshal(struct {
-		Type    BGPAttrType           `json:"type"`
-		Nexthop string                `json:"nexthop"`
-		AFI     uint16                `json:"afi"`
-		SAFI    uint8                 `json:"safi"`
-		Value   []AddrPrefixInterface `json:"value"`
-	}{
-		Type:    p.GetType(),
-		Nexthop: nexthop,
-		AFI:     p.AFI,
-		SAFI:    p.SAFI,
-		Value:   p.Value,
-	})
-}
-
-func (p *PathAttributeMpReachNLRI) String() string {
-	return fmt.Sprintf("{MpReach(%s): {Nexthop: %s, NLRIs: %s}}", AfiSafiToRouteFamily(p.AFI, p.SAFI), p.Nexthop, p.Value)
-}
-
-func NewPathAttributeMpReachNLRI(nexthop string, nlri []AddrPrefixInterface) *PathAttributeMpReachNLRI {
-	// AFI(2) + SAFI(1) + NexthopLength(1) + Nexthop(variable)
-	// + Reserved(1) + NLRI(variable)
-	l := 5
-	var afi uint16
-	var safi uint8
-	if len(nlri) > 0 {
-		afi = nlri[0].AFI()
-		safi = nlri[0].SAFI()
-	}
-	nh := net.ParseIP(nexthop)
-	if nh.To4() != nil && afi != AFI_IP6 {
-		nh = nh.To4()
-		switch safi {
-		case SAFI_MPLS_VPN:
-			l += 12
-		case SAFI_FLOW_SPEC_VPN, SAFI_FLOW_SPEC_UNICAST:
-			// Should not have Nexthop
-		default:
-			l += 4
-		}
-	} else {
-		switch safi {
-		case SAFI_MPLS_VPN:
-			l += 24
-		case SAFI_FLOW_SPEC_VPN, SAFI_FLOW_SPEC_UNICAST:
-			// Should not have Nexthop
-		default:
-			l += 16
-		}
-	}
-	var nlriLen int
-	for _, n := range nlri {
-		l += n.Len()
-		nBuf, _ := n.Serialize()
-		nlriLen += len(nBuf)
-	}
-	t := BGP_ATTR_TYPE_MP_REACH_NLRI
-	return &PathAttributeMpReachNLRI{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Nexthop: nh,
-		AFI:     afi,
-		SAFI:    safi,
-		Value:   nlri,
-	}
-}
-
-type PathAttributeMpUnreachNLRI struct {
-	PathAttribute
-	AFI   uint16
-	SAFI  uint8
-	Value []AddrPrefixInterface
-}
-
-func (p *PathAttributeMpUnreachNLRI) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-	eData, _ := p.PathAttribute.Serialize(value, options...)
-	if p.Length < 3 {
-		return NewMessageError(eCode, eSubCode, value, "unreach header length is incorrect")
-	}
-	afi := binary.BigEndian.Uint16(value[0:2])
-	safi := value[2]
-	_, err = NewPrefixFromRouteFamily(afi, safi)
-	if err != nil {
-		return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, eData, err.Error())
-	}
-	value = value[3:]
-	p.AFI = afi
-	p.SAFI = safi
-	addpathLen := 0
-	if IsAddPathEnabled(true, AfiSafiToRouteFamily(afi, safi), options) {
-		addpathLen = 4
-	}
-	for len(value) > 0 {
-		prefix, err := NewPrefixFromRouteFamily(afi, safi)
-		if err != nil {
-			return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, eData, err.Error())
-		}
-		err = prefix.DecodeFromBytes(value, options...)
-		if err != nil {
-			return err
-		}
-		if prefix.Len(options...)+addpathLen > len(value) {
-			return NewMessageError(eCode, eSubCode, eData, "prefix length is incorrect")
-		}
-		value = value[prefix.Len(options...)+addpathLen:]
-		p.Value = append(p.Value, prefix)
-	}
-	return nil
-}
-
-func (p *PathAttributeMpUnreachNLRI) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 3)
-	binary.BigEndian.PutUint16(buf, p.AFI)
-	buf[2] = p.SAFI
-	for _, prefix := range p.Value {
-		pbuf, err := prefix.Serialize(options...)
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, pbuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeMpUnreachNLRI) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType           `json:"type"`
-		AFI   uint16                `json:"afi"`
-		SAFI  uint8                 `json:"safi"`
-		Value []AddrPrefixInterface `json:"value"`
-	}{
-		Type:  p.GetType(),
-		AFI:   p.AFI,
-		SAFI:  p.SAFI,
-		Value: p.Value,
-	})
-}
-
-func (p *PathAttributeMpUnreachNLRI) String() string {
-	if len(p.Value) > 0 {
-		return fmt.Sprintf("{MpUnreach(%s): {NLRIs: %s}}", AfiSafiToRouteFamily(p.AFI, p.SAFI), p.Value)
-	}
-	return fmt.Sprintf("{MpUnreach(%s): End-of-Rib}", AfiSafiToRouteFamily(p.AFI, p.SAFI))
-}
-
-func NewPathAttributeMpUnreachNLRI(nlri []AddrPrefixInterface) *PathAttributeMpUnreachNLRI {
-	// AFI(2) + SAFI(1) + NLRI(variable)
-	l := 3
-	var afi uint16
-	var safi uint8
-	if len(nlri) > 0 {
-		afi = nlri[0].AFI()
-		safi = nlri[0].SAFI()
-	}
-	for _, n := range nlri {
-		l += n.Len()
-	}
-	t := BGP_ATTR_TYPE_MP_UNREACH_NLRI
-	return &PathAttributeMpUnreachNLRI{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		AFI:   afi,
-		SAFI:  safi,
-		Value: nlri,
-	}
-}
-
-type ExtendedCommunityInterface interface {
-	Serialize() ([]byte, error)
-	String() string
-	GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType)
-	MarshalJSON() ([]byte, error)
-	Flat() map[string]string
-}
-
-type TwoOctetAsSpecificExtended struct {
-	SubType      ExtendedCommunityAttrSubType
-	AS           uint16
-	LocalAdmin   uint32
-	IsTransitive bool
-}
-
-func (e *TwoOctetAsSpecificExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	if e.IsTransitive {
-		buf[0] = byte(EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC)
-	} else {
-		buf[0] = byte(EC_TYPE_NON_TRANSITIVE_TWO_OCTET_AS_SPECIFIC)
-	}
-	buf[1] = byte(e.SubType)
-	binary.BigEndian.PutUint16(buf[2:], e.AS)
-	binary.BigEndian.PutUint32(buf[4:], e.LocalAdmin)
-	return buf, nil
-}
-
-func (e *TwoOctetAsSpecificExtended) String() string {
-	return fmt.Sprintf("%d:%d", e.AS, e.LocalAdmin)
-}
-
-func (e *TwoOctetAsSpecificExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{
-		Type:    t,
-		Subtype: s,
-		Value:   e.String(),
-	})
-}
-
-func (e *TwoOctetAsSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	t := EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC
-	if !e.IsTransitive {
-		t = EC_TYPE_NON_TRANSITIVE_TWO_OCTET_AS_SPECIFIC
-	}
-	return t, e.SubType
-}
-
-func NewTwoOctetAsSpecificExtended(subtype ExtendedCommunityAttrSubType, as uint16, localAdmin uint32, isTransitive bool) *TwoOctetAsSpecificExtended {
-	return &TwoOctetAsSpecificExtended{
-		SubType:      subtype,
-		AS:           as,
-		LocalAdmin:   localAdmin,
-		IsTransitive: isTransitive,
-	}
-}
-
-type IPv4AddressSpecificExtended struct {
-	SubType      ExtendedCommunityAttrSubType
-	IPv4         net.IP
-	LocalAdmin   uint16
-	IsTransitive bool
-}
-
-func (e *IPv4AddressSpecificExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	if e.IsTransitive {
-		buf[0] = byte(EC_TYPE_TRANSITIVE_IP4_SPECIFIC)
-	} else {
-		buf[0] = byte(EC_TYPE_NON_TRANSITIVE_IP4_SPECIFIC)
-	}
-	buf[1] = byte(e.SubType)
-	copy(buf[2:6], e.IPv4)
-	binary.BigEndian.PutUint16(buf[6:], e.LocalAdmin)
-	return buf, nil
-}
-
-func (e *IPv4AddressSpecificExtended) String() string {
-	return fmt.Sprintf("%s:%d", e.IPv4.String(), e.LocalAdmin)
-}
-
-func (e *IPv4AddressSpecificExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{
-		Type:    t,
-		Subtype: s,
-		Value:   e.String(),
-	})
-}
-
-func (e *IPv4AddressSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	t := EC_TYPE_TRANSITIVE_IP4_SPECIFIC
-	if !e.IsTransitive {
-		t = EC_TYPE_NON_TRANSITIVE_IP4_SPECIFIC
-	}
-	return t, e.SubType
-}
-
-func NewIPv4AddressSpecificExtended(subtype ExtendedCommunityAttrSubType, ip string, localAdmin uint16, isTransitive bool) *IPv4AddressSpecificExtended {
-	ipv4 := net.ParseIP(ip)
-	if ipv4.To4() == nil {
-		return nil
-	}
-	return &IPv4AddressSpecificExtended{
-		SubType:      subtype,
-		IPv4:         ipv4.To4(),
-		LocalAdmin:   localAdmin,
-		IsTransitive: isTransitive,
-	}
-}
-
-type IPv6AddressSpecificExtended struct {
-	SubType      ExtendedCommunityAttrSubType
-	IPv6         net.IP
-	LocalAdmin   uint16
-	IsTransitive bool
-}
-
-func (e *IPv6AddressSpecificExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 20)
-	if e.IsTransitive {
-		buf[0] = byte(EC_TYPE_TRANSITIVE_IP6_SPECIFIC)
-	} else {
-		buf[0] = byte(EC_TYPE_NON_TRANSITIVE_IP6_SPECIFIC)
-	}
-	buf[1] = byte(e.SubType)
-	copy(buf[2:18], e.IPv6)
-	binary.BigEndian.PutUint16(buf[18:], e.LocalAdmin)
-	return buf, nil
-}
-
-func (e *IPv6AddressSpecificExtended) String() string {
-	return fmt.Sprintf("%s:%d", e.IPv6.String(), e.LocalAdmin)
-}
-
-func (e *IPv6AddressSpecificExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{
-		Type:    t,
-		Subtype: s,
-		Value:   e.String(),
-	})
-}
-
-func (e *IPv6AddressSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	t := EC_TYPE_TRANSITIVE_IP6_SPECIFIC
-	if !e.IsTransitive {
-		t = EC_TYPE_NON_TRANSITIVE_IP6_SPECIFIC
-	}
-	return t, e.SubType
-}
-
-func NewIPv6AddressSpecificExtended(subtype ExtendedCommunityAttrSubType, ip string, localAdmin uint16, isTransitive bool) *IPv6AddressSpecificExtended {
-	ipv6 := net.ParseIP(ip)
-	if ipv6.To16() == nil {
-		return nil
-	}
-	return &IPv6AddressSpecificExtended{
-		SubType:      subtype,
-		IPv6:         ipv6.To16(),
-		LocalAdmin:   localAdmin,
-		IsTransitive: isTransitive,
-	}
-}
-
-type FourOctetAsSpecificExtended struct {
-	SubType      ExtendedCommunityAttrSubType
-	AS           uint32
-	LocalAdmin   uint16
-	IsTransitive bool
-}
-
-func (e *FourOctetAsSpecificExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	if e.IsTransitive {
-		buf[0] = byte(EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC)
-	} else {
-		buf[0] = byte(EC_TYPE_NON_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC)
-	}
-	buf[1] = byte(e.SubType)
-	binary.BigEndian.PutUint32(buf[2:], e.AS)
-	binary.BigEndian.PutUint16(buf[6:], e.LocalAdmin)
-	return buf, nil
-}
-
-func (e *FourOctetAsSpecificExtended) String() string {
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint32(buf, e.AS)
-	asUpper := binary.BigEndian.Uint16(buf[0:2])
-	asLower := binary.BigEndian.Uint16(buf[2:])
-	return fmt.Sprintf("%d.%d:%d", asUpper, asLower, e.LocalAdmin)
-}
-
-func (e *FourOctetAsSpecificExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{
-		Type:    t,
-		Subtype: s,
-		Value:   e.String(),
-	})
-}
-
-func (e *FourOctetAsSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	t := EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC
-	if !e.IsTransitive {
-		t = EC_TYPE_NON_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC
-	}
-	return t, e.SubType
-}
-
-func NewFourOctetAsSpecificExtended(subtype ExtendedCommunityAttrSubType, as uint32, localAdmin uint16, isTransitive bool) *FourOctetAsSpecificExtended {
-	return &FourOctetAsSpecificExtended{
-		SubType:      subtype,
-		AS:           as,
-		LocalAdmin:   localAdmin,
-		IsTransitive: isTransitive,
-	}
-}
-
-func ParseExtendedCommunity(subtype ExtendedCommunityAttrSubType, com string) (ExtendedCommunityInterface, error) {
-	if subtype == EC_SUBTYPE_ORIGIN_VALIDATION {
-		var state ValidationState
-		switch com {
-		case VALIDATION_STATE_VALID.String():
-			state = VALIDATION_STATE_VALID
-		case VALIDATION_STATE_NOT_FOUND.String():
-			state = VALIDATION_STATE_NOT_FOUND
-		case VALIDATION_STATE_INVALID.String():
-			state = VALIDATION_STATE_INVALID
-		default:
-			return nil, fmt.Errorf("invalid validation state")
-		}
-		return &ValidationExtended{
-			State: state,
-		}, nil
-	}
-	elems, err := parseRdAndRt(com)
-	if err != nil {
-		return nil, err
-	}
-	localAdmin, _ := strconv.ParseUint(elems[10], 10, 32)
-	ip := net.ParseIP(elems[1])
-	isTransitive := true
-	switch {
-	case ip.To4() != nil:
-		return NewIPv4AddressSpecificExtended(subtype, elems[1], uint16(localAdmin), isTransitive), nil
-	case ip.To16() != nil:
-		return NewIPv6AddressSpecificExtended(subtype, elems[1], uint16(localAdmin), isTransitive), nil
-	case elems[6] == "" && elems[7] == "":
-		asn, _ := strconv.ParseUint(elems[8], 10, 16)
-		return NewTwoOctetAsSpecificExtended(subtype, uint16(asn), uint32(localAdmin), isTransitive), nil
-	default:
-		fst, _ := strconv.ParseUint(elems[7], 10, 16)
-		snd, _ := strconv.ParseUint(elems[8], 10, 16)
-		asn := fst<<16 | snd
-		return NewFourOctetAsSpecificExtended(subtype, uint32(asn), uint16(localAdmin), isTransitive), nil
-	}
-}
-
-func ParseRouteTarget(rt string) (ExtendedCommunityInterface, error) {
-	return ParseExtendedCommunity(EC_SUBTYPE_ROUTE_TARGET, rt)
-}
-
-func SerializeExtendedCommunities(comms []ExtendedCommunityInterface) ([][]byte, error) {
-	var bufs [][]byte
-	var err error
-	for _, c := range comms {
-		buf, err := c.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		bufs = append(bufs, buf)
-	}
-	return bufs, err
-}
-
-type ValidationState uint8
-
-const (
-	VALIDATION_STATE_VALID     ValidationState = 0
-	VALIDATION_STATE_NOT_FOUND ValidationState = 1
-	VALIDATION_STATE_INVALID   ValidationState = 2
-)
-
-func (s ValidationState) String() string {
-	switch s {
-	case VALIDATION_STATE_VALID:
-		return "valid"
-	case VALIDATION_STATE_NOT_FOUND:
-		return "not-found"
-	case VALIDATION_STATE_INVALID:
-		return "invalid"
-	}
-	return fmt.Sprintf("unknown validation state(%d)", s)
-}
-
-type ValidationExtended struct {
-	State ValidationState
-}
-
-func (e *ValidationExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	typ, subType := e.GetTypes()
-	buf[0] = byte(typ)
-	buf[1] = byte(subType)
-	buf[7] = byte(e.State)
-	return buf, nil
-}
-
-func (e *ValidationExtended) String() string {
-	return e.State.String()
-}
-
-func (e *ValidationExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_NON_TRANSITIVE_OPAQUE, EC_SUBTYPE_ORIGIN_VALIDATION
-}
-
-func (e *ValidationExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		SubType ExtendedCommunityAttrSubType `json:"subtype"`
-		State   ValidationState              `json:"value"`
-	}{
-		Type:    t,
-		SubType: s,
-		State:   e.State,
-	})
-}
-
-func NewValidationExtended(state ValidationState) *ValidationExtended {
-	return &ValidationExtended{
-		State: state,
-	}
-}
-
-type ColorExtended struct {
-	Color uint32
-}
-
-func (e *ColorExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	typ, subType := e.GetTypes()
-	buf[0] = byte(typ)
-	buf[1] = byte(subType)
-	binary.BigEndian.PutUint32(buf[4:8], uint32(e.Color))
-	return buf, nil
-}
-
-func (e *ColorExtended) String() string {
-	return fmt.Sprintf("%d", e.Color)
-}
-
-func (e *ColorExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_TRANSITIVE_OPAQUE, EC_SUBTYPE_COLOR
-}
-
-func (e *ColorExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		SubType ExtendedCommunityAttrSubType `json:"subtype"`
-		Color   uint32                       `json:"color"`
-	}{
-		Type:    t,
-		SubType: s,
-		Color:   e.Color,
-	})
-}
-
-func NewColorExtended(color uint32) *ColorExtended {
-	return &ColorExtended{
-		Color: color,
-	}
-}
-
-type EncapExtended struct {
-	TunnelType TunnelType
-}
-
-func (e *EncapExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	typ, subType := e.GetTypes()
-	buf[0] = byte(typ)
-	buf[1] = byte(subType)
-	binary.BigEndian.PutUint16(buf[6:8], uint16(e.TunnelType))
-	return buf, nil
-}
-
-func (e *EncapExtended) String() string {
-	switch e.TunnelType {
-	case TUNNEL_TYPE_L2TP3:
-		return "L2TPv3 over IP"
-	case TUNNEL_TYPE_GRE:
-		return "GRE"
-	case TUNNEL_TYPE_IP_IN_IP:
-		return "IP in IP"
-	case TUNNEL_TYPE_VXLAN:
-		return "VXLAN"
-	case TUNNEL_TYPE_NVGRE:
-		return "NVGRE"
-	case TUNNEL_TYPE_MPLS:
-		return "MPLS"
-	case TUNNEL_TYPE_MPLS_IN_GRE:
-		return "MPLS in GRE"
-	case TUNNEL_TYPE_VXLAN_GRE:
-		return "VXLAN GRE"
-	case TUNNEL_TYPE_MPLS_IN_UDP:
-		return "MPLS in UDP"
-	default:
-		return fmt.Sprintf("tunnel: %d", e.TunnelType)
-	}
-}
-
-func (e *EncapExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_TRANSITIVE_OPAQUE, EC_SUBTYPE_ENCAPSULATION
-}
-
-func (e *EncapExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type       ExtendedCommunityAttrType    `json:"type"`
-		SubType    ExtendedCommunityAttrSubType `json:"subtype"`
-		TunnelType TunnelType                   `json:"tunnel_type"`
-	}{
-		Type:       t,
-		SubType:    s,
-		TunnelType: e.TunnelType,
-	})
-}
-
-func NewEncapExtended(tunnelType TunnelType) *EncapExtended {
-	return &EncapExtended{
-		TunnelType: tunnelType,
-	}
-}
-
-type DefaultGatewayExtended struct {
-}
-
-func (e *DefaultGatewayExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	typ, subType := e.GetTypes()
-	buf[0] = byte(typ)
-	buf[1] = byte(subType)
-	return buf, nil
-}
-
-func (e *DefaultGatewayExtended) String() string {
-	return "default-gateway"
-}
-
-func (e *DefaultGatewayExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_TRANSITIVE_OPAQUE, EC_SUBTYPE_DEFAULT_GATEWAY
-}
-
-func (e *DefaultGatewayExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		SubType ExtendedCommunityAttrSubType `json:"subtype"`
-	}{
-		Type:    t,
-		SubType: s,
-	})
-}
-
-func NewDefaultGatewayExtended() *DefaultGatewayExtended {
-	return &DefaultGatewayExtended{}
-}
-
-type OpaqueExtended struct {
-	IsTransitive bool
-	Value        []byte
-}
-
-func (e *OpaqueExtended) Serialize() ([]byte, error) {
-	if len(e.Value) != 7 {
-		return nil, fmt.Errorf("invalid value length for opaque extended community: %d", len(e.Value))
-	}
-	buf := make([]byte, 8)
-	if e.IsTransitive {
-		buf[0] = byte(EC_TYPE_TRANSITIVE_OPAQUE)
-	} else {
-		buf[0] = byte(EC_TYPE_NON_TRANSITIVE_OPAQUE)
-	}
-	copy(buf[1:], e.Value)
-	return buf, nil
-}
-
-func (e *OpaqueExtended) String() string {
-	buf := make([]byte, 8)
-	copy(buf[1:], e.Value)
-	return fmt.Sprintf("%d", binary.BigEndian.Uint64(buf))
-}
-
-func (e *OpaqueExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	var subType ExtendedCommunityAttrSubType
-	if len(e.Value) > 0 {
-		// Use the first byte of value as the sub type
-		subType = ExtendedCommunityAttrSubType(e.Value[0])
-	}
-	if e.IsTransitive {
-		return EC_TYPE_TRANSITIVE_OPAQUE, subType
-	}
-	return EC_TYPE_NON_TRANSITIVE_OPAQUE, subType
-}
-
-func (e *OpaqueExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   []byte                       `json:"value"`
-	}{
-		Type:    t,
-		Subtype: s,
-		Value:   e.Value,
-	})
-}
-
-func NewOpaqueExtended(isTransitive bool, value []byte) *OpaqueExtended {
-	v := make([]byte, 7)
-	copy(v, value)
-	return &OpaqueExtended{
-		IsTransitive: isTransitive,
-		Value:        v,
-	}
-}
-
-func parseOpaqueExtended(data []byte) (ExtendedCommunityInterface, error) {
-	typ := ExtendedCommunityAttrType(data[0])
-	isTransitive := false
-	switch typ {
-	case EC_TYPE_TRANSITIVE_OPAQUE:
-		isTransitive = true
-	case EC_TYPE_NON_TRANSITIVE_OPAQUE:
-		// isTransitive = false
-	default:
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("invalid opaque extended community type: %d", data[0]))
-	}
-	subType := ExtendedCommunityAttrSubType(data[1])
-
-	if isTransitive {
-		switch subType {
-		case EC_SUBTYPE_COLOR:
-			return &ColorExtended{
-				Color: binary.BigEndian.Uint32(data[4:8]),
-			}, nil
-		case EC_SUBTYPE_ENCAPSULATION:
-			return &EncapExtended{
-				TunnelType: TunnelType(binary.BigEndian.Uint16(data[6:8])),
-			}, nil
-		case EC_SUBTYPE_DEFAULT_GATEWAY:
-			return &DefaultGatewayExtended{}, nil
-		}
-	} else {
-		switch subType {
-		case EC_SUBTYPE_ORIGIN_VALIDATION:
-			return &ValidationExtended{
-				State: ValidationState(data[7]),
-			}, nil
-		}
-	}
-	return NewOpaqueExtended(isTransitive, data[1:8]), nil
-}
-
-type ESILabelExtended struct {
-	Label          uint32
-	IsSingleActive bool
-}
-
-func (e *ESILabelExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	buf[0] = byte(EC_TYPE_EVPN)
-	buf[1] = byte(EC_SUBTYPE_ESI_LABEL)
-	if e.IsSingleActive {
-		buf[2] = byte(1)
-	}
-	buf[3] = 0
-	buf[4] = 0
-	buf[5] = byte((e.Label >> 16) & 0xff)
-	buf[6] = byte((e.Label >> 8) & 0xff)
-	buf[7] = byte(e.Label & 0xff)
-	return buf, nil
-}
-
-func (e *ESILabelExtended) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0, 32))
-	buf.WriteString(fmt.Sprintf("esi-label: %d", e.Label))
-	if e.IsSingleActive {
-		buf.WriteString(", single-active")
-	}
-	return buf.String()
-}
-
-func (e *ESILabelExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type           ExtendedCommunityAttrType    `json:"type"`
-		Subtype        ExtendedCommunityAttrSubType `json:"subtype"`
-		Label          uint32                       `json:"label"`
-		IsSingleActive bool                         `json:"is_single_active"`
-	}{
-		Type:           t,
-		Subtype:        s,
-		Label:          e.Label,
-		IsSingleActive: e.IsSingleActive,
-	})
-}
-
-func (e *ESILabelExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_EVPN, EC_SUBTYPE_ESI_LABEL
-}
-
-func NewESILabelExtended(label uint32, isSingleActive bool) *ESILabelExtended {
-	return &ESILabelExtended{
-		Label:          label,
-		IsSingleActive: isSingleActive,
-	}
-}
-
-type ESImportRouteTarget struct {
-	ESImport net.HardwareAddr
-}
-
-func (e *ESImportRouteTarget) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	buf[0] = byte(EC_TYPE_EVPN)
-	buf[1] = byte(EC_SUBTYPE_ES_IMPORT)
-	copy(buf[2:], e.ESImport)
-	return buf, nil
-}
-
-func (e *ESImportRouteTarget) String() string {
-	return fmt.Sprintf("es-import rt: %s", e.ESImport.String())
-}
-
-func (e *ESImportRouteTarget) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{
-		Type:    t,
-		Subtype: s,
-		Value:   e.ESImport.String(),
-	})
-}
-
-func (e *ESImportRouteTarget) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_EVPN, EC_SUBTYPE_ES_IMPORT
-}
-
-func NewESImportRouteTarget(mac string) *ESImportRouteTarget {
-	esImport, err := net.ParseMAC(mac)
-	if err != nil {
-		return nil
-	}
-	return &ESImportRouteTarget{
-		ESImport: esImport,
-	}
-}
-
-type MacMobilityExtended struct {
-	Sequence uint32
-	IsSticky bool
-}
-
-func (e *MacMobilityExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	buf[0] = byte(EC_TYPE_EVPN)
-	buf[1] = byte(EC_SUBTYPE_MAC_MOBILITY)
-	if e.IsSticky {
-		buf[2] = byte(1)
-	}
-	binary.BigEndian.PutUint32(buf[4:], e.Sequence)
-	return buf, nil
-}
-
-func (e *MacMobilityExtended) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0, 32))
-	buf.WriteString(fmt.Sprintf("mac-mobility: %d", e.Sequence))
-	if e.IsSticky {
-		buf.WriteString(", sticky")
-	}
-	return buf.String()
-}
-
-func (e *MacMobilityExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type     ExtendedCommunityAttrType    `json:"type"`
-		Subtype  ExtendedCommunityAttrSubType `json:"subtype"`
-		Sequence uint32                       `json:"sequence"`
-		IsSticky bool                         `json:"is_sticky"`
-	}{
-		Type:     t,
-		Subtype:  s,
-		Sequence: e.Sequence,
-		IsSticky: e.IsSticky,
-	})
-}
-
-func (e *MacMobilityExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_EVPN, EC_SUBTYPE_MAC_MOBILITY
-}
-
-func NewMacMobilityExtended(seq uint32, isSticky bool) *MacMobilityExtended {
-	return &MacMobilityExtended{
-		Sequence: seq,
-		IsSticky: isSticky,
-	}
-}
-
-type RouterMacExtended struct {
-	Mac net.HardwareAddr
-}
-
-func (e *RouterMacExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 2, 8)
-	buf[0] = byte(EC_TYPE_EVPN)
-	buf[1] = byte(EC_SUBTYPE_ROUTER_MAC)
-	buf = append(buf, e.Mac...)
-	return buf, nil
-}
-
-func (e *RouterMacExtended) String() string {
-	return fmt.Sprintf("router's mac: %s", e.Mac.String())
-}
-
-func (e *RouterMacExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Mac     string                       `json:"mac"`
-	}{
-		Type:    t,
-		Subtype: s,
-		Mac:     e.Mac.String(),
-	})
-}
-
-func (e *RouterMacExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_EVPN, EC_SUBTYPE_ROUTER_MAC
-}
-
-func NewRoutersMacExtended(mac string) *RouterMacExtended {
-	hw, err := net.ParseMAC(mac)
-	if err != nil {
-		return nil
-	}
-	return &RouterMacExtended{
-		Mac: hw,
-	}
-}
-
-func parseEvpnExtended(data []byte) (ExtendedCommunityInterface, error) {
-	if ExtendedCommunityAttrType(data[0]) != EC_TYPE_EVPN {
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("ext comm type is not EC_TYPE_EVPN: %d", data[0]))
-	}
-	subType := ExtendedCommunityAttrSubType(data[1])
-	switch subType {
-	case EC_SUBTYPE_ESI_LABEL:
-		var isSingleActive bool
-		if data[2] > 0 {
-			isSingleActive = true
-		}
-		label := uint32(data[5])<<16 | uint32(data[6])<<8 | uint32(data[7])
-		return &ESILabelExtended{
-			IsSingleActive: isSingleActive,
-			Label:          label,
-		}, nil
-	case EC_SUBTYPE_ES_IMPORT:
-		return &ESImportRouteTarget{
-			ESImport: net.HardwareAddr(data[2:8]),
-		}, nil
-	case EC_SUBTYPE_MAC_MOBILITY:
-		var isSticky bool
-		if data[2] > 0 {
-			isSticky = true
-		}
-		seq := binary.BigEndian.Uint32(data[4:8])
-		return &MacMobilityExtended{
-			Sequence: seq,
-			IsSticky: isSticky,
-		}, nil
-	case EC_SUBTYPE_ROUTER_MAC:
-		return &RouterMacExtended{
-			Mac: net.HardwareAddr(data[2:8]),
-		}, nil
-	}
-	return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("unknown evpn subtype: %d", subType))
-}
-
-type TrafficRateExtended struct {
-	AS   uint16
-	Rate float32
-}
-
-func (e *TrafficRateExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL)
-	buf[1] = byte(EC_SUBTYPE_FLOWSPEC_TRAFFIC_RATE)
-	binary.BigEndian.PutUint16(buf[2:4], e.AS)
-	binary.BigEndian.PutUint32(buf[4:8], math.Float32bits(e.Rate))
-	return buf, nil
-}
-
-func (e *TrafficRateExtended) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0, 32))
-	if e.Rate == 0 {
-		buf.WriteString("discard")
-	} else {
-		buf.WriteString(fmt.Sprintf("rate: %f", e.Rate))
-	}
-	if e.AS != 0 {
-		buf.WriteString(fmt.Sprintf("(as: %d)", e.AS))
-	}
-	return buf.String()
-}
-
-func (e *TrafficRateExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		As      uint16                       `json:"as"`
-		Rate    float32                      `json:"rate"`
-	}{t, s, e.AS, e.Rate})
-}
-
-func (e *TrafficRateExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_TRAFFIC_RATE
-}
-
-func NewTrafficRateExtended(as uint16, rate float32) *TrafficRateExtended {
-	return &TrafficRateExtended{
-		AS:   as,
-		Rate: rate,
-	}
-}
-
-type TrafficActionExtended struct {
-	Terminal bool
-	Sample   bool
-}
-
-func (e *TrafficActionExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL)
-	buf[1] = byte(EC_SUBTYPE_FLOWSPEC_TRAFFIC_ACTION)
-	if e.Terminal {
-		buf[7] = 0x01
-	}
-	if e.Sample {
-		buf[7] = buf[7] | 0x2
-	}
-	return buf, nil
-}
-
-func (e *TrafficActionExtended) String() string {
-	ss := make([]string, 0, 2)
-	if e.Terminal {
-		ss = append(ss, "terminal")
-	}
-	if e.Sample {
-		ss = append(ss, "sample")
-	}
-	return fmt.Sprintf("action: %s", strings.Join(ss, "-"))
-}
-
-func (e *TrafficActionExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type     ExtendedCommunityAttrType    `json:"type"`
-		Subtype  ExtendedCommunityAttrSubType `json:"subtype"`
-		Terminal bool                         `json:"terminal"`
-		Sample   bool                         `json:"sample"`
-	}{t, s, e.Terminal, e.Sample})
-}
-
-func (e *TrafficActionExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_TRAFFIC_ACTION
-}
-
-func NewTrafficActionExtended(terminal bool, sample bool) *TrafficActionExtended {
-	return &TrafficActionExtended{
-		Terminal: terminal,
-		Sample:   sample,
-	}
-}
-
-type RedirectTwoOctetAsSpecificExtended struct {
-	TwoOctetAsSpecificExtended
-}
-
-func (e *RedirectTwoOctetAsSpecificExtended) Serialize() ([]byte, error) {
-	buf, err := e.TwoOctetAsSpecificExtended.Serialize()
-	buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL)
-	buf[1] = byte(EC_SUBTYPE_FLOWSPEC_REDIRECT)
-	return buf, err
-}
-
-func (e *RedirectTwoOctetAsSpecificExtended) String() string {
-	return fmt.Sprintf("redirect: %s", e.TwoOctetAsSpecificExtended.String())
-}
-
-func (e *RedirectTwoOctetAsSpecificExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{t, s, e.TwoOctetAsSpecificExtended.String()})
-}
-
-func (e *RedirectTwoOctetAsSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_REDIRECT
-}
-
-func NewRedirectTwoOctetAsSpecificExtended(as uint16, localAdmin uint32) *RedirectTwoOctetAsSpecificExtended {
-	return &RedirectTwoOctetAsSpecificExtended{*NewTwoOctetAsSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, as, localAdmin, false)}
-}
-
-type RedirectIPv4AddressSpecificExtended struct {
-	IPv4AddressSpecificExtended
-}
-
-func (e *RedirectIPv4AddressSpecificExtended) Serialize() ([]byte, error) {
-	buf, err := e.IPv4AddressSpecificExtended.Serialize()
-	buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2)
-	buf[1] = byte(EC_SUBTYPE_FLOWSPEC_REDIRECT)
-	return buf, err
-}
-
-func (e *RedirectIPv4AddressSpecificExtended) String() string {
-	return fmt.Sprintf("redirect: %s", e.IPv4AddressSpecificExtended.String())
-}
-
-func (e *RedirectIPv4AddressSpecificExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{t, s, e.IPv4AddressSpecificExtended.String()})
-}
-
-func (e *RedirectIPv4AddressSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2, EC_SUBTYPE_FLOWSPEC_REDIRECT
-}
-
-func NewRedirectIPv4AddressSpecificExtended(ipv4 string, localAdmin uint16) *RedirectIPv4AddressSpecificExtended {
-	e := NewIPv4AddressSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, ipv4, localAdmin, false)
-	if e == nil {
-		return nil
-	}
-	return &RedirectIPv4AddressSpecificExtended{*e}
-}
-
-type RedirectIPv6AddressSpecificExtended struct {
-	IPv6AddressSpecificExtended
-}
-
-func (e *RedirectIPv6AddressSpecificExtended) Serialize() ([]byte, error) {
-	buf, err := e.IPv6AddressSpecificExtended.Serialize()
-	buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL)
-	buf[1] = byte(EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6)
-	return buf, err
-}
-
-func (e *RedirectIPv6AddressSpecificExtended) String() string {
-	return fmt.Sprintf("redirect: %s", e.IPv6AddressSpecificExtended.String())
-}
-
-func (e *RedirectIPv6AddressSpecificExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{t, s, e.IPv6AddressSpecificExtended.String()})
-}
-
-func (e *RedirectIPv6AddressSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6
-}
-
-func NewRedirectIPv6AddressSpecificExtended(ipv6 string, localAdmin uint16) *RedirectIPv6AddressSpecificExtended {
-	e := NewIPv6AddressSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, ipv6, localAdmin, false)
-	if e == nil {
-		return nil
-	}
-	return &RedirectIPv6AddressSpecificExtended{*e}
-}
-
-type RedirectFourOctetAsSpecificExtended struct {
-	FourOctetAsSpecificExtended
-}
-
-func (e *RedirectFourOctetAsSpecificExtended) Serialize() ([]byte, error) {
-	buf, err := e.FourOctetAsSpecificExtended.Serialize()
-	buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3)
-	buf[1] = byte(EC_SUBTYPE_FLOWSPEC_REDIRECT)
-	return buf, err
-}
-
-func (e *RedirectFourOctetAsSpecificExtended) String() string {
-	return fmt.Sprintf("redirect: %s", e.FourOctetAsSpecificExtended.String())
-}
-
-func (e *RedirectFourOctetAsSpecificExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   string                       `json:"value"`
-	}{t, s, e.FourOctetAsSpecificExtended.String()})
-}
-
-func (e *RedirectFourOctetAsSpecificExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3, EC_SUBTYPE_FLOWSPEC_REDIRECT
-}
-
-func NewRedirectFourOctetAsSpecificExtended(as uint32, localAdmin uint16) *RedirectFourOctetAsSpecificExtended {
-	return &RedirectFourOctetAsSpecificExtended{*NewFourOctetAsSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, as, localAdmin, false)}
-}
-
-type TrafficRemarkExtended struct {
-	DSCP uint8
-}
-
-func (e *TrafficRemarkExtended) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	buf[0] = byte(EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL)
-	buf[1] = byte(EC_SUBTYPE_FLOWSPEC_TRAFFIC_REMARK)
-	buf[7] = byte(e.DSCP)
-	return buf, nil
-}
-
-func (e *TrafficRemarkExtended) String() string {
-	return fmt.Sprintf("remark: %d", e.DSCP)
-}
-
-func (e *TrafficRemarkExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   uint8                        `json:"value"`
-	}{t, s, e.DSCP})
-}
-
-func (e *TrafficRemarkExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	return EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_SUBTYPE_FLOWSPEC_TRAFFIC_REMARK
-}
-
-func NewTrafficRemarkExtended(dscp uint8) *TrafficRemarkExtended {
-	return &TrafficRemarkExtended{
-		DSCP: dscp,
-	}
-}
-
-func parseFlowSpecExtended(data []byte) (ExtendedCommunityInterface, error) {
-	typ := ExtendedCommunityAttrType(data[0])
-	if typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL && typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2 && typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3 {
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("ext comm type is not EC_TYPE_FLOWSPEC: %d", data[0]))
-	}
-	subType := ExtendedCommunityAttrSubType(data[1])
-	switch subType {
-	case EC_SUBTYPE_FLOWSPEC_TRAFFIC_RATE:
-		asn := binary.BigEndian.Uint16(data[2:4])
-		bits := binary.BigEndian.Uint32(data[4:8])
-		rate := math.Float32frombits(bits)
-		return NewTrafficRateExtended(asn, rate), nil
-	case EC_SUBTYPE_FLOWSPEC_TRAFFIC_ACTION:
-		terminal := data[7]&0x1 == 1
-		sample := (data[7]>>1)&0x1 == 1
-		return NewTrafficActionExtended(terminal, sample), nil
-	case EC_SUBTYPE_FLOWSPEC_REDIRECT:
-		// RFC7674
-		switch typ {
-		case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL:
-			as := binary.BigEndian.Uint16(data[2:4])
-			localAdmin := binary.BigEndian.Uint32(data[4:8])
-			return NewRedirectTwoOctetAsSpecificExtended(as, localAdmin), nil
-		case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2:
-			ipv4 := net.IP(data[2:6]).String()
-			localAdmin := binary.BigEndian.Uint16(data[6:8])
-			return NewRedirectIPv4AddressSpecificExtended(ipv4, localAdmin), nil
-		case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3:
-			as := binary.BigEndian.Uint32(data[2:6])
-			localAdmin := binary.BigEndian.Uint16(data[6:8])
-			return NewRedirectFourOctetAsSpecificExtended(as, localAdmin), nil
-		}
-	case EC_SUBTYPE_FLOWSPEC_TRAFFIC_REMARK:
-		dscp := data[7]
-		return NewTrafficRemarkExtended(dscp), nil
-	case EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6:
-		ipv6 := net.IP(data[2:18]).String()
-		localAdmin := binary.BigEndian.Uint16(data[18:20])
-		return NewRedirectIPv6AddressSpecificExtended(ipv6, localAdmin), nil
-	}
-	return &UnknownExtended{
-		Type:  ExtendedCommunityAttrType(data[0]),
-		Value: data[1:8],
-	}, nil
-}
-
-func parseIP6FlowSpecExtended(data []byte) (ExtendedCommunityInterface, error) {
-	typ := ExtendedCommunityAttrType(data[0])
-	if typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL && typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2 && typ != EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3 {
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("ext comm type is not EC_TYPE_FLOWSPEC: %d", data[0]))
-	}
-	subType := ExtendedCommunityAttrSubType(data[1])
-	switch subType {
-	case EC_SUBTYPE_FLOWSPEC_REDIRECT_IP6:
-		// RFC7674
-		switch typ {
-		case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL:
-			ipv6 := net.IP(data[2:18]).String()
-			localAdmin := binary.BigEndian.Uint16(data[18:20])
-			return NewRedirectIPv6AddressSpecificExtended(ipv6, localAdmin), nil
-		}
-	}
-	return &UnknownExtended{
-		Type:  ExtendedCommunityAttrType(data[0]),
-		Value: data[1:20],
-	}, nil
-}
-
-type UnknownExtended struct {
-	Type  ExtendedCommunityAttrType
-	Value []byte
-}
-
-func (e *UnknownExtended) Serialize() ([]byte, error) {
-	if len(e.Value) != 7 {
-		return nil, fmt.Errorf("invalid value length for unknown extended community: %d", len(e.Value))
-	}
-	buf := make([]byte, 8)
-	buf[0] = uint8(e.Type)
-	copy(buf[1:], e.Value)
-	return buf, nil
-}
-
-func (e *UnknownExtended) String() string {
-	buf := make([]byte, 8)
-	copy(buf[1:], e.Value)
-	return fmt.Sprintf("%d", binary.BigEndian.Uint64(buf))
-}
-
-func (e *UnknownExtended) MarshalJSON() ([]byte, error) {
-	t, s := e.GetTypes()
-	return json.Marshal(struct {
-		Type    ExtendedCommunityAttrType    `json:"type"`
-		Subtype ExtendedCommunityAttrSubType `json:"subtype"`
-		Value   []byte                       `json:"value"`
-	}{
-		Type:    t,
-		Subtype: s,
-		Value:   e.Value,
-	})
-}
-
-func (e *UnknownExtended) GetTypes() (ExtendedCommunityAttrType, ExtendedCommunityAttrSubType) {
-	var subType ExtendedCommunityAttrSubType
-	if len(e.Value) > 0 {
-		// Use the first byte of value as the sub type
-		subType = ExtendedCommunityAttrSubType(e.Value[0])
-	}
-	return e.Type, subType
-}
-
-func NewUnknownExtended(typ ExtendedCommunityAttrType, value []byte) *UnknownExtended {
-	v := make([]byte, 7)
-	copy(v, value)
-	return &UnknownExtended{
-		Type:  typ,
-		Value: v,
-	}
-}
-
-type PathAttributeExtendedCommunities struct {
-	PathAttribute
-	Value []ExtendedCommunityInterface
-}
-
-func ParseExtended(data []byte) (ExtendedCommunityInterface, error) {
-	if len(data) < 8 {
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all extended community bytes are available")
-	}
-	attrType := ExtendedCommunityAttrType(data[0])
-	subtype := ExtendedCommunityAttrSubType(data[1])
-	transitive := false
-	switch attrType {
-	case EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC:
-		transitive = true
-		fallthrough
-	case EC_TYPE_NON_TRANSITIVE_TWO_OCTET_AS_SPECIFIC:
-		as := binary.BigEndian.Uint16(data[2:4])
-		localAdmin := binary.BigEndian.Uint32(data[4:8])
-		return NewTwoOctetAsSpecificExtended(subtype, as, localAdmin, transitive), nil
-	case EC_TYPE_TRANSITIVE_IP4_SPECIFIC:
-		transitive = true
-		fallthrough
-	case EC_TYPE_NON_TRANSITIVE_IP4_SPECIFIC:
-		ipv4 := net.IP(data[2:6]).String()
-		localAdmin := binary.BigEndian.Uint16(data[6:8])
-		return NewIPv4AddressSpecificExtended(subtype, ipv4, localAdmin, transitive), nil
-	case EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC:
-		transitive = true
-		fallthrough
-	case EC_TYPE_NON_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC:
-		as := binary.BigEndian.Uint32(data[2:6])
-		localAdmin := binary.BigEndian.Uint16(data[6:8])
-		return NewFourOctetAsSpecificExtended(subtype, as, localAdmin, transitive), nil
-	case EC_TYPE_TRANSITIVE_OPAQUE:
-		transitive = true
-		fallthrough
-	case EC_TYPE_NON_TRANSITIVE_OPAQUE:
-		return parseOpaqueExtended(data)
-	case EC_TYPE_EVPN:
-		return parseEvpnExtended(data)
-	case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL, EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL2, EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL3:
-		return parseFlowSpecExtended(data)
-	default:
-		return &UnknownExtended{
-			Type:  ExtendedCommunityAttrType(data[0]),
-			Value: data[1:8],
-		}, nil
-	}
-}
-
-func (p *PathAttributeExtendedCommunities) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length%8 != 0 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "extendedcommunities length isn't correct")
-	}
-	for len(value) >= 8 {
-		e, err := ParseExtended(value)
-		if err != nil {
-			return err
-		}
-		p.Value = append(p.Value, e)
-		value = value[8:]
-	}
-	return nil
-}
-
-func (p *PathAttributeExtendedCommunities) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, p := range p.Value {
-		ebuf, err := p.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, ebuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeExtendedCommunities) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0, 32))
-	for idx, v := range p.Value {
-		buf.WriteString("[")
-		buf.WriteString(v.String())
-		buf.WriteString("]")
-		if idx < len(p.Value)-1 {
-			buf.WriteString(", ")
-		}
-	}
-	return fmt.Sprintf("{Extcomms: %s}", buf.String())
-}
-
-func (p *PathAttributeExtendedCommunities) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType                  `json:"type"`
-		Value []ExtendedCommunityInterface `json:"value"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeExtendedCommunities(value []ExtendedCommunityInterface) *PathAttributeExtendedCommunities {
-	l := len(value) * 8
-	t := BGP_ATTR_TYPE_EXTENDED_COMMUNITIES
-	return &PathAttributeExtendedCommunities{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Value: value,
-	}
-}
-
-type PathAttributeAs4Path struct {
-	PathAttribute
-	Value []*As4PathParam
-}
-
-func (p *PathAttributeAs4Path) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-	isAs4, err := validateAsPathValueBytes(value)
-	if err != nil {
-		return err
-	}
-
-	if !isAs4 {
-		return NewMessageError(eCode, eSubCode, nil, "AS4 PATH param is malformed")
-	}
-
-	for len(value) > 0 {
-		tuple := &As4PathParam{}
-		tuple.DecodeFromBytes(value)
-		p.Value = append(p.Value, tuple)
-		if len(value) < tuple.Len() {
-			return NewMessageError(eCode, eSubCode, nil, "AS4 PATH param is malformed")
-		}
-		value = value[tuple.Len():]
-	}
-	return nil
-}
-
-func (p *PathAttributeAs4Path) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, v := range p.Value {
-		vbuf, err := v.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, vbuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeAs4Path) String() string {
-	params := make([]string, 0, len(p.Value))
-	for _, param := range p.Value {
-		params = append(params, param.String())
-	}
-	return strings.Join(params, " ")
-}
-
-func (p *PathAttributeAs4Path) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType     `json:"type"`
-		Value []*As4PathParam `json:"as_paths"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeAs4Path(value []*As4PathParam) *PathAttributeAs4Path {
-	var l int
-	for _, v := range value {
-		l += v.Len()
-	}
-	t := BGP_ATTR_TYPE_AS4_PATH
-	return &PathAttributeAs4Path{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Value: value,
-	}
-}
-
-type PathAttributeAs4Aggregator struct {
-	PathAttribute
-	Value PathAttributeAggregatorParam
-}
-
-func (p *PathAttributeAs4Aggregator) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length != 8 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-		return NewMessageError(eCode, eSubCode, nil, "AS4 Aggregator length is incorrect")
-	}
-	p.Value.AS = binary.BigEndian.Uint32(value[0:4])
-	p.Value.Address = value[4:]
-	return nil
-}
-
-func (p *PathAttributeAs4Aggregator) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 8)
-	binary.BigEndian.PutUint32(buf[0:], p.Value.AS)
-	copy(buf[4:], p.Value.Address.To4())
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeAs4Aggregator) String() string {
-	return fmt.Sprintf("{As4Aggregator: {AS: %d, Address: %s}}", p.Value.AS, p.Value.Address)
-}
-
-func (p *PathAttributeAs4Aggregator) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type    BGPAttrType `json:"type"`
-		AS      uint32      `json:"as"`
-		Address string      `json:"address"`
-	}{
-		Type:    p.GetType(),
-		AS:      p.Value.AS,
-		Address: p.Value.Address.String(),
-	})
-}
-
-func NewPathAttributeAs4Aggregator(as uint32, address string) *PathAttributeAs4Aggregator {
-	t := BGP_ATTR_TYPE_AS4_AGGREGATOR
-	return &PathAttributeAs4Aggregator{
-		PathAttribute: PathAttribute{
-			Flags:  PathAttrFlags[t],
-			Type:   t,
-			Length: 8,
-		},
-		Value: PathAttributeAggregatorParam{
-			AS:      as,
-			Address: net.ParseIP(address).To4(),
-		},
-	}
-}
-
-type TunnelEncapSubTLVInterface interface {
-	Len() int
-	DecodeFromBytes([]byte) error
-	Serialize() ([]byte, error)
-	String() string
-	MarshalJSON() ([]byte, error)
-}
-
-type TunnelEncapSubTLV struct {
-	Type   EncapSubTLVType
-	Length uint16
-}
-
-func (t *TunnelEncapSubTLV) Len() int {
-	if t.Type >= 0x80 {
-		return 3 + int(t.Length)
-	}
-	return 2 + int(t.Length)
-}
-
-func (t *TunnelEncapSubTLV) DecodeFromBytes(data []byte) (value []byte, err error) {
-	t.Type = EncapSubTLVType(data[0])
-	if t.Type >= 0x80 {
-		t.Length = binary.BigEndian.Uint16(data[1:3])
-		data = data[3:]
-	} else {
-		t.Length = uint16(data[1])
-		data = data[2:]
-	}
-	if len(data) < int(t.Length) {
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all TunnelEncapSubTLV bytes available")
-	}
-	return data, nil
-}
-
-func (t *TunnelEncapSubTLV) Serialize(value []byte) (buf []byte, err error) {
-	t.Length = uint16(len(value))
-	if t.Type >= 0x80 {
-		buf = append(make([]byte, 3), value...)
-		binary.BigEndian.PutUint16(buf[1:3], t.Length)
-	} else {
-		buf = append(make([]byte, 2), value...)
-		buf[1] = uint8(t.Length)
-	}
-	buf[0] = uint8(t.Type)
-	return buf, nil
-}
-
-type TunnelEncapSubTLVUnknown struct {
-	TunnelEncapSubTLV
-	Value []byte
-}
-
-func (t *TunnelEncapSubTLVUnknown) DecodeFromBytes(data []byte) error {
-	value, err := t.TunnelEncapSubTLV.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	t.Value = value
-	return nil
-}
-
-func (t *TunnelEncapSubTLVUnknown) Serialize() ([]byte, error) {
-	return t.TunnelEncapSubTLV.Serialize(t.Value)
-}
-
-func (t *TunnelEncapSubTLVUnknown) String() string {
-	return fmt.Sprintf("{Type: %d, Value: %x}", t.Type, t.Value)
-}
-
-func (t *TunnelEncapSubTLVUnknown) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  EncapSubTLVType `json:"type"`
-		Value []byte          `json:"value"`
-	}{
-		Type:  t.Type,
-		Value: t.Value,
-	})
-}
-
-func NewTunnelEncapSubTLVUnknown(typ EncapSubTLVType, value []byte) *TunnelEncapSubTLVUnknown {
-	return &TunnelEncapSubTLVUnknown{
-		TunnelEncapSubTLV: TunnelEncapSubTLV{
-			Type: typ,
-		},
-		Value: value,
-	}
-}
-
-type TunnelEncapSubTLVEncapsulation struct {
-	TunnelEncapSubTLV
-	Key    uint32 // this represent both SessionID for L2TPv3 case and GRE-key for GRE case (RFC5512 4.)
-	Cookie []byte
-}
-
-func (t *TunnelEncapSubTLVEncapsulation) DecodeFromBytes(data []byte) error {
-	value, err := t.TunnelEncapSubTLV.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	if t.Length < 4 {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all TunnelEncapSubTLVEncapsulation bytes available")
-	}
-	t.Key = binary.BigEndian.Uint32(value[0:4])
-	t.Cookie = value[4:]
-	return nil
-}
-
-func (t *TunnelEncapSubTLVEncapsulation) Serialize() ([]byte, error) {
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint32(buf, t.Key)
-	buf = append(buf, t.Cookie...)
-	return t.TunnelEncapSubTLV.Serialize(buf)
-}
-
-func (t *TunnelEncapSubTLVEncapsulation) String() string {
-	return fmt.Sprintf("{Key: %d, Cookie: %x}", t.Key, t.Cookie)
-}
-
-func (t *TunnelEncapSubTLVEncapsulation) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type   EncapSubTLVType `json:"type"`
-		Key    uint32          `json:"key"`
-		Cookie []byte          `json:"cookie"`
-	}{
-		Type:   t.Type,
-		Key:    t.Key,
-		Cookie: t.Cookie,
-	})
-}
-
-func NewTunnelEncapSubTLVEncapsulation(key uint32, cookie []byte) *TunnelEncapSubTLVEncapsulation {
-	return &TunnelEncapSubTLVEncapsulation{
-		TunnelEncapSubTLV: TunnelEncapSubTLV{
-			Type: ENCAP_SUBTLV_TYPE_ENCAPSULATION,
-		},
-		Key:    key,
-		Cookie: cookie,
-	}
-}
-
-type TunnelEncapSubTLVProtocol struct {
-	TunnelEncapSubTLV
-	Protocol uint16
-}
-
-func (t *TunnelEncapSubTLVProtocol) DecodeFromBytes(data []byte) error {
-	value, err := t.TunnelEncapSubTLV.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	if t.Length < 2 {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Not all TunnelEncapSubTLVProtocol bytes available")
-	}
-	t.Protocol = binary.BigEndian.Uint16(value[0:2])
-	return nil
-}
-
-func (t *TunnelEncapSubTLVProtocol) Serialize() ([]byte, error) {
-	buf := make([]byte, 2)
-	binary.BigEndian.PutUint16(buf, t.Protocol)
-	return t.TunnelEncapSubTLV.Serialize(buf)
-}
-
-func (t *TunnelEncapSubTLVProtocol) String() string {
-	return fmt.Sprintf("{Protocol: %d}", t.Protocol)
-}
-
-func (t *TunnelEncapSubTLVProtocol) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type     EncapSubTLVType `json:"type"`
-		Protocol uint16          `json:"protocol"`
-	}{
-		Type:     t.Type,
-		Protocol: t.Protocol,
-	})
-}
-
-func NewTunnelEncapSubTLVProtocol(protocol uint16) *TunnelEncapSubTLVProtocol {
-	return &TunnelEncapSubTLVProtocol{
-		TunnelEncapSubTLV: TunnelEncapSubTLV{
-			Type: ENCAP_SUBTLV_TYPE_PROTOCOL,
-		},
-		Protocol: protocol,
-	}
-}
-
-type TunnelEncapSubTLVColor struct {
-	TunnelEncapSubTLV
-	Color uint32
-}
-
-func (t *TunnelEncapSubTLVColor) DecodeFromBytes(data []byte) error {
-	value, err := t.TunnelEncapSubTLV.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	if t.Length != 8 {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "Invalid TunnelEncapSubTLVColor length")
-	}
-	t.Color = binary.BigEndian.Uint32(value[4:8])
-	return nil
-}
-
-func (t *TunnelEncapSubTLVColor) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	buf[0] = byte(EC_TYPE_TRANSITIVE_OPAQUE)
-	buf[1] = byte(EC_SUBTYPE_COLOR)
-	binary.BigEndian.PutUint32(buf[4:8], t.Color)
-	return t.TunnelEncapSubTLV.Serialize(buf)
-}
-
-func (t *TunnelEncapSubTLVColor) String() string {
-	return fmt.Sprintf("{Color: %d}", t.Color)
-}
-
-func (t *TunnelEncapSubTLVColor) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  EncapSubTLVType `json:"type"`
-		Color uint32          `json:"color"`
-	}{
-		Type:  t.Type,
-		Color: t.Color,
-	})
-}
-
-func NewTunnelEncapSubTLVColor(color uint32) *TunnelEncapSubTLVColor {
-	return &TunnelEncapSubTLVColor{
-		TunnelEncapSubTLV: TunnelEncapSubTLV{
-			Type: ENCAP_SUBTLV_TYPE_COLOR,
-		},
-		Color: color,
-	}
-}
-
-type TunnelEncapTLV struct {
-	Type   TunnelType
-	Length uint16
-	Value  []TunnelEncapSubTLVInterface
-}
-
-func (t *TunnelEncapTLV) Len() int {
-	var l int
-	for _, v := range t.Value {
-		l += v.Len()
-	}
-	return 4 + l // Type(2) + Length(2) + Value(variable)
-}
-
-func (t *TunnelEncapTLV) DecodeFromBytes(data []byte) error {
-	t.Type = TunnelType(binary.BigEndian.Uint16(data[0:2]))
-	t.Length = binary.BigEndian.Uint16(data[2:4])
-	data = data[4:]
-	if len(data) < int(t.Length) {
-		return NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, fmt.Sprintf("Not all TunnelEncapTLV bytes available"))
-	}
-	value := data[:t.Length]
-	for len(value) > 2 {
-		subType := EncapSubTLVType(value[0])
-		var subTlv TunnelEncapSubTLVInterface
-		switch subType {
-		case ENCAP_SUBTLV_TYPE_ENCAPSULATION:
-			subTlv = &TunnelEncapSubTLVEncapsulation{}
-		case ENCAP_SUBTLV_TYPE_PROTOCOL:
-			subTlv = &TunnelEncapSubTLVProtocol{}
-		case ENCAP_SUBTLV_TYPE_COLOR:
-			subTlv = &TunnelEncapSubTLVColor{}
-		default:
-			subTlv = &TunnelEncapSubTLVUnknown{
-				TunnelEncapSubTLV: TunnelEncapSubTLV{
-					Type: subType,
-				},
-			}
-		}
-		err := subTlv.DecodeFromBytes(value)
-		if err != nil {
-			return err
-		}
-		t.Value = append(t.Value, subTlv)
-		value = value[subTlv.Len():]
-	}
-	return nil
-}
-
-func (p *TunnelEncapTLV) Serialize() ([]byte, error) {
-	buf := make([]byte, 4)
-	for _, t := range p.Value {
-		tBuf, err := t.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, tBuf...)
-	}
-	binary.BigEndian.PutUint16(buf, uint16(p.Type))
-	binary.BigEndian.PutUint16(buf[2:], uint16(len(buf)-4))
-	return buf, nil
-}
-
-func (p *TunnelEncapTLV) String() string {
-	tlvList := make([]string, len(p.Value))
-	for i, v := range p.Value {
-		tlvList[i] = v.String()
-	}
-	return fmt.Sprintf("{%s: %s}", p.Type, strings.Join(tlvList, ", "))
-}
-
-func (p *TunnelEncapTLV) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  TunnelType                   `json:"type"`
-		Value []TunnelEncapSubTLVInterface `json:"value"`
-	}{
-		Type:  p.Type,
-		Value: p.Value,
-	})
-}
-
-func NewTunnelEncapTLV(typ TunnelType, value []TunnelEncapSubTLVInterface) *TunnelEncapTLV {
-	return &TunnelEncapTLV{
-		Type:  typ,
-		Value: value,
-	}
-}
-
-type PathAttributeTunnelEncap struct {
-	PathAttribute
-	Value []*TunnelEncapTLV
-}
-
-func (p *PathAttributeTunnelEncap) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	for len(value) > 4 {
-		tlv := &TunnelEncapTLV{}
-		err = tlv.DecodeFromBytes(value)
-		if err != nil {
-			return err
-		}
-		p.Value = append(p.Value, tlv)
-		value = value[4+tlv.Length:]
-	}
-	return nil
-}
-
-func (p *PathAttributeTunnelEncap) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, t := range p.Value {
-		bbuf, err := t.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, bbuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeTunnelEncap) String() string {
-	tlvList := make([]string, len(p.Value))
-	for i, v := range p.Value {
-		tlvList[i] = v.String()
-	}
-	return fmt.Sprintf("{TunnelEncap: %s}", strings.Join(tlvList, ", "))
-}
-
-func (p *PathAttributeTunnelEncap) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType       `json:"type"`
-		Value []*TunnelEncapTLV `json:"value"`
-	}{
-		Type:  p.Type,
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeTunnelEncap(value []*TunnelEncapTLV) *PathAttributeTunnelEncap {
-	var l int
-	for _, v := range value {
-		l += v.Len()
-	}
-	t := BGP_ATTR_TYPE_TUNNEL_ENCAP
-	return &PathAttributeTunnelEncap{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Value: value,
-	}
-}
-
-type PmsiTunnelIDInterface interface {
-	Len() int
-	Serialize() ([]byte, error)
-	String() string
-}
-
-type DefaultPmsiTunnelID struct {
-	Value []byte
-}
-
-func (i *DefaultPmsiTunnelID) Len() int {
-	return len(i.Value)
-}
-
-func (i *DefaultPmsiTunnelID) Serialize() ([]byte, error) {
-	return i.Value, nil
-}
-
-func (i *DefaultPmsiTunnelID) String() string {
-	return string(i.Value)
-}
-
-func NewDefaultPmsiTunnelID(value []byte) *DefaultPmsiTunnelID {
-	return &DefaultPmsiTunnelID{
-		Value: value,
-	}
-}
-
-type IngressReplTunnelID struct {
-	Value net.IP
-}
-
-func (i *IngressReplTunnelID) Len() int {
-	return len(i.Value)
-}
-
-func (i *IngressReplTunnelID) Serialize() ([]byte, error) {
-	if i.Value.To4() != nil {
-		return []byte(i.Value.To4()), nil
-	}
-	return []byte(i.Value), nil
-}
-
-func (i *IngressReplTunnelID) String() string {
-	return i.Value.String()
-}
-
-func NewIngressReplTunnelID(value string) *IngressReplTunnelID {
-	ip := net.ParseIP(value)
-	if ip == nil {
-		return nil
-	}
-	return &IngressReplTunnelID{
-		Value: ip,
-	}
-}
-
-type PathAttributePmsiTunnel struct {
-	PathAttribute
-	IsLeafInfoRequired bool
-	TunnelType         PmsiTunnelType
-	Label              uint32
-	TunnelID           PmsiTunnelIDInterface
-}
-
-func (p *PathAttributePmsiTunnel) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	if p.Length < 5 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-		return NewMessageError(eCode, eSubCode, nil, "PMSI Tunnel length is incorrect")
-	}
-
-	if (value[0] & 0x01) > 0 {
-		p.IsLeafInfoRequired = true
-	}
-	p.TunnelType = PmsiTunnelType(value[1])
-	if p.Label, err = labelDecode(value[2:5]); err != nil {
-		return err
-	}
-
-	switch p.TunnelType {
-	case PMSI_TUNNEL_TYPE_INGRESS_REPL:
-		p.TunnelID = &IngressReplTunnelID{net.IP(value[5:])}
-	default:
-		p.TunnelID = &DefaultPmsiTunnelID{value[5:]}
-	}
-	return nil
-}
-
-func (p *PathAttributePmsiTunnel) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 2)
-	if p.IsLeafInfoRequired {
-		buf[0] = 0x01
-	}
-	buf[1] = byte(p.TunnelType)
-	tbuf, err := labelSerialize(p.Label)
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, tbuf...)
-	tbuf, err = p.TunnelID.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, tbuf...)
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributePmsiTunnel) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0, 32))
-	buf.WriteString(fmt.Sprintf("{Pmsi: type: %s,", p.TunnelType))
-	if p.IsLeafInfoRequired {
-		buf.WriteString(" leaf-info-required,")
-	}
-	buf.WriteString(fmt.Sprintf(" label: %d, tunnel-id: %s}", p.Label, p.TunnelID))
-	return buf.String()
-}
-
-func (p *PathAttributePmsiTunnel) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type               BGPAttrType `json:"type"`
-		IsLeafInfoRequired bool        `json:"is-leaf-info-required"`
-		TunnelType         uint8       `json:"tunnel-type"`
-		Label              uint32      `json:"label"`
-		TunnelID           string      `json:"tunnel-id"`
-	}{
-		Type:               p.Type,
-		IsLeafInfoRequired: p.IsLeafInfoRequired,
-		TunnelType:         uint8(p.TunnelType),
-		Label:              p.Label,
-		TunnelID:           p.TunnelID.String(),
-	})
-}
-
-func NewPathAttributePmsiTunnel(typ PmsiTunnelType, isLeafInfoRequired bool, label uint32, id PmsiTunnelIDInterface) *PathAttributePmsiTunnel {
-	// Flags(1) + TunnelType(1) + Label(3) + TunnelID(variable)
-	l := 5 + id.Len()
-	t := BGP_ATTR_TYPE_PMSI_TUNNEL
-	return &PathAttributePmsiTunnel{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		IsLeafInfoRequired: isLeafInfoRequired,
-		TunnelType:         typ,
-		Label:              label,
-		TunnelID:           id,
-	}
-}
-
-func ParsePmsiTunnel(args []string) (*PathAttributePmsiTunnel, error) {
-	// Format:
-	// "<type>" ["leaf-info-required"] "<label>" "<tunnel-id>"
-	if len(args) < 3 {
-		return nil, fmt.Errorf("invalid pmsi tunnel arguments: %s", args)
-	}
-
-	pmsi := NewPathAttributePmsiTunnel(0, false, 0, nil)
-
-	switch args[0] {
-	case "ingress-repl":
-		pmsi.TunnelType = PMSI_TUNNEL_TYPE_INGRESS_REPL
-	default:
-		typ, err := strconv.ParseUint(args[0], 10, 8)
-		if err != nil {
-			return nil, fmt.Errorf("invalid pmsi tunnel type: %s", args[0])
-		}
-		pmsi.TunnelType = PmsiTunnelType(typ)
-	}
-
-	indx := 1
-	if args[indx] == "leaf-info-required" {
-		pmsi.IsLeafInfoRequired = true
-		indx++
-	}
-
-	label, err := strconv.ParseUint(args[indx], 10, 32)
-	if err != nil {
-		return nil, fmt.Errorf("invalid pmsi tunnel label: %s", args[indx])
-	}
-	pmsi.Label = uint32(label)
-	indx++
-
-	switch pmsi.TunnelType {
-	case PMSI_TUNNEL_TYPE_INGRESS_REPL:
-		ip := net.ParseIP(args[indx])
-		if ip == nil {
-			return nil, fmt.Errorf("invalid pmsi tunnel identifier: %s", args[indx])
-		}
-		pmsi.TunnelID = &IngressReplTunnelID{Value: ip}
-	default:
-		pmsi.TunnelID = &DefaultPmsiTunnelID{Value: []byte(args[indx])}
-	}
-
-	return pmsi, nil
-}
-
-type PathAttributeIP6ExtendedCommunities struct {
-	PathAttribute
-	Value []ExtendedCommunityInterface
-}
-
-func ParseIP6Extended(data []byte) (ExtendedCommunityInterface, error) {
-	if len(data) < 8 {
-		return nil, NewMessageError(BGP_ERROR_UPDATE_MESSAGE_ERROR, BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST, nil, "not all extended community bytes are available")
-	}
-	attrType := ExtendedCommunityAttrType(data[0])
-	subtype := ExtendedCommunityAttrSubType(data[1])
-	transitive := false
-	switch attrType {
-	case EC_TYPE_TRANSITIVE_IP6_SPECIFIC:
-		transitive = true
-		fallthrough
-	case EC_TYPE_NON_TRANSITIVE_IP6_SPECIFIC:
-		ipv6 := net.IP(data[2:18]).String()
-		localAdmin := binary.BigEndian.Uint16(data[18:20])
-		return NewIPv6AddressSpecificExtended(subtype, ipv6, localAdmin, transitive), nil
-	case EC_TYPE_GENERIC_TRANSITIVE_EXPERIMENTAL:
-		return parseIP6FlowSpecExtended(data)
-	default:
-		return &UnknownExtended{
-			Type:  ExtendedCommunityAttrType(data[0]),
-			Value: data[1:8],
-		}, nil
-	}
-}
-
-func (p *PathAttributeIP6ExtendedCommunities) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	if p.Length%20 != 0 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "extendedcommunities length isn't correct")
-	}
-	for len(value) >= 20 {
-		e, err := ParseIP6Extended(value)
-		if err != nil {
-			return err
-		}
-		p.Value = append(p.Value, e)
-		value = value[20:]
-	}
-	return nil
-}
-
-func (p *PathAttributeIP6ExtendedCommunities) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, p := range p.Value {
-		ebuf, err := p.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, ebuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeIP6ExtendedCommunities) String() string {
-	var buf []string
-	for _, v := range p.Value {
-		buf = append(buf, fmt.Sprintf("[%s]", v.String()))
-	}
-	return fmt.Sprintf("{Extcomms: %s}", strings.Join(buf, ","))
-}
-
-func (p *PathAttributeIP6ExtendedCommunities) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType                  `json:"type"`
-		Value []ExtendedCommunityInterface `json:"value"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeIP6ExtendedCommunities(value []ExtendedCommunityInterface) *PathAttributeIP6ExtendedCommunities {
-	l := len(value) * 20
-	t := BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES
-	return &PathAttributeIP6ExtendedCommunities{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Value: value,
-	}
-}
-
-type AigpTLVType uint8
-
-const (
-	AIGP_TLV_UNKNOWN AigpTLVType = iota
-	AIGP_TLV_IGP_METRIC
-)
-
-type AigpTLVInterface interface {
-	Serialize() ([]byte, error)
-	String() string
-	MarshalJSON() ([]byte, error)
-	Type() AigpTLVType
-	Len() int
-}
-
-type AigpTLVDefault struct {
-	typ   AigpTLVType
-	Value []byte
-}
-
-func (t *AigpTLVDefault) Serialize() ([]byte, error) {
-	buf := make([]byte, 3+len(t.Value))
-	buf[0] = uint8(t.Type())
-	binary.BigEndian.PutUint16(buf[1:], uint16(3+len(t.Value)))
-	copy(buf[3:], t.Value)
-	return buf, nil
-}
-
-func (t *AigpTLVDefault) String() string {
-	return fmt.Sprintf("{Type: %d, Value: %v}", t.Type(), t.Value)
-}
-
-func (t *AigpTLVDefault) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  AigpTLVType `json:"type"`
-		Value []byte      `json:"value"`
-	}{
-		Type:  t.Type(),
-		Value: t.Value,
-	})
-}
-
-func (t *AigpTLVDefault) Type() AigpTLVType {
-	return t.typ
-}
-
-func (t *AigpTLVDefault) Len() int {
-	return 3 + len(t.Value) // Type(1) + Length(2) + Value(variable)
-}
-
-func NewAigpTLVDefault(typ AigpTLVType, value []byte) *AigpTLVDefault {
-	return &AigpTLVDefault{
-		typ:   typ,
-		Value: value,
-	}
-}
-
-type AigpTLVIgpMetric struct {
-	Metric uint64
-}
-
-func (t *AigpTLVIgpMetric) Serialize() ([]byte, error) {
-	buf := make([]byte, 11)
-	buf[0] = uint8(AIGP_TLV_IGP_METRIC)
-	binary.BigEndian.PutUint16(buf[1:], uint16(11))
-	binary.BigEndian.PutUint64(buf[3:], t.Metric)
-	return buf, nil
-}
-
-func (t *AigpTLVIgpMetric) String() string {
-	return fmt.Sprintf("{Metric: %d}", t.Metric)
-}
-
-func (t *AigpTLVIgpMetric) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type   AigpTLVType `json:"type"`
-		Metric uint64      `json:"metric"`
-	}{
-		Type:   AIGP_TLV_IGP_METRIC,
-		Metric: t.Metric,
-	})
-}
-
-func NewAigpTLVIgpMetric(metric uint64) *AigpTLVIgpMetric {
-	return &AigpTLVIgpMetric{
-		Metric: metric,
-	}
-}
-
-func (t *AigpTLVIgpMetric) Type() AigpTLVType {
-	return AIGP_TLV_IGP_METRIC
-}
-
-func (t *AigpTLVIgpMetric) Len() int {
-	return 11
-}
-
-type PathAttributeAigp struct {
-	PathAttribute
-	Values []AigpTLVInterface
-}
-
-func (p *PathAttributeAigp) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data, options...)
-	if err != nil {
-		return err
-	}
-	for len(value) > 3 {
-		typ := value[0]
-		length := binary.BigEndian.Uint16(value[1:3])
-		if len(value) < int(length) {
-			break
-		}
-		v := value[3:length]
-		switch AigpTLVType(typ) {
-		case AIGP_TLV_IGP_METRIC:
-			if len(v) < 8 {
-				break
-			}
-			metric := binary.BigEndian.Uint64(v)
-			p.Values = append(p.Values, NewAigpTLVIgpMetric(metric))
-		default:
-			p.Values = append(p.Values, NewAigpTLVDefault(AigpTLVType(typ), v))
-		}
-		value = value[length:]
-	}
-	if len(value) != 0 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-		return NewMessageError(eCode, eSubCode, nil, "Aigp length is incorrect")
-	}
-	return nil
-}
-
-func (p *PathAttributeAigp) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, t := range p.Values {
-		bbuf, err := t.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, bbuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeAigp) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0, 32))
-	buf.WriteString("{Aigp: [")
-	for _, v := range p.Values {
-		buf.WriteString(v.String())
-	}
-	buf.WriteString("]}")
-	return buf.String()
-}
-
-func (p *PathAttributeAigp) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType        `json:"type"`
-		Value []AigpTLVInterface `json:"value"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Values,
-	})
-}
-
-func NewPathAttributeAigp(values []AigpTLVInterface) *PathAttributeAigp {
-	var l int
-	for _, v := range values {
-		l += v.Len()
-	}
-	t := BGP_ATTR_TYPE_AIGP
-	return &PathAttributeAigp{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Values: values,
-	}
-}
-
-type LargeCommunity struct {
-	ASN        uint32
-	LocalData1 uint32
-	LocalData2 uint32
-}
-
-func (c *LargeCommunity) Serialize() ([]byte, error) {
-	buf := make([]byte, 12)
-	binary.BigEndian.PutUint32(buf, c.ASN)
-	binary.BigEndian.PutUint32(buf[4:], c.LocalData1)
-	binary.BigEndian.PutUint32(buf[8:], c.LocalData2)
-	return buf, nil
-}
-
-func (c *LargeCommunity) String() string {
-	return fmt.Sprintf("%d:%d:%d", c.ASN, c.LocalData1, c.LocalData2)
-}
-
-func NewLargeCommunity(asn, data1, data2 uint32) *LargeCommunity {
-	return &LargeCommunity{
-		ASN:        asn,
-		LocalData1: data1,
-		LocalData2: data2,
-	}
-}
-
-func ParseLargeCommunity(value string) (*LargeCommunity, error) {
-	elems := strings.Split(value, ":")
-	if len(elems) != 3 {
-		return nil, fmt.Errorf("invalid large community format")
-	}
-	v := make([]uint32, 0, 3)
-	for _, elem := range elems {
-		e, err := strconv.ParseUint(elem, 10, 32)
-		if err != nil {
-			return nil, fmt.Errorf("invalid large community format")
-		}
-		v = append(v, uint32(e))
-	}
-	return NewLargeCommunity(v[0], v[1], v[2]), nil
-}
-
-type PathAttributeLargeCommunities struct {
-	PathAttribute
-	Values []*LargeCommunity
-}
-
-func (p *PathAttributeLargeCommunities) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	if p.Length%12 != 0 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return NewMessageError(eCode, eSubCode, nil, "large communities length isn't correct")
-	}
-	p.Values = make([]*LargeCommunity, 0, p.Length/12)
-	for len(value) >= 12 {
-		asn := binary.BigEndian.Uint32(value[:4])
-		data1 := binary.BigEndian.Uint32(value[4:8])
-		data2 := binary.BigEndian.Uint32(value[8:12])
-		p.Values = append(p.Values, NewLargeCommunity(asn, data1, data2))
-		value = value[12:]
-	}
-	return nil
-}
-
-func (p *PathAttributeLargeCommunities) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 0, len(p.Values)*12)
-	for _, t := range p.Values {
-		bbuf, err := t.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, bbuf...)
-	}
-	return p.PathAttribute.Serialize(buf, options...)
-}
-
-func (p *PathAttributeLargeCommunities) String() string {
-	buf := bytes.NewBuffer(make([]byte, 0, 32))
-	buf.WriteString("{LargeCommunity: [ ")
-	ss := []string{}
-	for _, v := range p.Values {
-		ss = append(ss, v.String())
-	}
-	buf.WriteString(strings.Join(ss, ", "))
-	buf.WriteString("]}")
-	return buf.String()
-}
-
-func (p *PathAttributeLargeCommunities) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Type  BGPAttrType       `json:"type"`
-		Value []*LargeCommunity `json:"value"`
-	}{
-		Type:  p.GetType(),
-		Value: p.Values,
-	})
-}
-
-func NewPathAttributeLargeCommunities(values []*LargeCommunity) *PathAttributeLargeCommunities {
-	l := len(values) * 12
-	t := BGP_ATTR_TYPE_LARGE_COMMUNITY
-	return &PathAttributeLargeCommunities{
-		PathAttribute: PathAttribute{
-			Flags:  getPathAttrFlags(t, l),
-			Type:   t,
-			Length: uint16(l),
-		},
-		Values: values,
-	}
-}
-
-type PathAttributeUnknown struct {
-	PathAttribute
-	Value []byte
-}
-
-func (p *PathAttributeUnknown) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	value, err := p.PathAttribute.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	p.Value = value
-	return nil
-}
-
-func (p *PathAttributeUnknown) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	return p.PathAttribute.Serialize(p.Value, options...)
-}
-
-func (p *PathAttributeUnknown) String() string {
-	return fmt.Sprintf("{Flags: %s, Type: %s, Value: %s}", p.Flags, p.Type, p.Value)
-}
-
-func (p *PathAttributeUnknown) MarshalJSON() ([]byte, error) {
-	return json.Marshal(struct {
-		Flags BGPAttrFlag `json:"flags"`
-		Type  BGPAttrType `json:"type"`
-		Value []byte      `json:"value"`
-	}{
-		Flags: p.GetFlags(),
-		Type:  p.GetType(),
-		Value: p.Value,
-	})
-}
-
-func NewPathAttributeUnknown(flags BGPAttrFlag, typ BGPAttrType, value []byte) *PathAttributeUnknown {
-	l := len(value)
-	if l > 255 {
-		flags |= BGP_ATTR_FLAG_EXTENDED_LENGTH
-	}
-	return &PathAttributeUnknown{
-		PathAttribute: PathAttribute{
-			Flags:  flags,
-			Type:   typ,
-			Length: uint16(l),
-		},
-		Value: value,
-	}
-}
-
-func GetPathAttribute(data []byte) (PathAttributeInterface, error) {
-	if len(data) < 2 {
-		eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-		eSubCode := uint8(BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR)
-		return nil, NewMessageError(eCode, eSubCode, data, "attribute type length is short")
-	}
-	switch BGPAttrType(data[1]) {
-	case BGP_ATTR_TYPE_ORIGIN:
-		return &PathAttributeOrigin{}, nil
-	case BGP_ATTR_TYPE_AS_PATH:
-		return &PathAttributeAsPath{}, nil
-	case BGP_ATTR_TYPE_NEXT_HOP:
-		return &PathAttributeNextHop{}, nil
-	case BGP_ATTR_TYPE_MULTI_EXIT_DISC:
-		return &PathAttributeMultiExitDisc{}, nil
-	case BGP_ATTR_TYPE_LOCAL_PREF:
-		return &PathAttributeLocalPref{}, nil
-	case BGP_ATTR_TYPE_ATOMIC_AGGREGATE:
-		return &PathAttributeAtomicAggregate{}, nil
-	case BGP_ATTR_TYPE_AGGREGATOR:
-		return &PathAttributeAggregator{}, nil
-	case BGP_ATTR_TYPE_COMMUNITIES:
-		return &PathAttributeCommunities{}, nil
-	case BGP_ATTR_TYPE_ORIGINATOR_ID:
-		return &PathAttributeOriginatorId{}, nil
-	case BGP_ATTR_TYPE_CLUSTER_LIST:
-		return &PathAttributeClusterList{}, nil
-	case BGP_ATTR_TYPE_MP_REACH_NLRI:
-		return &PathAttributeMpReachNLRI{}, nil
-	case BGP_ATTR_TYPE_MP_UNREACH_NLRI:
-		return &PathAttributeMpUnreachNLRI{}, nil
-	case BGP_ATTR_TYPE_EXTENDED_COMMUNITIES:
-		return &PathAttributeExtendedCommunities{}, nil
-	case BGP_ATTR_TYPE_AS4_PATH:
-		return &PathAttributeAs4Path{}, nil
-	case BGP_ATTR_TYPE_AS4_AGGREGATOR:
-		return &PathAttributeAs4Aggregator{}, nil
-	case BGP_ATTR_TYPE_TUNNEL_ENCAP:
-		return &PathAttributeTunnelEncap{}, nil
-	case BGP_ATTR_TYPE_PMSI_TUNNEL:
-		return &PathAttributePmsiTunnel{}, nil
-	case BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES:
-		return &PathAttributeIP6ExtendedCommunities{}, nil
-	case BGP_ATTR_TYPE_AIGP:
-		return &PathAttributeAigp{}, nil
-	case BGP_ATTR_TYPE_LARGE_COMMUNITY:
-		return &PathAttributeLargeCommunities{}, nil
-	}
-	return &PathAttributeUnknown{}, nil
-}
-
-type BGPUpdate struct {
-	WithdrawnRoutesLen    uint16
-	WithdrawnRoutes       []*IPAddrPrefix
-	TotalPathAttributeLen uint16
-	PathAttributes        []PathAttributeInterface
-	NLRI                  []*IPAddrPrefix
-}
-
-func (msg *BGPUpdate) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	var strongestError error
-
-	// cache error codes
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-
-	// check withdrawn route length
-	if len(data) < 2 {
-		return NewMessageError(eCode, eSubCode, nil, "message length isn't enough for withdrawn route length")
-	}
-
-	msg.WithdrawnRoutesLen = binary.BigEndian.Uint16(data[0:2])
-	data = data[2:]
-
-	// check withdrawn route
-	if len(data) < int(msg.WithdrawnRoutesLen) {
-		return NewMessageError(eCode, eSubCode, nil, "withdrawn route length exceeds message length")
-	}
-
-	addpathLen := 0
-	if IsAddPathEnabled(true, RF_IPv4_UC, options) {
-		addpathLen = 4
-	}
-
-	msg.WithdrawnRoutes = make([]*IPAddrPrefix, 0, msg.WithdrawnRoutesLen)
-	for routelen := msg.WithdrawnRoutesLen; routelen > 0; {
-		w := &IPAddrPrefix{}
-		err := w.DecodeFromBytes(data, options...)
-		if err != nil {
-			return err
-		}
-		routelen -= uint16(w.Len(options...) + addpathLen)
-		if len(data) < w.Len(options...)+addpathLen {
-			return NewMessageError(eCode, eSubCode, nil, "Withdrawn route length is short")
-		}
-		data = data[w.Len(options...)+addpathLen:]
-		msg.WithdrawnRoutes = append(msg.WithdrawnRoutes, w)
-	}
-
-	// check path total attribute length
-	if len(data) < 2 {
-		return NewMessageError(eCode, eSubCode, nil, "message length isn't enough for path total attribute length")
-	}
-
-	msg.TotalPathAttributeLen = binary.BigEndian.Uint16(data[0:2])
-	data = data[2:]
-
-	// check path attribute
-	if len(data) < int(msg.TotalPathAttributeLen) {
-		return NewMessageError(eCode, eSubCode, nil, "path total attribute length exceeds message length")
-	}
-
-	msg.PathAttributes = []PathAttributeInterface{}
-	for pathlen := msg.TotalPathAttributeLen; pathlen > 0; {
-		var e error
-		if pathlen < 3 {
-			e = NewMessageErrorWithErrorHandling(
-				eCode, BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR, data, ERROR_HANDLING_TREAT_AS_WITHDRAW, nil, "insufficient data to decode")
-			if e.(*MessageError).Stronger(strongestError) {
-				strongestError = e
-			}
-			data = data[pathlen:]
-			break
-		}
-		p, err := GetPathAttribute(data)
-		if err != nil {
-			return err
-		}
-
-		err = p.DecodeFromBytes(data, options...)
-		if err != nil {
-			e = err.(*MessageError)
-			if e.(*MessageError).SubTypeCode == BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR {
-				e.(*MessageError).ErrorHandling = ERROR_HANDLING_TREAT_AS_WITHDRAW
-			} else {
-				e.(*MessageError).ErrorHandling = getErrorHandlingFromPathAttribute(p.GetType())
-				e.(*MessageError).ErrorAttribute = &p
-			}
-			if e.(*MessageError).Stronger(strongestError) {
-				strongestError = e
-			}
-		}
-		pathlen -= uint16(p.Len(options...))
-		if len(data) < p.Len(options...) {
-			e = NewMessageErrorWithErrorHandling(
-				eCode, BGP_ERROR_SUB_ATTRIBUTE_LENGTH_ERROR, data, ERROR_HANDLING_TREAT_AS_WITHDRAW, nil, "attribute length is short")
-			if e.(*MessageError).Stronger(strongestError) {
-				strongestError = e
-			}
-		}
-		data = data[p.Len(options...):]
-		if e == nil || e.(*MessageError).ErrorHandling != ERROR_HANDLING_ATTRIBUTE_DISCARD {
-			msg.PathAttributes = append(msg.PathAttributes, p)
-		}
-	}
-
-	msg.NLRI = make([]*IPAddrPrefix, 0)
-	for restlen := len(data); restlen > 0; {
-		n := &IPAddrPrefix{}
-		err := n.DecodeFromBytes(data, options...)
-		if err != nil {
-			return err
-		}
-		restlen -= n.Len(options...) + addpathLen
-		if len(data) < n.Len(options...)+addpathLen {
-			return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, nil, "NLRI length is short")
-		}
-		if n.Len(options...) > 32 {
-			return NewMessageError(eCode, BGP_ERROR_SUB_INVALID_NETWORK_FIELD, nil, "NLRI length is too long")
-		}
-		data = data[n.Len(options...)+addpathLen:]
-		msg.NLRI = append(msg.NLRI, n)
-	}
-
-	return strongestError
-}
-
-func (msg *BGPUpdate) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	wbuf := make([]byte, 2)
-	for _, w := range msg.WithdrawnRoutes {
-		onewbuf, err := w.Serialize(options...)
-		if err != nil {
-			return nil, err
-		}
-		wbuf = append(wbuf, onewbuf...)
-	}
-	msg.WithdrawnRoutesLen = uint16(len(wbuf) - 2)
-	binary.BigEndian.PutUint16(wbuf, msg.WithdrawnRoutesLen)
-
-	pbuf := make([]byte, 2)
-	for _, p := range msg.PathAttributes {
-		onepbuf, err := p.Serialize(options...)
-		if err != nil {
-			return nil, err
-		}
-		pbuf = append(pbuf, onepbuf...)
-	}
-	msg.TotalPathAttributeLen = uint16(len(pbuf) - 2)
-	binary.BigEndian.PutUint16(pbuf, msg.TotalPathAttributeLen)
-
-	buf := append(wbuf, pbuf...)
-	for _, n := range msg.NLRI {
-		nbuf, err := n.Serialize(options...)
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, nbuf...)
-	}
-	return buf, nil
-}
-
-func (msg *BGPUpdate) IsEndOfRib() (bool, RouteFamily) {
-	if len(msg.WithdrawnRoutes) == 0 && len(msg.NLRI) == 0 {
-		if len(msg.PathAttributes) == 0 {
-			return true, RF_IPv4_UC
-		} else if len(msg.PathAttributes) == 1 && msg.PathAttributes[0].GetType() == BGP_ATTR_TYPE_MP_UNREACH_NLRI {
-			unreach := msg.PathAttributes[0].(*PathAttributeMpUnreachNLRI)
-			if len(unreach.Value) == 0 {
-				return true, AfiSafiToRouteFamily(unreach.AFI, unreach.SAFI)
-			}
-		}
-	}
-	return false, RouteFamily(0)
-}
-
-func TreatAsWithdraw(msg *BGPUpdate) *BGPUpdate {
-	withdraw := &BGPUpdate{
-		WithdrawnRoutesLen:    0,
-		WithdrawnRoutes:       []*IPAddrPrefix{},
-		TotalPathAttributeLen: 0,
-		PathAttributes:        make([]PathAttributeInterface, 0, len(msg.PathAttributes)),
-		NLRI:                  []*IPAddrPrefix{},
-	}
-	withdraw.WithdrawnRoutes = append(msg.WithdrawnRoutes, msg.NLRI...)
-	var unreach []AddrPrefixInterface
-
-	for _, p := range msg.PathAttributes {
-		switch nlri := p.(type) {
-		case *PathAttributeMpReachNLRI:
-			unreach = append(unreach, nlri.Value...)
-		case *PathAttributeMpUnreachNLRI:
-			unreach = append(unreach, nlri.Value...)
-		}
-	}
-	if len(unreach) != 0 {
-		withdraw.PathAttributes = append(withdraw.PathAttributes, NewPathAttributeMpUnreachNLRI(unreach))
-	}
-	return withdraw
-}
-
-func NewBGPUpdateMessage(withdrawnRoutes []*IPAddrPrefix, pathattrs []PathAttributeInterface, nlri []*IPAddrPrefix) *BGPMessage {
-	return &BGPMessage{
-		Header: BGPHeader{Type: BGP_MSG_UPDATE},
-		Body:   &BGPUpdate{0, withdrawnRoutes, 0, pathattrs, nlri},
-	}
-}
-
-func NewEndOfRib(family RouteFamily) *BGPMessage {
-	if family == RF_IPv4_UC {
-		return NewBGPUpdateMessage(nil, nil, nil)
-	} else {
-		afi, safi := RouteFamilyToAfiSafi(family)
-		t := BGP_ATTR_TYPE_MP_UNREACH_NLRI
-		unreach := &PathAttributeMpUnreachNLRI{
-			PathAttribute: PathAttribute{
-				Flags: PathAttrFlags[t],
-				Type:  t,
-			},
-			AFI:  afi,
-			SAFI: safi,
-		}
-		return NewBGPUpdateMessage(nil, []PathAttributeInterface{unreach}, nil)
-	}
-}
-
-type BGPNotification struct {
-	ErrorCode    uint8
-	ErrorSubcode uint8
-	Data         []byte
-}
-
-func (msg *BGPNotification) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if len(data) < 2 {
-		return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Not all Notificaiton bytes available")
-	}
-	msg.ErrorCode = data[0]
-	msg.ErrorSubcode = data[1]
-	if len(data) > 2 {
-		msg.Data = data[2:]
-	}
-	return nil
-}
-
-func (msg *BGPNotification) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 2)
-	buf[0] = msg.ErrorCode
-	buf[1] = msg.ErrorSubcode
-	buf = append(buf, msg.Data...)
-	return buf, nil
-}
-
-func NewBGPNotificationMessage(errcode uint8, errsubcode uint8, data []byte) *BGPMessage {
-	return &BGPMessage{
-		Header: BGPHeader{Type: BGP_MSG_NOTIFICATION},
-		Body:   &BGPNotification{errcode, errsubcode, data},
-	}
-}
-
-type BGPKeepAlive struct {
-}
-
-func (msg *BGPKeepAlive) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	return nil
-}
-
-func (msg *BGPKeepAlive) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	return nil, nil
-}
-
-func NewBGPKeepAliveMessage() *BGPMessage {
-	return &BGPMessage{
-		Header: BGPHeader{Len: 19, Type: BGP_MSG_KEEPALIVE},
-		Body:   &BGPKeepAlive{},
-	}
-}
-
-type BGPRouteRefresh struct {
-	AFI         uint16
-	Demarcation uint8
-	SAFI        uint8
-}
-
-func (msg *BGPRouteRefresh) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	if len(data) < 4 {
-		return NewMessageError(BGP_ERROR_ROUTE_REFRESH_MESSAGE_ERROR, BGP_ERROR_SUB_INVALID_MESSAGE_LENGTH, nil, "Not all RouteRefresh bytes available")
-	}
-	msg.AFI = binary.BigEndian.Uint16(data[0:2])
-	msg.Demarcation = data[2]
-	msg.SAFI = data[3]
-	return nil
-}
-
-func (msg *BGPRouteRefresh) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint16(buf[0:2], msg.AFI)
-	buf[2] = msg.Demarcation
-	buf[3] = msg.SAFI
-	return buf, nil
-}
-
-func NewBGPRouteRefreshMessage(afi uint16, demarcation uint8, safi uint8) *BGPMessage {
-	return &BGPMessage{
-		Header: BGPHeader{Type: BGP_MSG_ROUTE_REFRESH},
-		Body:   &BGPRouteRefresh{afi, demarcation, safi},
-	}
-}
-
-type BGPBody interface {
-	DecodeFromBytes([]byte, ...*MarshallingOption) error
-	Serialize(...*MarshallingOption) ([]byte, error)
-}
-
-const (
-	BGP_HEADER_LENGTH      = 19
-	BGP_MAX_MESSAGE_LENGTH = 4096
-)
-
-type BGPHeader struct {
-	Marker []byte
-	Len    uint16
-	Type   uint8
-}
-
-func (msg *BGPHeader) DecodeFromBytes(data []byte, options ...*MarshallingOption) error {
-	// minimum BGP message length
-	if uint16(len(data)) < BGP_HEADER_LENGTH {
-		return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "not all BGP message header")
-	}
-
-	msg.Len = binary.BigEndian.Uint16(data[16:18])
-	if int(msg.Len) < BGP_HEADER_LENGTH {
-		return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "unknown message type")
-	}
-
-	msg.Type = data[18]
-	return nil
-}
-
-func (msg *BGPHeader) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	buf := make([]byte, 19)
-	for i := range buf[:16] {
-		buf[i] = 0xff
-	}
-	binary.BigEndian.PutUint16(buf[16:18], msg.Len)
-	buf[18] = msg.Type
-	return buf, nil
-}
-
-type BGPMessage struct {
-	Header BGPHeader
-	Body   BGPBody
-}
-
-func parseBody(h *BGPHeader, data []byte, options ...*MarshallingOption) (*BGPMessage, error) {
-	if len(data) < int(h.Len)-BGP_HEADER_LENGTH {
-		return nil, NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "Not all BGP message bytes available")
-	}
-	msg := &BGPMessage{Header: *h}
-
-	switch msg.Header.Type {
-	case BGP_MSG_OPEN:
-		msg.Body = &BGPOpen{}
-	case BGP_MSG_UPDATE:
-		msg.Body = &BGPUpdate{}
-	case BGP_MSG_NOTIFICATION:
-		msg.Body = &BGPNotification{}
-	case BGP_MSG_KEEPALIVE:
-		msg.Body = &BGPKeepAlive{}
-	case BGP_MSG_ROUTE_REFRESH:
-		msg.Body = &BGPRouteRefresh{}
-	default:
-		return nil, NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_TYPE, nil, "unknown message type")
-	}
-	err := msg.Body.DecodeFromBytes(data, options...)
-	return msg, err
-}
-
-func ParseBGPMessage(data []byte, options ...*MarshallingOption) (*BGPMessage, error) {
-	h := &BGPHeader{}
-	err := h.DecodeFromBytes(data, options...)
-	if err != nil {
-		return nil, err
-	}
-
-	if int(h.Len) > len(data) {
-		return nil, NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, nil, "unknown message type")
-	}
-
-	return parseBody(h, data[19:h.Len], options...)
-}
-
-func ParseBGPBody(h *BGPHeader, data []byte, options ...*MarshallingOption) (*BGPMessage, error) {
-	return parseBody(h, data, options...)
-}
-
-func (msg *BGPMessage) Serialize(options ...*MarshallingOption) ([]byte, error) {
-	b, err := msg.Body.Serialize(options...)
-	if err != nil {
-		return nil, err
-	}
-	if msg.Header.Len == 0 {
-		if 19+len(b) > BGP_MAX_MESSAGE_LENGTH {
-			return nil, NewMessageError(0, 0, nil, fmt.Sprintf("too long message length %d", 19+len(b)))
-		}
-		msg.Header.Len = 19 + uint16(len(b))
-	}
-	h, err := msg.Header.Serialize(options...)
-	if err != nil {
-		return nil, err
-	}
-	return append(h, b...), nil
-}
-
-type ErrorHandling int
-
-const (
-	ERROR_HANDLING_NONE ErrorHandling = iota
-	ERROR_HANDLING_ATTRIBUTE_DISCARD
-	ERROR_HANDLING_TREAT_AS_WITHDRAW
-	ERROR_HANDLING_AFISAFI_DISABLE
-	ERROR_HANDLING_SESSION_RESET
-)
-
-func getErrorHandlingFromPathAttribute(t BGPAttrType) ErrorHandling {
-	switch t {
-	case BGP_ATTR_TYPE_ORIGIN:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_AS_PATH:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_AS4_PATH:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_NEXT_HOP:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_MULTI_EXIT_DISC:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_LOCAL_PREF:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_ATOMIC_AGGREGATE:
-		return ERROR_HANDLING_ATTRIBUTE_DISCARD
-	case BGP_ATTR_TYPE_AGGREGATOR:
-		return ERROR_HANDLING_ATTRIBUTE_DISCARD
-	case BGP_ATTR_TYPE_AS4_AGGREGATOR:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_COMMUNITIES:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_ORIGINATOR_ID:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_CLUSTER_LIST:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_MP_REACH_NLRI:
-		return ERROR_HANDLING_AFISAFI_DISABLE
-	case BGP_ATTR_TYPE_MP_UNREACH_NLRI:
-		return ERROR_HANDLING_AFISAFI_DISABLE
-	case BGP_ATTR_TYPE_EXTENDED_COMMUNITIES:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_IP6_EXTENDED_COMMUNITIES:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_PMSI_TUNNEL:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_LARGE_COMMUNITY:
-		return ERROR_HANDLING_TREAT_AS_WITHDRAW
-	case BGP_ATTR_TYPE_TUNNEL_ENCAP:
-		return ERROR_HANDLING_ATTRIBUTE_DISCARD
-	case BGP_ATTR_TYPE_AIGP:
-		return ERROR_HANDLING_ATTRIBUTE_DISCARD
-	default:
-		return ERROR_HANDLING_ATTRIBUTE_DISCARD
-	}
-}
-
-type MessageError struct {
-	TypeCode       uint8
-	SubTypeCode    uint8
-	Data           []byte
-	Message        string
-	ErrorHandling  ErrorHandling
-	ErrorAttribute *PathAttributeInterface
-}
-
-func NewMessageError(typeCode, subTypeCode uint8, data []byte, msg string) error {
-	return &MessageError{
-		TypeCode:       typeCode,
-		SubTypeCode:    subTypeCode,
-		Data:           data,
-		ErrorHandling:  ERROR_HANDLING_SESSION_RESET,
-		ErrorAttribute: nil,
-		Message:        msg,
-	}
-}
-
-func NewMessageErrorWithErrorHandling(typeCode, subTypeCode uint8, data []byte, errorHandling ErrorHandling, errorAttribute *PathAttributeInterface, msg string) error {
-	return &MessageError{
-		TypeCode:       typeCode,
-		SubTypeCode:    subTypeCode,
-		Data:           data,
-		ErrorHandling:  errorHandling,
-		ErrorAttribute: errorAttribute,
-		Message:        msg,
-	}
-}
-
-func (e *MessageError) Error() string {
-	return e.Message
-}
-
-func (e *MessageError) Stronger(err error) bool {
-	if err == nil {
-		return true
-	}
-	if msgErr, ok := err.(*MessageError); ok {
-		return e.ErrorHandling > msgErr.ErrorHandling
-	}
-	return false
-}
-
-func (e *TwoOctetAsSpecificExtended) Flat() map[string]string {
-	if e.SubType == EC_SUBTYPE_ROUTE_TARGET {
-		return map[string]string{"routeTarget": e.String()}
-	}
-	return map[string]string{}
-}
-
-func (e *ColorExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *EncapExtended) Flat() map[string]string {
-	return map[string]string{"encaspulation": e.TunnelType.String()}
-}
-
-func (e *DefaultGatewayExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *ValidationExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *OpaqueExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *IPv4AddressSpecificExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *IPv6AddressSpecificExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *FourOctetAsSpecificExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *ESILabelExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *ESImportRouteTarget) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *MacMobilityExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *RouterMacExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *TrafficRateExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *TrafficRemarkExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *RedirectIPv4AddressSpecificExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *RedirectIPv6AddressSpecificExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *RedirectFourOctetAsSpecificExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *UnknownExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (e *TrafficActionExtended) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (p *PathAttributeExtendedCommunities) Flat() map[string]string {
-	flat := map[string]string{}
-	for _, ec := range p.Value {
-		FlatUpdate(flat, ec.Flat())
-	}
-	return flat
-}
-
-func (p *PathAttribute) Flat() map[string]string {
-	return map[string]string{}
-}
-
-func (l *LabeledVPNIPAddrPrefix) Flat() map[string]string {
-	prefixLen := l.IPAddrPrefixDefault.Length - uint8(8*(l.Labels.Len()+l.RD.Len()))
-	return map[string]string{
-		"Prefix":    l.IPAddrPrefixDefault.Prefix.String(),
-		"PrefixLen": fmt.Sprintf("%d", prefixLen),
-		"NLRI":      l.String(),
-		"Label":     l.Labels.String(),
-	}
-}
-
-func (p *IPAddrPrefixDefault) Flat() map[string]string {
-	l := strings.Split(p.String(), "/")
-	if len(l) == 2 {
-		return map[string]string{
-			"Prefix":    l[0],
-			"PrefixLen": l[1],
-		}
-	}
-	return map[string]string{}
-}
-
-func (l *EVPNNLRI) Flat() map[string]string {
-	return map[string]string{}
-}
-func (l *RouteTargetMembershipNLRI) Flat() map[string]string {
-	return map[string]string{}
-}
-func (l *FlowSpecIPv4Unicast) Flat() map[string]string {
-	return map[string]string{}
-}
-func (l *FlowSpecIPv4VPN) Flat() map[string]string {
-	return map[string]string{}
-}
-func (l *FlowSpecIPv6Unicast) Flat() map[string]string {
-	return map[string]string{}
-}
-func (l *FlowSpecIPv6VPN) Flat() map[string]string {
-	return map[string]string{}
-}
-func (l *FlowSpecL2VPN) Flat() map[string]string {
-	return map[string]string{}
-}
-func (l *OpaqueNLRI) Flat() map[string]string {
-	return map[string]string{}
-}
-
-// Update a Flat representation by adding elements of the second
-// one. If two elements use same keys, values are separated with
-// ';'. In this case, it returns an error but the update has been
-// realized.
-func FlatUpdate(f1, f2 map[string]string) error {
-	conflict := false
-	for k2, v2 := range f2 {
-		if v1, ok := f1[k2]; ok {
-			f1[k2] = v1 + ";" + v2
-			conflict = true
-		} else {
-			f1[k2] = v2
-		}
-	}
-	if conflict {
-		return fmt.Errorf("Keys conflict")
-	} else {
-		return nil
-	}
-}
diff --git a/packet/bgp/bgp_race_test.go b/packet/bgp/bgp_race_test.go
deleted file mode 100644
index 08038200..00000000
--- a/packet/bgp/bgp_race_test.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (C) 2018 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.
-
-// +build race
-
-package bgp
-
-import (
-	"testing"
-	"time"
-)
-
-// Test_RaceCondition detects data races when serialization.
-// Currently tests only attributes contained in UPDATE message.
-func Test_RaceCondition(t *testing.T) {
-	m := NewTestBGPUpdateMessage()
-	updateBody := m.Body.(*BGPUpdate)
-
-	go func(body *BGPUpdate) {
-		for _, v := range body.WithdrawnRoutes {
-			v.Serialize()
-		}
-		for _, v := range body.PathAttributes {
-			v.Serialize()
-		}
-		for _, v := range body.NLRI {
-			v.Serialize()
-		}
-	}(updateBody)
-
-	time.Sleep(time.Second)
-
-	updateBody.Serialize()
-}
diff --git a/packet/bgp/bgp_test.go b/packet/bgp/bgp_test.go
deleted file mode 100644
index a4801f27..00000000
--- a/packet/bgp/bgp_test.go
+++ /dev/null
@@ -1,1194 +0,0 @@
-// Copyright (C) 2016 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 (
-	"bytes"
-	"encoding/binary"
-	"net"
-	"reflect"
-	"strconv"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func keepalive() *BGPMessage {
-	return NewBGPKeepAliveMessage()
-}
-
-func notification() *BGPMessage {
-	return NewBGPNotificationMessage(1, 2, nil)
-}
-
-func refresh() *BGPMessage {
-	return NewBGPRouteRefreshMessage(1, 2, 10)
-}
-
-var result []string
-
-func BenchmarkNormalizeFlowSpecOpValues(b *testing.B) {
-	var r []string
-	for n := 0; n < b.N; n++ {
-		r = normalizeFlowSpecOpValues([]string{"&<=80"})
-	}
-	result = r
-}
-
-func Test_Message(t *testing.T) {
-	l := []*BGPMessage{keepalive(), notification(), refresh(), NewTestBGPOpenMessage(), NewTestBGPUpdateMessage()}
-
-	for _, m1 := range l {
-		buf1, err := m1.Serialize()
-		assert.NoError(t, err)
-
-		t.Log("LEN =", len(buf1))
-		m2, err := ParseBGPMessage(buf1)
-		assert.NoError(t, err)
-
-		// FIXME: shouldn't but workaround for some structs.
-		_, err = m2.Serialize()
-		assert.NoError(t, err)
-
-		assert.True(t, reflect.DeepEqual(m1, m2))
-	}
-}
-
-func Test_IPAddrPrefixString(t *testing.T) {
-	ipv4 := NewIPAddrPrefix(24, "129.6.10.0")
-	assert.Equal(t, "129.6.10.0/24", ipv4.String())
-	ipv4 = NewIPAddrPrefix(24, "129.6.10.1")
-	assert.Equal(t, "129.6.10.0/24", ipv4.String())
-	ipv4 = NewIPAddrPrefix(22, "129.6.129.0")
-	assert.Equal(t, "129.6.128.0/22", ipv4.String())
-
-	ipv6 := NewIPv6AddrPrefix(64, "3343:faba:3903::0")
-	assert.Equal(t, "3343:faba:3903::/64", ipv6.String())
-	ipv6 = NewIPv6AddrPrefix(64, "3343:faba:3903::1")
-	assert.Equal(t, "3343:faba:3903::/64", ipv6.String())
-	ipv6 = NewIPv6AddrPrefix(63, "3343:faba:3903:129::0")
-	assert.Equal(t, "3343:faba:3903:128::/63", ipv6.String())
-}
-
-func Test_RouteTargetMembershipNLRIString(t *testing.T) {
-	assert := assert.New(t)
-
-	// TwoOctetAsSpecificExtended
-	buf := make([]byte, 13)
-	buf[0] = 96 // in bit length
-	binary.BigEndian.PutUint32(buf[1:5], 65546)
-	buf[5] = byte(EC_TYPE_TRANSITIVE_TWO_OCTET_AS_SPECIFIC) // typehigh
-	binary.BigEndian.PutUint16(buf[7:9], 65000)
-	binary.BigEndian.PutUint32(buf[9:], 65546)
-	r := &RouteTargetMembershipNLRI{}
-	err := r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:65000:65546", r.String())
-	buf, err = r.Serialize()
-	assert.Equal(nil, err)
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:65000:65546", r.String())
-
-	// IPv4AddressSpecificExtended
-	buf = make([]byte, 13)
-	buf[0] = 96 // in bit length
-	binary.BigEndian.PutUint32(buf[1:5], 65546)
-	buf[5] = byte(EC_TYPE_TRANSITIVE_IP4_SPECIFIC) // typehigh
-	ip := net.ParseIP("10.0.0.1").To4()
-	copy(buf[7:11], []byte(ip))
-	binary.BigEndian.PutUint16(buf[11:], 65000)
-	r = &RouteTargetMembershipNLRI{}
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:10.0.0.1:65000", r.String())
-	buf, err = r.Serialize()
-	assert.Equal(nil, err)
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:10.0.0.1:65000", r.String())
-
-	// FourOctetAsSpecificExtended
-	buf = make([]byte, 13)
-	buf[0] = 96 // in bit length
-	binary.BigEndian.PutUint32(buf[1:5], 65546)
-	buf[5] = byte(EC_TYPE_TRANSITIVE_FOUR_OCTET_AS_SPECIFIC) // typehigh
-	buf[6] = byte(EC_SUBTYPE_ROUTE_TARGET)                   // subtype
-	binary.BigEndian.PutUint32(buf[7:], 65546)
-	binary.BigEndian.PutUint16(buf[11:], 65000)
-	r = &RouteTargetMembershipNLRI{}
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:1.10:65000", r.String())
-	buf, err = r.Serialize()
-	assert.Equal(nil, err)
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:1.10:65000", r.String())
-
-	// OpaqueExtended
-	buf = make([]byte, 13)
-	buf[0] = 96 // in bit length
-	binary.BigEndian.PutUint32(buf[1:5], 65546)
-	buf[5] = byte(EC_TYPE_TRANSITIVE_OPAQUE) // typehigh
-	binary.BigEndian.PutUint32(buf[9:], 1000000)
-	r = &RouteTargetMembershipNLRI{}
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:1000000", r.String())
-	buf, err = r.Serialize()
-	assert.Equal(nil, err)
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:1000000", r.String())
-
-	// Unknown
-	buf = make([]byte, 13)
-	buf[0] = 96 // in bit length
-	binary.BigEndian.PutUint32(buf[1:5], 65546)
-	buf[5] = 0x04 // typehigh
-	binary.BigEndian.PutUint32(buf[9:], 1000000)
-	r = &RouteTargetMembershipNLRI{}
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:1000000", r.String())
-	buf, err = r.Serialize()
-	assert.Equal(nil, err)
-	err = r.DecodeFromBytes(buf)
-	assert.Equal(nil, err)
-	assert.Equal("65546:1000000", r.String())
-
-}
-
-func Test_MalformedUpdateMsg(t *testing.T) {
-	assert := assert.New(t)
-
-	// Invalid AGGREGATOR
-	bufin := []byte{
-		0x00, 0x00, // Withdraws(0)
-		0x00, 0x16, // Attrs Len(22)
-		0xc0, 0x07, 0x05, // Flag, Type(7), Length(5)
-		0x00, 0x00, 0x00, 0x64, // aggregator - invalid length
-		0x00,
-		0x40, 0x01, 0x01, 0x00, // Attr(ORIGIN)
-		0x40, 0x03, 0x04, 0xc0, // Attr(NEXT_HOP)
-		0xa8, 0x01, 0x64,
-		0x40, 0x02, 0x00, // Attr(AS_PATH)
-	}
-
-	u := &BGPUpdate{}
-	err := u.DecodeFromBytes(bufin)
-	assert.Error(err)
-	assert.Equal(ERROR_HANDLING_ATTRIBUTE_DISCARD, err.(*MessageError).ErrorHandling)
-
-	// Invalid MP_REACH_NLRI
-	bufin = []byte{
-		0x00, 0x00, // Withdraws(0)
-		0x00, 0x27, // Attrs Len(39)
-		0x80, 0x0e, 0x1d, // Flag, Type(14), Length(29)
-		0x00, 0x02, 0x01, // afi(2), safi(1)
-		0x0f, 0x00, 0x00, 0x00, // nexthop - invalid nexthop length
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0xff,
-		0xff, 0x0a, 0x00, 0x00,
-		0x00,                   // SNPA(0)
-		0x40, 0x20, 0x01, 0x0d, // NLRI
-		0xb8, 0x00, 0x01, 0x00,
-		0x00,
-		0x40, 0x01, 0x01, 0x00, // Attr(ORIGIN)
-		0x40, 0x02, 0x00, // Attr(AS_PATH)
-	}
-
-	err = u.DecodeFromBytes(bufin)
-	assert.Error(err)
-	assert.Equal(ERROR_HANDLING_AFISAFI_DISABLE, err.(*MessageError).ErrorHandling)
-
-	// Invalid flag
-	bufin = []byte{
-		0x00, 0x00, // Withdraws(0)
-		0x00, 0x0e, // Attrs Len(14)
-		0xc0, 0x01, 0x01, 0x00, // Attr(ORIGIN) - invalid flag
-		0x40, 0x03, 0x04, 0xc0, // Attr(NEXT_HOP)
-		0xa8, 0x01, 0x64,
-		0x40, 0x02, 0x00, // Attr(AS_PATH)
-	}
-
-	err = u.DecodeFromBytes(bufin)
-	assert.Error(err)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, err.(*MessageError).ErrorHandling)
-
-	// Invalid AGGREGATOR and MULTI_EXIT_DESC
-	bufin = []byte{
-		0x00, 0x00, // Withdraws(0)
-		0x00, 0x1e, // Attrs Len(30)
-		0xc0, 0x07, 0x05, 0x00, // Attr(AGGREGATOR) - invalid length
-		0x00, 0x00, 0x64, 0x00,
-		0x80, 0x04, 0x05, 0x00, // Attr(MULTI_EXIT_DESC)  - invalid length
-		0x00, 0x00, 0x00, 0x64,
-		0x40, 0x01, 0x01, 0x00, // Attr(ORIGIN)
-		0x40, 0x02, 0x00, // Attr(AS_PATH)
-		0x40, 0x03, 0x04, 0xc0, // Attr(NEXT_HOP)
-		0xa8, 0x01, 0x64,
-		0x20, 0xc8, 0xc8, 0xc8, // NLRI
-		0xc8,
-	}
-
-	err = u.DecodeFromBytes(bufin)
-	assert.Error(err)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, err.(*MessageError).ErrorHandling)
-}
-
-func Test_RFC5512(t *testing.T) {
-	assert := assert.New(t)
-
-	buf := make([]byte, 8)
-	buf[0] = byte(EC_TYPE_TRANSITIVE_OPAQUE)
-	buf[1] = byte(EC_SUBTYPE_COLOR)
-	binary.BigEndian.PutUint32(buf[4:], 1000000)
-	ec, err := ParseExtended(buf)
-	assert.Equal(nil, err)
-	assert.Equal("1000000", ec.String())
-	buf, err = ec.Serialize()
-	assert.Equal(nil, err)
-	assert.Equal([]byte{0x3, 0xb, 0x0, 0x0, 0x0, 0xf, 0x42, 0x40}, buf)
-
-	buf = make([]byte, 8)
-	buf[0] = byte(EC_TYPE_TRANSITIVE_OPAQUE)
-	buf[1] = byte(EC_SUBTYPE_ENCAPSULATION)
-	binary.BigEndian.PutUint16(buf[6:], uint16(TUNNEL_TYPE_VXLAN))
-	ec, err = ParseExtended(buf)
-	assert.Equal(nil, err)
-	assert.Equal("VXLAN", ec.String())
-	buf, err = ec.Serialize()
-	assert.Equal(nil, err)
-	assert.Equal([]byte{0x3, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8}, buf)
-
-	tlv := NewTunnelEncapTLV(TUNNEL_TYPE_VXLAN, []TunnelEncapSubTLVInterface{NewTunnelEncapSubTLVColor(10)})
-	attr := NewPathAttributeTunnelEncap([]*TunnelEncapTLV{tlv})
-
-	buf1, err := attr.Serialize()
-	assert.Equal(nil, err)
-
-	p, err := GetPathAttribute(buf1)
-	assert.Equal(nil, err)
-
-	err = p.DecodeFromBytes(buf1)
-	assert.Equal(nil, err)
-
-	buf2, err := p.Serialize()
-	assert.Equal(nil, err)
-	assert.Equal(buf1, buf2)
-
-	n1 := NewEncapNLRI("10.0.0.1")
-	buf1, err = n1.Serialize()
-	assert.Equal(nil, err)
-
-	n2 := NewEncapNLRI("")
-	err = n2.DecodeFromBytes(buf1)
-	assert.Equal(nil, err)
-	assert.Equal("10.0.0.1", n2.String())
-
-	n3 := NewEncapv6NLRI("2001::1")
-	buf1, err = n3.Serialize()
-	assert.Equal(nil, err)
-
-	n4 := NewEncapv6NLRI("")
-	err = n4.DecodeFromBytes(buf1)
-	assert.Equal(nil, err)
-	assert.Equal("2001::1", n4.String())
-}
-
-func Test_ASLen(t *testing.T) {
-	assert := assert.New(t)
-
-	aspath := AsPathParam{
-		Num: 2,
-		AS:  []uint16{65000, 65001},
-	}
-	aspath.Type = BGP_ASPATH_ATTR_TYPE_SEQ
-	assert.Equal(2, aspath.ASLen())
-
-	aspath.Type = BGP_ASPATH_ATTR_TYPE_SET
-	assert.Equal(1, aspath.ASLen())
-
-	aspath.Type = BGP_ASPATH_ATTR_TYPE_CONFED_SEQ
-	assert.Equal(0, aspath.ASLen())
-
-	aspath.Type = BGP_ASPATH_ATTR_TYPE_CONFED_SET
-	assert.Equal(0, aspath.ASLen())
-
-	as4path := As4PathParam{
-		Num: 2,
-		AS:  []uint32{65000, 65001},
-	}
-	as4path.Type = BGP_ASPATH_ATTR_TYPE_SEQ
-	assert.Equal(2, as4path.ASLen())
-
-	as4path.Type = BGP_ASPATH_ATTR_TYPE_SET
-	assert.Equal(1, as4path.ASLen())
-
-	as4path.Type = BGP_ASPATH_ATTR_TYPE_CONFED_SEQ
-	assert.Equal(0, as4path.ASLen())
-
-	as4path.Type = BGP_ASPATH_ATTR_TYPE_CONFED_SET
-	assert.Equal(0, as4path.ASLen())
-
-}
-
-func Test_MPLSLabelStack(t *testing.T) {
-	assert := assert.New(t)
-	mpls := NewMPLSLabelStack()
-	buf, err := mpls.Serialize()
-	assert.Nil(err)
-	assert.Equal(true, bytes.Equal(buf, []byte{0, 0, 1}))
-
-	mpls = &MPLSLabelStack{}
-	assert.Nil(mpls.DecodeFromBytes(buf))
-	assert.Equal(1, len(mpls.Labels))
-	assert.Equal(uint32(0), mpls.Labels[0])
-
-	mpls = NewMPLSLabelStack(WITHDRAW_LABEL)
-	buf, err = mpls.Serialize()
-	assert.Nil(err)
-	assert.Equal(true, bytes.Equal(buf, []byte{128, 0, 0}))
-
-	mpls = &MPLSLabelStack{}
-	assert.Nil(mpls.DecodeFromBytes(buf))
-	assert.Equal(1, len(mpls.Labels))
-	assert.Equal(WITHDRAW_LABEL, mpls.Labels[0])
-}
-
-func Test_FlowSpecNlri(t *testing.T) {
-	assert := assert.New(t)
-	cmp := make([]FlowSpecComponentInterface, 0)
-	cmp = append(cmp, NewFlowSpecDestinationPrefix(NewIPAddrPrefix(24, "10.0.0.0")))
-	cmp = append(cmp, NewFlowSpecSourcePrefix(NewIPAddrPrefix(24, "10.0.0.0")))
-	item1 := NewFlowSpecComponentItem(DEC_NUM_OP_EQ, TCP)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_IP_PROTO, []*FlowSpecComponentItem{item1}))
-	item2 := NewFlowSpecComponentItem(DEC_NUM_OP_GT_EQ, 20)
-	item3 := NewFlowSpecComponentItem(DEC_NUM_OP_AND|DEC_NUM_OP_LT_EQ, 30)
-	item4 := NewFlowSpecComponentItem(DEC_NUM_OP_GT_EQ, 10)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_DST_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_SRC_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_ICMP_TYPE, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_ICMP_CODE, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_PKT_LEN, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_DSCP, []*FlowSpecComponentItem{item2, item3, item4}))
-	isFragment := uint64(0x02)
-	lastFragment := uint64(0x08)
-	item5 := NewFlowSpecComponentItem(BITMASK_FLAG_OP_MATCH, isFragment)
-	item6 := NewFlowSpecComponentItem(BITMASK_FLAG_OP_AND, lastFragment)
-
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_FRAGMENT, []*FlowSpecComponentItem{item5, item6}))
-	item7 := NewFlowSpecComponentItem(0, TCP_FLAG_ACK)
-	item8 := NewFlowSpecComponentItem(BITMASK_FLAG_OP_AND|BITMASK_FLAG_OP_NOT, TCP_FLAG_URGENT)
-
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_TCP_FLAG, []*FlowSpecComponentItem{item7, item8}))
-	n1 := NewFlowSpecIPv4Unicast(cmp)
-
-	buf1, err := n1.Serialize()
-	assert.Nil(err)
-
-	n2, err := NewPrefixFromRouteFamily(RouteFamilyToAfiSafi(RF_FS_IPv4_UC))
-	assert.Nil(err)
-
-	err = n2.DecodeFromBytes(buf1)
-	assert.Nil(err)
-	// should be equal
-	assert.Equal(n1, n2)
-}
-
-func Test_FlowSpecExtended(t *testing.T) {
-	assert := assert.New(t)
-	exts := make([]ExtendedCommunityInterface, 0)
-	exts = append(exts, NewTrafficRateExtended(100, 9600.0))
-	exts = append(exts, NewTrafficActionExtended(true, false))
-	exts = append(exts, NewRedirectTwoOctetAsSpecificExtended(1000, 1000))
-	exts = append(exts, NewRedirectIPv4AddressSpecificExtended("10.0.0.1", 1000))
-	exts = append(exts, NewRedirectFourOctetAsSpecificExtended(10000000, 1000))
-	exts = append(exts, NewTrafficRemarkExtended(10))
-	m1 := NewPathAttributeExtendedCommunities(exts)
-	buf1, err := m1.Serialize()
-	require.NoError(t, err)
-
-	m2 := NewPathAttributeExtendedCommunities(nil)
-	err = m2.DecodeFromBytes(buf1)
-	require.NoError(t, err)
-
-	_, err = m2.Serialize()
-	require.NoError(t, err)
-
-	assert.Equal(m1, m2)
-}
-
-func Test_IP6FlowSpecExtended(t *testing.T) {
-	exts := make([]ExtendedCommunityInterface, 0)
-	exts = append(exts, NewRedirectIPv6AddressSpecificExtended("2001:db8::68", 1000))
-	m1 := NewPathAttributeIP6ExtendedCommunities(exts)
-	buf1, err := m1.Serialize()
-	require.NoError(t, err)
-
-	m2 := NewPathAttributeIP6ExtendedCommunities(nil)
-	err = m2.DecodeFromBytes(buf1)
-	require.NoError(t, err)
-
-	_, err = m2.Serialize()
-	require.NoError(t, err)
-
-	assert.Equal(t, m1, m2)
-}
-
-func Test_FlowSpecNlriv6(t *testing.T) {
-	cmp := make([]FlowSpecComponentInterface, 0)
-	cmp = append(cmp, NewFlowSpecDestinationPrefix6(NewIPv6AddrPrefix(64, "2001::"), 12))
-	cmp = append(cmp, NewFlowSpecSourcePrefix6(NewIPv6AddrPrefix(64, "2001::"), 12))
-	item1 := NewFlowSpecComponentItem(DEC_NUM_OP_EQ, TCP)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_IP_PROTO, []*FlowSpecComponentItem{item1}))
-	item2 := NewFlowSpecComponentItem(DEC_NUM_OP_GT_EQ, 20)
-	item3 := NewFlowSpecComponentItem(DEC_NUM_OP_AND|DEC_NUM_OP_LT_EQ, 30)
-	item4 := NewFlowSpecComponentItem(DEC_NUM_OP_EQ, 10)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_DST_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_SRC_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_ICMP_TYPE, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_ICMP_CODE, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_PKT_LEN, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_DSCP, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_LABEL, []*FlowSpecComponentItem{item2, item3, item4}))
-	isFragment := uint64(0x02)
-	item5 := NewFlowSpecComponentItem(BITMASK_FLAG_OP_MATCH, isFragment)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_FRAGMENT, []*FlowSpecComponentItem{item5}))
-	item6 := NewFlowSpecComponentItem(0, TCP_FLAG_ACK)
-	item7 := NewFlowSpecComponentItem(BITMASK_FLAG_OP_AND|BITMASK_FLAG_OP_NOT, TCP_FLAG_URGENT)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_TCP_FLAG, []*FlowSpecComponentItem{item6, item7}))
-	n1 := NewFlowSpecIPv6Unicast(cmp)
-	buf1, err := n1.Serialize()
-	require.NoError(t, err)
-
-	n2, err := NewPrefixFromRouteFamily(RouteFamilyToAfiSafi(RF_FS_IPv6_UC))
-	require.NoError(t, err)
-
-	err = n2.DecodeFromBytes(buf1)
-	require.NoError(t, err)
-
-	_, err = n2.Serialize()
-	require.NoError(t, err)
-
-	assert.Equal(t, n1, n2)
-}
-
-func Test_Aigp(t *testing.T) {
-	assert := assert.New(t)
-	m := NewAigpTLVIgpMetric(1000)
-	a1 := NewPathAttributeAigp([]AigpTLVInterface{m})
-	buf1, err := a1.Serialize()
-	require.NoError(t, err)
-
-	a2 := NewPathAttributeAigp(nil)
-	err = a2.DecodeFromBytes(buf1)
-	require.NoError(t, err)
-
-	assert.Equal(a1, a2)
-}
-
-func Test_FlowSpecNlriL2(t *testing.T) {
-	assert := assert.New(t)
-	mac, _ := net.ParseMAC("01:23:45:67:89:ab")
-	cmp := make([]FlowSpecComponentInterface, 0)
-	cmp = append(cmp, NewFlowSpecDestinationMac(mac))
-	cmp = append(cmp, NewFlowSpecSourceMac(mac))
-	item1 := NewFlowSpecComponentItem(DEC_NUM_OP_EQ, uint64(IPv4))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_ETHERNET_TYPE, []*FlowSpecComponentItem{item1}))
-	rd, _ := ParseRouteDistinguisher("100:100")
-	n1 := NewFlowSpecL2VPN(rd, cmp)
-	buf1, err := n1.Serialize()
-	assert.Nil(err)
-	n2, err := NewPrefixFromRouteFamily(RouteFamilyToAfiSafi(RF_FS_L2_VPN))
-	assert.Nil(err)
-	err = n2.DecodeFromBytes(buf1)
-	assert.Nil(err)
-
-	assert.Equal(n1, n2)
-}
-
-func Test_NotificationErrorCode(t *testing.T) {
-	// boundary check
-	t.Log(NewNotificationErrorCode(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_TYPE).String())
-	t.Log(NewNotificationErrorCode(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_TYPE+1).String())
-	t.Log(NewNotificationErrorCode(BGP_ERROR_MESSAGE_HEADER_ERROR, 0).String())
-	t.Log(NewNotificationErrorCode(0, BGP_ERROR_SUB_BAD_MESSAGE_TYPE).String())
-	t.Log(NewNotificationErrorCode(BGP_ERROR_ROUTE_REFRESH_MESSAGE_ERROR+1, 0).String())
-}
-
-func Test_FlowSpecNlriVPN(t *testing.T) {
-	assert := assert.New(t)
-	cmp := make([]FlowSpecComponentInterface, 0)
-	cmp = append(cmp, NewFlowSpecDestinationPrefix(NewIPAddrPrefix(24, "10.0.0.0")))
-	cmp = append(cmp, NewFlowSpecSourcePrefix(NewIPAddrPrefix(24, "10.0.0.0")))
-	rd, _ := ParseRouteDistinguisher("100:100")
-	n1 := NewFlowSpecIPv4VPN(rd, cmp)
-	buf1, err := n1.Serialize()
-	assert.Nil(err)
-	n2, err := NewPrefixFromRouteFamily(RouteFamilyToAfiSafi(RF_FS_IPv4_VPN))
-	assert.Nil(err)
-	err = n2.DecodeFromBytes(buf1)
-	require.NoError(t, err)
-
-	assert.Equal(n1, n2)
-}
-
-func Test_EVPNIPPrefixRoute(t *testing.T) {
-	assert := assert.New(t)
-	rd, _ := ParseRouteDistinguisher("100:100")
-	r := &EVPNIPPrefixRoute{
-		RD: rd,
-		ESI: EthernetSegmentIdentifier{
-			Type:  ESI_ARBITRARY,
-			Value: make([]byte, 9),
-		},
-		ETag:           10,
-		IPPrefixLength: 24,
-		IPPrefix:       net.IP{10, 10, 10, 0},
-		GWIPAddress:    net.IP{10, 10, 10, 10},
-		Label:          1000,
-	}
-	n1 := NewEVPNNLRI(EVPN_IP_PREFIX, r)
-	buf1, err := n1.Serialize()
-	assert.Nil(err)
-	n2, err := NewPrefixFromRouteFamily(RouteFamilyToAfiSafi(RF_EVPN))
-	assert.Nil(err)
-	err = n2.DecodeFromBytes(buf1)
-	assert.Nil(err)
-
-	assert.Equal(n1, n2)
-}
-
-func Test_CapExtendedNexthop(t *testing.T) {
-	assert := assert.New(t)
-	tuple := NewCapExtendedNexthopTuple(RF_IPv4_UC, AFI_IP6)
-	n1 := NewCapExtendedNexthop([]*CapExtendedNexthopTuple{tuple})
-	buf1, err := n1.Serialize()
-	assert.Nil(err)
-	n2, err := DecodeCapability(buf1)
-	assert.Nil(err)
-
-	assert.Equal(n1, n2)
-}
-
-func Test_AddPath(t *testing.T) {
-	assert := assert.New(t)
-	opt := &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}}
-	{
-		n1 := NewIPAddrPrefix(24, "10.10.10.0")
-		assert.Equal(n1.PathIdentifier(), uint32(0))
-		n1.SetPathLocalIdentifier(10)
-		assert.Equal(n1.PathLocalIdentifier(), uint32(10))
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := &IPAddrPrefix{}
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(10))
-	}
-	{
-		n1 := NewIPv6AddrPrefix(64, "2001::")
-		n1.SetPathIdentifier(10)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewIPv6AddrPrefix(0, "")
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(0))
-	}
-	opt = &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH, RF_IPv6_UC: BGP_ADD_PATH_BOTH}}
-	{
-		n1 := NewIPv6AddrPrefix(64, "2001::")
-		n1.SetPathLocalIdentifier(10)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewIPv6AddrPrefix(0, "")
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(10))
-	}
-	opt = &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_IPv4_VPN: BGP_ADD_PATH_BOTH, RF_IPv6_VPN: BGP_ADD_PATH_BOTH}}
-	{
-		rd, _ := ParseRouteDistinguisher("100:100")
-		labels := NewMPLSLabelStack(100, 200)
-		n1 := NewLabeledVPNIPAddrPrefix(24, "10.10.10.0", *labels, rd)
-		n1.SetPathLocalIdentifier(20)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewLabeledVPNIPAddrPrefix(0, "", MPLSLabelStack{}, nil)
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(20))
-	}
-	{
-		rd, _ := ParseRouteDistinguisher("100:100")
-		labels := NewMPLSLabelStack(100, 200)
-		n1 := NewLabeledVPNIPv6AddrPrefix(64, "2001::", *labels, rd)
-		n1.SetPathLocalIdentifier(20)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewLabeledVPNIPAddrPrefix(0, "", MPLSLabelStack{}, nil)
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(20))
-	}
-	opt = &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_IPv4_MPLS: BGP_ADD_PATH_BOTH, RF_IPv6_MPLS: BGP_ADD_PATH_BOTH}}
-	{
-		labels := NewMPLSLabelStack(100, 200)
-		n1 := NewLabeledIPAddrPrefix(24, "10.10.10.0", *labels)
-		n1.SetPathLocalIdentifier(20)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewLabeledIPAddrPrefix(0, "", MPLSLabelStack{})
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(20))
-	}
-	{
-		labels := NewMPLSLabelStack(100, 200)
-		n1 := NewLabeledIPv6AddrPrefix(64, "2001::", *labels)
-		n1.SetPathLocalIdentifier(20)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewLabeledIPAddrPrefix(0, "", MPLSLabelStack{})
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(20))
-	}
-	opt = &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_RTC_UC: BGP_ADD_PATH_BOTH}}
-	{
-		rt, _ := ParseRouteTarget("100:100")
-		n1 := NewRouteTargetMembershipNLRI(65000, rt)
-		n1.SetPathLocalIdentifier(30)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewRouteTargetMembershipNLRI(0, nil)
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(30))
-	}
-	opt = &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_EVPN: BGP_ADD_PATH_BOTH}}
-	{
-		n1 := NewEVPNNLRI(EVPN_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY,
-			&EVPNEthernetAutoDiscoveryRoute{NewRouteDistinguisherFourOctetAS(5, 6),
-				EthernetSegmentIdentifier{ESI_ARBITRARY, make([]byte, 9)}, 2, 2})
-		n1.SetPathLocalIdentifier(40)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewEVPNNLRI(0, nil)
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(40))
-	}
-	opt = &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_IPv4_ENCAP: BGP_ADD_PATH_BOTH}}
-	{
-		n1 := NewEncapNLRI("10.10.10.0")
-		n1.SetPathLocalIdentifier(50)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewEncapNLRI("")
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(50))
-	}
-	opt = &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_FS_IPv4_UC: BGP_ADD_PATH_BOTH}}
-	{
-		n1 := NewFlowSpecIPv4Unicast([]FlowSpecComponentInterface{NewFlowSpecDestinationPrefix(NewIPAddrPrefix(24, "10.0.0.0"))})
-		n1.SetPathLocalIdentifier(60)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := NewFlowSpecIPv4Unicast(nil)
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(60))
-	}
-	opt = &MarshallingOption{AddPath: map[RouteFamily]BGPAddPathMode{RF_OPAQUE: BGP_ADD_PATH_BOTH}}
-	{
-		n1 := NewOpaqueNLRI([]byte("key"), []byte("value"))
-		n1.SetPathLocalIdentifier(70)
-		bits, err := n1.Serialize(opt)
-		assert.Nil(err)
-		n2 := &OpaqueNLRI{}
-		err = n2.DecodeFromBytes(bits, opt)
-		assert.Nil(err)
-		assert.Equal(n2.PathIdentifier(), uint32(70))
-	}
-
-}
-
-func Test_CompareFlowSpecNLRI(t *testing.T) {
-	assert := assert.New(t)
-	cmp, err := ParseFlowSpecComponents(RF_FS_IPv4_UC, "destination 10.0.0.2/32 source 10.0.0.1/32 destination-port ==3128 protocol tcp")
-	assert.Nil(err)
-	// Note: Use NewFlowSpecIPv4Unicast() for the consistent ordered rules.
-	n1 := NewFlowSpecIPv4Unicast(cmp).FlowSpecNLRI
-	cmp, err = ParseFlowSpecComponents(RF_FS_IPv4_UC, "source 10.0.0.0/24 destination-port ==3128 protocol tcp")
-	assert.Nil(err)
-	n2 := NewFlowSpecIPv4Unicast(cmp).FlowSpecNLRI
-	r, err := CompareFlowSpecNLRI(&n1, &n2)
-	assert.Nil(err)
-	assert.True(r > 0)
-	cmp, err = ParseFlowSpecComponents(RF_FS_IPv4_UC, "source 10.0.0.9/32 port ==80 ==8080 destination-port >8080&<8080 ==3128 source-port >1024 protocol ==udp ==tcp")
-	n3 := NewFlowSpecIPv4Unicast(cmp).FlowSpecNLRI
-	assert.Nil(err)
-	cmp, err = ParseFlowSpecComponents(RF_FS_IPv4_UC, "destination 192.168.0.2/32")
-	n4 := NewFlowSpecIPv4Unicast(cmp).FlowSpecNLRI
-	assert.Nil(err)
-	r, err = CompareFlowSpecNLRI(&n3, &n4)
-	assert.Nil(err)
-	assert.True(r < 0)
-}
-
-func Test_MpReachNLRIWithIPv4MappedIPv6Prefix(t *testing.T) {
-	assert := assert.New(t)
-	n1 := NewIPv6AddrPrefix(120, "::ffff:10.0.0.0")
-	buf1, err := n1.Serialize()
-	assert.Nil(err)
-	n2, err := NewPrefixFromRouteFamily(RouteFamilyToAfiSafi(RF_IPv6_UC))
-	assert.Nil(err)
-	err = n2.DecodeFromBytes(buf1)
-	assert.Nil(err)
-
-	assert.Equal(n1, n2)
-
-	label := NewMPLSLabelStack(2)
-
-	n3 := NewLabeledIPv6AddrPrefix(120, "::ffff:10.0.0.0", *label)
-	buf1, err = n3.Serialize()
-	assert.Nil(err)
-	n4, err := NewPrefixFromRouteFamily(RouteFamilyToAfiSafi(RF_IPv6_MPLS))
-	assert.Nil(err)
-	err = n4.DecodeFromBytes(buf1)
-	assert.Nil(err)
-
-	assert.Equal(n3, n4)
-}
-
-func Test_MpReachNLRIWithIPv6PrefixWithIPv4Peering(t *testing.T) {
-	assert := assert.New(t)
-	bufin := []byte{
-		0x80, 0x0e, 0x1e, // flags(1), type(1), length(1)
-		0x00, 0x02, 0x01, 0x10, // afi(2), safi(1), nexthoplen(1)
-		0x00, 0x00, 0x00, 0x00, // nexthop(16)
-		0x00, 0x00, 0x00, 0x00, // = "::ffff:172.20.0.1"
-		0x00, 0x00, 0xff, 0xff,
-		0xac, 0x14, 0x00, 0x01,
-		0x00,                   // reserved(1)
-		0x40, 0x20, 0x01, 0x0d, // nlri(9)
-		0xb8, 0x00, 0x01, 0x00, // = "2001:db8:1:1::/64"
-		0x01,
-	}
-	// Test DecodeFromBytes()
-	p := &PathAttributeMpReachNLRI{}
-	err := p.DecodeFromBytes(bufin)
-	assert.Nil(err)
-	// Test decoded values
-	assert.Equal(BGPAttrFlag(0x80), p.Flags)
-	assert.Equal(BGPAttrType(0xe), p.Type)
-	assert.Equal(uint16(0x1e), p.Length)
-	assert.Equal(uint16(AFI_IP6), p.AFI)
-	assert.Equal(uint8(SAFI_UNICAST), p.SAFI)
-	assert.Equal(net.ParseIP("::ffff:172.20.0.1"), p.Nexthop)
-	assert.Equal(net.ParseIP(""), p.LinkLocalNexthop)
-	value := []AddrPrefixInterface{
-		NewIPv6AddrPrefix(64, "2001:db8:1:1::"),
-	}
-	assert.Equal(value, p.Value)
-	// Set NextHop as IPv4 address (because IPv4 peering)
-	p.Nexthop = net.ParseIP("172.20.0.1")
-	// Test Serialize()
-	bufout, err := p.Serialize()
-	assert.Nil(err)
-	// Test serialised value
-	assert.Equal(bufin, bufout)
-}
-
-func Test_MpReachNLRIWithIPv6(t *testing.T) {
-	assert := assert.New(t)
-	bufin := []byte{
-		0x90, 0x0e, 0x00, 0x1e, // flags(1), type(1), length(2),
-		0x00, 0x02, 0x01, 0x10, // afi(2), safi(1), nexthoplen(1)
-		0x20, 0x01, 0x0d, 0xb8, // nexthop(16)
-		0x00, 0x01, 0x00, 0x00, // = "2001:db8:1::1"
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01,
-		0x00,                   // reserved(1)
-		0x40, 0x20, 0x01, 0x0d, // nlri(9)
-		0xb8, 0x00, 0x53, 0x00, // = "2001:db8:53::/64"
-		0x00,
-	}
-	// Test DecodeFromBytes()
-	p := &PathAttributeMpReachNLRI{}
-	err := p.DecodeFromBytes(bufin)
-	assert.Nil(err)
-	// Test decoded values
-	assert.Equal(BGPAttrFlag(0x90), p.Flags)
-	assert.Equal(BGPAttrType(0xe), p.Type)
-	assert.Equal(uint16(0x1e), p.Length)
-	assert.Equal(uint16(AFI_IP6), p.AFI)
-	assert.Equal(uint8(SAFI_UNICAST), p.SAFI)
-	assert.Equal(net.ParseIP("2001:db8:1::1"), p.Nexthop)
-	value := []AddrPrefixInterface{
-		NewIPv6AddrPrefix(64, "2001:db8:53::"),
-	}
-	assert.Equal(value, p.Value)
-}
-
-func Test_MpUnreachNLRIWithIPv6(t *testing.T) {
-	assert := assert.New(t)
-	bufin := []byte{
-		0x90, 0x0f, 0x00, 0x0c, // flags(1), type(1), length(2),
-		0x00, 0x02, 0x01, // afi(2), safi(1),
-		0x40, 0x20, 0x01, 0x0d, // nlri(9)
-		0xb8, 0x00, 0x53, 0x00, // = "2001:db8:53::/64"
-		0x00,
-	}
-	// Test DecodeFromBytes()
-	p := &PathAttributeMpUnreachNLRI{}
-	err := p.DecodeFromBytes(bufin)
-	assert.Nil(err)
-	// Test decoded values
-	assert.Equal(BGPAttrFlag(0x90), p.Flags)
-	assert.Equal(BGPAttrType(0xf), p.Type)
-	assert.Equal(uint16(0x0c), p.Length)
-	assert.Equal(uint16(AFI_IP6), p.AFI)
-	assert.Equal(uint8(SAFI_UNICAST), p.SAFI)
-	value := []AddrPrefixInterface{
-		NewIPv6AddrPrefix(64, "2001:db8:53::"),
-	}
-	assert.Equal(value, p.Value)
-}
-
-func Test_MpReachNLRIWithIPv6PrefixWithLinkLocalNexthop(t *testing.T) {
-	assert := assert.New(t)
-	bufin := []byte{
-		0x80, 0x0e, 0x2c, // flags(1), type(1), length(1)
-		0x00, 0x02, 0x01, 0x20, // afi(2), safi(1), nexthoplen(1)
-		0x20, 0x01, 0x0d, 0xb8, // nexthop(32)
-		0x00, 0x01, 0x00, 0x00, // = "2001:db8:1::1"
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01,
-		0xfe, 0x80, 0x00, 0x00, // + "fe80::1" (link local)
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01,
-		0x00,                   // reserved(1)
-		0x30, 0x20, 0x10, 0x0a, // nlri(7)
-		0xb8, 0x00, 0x01, // = "2010:ab8:1::/48"
-	}
-	// Test DecodeFromBytes()
-	p := &PathAttributeMpReachNLRI{}
-	err := p.DecodeFromBytes(bufin)
-	assert.Nil(err)
-	// Test decoded values
-	assert.Equal(BGPAttrFlag(0x80), p.Flags)
-	assert.Equal(BGPAttrType(0xe), p.Type)
-	assert.Equal(uint16(0x2c), p.Length)
-	assert.Equal(uint16(AFI_IP6), p.AFI)
-	assert.Equal(uint8(SAFI_UNICAST), p.SAFI)
-	assert.Equal(net.ParseIP("2001:db8:1::1"), p.Nexthop)
-	assert.Equal(net.ParseIP("fe80::1"), p.LinkLocalNexthop)
-	value := []AddrPrefixInterface{
-		NewIPv6AddrPrefix(48, "2010:ab8:1::"),
-	}
-	assert.Equal(value, p.Value)
-	// Test Serialize()
-	bufout, err := p.Serialize()
-	assert.Nil(err)
-	// Test serialised value
-	assert.Equal(bufin, bufout)
-}
-
-func Test_MpReachNLRIWithVPNv4Prefix(t *testing.T) {
-	assert := assert.New(t)
-	bufin := []byte{
-		0x80, 0x0e, 0x20, // flags(1), type(1), length(1)
-		0x00, 0x01, 0x80, 0x0c, // afi(2), safi(1), nexthoplen(1)
-		0x00, 0x00, 0x00, 0x00, // nexthop(12)
-		0x00, 0x00, 0x00, 0x00, // = (rd:"0:0",) "172.20.0.1"
-		0xac, 0x14, 0x00, 0x01,
-		0x00,                   // reserved(1)
-		0x70, 0x00, 0x01, 0x01, // nlri(15)
-		0x00, 0x00, 0xfd, 0xe8, // = label:16, rd:"65000:100", prefix:"10.1.1.0/24"
-		0x00, 0x00, 0x00, 0x64,
-		0x0a, 0x01, 0x01,
-	}
-	// Test DecodeFromBytes()
-	p := &PathAttributeMpReachNLRI{}
-	err := p.DecodeFromBytes(bufin)
-	assert.Nil(err)
-	// Test decoded values
-	assert.Equal(BGPAttrFlag(0x80), p.Flags)
-	assert.Equal(BGPAttrType(0xe), p.Type)
-	assert.Equal(uint16(0x20), p.Length)
-	assert.Equal(uint16(AFI_IP), p.AFI)
-	assert.Equal(uint8(SAFI_MPLS_VPN), p.SAFI)
-	assert.Equal(net.ParseIP("172.20.0.1").To4(), p.Nexthop)
-	assert.Equal(net.ParseIP(""), p.LinkLocalNexthop)
-	value := []AddrPrefixInterface{
-		NewLabeledVPNIPAddrPrefix(24, "10.1.1.0", *NewMPLSLabelStack(16),
-			NewRouteDistinguisherTwoOctetAS(65000, 100)),
-	}
-	assert.Equal(value, p.Value)
-	// Test Serialize()
-	bufout, err := p.Serialize()
-	assert.Nil(err)
-	// Test serialised value
-	assert.Equal(bufin, bufout)
-}
-
-func Test_MpReachNLRIWithVPNv6Prefix(t *testing.T) {
-	assert := assert.New(t)
-	bufin := []byte{
-		0x80, 0x0e, 0x39, // flags(1), type(1), length(1)
-		0x00, 0x02, 0x80, 0x18, // afi(2), safi(1), nexthoplen(1)
-		0x00, 0x00, 0x00, 0x00, // nexthop(24)
-		0x00, 0x00, 0x00, 0x00, // = (rd:"0:0",) "2001:db8:1::1"
-		0x20, 0x01, 0x0d, 0xb8,
-		0x00, 0x01, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01,
-		0x00,                   // reserved(1)
-		0xd4, 0x00, 0x01, 0x01, // nlri(28)
-		0x00, 0x00, 0xfd, 0xe8, // = label:16, rd:"65000:100", prefix:"2001:1::/124"
-		0x00, 0x00, 0x00, 0x64,
-		0x20, 0x01, 0x00, 0x01,
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00,
-	}
-	// Test DecodeFromBytes()
-	p := &PathAttributeMpReachNLRI{}
-	err := p.DecodeFromBytes(bufin)
-	assert.Nil(err)
-	// Test decoded values
-	assert.Equal(BGPAttrFlag(0x80), p.Flags)
-	assert.Equal(BGPAttrType(0xe), p.Type)
-	assert.Equal(uint16(0x39), p.Length)
-	assert.Equal(uint16(AFI_IP6), p.AFI)
-	assert.Equal(uint8(SAFI_MPLS_VPN), p.SAFI)
-	assert.Equal(net.ParseIP("2001:db8:1::1"), p.Nexthop)
-	assert.Equal(net.ParseIP(""), p.LinkLocalNexthop)
-	value := []AddrPrefixInterface{
-		NewLabeledVPNIPv6AddrPrefix(124, "2001:1::", *NewMPLSLabelStack(16),
-			NewRouteDistinguisherTwoOctetAS(65000, 100)),
-	}
-	assert.Equal(value, p.Value)
-	// Test Serialize()
-	bufout, err := p.Serialize()
-	assert.Nil(err)
-	// Test serialised value
-	assert.Equal(bufin, bufout)
-}
-
-func Test_MpReachNLRIWithIPv4PrefixWithIPv6Nexthop(t *testing.T) {
-	assert := assert.New(t)
-	bufin := []byte{
-		0x80, 0x0e, 0x19, // flags(1), type(1), length(1)
-		0x00, 0x01, 0x01, 0x10, // afi(1), safi(1), nexthoplen(1)
-		0x20, 0x01, 0x0d, 0xb8, // nexthop(32)
-		0x00, 0x01, 0x00, 0x00, // = "2001:db8:1::1"
-		0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x01,
-		0x00,                   // reserved(1)
-		0x18, 0xc0, 0xa8, 0x0a, // nlri(7)
-	}
-	// Test DecodeFromBytes()
-	p := &PathAttributeMpReachNLRI{}
-	err := p.DecodeFromBytes(bufin)
-	assert.Nil(err)
-	// Test decoded values
-	assert.Equal(BGPAttrFlag(0x80), p.Flags)
-	assert.Equal(BGPAttrType(0xe), p.Type)
-	assert.Equal(uint16(0x19), p.Length)
-	assert.Equal(uint16(AFI_IP), p.AFI)
-	assert.Equal(uint8(SAFI_UNICAST), p.SAFI)
-	assert.Equal(net.ParseIP("2001:db8:1::1"), p.Nexthop)
-	value := []AddrPrefixInterface{
-		NewIPAddrPrefix(24, "192.168.10.0"),
-	}
-	assert.Equal(value, p.Value)
-	// Test Serialize()
-	bufout, err := p.Serialize()
-	assert.Nil(err)
-	// Test serialised value
-	assert.Equal(bufin, bufout)
-}
-
-func Test_ParseRouteDistinguisher(t *testing.T) {
-	assert := assert.New(t)
-
-	rd, _ := ParseRouteDistinguisher("100:1000")
-	rdType0, ok := rd.(*RouteDistinguisherTwoOctetAS)
-	if !ok {
-		t.Fatal("Type of RD interface is not RouteDistinguisherTwoOctetAS")
-	}
-
-	assert.Equal(uint16(100), rdType0.Admin)
-	assert.Equal(uint32(1000), rdType0.Assigned)
-
-	rd, _ = ParseRouteDistinguisher("10.0.0.0:100")
-	rdType1, ok := rd.(*RouteDistinguisherIPAddressAS)
-	if !ok {
-		t.Fatal("Type of RD interface is not RouteDistinguisherIPAddressAS")
-	}
-
-	assert.Equal("10.0.0.0", rdType1.Admin.String())
-	assert.Equal(uint16(100), rdType1.Assigned)
-
-	rd, _ = ParseRouteDistinguisher("100.1000:10000")
-	rdType2, ok := rd.(*RouteDistinguisherFourOctetAS)
-	if !ok {
-		t.Fatal("Type of RD interface is not RouteDistinguisherFourOctetAS")
-	}
-
-	assert.Equal(uint32((100<<16)|1000), rdType2.Admin)
-	assert.Equal(uint16(10000), rdType2.Assigned)
-}
-
-func Test_ParseEthernetSegmentIdentifier(t *testing.T) {
-	assert := assert.New(t)
-
-	// "single-homed"
-	esiZero := EthernetSegmentIdentifier{}
-	args := make([]string, 0)
-	esi, err := ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(esiZero, esi)
-	args = []string{"single-homed"}
-	esi, err = ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(esiZero, esi)
-
-	// ESI_ARBITRARY
-	args = []string{"ARBITRARY", "11:22:33:44:55:66:77:88:99"} // omit "ESI_"
-	esi, err = ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(EthernetSegmentIdentifier{
-		Type:  ESI_ARBITRARY,
-		Value: []byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99},
-	}, esi)
-
-	// ESI_LACP
-	args = []string{"lacp", "aa:bb:cc:dd:ee:ff", strconv.FormatInt(0x1122, 10)} // lower case
-	esi, err = ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(EthernetSegmentIdentifier{
-		Type:  ESI_LACP,
-		Value: []byte{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x00},
-	}, esi)
-
-	// ESI_MSTP
-	args = []string{"esi_mstp", "aa:bb:cc:dd:ee:ff", strconv.FormatInt(0x1122, 10)} // omit "ESI_" + lower case
-	esi, err = ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(EthernetSegmentIdentifier{
-		Type:  ESI_MSTP,
-		Value: []byte{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x00},
-	}, esi)
-
-	// ESI_MAC
-	args = []string{"ESI_MAC", "aa:bb:cc:dd:ee:ff", strconv.FormatInt(0x112233, 10)}
-	esi, err = ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(EthernetSegmentIdentifier{
-		Type:  ESI_MAC,
-		Value: []byte{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x11, 0x22, 0x33},
-	}, esi)
-
-	// ESI_ROUTERID
-	args = []string{"ESI_ROUTERID", "1.1.1.1", strconv.FormatInt(0x11223344, 10)}
-	esi, err = ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(EthernetSegmentIdentifier{
-		Type:  ESI_ROUTERID,
-		Value: []byte{0x01, 0x01, 0x01, 0x01, 0x11, 0x22, 0x33, 0x44, 0x00},
-	}, esi)
-
-	// ESI_AS
-	args = []string{"ESI_AS", strconv.FormatInt(0xaabbccdd, 10), strconv.FormatInt(0x11223344, 10)}
-	esi, err = ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(EthernetSegmentIdentifier{
-		Type:  ESI_AS,
-		Value: []byte{0xaa, 0xbb, 0xcc, 0xdd, 0x11, 0x22, 0x33, 0x44, 0x00},
-	}, esi)
-
-	// Other
-	args = []string{"99", "11:22:33:44:55:66:77:88:99"}
-	esi, err = ParseEthernetSegmentIdentifier(args)
-	assert.Nil(err)
-	assert.Equal(EthernetSegmentIdentifier{
-		Type:  ESIType(99),
-		Value: []byte{0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99},
-	}, esi)
-}
-
-func TestParseBogusShortData(t *testing.T) {
-	var bodies = []BGPBody{
-		&BGPOpen{},
-		&BGPUpdate{},
-		&BGPNotification{},
-		&BGPKeepAlive{},
-		&BGPRouteRefresh{},
-	}
-
-	for _, b := range bodies {
-		b.DecodeFromBytes([]byte{0})
-	}
-}
-
-func TestFuzzCrashers(t *testing.T) {
-	var crashers = []string{
-		"000000000000000000\x01",
-	}
-
-	for _, f := range crashers {
-		ParseBGPMessage([]byte(f))
-	}
-}
-
-func TestNormalizeFlowSpecOpValues(t *testing.T) {
-	tests := []struct {
-		msg  string
-		args []string
-		want []string
-	}{
-		{
-			msg:  "valid match",
-			args: []string{"  &  <=80", " tcp  != udp ", " =!   SA   & =U!  F", " =  is-fragment+last-fragment"},
-			want: []string{"<=80", "tcp", "!=udp", "=!SA", "&=U", "!F", "=is-fragment+last-fragment"},
-		},
-		{
-			msg:  "RFC5575 trims & prefix",
-			args: []string{"&<=80"},
-			want: []string{"<=80"},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.msg, func(t *testing.T) {
-			got := normalizeFlowSpecOpValues(tt.args)
-			assert.Equal(t, tt.want, got)
-		})
-	}
-}
diff --git a/packet/bgp/bgpattrtype_string.go b/packet/bgp/bgpattrtype_string.go
deleted file mode 100644
index 1a2cf1d0..00000000
--- a/packet/bgp/bgpattrtype_string.go
+++ /dev/null
@@ -1,28 +0,0 @@
-// generated by stringer -type BGPAttrType bgp.go; DO NOT EDIT
-
-package bgp
-
-import "fmt"
-
-const (
-	_BGPAttrType_name_0 = "BGP_ATTR_TYPE_ORIGINBGP_ATTR_TYPE_AS_PATHBGP_ATTR_TYPE_NEXT_HOPBGP_ATTR_TYPE_MULTI_EXIT_DISCBGP_ATTR_TYPE_LOCAL_PREFBGP_ATTR_TYPE_ATOMIC_AGGREGATEBGP_ATTR_TYPE_AGGREGATORBGP_ATTR_TYPE_COMMUNITIESBGP_ATTR_TYPE_ORIGINATOR_IDBGP_ATTR_TYPE_CLUSTER_LIST"
-	_BGPAttrType_name_1 = "BGP_ATTR_TYPE_MP_REACH_NLRIBGP_ATTR_TYPE_MP_UNREACH_NLRIBGP_ATTR_TYPE_EXTENDED_COMMUNITIESBGP_ATTR_TYPE_AS4_PATHBGP_ATTR_TYPE_AS4_AGGREGATOR"
-)
-
-var (
-	_BGPAttrType_index_0 = [...]uint8{0, 20, 41, 63, 92, 116, 146, 170, 195, 222, 248}
-	_BGPAttrType_index_1 = [...]uint8{0, 27, 56, 90, 112, 140}
-)
-
-func (i BGPAttrType) String() string {
-	switch {
-	case 1 <= i && i <= 10:
-		i -= 1
-		return _BGPAttrType_name_0[_BGPAttrType_index_0[i]:_BGPAttrType_index_0[i+1]]
-	case 14 <= i && i <= 18:
-		i -= 14
-		return _BGPAttrType_name_1[_BGPAttrType_index_1[i]:_BGPAttrType_index_1[i+1]]
-	default:
-		return fmt.Sprintf("BGPAttrType(%d)", i)
-	}
-}
diff --git a/packet/bgp/constant.go b/packet/bgp/constant.go
deleted file mode 100644
index 5ea7b414..00000000
--- a/packet/bgp/constant.go
+++ /dev/null
@@ -1,327 +0,0 @@
-// 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 (
-	"fmt"
-	"strings"
-)
-
-const AS_TRANS = 23456
-
-const BGP_PORT = 179
-
-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 fmt.Sprintf("%d", 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)
-	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 fmt.Sprintf("%d", t)
-}
diff --git a/packet/bgp/esitype_string.go b/packet/bgp/esitype_string.go
deleted file mode 100644
index 5651bda8..00000000
--- a/packet/bgp/esitype_string.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// generated by stringer -type=ESIType bgp.go validate.go; DO NOT EDIT
-
-package bgp
-
-import "fmt"
-
-const _ESIType_name = "ESI_ARBITRARYESI_LACPESI_MSTPESI_MACESI_ROUTERIDESI_AS"
-
-var _ESIType_index = [...]uint8{0, 13, 21, 29, 36, 48, 54}
-
-func (i ESIType) String() string {
-	if i+1 >= ESIType(len(_ESIType_index)) {
-		return fmt.Sprintf("ESIType(%d)", i)
-	}
-	return _ESIType_name[_ESIType_index[i]:_ESIType_index[i+1]]
-}
diff --git a/packet/bgp/fsmstate_string.go b/packet/bgp/fsmstate_string.go
deleted file mode 100644
index 4416afc1..00000000
--- a/packet/bgp/fsmstate_string.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// generated by stringer -type=FSMState -output=fsmstate_string.go bgp.go validate.go mrt.go rtr.go constant.go bmp.go esitype_string.go bgpattrtype_string.go; DO NOT EDIT
-
-package bgp
-
-import "fmt"
-
-const _FSMState_name = "BGP_FSM_IDLEBGP_FSM_CONNECTBGP_FSM_ACTIVEBGP_FSM_OPENSENTBGP_FSM_OPENCONFIRMBGP_FSM_ESTABLISHED"
-
-var _FSMState_index = [...]uint8{0, 12, 27, 41, 57, 76, 95}
-
-func (i FSMState) String() string {
-	if i < 0 || i >= FSMState(len(_FSMState_index)-1) {
-		return fmt.Sprintf("FSMState(%d)", i)
-	}
-	return _FSMState_name[_FSMState_index[i]:_FSMState_index[i+1]]
-}
diff --git a/packet/bgp/helper.go b/packet/bgp/helper.go
deleted file mode 100644
index 34648b2d..00000000
--- a/packet/bgp/helper.go
+++ /dev/null
@@ -1,126 +0,0 @@
-// Copyright (C) 2016 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
-
-func NewTestBGPOpenMessage() *BGPMessage {
-	p1 := NewOptionParameterCapability(
-		[]ParameterCapabilityInterface{NewCapRouteRefresh()})
-	p2 := NewOptionParameterCapability(
-		[]ParameterCapabilityInterface{NewCapMultiProtocol(RF_IPv4_UC)})
-	g := &CapGracefulRestartTuple{4, 2, 3}
-	p3 := NewOptionParameterCapability(
-		[]ParameterCapabilityInterface{NewCapGracefulRestart(false, true, 100,
-			[]*CapGracefulRestartTuple{g})})
-	p4 := NewOptionParameterCapability(
-		[]ParameterCapabilityInterface{NewCapFourOctetASNumber(100000)})
-	p5 := NewOptionParameterCapability(
-		[]ParameterCapabilityInterface{NewCapAddPath([]*CapAddPathTuple{NewCapAddPathTuple(RF_IPv4_UC, BGP_ADD_PATH_BOTH)})})
-	return NewBGPOpenMessage(11033, 303, "100.4.10.3",
-		[]OptionParameterInterface{p1, p2, p3, p4, p5})
-}
-
-func NewTestBGPUpdateMessage() *BGPMessage {
-	w1 := NewIPAddrPrefix(23, "121.1.3.2")
-	w2 := NewIPAddrPrefix(17, "100.33.3.0")
-	w := []*IPAddrPrefix{w1, w2}
-
-	aspath1 := []AsPathParamInterface{
-		NewAsPathParam(2, []uint16{1000}),
-		NewAsPathParam(1, []uint16{1001, 1002}),
-		NewAsPathParam(2, []uint16{1003, 1004}),
-	}
-
-	aspath2 := []AsPathParamInterface{
-		NewAs4PathParam(2, []uint32{1000000}),
-		NewAs4PathParam(1, []uint32{1000001, 1002}),
-		NewAs4PathParam(2, []uint32{1003, 100004}),
-	}
-
-	aspath3 := []*As4PathParam{
-		NewAs4PathParam(2, []uint32{1000000}),
-		NewAs4PathParam(1, []uint32{1000001, 1002}),
-		NewAs4PathParam(2, []uint32{1003, 100004}),
-	}
-
-	isTransitive := true
-
-	ecommunities := []ExtendedCommunityInterface{
-		NewTwoOctetAsSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, 10003, 3<<20, isTransitive),
-		NewFourOctetAsSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, 1<<20, 300, isTransitive),
-		NewIPv4AddressSpecificExtended(EC_SUBTYPE_ROUTE_TARGET, "192.2.1.2", 3000, isTransitive),
-		NewOpaqueExtended(false, []byte{1, 2, 3, 4, 5, 6, 7}),
-		NewValidationExtended(VALIDATION_STATE_INVALID),
-		NewUnknownExtended(99, []byte{0, 1, 2, 3, 4, 5, 6, 7}),
-		NewESILabelExtended(1000, true),
-		NewESImportRouteTarget("11:22:33:44:55:66"),
-		NewMacMobilityExtended(123, false),
-	}
-
-	prefixes1 := []AddrPrefixInterface{
-		NewLabeledVPNIPAddrPrefix(24, "192.0.9.0", *NewMPLSLabelStack(1, 2, 3),
-			NewRouteDistinguisherTwoOctetAS(256, 10000)),
-		NewLabeledVPNIPAddrPrefix(24, "192.10.8.0", *NewMPLSLabelStack(5, 6, 7, 8),
-			NewRouteDistinguisherIPAddressAS("10.0.1.1", 10001)),
-	}
-
-	prefixes2 := []AddrPrefixInterface{NewIPv6AddrPrefix(128,
-		"fe80:1234:1234:5667:8967:af12:8912:1023")}
-
-	prefixes3 := []AddrPrefixInterface{NewLabeledVPNIPv6AddrPrefix(128,
-		"fe80:1234:1234:5667:8967:af12:1203:33a1", *NewMPLSLabelStack(5, 6),
-		NewRouteDistinguisherFourOctetAS(5, 6))}
-
-	prefixes4 := []AddrPrefixInterface{NewLabeledIPAddrPrefix(25, "192.168.0.0",
-		*NewMPLSLabelStack(5, 6, 7))}
-
-	prefixes5 := []AddrPrefixInterface{
-		NewEVPNEthernetAutoDiscoveryRoute(NewRouteDistinguisherFourOctetAS(5, 6), EthernetSegmentIdentifier{ESI_ARBITRARY, make([]byte, 9)}, 2, 2),
-		NewEVPNMacIPAdvertisementRoute(NewRouteDistinguisherFourOctetAS(5, 6), EthernetSegmentIdentifier{ESI_ARBITRARY, make([]byte, 9)}, 3, "01:23:45:67:89:ab", "192.2.1.2", []uint32{3, 4}),
-		NewEVPNMulticastEthernetTagRoute(NewRouteDistinguisherFourOctetAS(5, 6), 3, "192.2.1.2"),
-		NewEVPNEthernetSegmentRoute(NewRouteDistinguisherFourOctetAS(5, 6), EthernetSegmentIdentifier{ESI_ARBITRARY, make([]byte, 9)}, "192.2.1.1"),
-		NewEVPNIPPrefixRoute(NewRouteDistinguisherFourOctetAS(5, 6), EthernetSegmentIdentifier{ESI_ARBITRARY, make([]byte, 9)}, 5, 24, "192.2.1.0", "192.3.1.1", 5),
-	}
-
-	p := []PathAttributeInterface{
-		NewPathAttributeOrigin(3),
-		NewPathAttributeAsPath(aspath1),
-		NewPathAttributeAsPath(aspath2),
-		NewPathAttributeNextHop("129.1.1.2"),
-		NewPathAttributeMultiExitDisc(1 << 20),
-		NewPathAttributeLocalPref(1 << 22),
-		NewPathAttributeAtomicAggregate(),
-		NewPathAttributeAggregator(uint16(30002), "129.0.2.99"),
-		NewPathAttributeAggregator(uint32(30002), "129.0.2.99"),
-		NewPathAttributeAggregator(uint32(300020), "129.0.2.99"),
-		NewPathAttributeCommunities([]uint32{1, 3}),
-		NewPathAttributeOriginatorId("10.10.0.1"),
-		NewPathAttributeClusterList([]string{"10.10.0.2", "10.10.0.3"}),
-		NewPathAttributeExtendedCommunities(ecommunities),
-		NewPathAttributeAs4Path(aspath3),
-		NewPathAttributeAs4Aggregator(10000, "112.22.2.1"),
-		NewPathAttributeMpReachNLRI("112.22.2.0", prefixes1),
-		NewPathAttributeMpReachNLRI("1023::", prefixes2),
-		NewPathAttributeMpReachNLRI("fe80::", prefixes3),
-		NewPathAttributeMpReachNLRI("129.1.1.1", prefixes4),
-		NewPathAttributeMpReachNLRI("129.1.1.1", prefixes5),
-		NewPathAttributeMpUnreachNLRI(prefixes1),
-		//NewPathAttributeMpReachNLRI("112.22.2.0", []AddrPrefixInterface{}),
-		//NewPathAttributeMpUnreachNLRI([]AddrPrefixInterface{}),
-		NewPathAttributeUnknown(BGP_ATTR_FLAG_TRANSITIVE, 100, []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}),
-	}
-	n := []*IPAddrPrefix{NewIPAddrPrefix(24, "13.2.3.1")}
-	return NewBGPUpdateMessage(w, p, n)
-}
diff --git a/packet/bgp/validate.go b/packet/bgp/validate.go
deleted file mode 100644
index 60cf26e4..00000000
--- a/packet/bgp/validate.go
+++ /dev/null
@@ -1,337 +0,0 @@
-package bgp
-
-import (
-	"encoding/binary"
-	"fmt"
-	"math"
-	"net"
-	"strconv"
-)
-
-// Validator for BGPUpdate
-func ValidateUpdateMsg(m *BGPUpdate, rfs map[RouteFamily]BGPAddPathMode, isEBGP bool, isConfed bool) (bool, error) {
-	var strongestError error
-
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCodeAttrList := uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST)
-	eSubCodeMissing := uint8(BGP_ERROR_SUB_MISSING_WELL_KNOWN_ATTRIBUTE)
-
-	if len(m.NLRI) > 0 || len(m.WithdrawnRoutes) > 0 {
-		if _, ok := rfs[RF_IPv4_UC]; !ok {
-			return false, NewMessageError(0, 0, nil, fmt.Sprintf("Address-family rf %d not available for session", RF_IPv4_UC))
-		}
-	}
-
-	seen := make(map[BGPAttrType]PathAttributeInterface)
-	newAttrs := make([]PathAttributeInterface, 0, len(seen))
-	// check path attribute
-	for _, a := range m.PathAttributes {
-		// check duplication
-		if _, ok := seen[a.GetType()]; !ok {
-			seen[a.GetType()] = a
-			newAttrs = append(newAttrs, a)
-			//check specific path attribute
-			ok, err := ValidateAttribute(a, rfs, isEBGP, isConfed)
-			if !ok {
-				if err.(*MessageError).ErrorHandling == ERROR_HANDLING_SESSION_RESET {
-					return false, err
-				} else if err.(*MessageError).Stronger(strongestError) {
-					strongestError = err
-				}
-			}
-		} else if a.GetType() == BGP_ATTR_TYPE_MP_REACH_NLRI || a.GetType() == BGP_ATTR_TYPE_MP_UNREACH_NLRI {
-			eMsg := "the path attribute apears twice. Type : " + strconv.Itoa(int(a.GetType()))
-			return false, NewMessageError(eCode, eSubCodeAttrList, nil, eMsg)
-		} else {
-			eMsg := "the path attribute apears twice. Type : " + strconv.Itoa(int(a.GetType()))
-			e := NewMessageErrorWithErrorHandling(eCode, eSubCodeAttrList, nil, ERROR_HANDLING_ATTRIBUTE_DISCARD, nil, eMsg)
-			if e.(*MessageError).Stronger(strongestError) {
-				strongestError = e
-			}
-		}
-	}
-	m.PathAttributes = newAttrs
-
-	if _, ok := seen[BGP_ATTR_TYPE_MP_REACH_NLRI]; ok || len(m.NLRI) > 0 {
-		// check the existence of well-known mandatory attributes
-		exist := func(attrs []BGPAttrType) (bool, BGPAttrType) {
-			for _, attr := range attrs {
-				_, ok := seen[attr]
-				if !ok {
-					return false, attr
-				}
-			}
-			return true, 0
-		}
-		mandatory := []BGPAttrType{BGP_ATTR_TYPE_ORIGIN, BGP_ATTR_TYPE_AS_PATH}
-		if len(m.NLRI) > 0 {
-			mandatory = append(mandatory, BGP_ATTR_TYPE_NEXT_HOP)
-		}
-		if ok, t := exist(mandatory); !ok {
-			eMsg := "well-known mandatory attributes are not present. type : " + strconv.Itoa(int(t))
-			data := []byte{byte(t)}
-			e := NewMessageErrorWithErrorHandling(eCode, eSubCodeMissing, data, ERROR_HANDLING_TREAT_AS_WITHDRAW, nil, eMsg)
-			if e.(*MessageError).Stronger(strongestError) {
-				strongestError = e
-			}
-		}
-	}
-
-	return strongestError == nil, strongestError
-}
-
-func ValidateAttribute(a PathAttributeInterface, rfs map[RouteFamily]BGPAddPathMode, isEBGP bool, isConfed bool) (bool, error) {
-	var strongestError error
-
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCodeBadOrigin := uint8(BGP_ERROR_SUB_INVALID_ORIGIN_ATTRIBUTE)
-	eSubCodeBadNextHop := uint8(BGP_ERROR_SUB_INVALID_NEXT_HOP_ATTRIBUTE)
-	eSubCodeUnknown := uint8(BGP_ERROR_SUB_UNRECOGNIZED_WELL_KNOWN_ATTRIBUTE)
-	eSubCodeMalformedAspath := uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH)
-
-	checkPrefix := func(l []AddrPrefixInterface) error {
-		for _, prefix := range l {
-			rf := AfiSafiToRouteFamily(prefix.AFI(), prefix.SAFI())
-			if _, ok := rfs[rf]; !ok {
-				return NewMessageError(0, 0, nil, fmt.Sprintf("Address-family %s not available for this session", rf))
-			}
-			switch rf {
-			case RF_FS_IPv4_UC, RF_FS_IPv6_UC, RF_FS_IPv4_VPN, RF_FS_IPv6_VPN, RF_FS_L2_VPN:
-				t := BGPFlowSpecType(0)
-				value := make([]FlowSpecComponentInterface, 0)
-				switch rf {
-				case RF_FS_IPv4_UC:
-					value = prefix.(*FlowSpecIPv4Unicast).Value
-				case RF_FS_IPv6_UC:
-					value = prefix.(*FlowSpecIPv6Unicast).Value
-				case RF_FS_IPv4_VPN:
-					value = prefix.(*FlowSpecIPv4VPN).Value
-				case RF_FS_IPv6_VPN:
-					value = prefix.(*FlowSpecIPv6VPN).Value
-				case RF_FS_L2_VPN:
-					value = prefix.(*FlowSpecL2VPN).Value
-				}
-				for _, v := range value {
-					if v.Type() <= t {
-						return NewMessageError(0, 0, nil, fmt.Sprintf("%s nlri violate strict type ordering", rf))
-					}
-					t = v.Type()
-				}
-			}
-		}
-		return nil
-	}
-
-	switch p := a.(type) {
-	case *PathAttributeMpUnreachNLRI:
-		rf := AfiSafiToRouteFamily(p.AFI, p.SAFI)
-		if _, ok := rfs[rf]; !ok {
-			return false, NewMessageError(0, 0, nil, fmt.Sprintf("Address-family rf %d not available for session", rf))
-		}
-		if err := checkPrefix(p.Value); err != nil {
-			return false, err
-		}
-	case *PathAttributeMpReachNLRI:
-		rf := AfiSafiToRouteFamily(p.AFI, p.SAFI)
-		if _, ok := rfs[rf]; !ok {
-			return false, NewMessageError(0, 0, nil, fmt.Sprintf("Address-family rf %d not available for session", rf))
-		}
-		if err := checkPrefix(p.Value); err != nil {
-			return false, err
-		}
-	case *PathAttributeOrigin:
-		v := uint8(p.Value)
-		if v != BGP_ORIGIN_ATTR_TYPE_IGP &&
-			v != BGP_ORIGIN_ATTR_TYPE_EGP &&
-			v != BGP_ORIGIN_ATTR_TYPE_INCOMPLETE {
-			data, _ := a.Serialize()
-			eMsg := "invalid origin attribute. value : " + strconv.Itoa(int(v))
-			e := NewMessageErrorWithErrorHandling(eCode, eSubCodeBadOrigin, data, getErrorHandlingFromPathAttribute(p.GetType()), nil, eMsg)
-			if e.(*MessageError).Stronger(strongestError) {
-				strongestError = e
-			}
-		}
-	case *PathAttributeNextHop:
-
-		isZero := func(ip net.IP) bool {
-			res := ip[0] & 0xff
-			return res == 0x00
-		}
-
-		isClassDorE := func(ip net.IP) bool {
-			res := ip[0] & 0xe0
-			return res == 0xe0
-		}
-
-		//check IP address represents host address
-		if p.Value.IsLoopback() || isZero(p.Value) || isClassDorE(p.Value) {
-			eMsg := "invalid nexthop address"
-			data, _ := a.Serialize()
-			e := NewMessageErrorWithErrorHandling(eCode, eSubCodeBadNextHop, data, getErrorHandlingFromPathAttribute(p.GetType()), nil, eMsg)
-			if e.(*MessageError).Stronger(strongestError) {
-				strongestError = e
-			}
-		}
-	case *PathAttributeAsPath:
-		if isEBGP {
-			if isConfed {
-				if segType := p.Value[0].GetType(); segType != BGP_ASPATH_ATTR_TYPE_CONFED_SEQ {
-					return false, NewMessageError(eCode, eSubCodeMalformedAspath, nil, fmt.Sprintf("segment type is not confederation seq (%d)", segType))
-				}
-			} else {
-				for _, param := range p.Value {
-					segType := param.GetType()
-					switch segType {
-					case BGP_ASPATH_ATTR_TYPE_CONFED_SET, BGP_ASPATH_ATTR_TYPE_CONFED_SEQ:
-						err := NewMessageErrorWithErrorHandling(
-							eCode, eSubCodeMalformedAspath, nil, getErrorHandlingFromPathAttribute(p.GetType()), nil, fmt.Sprintf("segment type confederation(%d) found", segType))
-						if err.(*MessageError).Stronger(strongestError) {
-							strongestError = err
-						}
-					}
-				}
-			}
-		}
-	case *PathAttributeLargeCommunities:
-		uniq := make([]*LargeCommunity, 0, len(p.Values))
-		for _, x := range p.Values {
-			found := false
-			for _, y := range uniq {
-				if x.String() == y.String() {
-					found = true
-					break
-				}
-			}
-			if !found {
-				uniq = append(uniq, x)
-			}
-		}
-		p.Values = uniq
-
-	case *PathAttributeUnknown:
-		if p.GetFlags()&BGP_ATTR_FLAG_OPTIONAL == 0 {
-			eMsg := fmt.Sprintf("unrecognized well-known attribute %s", p.GetType())
-			data, _ := a.Serialize()
-			return false, NewMessageError(eCode, eSubCodeUnknown, data, eMsg)
-		}
-	}
-
-	return strongestError == nil, strongestError
-}
-
-// validator for PathAttribute
-func validatePathAttributeFlags(t BGPAttrType, flags BGPAttrFlag) string {
-
-	/*
-	 * RFC 4271 P.17 For well-known attributes, the Transitive bit MUST be set to 1.
-	 */
-	if flags&BGP_ATTR_FLAG_OPTIONAL == 0 && flags&BGP_ATTR_FLAG_TRANSITIVE == 0 {
-		eMsg := fmt.Sprintf("well-known attribute %s must have transitive flag 1", t)
-		return eMsg
-	}
-	/*
-	 * RFC 4271 P.17 For well-known attributes and for optional non-transitive attributes,
-	 * the Partial bit MUST be set to 0.
-	 */
-	if flags&BGP_ATTR_FLAG_OPTIONAL == 0 && flags&BGP_ATTR_FLAG_PARTIAL != 0 {
-		eMsg := fmt.Sprintf("well-known attribute %s must have partial bit 0", t)
-		return eMsg
-	}
-	if flags&BGP_ATTR_FLAG_OPTIONAL != 0 && flags&BGP_ATTR_FLAG_TRANSITIVE == 0 && flags&BGP_ATTR_FLAG_PARTIAL != 0 {
-		eMsg := fmt.Sprintf("optional non-transitive attribute %s must have partial bit 0", t)
-		return eMsg
-	}
-
-	// check flags are correct
-	if f, ok := PathAttrFlags[t]; ok {
-		if f != flags & ^BGP_ATTR_FLAG_EXTENDED_LENGTH & ^BGP_ATTR_FLAG_PARTIAL {
-			eMsg := fmt.Sprintf("flags are invalid. attribute type: %s, expect: %s, actual: %s", t, f, flags)
-			return eMsg
-		}
-	}
-	return ""
-}
-
-func validateAsPathValueBytes(data []byte) (bool, error) {
-	eCode := uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR)
-	eSubCode := uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH)
-	if len(data)%2 != 0 {
-		return false, NewMessageError(eCode, eSubCode, nil, "AS PATH length is not odd")
-	}
-
-	tryParse := func(data []byte, use4byte bool) (bool, error) {
-		for len(data) > 0 {
-			if len(data) < 2 {
-				return false, NewMessageError(eCode, eSubCode, nil, "AS PATH header is short")
-			}
-			segType := data[0]
-			if segType == 0 || segType > 4 {
-				return false, NewMessageError(eCode, eSubCode, nil, "unknown AS_PATH seg type")
-			}
-			asNum := data[1]
-			data = data[2:]
-			if asNum == 0 || int(asNum) > math.MaxUint8 {
-				return false, NewMessageError(eCode, eSubCode, nil, "AS PATH the number of AS is incorrect")
-			}
-			segLength := int(asNum)
-			if use4byte {
-				segLength *= 4
-			} else {
-				segLength *= 2
-			}
-			if int(segLength) > len(data) {
-				return false, NewMessageError(eCode, eSubCode, nil, "seg length is short")
-			}
-			data = data[segLength:]
-		}
-		return true, nil
-	}
-	_, err := tryParse(data, true)
-	if err == nil {
-		return true, nil
-	}
-
-	_, err = tryParse(data, false)
-	if err == nil {
-		return false, nil
-	}
-	return false, NewMessageError(eCode, eSubCode, nil, "can't parse AS_PATH")
-}
-
-func ValidateBGPMessage(m *BGPMessage) error {
-	if m.Header.Len > BGP_MAX_MESSAGE_LENGTH {
-		buf := make([]byte, 2)
-		binary.BigEndian.PutUint16(buf, m.Header.Len)
-		return NewMessageError(BGP_ERROR_MESSAGE_HEADER_ERROR, BGP_ERROR_SUB_BAD_MESSAGE_LENGTH, buf, "too long length")
-	}
-
-	return nil
-}
-
-func ValidateOpenMsg(m *BGPOpen, expectedAS uint32) (uint32, error) {
-	if m.Version != 4 {
-		return 0, NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNSUPPORTED_VERSION_NUMBER, nil, fmt.Sprintf("unsupported version %d", m.Version))
-	}
-
-	as := uint32(m.MyAS)
-	for _, p := range m.OptParams {
-		paramCap, y := p.(*OptionParameterCapability)
-		if !y {
-			continue
-		}
-		for _, c := range paramCap.Capability {
-			if c.Code() == BGP_CAP_FOUR_OCTET_AS_NUMBER {
-				cap := c.(*CapFourOctetASNumber)
-				as = cap.CapValue
-			}
-		}
-	}
-	if expectedAS != 0 && as != expectedAS {
-		return 0, NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_BAD_PEER_AS, nil, fmt.Sprintf("as number mismatch expected %d, received %d", expectedAS, as))
-	}
-
-	if m.HoldTime < 3 && m.HoldTime != 0 {
-		return 0, NewMessageError(BGP_ERROR_OPEN_MESSAGE_ERROR, BGP_ERROR_SUB_UNACCEPTABLE_HOLD_TIME, nil, fmt.Sprintf("unacceptable hold time %d", m.HoldTime))
-	}
-	return as, nil
-}
diff --git a/packet/bgp/validate_test.go b/packet/bgp/validate_test.go
deleted file mode 100644
index 8bdec550..00000000
--- a/packet/bgp/validate_test.go
+++ /dev/null
@@ -1,423 +0,0 @@
-package bgp
-
-import (
-	"encoding/binary"
-	"net"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func bgpupdate() *BGPMessage {
-	aspath := []AsPathParamInterface{
-		NewAsPathParam(2, []uint16{65001}),
-	}
-
-	p := []PathAttributeInterface{
-		NewPathAttributeOrigin(1),
-		NewPathAttributeAsPath(aspath),
-		NewPathAttributeNextHop("192.168.1.1"),
-	}
-
-	n := []*IPAddrPrefix{NewIPAddrPrefix(24, "10.10.10.0")}
-	return NewBGPUpdateMessage(nil, p, n)
-}
-
-func bgpupdateV6() *BGPMessage {
-	aspath := []AsPathParamInterface{
-		NewAsPathParam(2, []uint16{65001}),
-	}
-
-	prefixes := []AddrPrefixInterface{NewIPv6AddrPrefix(100,
-		"fe80:1234:1234:5667:8967:af12:8912:1023")}
-
-	p := []PathAttributeInterface{
-		NewPathAttributeOrigin(1),
-		NewPathAttributeAsPath(aspath),
-		NewPathAttributeMpReachNLRI("1023::", prefixes),
-	}
-	return NewBGPUpdateMessage(nil, p, nil)
-}
-
-func Test_Validate_CapV4(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv6_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-
-	res, err = ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	require.NoError(t, err)
-	assert.Equal(true, res)
-}
-
-func Test_Validate_CapV6(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdateV6().Body.(*BGPUpdate)
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv6_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.NoError(err)
-	assert.True(res)
-
-	res, err = ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Error(err)
-	assert.False(res)
-}
-
-func Test_Validate_OK(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(true, res)
-	assert.NoError(err)
-
-}
-
-// func Test_Validate_wellknown_but_nontransitive(t *testing.T) {
-// 	assert := assert.New(t)
-// 	message := bgpupdate().Body.(*BGPUpdate)
-
-// 	originBytes := []byte{0, 1, 1, 1} // 0 means Flags
-// 	origin := &PathAttributeOrigin{}
-// 	origin.DecodeFromBytes(originBytes)
-// 	message.PathAttributes[0] = origin
-
-// 	res, err := ValidateUpdateMsg(message, []RouteFamily{RF_IPv4_UC,})
-// 	assert.Equal(false, res)
-// 	assert.Error(err)
-// 	e := err.(*MessageError)
-// 	assert.Equal(BGP_ERROR_UPDATE_MESSAGE_ERROR, e.TypeCode)
-// 	assert.Equal(BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR, e.SubTypeCode)
-// 	assert.Equal(originBytes, e.Data)
-// }
-
-// func Test_Validate_wellknown_but_partial(t *testing.T) {
-// 	assert := assert.New(t)
-// 	message := bgpupdate().Body.(*BGPUpdate)
-
-// 	originBytes := []byte{BGP_ATTR_FLAG_PARTIAL, 1, 1, 1}
-// 	origin := &PathAttributeOrigin{}
-// 	origin.DecodeFromBytes(originBytes)
-// 	message.PathAttributes[0] = origin
-
-// 	res, err := ValidateUpdateMsg(message, []RouteFamily{RF_IPv4_UC,})
-// 	assert.Equal(false, res)
-// 	assert.Error(err)
-// 	e := err.(*MessageError)
-// 	assert.Equal(BGP_ERROR_UPDATE_MESSAGE_ERROR, e.TypeCode)
-// 	assert.Equal(BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR, e.SubTypeCode)
-// 	assert.Equal(originBytes, e.Data)
-// }
-
-// func Test_Validate_optional_nontransitive_but_partial(t *testing.T) {
-// 	assert := assert.New(t)
-// 	message := bgpupdate().Body.(*BGPUpdate)
-// 	f := BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_PARTIAL
-// 	originBytes := []byte{byte(f), 1, 1, 1}
-// 	origin := &PathAttributeOrigin{}
-// 	origin.DecodeFromBytes(originBytes)
-// 	message.PathAttributes[0] = origin
-
-// 	res, err := ValidateUpdateMsg(message, []RouteFamily{RF_IPv4_UC,})
-// 	assert.Equal(false, res)
-// 	assert.Error(err)
-// 	e := err.(*MessageError)
-// 	assert.Equal(BGP_ERROR_UPDATE_MESSAGE_ERROR, e.TypeCode)
-// 	assert.Equal(BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR, e.SubTypeCode)
-// 	assert.Equal(originBytes, e.Data)
-// }
-
-// func Test_Validate_flag_mismatch(t *testing.T) {
-// 	assert := assert.New(t)
-// 	message := bgpupdate().Body.(*BGPUpdate)
-// 	f := BGP_ATTR_FLAG_OPTIONAL
-// 	// origin needs to be well-known
-// 	originBytes := []byte{byte(f), 1, 1, 1}
-// 	origin := &PathAttributeOrigin{}
-// 	origin.DecodeFromBytes(originBytes)
-// 	message.PathAttributes[0] = origin
-
-// 	res, err := ValidateUpdateMsg(message, []RouteFamily{RF_IPv4_UC,})
-// 	assert.Equal(false, res)
-// 	assert.Error(err)
-// 	e := err.(*MessageError)
-// 	assert.Equal(BGP_ERROR_UPDATE_MESSAGE_ERROR, e.TypeCode)
-// 	assert.Equal(BGP_ERROR_SUB_ATTRIBUTE_FLAGS_ERROR, e.SubTypeCode)
-// 	assert.Equal(originBytes, e.Data)
-// }
-
-func Test_Validate_duplicate_attribute(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-	// duplicate origin path attribute
-	originBytes := []byte{byte(PathAttrFlags[BGP_ATTR_TYPE_ORIGIN]), 1, 1, 1}
-	origin := &PathAttributeOrigin{}
-	origin.DecodeFromBytes(originBytes)
-	message.PathAttributes = append(message.PathAttributes, origin)
-
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e := err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_MALFORMED_ATTRIBUTE_LIST), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_ATTRIBUTE_DISCARD, e.ErrorHandling)
-	assert.Nil(e.Data)
-}
-
-func Test_Validate_mandatory_missing(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-	message.PathAttributes = message.PathAttributes[1:]
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e := err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_MISSING_WELL_KNOWN_ATTRIBUTE), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, e.ErrorHandling)
-	missing, _ := binary.Uvarint(e.Data)
-	assert.Equal(uint64(1), missing)
-}
-
-func Test_Validate_mandatory_missing_nocheck(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-	message.PathAttributes = message.PathAttributes[1:]
-	message.NLRI = nil
-
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(true, res)
-	assert.NoError(err)
-}
-
-func Test_Validate_invalid_origin(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-	// origin needs to be well-known
-	originBytes := []byte{byte(PathAttrFlags[BGP_ATTR_TYPE_ORIGIN]), 1, 1, 5}
-	origin := &PathAttributeOrigin{}
-	origin.DecodeFromBytes(originBytes)
-	message.PathAttributes[0] = origin
-
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e := err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_INVALID_ORIGIN_ATTRIBUTE), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, e.ErrorHandling)
-	assert.Equal(originBytes, e.Data)
-}
-
-func Test_Validate_invalid_nexthop_zero(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-
-	// invalid nexthop
-	addr := net.ParseIP("0.0.0.1").To4()
-	nexthopBytes := []byte{byte(PathAttrFlags[BGP_ATTR_TYPE_NEXT_HOP]), 3, 4}
-	nexthopBytes = append(nexthopBytes, addr...)
-	nexthop := &PathAttributeNextHop{}
-	nexthop.DecodeFromBytes(nexthopBytes)
-	message.PathAttributes[2] = nexthop
-
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e := err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_INVALID_NEXT_HOP_ATTRIBUTE), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, e.ErrorHandling)
-	assert.Equal(nexthopBytes, e.Data)
-}
-
-func Test_Validate_invalid_nexthop_lo(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-
-	// invalid nexthop
-	addr := net.ParseIP("127.0.0.1").To4()
-	nexthopBytes := []byte{byte(PathAttrFlags[BGP_ATTR_TYPE_NEXT_HOP]), 3, 4}
-	nexthopBytes = append(nexthopBytes, addr...)
-	nexthop := &PathAttributeNextHop{}
-	nexthop.DecodeFromBytes(nexthopBytes)
-	message.PathAttributes[2] = nexthop
-
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e := err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_INVALID_NEXT_HOP_ATTRIBUTE), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, e.ErrorHandling)
-	assert.Equal(nexthopBytes, e.Data)
-}
-
-func Test_Validate_invalid_nexthop_de(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-
-	// invalid nexthop
-	addr := net.ParseIP("224.0.0.1").To4()
-	nexthopBytes := []byte{byte(PathAttrFlags[BGP_ATTR_TYPE_NEXT_HOP]), 3, 4}
-	nexthopBytes = append(nexthopBytes, addr...)
-	nexthop := &PathAttributeNextHop{}
-	nexthop.DecodeFromBytes(nexthopBytes)
-	message.PathAttributes[2] = nexthop
-
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e := err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_INVALID_NEXT_HOP_ATTRIBUTE), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, e.ErrorHandling)
-	assert.Equal(nexthopBytes, e.Data)
-
-}
-
-func Test_Validate_unrecognized_well_known(t *testing.T) {
-
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-	f := BGP_ATTR_FLAG_TRANSITIVE
-	unknownBytes := []byte{byte(f), 30, 1, 1}
-	unknown := &PathAttributeUnknown{}
-	unknown.DecodeFromBytes(unknownBytes)
-	message.PathAttributes = append(message.PathAttributes, unknown)
-
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, false, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e := err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_UNRECOGNIZED_WELL_KNOWN_ATTRIBUTE), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_SESSION_RESET, e.ErrorHandling)
-	assert.Equal(unknownBytes, e.Data)
-}
-
-func Test_Validate_aspath(t *testing.T) {
-	assert := assert.New(t)
-	message := bgpupdate().Body.(*BGPUpdate)
-
-	// VALID AS_PATH
-	res, err := ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, true, false)
-	require.NoError(t, err)
-	assert.Equal(true, res)
-
-	// CONFED_SET
-	newAttrs := make([]PathAttributeInterface, 0)
-	attrs := message.PathAttributes
-	for _, attr := range attrs {
-		if _, y := attr.(*PathAttributeAsPath); y {
-			aspath := []AsPathParamInterface{
-				NewAsPathParam(BGP_ASPATH_ATTR_TYPE_CONFED_SET, []uint16{65001}),
-			}
-			newAttrs = append(newAttrs, NewPathAttributeAsPath(aspath))
-		} else {
-			newAttrs = append(newAttrs, attr)
-		}
-	}
-
-	message.PathAttributes = newAttrs
-	res, err = ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, true, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e := err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, e.ErrorHandling)
-	assert.Nil(e.Data)
-
-	res, err = ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, true, true)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e = err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH), e.SubTypeCode)
-	assert.Nil(e.Data)
-
-	// CONFED_SEQ
-	newAttrs = make([]PathAttributeInterface, 0)
-	attrs = message.PathAttributes
-	for _, attr := range attrs {
-		if _, y := attr.(*PathAttributeAsPath); y {
-			aspath := []AsPathParamInterface{
-				NewAsPathParam(BGP_ASPATH_ATTR_TYPE_CONFED_SEQ, []uint16{65001}),
-			}
-			newAttrs = append(newAttrs, NewPathAttributeAsPath(aspath))
-		} else {
-			newAttrs = append(newAttrs, attr)
-		}
-	}
-
-	message.PathAttributes = newAttrs
-	res, err = ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, true, false)
-	assert.Equal(false, res)
-	assert.Error(err)
-	e = err.(*MessageError)
-	assert.Equal(uint8(BGP_ERROR_UPDATE_MESSAGE_ERROR), e.TypeCode)
-	assert.Equal(uint8(BGP_ERROR_SUB_MALFORMED_AS_PATH), e.SubTypeCode)
-	assert.Equal(ERROR_HANDLING_TREAT_AS_WITHDRAW, e.ErrorHandling)
-	assert.Nil(e.Data)
-
-	res, err = ValidateUpdateMsg(message, map[RouteFamily]BGPAddPathMode{RF_IPv4_UC: BGP_ADD_PATH_BOTH}, true, true)
-	require.NoError(t, err)
-	assert.Equal(true, res)
-}
-
-func Test_Validate_flowspec(t *testing.T) {
-	assert := assert.New(t)
-	cmp := make([]FlowSpecComponentInterface, 0)
-	cmp = append(cmp, NewFlowSpecDestinationPrefix(NewIPAddrPrefix(24, "10.0.0.0")))
-	cmp = append(cmp, NewFlowSpecSourcePrefix(NewIPAddrPrefix(24, "10.0.0.0")))
-	item1 := NewFlowSpecComponentItem(DEC_NUM_OP_EQ, TCP)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_IP_PROTO, []*FlowSpecComponentItem{item1}))
-	item2 := NewFlowSpecComponentItem(DEC_NUM_OP_GT_EQ, 20)
-	item3 := NewFlowSpecComponentItem(DEC_NUM_OP_AND|DEC_NUM_OP_LT_EQ, 30)
-	item4 := NewFlowSpecComponentItem(DEC_NUM_OP_EQ, 10)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_DST_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_SRC_PORT, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_ICMP_TYPE, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_ICMP_CODE, []*FlowSpecComponentItem{item2, item3, item4}))
-	item5 := NewFlowSpecComponentItem(0, TCP_FLAG_ACK)
-	item6 := NewFlowSpecComponentItem(BITMASK_FLAG_OP_AND|BITMASK_FLAG_OP_NOT, TCP_FLAG_URGENT)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_TCP_FLAG, []*FlowSpecComponentItem{item5, item6}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_PKT_LEN, []*FlowSpecComponentItem{item2, item3, item4}))
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_DSCP, []*FlowSpecComponentItem{item2, item3, item4}))
-	isFragment := uint64(0x02)
-	item7 := NewFlowSpecComponentItem(BITMASK_FLAG_OP_MATCH, isFragment)
-	cmp = append(cmp, NewFlowSpecComponent(FLOW_SPEC_TYPE_FRAGMENT, []*FlowSpecComponentItem{item7}))
-	n1 := NewFlowSpecIPv4Unicast(cmp)
-	a := NewPathAttributeMpReachNLRI("", []AddrPrefixInterface{n1})
-	m := map[RouteFamily]BGPAddPathMode{RF_FS_IPv4_UC: BGP_ADD_PATH_NONE}
-	_, err := ValidateAttribute(a, m, false, false)
-	assert.Nil(err)
-
-	cmp = make([]FlowSpecComponentInterface, 0)
-	cmp = append(cmp, NewFlowSpecSourcePrefix(NewIPAddrPrefix(24, "10.0.0.0")))
-	cmp = append(cmp, NewFlowSpecDestinationPrefix(NewIPAddrPrefix(24, "10.0.0.0")))
-	n1 = NewFlowSpecIPv4Unicast(cmp)
-	a = NewPathAttributeMpReachNLRI("", []AddrPrefixInterface{n1})
-	// Swaps components order to reproduce the rules order violation.
-	n1.Value[0], n1.Value[1] = n1.Value[1], n1.Value[0]
-	_, err = ValidateAttribute(a, m, false, false)
-	assert.NotNil(err)
-}
-
-func TestValidateLargeCommunities(t *testing.T) {
-	assert := assert.New(t)
-	c1, err := ParseLargeCommunity("10:10:10")
-	assert.Nil(err)
-	c2, err := ParseLargeCommunity("10:10:10")
-	assert.Nil(err)
-	c3, err := ParseLargeCommunity("10:10:20")
-	assert.Nil(err)
-	a := NewPathAttributeLargeCommunities([]*LargeCommunity{c1, c2, c3})
-	assert.True(len(a.Values) == 3)
-	_, err = ValidateAttribute(a, nil, false, false)
-	assert.Nil(err)
-	assert.True(len(a.Values) == 2)
-}
diff --git a/packet/bmp/bmp.go b/packet/bmp/bmp.go
deleted file mode 100644
index eb2ce185..00000000
--- a/packet/bmp/bmp.go
+++ /dev/null
@@ -1,1071 +0,0 @@
-// Copyright (C) 2014,2015 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 bmp
-
-import (
-	"encoding/binary"
-	"fmt"
-	"github.com/osrg/gobgp/packet/bgp"
-	"math"
-	"net"
-)
-
-type BMPHeader struct {
-	Version uint8
-	Length  uint32
-	Type    uint8
-}
-
-const (
-	BMP_VERSION          = 3
-	BMP_HEADER_SIZE      = 6
-	BMP_PEER_HEADER_SIZE = 42
-)
-
-const (
-	BMP_DEFAULT_PORT = 11019
-)
-
-const (
-	BMP_PEER_TYPE_GLOBAL uint8 = iota
-	BMP_PEER_TYPE_L3VPN
-	BMP_PEER_TYPE_LOCAL
-	BMP_PEER_TYPE_LOCAL_RIB
-)
-
-const (
-	BMP_PEER_FLAG_IPV6        = 1 << 7
-	BMP_PEER_FLAG_POST_POLICY = 1 << 6
-	BMP_PEER_FLAG_TWO_AS      = 1 << 5
-	BMP_PEER_FLAG_FILTERED    = 1 << 6
-)
-
-func (h *BMPHeader) DecodeFromBytes(data []byte) error {
-	h.Version = data[0]
-	if data[0] != BMP_VERSION {
-		return fmt.Errorf("error version")
-	}
-	h.Length = binary.BigEndian.Uint32(data[1:5])
-	h.Type = data[5]
-	return nil
-}
-
-func (h *BMPHeader) Serialize() ([]byte, error) {
-	buf := make([]byte, BMP_HEADER_SIZE)
-	buf[0] = h.Version
-	binary.BigEndian.PutUint32(buf[1:], h.Length)
-	buf[5] = h.Type
-	return buf, nil
-}
-
-type BMPPeerHeader struct {
-	PeerType          uint8
-	Flags             uint8
-	PeerDistinguisher uint64
-	PeerAddress       net.IP
-	PeerAS            uint32
-	PeerBGPID         net.IP
-	Timestamp         float64
-}
-
-func NewBMPPeerHeader(t uint8, flags uint8, dist uint64, address string, as uint32, id string, stamp float64) *BMPPeerHeader {
-	h := &BMPPeerHeader{
-		PeerType:          t,
-		Flags:             flags,
-		PeerDistinguisher: dist,
-		PeerAS:            as,
-		PeerBGPID:         net.ParseIP(id).To4(),
-		Timestamp:         stamp,
-	}
-	if net.ParseIP(address).To4() != nil {
-		h.PeerAddress = net.ParseIP(address).To4()
-	} else {
-		h.PeerAddress = net.ParseIP(address).To16()
-		h.Flags |= BMP_PEER_FLAG_IPV6
-	}
-	return h
-}
-
-func (h *BMPPeerHeader) IsPostPolicy() bool {
-	if h.Flags&BMP_PEER_FLAG_POST_POLICY != 0 {
-		return true
-	} else {
-		return false
-	}
-}
-
-func (h *BMPPeerHeader) DecodeFromBytes(data []byte) error {
-	h.PeerType = data[0]
-	h.Flags = data[1]
-	h.PeerDistinguisher = binary.BigEndian.Uint64(data[2:10])
-	if h.Flags&BMP_PEER_FLAG_IPV6 != 0 {
-		h.PeerAddress = net.IP(data[10:26]).To16()
-	} else {
-		h.PeerAddress = net.IP(data[22:26]).To4()
-	}
-	h.PeerAS = binary.BigEndian.Uint32(data[26:30])
-	h.PeerBGPID = data[30:34]
-
-	timestamp1 := binary.BigEndian.Uint32(data[34:38])
-	timestamp2 := binary.BigEndian.Uint32(data[38:42])
-	h.Timestamp = float64(timestamp1) + float64(timestamp2)*math.Pow10(-6)
-	return nil
-}
-
-func (h *BMPPeerHeader) Serialize() ([]byte, error) {
-	buf := make([]byte, BMP_PEER_HEADER_SIZE)
-	buf[0] = h.PeerType
-	buf[1] = h.Flags
-	binary.BigEndian.PutUint64(buf[2:10], h.PeerDistinguisher)
-	if h.Flags&BMP_PEER_FLAG_IPV6 != 0 {
-		copy(buf[10:26], h.PeerAddress)
-	} else {
-		copy(buf[22:26], h.PeerAddress.To4())
-	}
-	binary.BigEndian.PutUint32(buf[26:30], h.PeerAS)
-	copy(buf[30:34], h.PeerBGPID)
-	t1, t2 := math.Modf(h.Timestamp)
-	t2 = math.Ceil(t2 * math.Pow10(6))
-	binary.BigEndian.PutUint32(buf[34:38], uint32(t1))
-	binary.BigEndian.PutUint32(buf[38:42], uint32(t2))
-	return buf, nil
-}
-
-type BMPRouteMonitoring struct {
-	BGPUpdate        *bgp.BGPMessage
-	BGPUpdatePayload []byte
-}
-
-func NewBMPRouteMonitoring(p BMPPeerHeader, update *bgp.BGPMessage) *BMPMessage {
-	return &BMPMessage{
-		Header: BMPHeader{
-			Version: BMP_VERSION,
-			Type:    BMP_MSG_ROUTE_MONITORING,
-		},
-		PeerHeader: p,
-		Body: &BMPRouteMonitoring{
-			BGPUpdate: update,
-		},
-	}
-}
-
-func (body *BMPRouteMonitoring) ParseBody(msg *BMPMessage, data []byte) error {
-	update, err := bgp.ParseBGPMessage(data)
-	if err != nil {
-		return err
-	}
-	body.BGPUpdate = update
-	return nil
-}
-
-func (body *BMPRouteMonitoring) Serialize() ([]byte, error) {
-	if body.BGPUpdatePayload != nil {
-		return body.BGPUpdatePayload, nil
-	}
-	return body.BGPUpdate.Serialize()
-}
-
-const (
-	BMP_STAT_TYPE_REJECTED = iota
-	BMP_STAT_TYPE_DUPLICATE_PREFIX
-	BMP_STAT_TYPE_DUPLICATE_WITHDRAW
-	BMP_STAT_TYPE_INV_UPDATE_DUE_TO_CLUSTER_LIST_LOOP
-	BMP_STAT_TYPE_INV_UPDATE_DUE_TO_AS_PATH_LOOP
-	BMP_STAT_TYPE_INV_UPDATE_DUE_TO_ORIGINATOR_ID
-	BMP_STAT_TYPE_INV_UPDATE_DUE_TO_AS_CONFED_LOOP
-	BMP_STAT_TYPE_ADJ_RIB_IN
-	BMP_STAT_TYPE_LOC_RIB
-	BMP_STAT_TYPE_PER_AFI_SAFI_ADJ_RIB_IN
-	BMP_STAT_TYPE_PER_AFI_SAFI_LOC_RIB
-	BMP_STAT_TYPE_WITHDRAW_UPDATE
-	BMP_STAT_TYPE_WITHDRAW_PREFIX
-	BMP_STAT_TYPE_DUPLICATE_UPDATE
-)
-
-type BMPStatsTLVInterface interface {
-	ParseValue([]byte) error
-	Serialize() ([]byte, error)
-}
-
-type BMPStatsTLV struct {
-	Type   uint16
-	Length uint16
-}
-
-type BMPStatsTLV32 struct {
-	BMPStatsTLV
-	Value uint32
-}
-
-func NewBMPStatsTLV32(t uint16, v uint32) *BMPStatsTLV32 {
-	return &BMPStatsTLV32{
-		BMPStatsTLV: BMPStatsTLV{
-			Type:   t,
-			Length: 4,
-		},
-		Value: v,
-	}
-}
-
-func (s *BMPStatsTLV32) ParseValue(data []byte) error {
-	if s.Length != 4 {
-		return fmt.Errorf("invalid length: %d bytes (%d bytes expected)", s.Length, 4)
-	}
-	s.Value = binary.BigEndian.Uint32(data[:8])
-	return nil
-}
-
-func (s *BMPStatsTLV32) Serialize() ([]byte, error) {
-	buf := make([]byte, 8)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], 4)
-	binary.BigEndian.PutUint32(buf[4:8], s.Value)
-	return buf, nil
-}
-
-type BMPStatsTLV64 struct {
-	BMPStatsTLV
-	Value uint64
-}
-
-func NewBMPStatsTLV64(t uint16, v uint64) *BMPStatsTLV64 {
-	return &BMPStatsTLV64{
-		BMPStatsTLV: BMPStatsTLV{
-			Type:   t,
-			Length: 8,
-		},
-		Value: v,
-	}
-}
-
-func (s *BMPStatsTLV64) ParseValue(data []byte) error {
-	if s.Length != 8 {
-		return fmt.Errorf("invalid length: %d bytes (%d bytes expected)", s.Length, 8)
-	}
-	s.Value = binary.BigEndian.Uint64(data[:8])
-	return nil
-}
-
-func (s *BMPStatsTLV64) Serialize() ([]byte, error) {
-	buf := make([]byte, 12)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], 8)
-	binary.BigEndian.PutUint64(buf[4:12], s.Value)
-	return buf, nil
-}
-
-type BMPStatsTLVPerAfiSafi64 struct {
-	BMPStatsTLV
-	AFI   uint16
-	SAFI  uint8
-	Value uint64
-}
-
-func NewBMPStatsTLVPerAfiSafi64(t uint16, afi uint16, safi uint8, v uint64) *BMPStatsTLVPerAfiSafi64 {
-	return &BMPStatsTLVPerAfiSafi64{
-		BMPStatsTLV: BMPStatsTLV{
-			Type:   t,
-			Length: 11,
-		},
-		AFI:   afi,
-		SAFI:  safi,
-		Value: v,
-	}
-}
-
-func (s *BMPStatsTLVPerAfiSafi64) ParseValue(data []byte) error {
-	if s.Length != 11 {
-		return fmt.Errorf("invalid length: %d bytes (%d bytes expected)", s.Length, 11)
-	}
-	s.AFI = binary.BigEndian.Uint16(data[0:2])
-	s.SAFI = data[2]
-	s.Value = binary.BigEndian.Uint64(data[3:11])
-	return nil
-}
-
-func (s *BMPStatsTLVPerAfiSafi64) Serialize() ([]byte, error) {
-	buf := make([]byte, 15)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], 11)
-	binary.BigEndian.PutUint16(buf[4:6], s.AFI)
-	buf[6] = s.SAFI
-	binary.BigEndian.PutUint64(buf[7:15], s.Value)
-	return buf, nil
-}
-
-type BMPStatisticsReport struct {
-	Count uint32
-	Stats []BMPStatsTLVInterface
-}
-
-func NewBMPStatisticsReport(p BMPPeerHeader, stats []BMPStatsTLVInterface) *BMPMessage {
-	return &BMPMessage{
-		Header: BMPHeader{
-			Version: BMP_VERSION,
-			Type:    BMP_MSG_STATISTICS_REPORT,
-		},
-		PeerHeader: p,
-		Body: &BMPStatisticsReport{
-			Count: uint32(len(stats)),
-			Stats: stats,
-		},
-	}
-}
-
-func (body *BMPStatisticsReport) ParseBody(msg *BMPMessage, data []byte) error {
-	body.Count = binary.BigEndian.Uint32(data[0:4])
-	data = data[4:]
-	for len(data) >= 4 {
-		tl := BMPStatsTLV{
-			Type:   binary.BigEndian.Uint16(data[0:2]),
-			Length: binary.BigEndian.Uint16(data[2:4]),
-		}
-		data = data[4:]
-		if len(data) < int(tl.Length) {
-			return fmt.Errorf("value length is not enough: %d bytes (%d bytes expected)", len(data), tl.Length)
-		}
-		var s BMPStatsTLVInterface
-		switch tl.Type {
-		case BMP_STAT_TYPE_ADJ_RIB_IN, BMP_STAT_TYPE_LOC_RIB:
-			s = &BMPStatsTLV64{BMPStatsTLV: tl}
-		case BMP_STAT_TYPE_PER_AFI_SAFI_ADJ_RIB_IN, BMP_STAT_TYPE_PER_AFI_SAFI_LOC_RIB:
-			s = &BMPStatsTLVPerAfiSafi64{BMPStatsTLV: tl}
-		default:
-			s = &BMPStatsTLV32{BMPStatsTLV: tl}
-		}
-		if err := s.ParseValue(data); err != nil {
-			return err
-		}
-		body.Stats = append(body.Stats, s)
-		data = data[tl.Length:]
-	}
-	return nil
-}
-
-func (body *BMPStatisticsReport) Serialize() ([]byte, error) {
-	buf := make([]byte, 4)
-	body.Count = uint32(len(body.Stats))
-	binary.BigEndian.PutUint32(buf[0:4], body.Count)
-	for _, tlv := range body.Stats {
-		tlvBuf, err := tlv.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, tlvBuf...)
-	}
-	return buf, nil
-}
-
-const (
-	BMP_PEER_DOWN_REASON_UNKNOWN = iota
-	BMP_PEER_DOWN_REASON_LOCAL_BGP_NOTIFICATION
-	BMP_PEER_DOWN_REASON_LOCAL_NO_NOTIFICATION
-	BMP_PEER_DOWN_REASON_REMOTE_BGP_NOTIFICATION
-	BMP_PEER_DOWN_REASON_REMOTE_NO_NOTIFICATION
-	BMP_PEER_DOWN_REASON_PEER_DE_CONFIGURED
-)
-
-type BMPPeerDownNotification struct {
-	Reason          uint8
-	BGPNotification *bgp.BGPMessage
-	Data            []byte
-}
-
-func NewBMPPeerDownNotification(p BMPPeerHeader, reason uint8, notification *bgp.BGPMessage, data []byte) *BMPMessage {
-	b := &BMPPeerDownNotification{
-		Reason: reason,
-	}
-	switch reason {
-	case BMP_PEER_DOWN_REASON_LOCAL_BGP_NOTIFICATION, BMP_PEER_DOWN_REASON_REMOTE_BGP_NOTIFICATION:
-		b.BGPNotification = notification
-	case BMP_PEER_DOWN_REASON_LOCAL_NO_NOTIFICATION:
-		b.Data = data
-	default:
-	}
-	return &BMPMessage{
-		Header: BMPHeader{
-			Version: BMP_VERSION,
-			Type:    BMP_MSG_PEER_DOWN_NOTIFICATION,
-		},
-		PeerHeader: p,
-		Body:       b,
-	}
-}
-
-func (body *BMPPeerDownNotification) ParseBody(msg *BMPMessage, data []byte) error {
-	body.Reason = data[0]
-	data = data[1:]
-	if body.Reason == BMP_PEER_DOWN_REASON_LOCAL_BGP_NOTIFICATION || body.Reason == BMP_PEER_DOWN_REASON_REMOTE_BGP_NOTIFICATION {
-		notification, err := bgp.ParseBGPMessage(data)
-		if err != nil {
-			return err
-		}
-		body.BGPNotification = notification
-	} else {
-		body.Data = data
-	}
-	return nil
-}
-
-func (body *BMPPeerDownNotification) Serialize() ([]byte, error) {
-	buf := make([]byte, 1)
-	buf[0] = body.Reason
-	switch body.Reason {
-	case BMP_PEER_DOWN_REASON_LOCAL_BGP_NOTIFICATION, BMP_PEER_DOWN_REASON_REMOTE_BGP_NOTIFICATION:
-		if body.BGPNotification != nil {
-			b, err := body.BGPNotification.Serialize()
-			if err != nil {
-				return nil, err
-			} else {
-				buf = append(buf, b...)
-			}
-		}
-	default:
-		if body.Data != nil {
-			buf = append(buf, body.Data...)
-		}
-	}
-	return buf, nil
-}
-
-type BMPPeerUpNotification struct {
-	LocalAddress    net.IP
-	LocalPort       uint16
-	RemotePort      uint16
-	SentOpenMsg     *bgp.BGPMessage
-	ReceivedOpenMsg *bgp.BGPMessage
-}
-
-func NewBMPPeerUpNotification(p BMPPeerHeader, lAddr string, lPort, rPort uint16, sent, recv *bgp.BGPMessage) *BMPMessage {
-	b := &BMPPeerUpNotification{
-		LocalPort:       lPort,
-		RemotePort:      rPort,
-		SentOpenMsg:     sent,
-		ReceivedOpenMsg: recv,
-	}
-	addr := net.ParseIP(lAddr)
-	if addr.To4() != nil {
-		b.LocalAddress = addr.To4()
-	} else {
-		b.LocalAddress = addr.To16()
-	}
-	return &BMPMessage{
-		Header: BMPHeader{
-			Version: BMP_VERSION,
-			Type:    BMP_MSG_PEER_UP_NOTIFICATION,
-		},
-		PeerHeader: p,
-		Body:       b,
-	}
-}
-
-func (body *BMPPeerUpNotification) ParseBody(msg *BMPMessage, data []byte) error {
-	if msg.PeerHeader.Flags&BMP_PEER_FLAG_IPV6 != 0 {
-		body.LocalAddress = net.IP(data[:16]).To16()
-	} else {
-		body.LocalAddress = net.IP(data[12:16]).To4()
-	}
-
-	body.LocalPort = binary.BigEndian.Uint16(data[16:18])
-	body.RemotePort = binary.BigEndian.Uint16(data[18:20])
-
-	data = data[20:]
-	sentopen, err := bgp.ParseBGPMessage(data)
-	if err != nil {
-		return err
-	}
-	body.SentOpenMsg = sentopen
-	data = data[body.SentOpenMsg.Header.Len:]
-	body.ReceivedOpenMsg, err = bgp.ParseBGPMessage(data)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (body *BMPPeerUpNotification) Serialize() ([]byte, error) {
-	buf := make([]byte, 20)
-	if body.LocalAddress.To4() != nil {
-		copy(buf[12:16], body.LocalAddress.To4())
-	} else {
-		copy(buf[:16], body.LocalAddress.To16())
-	}
-
-	binary.BigEndian.PutUint16(buf[16:18], body.LocalPort)
-	binary.BigEndian.PutUint16(buf[18:20], body.RemotePort)
-
-	m, _ := body.SentOpenMsg.Serialize()
-	buf = append(buf, m...)
-	m, _ = body.ReceivedOpenMsg.Serialize()
-	buf = append(buf, m...)
-	return buf, nil
-}
-
-const (
-	BMP_INIT_TLV_TYPE_STRING = iota
-	BMP_INIT_TLV_TYPE_SYS_DESCR
-	BMP_INIT_TLV_TYPE_SYS_NAME
-)
-
-type BMPInfoTLVInterface interface {
-	ParseValue([]byte) error
-	Serialize() ([]byte, error)
-}
-
-type BMPInfoTLV struct {
-	Type   uint16
-	Length uint16
-}
-
-type BMPInfoTLVString struct {
-	BMPInfoTLV
-	Value string
-}
-
-func NewBMPInfoTLVString(t uint16, v string) *BMPInfoTLVString {
-	return &BMPInfoTLVString{
-		BMPInfoTLV: BMPInfoTLV{Type: t},
-		Value:      v,
-	}
-}
-
-func (s *BMPInfoTLVString) ParseValue(data []byte) error {
-	s.Value = string(data[:s.Length])
-	return nil
-}
-
-func (s *BMPInfoTLVString) Serialize() ([]byte, error) {
-	s.Length = uint16(len([]byte(s.Value)))
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], s.Length)
-	buf = append(buf, []byte(s.Value)...)
-	return buf, nil
-}
-
-type BMPInfoTLVUnknown struct {
-	BMPInfoTLV
-	Value []byte
-}
-
-func NewBMPInfoTLVUnknown(t uint16, v []byte) *BMPInfoTLVUnknown {
-	return &BMPInfoTLVUnknown{
-		BMPInfoTLV: BMPInfoTLV{Type: t},
-		Value:      v,
-	}
-}
-
-func (s *BMPInfoTLVUnknown) ParseValue(data []byte) error {
-	s.Value = data[:s.Length]
-	return nil
-}
-
-func (s *BMPInfoTLVUnknown) Serialize() ([]byte, error) {
-	s.Length = uint16(len([]byte(s.Value)))
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], s.Length)
-	buf = append(buf, s.Value...)
-	return buf, nil
-}
-
-type BMPInitiation struct {
-	Info []BMPInfoTLVInterface
-}
-
-func NewBMPInitiation(info []BMPInfoTLVInterface) *BMPMessage {
-	return &BMPMessage{
-		Header: BMPHeader{
-			Version: BMP_VERSION,
-			Type:    BMP_MSG_INITIATION,
-		},
-		Body: &BMPInitiation{
-			Info: info,
-		},
-	}
-}
-
-func (body *BMPInitiation) ParseBody(msg *BMPMessage, data []byte) error {
-	for len(data) >= 4 {
-		tl := BMPInfoTLV{
-			Type:   binary.BigEndian.Uint16(data[0:2]),
-			Length: binary.BigEndian.Uint16(data[2:4]),
-		}
-		data = data[4:]
-		if len(data) < int(tl.Length) {
-			return fmt.Errorf("value length is not enough: %d bytes (%d bytes expected)", len(data), tl.Length)
-		}
-		var tlv BMPInfoTLVInterface
-		switch tl.Type {
-		case BMP_INIT_TLV_TYPE_STRING, BMP_INIT_TLV_TYPE_SYS_DESCR, BMP_INIT_TLV_TYPE_SYS_NAME:
-			tlv = &BMPInfoTLVString{BMPInfoTLV: tl}
-		default:
-			tlv = &BMPInfoTLVUnknown{BMPInfoTLV: tl}
-		}
-		if err := tlv.ParseValue(data); err != nil {
-			return err
-		}
-		body.Info = append(body.Info, tlv)
-		data = data[tl.Length:]
-	}
-	return nil
-}
-
-func (body *BMPInitiation) Serialize() ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, tlv := range body.Info {
-		b, err := tlv.Serialize()
-		if err != nil {
-			return buf, err
-		}
-		buf = append(buf, b...)
-	}
-	return buf, nil
-}
-
-const (
-	BMP_TERM_TLV_TYPE_STRING = iota
-	BMP_TERM_TLV_TYPE_REASON
-)
-
-const (
-	BMP_TERM_REASON_ADMIN = iota
-	BMP_TERM_REASON_UNSPEC
-	BMP_TERM_REASON_OUT_OF_RESOURCES
-	BMP_TERM_REASON_REDUNDANT_CONNECTION
-	BMP_TERM_REASON_PERMANENTLY_ADMIN
-)
-
-type BMPTermTLVInterface interface {
-	ParseValue([]byte) error
-	Serialize() ([]byte, error)
-}
-
-type BMPTermTLV struct {
-	Type   uint16
-	Length uint16
-}
-
-type BMPTermTLVString struct {
-	BMPTermTLV
-	Value string
-}
-
-func NewBMPTermTLVString(t uint16, v string) *BMPTermTLVString {
-	return &BMPTermTLVString{
-		BMPTermTLV: BMPTermTLV{Type: t},
-		Value:      v,
-	}
-}
-
-func (s *BMPTermTLVString) ParseValue(data []byte) error {
-	s.Value = string(data[:s.Length])
-	return nil
-}
-
-func (s *BMPTermTLVString) Serialize() ([]byte, error) {
-	s.Length = uint16(len([]byte(s.Value)))
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], s.Length)
-	buf = append(buf, []byte(s.Value)...)
-	return buf, nil
-}
-
-type BMPTermTLV16 struct {
-	BMPTermTLV
-	Value uint16
-}
-
-func NewBMPTermTLV16(t uint16, v uint16) *BMPTermTLV16 {
-	return &BMPTermTLV16{
-		BMPTermTLV: BMPTermTLV{Type: t},
-		Value:      v,
-	}
-}
-
-func (s *BMPTermTLV16) ParseValue(data []byte) error {
-	s.Value = binary.BigEndian.Uint16(data[:2])
-	return nil
-}
-
-func (s *BMPTermTLV16) Serialize() ([]byte, error) {
-	s.Length = 2
-	buf := make([]byte, 6)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], s.Length)
-	binary.BigEndian.PutUint16(buf[4:6], s.Value)
-	return buf, nil
-}
-
-type BMPTermTLVUnknown struct {
-	BMPTermTLV
-	Value []byte
-}
-
-func NewBMPTermTLVUnknown(t uint16, v []byte) *BMPTermTLVUnknown {
-	return &BMPTermTLVUnknown{
-		BMPTermTLV: BMPTermTLV{Type: t},
-		Value:      v,
-	}
-}
-
-func (s *BMPTermTLVUnknown) ParseValue(data []byte) error {
-	s.Value = data[:s.Length]
-	return nil
-}
-
-func (s *BMPTermTLVUnknown) Serialize() ([]byte, error) {
-	s.Length = uint16(len([]byte(s.Value)))
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], s.Length)
-	buf = append(buf, s.Value...)
-	return buf, nil
-}
-
-type BMPTermination struct {
-	Info []BMPTermTLVInterface
-}
-
-func NewBMPTermination(info []BMPTermTLVInterface) *BMPMessage {
-	return &BMPMessage{
-		Header: BMPHeader{
-			Version: BMP_VERSION,
-			Type:    BMP_MSG_TERMINATION,
-		},
-		Body: &BMPTermination{
-			Info: info,
-		},
-	}
-}
-
-func (body *BMPTermination) ParseBody(msg *BMPMessage, data []byte) error {
-	for len(data) >= 4 {
-		tl := BMPTermTLV{
-			Type:   binary.BigEndian.Uint16(data[0:2]),
-			Length: binary.BigEndian.Uint16(data[2:4]),
-		}
-		data = data[4:]
-		if len(data) < int(tl.Length) {
-			return fmt.Errorf("value length is not enough: %d bytes (%d bytes expected)", len(data), tl.Length)
-		}
-		var tlv BMPTermTLVInterface
-		switch tl.Type {
-		case BMP_TERM_TLV_TYPE_STRING:
-			tlv = &BMPTermTLVString{BMPTermTLV: tl}
-		case BMP_TERM_TLV_TYPE_REASON:
-			tlv = &BMPTermTLV16{BMPTermTLV: tl}
-		default:
-			tlv = &BMPTermTLVUnknown{BMPTermTLV: tl}
-		}
-		if err := tlv.ParseValue(data); err != nil {
-			return err
-		}
-		body.Info = append(body.Info, tlv)
-		data = data[tl.Length:]
-	}
-	return nil
-}
-
-func (body *BMPTermination) Serialize() ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, tlv := range body.Info {
-		b, err := tlv.Serialize()
-		if err != nil {
-			return buf, err
-		}
-		buf = append(buf, b...)
-	}
-	return buf, nil
-}
-
-const (
-	BMP_ROUTE_MIRRORING_TLV_TYPE_BGP_MSG = iota
-	BMP_ROUTE_MIRRORING_TLV_TYPE_INFO
-)
-
-const (
-	BMP_ROUTE_MIRRORING_INFO_ERR_PDU = iota
-	BMP_ROUTE_MIRRORING_INFO_MSG_LOST
-)
-
-type BMPRouteMirrTLVInterface interface {
-	ParseValue([]byte) error
-	Serialize() ([]byte, error)
-}
-
-type BMPRouteMirrTLV struct {
-	Type   uint16
-	Length uint16
-}
-
-type BMPRouteMirrTLVBGPMsg struct {
-	BMPRouteMirrTLV
-	Value *bgp.BGPMessage
-}
-
-func NewBMPRouteMirrTLVBGPMsg(t uint16, v *bgp.BGPMessage) *BMPRouteMirrTLVBGPMsg {
-	return &BMPRouteMirrTLVBGPMsg{
-		BMPRouteMirrTLV: BMPRouteMirrTLV{Type: t},
-		Value:           v,
-	}
-}
-
-func (s *BMPRouteMirrTLVBGPMsg) ParseValue(data []byte) error {
-	v, err := bgp.ParseBGPMessage(data)
-	if err != nil {
-		return err
-	}
-	s.Value = v
-	return nil
-}
-
-func (s *BMPRouteMirrTLVBGPMsg) Serialize() ([]byte, error) {
-	m, err := s.Value.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	s.Length = uint16(len(m))
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], s.Length)
-	buf = append(buf, m...)
-	return buf, nil
-}
-
-type BMPRouteMirrTLV16 struct {
-	BMPRouteMirrTLV
-	Value uint16
-}
-
-func NewBMPRouteMirrTLV16(t uint16, v uint16) *BMPRouteMirrTLV16 {
-	return &BMPRouteMirrTLV16{
-		BMPRouteMirrTLV: BMPRouteMirrTLV{Type: t},
-		Value:           v,
-	}
-}
-
-func (s *BMPRouteMirrTLV16) ParseValue(data []byte) error {
-	s.Value = binary.BigEndian.Uint16(data[:2])
-	return nil
-}
-
-func (s *BMPRouteMirrTLV16) Serialize() ([]byte, error) {
-	s.Length = 2
-	buf := make([]byte, 6)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], s.Length)
-	binary.BigEndian.PutUint16(buf[4:6], s.Value)
-	return buf, nil
-}
-
-type BMPRouteMirrTLVUnknown struct {
-	BMPRouteMirrTLV
-	Value []byte
-}
-
-func NewBMPRouteMirrTLVUnknown(t uint16, v []byte) *BMPRouteMirrTLVUnknown {
-	return &BMPRouteMirrTLVUnknown{
-		BMPRouteMirrTLV: BMPRouteMirrTLV{Type: t},
-		Value:           v,
-	}
-}
-
-func (s *BMPRouteMirrTLVUnknown) ParseValue(data []byte) error {
-	s.Value = data[:s.Length]
-	return nil
-}
-
-func (s *BMPRouteMirrTLVUnknown) Serialize() ([]byte, error) {
-	s.Length = uint16(len([]byte(s.Value)))
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint16(buf[0:2], s.Type)
-	binary.BigEndian.PutUint16(buf[2:4], s.Length)
-	buf = append(buf, s.Value...)
-	return buf, nil
-}
-
-type BMPRouteMirroring struct {
-	Info []BMPRouteMirrTLVInterface
-}
-
-func NewBMPRouteMirroring(p BMPPeerHeader, info []BMPRouteMirrTLVInterface) *BMPMessage {
-	return &BMPMessage{
-		Header: BMPHeader{
-			Version: BMP_VERSION,
-			Type:    BMP_MSG_ROUTE_MIRRORING,
-		},
-		PeerHeader: p,
-		Body: &BMPRouteMirroring{
-			Info: info,
-		},
-	}
-}
-
-func (body *BMPRouteMirroring) ParseBody(msg *BMPMessage, data []byte) error {
-	for len(data) >= 4 {
-		tl := BMPRouteMirrTLV{
-			Type:   binary.BigEndian.Uint16(data[0:2]),
-			Length: binary.BigEndian.Uint16(data[2:4]),
-		}
-		data = data[4:]
-		if len(data) < int(tl.Length) {
-			return fmt.Errorf("value length is not enough: %d bytes (%d bytes expected)", len(data), tl.Length)
-		}
-		var tlv BMPRouteMirrTLVInterface
-		switch tl.Type {
-		case BMP_ROUTE_MIRRORING_TLV_TYPE_BGP_MSG:
-			tlv = &BMPRouteMirrTLVBGPMsg{BMPRouteMirrTLV: tl}
-		case BMP_ROUTE_MIRRORING_TLV_TYPE_INFO:
-			tlv = &BMPRouteMirrTLV16{BMPRouteMirrTLV: tl}
-		default:
-			tlv = &BMPRouteMirrTLVUnknown{BMPRouteMirrTLV: tl}
-		}
-		if err := tlv.ParseValue(data); err != nil {
-			return err
-		}
-		body.Info = append(body.Info, tlv)
-		data = data[tl.Length:]
-	}
-	return nil
-}
-
-func (body *BMPRouteMirroring) Serialize() ([]byte, error) {
-	buf := make([]byte, 0)
-	for _, tlv := range body.Info {
-		b, err := tlv.Serialize()
-		if err != nil {
-			return buf, err
-		}
-		buf = append(buf, b...)
-	}
-	return buf, nil
-}
-
-type BMPBody interface {
-	// Sigh, some body messages need a BMPHeader to parse the body
-	// data so we need to pass BMPHeader (avoid DecodeFromBytes
-	// function name).
-	ParseBody(*BMPMessage, []byte) error
-	Serialize() ([]byte, error)
-}
-
-type BMPMessage struct {
-	Header     BMPHeader
-	PeerHeader BMPPeerHeader
-	Body       BMPBody
-}
-
-func (msg *BMPMessage) Serialize() ([]byte, error) {
-	buf := make([]byte, 0)
-	if msg.Header.Type != BMP_MSG_INITIATION && msg.Header.Type != BMP_MSG_TERMINATION {
-		p, err := msg.PeerHeader.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, p...)
-	}
-
-	b, err := msg.Body.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, b...)
-
-	if msg.Header.Length == 0 {
-		msg.Header.Length = uint32(BMP_HEADER_SIZE + len(buf))
-	}
-
-	h, err := msg.Header.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	return append(h, buf...), nil
-}
-
-func (msg *BMPMessage) Len() int {
-	return int(msg.Header.Length)
-}
-
-const (
-	BMP_MSG_ROUTE_MONITORING = iota
-	BMP_MSG_STATISTICS_REPORT
-	BMP_MSG_PEER_DOWN_NOTIFICATION
-	BMP_MSG_PEER_UP_NOTIFICATION
-	BMP_MSG_INITIATION
-	BMP_MSG_TERMINATION
-	BMP_MSG_ROUTE_MIRRORING
-)
-
-func ParseBMPMessage(data []byte) (msg *BMPMessage, err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			err = fmt.Errorf("not all data bytes are available")
-		}
-	}()
-
-	msg = &BMPMessage{}
-	err = msg.Header.DecodeFromBytes(data)
-	if err != nil {
-		return nil, err
-	}
-	data = data[BMP_HEADER_SIZE:msg.Header.Length]
-
-	switch msg.Header.Type {
-	case BMP_MSG_ROUTE_MONITORING:
-		msg.Body = &BMPRouteMonitoring{}
-	case BMP_MSG_STATISTICS_REPORT:
-		msg.Body = &BMPStatisticsReport{}
-	case BMP_MSG_PEER_DOWN_NOTIFICATION:
-		msg.Body = &BMPPeerDownNotification{}
-	case BMP_MSG_PEER_UP_NOTIFICATION:
-		msg.Body = &BMPPeerUpNotification{}
-	case BMP_MSG_INITIATION:
-		msg.Body = &BMPInitiation{}
-	case BMP_MSG_TERMINATION:
-		msg.Body = &BMPTermination{}
-	case BMP_MSG_ROUTE_MIRRORING:
-		msg.Body = &BMPRouteMirroring{}
-	default:
-		return nil, fmt.Errorf("unsupported BMP message type: %d", msg.Header.Type)
-	}
-
-	if msg.Header.Type != BMP_MSG_INITIATION && msg.Header.Type != BMP_MSG_TERMINATION {
-		msg.PeerHeader.DecodeFromBytes(data)
-		data = data[BMP_PEER_HEADER_SIZE:]
-	}
-
-	err = msg.Body.ParseBody(msg, data)
-	if err != nil {
-		return nil, err
-	}
-	return msg, nil
-}
-
-func SplitBMP(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	if atEOF && len(data) == 0 || len(data) < BMP_HEADER_SIZE {
-		return 0, nil, nil
-	}
-
-	msg := &BMPMessage{}
-	msg.Header.DecodeFromBytes(data)
-	if uint32(len(data)) < msg.Header.Length {
-		return 0, nil, nil
-	}
-
-	return int(msg.Header.Length), data[0:msg.Header.Length], nil
-}
diff --git a/packet/bmp/bmp_test.go b/packet/bmp/bmp_test.go
deleted file mode 100644
index fde4cd0f..00000000
--- a/packet/bmp/bmp_test.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (C) 2015 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 bmp
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/osrg/gobgp/packet/bgp"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func verify(t *testing.T, m1 *BMPMessage) {
-	buf1, _ := m1.Serialize()
-	m2, err := ParseBMPMessage(buf1)
-	require.NoError(t, err)
-
-	assert.Equal(t, m1, m2)
-}
-
-func Test_Initiation(t *testing.T) {
-	verify(t, NewBMPInitiation(nil))
-	m := NewBMPInitiation([]BMPInfoTLVInterface{
-		NewBMPInfoTLVString(BMP_INIT_TLV_TYPE_STRING, "free-form UTF-8 string"),
-		NewBMPInfoTLVUnknown(0xff, []byte{0x01, 0x02, 0x03, 0x04}),
-	})
-	verify(t, m)
-}
-
-func Test_Termination(t *testing.T) {
-	verify(t, NewBMPTermination(nil))
-	m := NewBMPTermination([]BMPTermTLVInterface{
-		NewBMPTermTLVString(BMP_TERM_TLV_TYPE_STRING, "free-form UTF-8 string"),
-		NewBMPTermTLV16(BMP_TERM_TLV_TYPE_REASON, BMP_TERM_REASON_ADMIN),
-		NewBMPTermTLVUnknown(0xff, []byte{0x01, 0x02, 0x03, 0x04}),
-	})
-	verify(t, m)
-}
-
-func Test_PeerUpNotification(t *testing.T) {
-	m := bgp.NewTestBGPOpenMessage()
-	p0 := NewBMPPeerHeader(0, 0, 1000, "10.0.0.1", 70000, "10.0.0.2", 1)
-	verify(t, NewBMPPeerUpNotification(*p0, "10.0.0.3", 10, 100, m, m))
-	p1 := NewBMPPeerHeader(0, 0, 1000, "fe80::6e40:8ff:feab:2c2a", 70000, "10.0.0.2", 1)
-	verify(t, NewBMPPeerUpNotification(*p1, "fe80::6e40:8ff:feab:2c2a", 10, 100, m, m))
-}
-
-func Test_PeerDownNotification(t *testing.T) {
-	p0 := NewBMPPeerHeader(0, 0, 1000, "10.0.0.1", 70000, "10.0.0.2", 1)
-	verify(t, NewBMPPeerDownNotification(*p0, BMP_PEER_DOWN_REASON_LOCAL_NO_NOTIFICATION, nil, []byte{0x3, 0xb}))
-	m := bgp.NewBGPNotificationMessage(1, 2, nil)
-	verify(t, NewBMPPeerDownNotification(*p0, BMP_PEER_DOWN_REASON_LOCAL_BGP_NOTIFICATION, m, nil))
-}
-
-func Test_RouteMonitoring(t *testing.T) {
-	m := bgp.NewTestBGPUpdateMessage()
-	p0 := NewBMPPeerHeader(0, 0, 1000, "fe80::6e40:8ff:feab:2c2a", 70000, "10.0.0.2", 1)
-	verify(t, NewBMPRouteMonitoring(*p0, m))
-}
-
-func Test_StatisticsReport(t *testing.T) {
-	p0 := NewBMPPeerHeader(0, 0, 1000, "10.0.0.1", 70000, "10.0.0.2", 1)
-	s0 := NewBMPStatisticsReport(
-		*p0,
-		[]BMPStatsTLVInterface{
-			NewBMPStatsTLV32(BMP_STAT_TYPE_REJECTED, 100),
-			NewBMPStatsTLV64(BMP_STAT_TYPE_ADJ_RIB_IN, 200),
-			NewBMPStatsTLVPerAfiSafi64(BMP_STAT_TYPE_PER_AFI_SAFI_LOC_RIB, bgp.AFI_IP, bgp.SAFI_UNICAST, 300),
-		},
-	)
-	verify(t, s0)
-}
-
-func Test_RouteMirroring(t *testing.T) {
-	p0 := NewBMPPeerHeader(0, 0, 1000, "10.0.0.1", 70000, "10.0.0.2", 1)
-	s0 := NewBMPRouteMirroring(
-		*p0,
-		[]BMPRouteMirrTLVInterface{
-			NewBMPRouteMirrTLV16(BMP_ROUTE_MIRRORING_TLV_TYPE_INFO, BMP_ROUTE_MIRRORING_INFO_MSG_LOST),
-			NewBMPRouteMirrTLVUnknown(0xff, []byte{0x01, 0x02, 0x03, 0x04}),
-			// RFC7854: BGP Message TLV MUST occur last in the list of TLVs
-			NewBMPRouteMirrTLVBGPMsg(BMP_ROUTE_MIRRORING_TLV_TYPE_BGP_MSG, bgp.NewTestBGPOpenMessage()),
-		},
-	)
-	verify(t, s0)
-}
-
-func Test_BogusHeader(t *testing.T) {
-	h, err := ParseBMPMessage(make([]byte, 10))
-	assert.Nil(t, h)
-	assert.NotNil(t, err)
-}
diff --git a/packet/mrt/mrt.go b/packet/mrt/mrt.go
deleted file mode 100644
index 9c6fef6d..00000000
--- a/packet/mrt/mrt.go
+++ /dev/null
@@ -1,1006 +0,0 @@
-// Copyright (C) 2015 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 mrt
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"math"
-	"net"
-	"time"
-
-	"github.com/osrg/gobgp/packet/bgp"
-)
-
-const (
-	MRT_COMMON_HEADER_LEN = 12
-)
-
-type MRTType uint16
-
-const (
-	NULL         MRTType = 0  // deprecated
-	START        MRTType = 1  // deprecated
-	DIE          MRTType = 2  // deprecated
-	I_AM_DEAD    MRTType = 3  // deprecated
-	PEER_DOWN    MRTType = 4  // deprecated
-	BGP          MRTType = 5  // deprecated
-	RIP          MRTType = 6  // deprecated
-	IDRP         MRTType = 7  // deprecated
-	RIPNG        MRTType = 8  // deprecated
-	BGP4PLUS     MRTType = 9  // deprecated
-	BGP4PLUS01   MRTType = 10 // deprecated
-	OSPFv2       MRTType = 11
-	TABLE_DUMP   MRTType = 12
-	TABLE_DUMPv2 MRTType = 13
-	BGP4MP       MRTType = 16
-	BGP4MP_ET    MRTType = 17
-	ISIS         MRTType = 32
-	ISIS_ET      MRTType = 33
-	OSPFv3       MRTType = 48
-	OSPFv3_ET    MRTType = 49
-)
-
-type MRTSubTyper interface {
-	ToUint16() uint16
-}
-
-type MRTSubTypeTableDumpv2 uint16
-
-const (
-	PEER_INDEX_TABLE           MRTSubTypeTableDumpv2 = 1
-	RIB_IPV4_UNICAST           MRTSubTypeTableDumpv2 = 2
-	RIB_IPV4_MULTICAST         MRTSubTypeTableDumpv2 = 3
-	RIB_IPV6_UNICAST           MRTSubTypeTableDumpv2 = 4
-	RIB_IPV6_MULTICAST         MRTSubTypeTableDumpv2 = 5
-	RIB_GENERIC                MRTSubTypeTableDumpv2 = 6
-	GEO_PEER_TABLE             MRTSubTypeTableDumpv2 = 7  // RFC6397
-	RIB_IPV4_UNICAST_ADDPATH   MRTSubTypeTableDumpv2 = 8  // RFC8050
-	RIB_IPV4_MULTICAST_ADDPATH MRTSubTypeTableDumpv2 = 9  // RFC8050
-	RIB_IPV6_UNICAST_ADDPATH   MRTSubTypeTableDumpv2 = 10 // RFC8050
-	RIB_IPV6_MULTICAST_ADDPATH MRTSubTypeTableDumpv2 = 11 // RFC8050
-	RIB_GENERIC_ADDPATH        MRTSubTypeTableDumpv2 = 12 // RFC8050
-)
-
-func (t MRTSubTypeTableDumpv2) ToUint16() uint16 {
-	return uint16(t)
-}
-
-type MRTSubTypeBGP4MP uint16
-
-const (
-	STATE_CHANGE              MRTSubTypeBGP4MP = 0
-	MESSAGE                   MRTSubTypeBGP4MP = 1
-	MESSAGE_AS4               MRTSubTypeBGP4MP = 4
-	STATE_CHANGE_AS4          MRTSubTypeBGP4MP = 5
-	MESSAGE_LOCAL             MRTSubTypeBGP4MP = 6
-	MESSAGE_AS4_LOCAL         MRTSubTypeBGP4MP = 7
-	MESSAGE_ADDPATH           MRTSubTypeBGP4MP = 8  // RFC8050
-	MESSAGE_AS4_ADDPATH       MRTSubTypeBGP4MP = 9  // RFC8050
-	MESSAGE_LOCAL_ADDPATH     MRTSubTypeBGP4MP = 10 // RFC8050
-	MESSAGE_AS4_LOCAL_ADDPATH MRTSubTypeBGP4MP = 11 // RFC8050
-)
-
-func (t MRTSubTypeBGP4MP) ToUint16() uint16 {
-	return uint16(t)
-}
-
-type BGPState uint16
-
-const (
-	IDLE        BGPState = 1
-	CONNECT     BGPState = 2
-	ACTIVE      BGPState = 3
-	OPENSENT    BGPState = 4
-	OPENCONFIRM BGPState = 5
-	ESTABLISHED BGPState = 6
-)
-
-func packValues(values []interface{}) ([]byte, error) {
-	b := new(bytes.Buffer)
-	for _, v := range values {
-		err := binary.Write(b, binary.BigEndian, v)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return b.Bytes(), nil
-}
-
-type MRTHeader struct {
-	Timestamp uint32
-	Type      MRTType
-	SubType   uint16
-	Len       uint32
-}
-
-func (h *MRTHeader) DecodeFromBytes(data []byte) error {
-	if len(data) < MRT_COMMON_HEADER_LEN {
-		return fmt.Errorf("not all MRTHeader bytes are available. expected: %d, actual: %d", MRT_COMMON_HEADER_LEN, len(data))
-	}
-	h.Timestamp = binary.BigEndian.Uint32(data[:4])
-	h.Type = MRTType(binary.BigEndian.Uint16(data[4:6]))
-	h.SubType = binary.BigEndian.Uint16(data[6:8])
-	h.Len = binary.BigEndian.Uint32(data[8:12])
-	return nil
-}
-
-func (h *MRTHeader) Serialize() ([]byte, error) {
-	return packValues([]interface{}{h.Timestamp, h.Type, h.SubType, h.Len})
-}
-
-func NewMRTHeader(timestamp uint32, t MRTType, subtype MRTSubTyper, l uint32) (*MRTHeader, error) {
-	return &MRTHeader{
-		Timestamp: timestamp,
-		Type:      t,
-		SubType:   subtype.ToUint16(),
-		Len:       l,
-	}, nil
-}
-
-func (h *MRTHeader) GetTime() time.Time {
-	t := int64(h.Timestamp)
-	return time.Unix(t, 0)
-}
-
-type MRTMessage struct {
-	Header MRTHeader
-	Body   Body
-}
-
-func (m *MRTMessage) Serialize() ([]byte, error) {
-	buf, err := m.Body.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	m.Header.Len = uint32(len(buf))
-	bbuf, err := m.Header.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	return append(bbuf, buf...), nil
-}
-
-func NewMRTMessage(timestamp uint32, t MRTType, subtype MRTSubTyper, body Body) (*MRTMessage, error) {
-	header, err := NewMRTHeader(timestamp, t, subtype, 0)
-	if err != nil {
-		return nil, err
-	}
-	return &MRTMessage{
-		Header: *header,
-		Body:   body,
-	}, nil
-}
-
-type Body interface {
-	DecodeFromBytes([]byte) error
-	Serialize() ([]byte, error)
-}
-
-type Peer struct {
-	Type      uint8
-	BgpId     net.IP
-	IpAddress net.IP
-	AS        uint32
-}
-
-func (p *Peer) DecodeFromBytes(data []byte) ([]byte, error) {
-	notAllBytesAvail := fmt.Errorf("not all Peer bytes are available")
-	if len(data) < 5 {
-		return nil, notAllBytesAvail
-	}
-	p.Type = uint8(data[0])
-	p.BgpId = net.IP(data[1:5])
-	data = data[5:]
-
-	if p.Type&1 > 0 {
-		if len(data) < 16 {
-			return nil, notAllBytesAvail
-		}
-		p.IpAddress = net.IP(data[:16])
-		data = data[16:]
-	} else {
-		if len(data) < 4 {
-			return nil, notAllBytesAvail
-		}
-		p.IpAddress = net.IP(data[:4])
-		data = data[4:]
-	}
-
-	if p.Type&(1<<1) > 0 {
-		if len(data) < 4 {
-			return nil, notAllBytesAvail
-		}
-		p.AS = binary.BigEndian.Uint32(data[:4])
-		data = data[4:]
-	} else {
-		if len(data) < 2 {
-			return nil, notAllBytesAvail
-		}
-		p.AS = uint32(binary.BigEndian.Uint16(data[:2]))
-		data = data[2:]
-	}
-
-	return data, nil
-}
-
-func (p *Peer) Serialize() ([]byte, error) {
-	var err error
-	var bbuf []byte
-	buf := make([]byte, 5)
-	buf[0] = uint8(p.Type)
-	copy(buf[1:], p.BgpId.To4())
-	if p.Type&1 > 0 {
-		buf = append(buf, p.IpAddress.To16()...)
-	} else {
-		buf = append(buf, p.IpAddress.To4()...)
-	}
-	if p.Type&(1<<1) > 0 {
-		bbuf, err = packValues([]interface{}{p.AS})
-	} else {
-		if p.AS > uint32(math.MaxUint16) {
-			return nil, fmt.Errorf("AS number is beyond 2 octet. %d > %d", p.AS, math.MaxUint16)
-		}
-		bbuf, err = packValues([]interface{}{uint16(p.AS)})
-	}
-	if err != nil {
-		return nil, err
-	}
-	return append(buf, bbuf...), nil
-}
-
-func NewPeer(bgpid string, ipaddr string, asn uint32, isAS4 bool) *Peer {
-	t := 0
-	addr := net.ParseIP(ipaddr).To4()
-	if addr == nil {
-		t |= 1
-		addr = net.ParseIP(ipaddr).To16()
-	}
-	if isAS4 {
-		t |= (1 << 1)
-	}
-	return &Peer{
-		Type:      uint8(t),
-		BgpId:     net.ParseIP(bgpid).To4(),
-		IpAddress: addr,
-		AS:        asn,
-	}
-}
-
-func (p *Peer) String() string {
-	return fmt.Sprintf("PEER ENTRY: ID [%s] Addr [%s] AS [%d]", p.BgpId, p.IpAddress, p.AS)
-}
-
-type PeerIndexTable struct {
-	CollectorBgpId net.IP
-	ViewName       string
-	Peers          []*Peer
-}
-
-func (t *PeerIndexTable) DecodeFromBytes(data []byte) error {
-	notAllBytesAvail := fmt.Errorf("not all PeerIndexTable bytes are available")
-	if len(data) < 6 {
-		return notAllBytesAvail
-	}
-	t.CollectorBgpId = net.IP(data[:4])
-	viewLen := binary.BigEndian.Uint16(data[4:6])
-	if len(data) < 6+int(viewLen) {
-		return notAllBytesAvail
-	}
-	t.ViewName = string(data[6 : 6+viewLen])
-
-	data = data[6+viewLen:]
-
-	if len(data) < 2 {
-		return notAllBytesAvail
-	}
-	peerNum := binary.BigEndian.Uint16(data[:2])
-	data = data[2:]
-	t.Peers = make([]*Peer, 0, peerNum)
-	var err error
-	for i := 0; i < int(peerNum); i++ {
-		p := &Peer{}
-		data, err = p.DecodeFromBytes(data)
-		if err != nil {
-			return err
-		}
-		t.Peers = append(t.Peers, p)
-	}
-
-	return nil
-}
-
-func (t *PeerIndexTable) Serialize() ([]byte, error) {
-	buf := make([]byte, 8+len(t.ViewName))
-	copy(buf, t.CollectorBgpId.To4())
-	binary.BigEndian.PutUint16(buf[4:], uint16(len(t.ViewName)))
-	copy(buf[6:], t.ViewName)
-	binary.BigEndian.PutUint16(buf[6+len(t.ViewName):], uint16(len(t.Peers)))
-	for _, peer := range t.Peers {
-		bbuf, err := peer.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, bbuf...)
-	}
-	return buf, nil
-}
-
-func NewPeerIndexTable(bgpid string, viewname string, peers []*Peer) *PeerIndexTable {
-	return &PeerIndexTable{
-		CollectorBgpId: net.ParseIP(bgpid).To4(),
-		ViewName:       viewname,
-		Peers:          peers,
-	}
-}
-
-func (t *PeerIndexTable) String() string {
-	return fmt.Sprintf("PEER_INDEX_TABLE: CollectorBgpId [%s] ViewName [%s] Peers [%s]", t.CollectorBgpId, t.ViewName, t.Peers)
-}
-
-type RibEntry struct {
-	PeerIndex      uint16
-	OriginatedTime uint32
-	PathIdentifier uint32
-	PathAttributes []bgp.PathAttributeInterface
-	isAddPath      bool
-}
-
-func (e *RibEntry) DecodeFromBytes(data []byte) ([]byte, error) {
-	notAllBytesAvail := fmt.Errorf("not all RibEntry bytes are available")
-	if len(data) < 8 {
-		return nil, notAllBytesAvail
-	}
-	e.PeerIndex = binary.BigEndian.Uint16(data[:2])
-	e.OriginatedTime = binary.BigEndian.Uint32(data[2:6])
-	if e.isAddPath {
-		e.PathIdentifier = binary.BigEndian.Uint32(data[6:10])
-		data = data[10:]
-	} else {
-		data = data[6:]
-	}
-	totalLen := binary.BigEndian.Uint16(data[:2])
-	data = data[2:]
-	for attrLen := totalLen; attrLen > 0; {
-		p, err := bgp.GetPathAttribute(data)
-		if err != nil {
-			return nil, err
-		}
-		err = p.DecodeFromBytes(data)
-		if err != nil {
-			return nil, err
-		}
-		attrLen -= uint16(p.Len())
-		if len(data) < p.Len() {
-			return nil, notAllBytesAvail
-		}
-		data = data[p.Len():]
-		e.PathAttributes = append(e.PathAttributes, p)
-	}
-	return data, nil
-}
-
-func (e *RibEntry) Serialize() ([]byte, error) {
-	pbuf := make([]byte, 0)
-	totalLen := 0
-	for _, pattr := range e.PathAttributes {
-		// TODO special modification is needed for MP_REACH_NLRI
-		// but also Quagga doesn't implement this.
-		//
-		// RFC 6396 4.3.4
-		// There is one exception to the encoding of BGP attributes for the BGP
-		// MP_REACH_NLRI attribute (BGP Type Code 14).
-		// Since the AFI, SAFI, and NLRI information is already encoded
-		// in the RIB Entry Header or RIB_GENERIC Entry Header,
-		// only the Next Hop Address Length and Next Hop Address fields are included.
-
-		pb, err := pattr.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		pbuf = append(pbuf, pb...)
-		totalLen += len(pb)
-	}
-	var buf []byte
-	if e.isAddPath {
-		buf = make([]byte, 12)
-		binary.BigEndian.PutUint16(buf, e.PeerIndex)
-		binary.BigEndian.PutUint32(buf[2:], e.OriginatedTime)
-		binary.BigEndian.PutUint32(buf[6:], e.PathIdentifier)
-		binary.BigEndian.PutUint16(buf[10:], uint16(totalLen))
-	} else {
-		buf = make([]byte, 8)
-		binary.BigEndian.PutUint16(buf, e.PeerIndex)
-		binary.BigEndian.PutUint32(buf[2:], e.OriginatedTime)
-		binary.BigEndian.PutUint16(buf[6:], uint16(totalLen))
-	}
-	buf = append(buf, pbuf...)
-	return buf, nil
-}
-
-func NewRibEntry(index uint16, time uint32, pathId uint32, pathAttrs []bgp.PathAttributeInterface, isAddPath bool) *RibEntry {
-	return &RibEntry{
-		PeerIndex:      index,
-		OriginatedTime: time,
-		PathIdentifier: pathId,
-		PathAttributes: pathAttrs,
-		isAddPath:      isAddPath,
-	}
-}
-
-func (e *RibEntry) String() string {
-	if e.isAddPath {
-		return fmt.Sprintf("RIB_ENTRY: PeerIndex [%d] OriginatedTime [%d] PathIdentifier[%d] PathAttributes [%v]", e.PeerIndex, e.OriginatedTime, e.PathIdentifier, e.PathAttributes)
-	} else {
-		return fmt.Sprintf("RIB_ENTRY: PeerIndex [%d] OriginatedTime [%d] PathAttributes [%v]", e.PeerIndex, e.OriginatedTime, e.PathAttributes)
-	}
-
-}
-
-type Rib struct {
-	SequenceNumber uint32
-	Prefix         bgp.AddrPrefixInterface
-	Entries        []*RibEntry
-	RouteFamily    bgp.RouteFamily
-	isAddPath      bool
-}
-
-func (u *Rib) DecodeFromBytes(data []byte) error {
-	if len(data) < 4 {
-		return fmt.Errorf("Not all RibIpv4Unicast message bytes available")
-	}
-	u.SequenceNumber = binary.BigEndian.Uint32(data[:4])
-	data = data[4:]
-	afi, safi := bgp.RouteFamilyToAfiSafi(u.RouteFamily)
-	if afi == 0 && safi == 0 {
-		afi = binary.BigEndian.Uint16(data[:2])
-		safi = data[2]
-		data = data[3:]
-	}
-	prefix, err := bgp.NewPrefixFromRouteFamily(afi, safi)
-	if err != nil {
-		return err
-	}
-	err = prefix.DecodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	u.Prefix = prefix
-	data = data[prefix.Len():]
-	entryNum := binary.BigEndian.Uint16(data[:2])
-	data = data[2:]
-	u.Entries = make([]*RibEntry, 0, entryNum)
-	for i := 0; i < int(entryNum); i++ {
-		e := &RibEntry{
-			isAddPath: u.isAddPath,
-		}
-		data, err = e.DecodeFromBytes(data)
-		if err != nil {
-			return err
-		}
-		u.Entries = append(u.Entries, e)
-	}
-	return nil
-}
-
-func (u *Rib) Serialize() ([]byte, error) {
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint32(buf, u.SequenceNumber)
-	rf := bgp.AfiSafiToRouteFamily(u.Prefix.AFI(), u.Prefix.SAFI())
-	switch rf {
-	case bgp.RF_IPv4_UC, bgp.RF_IPv4_MC, bgp.RF_IPv6_UC, bgp.RF_IPv6_MC:
-	default:
-		bbuf := make([]byte, 2)
-		binary.BigEndian.PutUint16(bbuf, u.Prefix.AFI())
-		buf = append(buf, bbuf...)
-		buf = append(buf, u.Prefix.SAFI())
-	}
-	bbuf, err := u.Prefix.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, bbuf...)
-	bbuf, err = packValues([]interface{}{uint16(len(u.Entries))})
-	if err != nil {
-		return nil, err
-	}
-	buf = append(buf, bbuf...)
-	for _, entry := range u.Entries {
-		bbuf, err = entry.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, bbuf...)
-	}
-	return buf, nil
-}
-
-func NewRib(seq uint32, prefix bgp.AddrPrefixInterface, entries []*RibEntry) *Rib {
-	rf := bgp.AfiSafiToRouteFamily(prefix.AFI(), prefix.SAFI())
-	return &Rib{
-		SequenceNumber: seq,
-		Prefix:         prefix,
-		Entries:        entries,
-		RouteFamily:    rf,
-		isAddPath:      entries[0].isAddPath,
-	}
-}
-
-func (u *Rib) String() string {
-	return fmt.Sprintf("RIB: Seq [%d] Prefix [%s] Entries [%s]", u.SequenceNumber, u.Prefix, u.Entries)
-}
-
-type GeoPeer struct {
-	Type      uint8
-	BgpId     net.IP
-	Latitude  float32
-	Longitude float32
-}
-
-func (p *GeoPeer) DecodeFromBytes(data []byte) ([]byte, error) {
-	if len(data) < 13 {
-		return nil, fmt.Errorf("not all GeoPeer bytes are available")
-	}
-	// Peer IP Address and Peer AS should not be included
-	p.Type = uint8(data[0])
-	if p.Type != uint8(0) {
-		return nil, fmt.Errorf("unsupported peer type for GeoPeer: %d", p.Type)
-	}
-	p.BgpId = net.IP(data[1:5])
-	p.Latitude = math.Float32frombits(binary.BigEndian.Uint32(data[5:9]))
-	p.Longitude = math.Float32frombits(binary.BigEndian.Uint32(data[9:13]))
-	return data[13:], nil
-}
-
-func (p *GeoPeer) Serialize() ([]byte, error) {
-	buf := make([]byte, 13)
-	buf[0] = uint8(0) // Peer IP Address and Peer AS should not be included
-	bgpId := p.BgpId.To4()
-	if bgpId == nil {
-		return nil, fmt.Errorf("invalid BgpId: %s", p.BgpId)
-	}
-	copy(buf[1:5], bgpId)
-	binary.BigEndian.PutUint32(buf[5:9], math.Float32bits(p.Latitude))
-	binary.BigEndian.PutUint32(buf[9:13], math.Float32bits(p.Longitude))
-	return buf, nil
-}
-
-func NewGeoPeer(bgpid string, latitude float32, longitude float32) *GeoPeer {
-	return &GeoPeer{
-		Type:      0, // Peer IP Address and Peer AS should not be included
-		BgpId:     net.ParseIP(bgpid).To4(),
-		Latitude:  latitude,
-		Longitude: longitude,
-	}
-}
-
-func (p *GeoPeer) String() string {
-	return fmt.Sprintf("PEER ENTRY: ID [%s] Latitude [%f] Longitude [%f]", p.BgpId, p.Latitude, p.Longitude)
-}
-
-type GeoPeerTable struct {
-	CollectorBgpId     net.IP
-	CollectorLatitude  float32
-	CollectorLongitude float32
-	Peers              []*GeoPeer
-}
-
-func (t *GeoPeerTable) DecodeFromBytes(data []byte) error {
-	if len(data) < 14 {
-		return fmt.Errorf("not all GeoPeerTable bytes are available")
-	}
-	t.CollectorBgpId = net.IP(data[0:4])
-	t.CollectorLatitude = math.Float32frombits(binary.BigEndian.Uint32(data[4:8]))
-	t.CollectorLongitude = math.Float32frombits(binary.BigEndian.Uint32(data[8:12]))
-	peerCount := binary.BigEndian.Uint16(data[12:14])
-	data = data[14:]
-	t.Peers = make([]*GeoPeer, 0, peerCount)
-	var err error
-	for i := 0; i < int(peerCount); i++ {
-		p := &GeoPeer{}
-		if data, err = p.DecodeFromBytes(data); err != nil {
-			return err
-		}
-		t.Peers = append(t.Peers, p)
-	}
-	return nil
-}
-
-func (t *GeoPeerTable) Serialize() ([]byte, error) {
-	buf := make([]byte, 14)
-	collectorBgpId := t.CollectorBgpId.To4()
-	if collectorBgpId == nil {
-		return nil, fmt.Errorf("invalid CollectorBgpId: %s", t.CollectorBgpId)
-	}
-	copy(buf[0:4], collectorBgpId)
-	binary.BigEndian.PutUint32(buf[4:8], math.Float32bits(t.CollectorLatitude))
-	binary.BigEndian.PutUint32(buf[8:12], math.Float32bits(t.CollectorLongitude))
-	binary.BigEndian.PutUint16(buf[12:14], uint16(len(t.Peers)))
-	for _, peer := range t.Peers {
-		pbuf, err := peer.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		buf = append(buf, pbuf...)
-	}
-	return buf, nil
-}
-
-func NewGeoPeerTable(bgpid string, latitude float32, longitude float32, peers []*GeoPeer) *GeoPeerTable {
-	return &GeoPeerTable{
-		CollectorBgpId:     net.ParseIP(bgpid).To4(),
-		CollectorLatitude:  latitude,
-		CollectorLongitude: longitude,
-		Peers:              peers,
-	}
-}
-
-func (t *GeoPeerTable) String() string {
-	return fmt.Sprintf("GEO_PEER_TABLE: CollectorBgpId [%s] CollectorLatitude [%f] CollectorLongitude [%f] Peers [%s]", t.CollectorBgpId, t.CollectorLatitude, t.CollectorLongitude, t.Peers)
-}
-
-type BGP4MPHeader struct {
-	PeerAS         uint32
-	LocalAS        uint32
-	InterfaceIndex uint16
-	AddressFamily  uint16
-	PeerIpAddress  net.IP
-	LocalIpAddress net.IP
-	isAS4          bool
-}
-
-func (m *BGP4MPHeader) decodeFromBytes(data []byte) ([]byte, error) {
-	if m.isAS4 && len(data) < 8 {
-		return nil, fmt.Errorf("Not all BGP4MPMessageAS4 bytes available")
-	} else if !m.isAS4 && len(data) < 4 {
-		return nil, fmt.Errorf("Not all BGP4MPMessageAS bytes available")
-	}
-
-	if m.isAS4 {
-		m.PeerAS = binary.BigEndian.Uint32(data[:4])
-		m.LocalAS = binary.BigEndian.Uint32(data[4:8])
-		data = data[8:]
-	} else {
-		m.PeerAS = uint32(binary.BigEndian.Uint16(data[:2]))
-		m.LocalAS = uint32(binary.BigEndian.Uint16(data[2:4]))
-		data = data[4:]
-	}
-	m.InterfaceIndex = binary.BigEndian.Uint16(data[:2])
-	m.AddressFamily = binary.BigEndian.Uint16(data[2:4])
-	switch m.AddressFamily {
-	case bgp.AFI_IP:
-		m.PeerIpAddress = net.IP(data[4:8]).To4()
-		m.LocalIpAddress = net.IP(data[8:12]).To4()
-		data = data[12:]
-	case bgp.AFI_IP6:
-		m.PeerIpAddress = net.IP(data[4:20])
-		m.LocalIpAddress = net.IP(data[20:36])
-		data = data[36:]
-	default:
-		return nil, fmt.Errorf("unsupported address family: %d", m.AddressFamily)
-	}
-	return data, nil
-}
-
-func (m *BGP4MPHeader) serialize() ([]byte, error) {
-	var values []interface{}
-	if m.isAS4 {
-		values = []interface{}{m.PeerAS, m.LocalAS, m.InterfaceIndex, m.AddressFamily}
-	} else {
-		values = []interface{}{uint16(m.PeerAS), uint16(m.LocalAS), m.InterfaceIndex, m.AddressFamily}
-	}
-	buf, err := packValues(values)
-	if err != nil {
-		return nil, err
-	}
-	var bbuf []byte
-	switch m.AddressFamily {
-	case bgp.AFI_IP:
-		bbuf = make([]byte, 8)
-		copy(bbuf, m.PeerIpAddress.To4())
-		copy(bbuf[4:], m.LocalIpAddress.To4())
-	case bgp.AFI_IP6:
-		bbuf = make([]byte, 32)
-		copy(bbuf, m.PeerIpAddress)
-		copy(bbuf[16:], m.LocalIpAddress)
-	default:
-		return nil, fmt.Errorf("unsupported address family: %d", m.AddressFamily)
-	}
-	return append(buf, bbuf...), nil
-}
-
-func newBGP4MPHeader(peeras, localas uint32, intfindex uint16, peerip, localip string, isAS4 bool) (*BGP4MPHeader, error) {
-	var af uint16
-	paddr := net.ParseIP(peerip).To4()
-	laddr := net.ParseIP(localip).To4()
-	if paddr != nil && laddr != nil {
-		af = bgp.AFI_IP
-	} else {
-		paddr = net.ParseIP(peerip).To16()
-		laddr = net.ParseIP(localip).To16()
-		if paddr != nil && laddr != nil {
-			af = bgp.AFI_IP6
-		} else {
-			return nil, fmt.Errorf("Peer IP Address and Local IP Address must have the same address family")
-		}
-	}
-	return &BGP4MPHeader{
-		PeerAS:         peeras,
-		LocalAS:        localas,
-		InterfaceIndex: intfindex,
-		AddressFamily:  af,
-		PeerIpAddress:  paddr,
-		LocalIpAddress: laddr,
-		isAS4:          isAS4,
-	}, nil
-}
-
-type BGP4MPStateChange struct {
-	*BGP4MPHeader
-	OldState BGPState
-	NewState BGPState
-}
-
-func (m *BGP4MPStateChange) DecodeFromBytes(data []byte) error {
-	rest, err := m.decodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-	if len(rest) < 4 {
-		return fmt.Errorf("Not all BGP4MPStateChange bytes available")
-	}
-	m.OldState = BGPState(binary.BigEndian.Uint16(rest[:2]))
-	m.NewState = BGPState(binary.BigEndian.Uint16(rest[2:4]))
-	return nil
-}
-
-func (m *BGP4MPStateChange) Serialize() ([]byte, error) {
-	buf, err := m.serialize()
-	if err != nil {
-		return nil, err
-	}
-	bbuf, err := packValues([]interface{}{m.OldState, m.NewState})
-	if err != nil {
-		return nil, err
-	}
-	return append(buf, bbuf...), nil
-}
-
-func NewBGP4MPStateChange(peeras, localas uint32, intfindex uint16, peerip, localip string, isAS4 bool, oldstate, newstate BGPState) *BGP4MPStateChange {
-	header, _ := newBGP4MPHeader(peeras, localas, intfindex, peerip, localip, isAS4)
-	return &BGP4MPStateChange{
-		BGP4MPHeader: header,
-		OldState:     oldstate,
-		NewState:     newstate,
-	}
-}
-
-type BGP4MPMessage struct {
-	*BGP4MPHeader
-	BGPMessage        *bgp.BGPMessage
-	BGPMessagePayload []byte
-	isLocal           bool
-	isAddPath         bool
-}
-
-func (m *BGP4MPMessage) DecodeFromBytes(data []byte) error {
-	rest, err := m.decodeFromBytes(data)
-	if err != nil {
-		return err
-	}
-
-	if len(rest) < bgp.BGP_HEADER_LENGTH {
-		return fmt.Errorf("Not all BGP4MPMessageAS4 bytes available")
-	}
-
-	msg, err := bgp.ParseBGPMessage(rest)
-	if err != nil {
-		return err
-	}
-	m.BGPMessage = msg
-	return nil
-}
-
-func (m *BGP4MPMessage) Serialize() ([]byte, error) {
-	buf, err := m.serialize()
-	if err != nil {
-		return nil, err
-	}
-	if m.BGPMessagePayload != nil {
-		return append(buf, m.BGPMessagePayload...), nil
-	}
-	bbuf, err := m.BGPMessage.Serialize()
-	if err != nil {
-		return nil, err
-	}
-	return append(buf, bbuf...), nil
-}
-
-func NewBGP4MPMessage(peeras, localas uint32, intfindex uint16, peerip, localip string, isAS4 bool, msg *bgp.BGPMessage) *BGP4MPMessage {
-	header, _ := newBGP4MPHeader(peeras, localas, intfindex, peerip, localip, isAS4)
-	return &BGP4MPMessage{
-		BGP4MPHeader: header,
-		BGPMessage:   msg,
-	}
-}
-
-func NewBGP4MPMessageLocal(peeras, localas uint32, intfindex uint16, peerip, localip string, isAS4 bool, msg *bgp.BGPMessage) *BGP4MPMessage {
-	header, _ := newBGP4MPHeader(peeras, localas, intfindex, peerip, localip, isAS4)
-	return &BGP4MPMessage{
-		BGP4MPHeader: header,
-		BGPMessage:   msg,
-		isLocal:      true,
-	}
-}
-
-func NewBGP4MPMessageAddPath(peeras, localas uint32, intfindex uint16, peerip, localip string, isAS4 bool, msg *bgp.BGPMessage) *BGP4MPMessage {
-	header, _ := newBGP4MPHeader(peeras, localas, intfindex, peerip, localip, isAS4)
-	return &BGP4MPMessage{
-		BGP4MPHeader: header,
-		BGPMessage:   msg,
-		isAddPath:    true,
-	}
-}
-
-func NewBGP4MPMessageLocalAddPath(peeras, localas uint32, intfindex uint16, peerip, localip string, isAS4 bool, msg *bgp.BGPMessage) *BGP4MPMessage {
-	header, _ := newBGP4MPHeader(peeras, localas, intfindex, peerip, localip, isAS4)
-	return &BGP4MPMessage{
-		BGP4MPHeader: header,
-		BGPMessage:   msg,
-		isLocal:      true,
-		isAddPath:    true,
-	}
-}
-
-func (m *BGP4MPMessage) String() string {
-	title := "BGP4MP_MSG"
-	if m.isAS4 {
-		title += "_AS4"
-	}
-	if m.isLocal {
-		title += "_LOCAL"
-	}
-	if m.isAddPath {
-		title += "_ADDPATH"
-	}
-	return fmt.Sprintf("%s: PeerAS [%d] LocalAS [%d] InterfaceIndex [%d] PeerIP [%s] LocalIP [%s] BGPMessage [%v]", title, m.PeerAS, m.LocalAS, m.InterfaceIndex, m.PeerIpAddress, m.LocalIpAddress, m.BGPMessage)
-}
-
-//This function can be passed into a bufio.Scanner.Split() to read buffered mrt msgs
-func SplitMrt(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	if atEOF && len(data) == 0 {
-		return 0, nil, nil
-	}
-	if cap(data) < MRT_COMMON_HEADER_LEN { // read more
-		return 0, nil, nil
-	}
-	//this reads the data
-	hdr := &MRTHeader{}
-	errh := hdr.DecodeFromBytes(data[:MRT_COMMON_HEADER_LEN])
-	if errh != nil {
-		return 0, nil, errh
-	}
-	totlen := int(hdr.Len + MRT_COMMON_HEADER_LEN)
-	if len(data) < totlen { //need to read more
-		return 0, nil, nil
-	}
-	return totlen, data[0:totlen], nil
-}
-
-func ParseMRTBody(h *MRTHeader, data []byte) (*MRTMessage, error) {
-	if len(data) < int(h.Len) {
-		return nil, fmt.Errorf("Not all MRT message bytes available. expected: %d, actual: %d", int(h.Len), len(data))
-	}
-	msg := &MRTMessage{Header: *h}
-	switch h.Type {
-	case TABLE_DUMPv2:
-		subType := MRTSubTypeTableDumpv2(h.SubType)
-		rf := bgp.RouteFamily(0)
-		isAddPath := false
-		switch subType {
-		case PEER_INDEX_TABLE:
-			msg.Body = &PeerIndexTable{}
-		case RIB_IPV4_UNICAST:
-			rf = bgp.RF_IPv4_UC
-		case RIB_IPV4_MULTICAST:
-			rf = bgp.RF_IPv4_MC
-		case RIB_IPV6_UNICAST:
-			rf = bgp.RF_IPv6_UC
-		case RIB_IPV6_MULTICAST:
-			rf = bgp.RF_IPv6_MC
-		case RIB_GENERIC:
-		case GEO_PEER_TABLE:
-			msg.Body = &GeoPeerTable{}
-		case RIB_IPV4_UNICAST_ADDPATH:
-			rf = bgp.RF_IPv4_UC
-			isAddPath = true
-		case RIB_IPV4_MULTICAST_ADDPATH:
-			rf = bgp.RF_IPv4_MC
-			isAddPath = true
-		case RIB_IPV6_UNICAST_ADDPATH:
-			rf = bgp.RF_IPv6_UC
-			isAddPath = true
-		case RIB_IPV6_MULTICAST_ADDPATH:
-			rf = bgp.RF_IPv6_MC
-			isAddPath = true
-		case RIB_GENERIC_ADDPATH:
-			isAddPath = true
-		default:
-			return nil, fmt.Errorf("unsupported table dumpv2 subtype: %v\n", subType)
-		}
-
-		if msg.Body == nil {
-			msg.Body = &Rib{
-				RouteFamily: rf,
-				isAddPath:   isAddPath,
-			}
-		}
-	case BGP4MP:
-		subType := MRTSubTypeBGP4MP(h.SubType)
-		isAS4 := true
-		switch subType {
-		case STATE_CHANGE:
-			isAS4 = false
-			fallthrough
-		case STATE_CHANGE_AS4:
-			msg.Body = &BGP4MPStateChange{
-				BGP4MPHeader: &BGP4MPHeader{isAS4: isAS4},
-			}
-		case MESSAGE:
-			isAS4 = false
-			fallthrough
-		case MESSAGE_AS4:
-			msg.Body = &BGP4MPMessage{
-				BGP4MPHeader: &BGP4MPHeader{isAS4: isAS4},
-			}
-		case MESSAGE_LOCAL:
-			isAS4 = false
-			fallthrough
-		case MESSAGE_AS4_LOCAL:
-			msg.Body = &BGP4MPMessage{
-				BGP4MPHeader: &BGP4MPHeader{isAS4: isAS4},
-				isLocal:      true,
-			}
-		case MESSAGE_ADDPATH:
-			isAS4 = false
-			fallthrough
-		case MESSAGE_AS4_ADDPATH:
-			msg.Body = &BGP4MPMessage{
-				BGP4MPHeader: &BGP4MPHeader{isAS4: isAS4},
-				isAddPath:    true,
-			}
-		case MESSAGE_LOCAL_ADDPATH:
-			isAS4 = false
-			fallthrough
-		case MESSAGE_AS4_LOCAL_ADDPATH:
-			msg.Body = &BGP4MPMessage{
-				BGP4MPHeader: &BGP4MPHeader{isAS4: isAS4},
-				isLocal:      true,
-				isAddPath:    true,
-			}
-		default:
-			return nil, fmt.Errorf("unsupported bgp4mp subtype: %v\n", subType)
-		}
-	default:
-		return nil, fmt.Errorf("unsupported type: %v\n", h.Type)
-	}
-	err := msg.Body.DecodeFromBytes(data)
-	if err != nil {
-		return nil, err
-	}
-	return msg, nil
-}
diff --git a/packet/mrt/mrt_test.go b/packet/mrt/mrt_test.go
deleted file mode 100644
index 30edd496..00000000
--- a/packet/mrt/mrt_test.go
+++ /dev/null
@@ -1,301 +0,0 @@
-// Copyright (C) 2015 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 mrt
-
-import (
-	"bufio"
-	"bytes"
-	"github.com/osrg/gobgp/packet/bgp"
-	"github.com/stretchr/testify/assert"
-	"reflect"
-	"testing"
-	"time"
-)
-
-func TestMrtHdr(t *testing.T) {
-	h1, err := NewMRTHeader(10, TABLE_DUMPv2, RIB_IPV4_MULTICAST, 20)
-	if err != nil {
-		t.Fatal(err)
-	}
-	b1, err := h1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	h2 := &MRTHeader{}
-	err = h2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, reflect.DeepEqual(h1, h2), true)
-}
-
-func TestMrtHdrTime(t *testing.T) {
-	h1, err := NewMRTHeader(10, TABLE_DUMPv2, RIB_IPV4_MULTICAST, 20)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ttime := time.Unix(10, 0)
-	htime := h1.GetTime()
-	t.Logf("this timestamp should be 10s after epoch:%v", htime)
-	assert.Equal(t, h1.GetTime(), ttime)
-}
-
-func testPeer(t *testing.T, p1 *Peer) {
-	b1, err := p1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	p2 := &Peer{}
-	rest, err := p2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, len(rest), 0)
-	assert.Equal(t, reflect.DeepEqual(p1, p2), true)
-}
-
-func TestMrtPeer(t *testing.T) {
-	p := NewPeer("192.168.0.1", "10.0.0.1", 65000, false)
-	testPeer(t, p)
-}
-
-func TestMrtPeerv6(t *testing.T) {
-	p := NewPeer("192.168.0.1", "2001::1", 65000, false)
-	testPeer(t, p)
-}
-
-func TestMrtPeerAS4(t *testing.T) {
-	p := NewPeer("192.168.0.1", "2001::1", 135500, true)
-	testPeer(t, p)
-}
-
-func TestMrtPeerIndexTable(t *testing.T) {
-	p1 := NewPeer("192.168.0.1", "10.0.0.1", 65000, false)
-	p2 := NewPeer("192.168.0.1", "2001::1", 65000, false)
-	p3 := NewPeer("192.168.0.1", "2001::1", 135500, true)
-	pt1 := NewPeerIndexTable("192.168.0.1", "test", []*Peer{p1, p2, p3})
-	b1, err := pt1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	pt2 := &PeerIndexTable{}
-	err = pt2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, reflect.DeepEqual(pt1, pt2), true)
-}
-
-func TestMrtRibEntry(t *testing.T) {
-	aspath1 := []bgp.AsPathParamInterface{
-		bgp.NewAsPathParam(2, []uint16{1000}),
-		bgp.NewAsPathParam(1, []uint16{1001, 1002}),
-		bgp.NewAsPathParam(2, []uint16{1003, 1004}),
-	}
-
-	p := []bgp.PathAttributeInterface{
-		bgp.NewPathAttributeOrigin(3),
-		bgp.NewPathAttributeAsPath(aspath1),
-		bgp.NewPathAttributeNextHop("129.1.1.2"),
-		bgp.NewPathAttributeMultiExitDisc(1 << 20),
-		bgp.NewPathAttributeLocalPref(1 << 22),
-	}
-
-	e1 := NewRibEntry(1, uint32(time.Now().Unix()), 0, p, false)
-	b1, err := e1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	e2 := &RibEntry{}
-	rest, err := e2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, len(rest), 0)
-	assert.Equal(t, reflect.DeepEqual(e1, e2), true)
-}
-
-func TestMrtRibEntryWithAddPath(t *testing.T) {
-	aspath1 := []bgp.AsPathParamInterface{
-		bgp.NewAsPathParam(2, []uint16{1000}),
-		bgp.NewAsPathParam(1, []uint16{1001, 1002}),
-		bgp.NewAsPathParam(2, []uint16{1003, 1004}),
-	}
-
-	p := []bgp.PathAttributeInterface{
-		bgp.NewPathAttributeOrigin(3),
-		bgp.NewPathAttributeAsPath(aspath1),
-		bgp.NewPathAttributeNextHop("129.1.1.2"),
-		bgp.NewPathAttributeMultiExitDisc(1 << 20),
-		bgp.NewPathAttributeLocalPref(1 << 22),
-	}
-	e1 := NewRibEntry(1, uint32(time.Now().Unix()), 200, p, true)
-	b1, err := e1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	e2 := &RibEntry{isAddPath: true}
-	rest, err := e2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, len(rest), 0)
-	assert.Equal(t, reflect.DeepEqual(e1, e2), true)
-}
-
-func TestMrtRib(t *testing.T) {
-	aspath1 := []bgp.AsPathParamInterface{
-		bgp.NewAsPathParam(2, []uint16{1000}),
-		bgp.NewAsPathParam(1, []uint16{1001, 1002}),
-		bgp.NewAsPathParam(2, []uint16{1003, 1004}),
-	}
-
-	p := []bgp.PathAttributeInterface{
-		bgp.NewPathAttributeOrigin(3),
-		bgp.NewPathAttributeAsPath(aspath1),
-		bgp.NewPathAttributeNextHop("129.1.1.2"),
-		bgp.NewPathAttributeMultiExitDisc(1 << 20),
-		bgp.NewPathAttributeLocalPref(1 << 22),
-	}
-
-	e1 := NewRibEntry(1, uint32(time.Now().Unix()), 0, p, false)
-	e2 := NewRibEntry(2, uint32(time.Now().Unix()), 0, p, false)
-	e3 := NewRibEntry(3, uint32(time.Now().Unix()), 0, p, false)
-
-	r1 := NewRib(1, bgp.NewIPAddrPrefix(24, "192.168.0.0"), []*RibEntry{e1, e2, e3})
-	b1, err := r1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	r2 := &Rib{
-		RouteFamily: bgp.RF_IPv4_UC,
-	}
-	err = r2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, reflect.DeepEqual(r1, r2), true)
-}
-
-func TestMrtRibWithAddPath(t *testing.T) {
-	aspath1 := []bgp.AsPathParamInterface{
-		bgp.NewAsPathParam(2, []uint16{1000}),
-		bgp.NewAsPathParam(1, []uint16{1001, 1002}),
-		bgp.NewAsPathParam(2, []uint16{1003, 1004}),
-	}
-
-	p := []bgp.PathAttributeInterface{
-		bgp.NewPathAttributeOrigin(3),
-		bgp.NewPathAttributeAsPath(aspath1),
-		bgp.NewPathAttributeNextHop("129.1.1.2"),
-		bgp.NewPathAttributeMultiExitDisc(1 << 20),
-		bgp.NewPathAttributeLocalPref(1 << 22),
-	}
-
-	e1 := NewRibEntry(1, uint32(time.Now().Unix()), 100, p, true)
-	e2 := NewRibEntry(2, uint32(time.Now().Unix()), 200, p, true)
-	e3 := NewRibEntry(3, uint32(time.Now().Unix()), 300, p, true)
-
-	r1 := NewRib(1, bgp.NewIPAddrPrefix(24, "192.168.0.0"), []*RibEntry{e1, e2, e3})
-	b1, err := r1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	r2 := &Rib{
-		RouteFamily: bgp.RF_IPv4_UC,
-		isAddPath:   true,
-	}
-	err = r2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, reflect.DeepEqual(r1, r2), true)
-}
-
-func TestMrtGeoPeerTable(t *testing.T) {
-	p1 := NewGeoPeer("192.168.0.1", 28.031157, 86.899684)
-	p2 := NewGeoPeer("192.168.0.1", 35.360556, 138.727778)
-	pt1 := NewGeoPeerTable("192.168.0.1", 12.345678, 98.765432, []*GeoPeer{p1, p2})
-	b1, err := pt1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	pt2 := &GeoPeerTable{}
-	err = pt2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, reflect.DeepEqual(pt1, pt2), true)
-}
-
-func TestMrtBgp4mpStateChange(t *testing.T) {
-	c1 := NewBGP4MPStateChange(65000, 65001, 1, "192.168.0.1", "192.168.0.2", false, ACTIVE, ESTABLISHED)
-	b1, err := c1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	c2 := &BGP4MPStateChange{BGP4MPHeader: &BGP4MPHeader{}}
-	err = c2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = c2.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, reflect.DeepEqual(c1, c2), true)
-}
-
-func TestMrtBgp4mpMessage(t *testing.T) {
-	msg := bgp.NewBGPKeepAliveMessage()
-	m1 := NewBGP4MPMessage(65000, 65001, 1, "192.168.0.1", "192.168.0.2", false, msg)
-	b1, err := m1.Serialize()
-	if err != nil {
-		t.Fatal(err)
-	}
-	m2 := &BGP4MPMessage{BGP4MPHeader: &BGP4MPHeader{}}
-	err = m2.DecodeFromBytes(b1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	assert.Equal(t, reflect.DeepEqual(m1, m2), true)
-}
-
-func TestMrtSplit(t *testing.T) {
-	var b bytes.Buffer
-	numwrite, numread := 10, 0
-	for i := 0; i < numwrite; i++ {
-		msg := bgp.NewBGPKeepAliveMessage()
-		m1 := NewBGP4MPMessage(65000, 65001, 1, "192.168.0.1", "192.168.0.2", false, msg)
-		mm, _ := NewMRTMessage(1234, BGP4MP, MESSAGE, m1)
-		b1, err := mm.Serialize()
-		if err != nil {
-			t.Fatal(err)
-		}
-		b.Write(b1)
-	}
-	t.Logf("wrote %d serialized MRT keepalives in the buffer", numwrite)
-	r := bytes.NewReader(b.Bytes())
-	scanner := bufio.NewScanner(r)
-	scanner.Split(SplitMrt)
-	for scanner.Scan() {
-		numread += 1
-	}
-	t.Logf("scanner scanned %d serialized keepalives from the buffer", numread)
-	assert.Equal(t, numwrite, numread)
-}
diff --git a/packet/rtr/rtr.go b/packet/rtr/rtr.go
deleted file mode 100644
index 902f1e62..00000000
--- a/packet/rtr/rtr.go
+++ /dev/null
@@ -1,392 +0,0 @@
-// Copyright (C) 2015 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 rtr
-
-import (
-	"encoding/binary"
-	"fmt"
-	"net"
-)
-
-const (
-	RPKI_DEFAULT_PORT = 323
-)
-
-const (
-	RTR_SERIAL_NOTIFY = iota
-	RTR_SERIAL_QUERY
-	RTR_RESET_QUERY
-	RTR_CACHE_RESPONSE
-	RTR_IPV4_PREFIX
-	_
-	RTR_IPV6_PREFIX
-	RTR_END_OF_DATA
-	RTR_CACHE_RESET
-	_
-	RTR_ERROR_REPORT
-)
-
-const (
-	RTR_SERIAL_NOTIFY_LEN         = 12
-	RTR_SERIAL_QUERY_LEN          = 12
-	RTR_RESET_QUERY_LEN           = 8
-	RTR_CACHE_RESPONSE_LEN        = 8
-	RTR_IPV4_PREFIX_LEN           = 20
-	RTR_IPV6_PREFIX_LEN           = 32
-	RTR_END_OF_DATA_LEN           = 12
-	RTR_CACHE_RESET_LEN           = 8
-	RTR_MIN_LEN                   = 8
-	RTR_ERROR_REPORT_ERR_PDU_LEN  = 4
-	RTR_ERROR_REPORT_ERR_TEXT_LEN = 4
-)
-
-const (
-	WITHDRAWAL uint8 = iota
-	ANNOUNCEMENT
-)
-
-const (
-	CORRUPT_DATA uint16 = iota
-	INTERNAL_ERROR
-	NO_DATA_AVAILABLE
-	INVALID_REQUEST
-	UNSUPPORTED_PROTOCOL_VERSION
-	UNSUPPORTED_PDU_TYPE
-	WITHDRAWAL_OF_UNKNOWN_RECORD
-	DUPLICATE_ANNOUNCEMENT_RECORD
-)
-
-type RTRMessage interface {
-	DecodeFromBytes([]byte) error
-	Serialize() ([]byte, error)
-}
-
-type RTRCommon struct {
-	Version      uint8
-	Type         uint8
-	SessionID    uint16
-	Len          uint32
-	SerialNumber uint32
-}
-
-func (m *RTRCommon) DecodeFromBytes(data []byte) error {
-	m.Version = data[0]
-	m.Type = data[1]
-	m.SessionID = binary.BigEndian.Uint16(data[2:4])
-	m.Len = binary.BigEndian.Uint32(data[4:8])
-	m.SerialNumber = binary.BigEndian.Uint32(data[8:12])
-	return nil
-}
-
-func (m *RTRCommon) Serialize() ([]byte, error) {
-	data := make([]byte, m.Len)
-	data[0] = m.Version
-	data[1] = m.Type
-	binary.BigEndian.PutUint16(data[2:4], m.SessionID)
-	binary.BigEndian.PutUint32(data[4:8], m.Len)
-	binary.BigEndian.PutUint32(data[8:12], m.SerialNumber)
-	return data, nil
-}
-
-type RTRSerialNotify struct {
-	RTRCommon
-}
-
-func NewRTRSerialNotify(id uint16, sn uint32) *RTRSerialNotify {
-	return &RTRSerialNotify{
-		RTRCommon{
-			Type:         RTR_SERIAL_NOTIFY,
-			SessionID:    id,
-			Len:          RTR_SERIAL_NOTIFY_LEN,
-			SerialNumber: sn,
-		},
-	}
-}
-
-type RTRSerialQuery struct {
-	RTRCommon
-}
-
-func NewRTRSerialQuery(id uint16, sn uint32) *RTRSerialQuery {
-	return &RTRSerialQuery{
-		RTRCommon{
-			Type:         RTR_SERIAL_QUERY,
-			SessionID:    id,
-			Len:          RTR_SERIAL_QUERY_LEN,
-			SerialNumber: sn,
-		},
-	}
-}
-
-type RTRReset struct {
-	Version uint8
-	Type    uint8
-	Len     uint32
-}
-
-func (m *RTRReset) DecodeFromBytes(data []byte) error {
-	m.Version = data[0]
-	m.Type = data[1]
-	m.Len = binary.BigEndian.Uint32(data[4:8])
-	return nil
-}
-
-func (m *RTRReset) Serialize() ([]byte, error) {
-	data := make([]byte, m.Len)
-	data[0] = m.Version
-	data[1] = m.Type
-	binary.BigEndian.PutUint32(data[4:8], m.Len)
-	return data, nil
-}
-
-type RTRResetQuery struct {
-	RTRReset
-}
-
-func NewRTRResetQuery() *RTRResetQuery {
-	return &RTRResetQuery{
-		RTRReset{
-			Type: RTR_RESET_QUERY,
-			Len:  RTR_RESET_QUERY_LEN,
-		},
-	}
-}
-
-type RTRCacheResponse struct {
-	Version   uint8
-	Type      uint8
-	SessionID uint16
-	Len       uint32
-}
-
-func (m *RTRCacheResponse) DecodeFromBytes(data []byte) error {
-	m.Version = data[0]
-	m.Type = data[1]
-	m.SessionID = binary.BigEndian.Uint16(data[2:4])
-	m.Len = binary.BigEndian.Uint32(data[4:8])
-	return nil
-}
-
-func (m *RTRCacheResponse) Serialize() ([]byte, error) {
-	data := make([]byte, m.Len)
-	data[0] = m.Version
-	data[1] = m.Type
-	binary.BigEndian.PutUint16(data[2:4], m.SessionID)
-	binary.BigEndian.PutUint32(data[4:8], m.Len)
-	return data, nil
-}
-
-func NewRTRCacheResponse(id uint16) *RTRCacheResponse {
-	return &RTRCacheResponse{
-		Type:      RTR_CACHE_RESPONSE,
-		SessionID: id,
-		Len:       RTR_CACHE_RESPONSE_LEN,
-	}
-}
-
-type RTRIPPrefix struct {
-	Version   uint8
-	Type      uint8
-	Len       uint32
-	Flags     uint8
-	PrefixLen uint8
-	MaxLen    uint8
-	Prefix    net.IP
-	AS        uint32
-}
-
-func (m *RTRIPPrefix) DecodeFromBytes(data []byte) error {
-	m.Version = data[0]
-	m.Type = data[1]
-	m.Len = binary.BigEndian.Uint32(data[4:8])
-	m.Flags = data[8]
-	m.PrefixLen = data[9]
-	m.MaxLen = data[10]
-	if m.Type == RTR_IPV4_PREFIX {
-		m.Prefix = net.IP(data[12:16]).To4()
-		m.AS = binary.BigEndian.Uint32(data[16:20])
-	} else {
-		m.Prefix = net.IP(data[12:28]).To16()
-		m.AS = binary.BigEndian.Uint32(data[28:32])
-	}
-	return nil
-}
-
-func (m *RTRIPPrefix) Serialize() ([]byte, error) {
-	data := make([]byte, m.Len)
-	data[0] = m.Version
-	data[1] = m.Type
-	binary.BigEndian.PutUint32(data[4:8], m.Len)
-	data[8] = m.Flags
-	data[9] = m.PrefixLen
-	data[10] = m.MaxLen
-	if m.Type == RTR_IPV4_PREFIX {
-		copy(data[12:16], m.Prefix.To4())
-		binary.BigEndian.PutUint32(data[16:20], m.AS)
-	} else {
-		copy(data[12:28], m.Prefix.To16())
-		binary.BigEndian.PutUint32(data[28:32], m.AS)
-	}
-	return data, nil
-}
-
-func NewRTRIPPrefix(prefix net.IP, prefixLen, maxLen uint8, as uint32, flags uint8) *RTRIPPrefix {
-	var pduType uint8
-	var pduLen uint32
-	if prefix.To4() != nil && prefixLen <= 32 {
-		pduType = RTR_IPV4_PREFIX
-		pduLen = RTR_IPV4_PREFIX_LEN
-	} else {
-		pduType = RTR_IPV6_PREFIX
-		pduLen = RTR_IPV6_PREFIX_LEN
-	}
-
-	return &RTRIPPrefix{
-		Type:      pduType,
-		Len:       pduLen,
-		Flags:     flags,
-		PrefixLen: prefixLen,
-		MaxLen:    maxLen,
-		Prefix:    prefix,
-		AS:        as,
-	}
-}
-
-type RTREndOfData struct {
-	RTRCommon
-}
-
-func NewRTREndOfData(id uint16, sn uint32) *RTREndOfData {
-	return &RTREndOfData{
-		RTRCommon{
-			Type:         RTR_END_OF_DATA,
-			SessionID:    id,
-			Len:          RTR_END_OF_DATA_LEN,
-			SerialNumber: sn,
-		},
-	}
-}
-
-type RTRCacheReset struct {
-	RTRReset
-}
-
-func NewRTRCacheReset() *RTRCacheReset {
-	return &RTRCacheReset{
-		RTRReset{
-			Type: RTR_CACHE_RESET,
-			Len:  RTR_CACHE_RESET_LEN,
-		},
-	}
-}
-
-type RTRErrorReport struct {
-	Version   uint8
-	Type      uint8
-	ErrorCode uint16
-	Len       uint32
-	PDULen    uint32
-	PDU       []byte
-	TextLen   uint32
-	Text      []byte
-}
-
-func (m *RTRErrorReport) DecodeFromBytes(data []byte) error {
-	m.Version = data[0]
-	m.Type = data[1]
-	m.ErrorCode = binary.BigEndian.Uint16(data[2:4])
-	m.Len = binary.BigEndian.Uint32(data[4:8])
-	m.PDULen = binary.BigEndian.Uint32(data[8:12])
-	m.PDU = make([]byte, m.PDULen)
-	copy(m.PDU, data[12:12+m.PDULen])
-	m.TextLen = binary.BigEndian.Uint32(data[12+m.PDULen : 16+m.PDULen])
-	m.Text = make([]byte, m.TextLen)
-	copy(m.Text, data[16+m.PDULen:])
-	return nil
-}
-
-func (m *RTRErrorReport) Serialize() ([]byte, error) {
-	data := make([]byte, m.Len)
-	data[0] = m.Version
-	data[1] = m.Type
-	binary.BigEndian.PutUint16(data[2:4], m.ErrorCode)
-	binary.BigEndian.PutUint32(data[4:8], m.Len)
-	binary.BigEndian.PutUint32(data[8:12], m.PDULen)
-	copy(data[12:], m.PDU)
-	binary.BigEndian.PutUint32(data[12+m.PDULen:16+m.PDULen], m.TextLen)
-	copy(data[16+m.PDULen:], m.Text)
-	return data, nil
-}
-
-func NewRTRErrorReport(errCode uint16, errPDU []byte, errMsg []byte) *RTRErrorReport {
-	pdu := &RTRErrorReport{Type: RTR_ERROR_REPORT, ErrorCode: errCode}
-	if errPDU != nil {
-		if errPDU[1] == RTR_ERROR_REPORT {
-			return nil
-		}
-		pdu.PDULen = uint32(len(errPDU))
-		pdu.PDU = errPDU
-	}
-	if errMsg != nil {
-		pdu.Text = errMsg
-		pdu.TextLen = uint32(len(errMsg))
-	}
-	pdu.Len = uint32(RTR_MIN_LEN) + uint32(RTR_ERROR_REPORT_ERR_PDU_LEN) + pdu.PDULen + uint32(RTR_ERROR_REPORT_ERR_TEXT_LEN) + pdu.TextLen
-	return pdu
-}
-
-func SplitRTR(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	if atEOF && len(data) == 0 || len(data) < RTR_MIN_LEN {
-		return 0, nil, nil
-	}
-
-	totalLen := binary.BigEndian.Uint32(data[4:8])
-	if totalLen < RTR_MIN_LEN {
-		return 0, nil, fmt.Errorf("Invalid length: %d", totalLen)
-	}
-	if uint32(len(data)) < totalLen {
-		return 0, nil, nil
-	}
-	return int(totalLen), data[0:totalLen], nil
-}
-
-func ParseRTR(data []byte) (RTRMessage, error) {
-	var msg RTRMessage
-	switch data[1] {
-	case RTR_SERIAL_NOTIFY:
-		msg = &RTRSerialNotify{}
-	case RTR_SERIAL_QUERY:
-		msg = &RTRSerialQuery{}
-	case RTR_RESET_QUERY:
-		msg = &RTRResetQuery{}
-	case RTR_CACHE_RESPONSE:
-		msg = &RTRCacheResponse{}
-	case RTR_IPV4_PREFIX:
-		msg = &RTRIPPrefix{}
-	case RTR_IPV6_PREFIX:
-		msg = &RTRIPPrefix{}
-	case RTR_END_OF_DATA:
-		msg = &RTREndOfData{}
-	case RTR_CACHE_RESET:
-		msg = &RTRCacheReset{}
-	case RTR_ERROR_REPORT:
-		msg = &RTRErrorReport{}
-	default:
-		return nil, fmt.Errorf("unknown RTR message type %d:", data[1])
-	}
-	err := msg.DecodeFromBytes(data)
-	return msg, err
-}
diff --git a/packet/rtr/rtr_test.go b/packet/rtr/rtr_test.go
deleted file mode 100644
index 08f930b2..00000000
--- a/packet/rtr/rtr_test.go
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (C) 2015 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 rtr
-
-import (
-	"encoding/hex"
-	"math/rand"
-	"net"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func verifyRTRMessage(t *testing.T, m1 RTRMessage) {
-	buf1, _ := m1.Serialize()
-	m2, err := ParseRTR(buf1)
-	require.NoError(t, err)
-
-	buf2, err := m2.Serialize()
-	require.NoError(t, err)
-
-	assert.Equal(t, buf1, buf2, "buf1: %v buf2: %v", hex.EncodeToString(buf1), hex.EncodeToString(buf2))
-}
-
-func randUint32() uint32 {
-	rand.Seed(time.Now().UnixNano())
-	return rand.Uint32()
-}
-
-func Test_RTRSerialNotify(t *testing.T) {
-	id := uint16(time.Now().Unix())
-	sn := randUint32()
-	verifyRTRMessage(t, NewRTRSerialNotify(id, sn))
-}
-
-func Test_RTRSerialQuery(t *testing.T) {
-	id := uint16(time.Now().Unix())
-	sn := randUint32()
-	verifyRTRMessage(t, NewRTRSerialQuery(id, sn))
-}
-
-func Test_RTRResetQuery(t *testing.T) {
-	verifyRTRMessage(t, NewRTRResetQuery())
-}
-
-func Test_RTRCacheResponse(t *testing.T) {
-	id := uint16(time.Now().Unix())
-	verifyRTRMessage(t, NewRTRCacheResponse(id))
-}
-
-type rtrIPPrefixTestCase struct {
-	pString string
-	pLen    uint8
-	mLen    uint8
-	asn     uint32
-	flags   uint8
-}
-
-var rtrIPPrefixTestCases = []rtrIPPrefixTestCase{
-	{"192.168.0.0", 16, 32, 65001, ANNOUNCEMENT},
-	{"192.168.0.0", 16, 32, 65001, WITHDRAWAL},
-	{"2001:db8::", 32, 128, 65001, ANNOUNCEMENT},
-	{"2001:db8::", 32, 128, 65001, WITHDRAWAL},
-	{"::ffff:0.0.0.0", 96, 128, 65001, ANNOUNCEMENT},
-	{"::ffff:0.0.0.0", 96, 128, 65001, WITHDRAWAL},
-}
-
-func Test_RTRIPPrefix(t *testing.T) {
-	for i := range rtrIPPrefixTestCases {
-		test := &rtrIPPrefixTestCases[i]
-		addr := net.ParseIP(test.pString)
-		verifyRTRMessage(t, NewRTRIPPrefix(addr, test.pLen, test.mLen, test.asn, test.flags))
-	}
-}
-
-func Test_RTREndOfData(t *testing.T) {
-	id := uint16(time.Now().Unix())
-	sn := randUint32()
-	verifyRTRMessage(t, NewRTREndOfData(id, sn))
-}
-
-func Test_RTRCacheReset(t *testing.T) {
-	verifyRTRMessage(t, NewRTRCacheReset())
-}
-
-func Test_RTRErrorReport(t *testing.T) {
-	errPDU, _ := NewRTRResetQuery().Serialize()
-	errText1 := []byte("Couldn't send CacheResponce PDU")
-	errText2 := []byte("Wrong Length of PDU: 10 bytes")
-
-	// See 5.10 ErrorReport in RFC6810
-	// when it doesn't have both "erroneous PDU" and "Arbitrary Text"
-	verifyRTRMessage(t, NewRTRErrorReport(NO_DATA_AVAILABLE, nil, nil))
-
-	// when it has "erroneous PDU"
-	verifyRTRMessage(t, NewRTRErrorReport(UNSUPPORTED_PROTOCOL_VERSION, errPDU, nil))
-
-	// when it has "ArbitaryText"
-	verifyRTRMessage(t, NewRTRErrorReport(INTERNAL_ERROR, nil, errText1))
-
-	// when it has both "erroneous PDU" and "Arbitrary Text"
-	verifyRTRMessage(t, NewRTRErrorReport(CORRUPT_DATA, errPDU, errText2))
-}