扫描全国的公网IP需要多久？

package main
import (
	"flag"
	"time"
	"github.com/kataras/golog"
)
var (
	protocol = flag.String("p", "icmp", "The protocol to use (icmp, tcp or udp)")
)
// 嵌入ip.sh
func main() {
	flag.Parse()
	input := make(chan []string, 1024)
	output := make(chan string, 1024)
	scanner := NewICMPScanner(input, output)
	var total int
	var alive int
	golog.Infof("start scanning")
	start := time.Now()
	// 将待探测的IP发送给send goroutine
	go func() {
		lines := readIPList()
		for _, line := range lines {
			ips := cidr2IPList(line)
			input <- ips
			total += len(ips)
		}
		close(input)
	}()
	// 启动 send goroutine
	scanner.Scan()
	// 接收 send goroutine 发送的结果, 直到发送之后5秒结束
	for ip := range output {
		golog.Infof("%s is alive", ip)
		alive++
	}
	golog.Infof("total: %d, alive: %d, time: %v", total, alive, time.Since(start))
}

go func() {
	lines := readIPList()
	for _, line := range lines {
		ips := cidr2IPList(line)
		input <- ips
		total += len(ips)
	}
	close(input)
}()

type ICMPScanner struct {
	src net.IP
	input  chan []string
	output chan string
}
// 调大缓存区
// sysctl net.core.rmem_max
// sysctl net.core.wmem_max
func NewICMPScanner(input chan []string, output chan string) *ICMPScanner {
	localIP := getLocalIP()
	s := &ICMPScanner{
		input:  input,
		output: output,
		src:    net.ParseIP(localIP),
	}
	return s
}
func (s *ICMPScanner) Scan() {
	go s.recv()
	go s.send(s.input)
}

// send sends a single ICMP echo request packet for each ip in the input channel.
func (s *ICMPScanner) send(input chan []string) error {
	defer func() {
		time.Sleep(5 * time.Second)
		close(s.output)
		golog.Infof("send goroutine exit")
	}()
	id := os.Getpid() & 0xffff
	// 创建 ICMP 连接
	conn, err := icmp.ListenPacket("ip4:icmp", s.src.String())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	// 不负责接收数据
	filter := createEmptyFilter()
	if assembled, err := bpf.Assemble(filter); err == nil {
		conn.IPv4PacketConn().SetBPF(assembled)
	}
    ... // 先忽略，后面再介绍
	return nil
}

seq := uint16(0)
for ips := range input {
	for _, ip := range ips {
		dst, err := net.ResolveIPAddr("ip", ip)
		if err != nil {
			golog.Fatalf("failed to resolve IP address: %v", err)
		}
		// 构造 ICMP 报文
		msg := &icmp.Message{
			Type: ipv4.ICMPTypeEcho,
			Code: 0,
			Body: &icmp.Echo{
				ID:   id,
				Seq:  int(seq),
				Data: []byte("Hello, are you there!"),
			},
		}
		msgBytes, err := msg.Marshal(nil)
		if err != nil {
			golog.Errorf("failed to marshal ICMP message: %v", err)
		}
		// 发送 ICMP 报文
		_, err = conn.WriteTo(msgBytes, dst)
		if err != nil {
			golog.Errorf("failed to send ICMP message: %v", err)
		}
		seq++
	}
}

func (s *ICMPScanner) recv() error {
	defer recover()
	id := os.Getpid() & 0xffff
	// 创建 ICMP 连接
	conn, err := icmp.ListenPacket("ip4:icmp", "0.0.0.0")
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()
	// 接收 ICMP 报文
	reply := make([]byte, 1500)
	for {
		n, peer, err := conn.ReadFrom(reply)
		if err != nil {
			log.Fatal(err)
		}
		// 解析 ICMP 报文
		msg, err := icmp.ParseMessage(protocolICMP, reply[:n])
		if err != nil {
			golog.Errorf("failed to parse ICMP message: %v", err)
			continue
		}
		// 打印结果
		switch msg.Type {
		case ipv4.ICMPTypeEchoReply:
			echoReply, ok := msg.Body.(*icmp.Echo)
			if !ok {
				continue
			}
			if echoReply.ID == id {
				s.output <- peer.String()
			}
		}
	}
}