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>

1 files changed, 264 insertions, 0 deletions

diff --git a/internal/pkg/config/util.go b/internal/pkg/config/util.go
new file mode 100644
index 00000000..591252b4
--- /dev/null
+++ b/internal/pkg/config/util.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 config
+
+import (
+	"fmt"
+	"net"
+	"path/filepath"
+	"regexp"
+	"strconv"
+
+	"github.com/osrg/gobgp/pkg/packet/bgp"
+)
+
+// Returns config file type by retrieving extension from the given path.
+// If no corresponding type found, returns the given def as the default value.
+func detectConfigFileType(path, def string) string {
+	switch ext := filepath.Ext(path); ext {
+	case ".toml":
+		return "toml"
+	case ".yaml", ".yml":
+		return "yaml"
+	case ".json":
+		return "json"
+	default:
+		return def
+	}
+}
+
+// yaml is decoded as []interface{}
+// but toml is decoded as []map[string]interface{}.
+// currently, viper can't hide this difference.
+// handle the difference here.
+func extractArray(intf interface{}) ([]interface{}, error) {
+	if intf != nil {
+		list, ok := intf.([]interface{})
+		if ok {
+			return list, nil
+		}
+		l, ok := intf.([]map[string]interface{})
+		if !ok {
+			return nil, fmt.Errorf("invalid configuration: neither []interface{} nor []map[string]interface{}")
+		}
+		list = make([]interface{}, 0, len(l))
+		for _, m := range l {
+			list = append(list, m)
+		}
+		return list, nil
+	}
+	return nil, nil
+}
+
+func getIPv6LinkLocalAddress(ifname string) (string, error) {
+	ifi, err := net.InterfaceByName(ifname)
+	if err != nil {
+		return "", err
+	}
+	addrs, err := ifi.Addrs()
+	if err != nil {
+		return "", err
+	}
+	for _, addr := range addrs {
+		ip := addr.(*net.IPNet).IP
+		if ip.To4() == nil && ip.IsLinkLocalUnicast() {
+			return fmt.Sprintf("%s%%%s", ip.String(), ifname), nil
+		}
+	}
+	return "", fmt.Errorf("no ipv6 link local address for %s", ifname)
+}
+
+func (b *BgpConfigSet) getPeerGroup(n string) (*PeerGroup, error) {
+	if n == "" {
+		return nil, nil
+	}
+	for _, pg := range b.PeerGroups {
+		if n == pg.Config.PeerGroupName {
+			return &pg, nil
+		}
+	}
+	return nil, fmt.Errorf("no such peer-group: %s", n)
+}
+
+func (d *DynamicNeighbor) validate(b *BgpConfigSet) error {
+	if d.Config.PeerGroup == "" {
+		return fmt.Errorf("dynamic neighbor requires the peer group config")
+	}
+
+	if _, err := b.getPeerGroup(d.Config.PeerGroup); err != nil {
+		return err
+	}
+	if _, _, err := net.ParseCIDR(d.Config.Prefix); err != nil {
+		return fmt.Errorf("invalid dynamic neighbor prefix %s", d.Config.Prefix)
+	}
+	return nil
+}
+
+func (n *Neighbor) IsConfederationMember(g *Global) bool {
+	for _, member := range g.Confederation.Config.MemberAsList {
+		if member == n.Config.PeerAs {
+			return true
+		}
+	}
+	return false
+}
+
+func (n *Neighbor) IsConfederation(g *Global) bool {
+	if n.Config.PeerAs == g.Config.As {
+		return true
+	}
+	return n.IsConfederationMember(g)
+}
+
+func (n *Neighbor) IsEBGPPeer(g *Global) bool {
+	return n.Config.PeerAs != g.Config.As
+}
+
+func (n *Neighbor) CreateRfMap() map[bgp.RouteFamily]bgp.BGPAddPathMode {
+	rfMap := make(map[bgp.RouteFamily]bgp.BGPAddPathMode)
+	for _, af := range n.AfiSafis {
+		mode := bgp.BGP_ADD_PATH_NONE
+		if af.AddPaths.State.Receive {
+			mode |= bgp.BGP_ADD_PATH_RECEIVE
+		}
+		if af.AddPaths.State.SendMax > 0 {
+			mode |= bgp.BGP_ADD_PATH_SEND
+		}
+		rfMap[af.State.Family] = mode
+	}
+	return rfMap
+}
+
+func (n *Neighbor) GetAfiSafi(family bgp.RouteFamily) *AfiSafi {
+	for _, a := range n.AfiSafis {
+		if string(a.Config.AfiSafiName) == family.String() {
+			return &a
+		}
+	}
+	return nil
+}
+
+func (n *Neighbor) ExtractNeighborAddress() (string, error) {
+	addr := n.State.NeighborAddress
+	if addr == "" {
+		addr = n.Config.NeighborAddress
+		if addr == "" {
+			return "", fmt.Errorf("NeighborAddress is not configured")
+		}
+	}
+	return addr, nil
+}
+
+func (n *Neighbor) IsAddPathReceiveEnabled(family bgp.RouteFamily) bool {
+	for _, af := range n.AfiSafis {
+		if af.State.Family == family {
+			return af.AddPaths.State.Receive
+		}
+	}
+	return false
+}
+
+type AfiSafis []AfiSafi
+
+func (c AfiSafis) ToRfList() ([]bgp.RouteFamily, error) {
+	rfs := make([]bgp.RouteFamily, 0, len(c))
+	for _, af := range c {
+		rfs = append(rfs, af.State.Family)
+	}
+	return rfs, nil
+}
+
+func inSlice(n Neighbor, b []Neighbor) int {
+	for i, nb := range b {
+		if nb.State.NeighborAddress == n.State.NeighborAddress {
+			return i
+		}
+	}
+	return -1
+}
+
+func existPeerGroup(n string, b []PeerGroup) int {
+	for i, nb := range b {
+		if nb.Config.PeerGroupName == n {
+			return i
+		}
+	}
+	return -1
+}
+
+func isAfiSafiChanged(x, y []AfiSafi) bool {
+	if len(x) != len(y) {
+		return true
+	}
+	m := make(map[string]bool)
+	for _, e := range x {
+		m[string(e.Config.AfiSafiName)] = true
+	}
+	for _, e := range y {
+		if !m[string(e.Config.AfiSafiName)] {
+			return true
+		}
+	}
+	return false
+}
+
+func (n *Neighbor) NeedsResendOpenMessage(new *Neighbor) bool {
+	return !n.Config.Equal(&new.Config) ||
+		!n.Transport.Config.Equal(&new.Transport.Config) ||
+		!n.AddPaths.Config.Equal(&new.AddPaths.Config) ||
+		!n.GracefulRestart.Config.Equal(&new.GracefulRestart.Config) ||
+		isAfiSafiChanged(n.AfiSafis, new.AfiSafis)
+}
+
+// TODO: these regexp are duplicated in api
+var _regexpPrefixMaskLengthRange = regexp.MustCompile(`(\d+)\.\.(\d+)`)
+
+func ParseMaskLength(prefix, mask string) (int, int, error) {
+	_, ipNet, err := net.ParseCIDR(prefix)
+	if err != nil {
+		return 0, 0, fmt.Errorf("invalid prefix: %s", prefix)
+	}
+	if mask == "" {
+		l, _ := ipNet.Mask.Size()
+		return l, l, nil
+	}
+	elems := _regexpPrefixMaskLengthRange.FindStringSubmatch(mask)
+	if len(elems) != 3 {
+		return 0, 0, fmt.Errorf("invalid mask length range: %s", mask)
+	}
+	// we've already checked the range is sane by regexp
+	min, _ := strconv.ParseUint(elems[1], 10, 8)
+	max, _ := strconv.ParseUint(elems[2], 10, 8)
+	if min > max {
+		return 0, 0, fmt.Errorf("invalid mask length range: %s", mask)
+	}
+	if ipv4 := ipNet.IP.To4(); ipv4 != nil {
+		f := func(i uint64) bool {
+			return i <= 32
+		}
+		if !f(min) || !f(max) {
+			return 0, 0, fmt.Errorf("ipv4 mask length range outside scope :%s", mask)
+		}
+	} else {
+		f := func(i uint64) bool {
+			return i <= 128
+		}
+		if !f(min) || !f(max) {
+			return 0, 0, fmt.Errorf("ipv6 mask length range outside scope :%s", mask)
+		}
+	}
+	return int(min), int(max), nil
+}