1// Network utility functions. 2 3package netutils 4 5import ( 6 "crypto/rand" 7 "encoding/hex" 8 "errors" 9 "fmt" 10 "io" 11 "net" 12 "strings" 13 14 "github.com/docker/libnetwork/types" 15) 16 17var ( 18 // ErrNetworkOverlapsWithNameservers preformatted error 19 ErrNetworkOverlapsWithNameservers = errors.New("requested network overlaps with nameserver") 20 // ErrNetworkOverlaps preformatted error 21 ErrNetworkOverlaps = errors.New("requested network overlaps with existing network") 22 // ErrNoDefaultRoute preformatted error 23 ErrNoDefaultRoute = errors.New("no default route") 24) 25 26// CheckNameserverOverlaps checks whether the passed network overlaps with any of the nameservers 27func CheckNameserverOverlaps(nameservers []string, toCheck *net.IPNet) error { 28 if len(nameservers) > 0 { 29 for _, ns := range nameservers { 30 _, nsNetwork, err := net.ParseCIDR(ns) 31 if err != nil { 32 return err 33 } 34 if NetworkOverlaps(toCheck, nsNetwork) { 35 return ErrNetworkOverlapsWithNameservers 36 } 37 } 38 } 39 return nil 40} 41 42// NetworkOverlaps detects overlap between one IPNet and another 43func NetworkOverlaps(netX *net.IPNet, netY *net.IPNet) bool { 44 return netX.Contains(netY.IP) || netY.Contains(netX.IP) 45} 46 47// NetworkRange calculates the first and last IP addresses in an IPNet 48func NetworkRange(network *net.IPNet) (net.IP, net.IP) { 49 if network == nil { 50 return nil, nil 51 } 52 53 firstIP := network.IP.Mask(network.Mask) 54 lastIP := types.GetIPCopy(firstIP) 55 for i := 0; i < len(firstIP); i++ { 56 lastIP[i] = firstIP[i] | ^network.Mask[i] 57 } 58 59 if network.IP.To4() != nil { 60 firstIP = firstIP.To4() 61 lastIP = lastIP.To4() 62 } 63 64 return firstIP, lastIP 65} 66 67// GetIfaceAddr returns the first IPv4 address and slice of IPv6 addresses for the specified network interface 68func GetIfaceAddr(name string) (net.Addr, []net.Addr, error) { 69 iface, err := net.InterfaceByName(name) 70 if err != nil { 71 return nil, nil, err 72 } 73 addrs, err := iface.Addrs() 74 if err != nil { 75 return nil, nil, err 76 } 77 var addrs4 []net.Addr 78 var addrs6 []net.Addr 79 for _, addr := range addrs { 80 ip := (addr.(*net.IPNet)).IP 81 if ip4 := ip.To4(); ip4 != nil { 82 addrs4 = append(addrs4, addr) 83 } else if ip6 := ip.To16(); len(ip6) == net.IPv6len { 84 addrs6 = append(addrs6, addr) 85 } 86 } 87 switch { 88 case len(addrs4) == 0: 89 return nil, nil, fmt.Errorf("Interface %v has no IPv4 addresses", name) 90 case len(addrs4) > 1: 91 fmt.Printf("Interface %v has more than 1 IPv4 address. Defaulting to using %v\n", 92 name, (addrs4[0].(*net.IPNet)).IP) 93 } 94 return addrs4[0], addrs6, nil 95} 96 97func genMAC(ip net.IP) net.HardwareAddr { 98 hw := make(net.HardwareAddr, 6) 99 // The first byte of the MAC address has to comply with these rules: 100 // 1. Unicast: Set the least-significant bit to 0. 101 // 2. Address is locally administered: Set the second-least-significant bit (U/L) to 1. 102 hw[0] = 0x02 103 // The first 24 bits of the MAC represent the Organizationally Unique Identifier (OUI). 104 // Since this address is locally administered, we can do whatever we want as long as 105 // it doesn't conflict with other addresses. 106 hw[1] = 0x42 107 // Fill the remaining 4 bytes based on the input 108 if ip == nil { 109 rand.Read(hw[2:]) 110 } else { 111 copy(hw[2:], ip.To4()) 112 } 113 return hw 114} 115 116// GenerateRandomMAC returns a new 6-byte(48-bit) hardware address (MAC) 117func GenerateRandomMAC() net.HardwareAddr { 118 return genMAC(nil) 119} 120 121// GenerateMACFromIP returns a locally administered MAC address where the 4 least 122// significant bytes are derived from the IPv4 address. 123func GenerateMACFromIP(ip net.IP) net.HardwareAddr { 124 return genMAC(ip) 125} 126 127// GenerateRandomName returns a new name joined with a prefix. This size 128// specified is used to truncate the randomly generated value 129func GenerateRandomName(prefix string, size int) (string, error) { 130 id := make([]byte, 32) 131 if _, err := io.ReadFull(rand.Reader, id); err != nil { 132 return "", err 133 } 134 return prefix + hex.EncodeToString(id)[:size], nil 135} 136 137// ReverseIP accepts a V4 or V6 IP string in the canonical form and returns a reversed IP in 138// the dotted decimal form . This is used to setup the IP to service name mapping in the optimal 139// way for the DNS PTR queries. 140func ReverseIP(IP string) string { 141 var reverseIP []string 142 143 if net.ParseIP(IP).To4() != nil { 144 reverseIP = strings.Split(IP, ".") 145 l := len(reverseIP) 146 for i, j := 0, l-1; i < l/2; i, j = i+1, j-1 { 147 reverseIP[i], reverseIP[j] = reverseIP[j], reverseIP[i] 148 } 149 } else { 150 reverseIP = strings.Split(IP, ":") 151 152 // Reversed IPv6 is represented in dotted decimal instead of the typical 153 // colon hex notation 154 for key := range reverseIP { 155 if len(reverseIP[key]) == 0 { // expand the compressed 0s 156 reverseIP[key] = strings.Repeat("0000", 8-strings.Count(IP, ":")) 157 } else if len(reverseIP[key]) < 4 { // 0-padding needed 158 reverseIP[key] = strings.Repeat("0", 4-len(reverseIP[key])) + reverseIP[key] 159 } 160 } 161 162 reverseIP = strings.Split(strings.Join(reverseIP, ""), "") 163 164 l := len(reverseIP) 165 for i, j := 0, l-1; i < l/2; i, j = i+1, j-1 { 166 reverseIP[i], reverseIP[j] = reverseIP[j], reverseIP[i] 167 } 168 } 169 170 return strings.Join(reverseIP, ".") 171} 172 173// ParseAlias parses and validates the specified string as an alias format (name:alias) 174func ParseAlias(val string) (string, string, error) { 175 if val == "" { 176 return "", "", errors.New("empty string specified for alias") 177 } 178 arr := strings.Split(val, ":") 179 if len(arr) > 2 { 180 return "", "", fmt.Errorf("bad format for alias: %s", val) 181 } 182 if len(arr) == 1 { 183 return val, val, nil 184 } 185 return arr[0], arr[1], nil 186} 187 188// ValidateAlias validates that the specified string has a valid alias format (containerName:alias). 189func ValidateAlias(val string) (string, error) { 190 if _, _, err := ParseAlias(val); err != nil { 191 return val, err 192 } 193 return val, nil 194} 195