netaddr

package module
v0.0.0-...-a6cfb69 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 10, 2018 License: Apache-2.0 Imports: 4 Imported by: 0

README

netaddr

A Go library for performing calculations on IPv4 and IPv6 subnets. There is also limited support for EUI addresses.

Installation

It should be noted that while the repository name is "netaddr-go" the package name is simply "netaddr".

go get github.com/dspinhirne/netaddr-go

Usage

package main

import "fmt"
import "github.com/dspinhirne/netaddr-go"

func main() {
	net,_ := netaddr.ParseIPv4Net("192.168.1.0/24")
	fmt.Println(net)
}

Documentation

Available online here.

Documentation

Overview

netaddr is a Go library for performing calculations on IPv4 and IPv6 subnets. There is also limited support for EUI addresses.

Index

Examples

Constants

View Source 
const (
	// 32 bits worth of '1'
	F32 uint32 = 0xffffffff

	// 64 bits worth of '1'
	F64 uint64 = 0xffffffffffffffff
)

Variables

This section is empty.

Functions

func IPv4PrefixLen 

func IPv4PrefixLen(size uint) uint

IPv4PrefixLen returns the prefix length needed to hold the number of IP addresses specified by "size".

Example 
// what size IPv4 subnet is capable of holding 200 addresses?
fmt.Println(IPv4PrefixLen(200))

Output:

24

Types

type EUI48 

type EUI48 uint64

EUI48 (Extended Unique Identifier 48-bit, or EUI-48) represents a 48-bit hardware address. It is typically associated with mac-addresses.

func ParseEUI48 

func ParseEUI48(eui string) (EUI48, error)

Parse an EUI-48 string into an EUI48 type. This will successfully parse most of the typically used formats such as:

  • aa-bb-cc-dd-ee-ff
  • aa:bb:cc:dd:ee:ff
  • aabb.ccdd.eeff
  • aabbccddeeff

Although, in truth, its not picky about the exact format as long as it contains exactly 12 hex characters with the optional delimiting characters '-', ':', or '.'.

func (EUI48) Bytes 

func (eui EUI48) Bytes() []byte

Bytes returns a slice containing each byte of the EUI48.

func (EUI48) String 

func (eui EUI48) String() string

func (EUI48) ToEUI64 

func (eui EUI48) ToEUI64() EUI64

ToEUI64 converts this EUI48 into an EUI64 by inserting 0xfffe between the OUI and EUI

type EUI64 

type EUI64 uint64

EUI64 (Extended Unique Identifier 64-bit, or EUI-64) represents a 64-bit hardware address.

func ParseEUI64 

func ParseEUI64(eui string) (EUI64, error)

Parse an EUI-64 string into an EUI64 type. This will successfully parse most of the typically used formats such as:

  • aa-bb-cc-dd-ee-ff-00-11
  • aa:bb:cc:dd:ee:ff:00:11
  • aabb.ccdd.eeff.0011
  • aabbccddeeff0011

Although, in truth, its not picky about the exact format as long as it contains exactly 16 hex characters with the optional delimiting characters '-', ':', or '.'.

func (EUI64) Bytes 

func (eui EUI64) Bytes() []byte

Bytes returns a slice containing each byte of the EUI64.

func (EUI64) String 

func (eui EUI64) String() string

func (EUI64) ToIPv6 

func (eui EUI64) ToIPv6(net *IPv6Net) *IPv6

ToIPv6 generates an IPv6 address from this EUI64 address and the provided IPv6Net. Nil will be returned if IPv6Net is not a /64.

Example 
net, _ := ParseIPv6Net("fe80::/64")
eui48 := EUI48(0xaabbccddeeff)
ip := eui48.ToEUI64().ToIPv6(net)
fmt.Println(ip)

Output:

fe80::a8bb:ccff:fedd:eeff

type IP 

type IP interface {
	String() string
	Version() uint
}

func ParseIP 

func ParseIP(ip string) (IP, error)

ParseIP parses a string into an IP

Example 
net, _ := ParseIP("10.0.0.0")
fmt.Println(net)

Output:

10.0.0.0

type IPNet 

type IPNet interface {
	String() string
	Version() uint
}

func ParseIPNet 

func ParseIPNet(net string) (IPNet, error)

ParseIPNet parses a string into an IPNet

Example 
net, _ := ParseIPNet("10.0.0.0/24")
fmt.Println(net)

Output:

10.0.0.0/24

type IPv4 

type IPv4 struct {
	// contains filtered or unexported fields
}

IPv4 represents an version 4 IP address.

func NewIPv4 

func NewIPv4(addr uint32) *IPv4

NewIPv4 creates an IPv4 type from a uint32

Example 
ip := NewIPv4(0x80000001)
fmt.Println(ip)

Output:

128.0.0.1

func ParseIPv4 

func ParseIPv4(ip string) (*IPv4, error)

ParseIPv4 parses a string into an IPv4 type. IP address should be in dotted-quad format (x.x.x.x) and should not contain a netmask.

Example 
ip, _ := ParseIPv4("128.0.0.1")
fmt.Println(ip)

Output:

128.0.0.1

func (*IPv4) Addr 

func (ip *IPv4) Addr() uint32

Addr returns the internal uint32 address.

func (*IPv4) Cmp 

func (ip *IPv4) Cmp(other *IPv4) (int, error)

Cmp compares equality with another IPv4. Return:

  • 1 if this IPv4 is numerically greater
  • 0 if the two are equal
  • -1 if this IPv4 is numerically less

func (*IPv4) MulticastMac 

func (ip *IPv4) MulticastMac() EUI48

MulticastMac returns the multicast mac-address for this IP. It will return a value of 0 for addresses outside of the multicast range 224.0.0.0/4.

func (*IPv4) Next 

func (ip *IPv4) Next() *IPv4

Next returns the next consecutive IPv4 or nil if the end of the address space is reached.

func (*IPv4) Prev 

func (ip *IPv4) Prev() *IPv4

Prev returns the preceding IPv4 or nil if this is 0.0.0.0.

func (*IPv4) String 

func (ip *IPv4) String() string

String return IPv4 address as a string.

func (*IPv4) ToNet 

func (ip *IPv4) ToNet() *IPv4Net

ToNet returns the IPv4 as a IPv4Net

func (*IPv4) Version 

func (ip *IPv4) Version() uint

type IPv4List 

type IPv4List []*IPv4

IPv4List is a slice of IPv4 types

func NewIPv4List 

func NewIPv4List(ips []string) (IPv4List, error)

NewIPv4List parses a slice of IPv4 addresses into a IPv4List.

func (IPv4List) Len 

func (list IPv4List) Len() int

Len is used to implement the sort interface

func (IPv4List) Less 

func (list IPv4List) Less(i, j int) bool

Less is used to implement the sort interface

func (IPv4List) Sort 

func (list IPv4List) Sort() IPv4List

Sort sorts the list using sort.Sort(). Returns itself.

Example 
ips := []string{"10.0.0.0", "1.0.0.0", "10.0.0.0", "192.168.1.0", "8.8.8.8", "10.0.0.0"}
list, _ := NewIPv4List(ips)
list.Sort()
fmt.Println(list)

Output:

[1.0.0.0 8.8.8.8 10.0.0.0 10.0.0.0 10.0.0.0 192.168.1.0]

func (IPv4List) Swap 

func (list IPv4List) Swap(i, j int)

Swap is used to implement the sort interface

type IPv4Net 

type IPv4Net struct {
	// contains filtered or unexported fields
}

IPv4Net represents an IPv4 network.

func NewIPv4Net 

func NewIPv4Net(ip *IPv4, m32 *Mask32) (*IPv4Net, error)

NewIPv4Net creates a IPv4Net type from a IPv4 and Mask32. If m32 is nil then default to /32.

Example 
ip, _ := ParseIPv4("10.0.0.0")
m32, _ := NewMask32(24)
net, _ := NewIPv4Net(ip, m32)
fmt.Println(net)

Output:

10.0.0.0/24

func ParseIPv4Net 

func ParseIPv4Net(addr string) (*IPv4Net, error)

ParseIPv4Net parses a string into an IPv4Net type. Accepts addresses in the form of:

  • single IP (eg. 192.168.1.1 -- defaults to /32)
  • CIDR format (eg. 192.168.1.1/24)
  • extended format (eg. 192.168.1.1 255.255.255.0)
Example 
net, _ := ParseIPv4Net("10.0.0.0/24")
fmt.Println(net)

Output:

10.0.0.0/24

func (*IPv4Net) Cmp 

func (net *IPv4Net) Cmp(other *IPv4Net) (int, error)

Cmp compares equality with another IPv4Net. Return:

  • 1 if this IPv4Net is numerically greater
  • 0 if the two are equal
  • -1 if this IPv4Net is numerically less

The comparasin is initially performed on using the Cmp() method of the network address, however, in cases where the network addresses are identical then the netmasks will be compared with the Cmp() method of the netmask.

func (*IPv4Net) Contains 

func (net *IPv4Net) Contains(ip *IPv4) bool

Contains returns true if the IPv4Net contains the IPv4

func (*IPv4Net) Extended 

func (net *IPv4Net) Extended() string

Extended returns the network address as a string in extended format.

Example 
net, _ := ParseIPv4Net("10.0.0.0/24")
fmt.Println(net.Extended())

Output:

10.0.0.0 255.255.255.0

func (*IPv4Net) Fill 

func (net *IPv4Net) Fill(list IPv4NetList) IPv4NetList

Fill returns a copy of the given IPv4NetList, stripped of any networks which are not subnets of this IPv4Net, and with any missing gaps filled in.

Example 
net, _ := ParseIPv4Net("10.0.0.0/24")
subs, _ := NewIPv4NetList([]string{"10.0.0.0/26"})
subs = net.Fill(subs) // fills in the missing subnets
fmt.Println(subs)

Output:

[10.0.0.0/26 10.0.0.64/26 10.0.0.128/25]

func (*IPv4Net) Len 

func (net *IPv4Net) Len() uint32

Len returns the number of IP addresses in this network. It will always return 0 for /0 networks.

func (*IPv4Net) Netmask 

func (net *IPv4Net) Netmask() *Mask32

Netmask returns the Mask32 used by the IPv4Net.

func (*IPv4Net) Network 

func (net *IPv4Net) Network() *IPv4

Network returns the network address of the IPv4Net.

func (*IPv4Net) Next 

func (net *IPv4Net) Next() *IPv4Net

Next returns the next largest consecutive IP network or nil if the end of the address space is reached.

Example 
net, _ := ParseIPv4Net("10.0.0.4/30")
next := net.Next()
fmt.Println(next)

Output:

10.0.0.8/29

func (*IPv4Net) NextSib 

func (net *IPv4Net) NextSib() *IPv4Net

NextSib returns the network immediately following this one. It will return nil if the end of the address space is reached.

Example 
net, _ := ParseIPv4Net("10.0.0.4/30")
next := net.NextSib()
fmt.Println(next)

Output:

10.0.0.8/30

func (*IPv4Net) Nth 

func (net *IPv4Net) Nth(index uint32) *IPv4

Nth returns the IP address at the given index. The size of the network may be determined with the Len() method. If the range is exceeded then return nil.

Example 
net, _ := ParseIPv4Net("10.0.0.0/24")
last := net.Len() - 1
bcast := net.Nth(last) // the broadcast address
fmt.Println(bcast)

Output:

10.0.0.255

func (*IPv4Net) NthSubnet 

func (net *IPv4Net) NthSubnet(prefixLen uint, index uint32) *IPv4Net

NthSubnet returns the subnet IPv4Net at the given index. The number of subnets may be determined with the SubnetCount() method. If the range is exceeded or an invalid prefixLen is provided then return nil.

Example 
net, _ := ParseIPv4Net("10.0.0.0/24")
fmt.Println(net.NthSubnet(30, 2)) // the 3rd /30 subnet

Output:

10.0.0.8/30

func (*IPv4Net) Prev 

func (net *IPv4Net) Prev() *IPv4Net

Prev returns the previous largest consecutive IP network or nil if the start of the address space is reached.

Example 
net, _ := ParseIPv4Net("10.0.0.8/30")
prev := net.Prev()
fmt.Println(prev)

Output:

10.0.0.0/29

func (*IPv4Net) PrevSib 

func (net *IPv4Net) PrevSib() *IPv4Net

PrevSib returns the network immediately preceding this one. It will return nil if this is 0.0.0.0.

Example 
net, _ := ParseIPv4Net("10.0.0.8/30")
prev := net.PrevSib()
fmt.Println(prev)

Output:

10.0.0.4/30

func (*IPv4Net) Rel 

func (net *IPv4Net) Rel(other *IPv4Net) (bool, int)

Rel determines the relationship to another IPv4Net. The method returns two values: a bool and an int. If the bool is false, then the two networks are unrelated and the int will be 0. If the bool is true, then the int will be interpreted as:

  • 1 if this IPv4Net is the supernet of other
  • 0 if the two are equal
  • -1 if this IPv4Net is a subnet of other

func (*IPv4Net) Resize 

func (net *IPv4Net) Resize(prefixLen uint) *IPv4Net

Resize returns a copy of the network with an adjusted netmask or nil if an invalid prefixLen is given.

Example 
net, _ := ParseIPv4Net("10.0.0.8/30")
resized := net.Resize(29)
fmt.Println(resized)

Output:

10.0.0.8/29

func (*IPv4Net) String 

func (net *IPv4Net) String() string

String returns the network address as a string in CIDR format.

func (*IPv4Net) SubnetCount 

func (net *IPv4Net) SubnetCount(prefixLen uint) uint32

SubnetCount returns the number a subnets of a given prefix length that this IPv4Net contains. It will return 0 for invalid requests (ie. bad prefix or prefix is shorter than that of this network). It will also return 0 if the result exceeds the capacity of uint32 (ie. if you want the # of /32 a /0 will hold)

func (*IPv4Net) Summ 

func (net *IPv4Net) Summ(other *IPv4Net) *IPv4Net

Summ creates a summary address from this IPv4Net and another or nil if the two networks are incapable of being summarized.

Example 
net1, _ := ParseIPv4Net("10.0.0.0/30")
net2, _ := ParseIPv4Net("10.0.0.4/30")
summd := net1.Summ(net2)
fmt.Println(summd)

Output:

10.0.0.0/29

func (*IPv4Net) Version 

func (ip *IPv4Net) Version() uint

type IPv4NetList 

type IPv4NetList []*IPv4Net

IPv4NetList is a slice of IPv4 types

func NewIPv4NetList 

func NewIPv4NetList(networks []string) (IPv4NetList, error)

NewIPv4NetList parses a slice of IP networks into a IPv4NetList.

Example 
nets := []string{"10.0.0.0/24", "1.0.0.0/24"}
list, _ := NewIPv4NetList(nets)
fmt.Println(list)

Output:

[10.0.0.0/24 1.0.0.0/24]

func (IPv4NetList) Len 

func (list IPv4NetList) Len() int

Len is used to implement the sort interface

func (IPv4NetList) Less 

func (list IPv4NetList) Less(i, j int) bool

Less is used to implement the sort interface

func (IPv4NetList) Sort 

func (list IPv4NetList) Sort() IPv4NetList

Sort sorts the list using sort.Sort(). Returns itself.

Example 
nets := []string{"10.0.0.0/24", "1.0.0.0/24", "10.0.0.0/8", "192.168.1.0/26", "8.8.8.8/32", "10.0.0.0/8"}
list, _ := NewIPv4NetList(nets)
list.Sort()
fmt.Println(list)

Output:

[1.0.0.0/24 8.8.8.8/32 10.0.0.0/24 10.0.0.0/8 10.0.0.0/8 192.168.1.0/26]

func (IPv4NetList) Summ 

func (list IPv4NetList) Summ() IPv4NetList

Summ returns a copy of the list with the contained IPv4Net entries sorted and summarized as much as possible.

Example 
nets := []string{"10.0.0.0/24", "10.0.0.64/26", "1.1.1.0/24", "1.0.0.0/8", "3.4.5.6/32", "3.4.5.8/31", "2.2.2.224/27"}
list, _ := NewIPv4NetList(nets)
list = list.Summ()
fmt.Println(list)

Output:

[1.0.0.0/8 2.2.2.224/27 3.4.5.6/32 3.4.5.8/31 10.0.0.0/24]

func (IPv4NetList) Swap 

func (list IPv4NetList) Swap(i, j int)

Swap is used to implement the sort interface

type IPv6 

type IPv6 struct {
	// contains filtered or unexported fields
}

func NewIPv6 

func NewIPv6(netId, hostId uint64) *IPv6

NewIPv6 creates an IPv6 type from a pair of uint64. The pair represents the upper/lower 64-bits of the address respectively

func ParseIPv6 

func ParseIPv6(ip string) (*IPv6, error)

ParseIPv6 arses a string into an IPv6 type. IP address should be in one of the following formats and should not contain a netmask.

  • long format (eg. 0000:0000:0000:0000:0000:0000:0000:0001)
  • zero-compressed short format (eg. ::1)

func (*IPv6) Cmp 

func (ip *IPv6) Cmp(other *IPv6) (int, error)

Cmp compares equality with another IPv6. Return:

  • 1 if this IPv6 is numerically greater
  • 0 if the two are equal
  • -1 if this IPv6 is numerically less

func (*IPv6) HostId 

func (ip *IPv6) HostId() uint64

HostId returns the interal uint64 for the host id portion of the address.

func (*IPv6) IsZero 

func (ip *IPv6) IsZero() bool

IsZero returns true if this address is "::"

func (*IPv6) Long 

func (ip *IPv6) Long() string

Long returns the IPv6 address as a string in long (uncompressed) format.

func (*IPv6) NetId 

func (ip *IPv6) NetId() uint64

NetId returns the interal uint64 for the network id portion of the address.

func (*IPv6) Next 

func (ip *IPv6) Next() *IPv6

Next returns the next consecutive IPv6 or nil if the end of this /64 address space is reached.

func (*IPv6) Prev 

func (ip *IPv6) Prev() *IPv6

Prev returns the preceding IPv6 or nil if this is first address of this /64 space.

func (*IPv6) String 

func (ip *IPv6) String() string

String returns IPv6 as a string in zero-compressed format (per rfc5952). Use Long() to render in uncompressed format.

func (*IPv6) ToNet 

func (ip *IPv6) ToNet() *IPv6Net

ToNet returns the IPv6 as a IPv6Net

func (*IPv6) Version 

func (ip *IPv6) Version() uint

type IPv6List 

type IPv6List []*IPv6

IPv6List is a slice of IPv6 types

func NewIPv6List 

func NewIPv6List(ips []string) (IPv6List, error)

NewIPv6List parses a slice of IPv6 addresses into a IPv6List.

func (IPv6List) Len 

func (list IPv6List) Len() int

Len is used to implement the sort interface

func (IPv6List) Less 

func (list IPv6List) Less(i, j int) bool

Less is used to implement the sort interface

func (IPv6List) Sort 

func (list IPv6List) Sort() IPv6List

Sort sorts the list using sort.Sort(). Returns itself.

Example 
ips := []string{"1::", "2::", "1::1", "::", "::1", "fec0::1"}
list, _ := NewIPv6List(ips)
list.Sort()
fmt.Println(list)

Output:

[:: ::1 1:: 1::1 2:: fec0::1]

func (IPv6List) Swap 

func (list IPv6List) Swap(i, j int)

Swap is used to implement the sort interface

type IPv6Net 

type IPv6Net struct {
	// contains filtered or unexported fields
}

IPv6Net represents an IPv6 network.

func NewIPv6Net 

func NewIPv6Net(ip *IPv6, m128 *Mask128) (*IPv6Net, error)

NewIPv6Net creates a IPv6Net type from a IPv6 and Mask128. If netmask is nil then default to /64 (or /0 for address ::).

func ParseIPv6Net 

func ParseIPv6Net(addr string) (*IPv6Net, error)

ParseIPv6Net parses a string into an IPv6Net type. Accepts addresses in the form of:

  • single IP (eg. FE80::1)
  • CIDR format (eg. ::1/128)

func (*IPv6Net) Cmp 

func (net *IPv6Net) Cmp(other *IPv6Net) (int, error)

Cmp compares equality with another IPv6Net. Return:

  • 1 if this IPv6Net is numerically greater
  • 0 if the two are equal
  • -1 if this IPv6Net is numerically less

The comparasin is initially performed on using the Cmp() method of the network address, however, in cases where the network addresses are identical then the netmasks will be compared with the Cmp() method of the netmask.

func (*IPv6Net) Contains 

func (net *IPv6Net) Contains(ip *IPv6) bool

Contains returns true if the IPv4Net contains the IPv4

func (*IPv6Net) Fill 

func (net *IPv6Net) Fill(list IPv6NetList) IPv6NetList

Fill returns a copy of the given IPv6NetList, stripped of any networks which are not subnets of this IPv6Net, and with any missing gaps filled in.

func (*IPv6Net) Len 

func (net *IPv6Net) Len() uint64

Len returns the number of IP addresses in this network. This is only useful if you have a subnet smaller than a /64 as it will always return 0 for prefixes <= 64.

func (*IPv6Net) Long 

func (net *IPv6Net) Long() string

Long returns the network address as a string in long (uncomrpessed) format.

func (*IPv6Net) Netmask 

func (net *IPv6Net) Netmask() *Mask128

Netmask returns the Mask128 used by the IPv6Net.

func (*IPv6Net) Network 

func (net *IPv6Net) Network() *IPv6

Network returns the network address of the IPv6Net.

func (*IPv6Net) Next 

func (net *IPv6Net) Next() *IPv6Net

Next returns the next largest consecutive IP network or nil if the end of the address space is reached.

func (*IPv6Net) NextSib 

func (net *IPv6Net) NextSib() *IPv6Net

NextSib returns the network immediately following this one. It will return nil if the end of the address space is reached.

func (*IPv6Net) Nth 

func (net *IPv6Net) Nth(index uint64) *IPv6

Nth returns the IP address at the given index. If the range is exceeded then return nil. This only works for /64 and greater; if the prefix length is < 64 then return nil. For /64 networks the max index is F64. If the prefix length is > 64 then use the Len() method to deterimine the size of the range.

func (*IPv6Net) NthSubnet 

func (net *IPv6Net) NthSubnet(prefixLen uint, index uint64) *IPv6Net

NthSubnet returns the subnet IPv6Net at the given index. The number of subnets may be determined with the SubnetCount() method. If the range is exceeded or an invalid prefixLen is provided then return nil.

func (*IPv6Net) Prev 

func (net *IPv6Net) Prev() *IPv6Net

Prev returns the previous largest consecutive IP network or nil if the start of the address space is reached.

func (*IPv6Net) PrevSib 

func (net *IPv6Net) PrevSib() *IPv6Net

PrevSib returns the network immediately preceding this one. It will return nil if start of the address space is reached.

func (*IPv6Net) Rel 

func (net *IPv6Net) Rel(other *IPv6Net) (bool, int)

Rel determines the relationship to another IPv6Net. The method returns two values: a bool and an int. If the bool is false, then the two networks are unrelated and the int will be 0. If the bool is true, then the int will be interpreted as:

  • 1 if this IPv6Net is the supernet of other
  • 0 if the two are equal
  • -1 if this IPv6Net is a subnet of other

func (*IPv6Net) Resize 

func (net *IPv6Net) Resize(prefixLen uint) *IPv6Net

Resize returns a copy of the network with an adjusted netmask.

func (*IPv6Net) String 

func (net *IPv6Net) String() string

String returns the network address as a string in zero-compressed format.

func (*IPv6Net) SubnetCount 

func (net *IPv6Net) SubnetCount(prefixLen uint) uint64

SubnetCount returns the number a subnets of a given prefix length that this IPv6Net contains. It will return 0 for invalid requests (ie. bad prefix or prefix is shorter than that of this network). It will also return 0 if the result exceeds the capacity of uint64 (ie. if you want the # of /128 a /8 will hold)

func (*IPv6Net) Summ 

func (net *IPv6Net) Summ(other *IPv6Net) *IPv6Net

Summ creates a summary address from this IPv6Net and another or nil if the two networks are incapable of being summarized.

func (*IPv6Net) Version 

func (ip *IPv6Net) Version() uint

type IPv6NetList 

type IPv6NetList []*IPv6Net

IPv6NetList is a slice of IPv6 types

func NewIPv6NetList 

func NewIPv6NetList(networks []string) (IPv6NetList, error)

NewIPv6NetList parses a slice of IP networks into a IPv6NetList.

Example 
nets := []string{"1::/64", "2::/64"}
list, _ := NewIPv6NetList(nets)
fmt.Println(list)

Output:

[1::/64 2::/64]

func (IPv6NetList) Len 

func (list IPv6NetList) Len() int

Len is used to implement the sort interface

func (IPv6NetList) Less 

func (list IPv6NetList) Less(i, j int) bool

Less is used to implement the sort interface

func (IPv6NetList) Sort 

func (list IPv6NetList) Sort() IPv6NetList

Sort sorts the list using sort.Sort(). Returns itself.

Example 
nets := []string{"1::/64", "2::/64", "1::/16", "::", "::1", "1::/16"}
list, _ := NewIPv6NetList(nets)
list.Sort()
fmt.Println(list)

Output:

[::/128 ::1/128 1::/64 1::/16 1::/16 2::/64]

func (IPv6NetList) Summ 

func (list IPv6NetList) Summ() IPv6NetList

Summ returns a copy of the list with the contained IPv6Net entries sorted and summarized as much as possible.

Example 
nets := []string{"ff00::/13", "ff08::/14", "ff0c::/14", "ff10::/12", "ff20::/11", "ff40::/10", "ff80::/9"}
list, _ := NewIPv6NetList(nets)
list = list.Summ()
fmt.Println(list)

Output:

[ff00::/8]

func (IPv6NetList) Swap 

func (list IPv6NetList) Swap(i, j int)

Swap is used to implement the sort interface

type Mask128 

type Mask128 struct {
	// contains filtered or unexported fields
}

Mask128 represents a 128-bit netmask used by IPv6Net.

func NewMask128 

func NewMask128(prefixLen uint) (*Mask128, error)

NewMask128 converts an integer, representing the prefix length for an IPv6 network, to a Mask128 type. Integer must be from 0 to 128.

func ParseMask128 

func ParseMask128(prefixLen string) (*Mask128, error)

ParseMask128 parses a prefix length string to a Mask128 type. Netmask must be in "slash" format (eg. '/64' or just '64').

func (*Mask128) Cmp 

func (m128 *Mask128) Cmp(other *Mask128) int

Cmp compares equality with another Mask128. Return:

  • 1 if this Mask128 is larger in capacity
  • 0 if the two are equal
  • -1 if this Mask128 is smaller in capacity

func (*Mask128) HostIdMask 

func (m128 *Mask128) HostIdMask() uint64

HostIdMask returns the internal uint64 mask for the host portion of the mask.

func (*Mask128) Len 

func (m128 *Mask128) Len() uint64

Len returns the number of IP addresses in this network. This is only useful if you have a subnet smaller than a /64 as it will always return 0 for prefixes <= 64.

func (*Mask128) NetIdMask 

func (m128 *Mask128) NetIdMask() uint64

NetIdMask returns the internal uint64 mask for the network portion of the mask.

func (*Mask128) PrefixLen 

func (m128 *Mask128) PrefixLen() uint

PrefixLen returns the prefix length as an Uint.

func (*Mask128) String 

func (m128 *Mask128) String() string

String returns the prefix length as a string.

type Mask32 

type Mask32 struct {
	// contains filtered or unexported fields
}

Mask32 represents a 32-bit netmask used by IPv4Net.

func NewMask32 

func NewMask32(prefixLen uint) (*Mask32, error)

NewMask32 converts an integer, representing the prefix length for an IPv4 address, to a Mask32 type. Integer must be from 0 to 32.

Example 
m32, _ := NewMask32(32)
fmt.Println(m32)

Output:

/32

func ParseMask32 

func ParseMask32(netmask string) (*Mask32, error)

ParseMask32 parses an IPv4 netmask or prefix length string to a Mask32 type. Netmask must be in either dotted-quad format (y.y.y.y) or "slash" format (eg. '/32' or just '32').

Example 
m32, _ := ParseMask32("/32")
fmt.Println(m32)

Output:

/32

func (*Mask32) Cmp 

func (m32 *Mask32) Cmp(other *Mask32) int

Cmp compares equality with another Mask32. Return:

  • 1 if this Mask32 is larger in capacity
  • 0 if the two are equal
  • -1 if this Mask32 is smaller in capacity

func (*Mask32) Extended 

func (m32 *Mask32) Extended() string

Extended returns the Mask32 as a string in extended format.

Example 
m32, _ := ParseMask32("/24")
fmt.Println(m32.Extended())

Output:

255.255.255.0

func (*Mask32) Len 

func (m32 *Mask32) Len() uint32

Len returns the number of IP addresses in this network. It will always return 0 for /0 networks.

func (*Mask32) Mask 

func (m32 *Mask32) Mask() uint32

Mask returns the internal uint32 mask.

func (*Mask32) PrefixLen 

func (m32 *Mask32) PrefixLen() uint

PrefixLen returns the prefix length as an Uint.

func (*Mask32) String 

func (m32 *Mask32) String() string

String returns the prefix length as a string. Use Extended() to return in extended format instead.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.