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>

19 files changed, 6451 insertions, 0 deletions

diff --git a/cmd/gobgp/cmd/bmp.go b/cmd/gobgp/cmd/bmp.go
new file mode 100644
index 00000000..6de8eac4
--- /dev/null
+++ b/cmd/gobgp/cmd/bmp.go
@@ -0,0 +1,102 @@
+// 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 cmd
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+
+	"github.com/osrg/gobgp/internal/pkg/config"
+	"github.com/osrg/gobgp/pkg/packet/bmp"
+	"github.com/spf13/cobra"
+)
+
+func modBmpServer(cmdType string, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: gobgp bmp %s <addr>[:<port>] [{pre|post|both|local-rib|all}]", cmdType)
+	}
+
+	var address string
+	port := uint32(bmp.BMP_DEFAULT_PORT)
+	if host, p, err := net.SplitHostPort(args[0]); err != nil {
+		ip := net.ParseIP(args[0])
+		if ip == nil {
+			return nil
+		}
+		address = args[0]
+	} else {
+		address = host
+		// Note: BmpServerConfig.Port is uint32 type, but the TCP/UDP port is
+		// 16-bit length.
+		pn, _ := strconv.ParseUint(p, 10, 16)
+		port = uint32(pn)
+	}
+
+	var err error
+	switch cmdType {
+	case CMD_ADD:
+		policyType := config.BMP_ROUTE_MONITORING_POLICY_TYPE_PRE_POLICY
+		if len(args) > 1 {
+			switch args[1] {
+			case "pre":
+			case "post":
+				policyType = config.BMP_ROUTE_MONITORING_POLICY_TYPE_POST_POLICY
+			case "both":
+				policyType = config.BMP_ROUTE_MONITORING_POLICY_TYPE_BOTH
+			case "local-rib":
+				policyType = config.BMP_ROUTE_MONITORING_POLICY_TYPE_LOCAL_RIB
+			case "all":
+				policyType = config.BMP_ROUTE_MONITORING_POLICY_TYPE_ALL
+			default:
+				return fmt.Errorf("invalid bmp policy type. valid type is {pre|post|both|local-rib|all}")
+			}
+		}
+		err = client.AddBMP(&config.BmpServerConfig{
+			Address: address,
+			Port:    port,
+			RouteMonitoringPolicy: policyType,
+		})
+	case CMD_DEL:
+		err = client.DeleteBMP(&config.BmpServerConfig{
+			Address: address,
+			Port:    port,
+		})
+	}
+	return err
+}
+
+func NewBmpCmd() *cobra.Command {
+
+	bmpCmd := &cobra.Command{
+		Use: CMD_BMP,
+	}
+
+	for _, w := range []string{CMD_ADD, CMD_DEL} {
+		subcmd := &cobra.Command{
+			Use: w,
+			Run: func(cmd *cobra.Command, args []string) {
+				err := modBmpServer(cmd.Use, args)
+				if err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+		bmpCmd.AddCommand(subcmd)
+	}
+
+	return bmpCmd
+}
diff --git a/cmd/gobgp/cmd/common.go b/cmd/gobgp/cmd/common.go
new file mode 100644
index 00000000..fbd75767
--- /dev/null
+++ b/cmd/gobgp/cmd/common.go
@@ -0,0 +1,347 @@
+// 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 cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+
+	api "github.com/osrg/gobgp/api"
+	cli "github.com/osrg/gobgp/internal/pkg/client"
+	"github.com/osrg/gobgp/internal/pkg/config"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+)
+
+const (
+	CMD_GLOBAL         = "global"
+	CMD_NEIGHBOR       = "neighbor"
+	CMD_POLICY         = "policy"
+	CMD_RIB            = "rib"
+	CMD_ADD            = "add"
+	CMD_DEL            = "del"
+	CMD_ALL            = "all"
+	CMD_SET            = "set"
+	CMD_LOCAL          = "local"
+	CMD_ADJ_IN         = "adj-in"
+	CMD_ADJ_OUT        = "adj-out"
+	CMD_RESET          = "reset"
+	CMD_SOFT_RESET     = "softreset"
+	CMD_SOFT_RESET_IN  = "softresetin"
+	CMD_SOFT_RESET_OUT = "softresetout"
+	CMD_SHUTDOWN       = "shutdown"
+	CMD_ENABLE         = "enable"
+	CMD_DISABLE        = "disable"
+	CMD_PREFIX         = "prefix"
+	CMD_ASPATH         = "as-path"
+	CMD_COMMUNITY      = "community"
+	CMD_EXTCOMMUNITY   = "ext-community"
+	CMD_IMPORT         = "import"
+	CMD_EXPORT         = "export"
+	CMD_IN             = "in"
+	CMD_MONITOR        = "monitor"
+	CMD_MRT            = "mrt"
+	CMD_DUMP           = "dump"
+	CMD_INJECT         = "inject"
+	CMD_RPKI           = "rpki"
+	CMD_RPKI_TABLE     = "table"
+	CMD_RPKI_SERVER    = "server"
+	CMD_VRF            = "vrf"
+	CMD_ACCEPTED       = "accepted"
+	CMD_REJECTED       = "rejected"
+	CMD_STATEMENT      = "statement"
+	CMD_CONDITION      = "condition"
+	CMD_ACTION         = "action"
+	CMD_UPDATE         = "update"
+	CMD_ROTATE         = "rotate"
+	CMD_BMP            = "bmp"
+	CMD_LARGECOMMUNITY = "large-community"
+	CMD_SUMMARY        = "summary"
+	CMD_VALIDATION     = "validation"
+)
+
+const (
+	PARAM_FLAG = iota
+	PARAM_SINGLE
+	PARAM_LIST
+)
+
+var subOpts struct {
+	AddressFamily string `short:"a" long:"address-family" description:"specifying an address family"`
+}
+
+var neighborsOpts struct {
+	Reason    string `short:"r" long:"reason" description:"specifying communication field on Cease NOTIFICATION message with Administrative Shutdown subcode"`
+	Transport string `short:"t" long:"transport" description:"specifying a transport protocol"`
+}
+
+var mrtOpts struct {
+	OutputDir   string
+	FileFormat  string
+	Filename    string `long:"filename" description:"MRT file name"`
+	RecordCount int64  `long:"count" description:"Number of records to inject"`
+	RecordSkip  int64  `long:"skip" description:"Number of records to skip before injecting"`
+	QueueSize   int    `long:"batch-size" description:"Maximum number of updates to keep queued"`
+	Best        bool   `long:"only-best" description:"only keep best path routes"`
+	SkipV4      bool   `long:"no-ipv4" description:"Skip importing IPv4 routes"`
+	SkipV6      bool   `long:"no-ipv4" description:"Skip importing IPv6 routes"`
+	NextHop     net.IP `long:"nexthop" description:"Rewrite nexthop"`
+}
+
+func formatTimedelta(d int64) string {
+	u := uint64(d)
+	neg := d < 0
+	if neg {
+		u = -u
+	}
+	secs := u % 60
+	u /= 60
+	mins := u % 60
+	u /= 60
+	hours := u % 24
+	days := u / 24
+
+	if days == 0 {
+		return fmt.Sprintf("%02d:%02d:%02d", hours, mins, secs)
+	}
+	return fmt.Sprintf("%dd ", days) + fmt.Sprintf("%02d:%02d:%02d", hours, mins, secs)
+}
+
+func cidr2prefix(cidr string) string {
+	_, n, err := net.ParseCIDR(cidr)
+	if err != nil {
+		return cidr
+	}
+	var buffer bytes.Buffer
+	for i := 0; i < len(n.IP); i++ {
+		buffer.WriteString(fmt.Sprintf("%08b", n.IP[i]))
+	}
+	ones, _ := n.Mask.Size()
+	return buffer.String()[:ones]
+}
+
+func extractReserved(args []string, keys map[string]int) (map[string][]string, error) {
+	m := make(map[string][]string, len(keys))
+	var k string
+	isReserved := func(s string) bool {
+		for r := range keys {
+			if s == r {
+				return true
+			}
+		}
+		return false
+	}
+	for _, arg := range args {
+		if isReserved(arg) {
+			k = arg
+			m[k] = make([]string, 0, 1)
+		} else {
+			m[k] = append(m[k], arg)
+		}
+	}
+	for k, v := range m {
+		if k == "" {
+			continue
+		}
+		switch keys[k] {
+		case PARAM_FLAG:
+			if len(v) != 0 {
+				return nil, fmt.Errorf("%s should not have arguments", k)
+			}
+		case PARAM_SINGLE:
+			if len(v) != 1 {
+				return nil, fmt.Errorf("%s should have one argument", k)
+			}
+		case PARAM_LIST:
+			if len(v) == 0 {
+				return nil, fmt.Errorf("%s should have one or more arguments", k)
+			}
+		}
+	}
+	return m, nil
+}
+
+type neighbors []*config.Neighbor
+
+func (n neighbors) Len() int {
+	return len(n)
+}
+
+func (n neighbors) Swap(i, j int) {
+	n[i], n[j] = n[j], n[i]
+}
+
+func (n neighbors) Less(i, j int) bool {
+	p1 := n[i].State.NeighborAddress
+	p2 := n[j].State.NeighborAddress
+	p1Isv4 := !strings.Contains(p1, ":")
+	p2Isv4 := !strings.Contains(p2, ":")
+	if p1Isv4 != p2Isv4 {
+		return p1Isv4
+	}
+	addrlen := 128
+	if p1Isv4 {
+		addrlen = 32
+	}
+	strings := sort.StringSlice{cidr2prefix(fmt.Sprintf("%s/%d", p1, addrlen)),
+		cidr2prefix(fmt.Sprintf("%s/%d", p2, addrlen))}
+	return strings.Less(0, 1)
+}
+
+type capabilities []bgp.ParameterCapabilityInterface
+
+func (c capabilities) Len() int {
+	return len(c)
+}
+
+func (c capabilities) Swap(i, j int) {
+	c[i], c[j] = c[j], c[i]
+}
+
+func (c capabilities) Less(i, j int) bool {
+	return c[i].Code() < c[j].Code()
+}
+
+type vrfs []*api.Vrf
+
+func (v vrfs) Len() int {
+	return len(v)
+}
+
+func (v vrfs) Swap(i, j int) {
+	v[i], v[j] = v[j], v[i]
+}
+
+func (v vrfs) Less(i, j int) bool {
+	return v[i].Name < v[j].Name
+}
+
+func newClient() *cli.Client {
+	var grpcOpts []grpc.DialOption
+	if globalOpts.TLS {
+		var creds credentials.TransportCredentials
+		if globalOpts.CaFile == "" {
+			creds = credentials.NewClientTLSFromCert(nil, "")
+		} else {
+			var err error
+			creds, err = credentials.NewClientTLSFromFile(globalOpts.CaFile, "")
+			if err != nil {
+				exitWithError(err)
+			}
+		}
+		grpcOpts = []grpc.DialOption{
+			grpc.WithTimeout(time.Second),
+			grpc.WithBlock(),
+			grpc.WithTransportCredentials(creds),
+		}
+	}
+	target := net.JoinHostPort(globalOpts.Host, strconv.Itoa(globalOpts.Port))
+	client, err := cli.New(target, grpcOpts...)
+	if err != nil {
+		exitWithError(fmt.Errorf("failed to connect to %s over gRPC: %s", target, err))
+	}
+	return client
+}
+
+func addr2AddressFamily(a net.IP) bgp.RouteFamily {
+	if a.To4() != nil {
+		return bgp.RF_IPv4_UC
+	} else if a.To16() != nil {
+		return bgp.RF_IPv6_UC
+	}
+	return bgp.RouteFamily(0)
+}
+
+func checkAddressFamily(def bgp.RouteFamily) (bgp.RouteFamily, error) {
+	var rf bgp.RouteFamily
+	var e error
+	switch subOpts.AddressFamily {
+	case "ipv4", "v4", "4":
+		rf = bgp.RF_IPv4_UC
+	case "ipv6", "v6", "6":
+		rf = bgp.RF_IPv6_UC
+	case "ipv4-l3vpn", "vpnv4", "vpn-ipv4":
+		rf = bgp.RF_IPv4_VPN
+	case "ipv6-l3vpn", "vpnv6", "vpn-ipv6":
+		rf = bgp.RF_IPv6_VPN
+	case "ipv4-labeled", "ipv4-labelled", "ipv4-mpls":
+		rf = bgp.RF_IPv4_MPLS
+	case "ipv6-labeled", "ipv6-labelled", "ipv6-mpls":
+		rf = bgp.RF_IPv6_MPLS
+	case "evpn":
+		rf = bgp.RF_EVPN
+	case "encap", "ipv4-encap":
+		rf = bgp.RF_IPv4_ENCAP
+	case "ipv6-encap":
+		rf = bgp.RF_IPv6_ENCAP
+	case "rtc":
+		rf = bgp.RF_RTC_UC
+	case "ipv4-flowspec", "ipv4-flow", "flow4":
+		rf = bgp.RF_FS_IPv4_UC
+	case "ipv6-flowspec", "ipv6-flow", "flow6":
+		rf = bgp.RF_FS_IPv6_UC
+	case "ipv4-l3vpn-flowspec", "ipv4vpn-flowspec", "flowvpn4":
+		rf = bgp.RF_FS_IPv4_VPN
+	case "ipv6-l3vpn-flowspec", "ipv6vpn-flowspec", "flowvpn6":
+		rf = bgp.RF_FS_IPv6_VPN
+	case "l2vpn-flowspec":
+		rf = bgp.RF_FS_L2_VPN
+	case "opaque":
+		rf = bgp.RF_OPAQUE
+	case "":
+		rf = def
+	default:
+		e = fmt.Errorf("unsupported address family: %s", subOpts.AddressFamily)
+	}
+	return rf, e
+}
+
+func printError(err error) {
+	if globalOpts.Json {
+		j, _ := json.Marshal(struct {
+			Error string `json:"error"`
+		}{Error: err.Error()})
+		fmt.Println(string(j))
+	} else {
+		fmt.Println(err)
+	}
+}
+
+func exitWithError(err error) {
+	printError(err)
+	os.Exit(1)
+}
+
+func getNextHopFromPathAttributes(attrs []bgp.PathAttributeInterface) net.IP {
+	for _, attr := range attrs {
+		switch a := attr.(type) {
+		case *bgp.PathAttributeNextHop:
+			return a.Value
+		case *bgp.PathAttributeMpReachNLRI:
+			return a.Nexthop
+		}
+	}
+	return nil
+}
diff --git a/cmd/gobgp/cmd/common_test.go b/cmd/gobgp/cmd/common_test.go
new file mode 100644
index 00000000..d7bb87b2
--- /dev/null
+++ b/cmd/gobgp/cmd/common_test.go
@@ -0,0 +1,40 @@
+// 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 cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_ExtractReserved(t *testing.T) {
+	assert := assert.New(t)
+	args := strings.Split("10 rt 100:100 med 10 nexthop 10.0.0.1 aigp metric 10 local-pref 100", " ")
+	keys := map[string]int{
+		"rt":         PARAM_LIST,
+		"med":        PARAM_SINGLE,
+		"nexthop":    PARAM_SINGLE,
+		"aigp":       PARAM_LIST,
+		"local-pref": PARAM_SINGLE}
+	m, _ := extractReserved(args, keys)
+	assert.True(len(m["rt"]) == 1)
+	assert.True(len(m["med"]) == 1)
+	assert.True(len(m["nexthop"]) == 1)
+	assert.True(len(m["aigp"]) == 2)
+	assert.True(len(m["local-pref"]) == 1)
+}
diff --git a/cmd/gobgp/cmd/global.go b/cmd/gobgp/cmd/global.go
new file mode 100644
index 00000000..4559f4ac
--- /dev/null
+++ b/cmd/gobgp/cmd/global.go
@@ -0,0 +1,1654 @@
+// 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 cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"net"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	api "github.com/osrg/gobgp/api"
+	"github.com/osrg/gobgp/internal/pkg/config"
+	"github.com/osrg/gobgp/internal/pkg/table"
+
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+)
+
+type ExtCommType int
+
+const (
+	ACCEPT ExtCommType = iota
+	DISCARD
+	RATE
+	REDIRECT
+	MARK
+	ACTION
+	RT
+	ENCAP
+	ESI_LABEL
+	ROUTER_MAC
+	DEFAULT_GATEWAY
+	VALID
+	NOT_FOUND
+	INVALID
+)
+
+var ExtCommNameMap = map[ExtCommType]string{
+	ACCEPT:          "accept",
+	DISCARD:         "discard",
+	RATE:            "rate-limit",
+	REDIRECT:        "redirect",
+	MARK:            "mark",
+	ACTION:          "action",
+	RT:              "rt",
+	ENCAP:           "encap",
+	ESI_LABEL:       "esi-label",
+	ROUTER_MAC:      "router-mac",
+	DEFAULT_GATEWAY: "default-gateway",
+	VALID:           "valid",
+	NOT_FOUND:       "not-found",
+	INVALID:         "invalid",
+}
+
+var ExtCommValueMap = map[string]ExtCommType{
+	ExtCommNameMap[ACCEPT]:          ACCEPT,
+	ExtCommNameMap[DISCARD]:         DISCARD,
+	ExtCommNameMap[RATE]:            RATE,
+	ExtCommNameMap[REDIRECT]:        REDIRECT,
+	ExtCommNameMap[MARK]:            MARK,
+	ExtCommNameMap[ACTION]:          ACTION,
+	ExtCommNameMap[RT]:              RT,
+	ExtCommNameMap[ENCAP]:           ENCAP,
+	ExtCommNameMap[ESI_LABEL]:       ESI_LABEL,
+	ExtCommNameMap[ROUTER_MAC]:      ROUTER_MAC,
+	ExtCommNameMap[DEFAULT_GATEWAY]: DEFAULT_GATEWAY,
+	ExtCommNameMap[VALID]:           VALID,
+	ExtCommNameMap[NOT_FOUND]:       NOT_FOUND,
+	ExtCommNameMap[INVALID]:         INVALID,
+}
+
+func rateLimitParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	exp := regexp.MustCompile(fmt.Sprintf("^(%s|(%s) (\\d+)(\\.(\\d+))?)( as (\\d+))?$", ExtCommNameMap[DISCARD], ExtCommNameMap[RATE]))
+	elems := exp.FindStringSubmatch(strings.Join(args, " "))
+	if len(elems) != 8 {
+		return nil, fmt.Errorf("invalid rate-limit")
+	}
+	var rate float32
+	var as uint64
+	if elems[2] == ExtCommNameMap[RATE] {
+		f, err := strconv.ParseFloat(elems[3]+elems[4], 32)
+		if err != nil {
+			return nil, err
+		}
+		rate = float32(f)
+	}
+	if elems[7] != "" {
+		var err error
+		as, err = strconv.ParseUint(elems[7], 10, 16)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return []bgp.ExtendedCommunityInterface{bgp.NewTrafficRateExtended(uint16(as), rate)}, nil
+}
+
+func redirectParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 2 || args[0] != ExtCommNameMap[REDIRECT] {
+		return nil, fmt.Errorf("invalid redirect")
+	}
+	rt, err := bgp.ParseRouteTarget(strings.Join(args[1:], " "))
+	if err != nil {
+		return nil, err
+	}
+	switch rt.(type) {
+	case *bgp.TwoOctetAsSpecificExtended:
+		r := rt.(*bgp.TwoOctetAsSpecificExtended)
+		return []bgp.ExtendedCommunityInterface{bgp.NewRedirectTwoOctetAsSpecificExtended(r.AS, r.LocalAdmin)}, nil
+	case *bgp.IPv4AddressSpecificExtended:
+		r := rt.(*bgp.IPv4AddressSpecificExtended)
+		return []bgp.ExtendedCommunityInterface{bgp.NewRedirectIPv4AddressSpecificExtended(r.IPv4.String(), r.LocalAdmin)}, nil
+	case *bgp.FourOctetAsSpecificExtended:
+		r := rt.(*bgp.FourOctetAsSpecificExtended)
+		return []bgp.ExtendedCommunityInterface{bgp.NewRedirectFourOctetAsSpecificExtended(r.AS, r.LocalAdmin)}, nil
+	case *bgp.IPv6AddressSpecificExtended:
+		r := rt.(*bgp.IPv6AddressSpecificExtended)
+		return []bgp.ExtendedCommunityInterface{bgp.NewRedirectIPv6AddressSpecificExtended(r.IPv6.String(), r.LocalAdmin)}, nil
+	}
+	return nil, fmt.Errorf("invalid redirect")
+}
+
+func markParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 2 || args[0] != ExtCommNameMap[MARK] {
+		return nil, fmt.Errorf("invalid mark")
+	}
+	dscp, err := strconv.ParseUint(args[1], 10, 8)
+	if err != nil {
+		return nil, fmt.Errorf("invalid mark")
+	}
+	return []bgp.ExtendedCommunityInterface{bgp.NewTrafficRemarkExtended(uint8(dscp))}, nil
+}
+
+func actionParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 2 || args[0] != ExtCommNameMap[ACTION] {
+		return nil, fmt.Errorf("invalid action")
+	}
+	sample := false
+	terminal := false
+	switch args[1] {
+	case "sample":
+		sample = true
+	case "terminal":
+		terminal = true
+	case "terminal-sample", "sample-terminal":
+		sample = true
+		terminal = true
+	default:
+		return nil, fmt.Errorf("invalid action")
+	}
+	return []bgp.ExtendedCommunityInterface{bgp.NewTrafficActionExtended(terminal, sample)}, nil
+}
+
+func rtParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 2 || args[0] != ExtCommNameMap[RT] {
+		return nil, fmt.Errorf("invalid rt")
+	}
+	exts := make([]bgp.ExtendedCommunityInterface, 0, len(args[1:]))
+	for _, arg := range args[1:] {
+		rt, err := bgp.ParseRouteTarget(arg)
+		if err != nil {
+			return nil, err
+		}
+		exts = append(exts, rt)
+	}
+	return exts, nil
+}
+
+func encapParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 2 || args[0] != ExtCommNameMap[ENCAP] {
+		return nil, fmt.Errorf("invalid encap")
+	}
+	var typ bgp.TunnelType
+	switch args[1] {
+	case "l2tpv3":
+		typ = bgp.TUNNEL_TYPE_L2TP3
+	case "gre":
+		typ = bgp.TUNNEL_TYPE_GRE
+	case "ip-in-ip":
+		typ = bgp.TUNNEL_TYPE_IP_IN_IP
+	case "vxlan":
+		typ = bgp.TUNNEL_TYPE_VXLAN
+	case "nvgre":
+		typ = bgp.TUNNEL_TYPE_NVGRE
+	case "mpls":
+		typ = bgp.TUNNEL_TYPE_MPLS
+	case "mpls-in-gre":
+		typ = bgp.TUNNEL_TYPE_MPLS_IN_GRE
+	case "vxlan-gre":
+		typ = bgp.TUNNEL_TYPE_VXLAN_GRE
+	default:
+		return nil, fmt.Errorf("invalid encap type")
+	}
+	return []bgp.ExtendedCommunityInterface{bgp.NewEncapExtended(typ)}, nil
+}
+
+func esiLabelParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 2 || args[0] != ExtCommNameMap[ESI_LABEL] {
+		return nil, fmt.Errorf("invalid esi-label")
+	}
+	label, err := strconv.ParseUint(args[1], 10, 32)
+	if err != nil {
+		return nil, err
+	}
+	isSingleActive := false
+	if len(args) > 2 {
+		switch args[2] {
+		case "single-active":
+			isSingleActive = true
+		case "all-active":
+			// isSingleActive = false
+		default:
+			return nil, fmt.Errorf("invalid esi-label")
+		}
+	}
+	o := &bgp.ESILabelExtended{
+		Label:          uint32(label),
+		IsSingleActive: isSingleActive,
+	}
+	return []bgp.ExtendedCommunityInterface{o}, nil
+}
+
+func routerMacParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 2 || args[0] != ExtCommNameMap[ROUTER_MAC] {
+		return nil, fmt.Errorf("invalid router's mac")
+	}
+	hw, err := net.ParseMAC(args[1])
+	if err != nil {
+		return nil, err
+	}
+	o := &bgp.RouterMacExtended{Mac: hw}
+	return []bgp.ExtendedCommunityInterface{o}, nil
+}
+
+func defaultGatewayParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 1 || args[0] != ExtCommNameMap[DEFAULT_GATEWAY] {
+		return nil, fmt.Errorf("invalid default-gateway")
+	}
+	return []bgp.ExtendedCommunityInterface{bgp.NewDefaultGatewayExtended()}, nil
+}
+
+func validationParser(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	if len(args) < 1 {
+		return nil, fmt.Errorf("invalid validation state")
+	}
+	var typ bgp.ValidationState
+	switch args[0] {
+	case "valid":
+		typ = bgp.VALIDATION_STATE_VALID
+	case "not-found":
+		typ = bgp.VALIDATION_STATE_NOT_FOUND
+	case "invalid":
+		typ = bgp.VALIDATION_STATE_INVALID
+	default:
+		return nil, fmt.Errorf("invalid validation state")
+	}
+	return []bgp.ExtendedCommunityInterface{bgp.NewValidationExtended(typ)}, nil
+}
+
+var ExtCommParserMap = map[ExtCommType]func([]string) ([]bgp.ExtendedCommunityInterface, error){
+	ACCEPT:          nil,
+	DISCARD:         rateLimitParser,
+	RATE:            rateLimitParser,
+	REDIRECT:        redirectParser,
+	MARK:            markParser,
+	ACTION:          actionParser,
+	RT:              rtParser,
+	ENCAP:           encapParser,
+	ESI_LABEL:       esiLabelParser,
+	ROUTER_MAC:      routerMacParser,
+	DEFAULT_GATEWAY: defaultGatewayParser,
+	VALID:           validationParser,
+	NOT_FOUND:       validationParser,
+	INVALID:         validationParser,
+}
+
+func ParseExtendedCommunities(args []string) ([]bgp.ExtendedCommunityInterface, error) {
+	idxs := make([]struct {
+		t ExtCommType
+		i int
+	}, 0, len(ExtCommNameMap))
+	for idx, v := range args {
+		if t, ok := ExtCommValueMap[v]; ok {
+			idxs = append(idxs, struct {
+				t ExtCommType
+				i int
+			}{t, idx})
+		}
+	}
+	exts := make([]bgp.ExtendedCommunityInterface, 0, len(idxs))
+	for i, idx := range idxs {
+		var a []string
+		f := ExtCommParserMap[idx.t]
+		if i < len(idxs)-1 {
+			a = args[:idxs[i+1].i-idx.i]
+			args = args[(idxs[i+1].i - idx.i):]
+		} else {
+			a = args
+			args = nil
+		}
+		if f == nil {
+			continue
+		}
+		ext, err := f(a)
+		if err != nil {
+			return nil, err
+		}
+		exts = append(exts, ext...)
+	}
+	if len(args) > 0 {
+		return nil, fmt.Errorf("failed to parse %v", args)
+	}
+	return exts, nil
+}
+
+func ParseFlowSpecArgs(rf bgp.RouteFamily, args []string) (bgp.AddrPrefixInterface, []string, error) {
+	// Format:
+	// match <rule>... [then <action>...] [rd <rd>] [rt <rt>...]
+	req := 3 // match <key1> <arg1> [<key2> <arg2>...]
+	if len(args) < req {
+		return nil, nil, fmt.Errorf("%d args required at least, but got %d", req, len(args))
+	}
+	m, err := extractReserved(args, map[string]int{
+		"match": PARAM_LIST,
+		"then":  PARAM_LIST,
+		"rd":    PARAM_SINGLE,
+		"rt":    PARAM_LIST})
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(m["match"]) == 0 {
+		return nil, nil, fmt.Errorf("specify filtering rules with keyword 'match'")
+	}
+
+	var rd bgp.RouteDistinguisherInterface
+	extcomms := m["then"]
+	switch rf {
+	case bgp.RF_FS_IPv4_VPN, bgp.RF_FS_IPv6_VPN, bgp.RF_FS_L2_VPN:
+		if len(m["rd"]) == 0 {
+			return nil, nil, fmt.Errorf("specify rd")
+		}
+		var err error
+		if rd, err = bgp.ParseRouteDistinguisher(m["rd"][0]); err != nil {
+			return nil, nil, fmt.Errorf("invalid rd: %s", m["rd"][0])
+		}
+		if len(m["rt"]) > 0 {
+			extcomms = append(extcomms, "rt")
+			extcomms = append(extcomms, m["rt"]...)
+		}
+	default:
+		if len(m["rd"]) > 0 {
+			return nil, nil, fmt.Errorf("cannot specify rd for %s", rf.String())
+		}
+		if len(m["rt"]) > 0 {
+			return nil, nil, fmt.Errorf("cannot specify rt for %s", rf.String())
+		}
+	}
+
+	rules, err := bgp.ParseFlowSpecComponents(rf, strings.Join(m["match"], " "))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var nlri bgp.AddrPrefixInterface
+	switch rf {
+	case bgp.RF_FS_IPv4_UC:
+		nlri = bgp.NewFlowSpecIPv4Unicast(rules)
+	case bgp.RF_FS_IPv6_UC:
+		nlri = bgp.NewFlowSpecIPv6Unicast(rules)
+	case bgp.RF_FS_IPv4_VPN:
+		nlri = bgp.NewFlowSpecIPv4VPN(rd, rules)
+	case bgp.RF_FS_IPv6_VPN:
+		nlri = bgp.NewFlowSpecIPv6VPN(rd, rules)
+	case bgp.RF_FS_L2_VPN:
+		nlri = bgp.NewFlowSpecL2VPN(rd, rules)
+	default:
+		return nil, nil, fmt.Errorf("invalid route family")
+	}
+
+	return nlri, extcomms, nil
+}
+
+func ParseEvpnEthernetAutoDiscoveryArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
+	// Format:
+	// esi <esi> etag <etag> label <label> rd <rd> [rt <rt>...] [encap <encap type>] [esi-label <esi-label> [single-active | all-active]]
+	req := 8
+	if len(args) < req {
+		return nil, nil, fmt.Errorf("%d args required at least, but got %d", req, len(args))
+	}
+	m, err := extractReserved(args, map[string]int{
+		"esi":       PARAM_LIST,
+		"etag":      PARAM_SINGLE,
+		"label":     PARAM_SINGLE,
+		"rd":        PARAM_SINGLE,
+		"rt":        PARAM_LIST,
+		"encap":     PARAM_SINGLE,
+		"esi-label": PARAM_SINGLE})
+	if err != nil {
+		return nil, nil, err
+	}
+	for _, f := range []string{"esi", "etag", "label", "rd"} {
+		for len(m[f]) == 0 {
+			return nil, nil, fmt.Errorf("specify %s", f)
+		}
+	}
+
+	esi, err := bgp.ParseEthernetSegmentIdentifier(m["esi"])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	e, err := strconv.ParseUint(m["etag"][0], 10, 32)
+	if err != nil {
+		return nil, nil, err
+	}
+	etag := uint32(e)
+
+	l, err := strconv.ParseUint(m["label"][0], 10, 32)
+	if err != nil {
+		return nil, nil, err
+	}
+	label := uint32(l)
+
+	rd, err := bgp.ParseRouteDistinguisher(m["rd"][0])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	extcomms := make([]string, 0)
+	if len(m["rt"]) > 0 {
+		extcomms = append(extcomms, "rt")
+		extcomms = append(extcomms, m["rt"]...)
+	}
+	if len(m["encap"]) > 0 {
+		extcomms = append(extcomms, "encap", m["encap"][0])
+	}
+	if len(m["esi-label"]) > 0 {
+		extcomms = append(extcomms, "esi-label")
+		extcomms = append(extcomms, m["esi-label"]...)
+	}
+
+	r := &bgp.EVPNEthernetAutoDiscoveryRoute{
+		RD:    rd,
+		ESI:   esi,
+		ETag:  etag,
+		Label: label,
+	}
+	return bgp.NewEVPNNLRI(bgp.EVPN_ROUTE_TYPE_ETHERNET_AUTO_DISCOVERY, r), extcomms, nil
+}
+
+func ParseEvpnMacAdvArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
+	// Format:
+	// <mac address> <ip address> [esi <esi>] etag <etag> label <label> rd <rd> [rt <rt>...] [encap <encap type>] [router-mac <mac address>] [default-gateway]
+	// or
+	// <mac address> <ip address> <etag> [esi <esi>] label <label> rd <rd> [rt <rt>...] [encap <encap type>] [router-mac <mac address>] [default-gateway]
+	// or
+	// <mac address> <ip address> <etag> <label> [esi <esi>] rd <rd> [rt <rt>...] [encap <encap type>] [router-mac <mac address>] [default-gateway]
+	req := 6
+	if len(args) < req {
+		return nil, nil, fmt.Errorf("%d args required at least, but got %d", req, len(args))
+	}
+	m, err := extractReserved(args, map[string]int{
+		"esi":        PARAM_LIST,
+		"etag":       PARAM_SINGLE,
+		"label":      PARAM_SINGLE,
+		"rd":         PARAM_SINGLE,
+		"rt":         PARAM_LIST,
+		"encap":      PARAM_SINGLE,
+		"router-mac": PARAM_SINGLE})
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(m[""]) < 2 {
+		return nil, nil, fmt.Errorf("specify mac and ip address")
+	}
+	macStr := m[""][0]
+	ipStr := m[""][1]
+	eTagStr := ""
+	labelStr := ""
+	if len(m[""]) == 2 {
+		if len(m["etag"]) == 0 || len(m["label"]) == 0 {
+			return nil, nil, fmt.Errorf("specify etag and label")
+		}
+		eTagStr = m["etag"][0]
+		labelStr = m["label"][0]
+	} else if len(m[""]) == 3 {
+		if len(m["label"]) == 0 {
+			return nil, nil, fmt.Errorf("specify label")
+		}
+		eTagStr = m[""][2]
+		labelStr = m["label"][0]
+	} else {
+		eTagStr = m[""][2]
+		labelStr = m[""][3]
+	}
+	if len(m["rd"]) == 0 {
+		return nil, nil, fmt.Errorf("specify rd")
+	}
+
+	mac, err := net.ParseMAC(macStr)
+	if err != nil {
+		return nil, nil, fmt.Errorf("invalid mac address: %s", macStr)
+	}
+
+	ip := net.ParseIP(ipStr)
+	ipLen := 0
+	if ip == nil {
+		return nil, nil, fmt.Errorf("invalid ip address: %s", ipStr)
+	} else if ip.IsUnspecified() {
+		ip = nil
+	} else if ip.To4() != nil {
+		ipLen = net.IPv4len * 8
+	} else {
+		ipLen = net.IPv6len * 8
+	}
+
+	esi, err := bgp.ParseEthernetSegmentIdentifier(m["esi"])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	eTag, err := strconv.ParseUint(eTagStr, 10, 32)
+	if err != nil {
+		return nil, nil, fmt.Errorf("invalid etag: %s: %s", eTagStr, err)
+	}
+
+	var labels []uint32
+	for _, l := range strings.SplitN(labelStr, ",", 2) {
+		label, err := strconv.ParseUint(l, 10, 32)
+		if err != nil {
+			return nil, nil, fmt.Errorf("invalid label: %s: %s", labelStr, err)
+		}
+		labels = append(labels, uint32(label))
+	}
+
+	rd, err := bgp.ParseRouteDistinguisher(m["rd"][0])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	extcomms := make([]string, 0)
+	if len(m["rt"]) > 0 {
+		extcomms = append(extcomms, "rt")
+		extcomms = append(extcomms, m["rt"]...)
+	}
+	if len(m["encap"]) > 0 {
+		extcomms = append(extcomms, "encap", m["encap"][0])
+	}
+
+	if len(m["router-mac"]) != 0 {
+		_, err := net.ParseMAC(m["router-mac"][0])
+		if err != nil {
+			return nil, nil, fmt.Errorf("invalid router-mac address: %s", m["router-mac"][0])
+		}
+		extcomms = append(extcomms, "router-mac", m["router-mac"][0])
+	}
+
+	for _, a := range args {
+		if a == "default-gateway" {
+			extcomms = append(extcomms, "default-gateway")
+			break
+		}
+	}
+
+	r := &bgp.EVPNMacIPAdvertisementRoute{
+		RD:               rd,
+		ESI:              esi,
+		MacAddressLength: 48,
+		MacAddress:       mac,
+		IPAddressLength:  uint8(ipLen),
+		IPAddress:        ip,
+		Labels:           labels,
+		ETag:             uint32(eTag),
+	}
+	return bgp.NewEVPNNLRI(bgp.EVPN_ROUTE_TYPE_MAC_IP_ADVERTISEMENT, r), extcomms, nil
+}
+
+func ParseEvpnMulticastArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
+	// Format:
+	// <ip address> etag <etag> rd <rd> [rt <rt>...] [encap <encap type>]
+	// or
+	// <ip address> <etag> rd <rd> [rt <rt>...] [encap <encap type>]
+	req := 4
+	if len(args) < req {
+		return nil, nil, fmt.Errorf("%d args required at least, but got %d", req, len(args))
+	}
+	m, err := extractReserved(args, map[string]int{
+		"etag":  PARAM_SINGLE,
+		"rd":    PARAM_SINGLE,
+		"rt":    PARAM_LIST,
+		"encap": PARAM_SINGLE})
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(m[""]) < 1 {
+		return nil, nil, fmt.Errorf("specify ip address")
+	}
+	ipStr := m[""][0]
+	eTagStr := ""
+	if len(m[""]) == 1 {
+		if len(m["etag"]) == 0 {
+			return nil, nil, fmt.Errorf("specify etag")
+		}
+		eTagStr = m["etag"][0]
+	} else {
+		eTagStr = m[""][1]
+	}
+	if len(m["rd"]) == 0 {
+		return nil, nil, fmt.Errorf("specify rd")
+	}
+
+	ip := net.ParseIP(ipStr)
+	ipLen := 0
+	if ip == nil {
+		return nil, nil, fmt.Errorf("invalid ip address: %s", ipStr)
+	} else if ip.IsUnspecified() {
+		ip = nil
+	} else if ip.To4() != nil {
+		ipLen = net.IPv4len * 8
+	} else {
+		ipLen = net.IPv6len * 8
+	}
+
+	eTag, err := strconv.ParseUint(eTagStr, 10, 32)
+	if err != nil {
+		return nil, nil, fmt.Errorf("invalid etag: %s: %s", eTagStr, err)
+	}
+
+	rd, err := bgp.ParseRouteDistinguisher(m["rd"][0])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	extcomms := make([]string, 0)
+	if len(m["rt"]) > 0 {
+		extcomms = append(extcomms, "rt")
+		extcomms = append(extcomms, m["rt"]...)
+	}
+	if len(m["encap"]) > 0 {
+		extcomms = append(extcomms, "encap", m["encap"][0])
+	}
+
+	r := &bgp.EVPNMulticastEthernetTagRoute{
+		RD:              rd,
+		IPAddressLength: uint8(ipLen),
+		IPAddress:       ip,
+		ETag:            uint32(eTag),
+	}
+	return bgp.NewEVPNNLRI(bgp.EVPN_INCLUSIVE_MULTICAST_ETHERNET_TAG, r), extcomms, nil
+}
+
+func ParseEvpnEthernetSegmentArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
+	// Format:
+	// <ip address> esi <esi> rd <rd> [rt <rt>...] [encap <encap type>]
+	req := 5
+	if len(args) < req {
+		return nil, nil, fmt.Errorf("%d args required at least, but got %d", req, len(args))
+	}
+	m, err := extractReserved(args, map[string]int{
+		"esi":   PARAM_LIST,
+		"rd":    PARAM_SINGLE,
+		"rt":    PARAM_LIST,
+		"encap": PARAM_SINGLE})
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(m[""]) < 1 {
+		return nil, nil, fmt.Errorf("specify ip address")
+	}
+	for _, f := range []string{"esi", "rd"} {
+		for len(m[f]) == 0 {
+			return nil, nil, fmt.Errorf("specify %s", f)
+		}
+	}
+
+	ip := net.ParseIP(m[""][0])
+	ipLen := 0
+	if ip == nil {
+		return nil, nil, fmt.Errorf("invalid ip address: %s", m[""][0])
+	} else if ip.IsUnspecified() {
+		ip = nil
+	} else if ip.To4() != nil {
+		ipLen = net.IPv4len * 8
+	} else {
+		ipLen = net.IPv6len * 8
+	}
+
+	esi, err := bgp.ParseEthernetSegmentIdentifier(m["esi"])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	rd, err := bgp.ParseRouteDistinguisher(m["rd"][0])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	extcomms := make([]string, 0)
+	if len(m["rt"]) > 0 {
+		extcomms = append(extcomms, "rt")
+		extcomms = append(extcomms, m["rt"]...)
+	}
+	if len(m["encap"]) > 0 {
+		extcomms = append(extcomms, "encap", m["encap"][0])
+	}
+
+	r := &bgp.EVPNEthernetSegmentRoute{
+		RD:              rd,
+		ESI:             esi,
+		IPAddressLength: uint8(ipLen),
+		IPAddress:       ip,
+	}
+	return bgp.NewEVPNNLRI(bgp.EVPN_ETHERNET_SEGMENT_ROUTE, r), extcomms, nil
+}
+
+func ParseEvpnIPPrefixArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
+	// Format:
+	// <ip prefix> [gw <gateway>] [esi <esi>] etag <etag> [label <label>] rd <rd> [rt <rt>...] [encap <encap type>]
+	req := 5
+	if len(args) < req {
+		return nil, nil, fmt.Errorf("%d args required at least, but got %d", req, len(args))
+	}
+	m, err := extractReserved(args, map[string]int{
+		"gw":         PARAM_SINGLE,
+		"esi":        PARAM_LIST,
+		"etag":       PARAM_SINGLE,
+		"label":      PARAM_SINGLE,
+		"rd":         PARAM_SINGLE,
+		"rt":         PARAM_LIST,
+		"encap":      PARAM_SINGLE,
+		"router-mac": PARAM_SINGLE})
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(m[""]) < 1 {
+		return nil, nil, fmt.Errorf("specify prefix")
+	}
+	for _, f := range []string{"etag", "rd"} {
+		for len(m[f]) == 0 {
+			return nil, nil, fmt.Errorf("specify %s", f)
+		}
+	}
+
+	_, nw, err := net.ParseCIDR(m[""][0])
+	if err != nil {
+		return nil, nil, err
+	}
+	ones, _ := nw.Mask.Size()
+
+	var gw net.IP
+	if len(m["gw"]) > 0 {
+		gw = net.ParseIP(m["gw"][0])
+	}
+
+	rd, err := bgp.ParseRouteDistinguisher(m["rd"][0])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	esi, err := bgp.ParseEthernetSegmentIdentifier(m["esi"])
+	if err != nil {
+		return nil, nil, err
+	}
+
+	e, err := strconv.ParseUint(m["etag"][0], 10, 32)
+	if err != nil {
+		return nil, nil, fmt.Errorf("invalid etag: %s: %s", m["etag"][0], err)
+	}
+	etag := uint32(e)
+
+	var label uint32
+	if len(m["label"]) > 0 {
+		e, err := strconv.ParseUint(m["label"][0], 10, 32)
+		if err != nil {
+			return nil, nil, fmt.Errorf("invalid label: %s: %s", m["label"][0], err)
+		}
+		label = uint32(e)
+	}
+
+	extcomms := make([]string, 0)
+	if len(m["rt"]) > 0 {
+		extcomms = append(extcomms, "rt")
+		extcomms = append(extcomms, m["rt"]...)
+	}
+	if len(m["encap"]) > 0 {
+		extcomms = append(extcomms, "encap", m["encap"][0])
+	}
+	if len(m["router-mac"]) > 0 {
+		extcomms = append(extcomms, "router-mac", m["router-mac"][0])
+	}
+
+	r := &bgp.EVPNIPPrefixRoute{
+		RD:             rd,
+		ESI:            esi,
+		ETag:           etag,
+		IPPrefixLength: uint8(ones),
+		IPPrefix:       nw.IP,
+		GWIPAddress:    gw,
+		Label:          label,
+	}
+	return bgp.NewEVPNNLRI(bgp.EVPN_IP_PREFIX, r), extcomms, nil
+}
+
+func ParseEvpnArgs(args []string) (bgp.AddrPrefixInterface, []string, error) {
+	if len(args) < 1 {
+		return nil, nil, fmt.Errorf("lack of args. need 1 but %d", len(args))
+	}
+	subtype := args[0]
+	args = args[1:]
+	switch subtype {
+	case "a-d":
+		return ParseEvpnEthernetAutoDiscoveryArgs(args)
+	case "macadv":
+		return ParseEvpnMacAdvArgs(args)
+	case "multicast":
+		return ParseEvpnMulticastArgs(args)
+	case "esi":
+		return ParseEvpnEthernetSegmentArgs(args)
+	case "prefix":
+		return ParseEvpnIPPrefixArgs(args)
+	}
+	return nil, nil, fmt.Errorf("invalid subtype. expect [macadv|multicast|prefix] but %s", subtype)
+}
+
+func extractOrigin(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	typ := bgp.BGP_ORIGIN_ATTR_TYPE_INCOMPLETE
+	for idx, arg := range args {
+		if arg == "origin" && len(args) > (idx+1) {
+			switch args[idx+1] {
+			case "igp":
+				typ = bgp.BGP_ORIGIN_ATTR_TYPE_IGP
+			case "egp":
+				typ = bgp.BGP_ORIGIN_ATTR_TYPE_EGP
+			case "incomplete":
+			default:
+				return nil, nil, fmt.Errorf("invalid origin type. expect [igp|egp|incomplete] but %s", args[idx+1])
+			}
+			args = append(args[:idx], args[idx+2:]...)
+			break
+		}
+	}
+	return args, bgp.NewPathAttributeOrigin(uint8(typ)), nil
+}
+
+func toAs4Value(s string) (uint32, error) {
+	if strings.Contains(s, ".") {
+		v := strings.Split(s, ".")
+		upper, err := strconv.ParseUint(v[0], 10, 16)
+		if err != nil {
+			return 0, nil
+		}
+		lower, err := strconv.ParseUint(v[1], 10, 16)
+		if err != nil {
+			return 0, nil
+		}
+		return uint32(upper<<16 | lower), nil
+	}
+	i, err := strconv.ParseUint(s, 10, 32)
+	if err != nil {
+		return 0, err
+	}
+	return uint32(i), nil
+}
+
+var (
+	_regexpASPathGroups  = regexp.MustCompile("[{}]")
+	_regexpASPathSegment = regexp.MustCompile(`,|\s+`)
+)
+
+func newAsPath(aspath string) (bgp.PathAttributeInterface, error) {
+	// For the first step, parses "aspath" into a list of uint32 list.
+	// e.g.) "10 20 {30,40} 50" -> [][]uint32{{10, 20}, {30, 40}, {50}}
+	segments := _regexpASPathGroups.Split(aspath, -1)
+	asPathPrams := make([]bgp.AsPathParamInterface, 0, len(segments))
+	for idx, segment := range segments {
+		if segment == "" {
+			continue
+		}
+		nums := _regexpASPathSegment.Split(segment, -1)
+		asNums := make([]uint32, 0, len(nums))
+		for _, n := range nums {
+			if n == "" {
+				continue
+			}
+			if asn, err := toAs4Value(n); err != nil {
+				return nil, err
+			} else {
+				asNums = append(asNums, uint32(asn))
+			}
+		}
+		// Assumes "idx" is even, the given "segment" is of type AS_SEQUENCE,
+		// otherwise AS_SET, because the "segment" enclosed in parentheses is
+		// of type AS_SET.
+		if idx%2 == 0 {
+			asPathPrams = append(asPathPrams, bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SEQ, asNums))
+		} else {
+			asPathPrams = append(asPathPrams, bgp.NewAs4PathParam(bgp.BGP_ASPATH_ATTR_TYPE_SET, asNums))
+		}
+	}
+	return bgp.NewPathAttributeAsPath(asPathPrams), nil
+}
+
+func extractAsPath(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	for idx, arg := range args {
+		if arg == "aspath" && len(args) > (idx+1) {
+			attr, err := newAsPath(args[idx+1])
+			if err != nil {
+				return nil, nil, err
+			}
+			args = append(args[:idx], args[idx+2:]...)
+			return args, attr, nil
+		}
+	}
+	return args, nil, nil
+}
+
+func extractNexthop(rf bgp.RouteFamily, args []string) ([]string, string, error) {
+	afi, _ := bgp.RouteFamilyToAfiSafi(rf)
+	nexthop := "0.0.0.0"
+	if afi == bgp.AFI_IP6 {
+		nexthop = "::"
+	}
+	for idx, arg := range args {
+		if arg == "nexthop" && len(args) > (idx+1) {
+			if net.ParseIP(args[idx+1]) == nil {
+				return nil, "", fmt.Errorf("invalid nexthop address")
+			}
+			nexthop = args[idx+1]
+			args = append(args[:idx], args[idx+2:]...)
+			break
+		}
+	}
+	return args, nexthop, nil
+}
+
+func extractLocalPref(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	for idx, arg := range args {
+		if arg == "local-pref" && len(args) > (idx+1) {
+			metric, err := strconv.ParseUint(args[idx+1], 10, 32)
+			if err != nil {
+				return nil, nil, err
+			}
+			args = append(args[:idx], args[idx+2:]...)
+			return args, bgp.NewPathAttributeLocalPref(uint32(metric)), nil
+		}
+	}
+	return args, nil, nil
+}
+
+func extractMed(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	for idx, arg := range args {
+		if arg == "med" && len(args) > (idx+1) {
+			med, err := strconv.ParseUint(args[idx+1], 10, 32)
+			if err != nil {
+				return nil, nil, err
+			}
+			args = append(args[:idx], args[idx+2:]...)
+			return args, bgp.NewPathAttributeMultiExitDisc(uint32(med)), nil
+		}
+	}
+	return args, nil, nil
+}
+
+func extractCommunity(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	for idx, arg := range args {
+		if arg == "community" && len(args) > (idx+1) {
+			elems := strings.Split(args[idx+1], ",")
+			comms := make([]uint32, 0, 1)
+			for _, elem := range elems {
+				c, err := table.ParseCommunity(elem)
+				if err != nil {
+					return nil, nil, err
+				}
+				comms = append(comms, c)
+			}
+			args = append(args[:idx], args[idx+2:]...)
+			return args, bgp.NewPathAttributeCommunities(comms), nil
+		}
+	}
+	return args, nil, nil
+}
+
+func extractLargeCommunity(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	for idx, arg := range args {
+		if arg == "large-community" && len(args) > (idx+1) {
+			elems := strings.Split(args[idx+1], ",")
+			comms := make([]*bgp.LargeCommunity, 0, 1)
+			for _, elem := range elems {
+				c, err := bgp.ParseLargeCommunity(elem)
+				if err != nil {
+					return nil, nil, err
+				}
+				comms = append(comms, c)
+			}
+			args = append(args[:idx], args[idx+2:]...)
+			return args, bgp.NewPathAttributeLargeCommunities(comms), nil
+		}
+	}
+	return args, nil, nil
+}
+
+func extractPmsiTunnel(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	for idx, arg := range args {
+		if arg == "pmsi" {
+			pmsi, err := bgp.ParsePmsiTunnel(args[idx+1:])
+			if err != nil {
+				return nil, nil, err
+			}
+			if pmsi.IsLeafInfoRequired {
+				return append(args[:idx], args[idx+5:]...), pmsi, nil
+			}
+			return append(args[:idx], args[idx+4:]...), pmsi, nil
+		}
+	}
+	return args, nil, nil
+}
+
+func extractAigp(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	for idx, arg := range args {
+		if arg == "aigp" {
+			if len(args) < (idx + 3) {
+				return nil, nil, fmt.Errorf("invalid aigp format")
+			}
+			typ := args[idx+1]
+			switch typ {
+			case "metric":
+				metric, err := strconv.ParseUint(args[idx+2], 10, 64)
+				if err != nil {
+					return nil, nil, err
+				}
+				aigp := bgp.NewPathAttributeAigp([]bgp.AigpTLVInterface{bgp.NewAigpTLVIgpMetric(uint64(metric))})
+				return append(args[:idx], args[idx+3:]...), aigp, nil
+			default:
+				return nil, nil, fmt.Errorf("unknown aigp type: %s", typ)
+			}
+		}
+	}
+	return args, nil, nil
+}
+
+func extractAggregator(args []string) ([]string, bgp.PathAttributeInterface, error) {
+	for idx, arg := range args {
+		if arg == "aggregator" {
+			if len(args) < (idx + 1) {
+				return nil, nil, fmt.Errorf("invalid aggregator format")
+			}
+			v := strings.SplitN(args[idx+1], ":", 2)
+			if len(v) != 2 {
+				return nil, nil, fmt.Errorf("invalid aggregator format")
+			}
+			as, err := strconv.ParseUint(v[0], 10, 32)
+			if err != nil {
+				return nil, nil, fmt.Errorf("invalid aggregator format")
+			}
+			attr := bgp.NewPathAttributeAggregator(uint32(as), net.ParseIP(v[1]).String())
+			return append(args[:idx], args[idx+2:]...), attr, nil
+		}
+	}
+	return args, nil, nil
+}
+
+func ParsePath(rf bgp.RouteFamily, args []string) (*api.Path, error) {
+	var nlri bgp.AddrPrefixInterface
+	var extcomms []string
+	var err error
+	attrs := make([]bgp.PathAttributeInterface, 0, 1)
+
+	fns := []func([]string) ([]string, bgp.PathAttributeInterface, error){
+		extractOrigin,         // 1 ORIGIN
+		extractAsPath,         // 2 AS_PATH
+		extractMed,            // 4 MULTI_EXIT_DISC
+		extractLocalPref,      // 5 LOCAL_PREF
+		extractAggregator,     // 7 AGGREGATOR
+		extractCommunity,      // 8 COMMUNITY
+		extractPmsiTunnel,     // 22 PMSI_TUNNEL
+		extractAigp,           // 26 AIGP
+		extractLargeCommunity, // 32 LARGE_COMMUNITY
+	}
+
+	for _, fn := range fns {
+		var a bgp.PathAttributeInterface
+		args, a, err = fn(args)
+		if err != nil {
+			return nil, err
+		}
+		if a != nil {
+			attrs = append(attrs, a)
+		}
+	}
+
+	args, nexthop, err := extractNexthop(rf, args)
+	if err != nil {
+		return nil, err
+	}
+
+	switch rf {
+	case bgp.RF_IPv4_UC, bgp.RF_IPv6_UC:
+		if len(args) < 1 {
+			return nil, fmt.Errorf("invalid format")
+		}
+		ip, nw, err := net.ParseCIDR(args[0])
+		if err != nil {
+			return nil, err
+		}
+		ones, _ := nw.Mask.Size()
+		if rf == bgp.RF_IPv4_UC {
+			if ip.To4() == nil {
+				return nil, fmt.Errorf("invalid ipv4 prefix")
+			}
+			nlri = bgp.NewIPAddrPrefix(uint8(ones), ip.String())
+		} else {
+			if ip.To16() == nil {
+				return nil, fmt.Errorf("invalid ipv6 prefix")
+			}
+			nlri = bgp.NewIPv6AddrPrefix(uint8(ones), ip.String())
+		}
+
+		if len(args) > 2 && args[1] == "identifier" {
+			id, err := strconv.ParseUint(args[2], 10, 32)
+			if err != nil {
+				return nil, fmt.Errorf("invalid format")
+			}
+			nlri.SetPathIdentifier(uint32(id))
+			extcomms = args[3:]
+		} else {
+			extcomms = args[1:]
+		}
+
+	case bgp.RF_IPv4_VPN, bgp.RF_IPv6_VPN:
+		if len(args) < 5 || args[1] != "label" || args[3] != "rd" {
+			return nil, fmt.Errorf("invalid format")
+		}
+		ip, nw, err := net.ParseCIDR(args[0])
+		if err != nil {
+			return nil, err
+		}
+		ones, _ := nw.Mask.Size()
+
+		label, err := strconv.ParseUint(args[2], 10, 32)
+		if err != nil {
+			return nil, fmt.Errorf("invalid format")
+		}
+		mpls := bgp.NewMPLSLabelStack(uint32(label))
+
+		rd, err := bgp.ParseRouteDistinguisher(args[4])
+		if err != nil {
+			return nil, err
+		}
+
+		extcomms = args[5:]
+
+		if rf == bgp.RF_IPv4_VPN {
+			if ip.To4() == nil {
+				return nil, fmt.Errorf("invalid ipv4 prefix")
+			}
+			nlri = bgp.NewLabeledVPNIPAddrPrefix(uint8(ones), ip.String(), *mpls, rd)
+		} else {
+			if ip.To16() == nil {
+				return nil, fmt.Errorf("invalid ipv6 prefix")
+			}
+			nlri = bgp.NewLabeledVPNIPv6AddrPrefix(uint8(ones), ip.String(), *mpls, rd)
+		}
+	case bgp.RF_IPv4_MPLS, bgp.RF_IPv6_MPLS:
+		if len(args) < 2 {
+			return nil, fmt.Errorf("invalid format")
+		}
+
+		ip, nw, err := net.ParseCIDR(args[0])
+		if err != nil {
+			return nil, err
+		}
+		ones, _ := nw.Mask.Size()
+
+		mpls, err := bgp.ParseMPLSLabelStack(args[1])
+		if err != nil {
+			return nil, err
+		}
+
+		extcomms = args[2:]
+
+		if rf == bgp.RF_IPv4_MPLS {
+			if ip.To4() == nil {
+				return nil, fmt.Errorf("invalid ipv4 prefix")
+			}
+			nlri = bgp.NewLabeledIPAddrPrefix(uint8(ones), ip.String(), *mpls)
+		} else {
+			if ip.To4() != nil {
+				return nil, fmt.Errorf("invalid ipv6 prefix")
+			}
+			nlri = bgp.NewLabeledIPv6AddrPrefix(uint8(ones), ip.String(), *mpls)
+		}
+	case bgp.RF_EVPN:
+		nlri, extcomms, err = ParseEvpnArgs(args)
+	case bgp.RF_FS_IPv4_UC, bgp.RF_FS_IPv4_VPN, bgp.RF_FS_IPv6_UC, bgp.RF_FS_IPv6_VPN, bgp.RF_FS_L2_VPN:
+		nlri, extcomms, err = ParseFlowSpecArgs(rf, args)
+	case bgp.RF_OPAQUE:
+		m, err := extractReserved(args, map[string]int{
+			"key":   PARAM_SINGLE,
+			"value": PARAM_SINGLE})
+		if err != nil {
+			return nil, err
+		}
+		if len(m["key"]) != 1 {
+			return nil, fmt.Errorf("opaque nlri key missing")
+		}
+		if len(m["value"]) > 0 {
+			nlri = bgp.NewOpaqueNLRI([]byte(m["key"][0]), []byte(m["value"][0]))
+		} else {
+			nlri = bgp.NewOpaqueNLRI([]byte(m["key"][0]), nil)
+		}
+	default:
+		return nil, fmt.Errorf("Unsupported route family: %s", rf)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	if rf == bgp.RF_IPv4_UC && net.ParseIP(nexthop).To4() != nil {
+		attrs = append(attrs, bgp.NewPathAttributeNextHop(nexthop))
+	} else {
+		mpreach := bgp.NewPathAttributeMpReachNLRI(nexthop, []bgp.AddrPrefixInterface{nlri})
+		attrs = append(attrs, mpreach)
+	}
+
+	if extcomms != nil {
+		extcomms, err := ParseExtendedCommunities(extcomms)
+		if err != nil {
+			return nil, err
+		}
+		normalextcomms := make([]bgp.ExtendedCommunityInterface, 0)
+		ipv6extcomms := make([]bgp.ExtendedCommunityInterface, 0)
+		for _, com := range extcomms {
+			switch com.(type) {
+			case *bgp.RedirectIPv6AddressSpecificExtended:
+				ipv6extcomms = append(ipv6extcomms, com)
+			default:
+				normalextcomms = append(normalextcomms, com)
+			}
+		}
+		if len(normalextcomms) != 0 {
+			p := bgp.NewPathAttributeExtendedCommunities(normalextcomms)
+			attrs = append(attrs, p)
+		}
+		if len(ipv6extcomms) != 0 {
+			ip6p := bgp.NewPathAttributeIP6ExtendedCommunities(ipv6extcomms)
+			attrs = append(attrs, ip6p)
+		}
+	}
+	sort.Slice(attrs, func(i, j int) bool { return attrs[i].GetType() < attrs[j].GetType() })
+
+	return api.NewPath(nlri, false, attrs, time.Now()), nil
+}
+
+func showGlobalRib(args []string) error {
+	return showNeighborRib(CMD_GLOBAL, "", args)
+}
+
+func modPath(resource string, name, modtype string, args []string) error {
+	rf, err := checkAddressFamily(bgp.RF_IPv4_UC)
+	if err != nil {
+		return err
+	}
+
+	path, err := ParsePath(rf, args)
+	if err != nil {
+		cmdstr := "global"
+		if resource == CMD_VRF {
+			cmdstr = fmt.Sprintf("vrf %s", name)
+		}
+		rdHelpMsgFmt := `
+    <RD> : xxx:yyy, xxx.xxx.xxx.xxx:yyy, xxx.xxx:yyy`
+		ss := make([]string, 0, len(bgp.ProtocolNameMap))
+		for _, v := range bgp.ProtocolNameMap {
+			ss = append(ss, v)
+		}
+		sort.SliceStable(ss, func(i, j int) bool { return ss[i] < ss[j] })
+		ss = append(ss, "<DEC_NUM>")
+		ipProtocols := strings.Join(ss, ", ")
+		ss = make([]string, 0, len(bgp.TCPFlagNameMap))
+		for _, v := range bgp.TCPSortedFlags {
+			ss = append(ss, bgp.TCPFlagNameMap[v])
+		}
+		tcpFlags := strings.Join(ss, ", ")
+		ss = make([]string, 0, len(bgp.EthernetTypeNameMap))
+		for _, v := range bgp.EthernetTypeNameMap {
+			ss = append(ss, v)
+		}
+		sort.SliceStable(ss, func(i, j int) bool { return ss[i] < ss[j] })
+		ss = append(ss, "<DEC_NUM>")
+		etherTypes := strings.Join(ss, ", ")
+		helpErrMap := map[bgp.RouteFamily]error{}
+		baseHelpMsgFmt := fmt.Sprintf(`error: %s
+usage: %s rib -a %%s %s <PREFIX> %%s [origin { igp | egp | incomplete }] [aspath <ASPATH>] [nexthop <ADDRESS>] [med <NUM>] [local-pref <NUM>] [community <COMMUNITY>] [aigp metric <NUM>] [large-community <LARGE_COMMUNITY>] [aggregator <AGGREGATOR>]
+	<ASPATH>: <AS>[,<AS>],
+	<COMMUNITY>: xxx:xxx|internet|planned-shut|accept-own|route-filter-translated-v4|route-filter-v4|route-filter-translated-v6|route-filter-v6|llgr-stale|no-llgr|blackhole|no-export|no-advertise|no-export-subconfed|no-peer,
+	<LARGE_COMMUNITY>: xxx:xxx:xxx[,<LARGE_COMMUNITY>],
+	<AGGREGATOR>: <AS>:<ADDRESS>`,
+			err,
+			cmdstr,
+			// <address family>
+			modtype,
+			// <label, rd>
+		)
+		helpErrMap[bgp.RF_IPv4_UC] = fmt.Errorf(baseHelpMsgFmt, "ipv4", "[identifier <VALUE>]")
+		helpErrMap[bgp.RF_IPv6_UC] = fmt.Errorf(baseHelpMsgFmt, "ipv6", "[identifier <VALUE>]")
+		helpErrMap[bgp.RF_IPv4_VPN] = fmt.Errorf(baseHelpMsgFmt, "vpnv4", "label <LABEL> rd <RD> [rt <RT>]")
+		helpErrMap[bgp.RF_IPv6_VPN] = fmt.Errorf(baseHelpMsgFmt, "vpnv6", "label <LABEL> rd <RD> [rt <RT>]")
+		helpErrMap[bgp.RF_IPv4_MPLS] = fmt.Errorf(baseHelpMsgFmt, "ipv4-mpls", "<LABEL>")
+		helpErrMap[bgp.RF_IPv6_MPLS] = fmt.Errorf(baseHelpMsgFmt, "ipv6-mpls", "<LABEL>")
+
+		fsHelpMsgFmt := fmt.Sprintf(`error: %s
+usage: %s rib -a %%s %s%%s match <MATCH> then <THEN>%%s%%s%%s
+    <THEN> : { %s |
+               %s |
+               %s <RATE> [as <AS>] |
+               %s <RT> |
+               %s <DEC_NUM> |
+               %s { sample | terminal | sample-terminal } }...
+    <RT> : xxx:yyy, xxx.xxx.xxx.xxx:yyy, xxxx::xxxx:yyy, xxx.xxx:yyy`,
+			err,
+			cmdstr,
+			// <address family>
+			modtype,
+			// "" or " rd <RD>"
+			// "" or " [rt <RT>]"
+			// <help message for RD>
+			// <MATCH>
+			ExtCommNameMap[ACCEPT],
+			ExtCommNameMap[DISCARD],
+			ExtCommNameMap[RATE],
+			ExtCommNameMap[REDIRECT],
+			ExtCommNameMap[MARK],
+			ExtCommNameMap[ACTION],
+		)
+		baseFsMatchExpr := fmt.Sprintf(`
+    <MATCH> : { %s <PREFIX> [<OFFSET>] |
+                %s <PREFIX> [<OFFSET>] |
+                %s <PROTOCOLS>... |
+                %s <FRAGMENTS>... |
+                %s <TCP_FLAGS>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... %%s}...
+    <PROTOCOLS> : [&] [<|<=|>|>=|==|!=] <PROTOCOL>
+    <PROTOCOL> : %s
+    <FRAGMENTS> : [&] [=|!|!=] <FRAGMENT>
+    <FRAGMENT> : dont-fragment, is-fragment, first-fragment, last-fragment, not-a-fragment
+    <TCP_FLAGS> : [&] [=|!|!=] <TCP_FLAG>
+    <TCP_FLAG> : %s%%s
+    <ITEM> : [&] [<|<=|>|>=|==|!=] <DEC_NUM>`,
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_DST_PREFIX],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_SRC_PREFIX],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_IP_PROTO],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_FRAGMENT],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_TCP_FLAG],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_PORT],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_DST_PORT],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_SRC_PORT],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_ICMP_TYPE],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_ICMP_CODE],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_PKT_LEN],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_DSCP],
+			// <additional help messages if exists>
+			ipProtocols,
+			tcpFlags,
+			// <additional help messages if exists>
+		)
+		ipv4FsMatchExpr := fmt.Sprintf(baseFsMatchExpr, "", "")
+		ipv6FsMatchExpr := fmt.Sprintf(baseFsMatchExpr, fmt.Sprintf(`|
+                %s <ITEM>... `,
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_LABEL]), "")
+		l2vpnFsMatchExpr := fmt.Sprintf(baseFsMatchExpr, fmt.Sprintf(`|
+                %s <ITEM>... |
+                %s <MAC_ADDRESS> |
+                %s <MAC_ADDRESS> |
+                %s <ETHER_TYPES>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... |
+                %s <ITEM>... `,
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_LABEL],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_DST_MAC],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_SRC_MAC],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_ETHERNET_TYPE],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_LLC_DSAP],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_LLC_SSAP],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_LLC_CONTROL],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_SNAP],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_VID],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_COS],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_INNER_VID],
+			bgp.FlowSpecNameMap[bgp.FLOW_SPEC_TYPE_INNER_COS]), fmt.Sprintf(`
+    <ETHER_TYPES> : [&] [<|<=|>|>=|==|!=] <ETHER_TYPE>
+    <ETHER_TYPE> : %s`,
+			etherTypes))
+		helpErrMap[bgp.RF_FS_IPv4_UC] = fmt.Errorf(fsHelpMsgFmt, "ipv4-flowspec", "", "", "", ipv4FsMatchExpr)
+		helpErrMap[bgp.RF_FS_IPv6_UC] = fmt.Errorf(fsHelpMsgFmt, "ipv6-flowspec", "", "", "", ipv6FsMatchExpr)
+		helpErrMap[bgp.RF_FS_IPv4_VPN] = fmt.Errorf(fsHelpMsgFmt, "ipv4-l3vpn-flowspec", " rd <RD>", " [rt <RT>]", rdHelpMsgFmt, ipv4FsMatchExpr)
+		helpErrMap[bgp.RF_FS_IPv6_VPN] = fmt.Errorf(fsHelpMsgFmt, "ipv6-l3vpn-flowspec", " rd <RD>", " [rt <RT>]", rdHelpMsgFmt, ipv6FsMatchExpr)
+		helpErrMap[bgp.RF_FS_L2_VPN] = fmt.Errorf(fsHelpMsgFmt, "l2vpn-flowspec", " rd <RD>", " [rt <RT>]", rdHelpMsgFmt, l2vpnFsMatchExpr)
+		helpErrMap[bgp.RF_EVPN] = fmt.Errorf(`error: %s
+usage: %s rib %s { a-d <A-D> | macadv <MACADV> | multicast <MULTICAST> | esi <ESI> | prefix <PREFIX> } -a evpn
+    <A-D>       : esi <esi> etag <etag> label <label> rd <rd> [rt <rt>...] [encap <encap type>] [esi-label <esi-label> [single-active | all-active]]
+    <MACADV>    : <mac address> <ip address> [esi <esi>] etag <etag> label <label> rd <rd> [rt <rt>...] [encap <encap type>] [router-mac <mac address>] [default-gateway]
+    <MULTICAST> : <ip address> etag <etag> rd <rd> [rt <rt>...] [encap <encap type>] [pmsi <type> [leaf-info-required] <label> <tunnel-id>]
+    <ESI>       : <ip address> esi <esi> rd <rd> [rt <rt>...] [encap <encap type>]
+    <PREFIX>    : <ip prefix> [gw <gateway>] [esi <esi>] etag <etag> [label <label>] rd <rd> [rt <rt>...] [encap <encap type>] [router-mac <mac address>]`,
+			err,
+			cmdstr,
+			modtype,
+		)
+		helpErrMap[bgp.RF_OPAQUE] = fmt.Errorf(`error: %s
+usage: %s rib %s key <KEY> [value <VALUE>]`,
+			err,
+			cmdstr,
+			modtype,
+		)
+		if err, ok := helpErrMap[rf]; ok {
+			return err
+		}
+		return err
+	}
+
+	if modtype == CMD_ADD {
+		if resource == CMD_VRF {
+			_, err = client.AddVRFPath(name, []*api.Path{path})
+		} else {
+			_, err = client.AddPath([]*api.Path{path})
+		}
+	} else {
+		if resource == CMD_VRF {
+			err = client.DeleteVRFPath(name, []*api.Path{path})
+		} else {
+			err = client.DeletePath([]*api.Path{path})
+		}
+	}
+	return err
+}
+
+func showGlobalConfig() error {
+	g, err := client.GetServer()
+	if err != nil {
+		return err
+	}
+	if globalOpts.Json {
+		j, _ := json.Marshal(g)
+		fmt.Println(string(j))
+		return nil
+	}
+	fmt.Println("AS:       ", g.Config.As)
+	fmt.Println("Router-ID:", g.Config.RouterId)
+	if len(g.Config.LocalAddressList) > 0 {
+		fmt.Printf("Listening Port: %d, Addresses: %s\n", g.Config.Port, strings.Join(g.Config.LocalAddressList, ", "))
+	}
+	if g.UseMultiplePaths.Config.Enabled {
+		fmt.Printf("Multipath: enabled")
+	}
+	return nil
+}
+
+func modGlobalConfig(args []string) error {
+	m, err := extractReserved(args, map[string]int{
+		"as":               PARAM_SINGLE,
+		"router-id":        PARAM_SINGLE,
+		"listen-port":      PARAM_SINGLE,
+		"listen-addresses": PARAM_LIST,
+		"use-multipath":    PARAM_FLAG})
+	if err != nil || len(m["as"]) != 1 || len(m["router-id"]) != 1 {
+		return fmt.Errorf("usage: gobgp global as <VALUE> router-id <VALUE> [use-multipath] [listen-port <VALUE>] [listen-addresses <VALUE>...]")
+	}
+	asn, err := strconv.ParseUint(m["as"][0], 10, 32)
+	if err != nil {
+		return err
+	}
+	id := net.ParseIP(m["router-id"][0])
+	if id.To4() == nil {
+		return fmt.Errorf("invalid router-id format")
+	}
+	var port int64
+	if len(m["listen-port"]) > 0 {
+		// Note: GlobalConfig.Port is uint32 type, but the TCP/UDP port is
+		// 16-bit length.
+		port, err = strconv.ParseInt(m["listen-port"][0], 10, 16)
+		if err != nil {
+			return err
+		}
+	}
+	useMultipath := false
+	if _, ok := m["use-multipath"]; ok {
+		useMultipath = true
+	}
+	return client.StartServer(&config.Global{
+		Config: config.GlobalConfig{
+			As:               uint32(asn),
+			RouterId:         id.String(),
+			Port:             int32(port),
+			LocalAddressList: m["listen-addresses"],
+		},
+		UseMultiplePaths: config.UseMultiplePaths{
+			Config: config.UseMultiplePathsConfig{
+				Enabled: useMultipath,
+			},
+		},
+	})
+}
+
+func NewGlobalCmd() *cobra.Command {
+	globalCmd := &cobra.Command{
+		Use: CMD_GLOBAL,
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			if len(args) != 0 {
+				err = modGlobalConfig(args)
+			} else {
+				err = showGlobalConfig()
+			}
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+
+	ribCmd := &cobra.Command{
+		Use: CMD_RIB,
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := showGlobalRib(args); err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+
+	ribCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+
+	for _, v := range []string{CMD_ADD, CMD_DEL} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(cmd *cobra.Command, args []string) {
+				err := modPath(CMD_GLOBAL, "", cmd.Use, args)
+				if err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+		ribCmd.AddCommand(cmd)
+
+		if v == CMD_DEL {
+			subcmd := &cobra.Command{
+				Use: CMD_ALL,
+				Run: func(cmd *cobra.Command, args []string) {
+					family, err := checkAddressFamily(bgp.RouteFamily(0))
+					if err != nil {
+						exitWithError(err)
+					}
+					if err = client.DeletePathByFamily(family); err != nil {
+						exitWithError(err)
+					}
+				},
+			}
+			cmd.AddCommand(subcmd)
+		}
+	}
+
+	summaryCmd := &cobra.Command{
+		Use: CMD_SUMMARY,
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := showRibInfo(CMD_GLOBAL, ""); err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+	ribCmd.AddCommand(summaryCmd)
+
+	policyCmd := &cobra.Command{
+		Use: CMD_POLICY,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) > 0 {
+				exitWithError(fmt.Errorf("usage: gobgp global policy [{ import | export }]"))
+			}
+			for _, v := range []string{CMD_IMPORT, CMD_EXPORT} {
+				if err := showNeighborPolicy("", v, 4); err != nil {
+					exitWithError(err)
+				}
+			}
+		},
+	}
+
+	for _, v := range []string{CMD_IMPORT, CMD_EXPORT} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(cmd *cobra.Command, args []string) {
+				if err := showNeighborPolicy("", cmd.Use, 0); err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+
+		for _, w := range []string{CMD_ADD, CMD_DEL, CMD_SET} {
+			subcmd := &cobra.Command{
+				Use: w,
+				Run: func(subcmd *cobra.Command, args []string) {
+					err := modNeighborPolicy("", cmd.Use, subcmd.Use, args)
+					if err != nil {
+						exitWithError(err)
+					}
+				},
+			}
+			cmd.AddCommand(subcmd)
+		}
+
+		policyCmd.AddCommand(cmd)
+	}
+
+	delCmd := &cobra.Command{
+		Use: CMD_DEL,
+	}
+
+	allCmd := &cobra.Command{
+		Use: CMD_ALL,
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := client.StopServer(); err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+	delCmd.AddCommand(allCmd)
+
+	globalCmd.AddCommand(ribCmd, policyCmd, delCmd)
+	return globalCmd
+}
diff --git a/cmd/gobgp/cmd/global_test.go b/cmd/gobgp/cmd/global_test.go
new file mode 100644
index 00000000..7aecb904
--- /dev/null
+++ b/cmd/gobgp/cmd/global_test.go
@@ -0,0 +1,38 @@
+// 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 cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_ParsePath(t *testing.T) {
+	assert := assert.New(t)
+	buf := "10.0.0.0/24 rt 100:100 med 10 nexthop 10.0.0.1 aigp metric 10 local-pref 100"
+
+	path, err := ParsePath(bgp.RF_IPv4_UC, strings.Split(buf, " "))
+	assert.Nil(err)
+	i := 0
+	attrs, _ := path.GetNativePathAttributes()
+	for _, a := range attrs {
+		assert.True(i < int(a.GetType()))
+		i = int(a.GetType())
+	}
+}
diff --git a/cmd/gobgp/cmd/monitor.go b/cmd/gobgp/cmd/monitor.go
new file mode 100644
index 00000000..6b07eb2d
--- /dev/null
+++ b/cmd/gobgp/cmd/monitor.go
@@ -0,0 +1,201 @@
+// 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 cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+
+	"github.com/spf13/cobra"
+
+	api "github.com/osrg/gobgp/api"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+)
+
+func makeMonitorRouteArgs(p *api.Path, showIdentifier bgp.BGPAddPathMode) []interface{} {
+	pathStr := make([]interface{}, 0)
+
+	// Title
+	title := "ROUTE"
+	if p.IsWithdraw {
+		title = "DELROUTE"
+	}
+	pathStr = append(pathStr, title)
+
+	// NLRI
+	// If Add-Path required, append Path Identifier.
+	nlri, _ := p.GetNativeNlri()
+	if showIdentifier != bgp.BGP_ADD_PATH_NONE {
+		pathStr = append(pathStr, p.GetIdentifier())
+	}
+	pathStr = append(pathStr, nlri)
+
+	attrs, _ := p.GetNativePathAttributes()
+	// Next Hop
+	nexthop := "fictitious"
+	if n := getNextHopFromPathAttributes(attrs); n != nil {
+		nexthop = n.String()
+	}
+	pathStr = append(pathStr, nexthop)
+
+	// AS_PATH
+	aspathstr := func() string {
+		for _, attr := range attrs {
+			switch a := attr.(type) {
+			case *bgp.PathAttributeAsPath:
+				return bgp.AsPathString(a)
+			}
+		}
+		return ""
+	}()
+	pathStr = append(pathStr, aspathstr)
+
+	// Path Attributes
+	pathStr = append(pathStr, getPathAttributeString(nlri, attrs))
+
+	return pathStr
+}
+
+func monitorRoute(pathList []*api.Path, showIdentifier bgp.BGPAddPathMode) {
+	var pathStrs [][]interface{}
+
+	for _, p := range pathList {
+		pathStrs = append(pathStrs, makeMonitorRouteArgs(p, showIdentifier))
+	}
+
+	format := "[%s] %s via %s aspath [%s] attrs %s\n"
+	if showIdentifier != bgp.BGP_ADD_PATH_NONE {
+		format = "[%s] %d:%s via %s aspath [%s] attrs %s\n"
+	}
+	for _, pathStr := range pathStrs {
+		fmt.Printf(format, pathStr...)
+	}
+}
+
+func NewMonitorCmd() *cobra.Command {
+
+	var current bool
+
+	monitor := func(recver interface {
+		Recv() (*api.Destination, error)
+	}, showIdentifier bgp.BGPAddPathMode) {
+		for {
+			dst, err := recver.Recv()
+			if err == io.EOF {
+				break
+			} else if err != nil {
+				exitWithError(err)
+			}
+			if globalOpts.Json {
+				j, _ := json.Marshal(dst.Paths)
+				fmt.Println(string(j))
+			} else {
+				monitorRoute(dst.Paths, showIdentifier)
+			}
+		}
+	}
+
+	ribCmd := &cobra.Command{
+		Use: CMD_RIB,
+		Run: func(cmd *cobra.Command, args []string) {
+			family, err := checkAddressFamily(bgp.RouteFamily(0))
+			if err != nil {
+				exitWithError(err)
+			}
+			recver, err := client.MonitorRIB(family, current)
+			if err != nil {
+				exitWithError(err)
+			}
+			monitor(recver, bgp.BGP_ADD_PATH_NONE)
+		},
+	}
+	ribCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+
+	globalCmd := &cobra.Command{
+		Use: CMD_GLOBAL,
+	}
+	globalCmd.AddCommand(ribCmd)
+
+	neighborCmd := &cobra.Command{
+		Use:  fmt.Sprintf("%s [<neighbor address>]", CMD_NEIGHBOR),
+		Args: cobra.MaximumNArgs(1),
+		Run: func(cmd *cobra.Command, args []string) {
+			name := ""
+			if len(args) > 0 {
+				name = args[0]
+			}
+			stream, err := client.MonitorNeighborState(name, current)
+			if err != nil {
+				exitWithError(err)
+			}
+			for {
+				s, err := stream.Recv()
+				if err == io.EOF {
+					break
+				} else if err != nil {
+					exitWithError(err)
+				}
+				if globalOpts.Json {
+					j, _ := json.Marshal(s)
+					fmt.Println(string(j))
+				} else {
+					addr := s.State.NeighborAddress
+					if s.Config.NeighborInterface != "" {
+						addr = fmt.Sprintf("%s(%s)", addr, s.Config.NeighborInterface)
+					}
+					fmt.Printf("[NEIGH] %s fsm: %s admin: %s\n", addr, s.State.SessionState, s.State.AdminState)
+				}
+			}
+		},
+	}
+
+	adjInCmd := &cobra.Command{
+		Use: CMD_ADJ_IN,
+		Run: func(cmd *cobra.Command, args []string) {
+			name := ""
+			if len(args) > 0 {
+				remoteIP := net.ParseIP(args[0])
+				if remoteIP == nil {
+					exitWithError(fmt.Errorf("invalid ip address: %s", args[0]))
+				}
+				name = args[0]
+			}
+			family, err := checkAddressFamily(bgp.RouteFamily(0))
+			if err != nil {
+				exitWithError(err)
+			}
+			recver, err := client.MonitorAdjRIBIn(name, family, current)
+			if err != nil {
+				exitWithError(err)
+			}
+			monitor(recver, bgp.BGP_ADD_PATH_RECEIVE)
+		},
+	}
+	adjInCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+
+	monitorCmd := &cobra.Command{
+		Use: CMD_MONITOR,
+	}
+	monitorCmd.AddCommand(globalCmd)
+	monitorCmd.AddCommand(neighborCmd)
+	monitorCmd.AddCommand(adjInCmd)
+
+	monitorCmd.PersistentFlags().BoolVarP(&current, "current", "", false, "dump current contents")
+
+	return monitorCmd
+}
diff --git a/cmd/gobgp/cmd/mrt.go b/cmd/gobgp/cmd/mrt.go
new file mode 100644
index 00000000..32c4fc9b
--- /dev/null
+++ b/cmd/gobgp/cmd/mrt.go
@@ -0,0 +1,238 @@
+// 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 cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	api "github.com/osrg/gobgp/api"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+	"github.com/osrg/gobgp/pkg/packet/mrt"
+)
+
+func injectMrt() error {
+
+	file, err := os.Open(mrtOpts.Filename)
+	if err != nil {
+		return fmt.Errorf("failed to open file: %s", err)
+	}
+
+	if mrtOpts.NextHop != nil && !mrtOpts.SkipV4 && !mrtOpts.SkipV6 {
+		fmt.Println("You should probably specify either --no-ipv4 or --no-ipv6 when overwriting nexthop, unless your dump contains only one type of routes")
+	}
+
+	var idx int64
+	if mrtOpts.QueueSize < 1 {
+		return fmt.Errorf("Specified queue size is smaller than 1, refusing to run with unbounded memory usage")
+	}
+
+	ch := make(chan []*api.Path, mrtOpts.QueueSize)
+	go func() {
+
+		var peers []*mrt.Peer
+		for {
+			buf := make([]byte, mrt.MRT_COMMON_HEADER_LEN)
+			_, err := file.Read(buf)
+			if err == io.EOF {
+				break
+			} else if err != nil {
+				exitWithError(fmt.Errorf("failed to read: %s", err))
+			}
+
+			h := &mrt.MRTHeader{}
+			err = h.DecodeFromBytes(buf)
+			if err != nil {
+				exitWithError(fmt.Errorf("failed to parse"))
+			}
+
+			buf = make([]byte, h.Len)
+			_, err = file.Read(buf)
+			if err != nil {
+				exitWithError(fmt.Errorf("failed to read"))
+			}
+
+			msg, err := mrt.ParseMRTBody(h, buf)
+			if err != nil {
+				printError(fmt.Errorf("failed to parse: %s", err))
+				continue
+			}
+
+			if globalOpts.Debug {
+				fmt.Println(msg)
+			}
+
+			if msg.Header.Type == mrt.TABLE_DUMPv2 {
+				subType := mrt.MRTSubTypeTableDumpv2(msg.Header.SubType)
+				switch subType {
+				case mrt.PEER_INDEX_TABLE:
+					peers = msg.Body.(*mrt.PeerIndexTable).Peers
+					continue
+				case mrt.RIB_IPV4_UNICAST, mrt.RIB_IPV4_UNICAST_ADDPATH:
+					if mrtOpts.SkipV4 {
+						continue
+					}
+				case mrt.RIB_IPV6_UNICAST, mrt.RIB_IPV6_UNICAST_ADDPATH:
+					if mrtOpts.SkipV6 {
+						continue
+					}
+				case mrt.GEO_PEER_TABLE:
+					fmt.Printf("WARNING: Skipping GEO_PEER_TABLE: %s", msg.Body.(*mrt.GeoPeerTable))
+				default:
+					exitWithError(fmt.Errorf("unsupported subType: %v", subType))
+				}
+
+				if peers == nil {
+					exitWithError(fmt.Errorf("not found PEER_INDEX_TABLE"))
+				}
+
+				rib := msg.Body.(*mrt.Rib)
+				nlri := rib.Prefix
+
+				paths := make([]*api.Path, 0, len(rib.Entries))
+
+				for _, e := range rib.Entries {
+					if len(peers) < int(e.PeerIndex) {
+						exitWithError(fmt.Errorf("invalid peer index: %d (PEER_INDEX_TABLE has only %d peers)\n", e.PeerIndex, len(peers)))
+					}
+					//t := time.Unix(int64(e.OriginatedTime), 0)
+
+					var attrs []bgp.PathAttributeInterface
+					switch subType {
+					case mrt.RIB_IPV4_UNICAST, mrt.RIB_IPV4_UNICAST_ADDPATH:
+						if mrtOpts.NextHop != nil {
+							for i, attr := range e.PathAttributes {
+								if attr.GetType() != bgp.BGP_ATTR_TYPE_NEXT_HOP {
+									e.PathAttributes[i] = bgp.NewPathAttributeNextHop(mrtOpts.NextHop.String())
+									break
+								}
+							}
+						}
+						attrs = e.PathAttributes
+					default:
+						attrs = make([]bgp.PathAttributeInterface, 0, len(e.PathAttributes))
+						for _, attr := range e.PathAttributes {
+							if attr.GetType() != bgp.BGP_ATTR_TYPE_MP_REACH_NLRI {
+								attrs = append(attrs, attr)
+							} else {
+								a := attr.(*bgp.PathAttributeMpReachNLRI)
+								nexthop := a.Nexthop.String()
+								if mrtOpts.NextHop != nil {
+									nexthop = mrtOpts.NextHop.String()
+								}
+								attrs = append(attrs, bgp.NewPathAttributeMpReachNLRI(nexthop, []bgp.AddrPrefixInterface{nlri}))
+							}
+						}
+					}
+
+					path := api.NewPath(nlri, false, attrs, time.Unix(int64(e.OriginatedTime), 0))
+					path.SourceAsn = peers[e.PeerIndex].AS
+					path.SourceId = peers[e.PeerIndex].BgpId.String()
+
+					// TODO: compare here if mrtOpts.Best is enabled
+					paths = append(paths, path)
+				}
+
+				// TODO: calculate properly if necessary.
+				if mrtOpts.Best {
+					paths = []*api.Path{paths[0]}
+				}
+
+				if idx >= mrtOpts.RecordSkip {
+					ch <- paths
+				}
+
+				idx += 1
+				if idx == mrtOpts.RecordCount+mrtOpts.RecordSkip {
+					break
+				}
+			}
+		}
+
+		close(ch)
+	}()
+
+	stream, err := client.AddPathByStream()
+	if err != nil {
+		return fmt.Errorf("failed to add path: %s", err)
+	}
+
+	for paths := range ch {
+		err = stream.Send(paths...)
+		if err != nil {
+			return fmt.Errorf("failed to send: %s", err)
+		}
+	}
+
+	if err := stream.Close(); err != nil {
+		return fmt.Errorf("failed to send: %s", err)
+	}
+	return nil
+}
+
+func NewMrtCmd() *cobra.Command {
+	globalInjectCmd := &cobra.Command{
+		Use: CMD_GLOBAL,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) < 1 {
+				exitWithError(fmt.Errorf("usage: gobgp mrt inject global <filename> [<count> [<skip>]]"))
+			}
+			mrtOpts.Filename = args[0]
+			if len(args) > 1 {
+				var err error
+				mrtOpts.RecordCount, err = strconv.ParseInt(args[1], 10, 64)
+				if err != nil {
+					exitWithError(fmt.Errorf("invalid count value: %s", args[1]))
+				}
+				if len(args) > 2 {
+					mrtOpts.RecordSkip, err = strconv.ParseInt(args[2], 10, 64)
+					if err != nil {
+						exitWithError(fmt.Errorf("invalid skip value: %s", args[2]))
+					}
+				}
+			} else {
+				mrtOpts.RecordCount = -1
+				mrtOpts.RecordSkip = 0
+			}
+			err := injectMrt()
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+
+	injectCmd := &cobra.Command{
+		Use: CMD_INJECT,
+	}
+	injectCmd.AddCommand(globalInjectCmd)
+
+	mrtCmd := &cobra.Command{
+		Use: CMD_MRT,
+	}
+	mrtCmd.AddCommand(injectCmd)
+
+	mrtCmd.PersistentFlags().BoolVarP(&mrtOpts.Best, "only-best", "", false, "inject only best paths")
+	mrtCmd.PersistentFlags().BoolVarP(&mrtOpts.SkipV4, "no-ipv4", "", false, "Do not import IPv4 routes")
+	mrtCmd.PersistentFlags().BoolVarP(&mrtOpts.SkipV6, "no-ipv6", "", false, "Do not import IPv6 routes")
+	mrtCmd.PersistentFlags().IntVarP(&mrtOpts.QueueSize, "queue-size", "", 1<<10, "Maximum number of updates to keep queued")
+	mrtCmd.PersistentFlags().IPVarP(&mrtOpts.NextHop, "nexthop", "", nil, "Overwrite nexthop")
+	return mrtCmd
+}
diff --git a/cmd/gobgp/cmd/neighbor.go b/cmd/gobgp/cmd/neighbor.go
new file mode 100644
index 00000000..c6dd8be6
--- /dev/null
+++ b/cmd/gobgp/cmd/neighbor.go
@@ -0,0 +1,1321 @@
+// 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 cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	api "github.com/osrg/gobgp/api"
+	"github.com/osrg/gobgp/internal/pkg/config"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+)
+
+// used in showRoute() to determine the width of each column
+var (
+	columnWidthPrefix  = 20
+	columnWidthNextHop = 20
+	columnWidthAsPath  = 20
+	columnWidthLabel   = 10
+)
+
+func updateColumnWidth(nlri, nexthop, aspath, label string) {
+	if prefixLen := len(nlri); columnWidthPrefix < prefixLen {
+		columnWidthPrefix = prefixLen
+	}
+	if columnWidthNextHop < len(nexthop) {
+		columnWidthNextHop = len(nexthop)
+	}
+	if columnWidthAsPath < len(aspath) {
+		columnWidthAsPath = len(aspath)
+	}
+	if columnWidthLabel < len(label) {
+		columnWidthLabel = len(label)
+	}
+}
+
+func getNeighbors(vrf string) (neighbors, error) {
+	if vrf != "" {
+		n, err := client.ListNeighborByVRF(vrf)
+		return neighbors(n), err
+	} else if t := neighborsOpts.Transport; t != "" {
+		switch t {
+		case "ipv4":
+			n, err := client.ListNeighborByTransport(bgp.AFI_IP)
+			return neighbors(n), err
+		case "ipv6":
+			n, err := client.ListNeighborByTransport(bgp.AFI_IP6)
+			return neighbors(n), err
+		default:
+			return nil, fmt.Errorf("invalid transport: %s", t)
+		}
+	}
+	n, err := client.ListNeighbor()
+	return neighbors(n), err
+}
+
+func getASN(p *config.Neighbor) string {
+	asn := "*"
+	if p.State.PeerAs > 0 {
+		asn = fmt.Sprint(p.State.PeerAs)
+	}
+	return asn
+}
+
+func showNeighbors(vrf string) error {
+	m, err := getNeighbors(vrf)
+	if err != nil {
+		return err
+	}
+	if globalOpts.Json {
+		j, _ := json.Marshal(m)
+		fmt.Println(string(j))
+		return nil
+	}
+
+	if globalOpts.Quiet {
+		for _, p := range m {
+			fmt.Println(p.State.NeighborAddress)
+		}
+		return nil
+	}
+	maxaddrlen := 0
+	maxaslen := 2
+	maxtimelen := len("Up/Down")
+	timedelta := []string{}
+
+	sort.Sort(m)
+
+	now := time.Now()
+	for _, n := range m {
+		if i := len(n.Config.NeighborInterface); i > maxaddrlen {
+			maxaddrlen = i
+		} else if j := len(n.State.NeighborAddress); j > maxaddrlen {
+			maxaddrlen = j
+		}
+		if l := len(getASN(n)); l > maxaslen {
+			maxaslen = l
+		}
+		timeStr := "never"
+		if n.Timers.State.Uptime != 0 {
+			t := int64(n.Timers.State.Downtime)
+			if n.State.SessionState == config.SESSION_STATE_ESTABLISHED {
+				t = int64(n.Timers.State.Uptime)
+			}
+			timeStr = formatTimedelta(int64(now.Sub(time.Unix(int64(t), 0)).Seconds()))
+		}
+		if len(timeStr) > maxtimelen {
+			maxtimelen = len(timeStr)
+		}
+		timedelta = append(timedelta, timeStr)
+	}
+
+	format := "%-" + fmt.Sprint(maxaddrlen) + "s" + " %" + fmt.Sprint(maxaslen) + "s" + " %" + fmt.Sprint(maxtimelen) + "s"
+	format += " %-11s |%9s %9s\n"
+	fmt.Printf(format, "Peer", "AS", "Up/Down", "State", "#Received", "Accepted")
+	formatFsm := func(admin config.AdminState, fsm config.SessionState) string {
+		switch admin {
+		case config.ADMIN_STATE_DOWN:
+			return "Idle(Admin)"
+		case config.ADMIN_STATE_PFX_CT:
+			return "Idle(PfxCt)"
+		}
+
+		switch fsm {
+		case config.SESSION_STATE_IDLE:
+			return "Idle"
+		case config.SESSION_STATE_CONNECT:
+			return "Connect"
+		case config.SESSION_STATE_ACTIVE:
+			return "Active"
+		case config.SESSION_STATE_OPENSENT:
+			return "Sent"
+		case config.SESSION_STATE_OPENCONFIRM:
+			return "Confirm"
+		case config.SESSION_STATE_ESTABLISHED:
+			return "Establ"
+		default:
+			return string(fsm)
+		}
+	}
+
+	for i, n := range m {
+		neigh := n.State.NeighborAddress
+		if n.Config.NeighborInterface != "" {
+			neigh = n.Config.NeighborInterface
+		}
+		fmt.Printf(format, neigh, getASN(n), timedelta[i], formatFsm(n.State.AdminState, n.State.SessionState), fmt.Sprint(n.State.AdjTable.Received), fmt.Sprint(n.State.AdjTable.Accepted))
+	}
+
+	return nil
+}
+
+func showNeighbor(args []string) error {
+	p, e := client.GetNeighbor(args[0], true)
+	if e != nil {
+		return e
+	}
+	if globalOpts.Json {
+		j, _ := json.Marshal(p)
+		fmt.Println(string(j))
+		return nil
+	}
+
+	fmt.Printf("BGP neighbor is %s, remote AS %s", p.State.NeighborAddress, getASN(p))
+
+	if p.RouteReflector.Config.RouteReflectorClient {
+		fmt.Printf(", route-reflector-client\n")
+	} else if p.RouteServer.Config.RouteServerClient {
+		fmt.Printf(", route-server-client\n")
+	} else {
+		fmt.Printf("\n")
+	}
+
+	id := "unknown"
+	if p.State.RemoteRouterId != "" {
+		id = p.State.RemoteRouterId
+	}
+	fmt.Printf("  BGP version 4, remote router ID %s\n", id)
+	fmt.Printf("  BGP state = %s", p.State.SessionState)
+	if p.Timers.State.Uptime > 0 {
+		fmt.Printf(", up for %s\n", formatTimedelta(int64(p.Timers.State.Uptime)-time.Now().Unix()))
+	} else {
+		fmt.Print("\n")
+	}
+	fmt.Printf("  BGP OutQ = %d, Flops = %d\n", p.State.Queues.Output, p.State.Flops)
+	fmt.Printf("  Hold time is %d, keepalive interval is %d seconds\n", int(p.Timers.State.NegotiatedHoldTime), int(p.Timers.State.KeepaliveInterval))
+	fmt.Printf("  Configured hold time is %d, keepalive interval is %d seconds\n", int(p.Timers.Config.HoldTime), int(p.Timers.Config.KeepaliveInterval))
+
+	elems := make([]string, 0, 3)
+	if as := p.AsPathOptions.Config.AllowOwnAs; as > 0 {
+		elems = append(elems, fmt.Sprintf("Allow Own AS: %d", as))
+	}
+	switch p.Config.RemovePrivateAs {
+	case config.REMOVE_PRIVATE_AS_OPTION_ALL:
+		elems = append(elems, "Remove private AS: all")
+	case config.REMOVE_PRIVATE_AS_OPTION_REPLACE:
+		elems = append(elems, "Remove private AS: replace")
+	}
+	if p.AsPathOptions.Config.ReplacePeerAs {
+		elems = append(elems, "Replace peer AS: enabled")
+	}
+
+	fmt.Printf("  %s\n", strings.Join(elems, ", "))
+
+	fmt.Printf("  Neighbor capabilities:\n")
+	caps := capabilities{}
+	lookup := func(val bgp.ParameterCapabilityInterface, l capabilities) bgp.ParameterCapabilityInterface {
+		for _, v := range l {
+			if v.Code() == val.Code() {
+				if v.Code() == bgp.BGP_CAP_MULTIPROTOCOL {
+					lhs := v.(*bgp.CapMultiProtocol).CapValue
+					rhs := val.(*bgp.CapMultiProtocol).CapValue
+					if lhs == rhs {
+						return v
+					}
+					continue
+				}
+				return v
+			}
+		}
+		return nil
+	}
+	for _, c := range p.State.LocalCapabilityList {
+		caps = append(caps, c)
+	}
+	for _, c := range p.State.RemoteCapabilityList {
+		if lookup(c, caps) == nil {
+			caps = append(caps, c)
+		}
+	}
+
+	sort.Sort(caps)
+
+	firstMp := true
+
+	for _, c := range caps {
+		support := ""
+		if m := lookup(c, p.State.LocalCapabilityList); m != nil {
+			support += "advertised"
+		}
+		if lookup(c, p.State.RemoteCapabilityList) != nil {
+			if len(support) != 0 {
+				support += " and "
+			}
+			support += "received"
+		}
+
+		switch c.Code() {
+		case bgp.BGP_CAP_MULTIPROTOCOL:
+			if firstMp {
+				fmt.Printf("    %s:\n", c.Code())
+				firstMp = false
+			}
+			m := c.(*bgp.CapMultiProtocol).CapValue
+			fmt.Printf("        %s:\t%s\n", m, support)
+		case bgp.BGP_CAP_GRACEFUL_RESTART:
+			fmt.Printf("    %s:\t%s\n", c.Code(), support)
+			grStr := func(g *bgp.CapGracefulRestart) string {
+				str := ""
+				if len(g.Tuples) > 0 {
+					str += fmt.Sprintf("restart time %d sec", g.Time)
+				}
+				if g.Flags&0x08 > 0 {
+					if len(str) > 0 {
+						str += ", "
+					}
+					str += "restart flag set"
+				}
+				if g.Flags&0x04 > 0 {
+					if len(str) > 0 {
+						str += ", "
+					}
+					str += "notification flag set"
+				}
+
+				if len(str) > 0 {
+					str += "\n"
+				}
+				for _, t := range g.Tuples {
+					str += fmt.Sprintf("	    %s", bgp.AfiSafiToRouteFamily(t.AFI, t.SAFI))
+					if t.Flags == 0x80 {
+						str += ", forward flag set"
+					}
+					str += "\n"
+				}
+				return str
+			}
+			if m := lookup(c, p.State.LocalCapabilityList); m != nil {
+				g := m.(*bgp.CapGracefulRestart)
+				if s := grStr(g); len(s) > 0 {
+					fmt.Printf("        Local: %s", s)
+				}
+			}
+			if m := lookup(c, p.State.RemoteCapabilityList); m != nil {
+				g := m.(*bgp.CapGracefulRestart)
+				if s := grStr(g); len(s) > 0 {
+					fmt.Printf("        Remote: %s", s)
+				}
+			}
+		case bgp.BGP_CAP_LONG_LIVED_GRACEFUL_RESTART:
+			fmt.Printf("    %s:\t%s\n", c.Code(), support)
+			grStr := func(g *bgp.CapLongLivedGracefulRestart) string {
+				var str string
+				for _, t := range g.Tuples {
+					str += fmt.Sprintf("	    %s, restart time %d sec", bgp.AfiSafiToRouteFamily(t.AFI, t.SAFI), t.RestartTime)
+					if t.Flags == 0x80 {
+						str += ", forward flag set"
+					}
+					str += "\n"
+				}
+				return str
+			}
+			if m := lookup(c, p.State.LocalCapabilityList); m != nil {
+				g := m.(*bgp.CapLongLivedGracefulRestart)
+				if s := grStr(g); len(s) > 0 {
+					fmt.Printf("        Local:\n%s", s)
+				}
+			}
+			if m := lookup(c, p.State.RemoteCapabilityList); m != nil {
+				g := m.(*bgp.CapLongLivedGracefulRestart)
+				if s := grStr(g); len(s) > 0 {
+					fmt.Printf("        Remote:\n%s", s)
+				}
+			}
+		case bgp.BGP_CAP_EXTENDED_NEXTHOP:
+			fmt.Printf("    %s:\t%s\n", c.Code(), support)
+			exnhStr := func(e *bgp.CapExtendedNexthop) string {
+				lines := make([]string, 0, len(e.Tuples))
+				for _, t := range e.Tuples {
+					var nhafi string
+					switch int(t.NexthopAFI) {
+					case bgp.AFI_IP:
+						nhafi = "ipv4"
+					case bgp.AFI_IP6:
+						nhafi = "ipv6"
+					default:
+						nhafi = fmt.Sprintf("%d", t.NexthopAFI)
+					}
+					line := fmt.Sprintf("nlri: %s, nexthop: %s", bgp.AfiSafiToRouteFamily(t.NLRIAFI, uint8(t.NLRISAFI)), nhafi)
+					lines = append(lines, line)
+				}
+				return strings.Join(lines, "\n")
+			}
+			if m := lookup(c, p.State.LocalCapabilityList); m != nil {
+				e := m.(*bgp.CapExtendedNexthop)
+				if s := exnhStr(e); len(s) > 0 {
+					fmt.Printf("        Local:  %s\n", s)
+				}
+			}
+			if m := lookup(c, p.State.RemoteCapabilityList); m != nil {
+				e := m.(*bgp.CapExtendedNexthop)
+				if s := exnhStr(e); len(s) > 0 {
+					fmt.Printf("        Remote: %s\n", s)
+				}
+			}
+		case bgp.BGP_CAP_ADD_PATH:
+			fmt.Printf("    %s:\t%s\n", c.Code(), support)
+			if m := lookup(c, p.State.LocalCapabilityList); m != nil {
+				fmt.Println("      Local:")
+				for _, item := range m.(*bgp.CapAddPath).Tuples {
+					fmt.Printf("         %s:\t%s\n", item.RouteFamily, item.Mode)
+				}
+			}
+			if m := lookup(c, p.State.RemoteCapabilityList); m != nil {
+				fmt.Println("      Remote:")
+				for _, item := range m.(*bgp.CapAddPath).Tuples {
+					fmt.Printf("         %s:\t%s\n", item.RouteFamily, item.Mode)
+				}
+			}
+		default:
+			fmt.Printf("    %s:\t%s\n", c.Code(), support)
+		}
+	}
+	fmt.Print("  Message statistics:\n")
+	fmt.Print("                         Sent       Rcvd\n")
+	fmt.Printf("    Opens:         %10d %10d\n", p.State.Messages.Sent.Open, p.State.Messages.Received.Open)
+	fmt.Printf("    Notifications: %10d %10d\n", p.State.Messages.Sent.Notification, p.State.Messages.Received.Notification)
+	fmt.Printf("    Updates:       %10d %10d\n", p.State.Messages.Sent.Update, p.State.Messages.Received.Update)
+	fmt.Printf("    Keepalives:    %10d %10d\n", p.State.Messages.Sent.Keepalive, p.State.Messages.Received.Keepalive)
+	fmt.Printf("    Route Refresh: %10d %10d\n", p.State.Messages.Sent.Refresh, p.State.Messages.Received.Refresh)
+	fmt.Printf("    Discarded:     %10d %10d\n", p.State.Messages.Sent.Discarded, p.State.Messages.Received.Discarded)
+	fmt.Printf("    Total:         %10d %10d\n", p.State.Messages.Sent.Total, p.State.Messages.Received.Total)
+	fmt.Print("  Route statistics:\n")
+	fmt.Printf("    Advertised:    %10d\n", p.State.AdjTable.Advertised)
+	fmt.Printf("    Received:      %10d\n", p.State.AdjTable.Received)
+	fmt.Printf("    Accepted:      %10d\n", p.State.AdjTable.Accepted)
+	first := true
+	for _, afisafi := range p.AfiSafis {
+		if afisafi.PrefixLimit.Config.MaxPrefixes > 0 {
+			if first {
+				fmt.Println("  Prefix Limits:")
+				first = false
+			}
+			fmt.Printf("    %s:\tMaximum prefixes allowed %d", afisafi.Config.AfiSafiName, afisafi.PrefixLimit.Config.MaxPrefixes)
+			if afisafi.PrefixLimit.Config.ShutdownThresholdPct > 0 {
+				fmt.Printf(", Threshold for warning message %d%%\n", afisafi.PrefixLimit.Config.ShutdownThresholdPct)
+			} else {
+				fmt.Printf("\n")
+			}
+		}
+	}
+	return nil
+}
+
+type AsPathFormat struct{}
+
+func getPathSymbolString(p *api.Path, idx int, showBest bool) string {
+	symbols := ""
+	if p.Stale {
+		symbols += "S"
+	}
+	if v := p.GetValidationDetail(); v != nil {
+		switch v.State {
+		case api.RPKIValidation_STATE_NOT_FOUND:
+			symbols += "N"
+		case api.RPKIValidation_STATE_VALID:
+			symbols += "V"
+		case api.RPKIValidation_STATE_INVALID:
+			symbols += "I"
+		}
+
+	}
+	if showBest {
+		if idx == 0 && !p.IsNexthopInvalid {
+			symbols += "*>"
+		} else {
+			symbols += "* "
+		}
+	}
+	return symbols
+}
+
+func getPathAttributeString(nlri bgp.AddrPrefixInterface, attrs []bgp.PathAttributeInterface) string {
+	s := make([]string, 0)
+	for _, a := range attrs {
+		switch a.GetType() {
+		case bgp.BGP_ATTR_TYPE_NEXT_HOP, bgp.BGP_ATTR_TYPE_MP_REACH_NLRI, bgp.BGP_ATTR_TYPE_AS_PATH, bgp.BGP_ATTR_TYPE_AS4_PATH:
+			continue
+		default:
+			s = append(s, a.String())
+		}
+	}
+	switch n := nlri.(type) {
+	case *bgp.EVPNNLRI:
+		// We print non route key fields like path attributes.
+		switch route := n.RouteTypeData.(type) {
+		case *bgp.EVPNMacIPAdvertisementRoute:
+			s = append(s, fmt.Sprintf("[ESI: %s]", route.ESI.String()))
+		case *bgp.EVPNIPPrefixRoute:
+			s = append(s, fmt.Sprintf("[ESI: %s]", route.ESI.String()))
+			if route.GWIPAddress != nil {
+				s = append(s, fmt.Sprintf("[GW: %s]", route.GWIPAddress.String()))
+			}
+		}
+	}
+	return fmt.Sprint(s)
+}
+
+func makeShowRouteArgs(p *api.Path, idx int, now time.Time, showAge, showBest, showLabel bool, showIdentifier bgp.BGPAddPathMode) []interface{} {
+	nlri, _ := p.GetNativeNlri()
+
+	// Path Symbols (e.g. "*>")
+	args := []interface{}{getPathSymbolString(p, idx, showBest)}
+
+	// Path Identifier
+	switch showIdentifier {
+	case bgp.BGP_ADD_PATH_RECEIVE:
+		args = append(args, fmt.Sprint(p.GetIdentifier()))
+	case bgp.BGP_ADD_PATH_SEND:
+		args = append(args, fmt.Sprint(p.GetLocalIdentifier()))
+	}
+
+	// NLRI
+	args = append(args, nlri)
+
+	// Label
+	label := ""
+	if showLabel {
+		label = bgp.LabelString(nlri)
+		args = append(args, label)
+	}
+
+	attrs, _ := p.GetNativePathAttributes()
+	// Next Hop
+	nexthop := "fictitious"
+	if n := getNextHopFromPathAttributes(attrs); n != nil {
+		nexthop = n.String()
+	}
+	args = append(args, nexthop)
+
+	// AS_PATH
+	aspathstr := func() string {
+		for _, attr := range attrs {
+			switch a := attr.(type) {
+			case *bgp.PathAttributeAsPath:
+				return bgp.AsPathString(a)
+			}
+		}
+		return ""
+	}()
+	args = append(args, aspathstr)
+
+	// Age
+	if showAge {
+		t := time.Unix(p.Age, 0)
+		args = append(args, formatTimedelta(int64(now.Sub(t).Seconds())))
+	}
+
+	// Path Attributes
+	pattrstr := getPathAttributeString(nlri, attrs)
+	args = append(args, pattrstr)
+
+	updateColumnWidth(nlri.String(), nexthop, aspathstr, label)
+
+	return args
+}
+
+func showRoute(dsts []*api.Destination, showAge, showBest, showLabel bool, showIdentifier bgp.BGPAddPathMode) {
+	pathStrs := make([][]interface{}, 0, len(dsts))
+	now := time.Now()
+	for _, dst := range dsts {
+		for idx, p := range dst.Paths {
+			pathStrs = append(pathStrs, makeShowRouteArgs(p, idx, now, showAge, showBest, showLabel, showIdentifier))
+		}
+	}
+
+	headers := make([]interface{}, 0)
+	var format string
+	headers = append(headers, "") // Symbols
+	format = fmt.Sprintf("%%-3s")
+	if showIdentifier != bgp.BGP_ADD_PATH_NONE {
+		headers = append(headers, "ID")
+		format += "%-3s "
+	}
+	headers = append(headers, "Network")
+	format += fmt.Sprintf("%%-%ds ", columnWidthPrefix)
+	if showLabel {
+		headers = append(headers, "Labels")
+		format += fmt.Sprintf("%%-%ds ", columnWidthLabel)
+	}
+	headers = append(headers, "Next Hop", "AS_PATH")
+	format += fmt.Sprintf("%%-%ds %%-%ds ", columnWidthNextHop, columnWidthAsPath)
+	if showAge {
+		headers = append(headers, "Age")
+		format += "%-10s "
+	}
+	headers = append(headers, "Attrs")
+	format += "%-s\n"
+
+	fmt.Printf(format, headers...)
+	for _, pathStr := range pathStrs {
+		fmt.Printf(format, pathStr...)
+	}
+}
+
+func checkOriginAsWasNotShown(p *api.Path, asPath []bgp.AsPathParamInterface, shownAs map[uint32]struct{}) bool {
+	// the path was generated in internal
+	if len(asPath) == 0 {
+		return false
+	}
+	asList := asPath[len(asPath)-1].GetAS()
+	origin := asList[len(asList)-1]
+
+	if _, ok := shownAs[origin]; ok {
+		return false
+	}
+	shownAs[origin] = struct{}{}
+	return true
+}
+
+func showValidationInfo(p *api.Path, shownAs map[uint32]struct{}) error {
+	var asPath []bgp.AsPathParamInterface
+	attrs, _ := p.GetNativePathAttributes()
+	for _, attr := range attrs {
+		if attr.GetType() == bgp.BGP_ATTR_TYPE_AS_PATH {
+			asPath = attr.(*bgp.PathAttributeAsPath).Value
+		}
+	}
+
+	nlri, _ := p.GetNativeNlri()
+	if len(asPath) == 0 {
+		return fmt.Errorf("The path to %s was locally generated.\n", nlri.String())
+	} else if !checkOriginAsWasNotShown(p, asPath, shownAs) {
+		return nil
+	}
+
+	status := p.GetValidationDetail().State
+	reason := p.GetValidationDetail().Reason
+	asList := asPath[len(asPath)-1].GetAS()
+	origin := asList[len(asList)-1]
+
+	fmt.Printf("Target Prefix: %s, AS: %d\n", nlri.String(), origin)
+	fmt.Printf("  This route is %s", status)
+	switch status {
+	case api.RPKIValidation_STATE_INVALID:
+		fmt.Printf("  reason: %s\n", reason)
+		switch reason {
+		case api.RPKIValidation_REASON_AS:
+			fmt.Println("  No VRP ASN matches the route origin ASN.")
+		case api.RPKIValidation_REASON_LENGTH:
+			fmt.Println("  Route Prefix length is greater than the maximum length allowed by VRP(s) matching this route origin ASN.")
+		}
+	case api.RPKIValidation_STATE_NOT_FOUND:
+		fmt.Println("\n  No VRP Covers the Route Prefix")
+	default:
+		fmt.Print("\n\n")
+	}
+
+	printVRPs := func(l []*api.Roa) {
+		if len(l) == 0 {
+			fmt.Println("    No Entry")
+		} else {
+			var format string
+			if ip, _, _ := net.ParseCIDR(nlri.String()); ip.To4() != nil {
+				format = "    %-18s %-6s %-10s\n"
+			} else {
+				format = "    %-42s %-6s %-10s\n"
+			}
+			fmt.Printf(format, "Network", "AS", "MaxLen")
+			for _, m := range l {
+				fmt.Printf(format, m.Prefix, fmt.Sprint(m.As), fmt.Sprint(m.Maxlen))
+			}
+		}
+	}
+
+	fmt.Println("  Matched VRPs: ")
+	printVRPs(p.GetValidationDetail().Matched)
+	fmt.Println("  Unmatched AS VRPs: ")
+	printVRPs(p.GetValidationDetail().UnmatchedAs)
+	fmt.Println("  Unmatched Length VRPs: ")
+	printVRPs(p.GetValidationDetail().UnmatchedLength)
+
+	return nil
+}
+
+func showRibInfo(r, name string) error {
+	def := addr2AddressFamily(net.ParseIP(name))
+	if r == CMD_GLOBAL {
+		def = bgp.RF_IPv4_UC
+	}
+	family, err := checkAddressFamily(def)
+	if err != nil {
+		return err
+	}
+
+	var info *api.TableInfo
+	switch r {
+	case CMD_GLOBAL:
+		info, err = client.GetRIBInfo(family)
+	case CMD_LOCAL:
+		info, err = client.GetLocalRIBInfo(name, family)
+	case CMD_ADJ_IN:
+		info, err = client.GetAdjRIBInInfo(name, family)
+	case CMD_ADJ_OUT:
+		info, err = client.GetAdjRIBOutInfo(name, family)
+	default:
+		return fmt.Errorf("invalid resource to show RIB info: %s", r)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if globalOpts.Json {
+		j, _ := json.Marshal(info)
+		fmt.Println(string(j))
+		return nil
+	}
+	fmt.Printf("Table %s\n", family)
+	fmt.Printf("Destination: %d, Path: %d\n", info.NumDestination, info.NumPath)
+	return nil
+}
+
+func parseCIDRorIP(str string) (net.IP, *net.IPNet, error) {
+	ip, n, err := net.ParseCIDR(str)
+	if err == nil {
+		return ip, n, nil
+	}
+	ip = net.ParseIP(str)
+	if ip == nil {
+		return ip, nil, fmt.Errorf("invalid CIDR/IP")
+	}
+	return ip, nil, nil
+}
+
+func showNeighborRib(r string, name string, args []string) error {
+	showBest := false
+	showAge := true
+	showLabel := false
+	showIdentifier := bgp.BGP_ADD_PATH_NONE
+	validationTarget := ""
+
+	def := addr2AddressFamily(net.ParseIP(name))
+	switch r {
+	case CMD_GLOBAL:
+		def = bgp.RF_IPv4_UC
+		showBest = true
+	case CMD_LOCAL:
+		showBest = true
+	case CMD_ADJ_OUT:
+		showAge = false
+	case CMD_VRF:
+		def = bgp.RF_IPv4_UC
+		showBest = true
+	}
+	family, err := checkAddressFamily(def)
+	if err != nil {
+		return err
+	}
+	switch family {
+	case bgp.RF_IPv4_MPLS, bgp.RF_IPv6_MPLS, bgp.RF_IPv4_VPN, bgp.RF_IPv6_VPN, bgp.RF_EVPN:
+		showLabel = true
+	}
+
+	var filter []*api.TableLookupPrefix
+	if len(args) > 0 {
+		target := args[0]
+		switch family {
+		case bgp.RF_EVPN:
+			// Uses target as EVPN Route Type string
+		default:
+			if _, _, err = parseCIDRorIP(target); err != nil {
+				return err
+			}
+		}
+		var option api.TableLookupOption
+		args = args[1:]
+		for len(args) != 0 {
+			if args[0] == "longer-prefixes" {
+				option = api.TableLookupOption_LOOKUP_LONGER
+			} else if args[0] == "shorter-prefixes" {
+				option = api.TableLookupOption_LOOKUP_SHORTER
+			} else if args[0] == "validation" {
+				if r != CMD_ADJ_IN {
+					return fmt.Errorf("RPKI information is supported for only adj-in.")
+				}
+				validationTarget = target
+			} else {
+				return fmt.Errorf("invalid format for route filtering")
+			}
+			args = args[1:]
+		}
+		filter = []*api.TableLookupPrefix{&api.TableLookupPrefix{
+			Prefix:       target,
+			LookupOption: option,
+		},
+		}
+	}
+
+	var rib *api.Table
+	switch r {
+	case CMD_GLOBAL:
+		rib, err = client.GetRIB(family, filter)
+	case CMD_LOCAL:
+		rib, err = client.GetLocalRIB(name, family, filter)
+	case CMD_ADJ_IN, CMD_ACCEPTED, CMD_REJECTED:
+		showIdentifier = bgp.BGP_ADD_PATH_RECEIVE
+		rib, err = client.GetAdjRIBIn(name, family, filter)
+	case CMD_ADJ_OUT:
+		showIdentifier = bgp.BGP_ADD_PATH_SEND
+		rib, err = client.GetAdjRIBOut(name, family, filter)
+	case CMD_VRF:
+		rib, err = client.GetVRFRIB(name, family, filter)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	switch r {
+	case CMD_LOCAL, CMD_ADJ_IN, CMD_ACCEPTED, CMD_REJECTED, CMD_ADJ_OUT:
+		if len(rib.Destinations) == 0 {
+			peer, err := client.GetNeighbor(name, false)
+			if err != nil {
+				return err
+			}
+			if peer.State.SessionState != config.SESSION_STATE_ESTABLISHED {
+				return fmt.Errorf("Neighbor %v's BGP session is not established", name)
+			}
+		}
+	}
+
+	if globalOpts.Json {
+		d := make(map[string]*api.Destination)
+		for _, dst := range rib.GetDestinations() {
+			d[dst.Prefix] = dst
+		}
+		j, _ := json.Marshal(d)
+		fmt.Println(string(j))
+		return nil
+	}
+
+	if validationTarget != "" {
+		// show RPKI validation info
+		d := func() *api.Destination {
+			for _, dst := range rib.GetDestinations() {
+				if dst.Prefix == validationTarget {
+					return dst
+				}
+			}
+			return nil
+		}()
+		if d == nil {
+			fmt.Println("Network not in table")
+			return nil
+		}
+		shownAs := make(map[uint32]struct{})
+		for _, p := range d.GetPaths() {
+			if err := showValidationInfo(p, shownAs); err != nil {
+				return err
+			}
+		}
+	} else {
+		// show RIB
+		dsts := rib.GetDestinations()
+		switch family {
+		case bgp.RF_IPv4_UC, bgp.RF_IPv6_UC:
+			type d struct {
+				prefix net.IP
+				dst    *api.Destination
+			}
+			l := make([]*d, 0, len(dsts))
+			for _, dst := range dsts {
+				_, p, _ := net.ParseCIDR(dst.Prefix)
+				l = append(l, &d{prefix: p.IP, dst: dst})
+			}
+
+			sort.Slice(l, func(i, j int) bool {
+				return bytes.Compare(l[i].prefix, l[j].prefix) < 0
+			})
+
+			dsts = make([]*api.Destination, 0, len(dsts))
+			for _, s := range l {
+				dsts = append(dsts, s.dst)
+			}
+		}
+
+		for _, d := range dsts {
+			switch r {
+			case CMD_ACCEPTED:
+				l := make([]*api.Path, 0, len(d.Paths))
+				for _, p := range d.GetPaths() {
+					if !p.Filtered {
+						l = append(l, p)
+					}
+				}
+				d.Paths = l
+			case CMD_REJECTED:
+				// always nothing
+				d.Paths = []*api.Path{}
+			default:
+			}
+		}
+		if len(dsts) > 0 {
+			showRoute(dsts, showAge, showBest, showLabel, showIdentifier)
+		} else {
+			fmt.Println("Network not in table")
+		}
+	}
+	return nil
+}
+
+func resetNeighbor(cmd string, remoteIP string, args []string) error {
+	family := bgp.RouteFamily(0)
+	if reasonLen := len(neighborsOpts.Reason); reasonLen > bgp.BGP_ERROR_ADMINISTRATIVE_COMMUNICATION_MAX {
+		return fmt.Errorf("Too long reason for shutdown communication (max %d bytes)", bgp.BGP_ERROR_ADMINISTRATIVE_COMMUNICATION_MAX)
+	}
+	switch cmd {
+	case CMD_RESET:
+		return client.ResetNeighbor(remoteIP, neighborsOpts.Reason)
+	case CMD_SOFT_RESET:
+		return client.SoftReset(remoteIP, family)
+	case CMD_SOFT_RESET_IN:
+		return client.SoftResetIn(remoteIP, family)
+	case CMD_SOFT_RESET_OUT:
+		return client.SoftResetOut(remoteIP, family)
+	}
+	return nil
+}
+
+func stateChangeNeighbor(cmd string, remoteIP string, args []string) error {
+	if reasonLen := len(neighborsOpts.Reason); reasonLen > bgp.BGP_ERROR_ADMINISTRATIVE_COMMUNICATION_MAX {
+		return fmt.Errorf("Too long reason for shutdown communication (max %d bytes)", bgp.BGP_ERROR_ADMINISTRATIVE_COMMUNICATION_MAX)
+	}
+	switch cmd {
+	case CMD_SHUTDOWN:
+		fmt.Printf("WARNING: command `%s` is deprecated. use `%s` instead\n", CMD_SHUTDOWN, CMD_DISABLE)
+		return client.ShutdownNeighbor(remoteIP, neighborsOpts.Reason)
+	case CMD_ENABLE:
+		return client.EnableNeighbor(remoteIP)
+	case CMD_DISABLE:
+		return client.DisableNeighbor(remoteIP, neighborsOpts.Reason)
+	}
+	return nil
+}
+
+func showNeighborPolicy(remoteIP, policyType string, indent int) error {
+	var assignment *api.PolicyAssignment
+	var err error
+
+	switch strings.ToLower(policyType) {
+	case "import":
+		assignment, err = client.GetRouteServerImportPolicy(remoteIP)
+	case "export":
+		assignment, err = client.GetRouteServerExportPolicy(remoteIP)
+	default:
+		return fmt.Errorf("invalid policy type: choose from (in|import|export)")
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if globalOpts.Json {
+		j, _ := json.Marshal(assignment)
+		fmt.Println(string(j))
+		return nil
+	}
+
+	fmt.Printf("%s policy:\n", strings.Title(policyType))
+	fmt.Printf("%sDefault: %s\n", strings.Repeat(" ", indent), assignment.Default.String())
+	for _, p := range assignment.Policies {
+		fmt.Printf("%sName %s:\n", strings.Repeat(" ", indent), p.Name)
+		printPolicy(indent+4, p)
+	}
+	return nil
+}
+
+func extractDefaultAction(args []string) ([]string, api.RouteAction, error) {
+	for idx, arg := range args {
+		if arg == "default" {
+			if len(args) < (idx + 2) {
+				return nil, api.RouteAction_NONE, fmt.Errorf("specify default action [accept|reject]")
+			}
+			typ := args[idx+1]
+			switch strings.ToLower(typ) {
+			case "accept":
+				return append(args[:idx], args[idx+2:]...), api.RouteAction_ACCEPT, nil
+			case "reject":
+				return append(args[:idx], args[idx+2:]...), api.RouteAction_REJECT, nil
+			default:
+				return nil, api.RouteAction_NONE, fmt.Errorf("invalid default action")
+			}
+		}
+	}
+	return args, api.RouteAction_NONE, nil
+}
+
+func modNeighborPolicy(remoteIP, policyType, cmdType string, args []string) error {
+	resource := api.Resource_GLOBAL
+	if remoteIP != "" {
+		resource = api.Resource_LOCAL
+	}
+
+	assign := &api.PolicyAssignment{
+		Name:     remoteIP,
+		Resource: resource,
+	}
+
+	switch strings.ToLower(policyType) {
+	case "import":
+		assign.Type = api.PolicyType_IMPORT
+	case "export":
+		assign.Type = api.PolicyType_EXPORT
+	}
+
+	usage := fmt.Sprintf("usage: gobgp neighbor %s policy %s %s", remoteIP, policyType, cmdType)
+	if remoteIP == "" {
+		usage = fmt.Sprintf("usage: gobgp global policy %s %s", policyType, cmdType)
+	}
+
+	var err error
+	switch cmdType {
+	case CMD_ADD, CMD_SET:
+		if len(args) < 1 {
+			return fmt.Errorf("%s <policy name>... [default {%s|%s}]", usage, "accept", "reject")
+		}
+		var err error
+		var def api.RouteAction
+		args, def, err = extractDefaultAction(args)
+		if err != nil {
+			return fmt.Errorf("%s\n%s <policy name>... [default {%s|%s}]", err, usage, "accept", "reject")
+		}
+		assign.Default = def
+	}
+	ps := make([]*api.Policy, 0, len(args))
+	for _, name := range args {
+		ps = append(ps, &api.Policy{Name: name})
+	}
+	assign.Policies = ps
+	switch cmdType {
+	case CMD_ADD:
+		err = client.AddPolicyAssignment(assign)
+	case CMD_SET:
+		err = client.ReplacePolicyAssignment(assign)
+	case CMD_DEL:
+		all := false
+		if len(args) == 0 {
+			all = true
+		}
+		err = client.DeletePolicyAssignment(assign, all)
+	}
+	return err
+}
+
+func modNeighbor(cmdType string, args []string) error {
+	params := map[string]int{
+		"interface": PARAM_SINGLE,
+	}
+	usage := fmt.Sprintf("usage: gobgp neighbor %s [ <neighbor-address> | interface <neighbor-interface> ]", cmdType)
+	if cmdType == CMD_ADD {
+		usage += " as <VALUE>"
+	} else if cmdType == CMD_UPDATE {
+		usage += " [ as <VALUE> ]"
+	}
+	if cmdType == CMD_ADD || cmdType == CMD_UPDATE {
+		params["as"] = PARAM_SINGLE
+		params["family"] = PARAM_SINGLE
+		params["vrf"] = PARAM_SINGLE
+		params["route-reflector-client"] = PARAM_SINGLE
+		params["route-server-client"] = PARAM_FLAG
+		params["allow-own-as"] = PARAM_SINGLE
+		params["remove-private-as"] = PARAM_SINGLE
+		params["replace-peer-as"] = PARAM_FLAG
+		usage += " [ family <address-families-list> | vrf <vrf-name> | route-reflector-client [<cluster-id>] | route-server-client | allow-own-as <num> | remove-private-as (all|replace) | replace-peer-as ]"
+	}
+
+	m, err := extractReserved(args, params)
+	if err != nil || (len(m[""]) != 1 && len(m["interface"]) != 1) {
+		return fmt.Errorf("%s", usage)
+	}
+
+	unnumbered := len(m["interface"]) > 0
+	if !unnumbered {
+		if _, err := net.ResolveIPAddr("ip", m[""][0]); err != nil {
+			return err
+		}
+	}
+
+	getNeighborAddress := func() (string, error) {
+		if unnumbered {
+			return config.GetIPv6LinkLocalNeighborAddress(m["interface"][0])
+		}
+		return m[""][0], nil
+	}
+
+	getNeighborConfig := func() (*config.Neighbor, error) {
+		addr, err := getNeighborAddress()
+		if err != nil {
+			return nil, err
+		}
+		var peer *config.Neighbor
+		switch cmdType {
+		case CMD_ADD, CMD_DEL:
+			peer = &config.Neighbor{}
+			if unnumbered {
+				peer.Config.NeighborInterface = m["interface"][0]
+			} else {
+				peer.Config.NeighborAddress = addr
+			}
+			peer.State.NeighborAddress = addr
+		case CMD_UPDATE:
+			peer, err = client.GetNeighbor(addr)
+			if err != nil {
+				return nil, err
+			}
+		default:
+			return nil, fmt.Errorf("invalid command: %s", cmdType)
+		}
+		return peer, nil
+	}
+
+	updateNeighborConfig := func(peer *config.Neighbor) error {
+		if len(m["as"]) > 0 {
+			as, err := strconv.ParseUint(m["as"][0], 10, 32)
+			if err != nil {
+				return err
+			}
+			peer.Config.PeerAs = uint32(as)
+		}
+		if len(m["family"]) == 1 {
+			peer.AfiSafis = make([]config.AfiSafi, 0) // for the case of CMD_UPDATE
+			for _, family := range strings.Split(m["family"][0], ",") {
+				afiSafiName := config.AfiSafiType(family)
+				if afiSafiName.ToInt() == -1 {
+					return fmt.Errorf("invalid family value: %s", family)
+				}
+				peer.AfiSafis = append(peer.AfiSafis, config.AfiSafi{Config: config.AfiSafiConfig{AfiSafiName: afiSafiName}})
+			}
+		}
+		if len(m["vrf"]) == 1 {
+			peer.Config.Vrf = m["vrf"][0]
+		}
+		if option, ok := m["route-reflector-client"]; ok {
+			peer.RouteReflector.Config = config.RouteReflectorConfig{
+				RouteReflectorClient: true,
+			}
+			if len(option) == 1 {
+				peer.RouteReflector.Config.RouteReflectorClusterId = config.RrClusterIdType(option[0])
+			}
+		}
+		if _, ok := m["route-server-client"]; ok {
+			peer.RouteServer.Config = config.RouteServerConfig{
+				RouteServerClient: true,
+			}
+		}
+		if option, ok := m["allow-own-as"]; ok {
+			as, err := strconv.ParseUint(option[0], 10, 8)
+			if err != nil {
+				return err
+			}
+			peer.AsPathOptions.Config.AllowOwnAs = uint8(as)
+		}
+		if option, ok := m["remove-private-as"]; ok {
+			switch option[0] {
+			case "all":
+				peer.Config.RemovePrivateAs = config.REMOVE_PRIVATE_AS_OPTION_ALL
+			case "replace":
+				peer.Config.RemovePrivateAs = config.REMOVE_PRIVATE_AS_OPTION_REPLACE
+			default:
+				return fmt.Errorf("invalid remove-private-as value: all or replace")
+			}
+		}
+		if _, ok := m["replace-peer-as"]; ok {
+			peer.AsPathOptions.Config.ReplacePeerAs = true
+		}
+		return nil
+	}
+
+	n, err := getNeighborConfig()
+	if err != nil {
+		return err
+	}
+
+	switch cmdType {
+	case CMD_ADD:
+		if err := updateNeighborConfig(n); err != nil {
+			return err
+		}
+		return client.AddNeighbor(n)
+	case CMD_DEL:
+		return client.DeleteNeighbor(n)
+	case CMD_UPDATE:
+		if err := updateNeighborConfig(n); err != nil {
+			return err
+		}
+		_, err := client.UpdateNeighbor(n, true)
+		return err
+	}
+	return nil
+}
+
+func NewNeighborCmd() *cobra.Command {
+
+	neighborCmdImpl := &cobra.Command{}
+
+	type cmds struct {
+		names []string
+		f     func(string, string, []string) error
+	}
+
+	c := make([]cmds, 0, 3)
+	c = append(c, cmds{[]string{CMD_LOCAL, CMD_ADJ_IN, CMD_ADJ_OUT, CMD_ACCEPTED, CMD_REJECTED}, showNeighborRib})
+	c = append(c, cmds{[]string{CMD_RESET, CMD_SOFT_RESET, CMD_SOFT_RESET_IN, CMD_SOFT_RESET_OUT}, resetNeighbor})
+	c = append(c, cmds{[]string{CMD_SHUTDOWN, CMD_ENABLE, CMD_DISABLE}, stateChangeNeighbor})
+
+	for _, v := range c {
+		f := v.f
+		for _, name := range v.names {
+			c := &cobra.Command{
+				Use: name,
+				Run: func(cmd *cobra.Command, args []string) {
+					addr := ""
+					switch name {
+					case CMD_RESET, CMD_SOFT_RESET, CMD_SOFT_RESET_IN, CMD_SOFT_RESET_OUT, CMD_SHUTDOWN:
+						if args[len(args)-1] == "all" {
+							addr = "all"
+						}
+					}
+					if addr == "" {
+						peer, err := client.GetNeighbor(args[len(args)-1], false)
+						if err != nil {
+							exitWithError(err)
+						}
+						addr = peer.State.NeighborAddress
+					}
+					err := f(cmd.Use, addr, args[:len(args)-1])
+					if err != nil {
+						exitWithError(err)
+					}
+				},
+			}
+			neighborCmdImpl.AddCommand(c)
+			switch name {
+			case CMD_LOCAL, CMD_ADJ_IN, CMD_ADJ_OUT:
+				n := name
+				c.AddCommand(&cobra.Command{
+					Use: CMD_SUMMARY,
+					Run: func(cmd *cobra.Command, args []string) {
+						if err := showRibInfo(n, args[len(args)-1]); err != nil {
+							exitWithError(err)
+						}
+					},
+				})
+			}
+		}
+	}
+
+	policyCmd := &cobra.Command{
+		Use: CMD_POLICY,
+		Run: func(cmd *cobra.Command, args []string) {
+			peer, err := client.GetNeighbor(args[0], false)
+			if err != nil {
+				exitWithError(err)
+			}
+			remoteIP := peer.State.NeighborAddress
+			for _, v := range []string{CMD_IN, CMD_IMPORT, CMD_EXPORT} {
+				if err := showNeighborPolicy(remoteIP, v, 4); err != nil {
+					exitWithError(err)
+				}
+			}
+		},
+	}
+
+	for _, v := range []string{CMD_IN, CMD_IMPORT, CMD_EXPORT} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(cmd *cobra.Command, args []string) {
+				peer, err := client.GetNeighbor(args[0], false)
+				if err != nil {
+					exitWithError(err)
+				}
+				remoteIP := peer.State.NeighborAddress
+				err = showNeighborPolicy(remoteIP, cmd.Use, 0)
+				if err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+
+		for _, w := range []string{CMD_ADD, CMD_DEL, CMD_SET} {
+			subcmd := &cobra.Command{
+				Use: w,
+				Run: func(subcmd *cobra.Command, args []string) {
+					peer, err := client.GetNeighbor(args[len(args)-1], false)
+					if err != nil {
+						exitWithError(err)
+					}
+					remoteIP := peer.State.NeighborAddress
+					args = args[:len(args)-1]
+					if err = modNeighborPolicy(remoteIP, cmd.Use, subcmd.Use, args); err != nil {
+						exitWithError(err)
+					}
+				},
+			}
+			cmd.AddCommand(subcmd)
+		}
+
+		policyCmd.AddCommand(cmd)
+
+	}
+
+	neighborCmdImpl.AddCommand(policyCmd)
+
+	neighborCmd := &cobra.Command{
+		Use: CMD_NEIGHBOR,
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			if len(args) == 0 {
+				err = showNeighbors("")
+			} else if len(args) == 1 {
+				err = showNeighbor(args)
+			} else {
+				args = append(args[1:], args[0])
+				neighborCmdImpl.SetArgs(args)
+				err = neighborCmdImpl.Execute()
+			}
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+
+	for _, v := range []string{CMD_ADD, CMD_DEL, CMD_UPDATE} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(c *cobra.Command, args []string) {
+				if err := modNeighbor(c.Use, args); err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+		neighborCmd.AddCommand(cmd)
+	}
+
+	neighborCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+	neighborCmd.PersistentFlags().StringVarP(&neighborsOpts.Reason, "reason", "", "", "specifying communication field on Cease NOTIFICATION message with Administrative Shutdown subcode")
+	neighborCmd.PersistentFlags().StringVarP(&neighborsOpts.Transport, "transport", "t", "", "specifying a transport protocol")
+	return neighborCmd
+}
diff --git a/cmd/gobgp/cmd/policy.go b/cmd/gobgp/cmd/policy.go
new file mode 100644
index 00000000..7faa8648
--- /dev/null
+++ b/cmd/gobgp/cmd/policy.go
@@ -0,0 +1,1081 @@
+// 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 cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	api "github.com/osrg/gobgp/api"
+	"github.com/osrg/gobgp/internal/pkg/config"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+)
+
+var (
+	_regexpCommunity      = regexp.MustCompile(`\^\^(\S+)\$\$`)
+	repexpCommunity       = regexp.MustCompile(`(\d+.)*\d+:\d+`)
+	regexpLargeCommunity  = regexp.MustCompile(`\d+:\d+:\d+`)
+	regexpCommunityString = regexp.MustCompile(`[\^\$]`)
+)
+
+func parseCommunityRegexp(arg string) (*regexp.Regexp, error) {
+	i, err := strconv.ParseUint(arg, 10, 32)
+	if err == nil {
+		return regexp.Compile(fmt.Sprintf("^%d:%d$", i>>16, i&0x0000ffff))
+	}
+	if repexpCommunity.MatchString(arg) {
+		return regexp.Compile(fmt.Sprintf("^%s$", arg))
+	}
+	for i, v := range bgp.WellKnownCommunityNameMap {
+		if strings.Replace(strings.ToLower(arg), "_", "-", -1) == v {
+			return regexp.Compile(fmt.Sprintf("^%d:%d$", i>>16, i&0x0000ffff))
+		}
+	}
+	exp, err := regexp.Compile(arg)
+	if err != nil {
+		return nil, fmt.Errorf("invalid community format: %s", arg)
+	}
+	return exp, nil
+}
+
+func parseExtCommunityRegexp(arg string) (bgp.ExtendedCommunityAttrSubType, *regexp.Regexp, error) {
+	var subtype bgp.ExtendedCommunityAttrSubType
+	elems := strings.SplitN(arg, ":", 2)
+	if len(elems) < 2 {
+		return subtype, nil, fmt.Errorf("invalid ext-community format([rt|soo]:<value>)")
+	}
+	switch strings.ToLower(elems[0]) {
+	case "rt":
+		subtype = bgp.EC_SUBTYPE_ROUTE_TARGET
+	case "soo":
+		subtype = bgp.EC_SUBTYPE_ROUTE_ORIGIN
+	default:
+		return subtype, nil, fmt.Errorf("unknown ext-community subtype. rt, soo is supported")
+	}
+	exp, err := parseCommunityRegexp(elems[1])
+	return subtype, exp, err
+}
+
+func parseLargeCommunityRegexp(arg string) (*regexp.Regexp, error) {
+	if regexpLargeCommunity.MatchString(arg) {
+		return regexp.Compile(fmt.Sprintf("^%s$", arg))
+	}
+	exp, err := regexp.Compile(arg)
+	if err != nil {
+		return nil, fmt.Errorf("invalid large-community format: %s", arg)
+	}
+	return exp, nil
+}
+
+func routeTypePrettyString(s api.Conditions_RouteType) string {
+	switch s {
+	case api.Conditions_ROUTE_TYPE_EXTERNAL:
+		return "external"
+	case api.Conditions_ROUTE_TYPE_INTERNAL:
+		return "internal"
+	case api.Conditions_ROUTE_TYPE_LOCAL:
+		return "local"
+	}
+	return "unknown"
+}
+
+func prettyString(v interface{}) string {
+	switch a := v.(type) {
+	case *api.MatchSet:
+		var typ string
+		switch a.Type {
+		case api.MatchType_ALL:
+			typ = "all"
+		case api.MatchType_ANY:
+			typ = "any"
+		case api.MatchType_INVERT:
+			typ = "invert"
+		}
+		return fmt.Sprintf("%s %s", typ, a.GetName())
+	case *api.AsPathLength:
+		var typ string
+		switch a.Type {
+		case api.AsPathLengthType_EQ:
+			typ = "="
+		case api.AsPathLengthType_GE:
+			typ = ">="
+		case api.AsPathLengthType_LE:
+			typ = "<="
+		}
+		return fmt.Sprintf("%s%d", typ, a.Length)
+	case *api.CommunityAction:
+		l := regexpCommunityString.ReplaceAllString(strings.Join(a.Communities, ", "), "")
+		var typ string
+		switch a.Type {
+		case api.CommunityActionType_COMMUNITY_ADD:
+			typ = "add"
+		case api.CommunityActionType_COMMUNITY_REMOVE:
+			typ = "remove"
+		case api.CommunityActionType_COMMUNITY_REPLACE:
+			typ = "replace"
+		}
+		return fmt.Sprintf("%s[%s]", typ, l)
+	case *api.MedAction:
+		if a.Type == api.MedActionType_MED_MOD && a.Value > 0 {
+			return fmt.Sprintf("+%d", a.Value)
+		}
+		return fmt.Sprintf("%d", a.Value)
+	case *api.LocalPrefAction:
+		return fmt.Sprintf("%d", a.Value)
+	case *api.NexthopAction:
+		if a.Self {
+			return "self"
+		}
+		return a.Address
+	case *api.AsPrependAction:
+		return fmt.Sprintf("prepend %d %d times", a.Asn, a.Repeat)
+	}
+	return "unknown"
+}
+
+func formatDefinedSet(head bool, typ string, indent int, list []*api.DefinedSet) string {
+	if len(list) == 0 {
+		return "Nothing defined yet\n"
+	}
+	buff := bytes.NewBuffer(make([]byte, 0, 64))
+	sIndent := strings.Repeat(" ", indent)
+	maxNameLen := 0
+	for _, s := range list {
+		if len(s.GetName()) > maxNameLen {
+			maxNameLen = len(s.GetName())
+		}
+	}
+	if head {
+		if len("NAME") > maxNameLen {
+			maxNameLen = len("NAME")
+		}
+	}
+	format := fmt.Sprintf("%%-%ds  %%s\n", maxNameLen)
+	if head {
+		buff.WriteString(fmt.Sprintf(format, "NAME", typ))
+	}
+	for _, s := range list {
+		l := s.GetList()
+		if len(l) == 0 {
+			buff.WriteString(fmt.Sprintf(format, s.GetName(), ""))
+		}
+		for i, x := range l {
+			if typ == "COMMUNITY" || typ == "EXT-COMMUNITY" || typ == "LARGE-COMMUNITY" {
+				x = _regexpCommunity.ReplaceAllString(x, "$1")
+			}
+			if i == 0 {
+				buff.WriteString(fmt.Sprintf(format, s.GetName(), x))
+			} else {
+				buff.WriteString(fmt.Sprint(sIndent))
+				buff.WriteString(fmt.Sprintf(format, "", x))
+			}
+		}
+	}
+	return buff.String()
+}
+
+func showDefinedSet(v string, args []string) error {
+	var typ api.DefinedType
+	switch v {
+	case CMD_PREFIX:
+		typ = api.DefinedType_PREFIX
+	case CMD_NEIGHBOR:
+		typ = api.DefinedType_NEIGHBOR
+	case CMD_ASPATH:
+		typ = api.DefinedType_AS_PATH
+	case CMD_COMMUNITY:
+		typ = api.DefinedType_COMMUNITY
+	case CMD_EXTCOMMUNITY:
+		typ = api.DefinedType_EXT_COMMUNITY
+	case CMD_LARGECOMMUNITY:
+		typ = api.DefinedType_LARGE_COMMUNITY
+	default:
+		return fmt.Errorf("unknown defined type: %s", v)
+	}
+	var m []*api.DefinedSet
+	if len(args) > 0 {
+		d, err := client.GetDefinedSetByName(typ, args[0])
+		if err != nil {
+			return err
+		}
+		m = []*api.DefinedSet{d}
+	} else {
+		var err error
+		m, err = client.GetDefinedSet(typ)
+		if err != nil {
+			return err
+		}
+	}
+	if globalOpts.Json {
+		j, _ := json.Marshal(m)
+		fmt.Println(string(j))
+		return nil
+	}
+	if globalOpts.Quiet {
+		if len(args) > 0 {
+			fmt.Println(m)
+		} else {
+			for _, p := range m {
+				fmt.Println(p.GetName())
+			}
+		}
+		return nil
+	}
+	var output string
+	switch v {
+	case CMD_PREFIX:
+		output = formatDefinedSet(true, "PREFIX", 0, m)
+	case CMD_NEIGHBOR:
+		output = formatDefinedSet(true, "ADDRESS", 0, m)
+	case CMD_ASPATH:
+		output = formatDefinedSet(true, "AS-PATH", 0, m)
+	case CMD_COMMUNITY:
+		output = formatDefinedSet(true, "COMMUNITY", 0, m)
+	case CMD_EXTCOMMUNITY:
+		output = formatDefinedSet(true, "EXT-COMMUNITY", 0, m)
+	case CMD_LARGECOMMUNITY:
+		output = formatDefinedSet(true, "LARGE-COMMUNITY", 0, m)
+	}
+	fmt.Print(output)
+	return nil
+}
+
+func parsePrefixSet(args []string) (*api.DefinedSet, error) {
+	if len(args) < 1 {
+		return nil, fmt.Errorf("empty neighbor set name")
+	}
+	name := args[0]
+	args = args[1:]
+	var list []*api.Prefix
+	if len(args) > 0 {
+		mask := ""
+		if len(args) > 1 {
+			mask = args[1]
+		}
+		min, max, err := config.ParseMaskLength(args[0], mask)
+		if err != nil {
+			return nil, err
+		}
+		prefix := &api.Prefix{
+			IpPrefix:      args[0],
+			MaskLengthMax: uint32(max),
+			MaskLengthMin: uint32(min),
+		}
+		list = []*api.Prefix{prefix}
+	}
+	return &api.DefinedSet{
+		Type:     api.DefinedType_PREFIX,
+		Name:     name,
+		Prefixes: list,
+	}, nil
+}
+
+func parseNeighborSet(args []string) (*api.DefinedSet, error) {
+	if len(args) < 1 {
+		return nil, fmt.Errorf("empty neighbor set name")
+	}
+	name := args[0]
+	args = args[1:]
+	list := make([]string, 0, len(args[1:]))
+	for _, arg := range args {
+		address := net.ParseIP(arg)
+		if address.To4() != nil {
+			list = append(list, fmt.Sprintf("%s/32", arg))
+		} else if address.To16() != nil {
+			list = append(list, fmt.Sprintf("%s/128", arg))
+		} else {
+			_, _, err := net.ParseCIDR(arg)
+			if err != nil {
+				return nil, fmt.Errorf("invalid address or prefix: %s\nplease enter ipv4 or ipv6 format", arg)
+			}
+		}
+	}
+	return &api.DefinedSet{
+		Type: api.DefinedType_NEIGHBOR,
+		Name: name,
+		List: list,
+	}, nil
+}
+
+func parseAsPathSet(args []string) (*api.DefinedSet, error) {
+	if len(args) < 1 {
+		return nil, fmt.Errorf("empty as-path set name")
+	}
+	name := args[0]
+	args = args[1:]
+	for _, arg := range args {
+		_, err := regexp.Compile(arg)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return &api.DefinedSet{
+		Type: api.DefinedType_AS_PATH,
+		Name: name,
+		List: args,
+	}, nil
+}
+
+func parseCommunitySet(args []string) (*api.DefinedSet, error) {
+	if len(args) < 1 {
+		return nil, fmt.Errorf("empty community set name")
+	}
+	name := args[0]
+	args = args[1:]
+	for _, arg := range args {
+		if _, err := parseCommunityRegexp(arg); err != nil {
+			return nil, err
+		}
+	}
+	return &api.DefinedSet{
+		Type: api.DefinedType_COMMUNITY,
+		Name: name,
+		List: args,
+	}, nil
+}
+
+func parseExtCommunitySet(args []string) (*api.DefinedSet, error) {
+	if len(args) < 1 {
+		return nil, fmt.Errorf("empty ext-community set name")
+	}
+	name := args[0]
+	args = args[1:]
+	for _, arg := range args {
+		if _, _, err := parseExtCommunityRegexp(arg); err != nil {
+			return nil, err
+		}
+	}
+	return &api.DefinedSet{
+		Type: api.DefinedType_EXT_COMMUNITY,
+		Name: name,
+		List: args,
+	}, nil
+}
+
+func parseLargeCommunitySet(args []string) (*api.DefinedSet, error) {
+	if len(args) < 1 {
+		return nil, fmt.Errorf("empty large-community set name")
+	}
+	name := args[0]
+	args = args[1:]
+	for _, arg := range args {
+		if _, err := parseLargeCommunityRegexp(arg); err != nil {
+			return nil, err
+		}
+	}
+	return &api.DefinedSet{
+		Type: api.DefinedType_LARGE_COMMUNITY,
+		Name: name,
+		List: args,
+	}, nil
+}
+
+func parseDefinedSet(settype string, args []string) (*api.DefinedSet, error) {
+	if len(args) < 1 {
+		return nil, fmt.Errorf("empty large-community set name")
+	}
+
+	switch settype {
+	case CMD_PREFIX:
+		return parsePrefixSet(args)
+	case CMD_NEIGHBOR:
+		return parseNeighborSet(args)
+	case CMD_ASPATH:
+		return parseAsPathSet(args)
+	case CMD_COMMUNITY:
+		return parseCommunitySet(args)
+	case CMD_EXTCOMMUNITY:
+		return parseExtCommunitySet(args)
+	case CMD_LARGECOMMUNITY:
+		return parseLargeCommunitySet(args)
+	default:
+		return nil, fmt.Errorf("invalid defined set type: %s", settype)
+	}
+}
+
+var modPolicyUsageFormat = map[string]string{
+	CMD_PREFIX:         "usage: policy prefix %s <name> [<prefix> [<mask range>]]",
+	CMD_NEIGHBOR:       "usage: policy neighbor %s <name> [<neighbor address>...]",
+	CMD_ASPATH:         "usage: policy aspath %s <name> [<regexp>...]",
+	CMD_COMMUNITY:      "usage: policy community %s <name> [<regexp>...]",
+	CMD_EXTCOMMUNITY:   "usage: policy extcommunity %s <name> [<regexp>...]",
+	CMD_LARGECOMMUNITY: "usage: policy large-community %s <name> [<regexp>...]",
+}
+
+func modDefinedSet(settype string, modtype string, args []string) error {
+	var d *api.DefinedSet
+	var err error
+	if len(args) < 1 {
+		return fmt.Errorf(modPolicyUsageFormat[settype], modtype)
+	}
+	if d, err = parseDefinedSet(settype, args); err != nil {
+		return err
+	}
+	switch modtype {
+	case CMD_ADD:
+		err = client.AddDefinedSet(d)
+	case CMD_DEL:
+		all := false
+		if len(args) < 2 {
+			all = true
+		}
+		err = client.DeleteDefinedSet(d, all)
+	case CMD_SET:
+		err = client.ReplaceDefinedSet(d)
+	}
+	return err
+}
+
+func printStatement(indent int, s *api.Statement) {
+	sIndent := func(indent int) string {
+		return strings.Repeat(" ", indent)
+	}
+	fmt.Printf("%sStatementName %s:\n", sIndent(indent), s.Name)
+	fmt.Printf("%sConditions:\n", sIndent(indent+2))
+
+	ind := sIndent(indent + 4)
+
+	c := s.Conditions
+	if c.PrefixSet != nil {
+		fmt.Printf("%sPrefixSet: %s \n", ind, prettyString(c.PrefixSet))
+	} else if c.NeighborSet != nil {
+		fmt.Printf("%sNeighborSet: %s\n", ind, prettyString(c.NeighborSet))
+	} else if c.AsPathSet != nil {
+		fmt.Printf("%sAsPathSet: %s \n", ind, prettyString(c.AsPathSet))
+	} else if c.CommunitySet != nil {
+		fmt.Printf("%sCommunitySet: %s\n", ind, prettyString(c.CommunitySet))
+	} else if c.ExtCommunitySet != nil {
+		fmt.Printf("%sExtCommunitySet: %s\n", ind, prettyString(c.ExtCommunitySet))
+	} else if c.LargeCommunitySet != nil {
+		fmt.Printf("%sLargeCommunitySet: %s\n", ind, prettyString(c.LargeCommunitySet))
+	} else if c.NextHopInList != nil {
+		fmt.Printf("%sNextHopInList: %s\n", ind, "[ "+strings.Join(c.NextHopInList, ", ")+" ]")
+	} else if c.AsPathLength != nil {
+		fmt.Printf("%sAsPathLength: %s\n", ind, prettyString(c.AsPathLength))
+	} else if c.RpkiResult != -1 {
+		var result string
+		switch c.RpkiResult {
+		case 0:
+			result = "none"
+		case 1:
+			result = "valid"
+		case 2:
+			result = "invalid"
+		case 3:
+			result = "not-found"
+		}
+		fmt.Printf("%sRPKI result: %s\n", ind, result)
+	} else if c.RouteType != api.Conditions_ROUTE_TYPE_NONE {
+		fmt.Printf("%sRoute Type: %s\n", ind, routeTypePrettyString(c.RouteType))
+	} else if c.AfiSafiIn != nil {
+		fmt.Printf("%sAFI SAFI In: %s\n", ind, c.AfiSafiIn)
+	}
+
+	fmt.Printf("%sActions:\n", sIndent(indent+2))
+	a := s.Actions
+	if a.Community != nil {
+		fmt.Println(ind, "Community: ", prettyString(a.Community))
+	} else if a.ExtCommunity != nil {
+		fmt.Println(ind, "ExtCommunity: ", prettyString(a.ExtCommunity))
+	} else if a.LargeCommunity != nil {
+		fmt.Println(ind, "LargeCommunity: ", prettyString(a.LargeCommunity))
+	} else if a.Med != nil {
+		fmt.Println(ind, "MED: ", prettyString(a.Med))
+	} else if a.LocalPref != nil {
+		fmt.Println(ind, "LocalPref: ", prettyString(a.LocalPref))
+	} else if a.AsPrepend != nil {
+		fmt.Println(ind, "ASPathPrepend: ", prettyString(a.AsPrepend))
+	} else if a.Nexthop != nil {
+		fmt.Println(ind, "Nexthop: ", prettyString(a.Nexthop))
+	}
+
+	if a.RouteAction != api.RouteAction_NONE {
+		action := "accept"
+		if a.RouteAction == api.RouteAction_REJECT {
+			action = "reject"
+		}
+		fmt.Println(ind, action)
+	}
+}
+
+func printPolicy(indent int, pd *api.Policy) {
+	for _, s := range pd.Statements {
+		printStatement(indent, s)
+	}
+}
+
+func showPolicy(args []string) error {
+	policies, err := client.GetPolicy()
+	if err != nil {
+		return err
+	}
+	var m []*api.Policy
+	if len(args) > 0 {
+		for _, p := range policies {
+			if args[0] == p.Name {
+				m = append(m, p)
+				break
+			}
+		}
+		if len(m) == 0 {
+			return fmt.Errorf("not found %s", args[0])
+		}
+	} else {
+		m = policies
+	}
+	if globalOpts.Json {
+		j, _ := json.Marshal(m)
+		fmt.Println(string(j))
+		return nil
+	}
+	if globalOpts.Quiet {
+		for _, p := range m {
+			fmt.Println(p.Name)
+		}
+		return nil
+	}
+
+	for _, pd := range m {
+		fmt.Printf("Name %s:\n", pd.Name)
+		printPolicy(4, pd)
+	}
+	return nil
+}
+
+func showStatement(args []string) error {
+	stmts, err := client.GetStatement()
+	if err != nil {
+		return err
+	}
+	var m []*api.Statement
+	if len(args) > 0 {
+		for _, s := range stmts {
+			if args[0] == s.Name {
+				m = append(m, s)
+				break
+			}
+		}
+		if len(m) == 0 {
+			return fmt.Errorf("not found %s", args[0])
+		}
+	} else {
+		m = stmts
+	}
+	if globalOpts.Json {
+		j, _ := json.Marshal(m)
+		fmt.Println(string(j))
+		return nil
+	}
+	if globalOpts.Quiet {
+		for _, s := range m {
+			fmt.Println(s.Name)
+		}
+		return nil
+	}
+	for _, s := range m {
+		printStatement(0, s)
+	}
+	return nil
+}
+
+func modStatement(op string, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: gobgp policy statement %s <name>", op)
+	}
+	stmt := &api.Statement{
+		Name: args[0],
+	}
+	var err error
+	switch op {
+	case CMD_ADD:
+		err = client.AddStatement(stmt)
+	case CMD_DEL:
+		err = client.DeleteStatement(stmt, false)
+	default:
+		return fmt.Errorf("invalid operation: %s", op)
+	}
+	return err
+}
+
+func modCondition(name, op string, args []string) error {
+	stmt := &api.Statement{
+		Name:       name,
+		Conditions: &api.Conditions{},
+	}
+	usage := fmt.Sprintf("usage: gobgp policy statement %s %s condition", name, op)
+	if len(args) < 1 {
+		return fmt.Errorf("%s { prefix | neighbor | as-path | community | ext-community | large-community | as-path-length | rpki | route-type | next-hop-in-list | afi-safi-in }", usage)
+	}
+	typ := args[0]
+	args = args[1:]
+	switch typ {
+	case "prefix":
+		stmt.Conditions.PrefixSet = &api.MatchSet{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s prefix <set-name> [{ any | invert }]", usage)
+		}
+		stmt.Conditions.PrefixSet.Name = args[0]
+		if len(args) == 1 {
+			break
+		}
+		switch strings.ToLower(args[1]) {
+		case "any":
+			stmt.Conditions.PrefixSet.Type = api.MatchType_ANY
+		case "invert":
+			stmt.Conditions.PrefixSet.Type = api.MatchType_INVERT
+		default:
+			return fmt.Errorf("%s prefix <set-name> [{ any | invert }]", usage)
+		}
+	case "neighbor":
+		stmt.Conditions.NeighborSet = &api.MatchSet{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s neighbor <set-name> [{ any | invert }]", usage)
+		}
+		stmt.Conditions.NeighborSet.Name = args[0]
+		if len(args) == 1 {
+			break
+		}
+		switch strings.ToLower(args[1]) {
+		case "any":
+			stmt.Conditions.NeighborSet.Type = api.MatchType_ANY
+		case "invert":
+			stmt.Conditions.NeighborSet.Type = api.MatchType_INVERT
+		default:
+			return fmt.Errorf("%s neighbor <set-name> [{ any | invert }]", usage)
+		}
+	case "as-path":
+		stmt.Conditions.AsPathSet = &api.MatchSet{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s as-path <set-name> [{ any | all | invert }]", usage)
+		}
+		stmt.Conditions.AsPathSet.Name = args[0]
+		if len(args) == 1 {
+			break
+		}
+		switch strings.ToLower(args[1]) {
+		case "any":
+			stmt.Conditions.AsPathSet.Type = api.MatchType_ANY
+		case "all":
+			stmt.Conditions.AsPathSet.Type = api.MatchType_ALL
+		case "invert":
+			stmt.Conditions.AsPathSet.Type = api.MatchType_INVERT
+		default:
+			return fmt.Errorf("%s as-path <set-name> [{ any | all | invert }]", usage)
+		}
+	case "community":
+		stmt.Conditions.CommunitySet = &api.MatchSet{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s community <set-name> [{ any | all | invert }]", usage)
+		}
+		stmt.Conditions.CommunitySet.Name = args[0]
+		if len(args) == 1 {
+			break
+		}
+		switch strings.ToLower(args[1]) {
+		case "any":
+			stmt.Conditions.CommunitySet.Type = api.MatchType_ANY
+		case "all":
+			stmt.Conditions.CommunitySet.Type = api.MatchType_ALL
+		case "invert":
+			stmt.Conditions.CommunitySet.Type = api.MatchType_INVERT
+		default:
+			return fmt.Errorf("%s community <set-name> [{ any | all | invert }]", usage)
+		}
+	case "ext-community":
+		stmt.Conditions.ExtCommunitySet = &api.MatchSet{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s ext-community <set-name> [{ any | all | invert }]", usage)
+		}
+		stmt.Conditions.ExtCommunitySet.Name = args[0]
+		if len(args) == 1 {
+			break
+		}
+		switch strings.ToLower(args[1]) {
+		case "any":
+			stmt.Conditions.ExtCommunitySet.Type = api.MatchType_ANY
+		case "all":
+			stmt.Conditions.ExtCommunitySet.Type = api.MatchType_ALL
+		case "invert":
+			stmt.Conditions.ExtCommunitySet.Type = api.MatchType_INVERT
+		default:
+			return fmt.Errorf("%s ext-community <set-name> [{ any | all | invert }]", usage)
+		}
+	case "large-community":
+		stmt.Conditions.LargeCommunitySet = &api.MatchSet{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s large-community <set-name> [{ any | all | invert }]", usage)
+		}
+		stmt.Conditions.LargeCommunitySet.Name = args[0]
+		if len(args) == 1 {
+			break
+		}
+		switch strings.ToLower(args[1]) {
+		case "any":
+			stmt.Conditions.LargeCommunitySet.Type = api.MatchType_ANY
+		case "all":
+			stmt.Conditions.LargeCommunitySet.Type = api.MatchType_ALL
+		case "invert":
+			stmt.Conditions.LargeCommunitySet.Type = api.MatchType_INVERT
+		default:
+			return fmt.Errorf("%s large-community <set-name> [{ any | all | invert }]", usage)
+		}
+	case "as-path-length":
+		stmt.Conditions.AsPathLength = &api.AsPathLength{}
+		if len(args) < 2 {
+			return fmt.Errorf("%s as-path-length <length> { eq | ge | le }", usage)
+		}
+		length, err := strconv.ParseUint(args[0], 10, 32)
+		if err != nil {
+			return err
+		}
+		stmt.Conditions.AsPathLength.Length = uint32(length)
+		switch strings.ToLower(args[1]) {
+		case "eq":
+			stmt.Conditions.AsPathLength.Type = api.AsPathLengthType_EQ
+		case "ge":
+			stmt.Conditions.AsPathLength.Type = api.AsPathLengthType_GE
+		case "le":
+			stmt.Conditions.AsPathLength.Type = api.AsPathLengthType_LE
+		default:
+			return fmt.Errorf("%s as-path-length <length> { eq | ge | le }", usage)
+		}
+	case "rpki":
+		if len(args) < 1 {
+			return fmt.Errorf("%s rpki { valid | invalid | not-found }", usage)
+		}
+		switch strings.ToLower(args[0]) {
+		case "valid":
+			stmt.Conditions.RpkiResult = int32(config.RpkiValidationResultTypeToIntMap[config.RPKI_VALIDATION_RESULT_TYPE_VALID])
+		case "invalid":
+			stmt.Conditions.RpkiResult = int32(config.RpkiValidationResultTypeToIntMap[config.RPKI_VALIDATION_RESULT_TYPE_INVALID])
+		case "not-found":
+			stmt.Conditions.RpkiResult = int32(config.RpkiValidationResultTypeToIntMap[config.RPKI_VALIDATION_RESULT_TYPE_NOT_FOUND])
+		default:
+			return fmt.Errorf("%s rpki { valid | invalid | not-found }", usage)
+		}
+	case "route-type":
+		err := fmt.Errorf("%s route-type { internal | external | local }", usage)
+		if len(args) < 1 {
+			return err
+		}
+		switch strings.ToLower(args[0]) {
+		case "internal":
+			stmt.Conditions.RouteType = api.Conditions_ROUTE_TYPE_INTERNAL
+		case "external":
+			stmt.Conditions.RouteType = api.Conditions_ROUTE_TYPE_EXTERNAL
+		case "local":
+			stmt.Conditions.RouteType = api.Conditions_ROUTE_TYPE_LOCAL
+		default:
+			return err
+		}
+	case "next-hop-in-list":
+		stmt.Conditions.NextHopInList = args
+	case "afi-safi-in":
+		afiSafisInList := make([]api.Family, 0, len(args))
+		for _, arg := range args {
+			afiSafisInList = append(afiSafisInList, api.Family(bgp.AddressFamilyValueMap[arg]))
+		}
+		stmt.Conditions.AfiSafiIn = afiSafisInList
+	default:
+		return fmt.Errorf("%s { prefix | neighbor | as-path | community | ext-community | large-community | as-path-length | rpki | route-type | next-hop-in-list | afi-safi-in }", usage)
+	}
+
+	var err error
+	switch op {
+	case CMD_ADD:
+		err = client.AddStatement(stmt)
+	case CMD_DEL:
+		err = client.DeleteStatement(stmt, false)
+	case CMD_SET:
+		err = client.ReplaceStatement(stmt)
+	default:
+		return fmt.Errorf("invalid operation: %s", op)
+	}
+	return err
+}
+
+func modAction(name, op string, args []string) error {
+	stmt := &api.Statement{
+		Name:    name,
+		Actions: &api.Actions{},
+	}
+	usage := fmt.Sprintf("usage: gobgp policy statement %s %s action", name, op)
+	if len(args) < 1 {
+		return fmt.Errorf("%s { reject | accept | community | ext-community | large-community | med | local-pref | as-prepend | next-hop }", usage)
+	}
+	typ := args[0]
+	args = args[1:]
+	switch typ {
+	case "reject":
+		stmt.Actions.RouteAction = api.RouteAction_REJECT
+	case "accept":
+		stmt.Actions.RouteAction = api.RouteAction_ACCEPT
+	case "community":
+		stmt.Actions.Community = &api.CommunityAction{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s community { add | remove | replace } <value>...", usage)
+		}
+		stmt.Actions.Community.Communities = args[1:]
+		switch strings.ToLower(args[0]) {
+		case "add":
+			stmt.Actions.Community.Type = api.CommunityActionType_COMMUNITY_ADD
+		case "remove":
+			stmt.Actions.Community.Type = api.CommunityActionType_COMMUNITY_REMOVE
+		case "replace":
+			stmt.Actions.Community.Type = api.CommunityActionType_COMMUNITY_REPLACE
+		default:
+			return fmt.Errorf("%s community { add | remove | replace } <value>...", usage)
+		}
+	case "ext-community":
+		stmt.Actions.ExtCommunity = &api.CommunityAction{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s ext-community { add | remove | replace } <value>...", usage)
+		}
+		stmt.Actions.ExtCommunity.Communities = args[1:]
+		switch strings.ToLower(args[0]) {
+		case "add":
+			stmt.Actions.ExtCommunity.Type = api.CommunityActionType_COMMUNITY_ADD
+		case "remove":
+			stmt.Actions.ExtCommunity.Type = api.CommunityActionType_COMMUNITY_REMOVE
+		case "replace":
+			stmt.Actions.ExtCommunity.Type = api.CommunityActionType_COMMUNITY_REPLACE
+		default:
+			return fmt.Errorf("%s ext-community { add | remove | replace } <value>...", usage)
+		}
+	case "large-community":
+		stmt.Actions.LargeCommunity = &api.CommunityAction{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s large-community { add | remove | replace } <value>...", usage)
+		}
+		stmt.Actions.LargeCommunity.Communities = args[1:]
+		switch strings.ToLower(args[0]) {
+		case "add":
+			stmt.Actions.LargeCommunity.Type = api.CommunityActionType_COMMUNITY_ADD
+		case "remove":
+			stmt.Actions.LargeCommunity.Type = api.CommunityActionType_COMMUNITY_REMOVE
+		case "replace":
+			stmt.Actions.LargeCommunity.Type = api.CommunityActionType_COMMUNITY_REPLACE
+		default:
+			return fmt.Errorf("%s large-community { add | remove | replace } <value>...", usage)
+		}
+	case "med":
+		stmt.Actions.Med = &api.MedAction{}
+		if len(args) < 2 {
+			return fmt.Errorf("%s med { add | sub | set } <value>", usage)
+		}
+		med, err := strconv.ParseInt(args[1], 10, 32)
+		if err != nil {
+			return err
+		}
+		stmt.Actions.Med.Value = int64(med)
+		switch strings.ToLower(args[0]) {
+		case "add":
+			stmt.Actions.Med.Type = api.MedActionType_MED_MOD
+		case "sub":
+			stmt.Actions.Med.Type = api.MedActionType_MED_MOD
+			stmt.Actions.Med.Value = -1 * stmt.Actions.Med.Value
+		case "set":
+			stmt.Actions.Med.Type = api.MedActionType_MED_REPLACE
+		default:
+			return fmt.Errorf("%s med { add | sub | set } <value>", usage)
+		}
+	case "local-pref":
+		stmt.Actions.LocalPref = &api.LocalPrefAction{}
+		if len(args) < 1 {
+			return fmt.Errorf("%s local-pref <value>", usage)
+		}
+		value, err := strconv.ParseUint(args[0], 10, 32)
+		if err != nil {
+			return err
+		}
+		stmt.Actions.LocalPref.Value = uint32(value)
+	case "as-prepend":
+		stmt.Actions.AsPrepend = &api.AsPrependAction{}
+		if len(args) < 2 {
+			return fmt.Errorf("%s as-prepend { <asn> | last-as } <repeat-value>", usage)
+		}
+		asn, _ := strconv.ParseUint(args[0], 10, 32)
+		stmt.Actions.AsPrepend.Asn = uint32(asn)
+		repeat, err := strconv.ParseUint(args[1], 10, 8)
+		if err != nil {
+			return err
+		}
+		stmt.Actions.AsPrepend.Repeat = uint32(repeat)
+	case "next-hop":
+		stmt.Actions.Nexthop = &api.NexthopAction{}
+		if len(args) != 1 {
+			return fmt.Errorf("%s next-hop { <value> | self }", usage)
+		}
+		stmt.Actions.Nexthop.Address = args[0]
+	}
+	var err error
+	switch op {
+	case CMD_ADD:
+		err = client.AddStatement(stmt)
+	case CMD_DEL:
+		err = client.DeleteStatement(stmt, false)
+	case CMD_SET:
+		err = client.ReplaceStatement(stmt)
+	default:
+		return fmt.Errorf("invalid operation: %s", op)
+	}
+	return err
+}
+
+func modPolicy(modtype string, args []string) error {
+	if len(args) < 1 {
+		return fmt.Errorf("usage: gobgp policy %s <name> [<statement name>...]", modtype)
+	}
+	name := args[0]
+	args = args[1:]
+	stmts := make([]*api.Statement, 0, len(args))
+	for _, n := range args {
+		stmts = append(stmts, &api.Statement{Name: n})
+	}
+	policy := &api.Policy{
+		Name:       name,
+		Statements: stmts,
+	}
+
+	var err error
+	switch modtype {
+	case CMD_ADD:
+		err = client.AddPolicy(policy, true)
+	case CMD_DEL:
+		all := false
+		if len(args) < 1 {
+			all = true
+		}
+		err = client.DeletePolicy(policy, all, true)
+	case CMD_SET:
+		err = client.ReplacePolicy(policy, true, true)
+	}
+	return err
+}
+
+func NewPolicyCmd() *cobra.Command {
+	policyCmd := &cobra.Command{
+		Use: CMD_POLICY,
+		Run: func(cmd *cobra.Command, args []string) {
+			err := showPolicy(args)
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+
+	for _, v := range []string{CMD_PREFIX, CMD_NEIGHBOR, CMD_ASPATH, CMD_COMMUNITY, CMD_EXTCOMMUNITY, CMD_LARGECOMMUNITY} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(cmd *cobra.Command, args []string) {
+				if err := showDefinedSet(cmd.Use, args); err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+		for _, w := range []string{CMD_ADD, CMD_DEL, CMD_SET} {
+			subcmd := &cobra.Command{
+				Use: w,
+				Run: func(c *cobra.Command, args []string) {
+					if err := modDefinedSet(cmd.Use, c.Use, args); err != nil {
+						exitWithError(err)
+					}
+				},
+			}
+			cmd.AddCommand(subcmd)
+		}
+		policyCmd.AddCommand(cmd)
+	}
+
+	stmtCmdImpl := &cobra.Command{}
+	for _, v := range []string{CMD_ADD, CMD_DEL, CMD_SET} {
+		cmd := &cobra.Command{
+			Use: v,
+		}
+		for _, w := range []string{CMD_CONDITION, CMD_ACTION} {
+			subcmd := &cobra.Command{
+				Use: w,
+				Run: func(c *cobra.Command, args []string) {
+					name := args[len(args)-1]
+					args = args[:len(args)-1]
+					var err error
+					if c.Use == CMD_CONDITION {
+						err = modCondition(name, cmd.Use, args)
+					} else {
+						err = modAction(name, cmd.Use, args)
+					}
+					if err != nil {
+						exitWithError(err)
+					}
+				},
+			}
+			cmd.AddCommand(subcmd)
+		}
+		stmtCmdImpl.AddCommand(cmd)
+	}
+
+	stmtCmd := &cobra.Command{
+		Use: CMD_STATEMENT,
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			if len(args) < 2 {
+				err = showStatement(args)
+			} else {
+				args = append(args[1:], args[0])
+				stmtCmdImpl.SetArgs(args)
+				err = stmtCmdImpl.Execute()
+			}
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+	for _, v := range []string{CMD_ADD, CMD_DEL} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(c *cobra.Command, args []string) {
+				err := modStatement(c.Use, args)
+				if err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+		stmtCmd.AddCommand(cmd)
+	}
+	policyCmd.AddCommand(stmtCmd)
+
+	for _, v := range []string{CMD_ADD, CMD_DEL, CMD_SET} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(c *cobra.Command, args []string) {
+				err := modPolicy(c.Use, args)
+				if err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+		policyCmd.AddCommand(cmd)
+	}
+
+	return policyCmd
+}
diff --git a/cmd/gobgp/cmd/root.go b/cmd/gobgp/cmd/root.go
new file mode 100644
index 00000000..90df5ee4
--- /dev/null
+++ b/cmd/gobgp/cmd/root.go
@@ -0,0 +1,94 @@
+// 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 cmd
+
+import (
+	"fmt"
+	"net/http"
+	_ "net/http/pprof"
+
+	cli "github.com/osrg/gobgp/internal/pkg/client"
+	"github.com/spf13/cobra"
+)
+
+var globalOpts struct {
+	Host         string
+	Port         int
+	Debug        bool
+	Quiet        bool
+	Json         bool
+	GenCmpl      bool
+	BashCmplFile string
+	PprofPort    int
+	TLS          bool
+	CaFile       string
+}
+
+var client *cli.Client
+
+func NewRootCmd() *cobra.Command {
+	cobra.EnablePrefixMatching = true
+	rootCmd := &cobra.Command{
+		Use: "gobgp",
+		PersistentPreRun: func(cmd *cobra.Command, args []string) {
+			if globalOpts.PprofPort > 0 {
+				go func() {
+					if err := http.ListenAndServe(fmt.Sprintf("localhost:%d", globalOpts.PprofPort), nil); err != nil {
+						exitWithError(err)
+					}
+				}()
+			}
+
+			if !globalOpts.GenCmpl {
+				client = newClient()
+			}
+		},
+		Run: func(cmd *cobra.Command, args []string) {
+			if globalOpts.GenCmpl {
+				cmd.GenBashCompletionFile(globalOpts.BashCmplFile)
+			} else {
+				cmd.HelpFunc()(cmd, args)
+			}
+		},
+		PersistentPostRun: func(cmd *cobra.Command, args []string) {
+			if client != nil {
+				client.Close()
+			}
+		},
+	}
+
+	rootCmd.PersistentFlags().StringVarP(&globalOpts.Host, "host", "u", "127.0.0.1", "host")
+	rootCmd.PersistentFlags().IntVarP(&globalOpts.Port, "port", "p", 50051, "port")
+	rootCmd.PersistentFlags().BoolVarP(&globalOpts.Json, "json", "j", false, "use json format to output format")
+	rootCmd.PersistentFlags().BoolVarP(&globalOpts.Debug, "debug", "d", false, "use debug")
+	rootCmd.PersistentFlags().BoolVarP(&globalOpts.Quiet, "quiet", "q", false, "use quiet")
+	rootCmd.PersistentFlags().BoolVarP(&globalOpts.GenCmpl, "gen-cmpl", "c", false, "generate completion file")
+	rootCmd.PersistentFlags().StringVarP(&globalOpts.BashCmplFile, "bash-cmpl-file", "", "gobgp-completion.bash", "bash cmpl filename")
+	rootCmd.PersistentFlags().IntVarP(&globalOpts.PprofPort, "pprof-port", "r", 0, "pprof port")
+	rootCmd.PersistentFlags().BoolVarP(&globalOpts.TLS, "tls", "", false, "connection uses TLS if true, else plain TCP")
+	rootCmd.PersistentFlags().StringVarP(&globalOpts.CaFile, "tls-ca-file", "", "", "The file containing the CA root cert file")
+
+	globalCmd := NewGlobalCmd()
+	neighborCmd := NewNeighborCmd()
+	vrfCmd := NewVrfCmd()
+	policyCmd := NewPolicyCmd()
+	monitorCmd := NewMonitorCmd()
+	mrtCmd := NewMrtCmd()
+	rpkiCmd := NewRPKICmd()
+	bmpCmd := NewBmpCmd()
+	rootCmd.AddCommand(globalCmd, neighborCmd, vrfCmd, policyCmd, monitorCmd, mrtCmd, rpkiCmd, bmpCmd)
+	return rootCmd
+}
diff --git a/cmd/gobgp/cmd/rpki.go b/cmd/gobgp/cmd/rpki.go
new file mode 100644
index 00000000..853892d4
--- /dev/null
+++ b/cmd/gobgp/cmd/rpki.go
@@ -0,0 +1,162 @@
+// 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 cmd
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+	"github.com/spf13/cobra"
+)
+
+func showRPKIServer(args []string) error {
+	servers, err := client.GetRPKI()
+	if err != nil {
+		fmt.Println(err)
+		return err
+	}
+	if len(args) == 0 {
+		format := "%-23s %-6s %-10s %s\n"
+		fmt.Printf(format, "Session", "State", "Uptime", "#IPv4/IPv6 records")
+		for _, r := range servers {
+			s := "Down"
+			uptime := "never"
+			if r.State.Up {
+				s = "Up"
+				uptime = fmt.Sprint(formatTimedelta(int64(time.Since(time.Unix(r.State.Uptime, 0)).Seconds())))
+			}
+
+			fmt.Printf(format, net.JoinHostPort(r.Config.Address, fmt.Sprintf("%d", r.Config.Port)), s, uptime, fmt.Sprintf("%d/%d", r.State.RecordsV4, r.State.RecordsV6))
+		}
+		return nil
+	}
+
+	for _, r := range servers {
+		if r.Config.Address == args[0] {
+			up := "Down"
+			if r.State.Up {
+				up = "Up"
+			}
+			fmt.Printf("Session: %s, State: %s\n", r.Config.Address, up)
+			fmt.Println("  Port:", r.Config.Port)
+			fmt.Println("  Serial:", r.State.SerialNumber)
+			fmt.Printf("  Prefix: %d/%d\n", r.State.PrefixesV4, r.State.PrefixesV6)
+			fmt.Printf("  Record: %d/%d\n", r.State.RecordsV4, r.State.RecordsV6)
+			fmt.Println("  Message statistics:")
+			fmt.Printf("    Receivedv4:    %10d\n", r.State.RpkiMessages.RpkiReceived.Ipv4Prefix)
+			fmt.Printf("    Receivedv6:    %10d\n", r.State.RpkiMessages.RpkiReceived.Ipv4Prefix)
+			fmt.Printf("    SerialNotify:  %10d\n", r.State.RpkiMessages.RpkiReceived.SerialNotify)
+			fmt.Printf("    CacheReset:    %10d\n", r.State.RpkiMessages.RpkiReceived.CacheReset)
+			fmt.Printf("    CacheResponse: %10d\n", r.State.RpkiMessages.RpkiReceived.CacheResponse)
+			fmt.Printf("    EndOfData:     %10d\n", r.State.RpkiMessages.RpkiReceived.EndOfData)
+			fmt.Printf("    Error:         %10d\n", r.State.RpkiMessages.RpkiReceived.Error)
+			fmt.Printf("    SerialQuery:   %10d\n", r.State.RpkiMessages.RpkiSent.SerialQuery)
+			fmt.Printf("    ResetQuery:    %10d\n", r.State.RpkiMessages.RpkiSent.ResetQuery)
+		}
+	}
+	return nil
+}
+
+func showRPKITable(args []string) error {
+	family, err := checkAddressFamily(bgp.RouteFamily(0))
+	if err != nil {
+		exitWithError(err)
+	}
+	roas, err := client.GetROA(family)
+	if err != nil {
+		exitWithError(err)
+	}
+
+	var format string
+	afi, _ := bgp.RouteFamilyToAfiSafi(family)
+	if afi == bgp.AFI_IP {
+		format = "%-18s %-6s %-10s %s\n"
+	} else {
+		format = "%-42s %-6s %-10s %s\n"
+	}
+	fmt.Printf(format, "Network", "Maxlen", "AS", "Server")
+	for _, r := range roas {
+		if len(args) > 0 && args[0] != r.Conf.Address {
+			continue
+		}
+		fmt.Printf(format, r.Prefix, fmt.Sprint(r.Maxlen), fmt.Sprint(r.As), net.JoinHostPort(r.Conf.Address, r.Conf.RemotePort))
+	}
+	return nil
+}
+
+func NewRPKICmd() *cobra.Command {
+	rpkiCmd := &cobra.Command{
+		Use: CMD_RPKI,
+	}
+
+	serverCmd := &cobra.Command{
+		Use: CMD_RPKI_SERVER,
+		Run: func(cmd *cobra.Command, args []string) {
+			if len(args) == 0 || len(args) == 1 {
+				showRPKIServer(args)
+				return
+			} else if len(args) != 2 {
+				exitWithError(fmt.Errorf("usage: gobgp rpki server <ip address> [reset|softreset|enable]"))
+			}
+			addr := net.ParseIP(args[0])
+			if addr == nil {
+				exitWithError(fmt.Errorf("invalid ip address: %s", args[0]))
+			}
+			var err error
+			switch args[1] {
+			case "add":
+				err = client.AddRPKIServer(addr.String(), 323, 0)
+			case "reset":
+				err = client.ResetRPKIServer(addr.String())
+			case "softreset":
+				err = client.SoftResetRPKIServer(addr.String())
+			case "enable":
+				err = client.EnableRPKIServer(addr.String())
+			case "disable":
+				err = client.DisableRPKIServer(addr.String())
+			default:
+				exitWithError(fmt.Errorf("unknown operation: %s", args[1]))
+			}
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+	rpkiCmd.AddCommand(serverCmd)
+
+	tableCmd := &cobra.Command{
+		Use: CMD_RPKI_TABLE,
+		Run: func(cmd *cobra.Command, args []string) {
+			showRPKITable(args)
+		},
+	}
+	tableCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+
+	validateCmd := &cobra.Command{
+		Use: "validate",
+		Run: func(cmd *cobra.Command, args []string) {
+			if err := client.ValidateRIBWithRPKI(args...); err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+	rpkiCmd.AddCommand(validateCmd)
+
+	rpkiCmd.AddCommand(tableCmd)
+	return rpkiCmd
+}
diff --git a/cmd/gobgp/cmd/rpki_test.go b/cmd/gobgp/cmd/rpki_test.go
new file mode 100644
index 00000000..af4a9cd1
--- /dev/null
+++ b/cmd/gobgp/cmd/rpki_test.go
@@ -0,0 +1,76 @@
+// 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.
+
+package cmd
+
+import (
+	"testing"
+	"time"
+
+	"github.com/osrg/gobgp/internal/pkg/config"
+	"github.com/osrg/gobgp/pkg/server"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestShowRPKITable(test *testing.T) {
+	assert := assert.New(test)
+
+	s := server.NewBgpServer()
+	go s.Serve()
+
+	g := server.NewGrpcServer(s, ":50051")
+	go g.Serve()
+
+	err := s.Start(&config.Global{
+		Config: config.GlobalConfig{
+			As:       1,
+			RouterId: "1.1.1.1",
+			Port:     -1,
+		},
+	})
+	assert.Nil(err)
+	defer s.Stop()
+
+	// MF RPKI Project
+	// http://www.mfeed.ad.jp/rpki/en/roa_cache/technical_info.html
+	rpki := &config.RpkiServerConfig{
+		Address: "210.173.170.254",
+		Port:    323,
+	}
+	err = s.AddRpki(rpki)
+	assert.Nil(err)
+
+	globalOpts.Host = "127.0.0.1"
+	globalOpts.Port = 50051
+	client = newClient()
+	defer client.Close()
+
+	// Wait for downloading ROA info
+	for i := 0; ; i++ {
+		if servers, err := s.GetRpki(); err == nil && len(servers) > 0 {
+			if servers[0].State.RecordsV4 > 0 {
+				break
+			}
+		}
+		if i > 10 {
+			test.Error("timeout to download ROA info")
+			break
+		}
+		time.Sleep(1 * time.Second)
+	}
+
+	err = showRPKITable(nil)
+	assert.Nil(err)
+}
diff --git a/cmd/gobgp/cmd/vrf.go b/cmd/gobgp/cmd/vrf.go
new file mode 100644
index 00000000..fd55dc0a
--- /dev/null
+++ b/cmd/gobgp/cmd/vrf.go
@@ -0,0 +1,264 @@
+// 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 cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	api "github.com/osrg/gobgp/api"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+
+	"github.com/golang/protobuf/ptypes/any"
+	"github.com/spf13/cobra"
+)
+
+func getVrfs() (vrfs, error) {
+	ret, err := client.GetVRF()
+	if err != nil {
+		return nil, err
+	}
+	sort.Sort(vrfs(ret))
+	return ret, nil
+}
+
+func showVrfs() error {
+	maxLens := []int{20, 20, 20, 20, 5}
+	vrfs, err := getVrfs()
+	if err != nil {
+		return err
+	}
+	if globalOpts.Json {
+		j, _ := json.Marshal(vrfs)
+		fmt.Println(string(j))
+		return nil
+	}
+	if globalOpts.Quiet {
+		for _, v := range vrfs {
+			fmt.Println(v.Name)
+		}
+		return nil
+	}
+	lines := make([][]string, 0, len(vrfs))
+	for _, v := range vrfs {
+		name := v.Name
+		rd, err := api.UnmarshalRD(v.Rd)
+		if err != nil {
+			return err
+		}
+		rdStr := rd.String()
+
+		f := func(rts []*any.Any) (string, error) {
+			ret := make([]string, 0, len(rts))
+			for _, an := range rts {
+				rt, err := api.UnmarshalRT(an)
+				if err != nil {
+					return "", err
+				}
+				ret = append(ret, rt.String())
+			}
+			return strings.Join(ret, ", "), nil
+		}
+
+		importRts, err := f(v.ImportRt)
+		if err != nil {
+			return err
+		}
+		exportRts, err := f(v.ExportRt)
+		if err != nil {
+			return err
+		}
+		lines = append(lines, []string{name, rdStr, importRts, exportRts, fmt.Sprintf("%d", v.Id)})
+
+		for i, v := range []int{len(name), len(rdStr), len(importRts), len(exportRts)} {
+			if v > maxLens[i] {
+				maxLens[i] = v + 4
+			}
+		}
+
+	}
+	format := fmt.Sprintf("  %%-%ds %%-%ds %%-%ds %%-%ds %%-%ds\n", maxLens[0], maxLens[1], maxLens[2], maxLens[3], maxLens[4])
+	fmt.Printf(format, "Name", "RD", "Import RT", "Export RT", "ID")
+	for _, l := range lines {
+		fmt.Printf(format, l[0], l[1], l[2], l[3], l[4])
+	}
+	return nil
+}
+
+func showVrf(name string) error {
+	return showNeighborRib(CMD_VRF, name, nil)
+}
+
+func modVrf(typ string, args []string) error {
+	var err error
+	switch typ {
+	case CMD_ADD:
+		a, err := extractReserved(args, map[string]int{
+			"rd": PARAM_SINGLE,
+			"rt": PARAM_LIST,
+			"id": PARAM_SINGLE})
+		if err != nil || len(a[""]) != 1 || len(a["rd"]) != 1 || len(a["rt"]) < 2 {
+			return fmt.Errorf("Usage: gobgp vrf add <vrf name> [ id <id> ] rd <rd> rt { import | export | both } <rt>...")
+		}
+		name := a[""][0]
+		var rd bgp.RouteDistinguisherInterface
+		rd, err = bgp.ParseRouteDistinguisher(a["rd"][0])
+		if err != nil {
+			return err
+		}
+		cur := ""
+		importRt := make([]bgp.ExtendedCommunityInterface, 0)
+		exportRt := make([]bgp.ExtendedCommunityInterface, 0)
+		for _, elem := range a["rt"] {
+			if elem == "import" || elem == "export" || elem == "both" {
+				cur = elem
+				continue
+			}
+			rt, err := bgp.ParseRouteTarget(elem)
+			if err != nil {
+				return err
+			}
+			switch cur {
+			case "import":
+				importRt = append(importRt, rt)
+			case "export":
+				exportRt = append(exportRt, rt)
+			case "both":
+				importRt = append(importRt, rt)
+				exportRt = append(exportRt, rt)
+			default:
+				return fmt.Errorf("Usage: gobgp vrf add <vrf name> rd <rd> rt { import | export | both } <rt>...")
+			}
+		}
+		var id uint64
+		if len(a["id"]) > 0 {
+			id, err = strconv.ParseUint(a["id"][0], 10, 32)
+			if err != nil {
+				return err
+			}
+		}
+		if err := client.AddVRF(name, int(id), rd, importRt, exportRt); err != nil {
+			return err
+		}
+	case CMD_DEL:
+		if len(args) != 1 {
+			return fmt.Errorf("Usage: gobgp vrf del <vrf name>")
+		}
+		err = client.DeleteVRF(args[0])
+	}
+	return err
+}
+
+func NewVrfCmd() *cobra.Command {
+	ribCmd := &cobra.Command{
+		Use: CMD_RIB,
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			if len(args) == 1 {
+				err = showVrf(args[0])
+			} else {
+				err = fmt.Errorf("usage: gobgp vrf <vrf-name> rib")
+			}
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+
+	for _, v := range []string{CMD_ADD, CMD_DEL} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(cmd *cobra.Command, args []string) {
+				err := modPath(CMD_VRF, args[len(args)-1], cmd.Use, args[:len(args)-1])
+				if err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+		ribCmd.AddCommand(cmd)
+	}
+
+	neighborCmd := &cobra.Command{
+		Use: CMD_NEIGHBOR,
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			if len(args) == 1 {
+				var vs vrfs
+				vs, err = getVrfs()
+				if err != nil {
+					exitWithError(err)
+				}
+				found := false
+				for _, v := range vs {
+					if v.Name == args[0] {
+						found = true
+						break
+					}
+				}
+				if !found {
+					err = fmt.Errorf("vrf %s not found", args[0])
+				} else {
+					err = showNeighbors(args[0])
+				}
+			} else {
+				err = fmt.Errorf("usage: gobgp vrf <vrf-name> neighbor")
+			}
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+
+	vrfCmdImpl := &cobra.Command{}
+	vrfCmdImpl.AddCommand(ribCmd, neighborCmd)
+
+	vrfCmd := &cobra.Command{
+		Use: CMD_VRF,
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			if len(args) == 0 {
+				err = showVrfs()
+			} else if len(args) == 1 {
+			} else {
+				args = append(args[1:], args[0])
+				vrfCmdImpl.SetArgs(args)
+				err = vrfCmdImpl.Execute()
+			}
+			if err != nil {
+				exitWithError(err)
+			}
+		},
+	}
+
+	for _, v := range []string{CMD_ADD, CMD_DEL} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(cmd *cobra.Command, args []string) {
+				err := modVrf(cmd.Use, args)
+				if err != nil {
+					exitWithError(err)
+				}
+			},
+		}
+		vrfCmd.AddCommand(cmd)
+	}
+	vrfCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+
+	return vrfCmd
+}
diff --git a/cmd/gobgp/lib/lib.go b/cmd/gobgp/lib/lib.go
new file mode 100644
index 00000000..ee71a859
--- /dev/null
+++ b/cmd/gobgp/lib/lib.go
@@ -0,0 +1,78 @@
+// 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 main
+
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <string.h>
+// typedef struct {
+//     char *value;
+//     int len;
+// } buf;
+//
+// typedef struct path_t {
+//     buf   nlri;
+//     buf** path_attributes;
+//     int   path_attributes_len;
+//     int   path_attributes_cap;
+// } path;
+//
+// path* new_path() {
+//	path* p;
+//	int cap = 32;
+//	p = (path*)malloc(sizeof(path));
+//	memset(p, 0, sizeof(path));
+//	p->nlri.len = 0;
+//	p->path_attributes_len = 0;
+//	p->path_attributes_cap = cap;
+//	p->path_attributes = (buf**)malloc(sizeof(buf)*cap);
+//	return p;
+// }
+//
+// void free_path(path* p) {
+//	int i;
+//	if (p->nlri.value != NULL) {
+//	    free(p->nlri.value);
+//	}
+//	for (i = 0; i < p->path_attributes_len; i++) {
+//	    buf* b;
+//	    b = p->path_attributes[i];
+//	    free(b->value);
+//	    free(b);
+//	}
+//	free(p->path_attributes);
+//	free(p);
+// }
+//
+// int append_path_attribute(path* p, int len, char* value) {
+//	buf* b;
+//	if (p->path_attributes_len >= p->path_attributes_cap) {
+//	    return -1;
+//	}
+//	b = (buf*)malloc(sizeof(buf));
+//	b->value = value;
+//	b->len = len;
+//	p->path_attributes[p->path_attributes_len] = b;
+//	p->path_attributes_len++;
+//	return 0;
+// }
+// buf* get_path_attribute(path* p, int idx) {
+//	if (idx < 0 || idx >= p->path_attributes_len) {
+//	    return NULL;
+//	}
+//	return p->path_attributes[idx];
+// }
+import "C"
diff --git a/cmd/gobgp/lib/path.go b/cmd/gobgp/lib/path.go
new file mode 100644
index 00000000..130f5444
--- /dev/null
+++ b/cmd/gobgp/lib/path.go
@@ -0,0 +1,143 @@
+// 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 main
+
+// typedef struct {
+//     char *value;
+//     int len;
+// } buf;
+//
+// typedef struct path_t {
+//     buf   nlri;
+//     buf** path_attributes;
+//     int   path_attributes_len;
+//     int   path_attributes_cap;
+// } path;
+// extern path* new_path();
+// extern void free_path(path*);
+// extern int append_path_attribute(path*, int, char*);
+// extern buf* get_path_attribute(path*, int);
+import "C"
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/osrg/gobgp/cmd/gobgp/cmd"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+)
+
+//export get_route_family
+func get_route_family(input *C.char) C.int {
+	rf, err := bgp.GetRouteFamily(C.GoString(input))
+	if err != nil {
+		return C.int(-1)
+	}
+	return C.int(rf)
+}
+
+//export serialize_path
+func serialize_path(rf C.int, input *C.char) *C.path {
+	args := strings.Split(C.GoString(input), " ")
+	p, err := cmd.ParsePath(bgp.RouteFamily(rf), args)
+	if err != nil {
+		return nil
+	}
+	path := C.new_path()
+	if nlri, err := p.GetNativeNlri(); err != nil {
+		return nil
+	} else {
+		buf, _ := nlri.Serialize()
+		path.nlri.len = C.int(len(buf))
+		path.nlri.value = C.CString(string(buf))
+	}
+	attrs, err := p.GetNativePathAttributes()
+	if err != nil {
+		return nil
+	}
+	for _, attr := range attrs {
+		buf, err := attr.Serialize()
+		if err != nil {
+			return nil
+		}
+		C.append_path_attribute(path, C.int(len(buf)), C.CString(string(buf)))
+	}
+	return path
+}
+
+//export decode_path
+func decode_path(p *C.path) *C.char {
+	var buf []byte
+	var nlri bgp.AddrPrefixInterface
+	if p.nlri.len > 0 {
+		buf = []byte(C.GoStringN(p.nlri.value, p.nlri.len))
+		nlri = &bgp.IPAddrPrefix{}
+		err := nlri.DecodeFromBytes(buf)
+		if err != nil {
+			return nil
+		}
+	}
+	pattrs := make([]bgp.PathAttributeInterface, 0, int(p.path_attributes_len))
+	for i := 0; i < int(p.path_attributes_len); i++ {
+		b := C.get_path_attribute(p, C.int(i))
+		buf = []byte(C.GoStringN(b.value, b.len))
+		pattr, err := bgp.GetPathAttribute(buf)
+		if err != nil {
+			return nil
+		}
+
+		err = pattr.DecodeFromBytes(buf)
+		if err != nil {
+			return nil
+		}
+
+		switch pattr.GetType() {
+		case bgp.BGP_ATTR_TYPE_MP_REACH_NLRI:
+			mpreach := pattr.(*bgp.PathAttributeMpReachNLRI)
+			if len(mpreach.Value) != 1 {
+				return nil
+			}
+			nlri = mpreach.Value[0]
+		}
+
+		pattrs = append(pattrs, pattr)
+	}
+	j, _ := json.Marshal(struct {
+		Nlri      bgp.AddrPrefixInterface      `json:"nlri"`
+		PathAttrs []bgp.PathAttributeInterface `json:"attrs"`
+	}{
+		Nlri:      nlri,
+		PathAttrs: pattrs,
+	})
+	return C.CString(string(j))
+}
+
+//export decode_capabilities
+func decode_capabilities(p *C.buf) *C.char {
+	buf := []byte(C.GoStringN(p.value, p.len))
+	c, err := bgp.DecodeCapability(buf)
+	if err != nil {
+		return nil
+	}
+	j, _ := json.Marshal(c)
+	return C.CString(string(j))
+
+}
+
+func main() {
+	// We need the main function to make possible
+	// CGO compiler to compile the package as C shared library
+}
diff --git a/cmd/gobgp/main.go b/cmd/gobgp/main.go
new file mode 100644
index 00000000..b3ae82f6
--- /dev/null
+++ b/cmd/gobgp/main.go
@@ -0,0 +1,35 @@
+// 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 main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/osrg/gobgp/cmd/gobgp/cmd"
+	"google.golang.org/grpc"
+)
+
+var version = "master"
+
+func main() {
+	if len(os.Args) > 1 && os.Args[1] == "--version" {
+		fmt.Println("gobgp version", version)
+		os.Exit(0)
+	}
+	grpc.EnableTracing = false
+	cmd.NewRootCmd().Execute()
+}
diff --git a/cmd/gobgpd/main.go b/cmd/gobgpd/main.go
new file mode 100644
index 00000000..6f1a364d
--- /dev/null
+++ b/cmd/gobgpd/main.go
@@ -0,0 +1,450 @@
+//
+// Copyright (C) 2014-2017 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 main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	_ "net/http/pprof"
+	"os"
+	"os/signal"
+	"runtime"
+	"syscall"
+
+	"github.com/golang/protobuf/ptypes/any"
+	"github.com/jessevdk/go-flags"
+	"github.com/kr/pretty"
+	log "github.com/sirupsen/logrus"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+
+	api "github.com/osrg/gobgp/api"
+	"github.com/osrg/gobgp/internal/pkg/config"
+	"github.com/osrg/gobgp/internal/pkg/table"
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+	"github.com/osrg/gobgp/pkg/server"
+)
+
+var version = "master"
+
+func marshalRouteTargets(l []string) ([]*any.Any, error) {
+	rtList := make([]*any.Any, 0, len(l))
+	for _, rtString := range l {
+		rt, err := bgp.ParseRouteTarget(rtString)
+		if err != nil {
+			return nil, err
+		}
+		rtList = append(rtList, api.MarshalRT(rt))
+	}
+	return rtList, nil
+}
+
+func main() {
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGTERM)
+
+	var opts struct {
+		ConfigFile      string `short:"f" long:"config-file" description:"specifying a config file"`
+		ConfigType      string `short:"t" long:"config-type" description:"specifying config type (toml, yaml, json)" default:"toml"`
+		LogLevel        string `short:"l" long:"log-level" description:"specifying log level"`
+		LogPlain        bool   `short:"p" long:"log-plain" description:"use plain format for logging (json by default)"`
+		UseSyslog       string `short:"s" long:"syslog" description:"use syslogd"`
+		Facility        string `long:"syslog-facility" description:"specify syslog facility"`
+		DisableStdlog   bool   `long:"disable-stdlog" description:"disable standard logging"`
+		CPUs            int    `long:"cpus" description:"specify the number of CPUs to be used"`
+		GrpcHosts       string `long:"api-hosts" description:"specify the hosts that gobgpd listens on" default:":50051"`
+		GracefulRestart bool   `short:"r" long:"graceful-restart" description:"flag restart-state in graceful-restart capability"`
+		Dry             bool   `short:"d" long:"dry-run" description:"check configuration"`
+		PProfHost       string `long:"pprof-host" description:"specify the host that gobgpd listens on for pprof" default:"localhost:6060"`
+		PProfDisable    bool   `long:"pprof-disable" description:"disable pprof profiling"`
+		TLS             bool   `long:"tls" description:"enable TLS authentication for gRPC API"`
+		TLSCertFile     string `long:"tls-cert-file" description:"The TLS cert file"`
+		TLSKeyFile      string `long:"tls-key-file" description:"The TLS key file"`
+		Version         bool   `long:"version" description:"show version number"`
+	}
+	_, err := flags.Parse(&opts)
+	if err != nil {
+		os.Exit(1)
+	}
+
+	if opts.Version {
+		fmt.Println("gobgpd version", version)
+		os.Exit(0)
+	}
+
+	if opts.CPUs == 0 {
+		runtime.GOMAXPROCS(runtime.NumCPU())
+	} else {
+		if runtime.NumCPU() < opts.CPUs {
+			log.Errorf("Only %d CPUs are available but %d is specified", runtime.NumCPU(), opts.CPUs)
+			os.Exit(1)
+		}
+		runtime.GOMAXPROCS(opts.CPUs)
+	}
+
+	if !opts.PProfDisable {
+		go func() {
+			log.Println(http.ListenAndServe(opts.PProfHost, nil))
+		}()
+	}
+
+	switch opts.LogLevel {
+	case "debug":
+		log.SetLevel(log.DebugLevel)
+	case "info":
+		log.SetLevel(log.InfoLevel)
+	default:
+		log.SetLevel(log.InfoLevel)
+	}
+
+	if opts.DisableStdlog {
+		log.SetOutput(ioutil.Discard)
+	} else {
+		log.SetOutput(os.Stdout)
+	}
+
+	if opts.UseSyslog != "" {
+		if err := addSyslogHook(opts.UseSyslog, opts.Facility); err != nil {
+			log.Error("Unable to connect to syslog daemon, ", opts.UseSyslog)
+		}
+	}
+
+	if opts.LogPlain {
+		if opts.DisableStdlog {
+			log.SetFormatter(&log.TextFormatter{
+				DisableColors: true,
+			})
+		}
+	} else {
+		log.SetFormatter(&log.JSONFormatter{})
+	}
+
+	configCh := make(chan *config.BgpConfigSet)
+	if opts.Dry {
+		go config.ReadConfigfileServe(opts.ConfigFile, opts.ConfigType, configCh)
+		c := <-configCh
+		if opts.LogLevel == "debug" {
+			pretty.Println(c)
+		}
+		os.Exit(0)
+	}
+
+	log.Info("gobgpd started")
+	bgpServer := server.NewBgpServer()
+	go bgpServer.Serve()
+
+	var grpcOpts []grpc.ServerOption
+	if opts.TLS {
+		creds, err := credentials.NewServerTLSFromFile(opts.TLSCertFile, opts.TLSKeyFile)
+		if err != nil {
+			log.Fatalf("Failed to generate credentials: %v", err)
+		}
+		grpcOpts = []grpc.ServerOption{grpc.Creds(creds)}
+	}
+	// start grpc Server
+	apiServer := server.NewServer(bgpServer, grpc.NewServer(grpcOpts...), opts.GrpcHosts)
+	go func() {
+		if err := apiServer.Serve(); err != nil {
+			log.Fatalf("failed to listen grpc port: %s", err)
+		}
+	}()
+
+	if opts.ConfigFile != "" {
+		go config.ReadConfigfileServe(opts.ConfigFile, opts.ConfigType, configCh)
+	}
+
+	loop := func() {
+		var c *config.BgpConfigSet
+		for {
+			select {
+			case <-sigCh:
+				apiServer.Shutdown(context.Background(), &api.ShutdownRequest{})
+				return
+			case newConfig := <-configCh:
+				var added, deleted, updated []config.Neighbor
+				var addedPg, deletedPg, updatedPg []config.PeerGroup
+				var updatePolicy bool
+
+				if c == nil {
+					c = newConfig
+					if _, err := apiServer.StartServer(context.Background(), &api.StartServerRequest{
+						Global: server.NewGlobalFromConfigStruct(&c.Global),
+					}); err != nil {
+						log.Fatalf("failed to set global config: %s", err)
+					}
+
+					if newConfig.Zebra.Config.Enabled {
+						tps := c.Zebra.Config.RedistributeRouteTypeList
+						l := make([]string, 0, len(tps))
+						for _, t := range tps {
+							l = append(l, string(t))
+						}
+						if _, err := apiServer.EnableZebra(context.Background(), &api.EnableZebraRequest{
+							Url:                  c.Zebra.Config.Url,
+							RouteTypes:           l,
+							Version:              uint32(c.Zebra.Config.Version),
+							NexthopTriggerEnable: c.Zebra.Config.NexthopTriggerEnable,
+							NexthopTriggerDelay:  uint32(c.Zebra.Config.NexthopTriggerDelay),
+						}); err != nil {
+							log.Fatalf("failed to set zebra config: %s", err)
+						}
+					}
+
+					if len(newConfig.Collector.Config.Url) > 0 {
+						if _, err := apiServer.AddCollector(context.Background(), &api.AddCollectorRequest{
+							Url:               c.Collector.Config.Url,
+							DbName:            c.Collector.Config.DbName,
+							TableDumpInterval: c.Collector.Config.TableDumpInterval,
+						}); err != nil {
+							log.Fatalf("failed to set collector config: %s", err)
+						}
+					}
+
+					for _, c := range newConfig.RpkiServers {
+						if _, err := apiServer.AddRpki(context.Background(), &api.AddRpkiRequest{
+							Address:  c.Config.Address,
+							Port:     c.Config.Port,
+							Lifetime: c.Config.RecordLifetime,
+						}); err != nil {
+							log.Fatalf("failed to set rpki config: %s", err)
+						}
+					}
+					for _, c := range newConfig.BmpServers {
+						if _, err := apiServer.AddBmp(context.Background(), &api.AddBmpRequest{
+							Address: c.Config.Address,
+							Port:    c.Config.Port,
+							Type:    api.AddBmpRequest_MonitoringPolicy(c.Config.RouteMonitoringPolicy.ToInt()),
+						}); err != nil {
+							log.Fatalf("failed to set bmp config: %s", err)
+						}
+					}
+					for _, vrf := range newConfig.Vrfs {
+						rd, err := bgp.ParseRouteDistinguisher(vrf.Config.Rd)
+						if err != nil {
+							log.Fatalf("failed to load vrf rd config: %s", err)
+						}
+
+						importRtList, err := marshalRouteTargets(vrf.Config.ImportRtList)
+						if err != nil {
+							log.Fatalf("failed to load vrf import rt config: %s", err)
+						}
+						exportRtList, err := marshalRouteTargets(vrf.Config.ExportRtList)
+						if err != nil {
+							log.Fatalf("failed to load vrf export rt config: %s", err)
+						}
+
+						if _, err := apiServer.AddVrf(context.Background(), &api.AddVrfRequest{
+							Vrf: &api.Vrf{
+								Name:     vrf.Config.Name,
+								Rd:       api.MarshalRD(rd),
+								Id:       uint32(vrf.Config.Id),
+								ImportRt: importRtList,
+								ExportRt: exportRtList,
+							},
+						}); err != nil {
+							log.Fatalf("failed to set vrf config: %s", err)
+						}
+					}
+					for _, c := range newConfig.MrtDump {
+						if len(c.Config.FileName) == 0 {
+							continue
+						}
+						if _, err := apiServer.EnableMrt(context.Background(), &api.EnableMrtRequest{
+							DumpType: int32(c.Config.DumpType.ToInt()),
+							Filename: c.Config.FileName,
+							Interval: c.Config.DumpInterval,
+						}); err != nil {
+							log.Fatalf("failed to set mrt config: %s", err)
+						}
+					}
+					p := config.ConfigSetToRoutingPolicy(newConfig)
+					rp, err := server.NewAPIRoutingPolicyFromConfigStruct(p)
+					if err != nil {
+						log.Warn(err)
+					} else {
+						apiServer.UpdatePolicy(context.Background(), &api.UpdatePolicyRequest{
+							Sets:     rp.DefinedSet,
+							Policies: rp.PolicyDefinition,
+						})
+					}
+
+					added = newConfig.Neighbors
+					addedPg = newConfig.PeerGroups
+					if opts.GracefulRestart {
+						for i, n := range added {
+							if n.GracefulRestart.Config.Enabled {
+								added[i].GracefulRestart.State.LocalRestarting = true
+							}
+						}
+					}
+
+				} else {
+					addedPg, deletedPg, updatedPg = config.UpdatePeerGroupConfig(c, newConfig)
+					added, deleted, updated = config.UpdateNeighborConfig(c, newConfig)
+					updatePolicy = config.CheckPolicyDifference(config.ConfigSetToRoutingPolicy(c), config.ConfigSetToRoutingPolicy(newConfig))
+
+					if updatePolicy {
+						log.Info("Policy config is updated")
+						p := config.ConfigSetToRoutingPolicy(newConfig)
+						rp, err := server.NewAPIRoutingPolicyFromConfigStruct(p)
+						if err != nil {
+							log.Warn(err)
+						} else {
+							apiServer.UpdatePolicy(context.Background(), &api.UpdatePolicyRequest{
+								Sets:     rp.DefinedSet,
+								Policies: rp.PolicyDefinition,
+							})
+						}
+					}
+					// global policy update
+					if !newConfig.Global.ApplyPolicy.Config.Equal(&c.Global.ApplyPolicy.Config) {
+						a := newConfig.Global.ApplyPolicy.Config
+						toDefaultTable := func(r config.DefaultPolicyType) table.RouteType {
+							var def table.RouteType
+							switch r {
+							case config.DEFAULT_POLICY_TYPE_ACCEPT_ROUTE:
+								def = table.ROUTE_TYPE_ACCEPT
+							case config.DEFAULT_POLICY_TYPE_REJECT_ROUTE:
+								def = table.ROUTE_TYPE_REJECT
+							}
+							return def
+						}
+						toPolicies := func(r []string) []*table.Policy {
+							p := make([]*table.Policy, 0, len(r))
+							for _, n := range r {
+								p = append(p, &table.Policy{
+									Name: n,
+								})
+							}
+							return p
+						}
+
+						def := toDefaultTable(a.DefaultImportPolicy)
+						ps := toPolicies(a.ImportPolicyList)
+						apiServer.ReplacePolicyAssignment(context.Background(), &api.ReplacePolicyAssignmentRequest{
+							Assignment: server.NewAPIPolicyAssignmentFromTableStruct(&table.PolicyAssignment{
+								Name:     "",
+								Type:     table.POLICY_DIRECTION_IMPORT,
+								Policies: ps,
+								Default:  def,
+							}),
+						})
+
+						def = toDefaultTable(a.DefaultExportPolicy)
+						ps = toPolicies(a.ExportPolicyList)
+						apiServer.ReplacePolicyAssignment(context.Background(), &api.ReplacePolicyAssignmentRequest{
+							Assignment: server.NewAPIPolicyAssignmentFromTableStruct(&table.PolicyAssignment{
+								Name:     "",
+								Type:     table.POLICY_DIRECTION_EXPORT,
+								Policies: ps,
+								Default:  def,
+							}),
+						})
+
+						updatePolicy = true
+
+					}
+					c = newConfig
+				}
+				for _, pg := range addedPg {
+					log.Infof("PeerGroup %s is added", pg.Config.PeerGroupName)
+					if _, err := apiServer.AddPeerGroup(context.Background(), &api.AddPeerGroupRequest{
+						PeerGroup: server.NewPeerGroupFromConfigStruct(&pg),
+					}); err != nil {
+						log.Warn(err)
+					}
+				}
+				for _, pg := range deletedPg {
+					log.Infof("PeerGroup %s is deleted", pg.Config.PeerGroupName)
+					if _, err := apiServer.DeletePeerGroup(context.Background(), &api.DeletePeerGroupRequest{
+						PeerGroup: server.NewPeerGroupFromConfigStruct(&pg),
+					}); err != nil {
+						log.Warn(err)
+					}
+				}
+				for _, pg := range updatedPg {
+					log.Infof("PeerGroup %v is updated", pg.State.PeerGroupName)
+					if u, err := apiServer.UpdatePeerGroup(context.Background(), &api.UpdatePeerGroupRequest{
+						PeerGroup: server.NewPeerGroupFromConfigStruct(&pg),
+					}); err != nil {
+						log.Warn(err)
+					} else {
+						updatePolicy = updatePolicy || u.NeedsSoftResetIn
+					}
+				}
+				for _, pg := range updatedPg {
+					log.Infof("PeerGroup %s is updated", pg.Config.PeerGroupName)
+					if _, err := apiServer.UpdatePeerGroup(context.Background(), &api.UpdatePeerGroupRequest{
+						PeerGroup: server.NewPeerGroupFromConfigStruct(&pg),
+					}); err != nil {
+						log.Warn(err)
+					}
+				}
+				for _, dn := range newConfig.DynamicNeighbors {
+					log.Infof("Dynamic Neighbor %s is added to PeerGroup %s", dn.Config.Prefix, dn.Config.PeerGroup)
+					if _, err := apiServer.AddDynamicNeighbor(context.Background(), &api.AddDynamicNeighborRequest{
+						DynamicNeighbor: &api.DynamicNeighbor{
+							Prefix:    dn.Config.Prefix,
+							PeerGroup: dn.Config.PeerGroup,
+						},
+					}); err != nil {
+						log.Warn(err)
+					}
+				}
+				for _, p := range added {
+					log.Infof("Peer %v is added", p.State.NeighborAddress)
+					if _, err := apiServer.AddNeighbor(context.Background(), &api.AddNeighborRequest{
+						Peer: server.NewPeerFromConfigStruct(&p),
+					}); err != nil {
+						log.Warn(err)
+					}
+				}
+				for _, p := range deleted {
+					log.Infof("Peer %v is deleted", p.State.NeighborAddress)
+					if _, err := apiServer.DeleteNeighbor(context.Background(), &api.DeleteNeighborRequest{
+						Peer: server.NewPeerFromConfigStruct(&p),
+					}); err != nil {
+						log.Warn(err)
+					}
+				}
+				for _, p := range updated {
+					log.Infof("Peer %v is updated", p.State.NeighborAddress)
+					if u, err := apiServer.UpdateNeighbor(context.Background(), &api.UpdateNeighborRequest{
+						Peer: server.NewPeerFromConfigStruct(&p),
+					}); err != nil {
+						log.Warn(err)
+					} else {
+						updatePolicy = updatePolicy || u.NeedsSoftResetIn
+					}
+				}
+
+				if updatePolicy {
+					if _, err := apiServer.SoftResetNeighbor(context.Background(), &api.SoftResetNeighborRequest{
+						Address:   "",
+						Direction: api.SoftResetNeighborRequest_IN,
+					}); err != nil {
+						log.Warn(err)
+					}
+				}
+			}
+		}
+	}
+
+	loop()
+}
diff --git a/cmd/gobgpd/util.go b/cmd/gobgpd/util.go
new file mode 100644
index 00000000..1b7885b8
--- /dev/null
+++ b/cmd/gobgpd/util.go
@@ -0,0 +1,103 @@
+// Copyright (C) 2017 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 !windows
+
+package main
+
+import (
+	"log/syslog"
+	"os"
+	"os/signal"
+	"runtime"
+	"runtime/debug"
+	"strings"
+	"syscall"
+
+	log "github.com/sirupsen/logrus"
+	lSyslog "github.com/sirupsen/logrus/hooks/syslog"
+)
+
+func init() {
+	go func() {
+		sigCh := make(chan os.Signal, 1)
+		signal.Notify(sigCh, syscall.SIGUSR1)
+		for range sigCh {
+			runtime.GC()
+			debug.FreeOSMemory()
+		}
+	}()
+}
+
+func addSyslogHook(host, facility string) error {
+	dst := strings.SplitN(host, ":", 2)
+	network := ""
+	addr := ""
+	if len(dst) == 2 {
+		network = dst[0]
+		addr = dst[1]
+	}
+
+	priority := syslog.Priority(0)
+	switch facility {
+	case "kern":
+		priority = syslog.LOG_KERN
+	case "user":
+		priority = syslog.LOG_USER
+	case "mail":
+		priority = syslog.LOG_MAIL
+	case "daemon":
+		priority = syslog.LOG_DAEMON
+	case "auth":
+		priority = syslog.LOG_AUTH
+	case "syslog":
+		priority = syslog.LOG_SYSLOG
+	case "lpr":
+		priority = syslog.LOG_LPR
+	case "news":
+		priority = syslog.LOG_NEWS
+	case "uucp":
+		priority = syslog.LOG_UUCP
+	case "cron":
+		priority = syslog.LOG_CRON
+	case "authpriv":
+		priority = syslog.LOG_AUTHPRIV
+	case "ftp":
+		priority = syslog.LOG_FTP
+	case "local0":
+		priority = syslog.LOG_LOCAL0
+	case "local1":
+		priority = syslog.LOG_LOCAL1
+	case "local2":
+		priority = syslog.LOG_LOCAL2
+	case "local3":
+		priority = syslog.LOG_LOCAL3
+	case "local4":
+		priority = syslog.LOG_LOCAL4
+	case "local5":
+		priority = syslog.LOG_LOCAL5
+	case "local6":
+		priority = syslog.LOG_LOCAL6
+	case "local7":
+		priority = syslog.LOG_LOCAL7
+	}
+
+	hook, err := lSyslog.NewSyslogHook(network, addr, syslog.LOG_INFO|priority, "bgpd")
+	if err != nil {
+		return err
+	}
+	log.AddHook(hook)
+	return nil
+}
diff --git a/cmd/gobgpd/util_windows.go b/cmd/gobgpd/util_windows.go
new file mode 100644
index 00000000..56c5bc2f
--- /dev/null
+++ b/cmd/gobgpd/util_windows.go
@@ -0,0 +1,24 @@
+// Copyright (C) 2017 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 main
+
+import (
+	"errors"
+)
+
+func addSyslogHook(_, _ string) error {
+	return errors.New("syslog is not supported on this OS")
+}