probe/internal/pcap/packet.go

154 lines
3.0 KiB
Go
Raw Normal View History

2018-08-12 11:08:31 +00:00
package pcap
import (
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
)
type PacketType int
const (
PacketTypeUnknown PacketType = iota
PacketTypeARP
2018-08-31 10:05:49 +00:00
PacketTypeICMPv4
PacketTypeICMPv6
2018-08-12 11:08:31 +00:00
PacketTypeTCP
PacketTypeUDP
)
func getPacketType(packet gopacket.Packet) PacketType {
if packet == nil {
return PacketTypeUnknown
}
layer := packet.Layer(layers.LayerTypeARP)
if layer != nil {
return PacketTypeARP
}
2018-08-31 10:05:49 +00:00
layer = packet.Layer(layers.LayerTypeICMPv4)
if layer != nil {
return PacketTypeICMPv4
}
layer = packet.Layer(layers.LayerTypeICMPv6)
if layer != nil {
return PacketTypeICMPv6
}
2018-08-12 11:08:31 +00:00
layer = packet.Layer(layers.LayerTypeTCP)
if layer != nil {
if _, ok := layer.(*layers.TCP); ok {
return PacketTypeTCP
}
}
layer = packet.Layer(layers.LayerTypeUDP)
if layer != nil {
if _, ok := layer.(*layers.UDP); ok {
return PacketTypeUDP
}
}
return PacketTypeUnknown
}
func handlePacket(ps *pCapScan, packet gopacket.Packet) {
switch getPacketType(packet) {
case PacketTypeARP:
handlePacketARP(ps, packet)
2018-08-31 10:05:49 +00:00
case PacketTypeICMPv4:
handlePacketICMP4(ps, packet)
case PacketTypeICMPv6:
handlePacketICMP6(ps, packet)
2018-08-12 11:08:31 +00:00
case PacketTypeTCP:
handlePacketTCP(ps, packet)
case PacketTypeUDP:
handlePacketUDP(ps, packet)
default:
}
}
func handlePacketARP(ps *pCapScan, packet gopacket.Packet) {
ps.arpListenerChanMtx.RLock()
defer ps.arpListenerChanMtx.RUnlock()
arpLayer := packet.Layer(layers.LayerTypeARP)
arp := arpLayer.(*layers.ARP)
for _, ch := range ps.arpListenerChans {
ch <- arp
}
}
2018-08-31 10:05:49 +00:00
func handlePacketICMP4(ps *pCapScan, packet gopacket.Packet) {
ps.icmp4ListenerChanMtx.RLock()
defer ps.icmp4ListenerChanMtx.RUnlock()
// icmp4Layer := packet.Layer(layers.LayerTypeICMPv4)
// icmp4 := icmp4Layer.(*layers.ICMPv4)
for _, ch := range ps.icmp4ListenerChans {
ch <- packet
}
}
func handlePacketICMP6(ps *pCapScan, packet gopacket.Packet) {
ps.icmp6ListenerChanMtx.RLock()
defer ps.icmp6ListenerChanMtx.RUnlock()
// icmp6Layer := packet.Layer(layers.LayerTypeICMPv6)
// icmp6 := icmp6Layer.(*layers.ICMPv6)
for _, ch := range ps.icmp6ListenerChans {
ch <- packet
}
}
2018-08-12 11:08:31 +00:00
func handlePacketTCP(ps *pCapScan, packet gopacket.Packet) {
ipLayer := packet.Layer(layers.LayerTypeIPv4)
if nil == ipLayer {
return
}
ip := ipLayer.(*layers.IPv4).SrcIP.String()
2018-09-04 18:58:33 +00:00
layer := packet.Layer(layers.LayerTypeTCP)
tcp, _ := layer.(*layers.TCP)
2018-08-12 11:08:31 +00:00
ps.tcpListenerChanMtx.RLock()
2018-09-04 18:58:33 +00:00
defer func() {
ps.tcpListenerChanMtx.RUnlock()
}()
2018-08-12 11:08:31 +00:00
chs, ok := ps.tcpListenerChans[ip]
if ok {
2018-09-04 18:58:33 +00:00
// for _, ch := range chs {
// ch <- tcp
// }
2018-08-12 11:08:31 +00:00
for _, ch := range chs {
2018-09-04 18:58:33 +00:00
select {
case ch <- tcp:
default:
}
2018-08-12 11:08:31 +00:00
}
2018-09-04 18:58:33 +00:00
2018-08-12 11:08:31 +00:00
}
}
func handlePacketUDP(ps *pCapScan, packet gopacket.Packet) {
ipLayer := packet.Layer(layers.LayerTypeIPv4)
if nil == ipLayer {
return
}
ip := ipLayer.(*layers.IPv4).SrcIP.String()
ps.udpListenerChanMtx.RLock()
defer ps.udpListenerChanMtx.RUnlock()
chs, ok := ps.udpListenerChans[ip]
if ok {
for _, ch := range chs {
ch <- packet
}
}
}