Remove SimpleMaxHosts limit to fix large CIDR scanning

Closes #583

common/parsers/constants.go

@@ -21,15 +21,6 @@ const (
 	MaxPort = 65535
 )
 
-// =============================================================================
-// IP/主机解析常量
-// =============================================================================
-
-const (
-	// SimpleMaxHosts 最大主机数量限制
-	SimpleMaxHosts = 10000
-)
-
 // =============================================================================
 // 哈希验证常量
 // =============================================================================

common/parsers/parse_test.go

@@ -590,15 +590,15 @@ func TestParseIP_IPRange(t *testing.T) {
 	}
 }
 
-func TestParseIP_IPRangeLimit(t *testing.T) {
+func TestParseIP_IPRangeNoLimit(t *testing.T) {
-	result, err := parseIPRangeString("192.168.1.1-5", 3)
+	result, err := parseIPRangeString("192.168.1.1-5")
 	if err != nil {
 		t.Fatalf("parseIPRangeString error = %v", err)
 	}
 
-	expected := []string{"192.168.1.1", "192.168.1.2", "192.168.1.3"}
+	expected := []string{"192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.4", "192.168.1.5"}
 	if !reflect.DeepEqual(result, expected) {
-		t.Errorf("parseIPRangeString limit = %v, want %v", result, expected)
+		t.Errorf("parseIPRangeString = %v, want %v", result, expected)
 	}
 }
 
@@ -981,8 +981,8 @@ func TestParseIP_FullIPRange(t *testing.T) {
 	}
 }
 
-func TestParseIP_FullIPRangeNoLimit(t *testing.T) {
+func TestParseIP_FullIPRangeComplete(t *testing.T) {
-	result, err := parseIPRangeString("192.168.1.1-192.168.1.5", -1)
+	result, err := parseIPRangeString("192.168.1.1-192.168.1.5")
 	if err != nil {
 		t.Fatalf("parseIPRangeString error = %v", err)
 	}

common/parsers/parsers.go

@@ -90,31 +90,31 @@ func parseHostString(host string) ([]string, error) {
 
 		switch {
 		case h == "192":
-			cidrHosts, err := parseIPCIDR("192.168.0.0/16", SimpleMaxHosts)
+			cidrHosts, err := parseIPCIDR("192.168.0.0/16")
 			if err != nil {
 				return nil, err
 			}
 			hosts = append(hosts, cidrHosts...)
 		case h == "172":
-			cidrHosts, err := parseIPCIDR("172.16.0.0/12", SimpleMaxHosts)
+			cidrHosts, err := parseIPCIDR("172.16.0.0/12")
 			if err != nil {
 				return nil, err
 			}
 			hosts = append(hosts, cidrHosts...)
 		case h == "10":
-			cidrHosts, err := parseIPCIDR("10.0.0.0/8", SimpleMaxHosts)
+			cidrHosts, err := parseIPCIDR("10.0.0.0/8")
 			if err != nil {
 				return nil, err
 			}
 			hosts = append(hosts, cidrHosts...)
 		case strings.Contains(h, "/"):
-			cidrHosts, err := parseIPCIDR(h, SimpleMaxHosts)
+			cidrHosts, err := parseIPCIDR(h)
 			if err != nil {
 				return nil, fmt.Errorf(i18n.Tr("parser_cidr_failed", h)+": %w", err)
 			}
 			hosts = append(hosts, cidrHosts...)
 		case strings.Contains(h, "-") && !strings.Contains(h, ":") && looksLikeIPRange(h):
-			rangeHosts, err := parseIPRangeString(h, SimpleMaxHosts)
+			rangeHosts, err := parseIPRangeString(h)
 			if err != nil {
 				return nil, fmt.Errorf(i18n.Tr("parser_ip_range_failed", h)+": %w", err)
 			}
@@ -289,7 +289,7 @@ func ParseHashFile(filename string) ([]string, [][]byte, error) {
 // =============================================================================
 
 // parseIPCIDR 解析CIDR网段
-func parseIPCIDR(cidr string, maxTargets int) ([]string, error) {
+func parseIPCIDR(cidr string) ([]string, error) {
 	_, ipNet, err := net.ParseCIDR(cidr)
 	if err != nil {
 		return nil, err
@@ -299,17 +299,11 @@ func parseIPCIDR(cidr string, maxTargets int) ([]string, error) {
 	ip := make(net.IP, len(ipNet.IP))
 	copy(ip, ipNet.IP)
 
-	count := 0
 	for ipNet.Contains(ip) {
 		ips = append(ips, ip.String())
-		count++
-		if maxTargets > 0 && count >= maxTargets {
-			break
-		}
 		incrementIP(ip)
 	}
 
-	// 移除网络地址和广播地址
 	if len(ips) > 2 {
 		ips = ips[1 : len(ips)-1]
 	}
@@ -331,7 +325,7 @@ func looksLikeIPRange(s string) bool {
 }
 
 // parseIPRangeString 解析IP范围字符串
-func parseIPRangeString(rangeStr string, maxTargets int) ([]string, error) {
+func parseIPRangeString(rangeStr string) ([]string, error) {
 	parts := strings.Split(rangeStr, "-")
 	if len(parts) != 2 {
 		return nil, fmt.Errorf("%s", i18n.Tr("parser_invalid_ip_range_fmt", rangeStr))
@@ -347,7 +341,7 @@ func parseIPRangeString(rangeStr string, maxTargets int) ([]string, error) {
 
 	// 处理简写格式 (如: 192.168.1.1-100)
 	if len(endIPStr) < 4 || !strings.Contains(endIPStr, ".") {
-		return parseIPShortRange(startIPStr, endIPStr, maxTargets)
+		return parseIPShortRange(startIPStr, endIPStr)
 	}
 
 	// 处理完整格式 (如: 192.168.1.1-192.168.1.100)
@@ -356,11 +350,11 @@ func parseIPRangeString(rangeStr string, maxTargets int) ([]string, error) {
 		return nil, fmt.Errorf("%s", i18n.Tr("parser_invalid_end_ip", endIPStr))
 	}
 
-	return parseIPFullRange(startIP, endIP, maxTargets)
+	return parseIPFullRange(startIP, endIP)
 }
 
 // parseIPShortRange 解析短格式IP范围
-func parseIPShortRange(startIPStr, endSuffix string, maxTargets int) ([]string, error) {
+func parseIPShortRange(startIPStr, endSuffix string) ([]string, error) {
 	endNum, err := strconv.Atoi(endSuffix)
 	if err != nil || endNum > 255 {
 		return nil, fmt.Errorf("%s", i18n.Tr("parser_invalid_ip_end_val", endSuffix))
@@ -378,20 +372,15 @@ func parseIPShortRange(startIPStr, endSuffix string, maxTargets int) ([]string,
 	}
 
 	var allIP []string
-	count := 0
 	for i := startNum; i <= endNum; i++ {
 		allIP = append(allIP, fmt.Sprintf("%s.%d", prefixIP, i))
-		count++
-		if maxTargets > 0 && count >= maxTargets {
-			break
-		}
 	}
 
 	return allIP, nil
 }
 
 // parseIPFullRange 解析完整格式的IP范围
-func parseIPFullRange(startIP, endIP net.IP, maxTargets int) ([]string, error) {
+func parseIPFullRange(startIP, endIP net.IP) ([]string, error) {
 	start4 := startIP.To4()
 	end4 := endIP.To4()
 	if start4 == nil || end4 == nil {
@@ -409,12 +398,9 @@ func parseIPFullRange(startIP, endIP net.IP, maxTargets int) ([]string, error) {
 	current := make(net.IP, len(start4))
 	copy(current, start4)
 
-	count := 0
 	for {
 		ips = append(ips, current.String())
-		count++
+		if current.Equal(end4) {
-
-		if current.Equal(end4) || (maxTargets > 0 && count >= maxTargets) {
 			break
 		}
 		incrementIP(current)