From e610df69eb4d4df1a3c16eb35cb4966a6bfbee43 Mon Sep 17 00:00:00 2001
From: Jeff Carr <jcarr@wit.com>
Date: Sun, 27 Oct 2024 05:48:05 -0500
Subject: make that giang function it's own file

Signed-off-by: Jeff Carr <jcarr@wit.com>
---
 dumpNonStandardXML.go | 479 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 479 insertions(+)
 create mode 100644 dumpNonStandardXML.go

(limited to 'dumpNonStandardXML.go')

diff --git a/dumpNonStandardXML.go b/dumpNonStandardXML.go
new file mode 100644
index 0000000..2b2bdb9
--- /dev/null
+++ b/dumpNonStandardXML.go
@@ -0,0 +1,479 @@
+// Copyright 2024 WIT.COM Inc Licensed GPL 3.0
+
+// just a monstrous hack to get things working.
+// todo: rework this?
+
+// go through the libvirt xml object and dump out everything
+// that is "standard". This is just a way to double check that
+// there might be something interesting in a VM
+// 'standard' here means what I think is standard
+
+package virtigoxml
+
+import (
+	"encoding/xml"
+	"fmt"
+
+	"go.wit.com/log"
+	"libvirt.org/go/libvirtxml"
+)
+
+func DumpNonStandardXML(domcfg *libvirtxml.Domain) (string, error) {
+	// dump type
+	if domcfg.Type == "kvm" {
+		domcfg.Type = ""
+	} else {
+		fmt.Printf("type: %+v\n", domcfg.Type)
+	}
+
+	// dump normal OS settings
+	var standardOS bool = false
+	if domcfg.OS != nil {
+		if domcfg.OS.Type != nil {
+			// OS Type: &{Arch:x86_64 Machine:pc-i440fx-5.2 Type:hvm}
+			t := domcfg.OS.Type
+			if t.Arch == "x86_64" || t.Machine == "pc-i440fx-5.2" {
+				standardOS = true
+			}
+		}
+	}
+	if standardOS {
+		domcfg.OS = nil
+	} else {
+		fmt.Printf("OS: %+v\n", domcfg.OS)
+		fmt.Printf("OS Type: %+v\n", domcfg.OS.Type)
+	}
+
+	// ignore XMLName and IOThreads probably
+	// skip is hard coded in isDomainEmpty() function
+	// fmt.Printf("XMLName: %+v\n", domcfg.XMLName)
+	// fmt.Printf("IOThreads: %+v\n", domcfg.IOThreads)
+
+	// dump all the clock stuff if it's standard
+	var normalclock bool = true
+	if domcfg.Clock.Offset != "utc" {
+		normalclock = false
+	}
+	for i, t := range domcfg.Clock.Timer {
+		// fmt.Printf("Test Clock Timer: %d , %s , %+v\n", i, t.Name, t)
+		switch t.Name {
+		case "rtc":
+			if t.TickPolicy != "catchup" {
+				fmt.Printf("Clock Name: %+v , %+v\n", i, t)
+				normalclock = false
+			}
+		case "pit":
+			if t.TickPolicy != "delay" {
+				fmt.Printf("Clock Name: %+v , %+v\n", i, t)
+				normalclock = false
+			}
+		case "hpet":
+			if t.Present != "no" {
+				fmt.Printf("Clock Name: %+v , %+v\n", i, t)
+				normalclock = false
+			}
+		default:
+			fmt.Printf("Clock Name: %+v , %+v\n", i, t)
+			normalclock = false
+		}
+	}
+	if normalclock {
+		domcfg.Clock = nil
+	} else {
+		fmt.Printf("Clock was 'nonstandard' %+v\n", domcfg.Clock.Timer)
+	}
+
+	// probably just dump Features for now
+	// fmt.Printf("Features: %+v\n", domcfg.Features)
+	// fmt.Printf("Feature VMPort: %+v\n", domcfg.Features.VMPort)
+	// ignore if ACPI is set or not
+	var featurematch bool = true
+	if domcfg.Features.ACPI != nil {
+		domcfg.Features.ACPI = nil
+	} else {
+		featurematch = false
+	}
+	// ignore if APIC is set or not
+	if domcfg.Features.APIC != nil {
+		domcfg.Features.APIC = nil
+	} else {
+		featurematch = false
+	}
+	// what is VMPort anyway?
+	if domcfg.Features.VMPort != nil {
+		if domcfg.Features.VMPort.State == "off" {
+			domcfg.Features.VMPort = nil
+		}
+	} else {
+		featurematch = false
+	}
+	// screwit, if all three of those match just erase
+	// this. not sure what uses it anyway but it's probably obscure
+	// and I'm not using it on any of my machines right now
+	// also, this is dumb that I'm doing this but I want to
+	// fine tooth comb through this right now
+	// also, I don't have a boss so nobody can tell me what to do
+	if featurematch {
+		domcfg.Features = nil
+	}
+
+	// fmt.Printf("Features: %+v\n", domcfg.Features)
+
+	// for i, f := range domcfg.Features {
+	// 	fmt.Printf("Feature: %+v , %+v\n", i, f)
+	// }
+
+	// these should always just be strings?
+	domcfg.Name = ""
+	domcfg.UUID = ""
+
+	// todo: actually check these for anything different
+	domcfg.Memory = nil
+	domcfg.CurrentMemory = nil
+	domcfg.VCPU = nil
+	// is this always "host-passthrough" and "host-model"?
+	// only Fabrice knows :)
+	if domcfg.CPU != nil {
+		switch domcfg.CPU.Mode {
+		case "host-passthrough":
+			domcfg.CPU = nil
+		case "host-model":
+			domcfg.CPU = nil
+		case "custom":
+			updatedXML, _ := xml.MarshalIndent(domcfg.CPU, "", "  ")
+			log.Info("Ignoring custom CPU Start")
+			fmt.Println(string(updatedXML))
+			log.Info("Ignoring custom CPU End (--xml-ignore-cpu=true)")
+			//if argv.IgnoreCpu {
+			//	domcfg.CPU = nil
+			//}
+		default:
+			fmt.Printf("unknown CPU: %+v\n", domcfg.CPU)
+			fmt.Printf("unknown CPU Model: %+v\n", domcfg.CPU.Model)
+			fmt.Printf("unknown CPU Mode: %+v\n", domcfg.CPU.Mode)
+			updatedXML, _ := xml.MarshalIndent(domcfg.CPU, "", "  ")
+			log.Info("Non-Standard XML Start")
+			fmt.Println(string(updatedXML))
+			log.Info("Non-Standard XML End")
+		}
+	}
+
+	var secnormal bool = true
+	if len(domcfg.SecLabel) != 0 {
+		for _, sec := range domcfg.SecLabel {
+			switch sec.Model {
+			case "apparmor":
+				// log.Info("ignoring SecLabel apparmor. not supported yet")
+				// log.Info("you must set this later if you need this")
+				// xmlAny(sec)
+			case "dac":
+				// log.Info("ignoring SecLabel dac. not supported yet")
+				// log.Info("you must set this later if you need this")
+				// xmlAny(sec)
+			default:
+				fmt.Printf("unknown SecLabel: %+v\n", sec)
+				fmt.Printf("unknown SecLabel.Model: %+v\n", sec.Model)
+				xmlAny(sec)
+				secnormal = false
+			}
+		}
+	}
+	if secnormal {
+		domcfg.SecLabel = nil
+	}
+
+	// ignore Metadata
+	// this is probably something about what kind of OS you might be running
+	// todo: get this directly from the disk image
+	if domcfg.Metadata != nil {
+		var s string
+		s = domcfg.Metadata.XML
+		log.Info("Not saving Domain.Metadata.XML:", s)
+		log.Info("todo: get this from disk image")
+		domcfg.Metadata = nil
+	}
+
+	// ignore Resource
+	if domcfg.Resource != nil {
+		if domcfg.Resource.Partition == "/machine" {
+			domcfg.Resource = nil
+		} else {
+			fmt.Printf("non-standard Domain.Resource: %+v\n", domcfg.Resource)
+		}
+	}
+
+	// ignore Resource
+	if domcfg.ID != nil {
+		// ignore domain id
+		domcfg.ID = nil
+	}
+
+	// this will move elsewhere in the protobuf someday
+	// ignore all these for now
+	if domcfg.OnPoweroff != "" { // normally "destroy"
+		domcfg.OnPoweroff = ""
+	}
+	if domcfg.OnCrash != "" { // normally "restart", often "destroy"
+		domcfg.OnCrash = ""
+	}
+	if domcfg.OnReboot != "" { // normally "restart"
+		domcfg.OnReboot = ""
+	}
+	// same with PM. move to protobuf
+	domcfg.PM = nil
+
+	// only keep non-qemu stuff
+	var qemu bool = true
+	for _, disk := range domcfg.Devices.Disks {
+		if disk.Driver.Name != "qemu" {
+			fmt.Printf("- Disk: %s, Device: %s, Source: %s\n", disk.Device, disk.Driver.Name, disk.Source.File.File)
+			fmt.Printf("FOUND NON QEMU DISK\n")
+			fmt.Printf("FOUND NON QEMU DISKS\n")
+			qemu = false
+		} else {
+		}
+	}
+	if qemu {
+		domcfg.Devices.Disks = nil
+	} else {
+		// fmt.Printf("FOUND NON QEMU DISKS\n")
+	}
+
+	// network interfaces get processed elsewhere
+	domcfg.Devices.Interfaces = nil
+
+	// look for strange stuff here
+	var normalPCI bool = true
+	var keepPCI []libvirtxml.DomainController
+	for _, controller := range domcfg.Devices.Controllers {
+		switch controller.Type {
+		case "usb":
+			switch controller.Model {
+			case "ich9-ehci1":
+			case "piix3-uhci":
+			case "qemu-xhci":
+				// fmt.Printf("OK USB: %s, %d\n", controller.Model, *controller.Index)
+			case "ich9-uhci1":
+				// fmt.Printf("OK USB: %s, %d\n", controller.Model, *controller.Index)
+			case "ich9-uhci2":
+				// fmt.Printf("OK USB: %s, %d\n", controller.Model, *controller.Index)
+			case "ich9-uhci3":
+				// fmt.Printf("OK USB: %s, %d\n", controller.Model, *controller.Index)
+			default:
+				keepPCI = append(keepPCI, controller)
+				normalPCI = false
+				fmt.Printf("USB: %s, %d\n", controller.Model, *controller.Index)
+				// Domain:0xc0002d2760 Bus:0xc0002d2768 Slot:0xc0002d2770 Function:0xc0002d2778 MultiFunction:
+				pci := controller.Address.PCI
+				fmt.Printf("USB: Domain: %+v Slot %d Function %d\n", *pci.Domain, *pci.Slot, *pci.Function)
+			}
+		case "ide":
+			// fmt.Printf("IGNORE IDE\n")
+		case "virtio-serial":
+			// fmt.Printf("IGNORE virtio-serial\n")
+		case "sata":
+			// fmt.Printf("SATA: %s, %d\n", controller.Model, *controller.Index)
+			// fmt.Printf("SATA: %+v\n", controller)
+		case "scsi":
+			switch controller.Model {
+			case "virtio-scsi":
+				// fmt.Printf("IGNORE SCSI: lsilogic\n")
+			case "lsilogic":
+				// fmt.Printf("IGNORE SCSI: lsilogic\n")
+			default:
+				keepPCI = append(keepPCI, controller)
+				normalPCI = false
+			}
+		case "pci":
+			// these are the strings I've found so far
+			switch controller.Model {
+			case "pci-root":
+			case "pcie-root":
+			case "pcie-root-port":
+			case "pcie-to-pci-bridge":
+			default:
+				fmt.Printf("PCI: %s, %d\n", controller.Model, *controller.Index)
+				// Domain:0xc0002d2760 Bus:0xc0002d2768 Slot:0xc0002d2770 Function:0xc0002d2778 MultiFunction:
+				if controller.Address == nil {
+					fmt.Printf("PCI: controller.Address = nil\n")
+				} else {
+					pci := controller.Address.PCI
+					fmt.Printf("PCI: Domain: %+v Slot %d Function %d\n", *pci.Domain, *pci.Slot, *pci.Function)
+				}
+				normalPCI = false
+				keepPCI = append(keepPCI, controller)
+			}
+		default:
+			fmt.Printf("? controllerType: %s: %+v\n", controller.Type, controller)
+			normalPCI = false
+			keepPCI = append(keepPCI, controller)
+		}
+	}
+	if normalPCI {
+		domcfg.Devices.Controllers = nil
+	} else {
+		domcfg.Devices.Controllers = keepPCI
+	}
+
+	// ignore serial and console
+	domcfg.Devices.Serials = nil
+	domcfg.Devices.Consoles = nil
+
+	// ignore sound
+	domcfg.Devices.Sounds = nil
+
+	// ignore input
+	domcfg.Devices.Inputs = nil
+
+	// ignore MemoryBalloon. This is cool, but no mortal humans
+	// are going to use it at this point. By that I mean me.
+	// someday this will be in protobuf?
+	domcfg.Devices.MemBalloon = nil
+
+	if domcfg.Devices.Emulator == "/usr/bin/qemu-system-x86_64" {
+		domcfg.Devices.Emulator = ""
+	}
+
+	// ignore Graphics == Spice when AutoPort = 'yes'
+	var normalSpice bool = true
+	if domcfg.Devices.Graphics != nil {
+		for i, g := range domcfg.Devices.Graphics {
+			if g.VNC != nil {
+				// ignore vnc settings
+				// fmt.Printf("Ignore Graphics VNC settings: %d %+v\n", i, g)
+				continue
+			}
+			if g.Spice != nil {
+				// this is all moved to updateDroplet()
+				// this is a spice definition, just ignore it
+				// because port mappings and network access will be handled
+				// somewhere else someday
+				// fmt.Printf("Graphics: %d %+v\n", i, g)
+				var s *libvirtxml.DomainGraphicSpice
+				s = g.Spice
+				// fmt.Printf("Spice: %d %+v %s\n", i, s, s.AutoPort)
+				if s.AutoPort == "yes" {
+					// should ignore either way
+				} else {
+					// print out, but ignore the port number
+					// fmt.Printf("Spice Port = %d\n", s.Port)
+				}
+				continue
+			}
+			// figure out what to do with non-spice stuff
+			fmt.Printf("Unknown Graphics: %d %+v\n", i, g)
+			normalSpice = false
+		}
+	}
+	if normalSpice {
+		domcfg.Devices.Graphics = nil
+	}
+
+	// blank out emulator. should be in dom0
+	switch domcfg.Devices.Emulator {
+	case "":
+		domcfg.Devices.Emulator = ""
+	case "/usr/bin/kvm":
+		domcfg.Devices.Emulator = ""
+	case "/usr/bin/kvm-spice":
+		domcfg.Devices.Emulator = ""
+	default:
+		fmt.Printf("Unknown Emulator: %s\n", domcfg.Devices.Emulator)
+	}
+
+	// ignore Channels == SpiceVMC
+	normalSpice = true
+	if domcfg.Devices.Channels != nil {
+		for _, c := range domcfg.Devices.Channels {
+			if c.Source != nil {
+				s := c.Source
+				if s != nil {
+					// fmt.Printf("Channels: %+v\n", s.SpiceVMC)
+				} else {
+					fmt.Printf("? Channels: %+v\n", c)
+					normalSpice = false
+				}
+			} else {
+				fmt.Printf("? Channels: %+v\n", c)
+				normalSpice = false
+			}
+		}
+	}
+	if normalSpice {
+		domcfg.Devices.Channels = nil
+	}
+
+	// this is probably for spice to have keyboard and mouse input
+	normalSpice = true
+	if domcfg.Devices.RedirDevs != nil {
+		for _, c := range domcfg.Devices.RedirDevs {
+			s := c.Source
+			if s != nil {
+				if s.SpiceVMC != nil {
+					// this is the normal USB redirection (I guess)
+				} else {
+					normalSpice = false
+				}
+			} else {
+				normalSpice = false
+			}
+			// fmt.Printf("? RedirDevs: %+v\n", c)
+			// fmt.Printf("? RedirDevs Source: %+v\n", s)
+			// fmt.Printf("? RedirDevs SpiceVMC: %d\n", *s.SpiceVMC)
+			// fmt.Printf("? RedirDevs Address: %+v\n", c.Address)
+			// fmt.Printf("? RedirDevs USB: %+v\n", c.Address.USB)
+		}
+	}
+	if normalSpice {
+		domcfg.Devices.RedirDevs = nil
+	}
+
+	var normalRNGs bool = true
+	if domcfg.Devices.RNGs != nil {
+		for _, rng := range domcfg.Devices.RNGs {
+			if rng.Model == "virtio" {
+				// nothing to do for this
+			} else {
+				fmt.Printf("? RNGs: %+v\n", rng)
+				normalRNGs = false
+			}
+		}
+	}
+	if normalRNGs {
+		domcfg.Devices.RNGs = nil
+	}
+
+	// don't copy this over here yet.
+	// probably most domU's don't really use/need it set to what is in the XML
+	var normalVideo bool = true
+	if domcfg.Devices.Videos != nil {
+		for _, v := range domcfg.Devices.Videos {
+			switch v.Model.Type {
+			case "qxl":
+				if v.Model.VRam == 65536 {
+					// standard qxl video
+				} else {
+					fmt.Printf("? Video: %+v\n", v)
+					fmt.Printf("? Video Model: %+v\n", v.Model)
+					normalVideo = false
+				}
+			case "cirrus":
+			case "virtio":
+				// this should always be standard
+				//fmt.Printf("? Video: %+v\n", v)
+				//fmt.Printf("? Video Model: %+v\n", v.Model)
+				//fmt.Printf("? Video Address: %+v\n", v.Address)
+				//fmt.Printf("? Video PCI: %+v\n", v.Address.PCI)
+			default:
+				fmt.Printf("? Video: %+v\n", v)
+				fmt.Printf("? Video Model: %+v\n", v.Model)
+				normalVideo = false
+			}
+		}
+	}
+	if normalVideo {
+		domcfg.Devices.Videos = nil
+	}
+
+	return finalEmptyCheck(domcfg)
+}
-- 
cgit v1.2.3