Esempio n. 1
0
func NewIPAllocator(conf *IPAMConfig, store Store) (*IPAllocator, error) {
	var (
		start net.IP
		end   net.IP
		err   error
	)
	start, end, err = networkRange((*net.IPNet)(&conf.Subnet))
	if err != nil {
		return nil, err
	}

	// skip the .0 address
	start = ip.NextIP(start)

	if conf.RangeStart != nil {
		if err := validateRangeIP(conf.RangeStart, (*net.IPNet)(&conf.Subnet)); err != nil {
			return nil, err
		}
		start = conf.RangeStart
	}
	if conf.RangeEnd != nil {
		if err := validateRangeIP(conf.RangeEnd, (*net.IPNet)(&conf.Subnet)); err != nil {
			return nil, err
		}
		// RangeEnd is inclusive
		end = ip.NextIP(conf.RangeEnd)
	}

	return &IPAllocator{start, end, conf, store}, nil
}
Esempio n. 2
0
// Returns newly allocated IP along with its config
func (a *IPAllocator) Get(id string) (*plugin.IPConfig, error) {
	a.store.Lock()
	defer a.store.Unlock()

	gw := a.conf.Gateway
	if gw == nil {
		gw = ip.NextIP(a.conf.Subnet.IP)
	}

	for cur := a.start; !cur.Equal(a.end); cur = ip.NextIP(cur) {
		// don't allocate gateway IP
		if gw != nil && cur.Equal(gw) {
			continue
		}

		reserved, err := a.store.Reserve(id, cur)
		if err != nil {
			return nil, err
		}
		if reserved {
			return &plugin.IPConfig{
				IP:      net.IPNet{cur, a.conf.Subnet.Mask},
				Gateway: gw,
				Routes:  a.conf.Routes,
			}, nil
		}
	}

	return nil, fmt.Errorf("no IP addresses available in network: %s", a.conf.Name)
}
Esempio n. 3
0
// Allocates both an IP and the Gateway IP, i.e. a /31
// This is used for Point-to-Point links
func (a *IPAllocator) GetPtP(id string) (*plugin.IPConfig, error) {
	a.store.Lock()
	defer a.store.Unlock()

	for cur := a.start; !cur.Equal(a.end); cur = ip.NextIP(cur) {
		// we're looking for unreserved even, odd pair
		if !evenIP(cur) {
			continue
		}

		gw := cur
		reserved, err := a.store.Reserve(id, gw)
		if err != nil {
			return nil, err
		}
		if reserved {
			cur = ip.NextIP(cur)
			if cur.Equal(a.end) {
				break
			}

			reserved, err := a.store.Reserve(id, cur)
			if err != nil {
				return nil, err
			}
			if reserved {
				// found them both!
				_, bits := a.conf.Subnet.Mask.Size()
				mask := net.CIDRMask(bits-1, bits)

				return &plugin.IPConfig{
					IP:      net.IPNet{cur, mask},
					Gateway: gw,
					Routes:  a.conf.Routes,
				}, nil
			}
		}
	}

	return nil, fmt.Errorf("no ip addresses available in network: %s", a.conf.Name)
}
Esempio n. 4
0
// Returns newly allocated IP along with its config
func (a *IPAllocator) Get(id string) (*types.IPConfig, error) {
	a.store.Lock()
	defer a.store.Unlock()

	gw := a.conf.Gateway
	if gw == nil {
		gw = ip.NextIP(a.conf.Subnet.IP)
	}

	var requestedIP net.IP
	if a.conf.Args != nil {
		requestedIP = a.conf.Args.IP
	}

	if requestedIP != nil {
		if gw != nil && gw.Equal(a.conf.Args.IP) {
			return nil, fmt.Errorf("requested IP must differ gateway IP")
		}

		subnet := net.IPNet{
			IP:   a.conf.Subnet.IP,
			Mask: a.conf.Subnet.Mask,
		}
		err := validateRangeIP(requestedIP, &subnet)
		if err != nil {
			return nil, err
		}

		reserved, err := a.store.Reserve(id, requestedIP)
		if err != nil {
			return nil, err
		}

		if reserved {
			return &types.IPConfig{
				IP:      net.IPNet{IP: requestedIP, Mask: a.conf.Subnet.Mask},
				Gateway: gw,
				Routes:  a.conf.Routes,
			}, nil
		}
		return nil, fmt.Errorf("requested IP address %q is not available in network: %s", requestedIP, a.conf.Name)
	}

	for cur := a.start; !cur.Equal(a.end); cur = ip.NextIP(cur) {
		// don't allocate gateway IP
		if gw != nil && cur.Equal(gw) {
			continue
		}

		reserved, err := a.store.Reserve(id, cur)
		if err != nil {
			return nil, err
		}
		if reserved {
			return &types.IPConfig{
				IP:      net.IPNet{IP: cur, Mask: a.conf.Subnet.Mask},
				Gateway: gw,
				Routes:  a.conf.Routes,
			}, nil
		}
	}
	return nil, fmt.Errorf("no IP addresses available in network: %s", a.conf.Name)
}
Esempio n. 5
0
File: bridge.go Progetto: aanm/cni
func calcGatewayIP(ipn *net.IPNet) net.IP {
	nid := ipn.IP.Mask(ipn.Mask)
	return ip.NextIP(nid)
}