overflow_discovery/discovery/ipv4/host.go

package ipv4

import (
	"fmt"
	"net"
	"time"

	"git.loafle.net/commons_go/logging"
	"git.loafle.net/commons_go/util/net/cidr"
	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"

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

func ScanHost(zone *model.Zone, dh *model.DiscoveryHost, resultChan chan interface{}, errChan chan error, stopChan chan struct{}) {
	ps, err := pcap.RetainScanner(zone)
	if nil != err {
		errChan <- fmt.Errorf("Discovery: Cannot retain pcap instance %v", err)
		return
	}

	defer func() {
		pcap.ReleaseScanner(zone)
	}()

	cr, err := cidr.NewCIDRRanger(zone.Network)
	if nil != err {
		errChan <- err
		return
	}

	hostRanges, err := getTargetHostRange(dh, cr)
	if nil != err {
		errChan <- err
		return
	}

	arpChan := ps.OpenARP()
	defer func() {
		ps.CloseARP(arpChan)
	}()

	go func() {
		hosts := make(map[string]*model.Host)
		for {
			select {
			case packet, ok := <-arpChan:
				if !ok {
					logging.Logger().Debug(fmt.Sprintf("Discovery: arp channel is closed"))
					return
				}
				if h := handlePacketARP(zone, cr, hosts, packet); nil != h {
					resultChan <- h
				}
			case <-stopChan:
				return
			}
		}
	}()

	if err := sendARP(ps, zone, hostRanges, stopChan); nil != err {
		errChan <- err
		return
	}

	timer := time.NewTimer(10 * time.Second)

	select {
	case <-stopChan:
		return
	case <-timer.C:
		return
	}

}

func sendARP(ps pcap.PCapScanner, zone *model.Zone, hostRanges []net.IP, stopChan chan struct{}) error {
	hwAddr, err := net.ParseMAC(zone.Mac)
	if nil != err {
		return err
	}
	ip := net.ParseIP(zone.IP)
	if nil == ip {
		return fmt.Errorf("Discovery: IP(%s) of zone is not valid", zone.IP)
	}

	ethPacket := makePacketEthernet(hwAddr)
	arpPacket := makePacketARP(hwAddr, ip.To4())
	opts := gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}
	buf := gopacket.NewSerializeBuffer()

	for _, targetHost := range hostRanges {
		arpPacket.DstProtAddress = []byte(targetHost)
		// log.Printf("ARP:%v", arpPacket)
		gopacket.SerializeLayers(buf, opts, &ethPacket, &arpPacket)
		if err := ps.WritePacketData(buf.Bytes()); err != nil {
			return err
		}

		timer := time.NewTimer(time.Microsecond * 100)

		select {
		case <-stopChan:
			return nil
		case <-timer.C:
		}

	}
	return nil
}

func handlePacketARP(zone *model.Zone, cr cidr.CIDRRanger, hosts map[string]*model.Host, packet *layers.ARP) *model.Host {
	if packet.Operation != layers.ARPReply {
		return nil
	}

	ip := net.IP(packet.SourceProtAddress)
	if _, ok := hosts[ip.String()]; ok || !cr.Contains(ip) {
		return nil
	}
	h := &model.Host{}
	h.IP = ip.String()
	h.Mac = net.HardwareAddr(packet.SourceHwAddress).String()
	h.Zone = zone

	hosts[ip.String()] = h

	return h
}

func getTargetHostRange(dh *model.DiscoveryHost, cr cidr.CIDRRanger) ([]net.IP, error) {
	excludeIPs := make([]net.IP, 0)
	for _, eHost := range dh.ExcludeHosts {
		eIP := net.ParseIP(eHost)
		if nil == eIP {
			return nil, fmt.Errorf("Discovery: IP(%v) of exclude host is not valid", eHost)
		}
		excludeIPs = append(excludeIPs, eIP)
	}

	ranges := cr.Range(excludeIPs)

	return ranges, nil
}

func makePacketEthernet(hw net.HardwareAddr) layers.Ethernet {
	return layers.Ethernet{
		SrcMAC:       hw,
		DstMAC:       net.HardwareAddr{0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
		EthernetType: layers.EthernetTypeARP,
	}
}

func makePacketARP(hw net.HardwareAddr, ip net.IP) layers.ARP {
	return layers.ARP{
		AddrType:          layers.LinkTypeEthernet,
		Protocol:          layers.EthernetTypeIPv4,
		HwAddressSize:     6,
		ProtAddressSize:   4,
		Operation:         layers.ARPRequest,
		SourceHwAddress:   []byte(hw),
		SourceProtAddress: []byte(ip),
		DstHwAddress:      []byte{0, 0, 0, 0, 0, 0},
	}
}