fscan/Common/parsers/Simple.go

package parsers

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"sort"
	"strconv"
	"strings"
)

/*
Simple.go - 简化版本的解析器函数

这个文件提供了简化但功能完整的解析函数，用于替代复杂的解析器架构。
保持与现有代码的接口兼容性，但大幅简化实现逻辑。
*/

// =============================================================================
// 简化的IP/主机解析函数
// =============================================================================

// SimpleParseIP 简化版本的IP解析函数
// 保持与 ParseIP 的接口兼容性，但使用更简单的实现
func SimpleParseIP(host string, filename string, nohosts ...string) ([]string, error) {
	var hosts []string

	// 如果提供了文件名，从文件读取主机列表
	if filename != "" {
		fileHosts, fileErr := readHostsFromFile(filename)
		if fileErr != nil {
			return nil, fmt.Errorf("读取主机文件失败: %v", fileErr)
		}
		hosts = append(hosts, fileHosts...)
	}

	// 解析主机参数
	if host != "" {
		hostList, hostErr := parseHostString(host)
		if hostErr != nil {
			return nil, fmt.Errorf("解析主机失败: %v", hostErr)
		}
		hosts = append(hosts, hostList...)
	}

	// 处理排除主机
	if len(nohosts) > 0 && nohosts[0] != "" {
		excludeList, excludeErr := parseHostString(nohosts[0])
		if excludeErr != nil {
			return nil, fmt.Errorf("解析排除主机失败: %v", excludeErr)
		}
		hosts = excludeHosts(hosts, excludeList)
	}

	// 去重和排序
	hosts = removeDuplicates(hosts)
	sort.Strings(hosts)

	if len(hosts) == 0 {
		return nil, fmt.Errorf("没有找到有效的主机")
	}

	return hosts, nil
}

// =============================================================================
// 简化的端口解析函数
// =============================================================================

// SimpleParsePort 简化版本的端口解析函数
// 保持与 ParsePort 的接口兼容性
func SimpleParsePort(ports string) []int {
	if ports == "" {
		return nil
	}

	var result []int
	
	// 处理预定义端口组
	ports = expandPortGroups(ports)
	
	// 按逗号分割
	for _, portStr := range strings.Split(ports, ",") {
		portStr = strings.TrimSpace(portStr)
		if portStr == "" {
			continue
		}

		// 处理端口范围 (如 1-100)
		if strings.Contains(portStr, "-") {
			rangePorts := parsePortRange(portStr)
			result = append(result, rangePorts...)
		} else {
			// 单个端口
			if port, err := strconv.Atoi(portStr); err == nil {
				if port >= MinPort && port <= MaxPort {
					result = append(result, port)
				}
			}
		}
	}

	// 去重和排序
	result = removeDuplicatePorts(result)
	sort.Ints(result)

	return result
}

// SimpleParsePortsFromString 简化版本的端口字符串解析
// 保持与 ParsePortsFromString 的接口兼容性
func SimpleParsePortsFromString(portsStr string) []int {
	return SimpleParsePort(portsStr)
}

// =============================================================================
// 辅助函数
// =============================================================================

// readHostsFromFile 从文件读取主机列表
func readHostsFromFile(filename string) ([]string, error) {
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	var hosts []string
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line != "" && !strings.HasPrefix(line, CommentPrefix) {
			hosts = append(hosts, line)
		}
	}

	return hosts, scanner.Err()
}

// parseHostString 解析主机字符串
func parseHostString(host string) ([]string, error) {
	var hosts []string

	// 按逗号分割多个主机
	for _, h := range strings.Split(host, ",") {
		h = strings.TrimSpace(h)
		if h == "" {
			continue
		}

		// 检查是否为CIDR格式
		if strings.Contains(h, "/") {
			cidrHosts, err := parseCIDR(h)
			if err != nil {
				return nil, fmt.Errorf("解析CIDR %s 失败: %v", h, err)
			}
			hosts = append(hosts, cidrHosts...)
		} else if strings.Contains(h, "-") && !strings.Contains(h, ":") {
			// IP范围格式 (如 192.168.1.1-10)
			rangeHosts, err := parseIPRange(h)
			if err != nil {
				return nil, fmt.Errorf("解析IP范围 %s 失败: %v", h, err)
			}
			hosts = append(hosts, rangeHosts...)
		} else {
			// 单个主机
			hosts = append(hosts, h)
		}
	}

	return hosts, nil
}

// parseCIDR 解析CIDR格式的网段
func parseCIDR(cidr string) ([]string, error) {
	_, ipNet, err := net.ParseCIDR(cidr)
	if err != nil {
		return nil, err
	}

	var hosts []string
	for ip := ipNet.IP.Mask(ipNet.Mask); ipNet.Contains(ip); nextIP(ip) {
		hosts = append(hosts, ip.String())
		
		// 限制最大主机数量，防止内存溢出
		if len(hosts) > SimpleMaxHosts {
			break
		}
	}

	// 移除网络地址和广播地址
	if len(hosts) > 2 {
		hosts = hosts[1 : len(hosts)-1]
	}

	return hosts, nil
}

// parseIPRange 解析IP范围
func parseIPRange(rangeStr string) ([]string, error) {
	parts := strings.Split(rangeStr, "-")
	if len(parts) != 2 {
		return nil, fmt.Errorf("无效的IP范围格式: %s", rangeStr)
	}

	startIP := strings.TrimSpace(parts[0])
	endPart := strings.TrimSpace(parts[1])

	// 检查是否为短格式 (如 192.168.1.1-10)
	if !strings.Contains(endPart, ".") {
		return parseShortIPRange(startIP, endPart)
	}

	// 完整IP范围
	return parseFullIPRange(startIP, endPart)
}

// parseShortIPRange 解析短格式IP范围
func parseShortIPRange(startIPStr, endSuffix string) ([]string, error) {
	startIP := net.ParseIP(startIPStr)
	if startIP == nil {
		return nil, fmt.Errorf("无效的起始IP: %s", startIPStr)
	}

	endNum, err := strconv.Atoi(endSuffix)
	if err != nil {
		return nil, fmt.Errorf("无效的结束数字: %s", endSuffix)
	}

	var hosts []string
	startIPParts := strings.Split(startIPStr, ".")
	if len(startIPParts) != 4 {
		return nil, fmt.Errorf("无效的IP格式: %s", startIPStr)
	}

	baseIP := strings.Join(startIPParts[:3], ".")
	startNum, _ := strconv.Atoi(startIPParts[3])

	for i := startNum; i <= endNum && i <= RouterSwitchLastOctet; i++ {
		hosts = append(hosts, fmt.Sprintf("%s.%d", baseIP, i))
	}

	return hosts, nil
}

// parseFullIPRange 解析完整IP范围
func parseFullIPRange(startIPStr, endIPStr string) ([]string, error) {
	startIP := net.ParseIP(startIPStr)
	endIP := net.ParseIP(endIPStr)
	
	if startIP == nil || endIP == nil {
		return nil, fmt.Errorf("无效的IP地址")
	}

	var hosts []string
	for ip := make(net.IP, len(startIP)); ; nextIP(ip) {
		copy(ip, startIP)
		hosts = append(hosts, ip.String())
		
		if ip.Equal(endIP) {
			break
		}
		
		// 限制最大主机数量
		if len(hosts) > SimpleMaxHosts {
			break
		}
		
		nextIP(startIP)
	}

	return hosts, nil
}

// parsePortRange 解析端口范围
func parsePortRange(rangeStr string) []int {
	parts := strings.Split(rangeStr, "-")
	if len(parts) != 2 {
		return nil
	}

	start, err1 := strconv.Atoi(strings.TrimSpace(parts[0]))
	end, err2 := strconv.Atoi(strings.TrimSpace(parts[1]))
	
	if err1 != nil || err2 != nil || start < MinPort || end > MaxPort || start > end {
		return nil
	}

	var ports []int
	for i := start; i <= end; i++ {
		ports = append(ports, i)
		
		// 限制端口范围大小
		if len(ports) > SimpleMaxPortRange {
			break
		}
	}

	return ports
}

// expandPortGroups 展开端口组
func expandPortGroups(ports string) string {
	// 使用预定义的端口组
	portGroups := GetPortGroups()

	result := ports
	for group, portList := range portGroups {
		result = strings.ReplaceAll(result, group, portList)
	}

	return result
}

// excludeHosts 排除指定的主机
func excludeHosts(hosts, excludeList []string) []string {
	if len(excludeList) == 0 {
		return hosts
	}

	excludeMap := make(map[string]struct{})
	for _, exclude := range excludeList {
		excludeMap[exclude] = struct{}{}
	}

	var result []string
	for _, host := range hosts {
		if _, found := excludeMap[host]; !found {
			result = append(result, host)
		}
	}

	return result
}

// removeDuplicates 去除字符串重复项
func removeDuplicates(slice []string) []string {
	keys := make(map[string]struct{})
	var result []string
	
	for _, item := range slice {
		if _, found := keys[item]; !found {
			keys[item] = struct{}{}
			result = append(result, item)
		}
	}
	
	return result
}

// removeDuplicatePorts 去除端口重复项
func removeDuplicatePorts(slice []int) []int {
	keys := make(map[int]struct{})
	var result []int
	
	for _, item := range slice {
		if _, found := keys[item]; !found {
			keys[item] = struct{}{}
			result = append(result, item)
		}
	}
	
	return result
}

// nextIP 计算下一个IP地址
func nextIP(ip net.IP) {
	for j := len(ip) - 1; j >= 0; j-- {
		ip[j]++
		if ip[j] > 0 {
			break
		}
	}
}