probe/discoverer/zone.go

package discoverer

import (
	"net"
	"regexp"

	cun "git.loafle.net/commons/util-go/net"
	omd "git.loafle.net/overflow/model/discovery"
	omm "git.loafle.net/overflow/model/meta"
	omu "git.loafle.net/overflow/model/util"
)

func scanZone(dz *omd.DiscoverZone, resultChan chan interface{}, errChan chan error, doneChan chan<- struct{}, stopChan chan struct{}) {
	defer func() {
		doneChan <- struct{}{}
	}()

	var err error
	var ifaces []net.Interface
	var addrs []net.Addr
	var ipnet *cun.IPNet
	var zones []*cun.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 {
		errChan <- err
		return
	}

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

	for _, i := range ifaces {

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

		for _, addr := range addrs {

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

			zones = append(zones, ipnet)

			z := &omd.Zone{
				Network:        ipnet.String(),
				Iface:          i.Name,
				Mac:            i.HardwareAddr.String(),
				Address:        addr.String(),
				DiscoveredDate: omu.NowPtr(),
			}

			switch ipnet.Version() {
			case 6:
				z.MetaIPType = omm.ToMetaIPType(omm.MetaIPTypeEnumV6)
			default:
				z.MetaIPType = omm.ToMetaIPType(omm.MetaIPTypeEnumV4)
			}

			resultChan <- z
		}
	}
}

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 []*cun.IPNet, ipnet *cun.IPNet) bool {
	for _, i := range zones {
		if i.Contains(ipnet.IP) {
			return true
		}
	}
	return false
}