From fe7c06c550467da2c052c86dc8321f99e1d63395 Mon Sep 17 00:00:00 2001
From: Samuel Lorch <sam@soontm.de>
Date: Sun, 23 Apr 2023 19:40:58 +0200
Subject: [PATCH] util additions

---
 internal/util/address.go | 16 +++++++++-------
 internal/util/net.go     | 22 ++++++++++++++++++++++
 internal/util/service.go | 14 +++++++-------
 3 files changed, 38 insertions(+), 14 deletions(-)
 create mode 100644 internal/util/net.go

diff --git a/internal/util/address.go b/internal/util/address.go
index dc42dc3..5c2b15a 100644
--- a/internal/util/address.go
+++ b/internal/util/address.go
@@ -1,15 +1,17 @@
 package util
 
-import "nfsense.net/nfsense/internal/definitions"
+import (
+	"nfsense.net/nfsense/internal/definitions/object"
+)
 
 // ResolveBaseAddresses Resolves all groups to their base Addresses
-func ResolveBaseAddresses(allAddresses map[string]definitions.Address, addressNames []string) []definitions.Address {
-	baseAddresses := []definitions.Address{}
+func ResolveBaseAddresses(allAddresses map[string]object.Address, addressNames []string) []object.Address {
+	baseAddresses := []object.Address{}
 
 	for _, addressName := range addressNames {
 		address := allAddresses[addressName]
 
-		if address.Type == definitions.AddressGroup {
+		if address.Type == object.AddressGroup {
 			baseAddresses = append(baseAddresses, resolveAddressChildren(allAddresses, address)...)
 		} else {
 			baseAddresses = append(baseAddresses, address)
@@ -20,12 +22,12 @@ func ResolveBaseAddresses(allAddresses map[string]definitions.Address, addressNa
 	return baseAddresses
 }
 
-func resolveAddressChildren(allAddresses map[string]definitions.Address, a definitions.Address) []definitions.Address {
-	addressList := []definitions.Address{}
+func resolveAddressChildren(allAddresses map[string]object.Address, a object.Address) []object.Address {
+	addressList := []object.Address{}
 	for _, addressName := range *a.Children {
 		address := allAddresses[addressName]
 
-		if address.Type == definitions.AddressGroup {
+		if address.Type == object.AddressGroup {
 			addressList = append(addressList, resolveAddressChildren(allAddresses, address)...)
 		} else {
 			addressList = append(addressList, address)
diff --git a/internal/util/net.go b/internal/util/net.go
new file mode 100644
index 0000000..d35ed6b
--- /dev/null
+++ b/internal/util/net.go
@@ -0,0 +1,22 @@
+package util
+
+import (
+	"net"
+)
+
+func BroadcastAddr(n net.IPNet) net.IP {
+	var broadcast net.IP
+	var length int
+	if n.IP.To4() != nil {
+		broadcast = net.ParseIP("0.0.0.0").To4()
+		length = 4
+	} else {
+		broadcast = net.ParseIP("::")
+		length = 16
+
+	}
+	for i := 0; i < length; i++ {
+		broadcast[i] = n.IP[i] | ^n.Mask[i]
+	}
+	return broadcast
+}
diff --git a/internal/util/service.go b/internal/util/service.go
index e72cade..8132f51 100644
--- a/internal/util/service.go
+++ b/internal/util/service.go
@@ -1,15 +1,15 @@
 package util
 
-import "nfsense.net/nfsense/internal/definitions"
+import "nfsense.net/nfsense/internal/definitions/object"
 
 // ResolveBaseServices Resolves all groups to their base Services
-func ResolveBaseServices(allServices map[string]definitions.Service, serviceNames []string) []definitions.Service {
-	baseServices := []definitions.Service{}
+func ResolveBaseServices(allServices map[string]object.Service, serviceNames []string) []object.Service {
+	baseServices := []object.Service{}
 
 	for _, serviceName := range serviceNames {
 		service := allServices[serviceName]
 
-		if service.Type == definitions.ServiceGroup {
+		if service.Type == object.ServiceGroup {
 			baseServices = append(baseServices, resolveServiceChildren(allServices, service)...)
 		} else {
 			baseServices = append(baseServices, service)
@@ -20,12 +20,12 @@ func ResolveBaseServices(allServices map[string]definitions.Service, serviceName
 	return baseServices
 }
 
-func resolveServiceChildren(allServices map[string]definitions.Service, s definitions.Service) []definitions.Service {
-	serviceList := []definitions.Service{}
+func resolveServiceChildren(allServices map[string]object.Service, s object.Service) []object.Service {
+	serviceList := []object.Service{}
 	for _, serviceName := range *s.Children {
 		service := allServices[serviceName]
 
-		if service.Type == definitions.ServiceGroup {
+		if service.Type == object.ServiceGroup {
 			serviceList = append(serviceList, resolveServiceChildren(allServices, service)...)
 		} else {
 			serviceList = append(serviceList, service)