network-topology-discovery/internal/device/h3c.go

package device

import (
	"bufio"
	"fmt"
	"network-topology-discovery/pkg/models"
	"regexp"
	"strings"
)

// H3CParser H3C设备解析器
type H3CParser struct {
	BaseParser
}

// GetCommands 获取H3C设备命令列表
func (p *H3CParser) GetCommands() []string {
	return []string{
		"display version",
		"display interface",
		"display ip interface brief",
		"display lldp neighbor-information",
		"display arp",  // ARP表用于MAC到IP的映射
	}
}

// Parse 解析H3C设备输出
func (p *H3CParser) Parse(device *models.Device, outputs []string) error {
	if len(outputs) < 5 {
		return fmt.Errorf("insufficient command outputs")
	}

	p.parseVersion(device, outputs[0])
	
	// 检查命令输出是否为空
	if outputs[1] == "" {
		fmt.Printf("Warning: 'display interface' output is empty for device %s\n", device.IP)
	} else {
		device.Interfaces = p.parseInterfaces(outputs[1], outputs[2])
		if len(device.Interfaces) == 0 {
			fmt.Printf("Warning: parsed 0 interfaces for device %s (output length: %d)\n", 
				device.IP, len(outputs[1]))
		}
	}
	
	// 解析ARP表用于MAC到IP映射（允许失败）
	arpTable := make(map[string]string)
	if outputs[4] != "" {
		arpTable = p.parseARPTable(outputs[4])
		if len(arpTable) == 0 {
			fmt.Printf("Warning: ARP table is empty for device %s\n", device.IP)
		}
	} else {
		fmt.Printf("Warning: ARP command output is empty for device %s\n", device.IP)
	}
	
	// 解析LLDP邻居，使用ARP表进行MAC到IP的映射
	device.Neighbors = p.parseNeighbors(outputs[3], arpTable)
	
	fmt.Printf("Device %s: %d interfaces, %d neighbors, %d ARP entries\n",
		device.IP, len(device.Interfaces), len(device.Neighbors), len(arpTable))

	return nil
}

func (p *H3CParser) parseVersion(device *models.Device, output string) {
	hostnameRegex := regexp.MustCompile(`<(\S+)>`)
	if matches := hostnameRegex.FindStringSubmatch(output); len(matches) > 1 {
		device.Hostname = matches[1]
	}

	if strings.Contains(output, "Comware") {
		lines := strings.Split(output, "\n")
		for _, line := range lines {
			if strings.Contains(line, "Comware") {
				device.OSVersion = strings.TrimSpace(line)
				break
			}
		}
	}

	uptimeRegex := regexp.MustCompile(`uptime is\s+(\d+\s+\S+)`)
	if matches := uptimeRegex.FindStringSubmatch(output); len(matches) > 1 {
		device.Uptime = matches[1]
	}
}

func (p *H3CParser) parseInterfaces(interfaceOutput, briefOutput string) []models.Interface {
	var interfaces []models.Interface
	briefMap := p.parseInterfaceBrief(briefOutput)

	scanner := bufio.NewScanner(strings.NewReader(interfaceOutput))
	var currentInterface *models.Interface

	for scanner.Scan() {
		line := scanner.Text()

		if nameRegex := regexp.MustCompile(`^(\S+)\s+current state:\s+(UP|DOWN)`); nameRegex.MatchString(line) {
			if currentInterface != nil {
				interfaces = append(interfaces, *currentInterface)
			}
			matches := nameRegex.FindStringSubmatch(line)
			currentInterface = &models.Interface{
				Name:   matches[1],
				Status: strings.ToLower(matches[2]),
			}

			if brief, ok := briefMap[currentInterface.Name]; ok {
				currentInterface.IP = brief.IP
			}
		}

		if currentInterface != nil {
			if descRegex := regexp.MustCompile(`Description:\s+(.+)`); descRegex.MatchString(line) {
				currentInterface.Description = descRegex.FindStringSubmatch(line)[1]
			}

			if macRegex := regexp.MustCompile(`Hardware address is\s+(\S+)`); macRegex.MatchString(line) {
				currentInterface.MAC = macRegex.FindStringSubmatch(line)[1]
			}

			if ipRegex := regexp.MustCompile(`IP Address:\s+(\d+\.\d+\.\d+\.\d+)\s+Subnet Mask:\s+(\d+\.\d+\.\d+\.\d+)`); ipRegex.MatchString(line) {
				matches := ipRegex.FindStringSubmatch(line)
				currentInterface.IP = matches[1]
				currentInterface.Mask = matches[2]
			}

			if speedRegex := regexp.MustCompile(`(\d+)\s+(Kbps|Mbps|Gbps)`); speedRegex.MatchString(line) {
				matches := speedRegex.FindStringSubmatch(line)
				currentInterface.Speed = matches[1] + " " + matches[2]
			}
		}
	}

	if currentInterface != nil {
		interfaces = append(interfaces, *currentInterface)
	}

	return interfaces
}

// parseARPTable 解析ARP表，建立MAC到IP的映射
func (p *H3CParser) parseARPTable(output string) map[string]string {
	macToIP := make(map[string]string)
	lines := strings.Split(output, "\n")

	for _, line := range lines {
		// 跳过空行和标题行
		if strings.TrimSpace(line) == "" || 
		   strings.Contains(line, "Type") ||
		   strings.Contains(line, "------") {
			continue
		}

		// ARP表格式: IP Address      MAC Address      Interface/Vlan
		// 例: 172.16.12.1      a4bb-6de2-62cd   GE1/0/1
		fields := strings.Fields(line)
		if len(fields) >= 2 {
			ip := fields[0]
			mac := strings.ToLower(fields[1])
			
			// 验证是有效的IP和MAC
			if isValidIP(ip) && isValidMAC(mac) {
				macToIP[mac] = ip
			}
		}
	}

	return macToIP
}

func (p *H3CParser) parseInterfaceBrief(output string) map[string]models.Interface {
	interfaces := make(map[string]models.Interface)
	lines := strings.Split(output, "\n")

	for _, line := range lines {
		fields := strings.Fields(line)
		if len(fields) >= 4 {
			iface := models.Interface{
				Name:   fields[0],
				IP:     fields[1],
				Status: strings.ToLower(fields[3]),
			}
			interfaces[iface.Name] = iface
		}
	}

	return interfaces
}

func (p *H3CParser) parseNeighbors(output string, arpTable map[string]string) []models.Neighbor {
	var neighbors []models.Neighbor
	scanner := bufio.NewScanner(strings.NewReader(output))

	var currentNeighbor *models.Neighbor
	var localInterface string

	for scanner.Scan() {
		line := scanner.Text()

		// 匹配本地接口行: LLDP neighbor-information of port 20[GigabitEthernet1/0/20]:
		if portRegex := regexp.MustCompile(`LLDP neighbor-information of port \d+\[([^\]]+)\]:`); portRegex.MatchString(line) {
			// 保存前一个邻居
			if currentNeighbor != nil && currentNeighbor.RemoteInterface != "" {
				neighbors = append(neighbors, *currentNeighbor)
			}
			
			matches := portRegex.FindStringSubmatch(line)
			localInterface = matches[1]
			currentNeighbor = &models.Neighbor{
				LocalInterface: localInterface,
				Protocol:       "LLDP",
			}
			continue
		}

		if currentNeighbor != nil {
			// 提取 ChassisID (MAC地址)
			if strings.Contains(line, "ChassisID/subtype") {
				parts := strings.SplitN(line, ":", 2)
				if len(parts) == 2 {
					value := strings.TrimSpace(parts[1])
					// 格式: a4bb-6de2-62cd/MAC address
					if macParts := strings.Split(value, "/"); len(macParts) > 0 {
						mac := strings.TrimSpace(strings.ToLower(macParts[0]))
						// 通过ARP表查找IP
						if ip, ok := arpTable[mac]; ok {
							currentNeighbor.RemoteIP = ip
							currentNeighbor.RemoteDevice = ip
						} else {
							// 如果ARP表中没有，使用MAC地址作为标识
							currentNeighbor.RemoteDevice = mac
							// 注意：RemoteIP为空，拓扑可能无法连线
						}
					}
				}
			}

			// 提取 PortID (远程接口)
			if strings.Contains(line, "PortID/subtype") {
				parts := strings.SplitN(line, ":", 2)
				if len(parts) == 2 {
					value := strings.TrimSpace(parts[1])
					// 格式: GigabitEthernet0/0/1/Interface name
					if portParts := strings.Split(value, "/"); len(portParts) >= 3 {
						// 取前3部分作为接口名: GigabitEthernet0/0/1
						currentNeighbor.RemoteInterface = strings.Join(portParts[:3], "/")
					}
				}
			}
		}
	}

	// 添加最后一个邻居
	if currentNeighbor != nil && currentNeighbor.RemoteInterface != "" {
		neighbors = append(neighbors, *currentNeighbor)
	}

	return neighbors
}

// isValidIP 简单验证IP地址
func isValidIP(ip string) bool {
	parts := strings.Split(ip, ".")
	if len(parts) != 4 {
		return false
	}
	for _, part := range parts {
		if len(part) == 0 || len(part) > 3 {
			return false
		}
		for _, c := range part {
			if c < '0' || c > '9' {
				return false
			}
		}
	}
	return true
}

// isValidMAC 简单验证MAC地址
func isValidMAC(mac string) bool {
	parts := strings.Split(mac, "-")
	if len(parts) != 3 && len(parts) != 6 {
		return false
	}
	for _, part := range parts {
		if len(part) != 2 {
			return false
		}
		for _, c := range part {
			if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
				return false
			}
		}
	}
	return true
}