overflow_discovery/discovery/zone.go

package discovery

import (
	"net"
	"regexp"
	"strings"

	"git.loafle.net/overflow/overflow_discovery/api/module/discovery/model"
)

func scanZone(d *discovery, dz *model.DiscoveryZone, doneChan chan<- struct{}) {
	var err error
	var ifaces []net.Interface
	var addrs []net.Addr
	var ipnet *net.IPNet
	var zones []*net.IPNet
	// var gwIP net.IP
	// var gwIFace string

	// if gwIP, gwIFace, err = gateway.DiscoverGateway(); nil != err {
	// 	logChan <- err
	// 	return
	// }

	if ifaces, err = net.Interfaces(); nil != err {
		d.errChan <- err
		return
	}

	zones = make([]*net.IPNet, 0)

	for _, i := range ifaces {

		if addrs, err = i.Addrs(); nil != err {
			d.errChan <- err
			continue
		}

		for _, addr := range addrs {

			if _, ipnet, err = net.ParseCIDR(addr.String()); nil != err {
				d.errChan <- err
				continue
			}
			if ipnet.IP.IsLoopback() || checkSameZone(zones, ipnet) || checkExclude(dz.ExcludePatterns, i.Name) {
				continue
			}

			zones = append(zones, ipnet)

			z := &model.Zone{
				Network: ipnet.String(),
				Iface:   i.Name,
				Mac:     i.HardwareAddr.String(),
				IP:      strings.Split(addr.String(), "/")[0],
			}

			d.sendChan <- z
		}
	}

	doneChan <- struct{}{}

}

func checkExclude(ep []string, iface string) bool {
	var r *regexp.Regexp
	var err error
	for _, p := range ep {
		if r, err = regexp.Compile(p); nil != err {
			return false
		}
		if r.MatchString(iface) {
			return true
		}
	}
	return false
}

func checkSameZone(zones []*net.IPNet, ipnet *net.IPNet) bool {
	for _, i := range zones {
		if i.Contains(ipnet.IP) {
			return true
		}
	}
	return false
}