externalize function to do operation on ip

Author: simon

6rd.go

@@ -0,0 +1,30 @@
+package netadv
+
+import "net"
+
+// ConvertIPv4InIPv6Network convert ipv6 network followed by ipv4
+func ConvertIPv4InIPv6Network(network, ip string) (*net.IPNet, error) {
+	// parse original network
+	_, pNet1, err := net.ParseCIDR(network)
+	if err != nil {
+		return nil, err
+	}
+
+	// create an empty network
+	_, pNet2, err := net.ParseCIDR("0::/63")
+	if err != nil {
+		return nil, err
+	}
+
+	// set 2 last bytes in new network
+	ip2 := net.ParseIP(ip)
+	pNet2.IP[0] = ip2[14]
+	pNet2.IP[1] = ip2[15]
+
+	// we shift network to follow the first ip
+	shift, _ := pNet1.Mask.Size()
+	pNet2.IP = SliceShiftRight(pNet2.IP, uint(shift))
+
+	// return the OR of joined network
+	return IPNetOr(pNet1, pNet2), nil
+}

bitwise.go

@@ -0,0 +1,41 @@
+package netadv
+
+// SliceAnd return an AND on two slice of bytes
+func SliceAnd(s1, s2 []byte) []byte {
+	mini := MinI(len(s1), len(s2))
+	s := make([]byte, mini)
+	for i := 0; i < mini; i++ {
+		s[i] = s1[i] & s2[i]
+	}
+	return s
+}
+
+// SliceOr return an OR on two slice of bytes
+func SliceOr(s1, s2 []byte) []byte {
+	mini := MinI(len(s1), len(s2))
+	s := make([]byte, mini)
+	for i := 0; i < mini; i++ {
+		s[i] = s1[i] | s2[i]
+	}
+	return s
+}
+
+// SliceXor return an XOR on two slice of bytes
+func SliceXor(s1, s2 []byte) []byte {
+	mini := MinI(len(s1), len(s2))
+	s := make([]byte, mini)
+	for i := 0; i < mini; i++ {
+		s[i] = s1[i] ^ s2[i]
+	}
+	return s
+}
+
+// SliceNot return the NOT of bytes slice
+func SliceNot(s1 []byte) []byte {
+	mini := len(s1)
+	s := make([]byte, mini)
+	for i := 0; i < mini; i++ {
+		s[i] = ^s1[i]
+	}
+	return s
+}

common.go

@@ -0,0 +1,17 @@
+package netadv
+
+// MinI return the minimum between two int
+func MinI(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// MaxI return the maximum between two int
+func MaxI(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

ipnet.go

@@ -0,0 +1,10 @@
+package netadv
+
+import "net"
+
+// IPNetOr make OR bitwise operation on net.IPNet
+func IPNetOr(n1, n2 *net.IPNet) *net.IPNet {
+	oip := SliceOr(n1.IP, n2.IP)
+	omask := SliceOr(n1.Mask, n2.Mask)
+	return &net.IPNet{IP: oip, Mask: omask}
+}

main.go

@@ -0,0 +1 @@
+package netadv

slice.go

@@ -0,0 +1,40 @@
+package netadv
+
+// SliceShiftRight return a slive of bytes shifted by "bits" bits
+func SliceShiftRight(s1 []byte, bits uint) []byte {
+	l := len(s1)
+	s := make([]byte, l)
+
+	r := bits / 8
+	rs := bits - r*8
+
+	for i := 0; i < l; i++ {
+		// relative index
+		ri := i - int(r)
+		bl := byte(0)
+		if ri >= 1 {
+			bl = s1[ri-1] << (8 - rs)
+		}
+
+		bu := byte(0)
+		if ri >= 0 {
+			bu = s1[ri] >> rs
+		}
+		s[i] = bl | bu
+	}
+
+	return s
+}
+
+// SliceSetOne set 1 into the b'th byte
+func SliceSetOne(s1 []byte, b uint) []byte {
+	r := b / 8
+	rs := b - r*8
+
+	mb := byte(0x80)
+	mb = mb >> rs
+
+	s1[r] = s1[r] | mb
+
+	return s1
+}

split.go

@@ -0,0 +1,39 @@
+package netadv
+
+import "net"
+
+// SplitNetworks split network in a
+func SplitNetworks(network *net.IPNet, newsize uint) ([]*net.IPNet, error) {
+	var ret []*net.IPNet
+	oldsize, _ := network.Mask.Size()
+
+	// use a stack to avoid a recurvive function
+	ret = append(ret, network)
+	for i := oldsize; i < int(newsize); i++ {
+		var tmp []*net.IPNet
+
+		// parse network array to split all of them in two
+		for _, n := range ret {
+			one, two := SplitNetworkInTwo(n)
+			tmp = append(tmp, one)
+			tmp = append(tmp, two)
+		}
+		ret = tmp
+	}
+
+	return ret, nil
+}
+
+// SplitNetworkInTwo split a network in two. return two sub network
+func SplitNetworkInTwo(network *net.IPNet) (*net.IPNet, *net.IPNet) {
+	size, _ := network.Mask.Size()
+	newMask := net.CIDRMask(size+1, 8*net.IPv6len)
+
+	//	byte1 := net.IP{0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+	//	ip2 := SliceShiftRight(byte1, uint(size))
+
+	ip2 := SliceSetOne(net.IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, uint(size))
+	ip2 = SliceOr(network.IP, ip2)
+
+	return &net.IPNet{IP: network.IP, Mask: newMask}, &net.IPNet{IP: ip2, Mask: newMask}
+}