134 lines
3.0 KiB
Go
134 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
var startPattern = "DNSHelper <<-> START CONFIG"
|
|
var endPattern = "DNSHelper <->> END CONFIG"
|
|
|
|
func extractLinesToEdit(data *workingData) error {
|
|
startIndex := 0
|
|
endIndex := 0
|
|
for i, line := range data.DefaultContent {
|
|
if strings.Contains(line, startPattern) {
|
|
startIndex = i
|
|
continue
|
|
}
|
|
if strings.Contains(line, endPattern) {
|
|
endIndex = i
|
|
break
|
|
}
|
|
}
|
|
var fileModified bool
|
|
var fileCorrupted bool
|
|
switch {
|
|
case startIndex == 0 && endIndex == 0:
|
|
fileModified = false
|
|
fileCorrupted = false
|
|
case startIndex > 0 && endIndex > startIndex:
|
|
fileModified = true
|
|
fileCorrupted = false
|
|
default:
|
|
fileModified = true
|
|
fileCorrupted = true
|
|
}
|
|
|
|
if fileCorrupted == true {
|
|
return errors.New("content has been corrupted")
|
|
}
|
|
|
|
if fileModified == true {
|
|
data.PrefixContent = data.DefaultContent[:startIndex]
|
|
data.PostfixContent = data.DefaultContent[endIndex+1:]
|
|
data.ExistingContent = data.DefaultContent[startIndex+1 : endIndex]
|
|
} else {
|
|
data.PrefixContent = data.DefaultContent
|
|
data.PostfixContent = make([]string, 0)
|
|
data.ExistingContent = make([]string, 0)
|
|
}
|
|
data.NewContent = make([]string, 0)
|
|
//fmt.Println("PrefixContent:")
|
|
//for _, line := range data.PrefixContent {
|
|
// fmt.Println(line)
|
|
//}
|
|
//fmt.Println("ExistingContent:")
|
|
//for _, line := range data.ExistingContent {
|
|
// fmt.Println(line)
|
|
//}
|
|
//fmt.Println("PostfixContent:")
|
|
//for _, line := range data.PostfixContent {
|
|
// fmt.Println(line)
|
|
//}
|
|
return nil
|
|
}
|
|
|
|
func removeHostsFromExistingContent(data *workingData) {
|
|
var updatedContent []string
|
|
for _, host := range data.Hosts {
|
|
for _, line := range data.ExistingContent {
|
|
if !strings.Contains(line, host) {
|
|
updatedContent = append(updatedContent, line)
|
|
}
|
|
}
|
|
}
|
|
data.NewContent = updatedContent
|
|
}
|
|
|
|
func addHostsToWorkingData(data *workingData, hosts *string) {
|
|
hostToAddList := strings.Split(*hosts, ",")
|
|
var newHosts []string
|
|
for _, host := range hostToAddList {
|
|
newHosts = append(newHosts, host)
|
|
}
|
|
data.Hosts = newHosts
|
|
}
|
|
|
|
func addResolversToWorkingData(data *workingData, resolvers *string) {
|
|
resolverToAddList := strings.Split(*resolvers, ",")
|
|
var newResolvers []string
|
|
for _, resolver := range resolverToAddList {
|
|
newResolvers = append(newResolvers, resolver)
|
|
}
|
|
data.Resolvers = newResolvers
|
|
}
|
|
|
|
func addNameToIPMappingsToNewContent(data *workingData) {
|
|
for _, host := range data.Hosts {
|
|
for _, resolver := range data.Resolvers {
|
|
ips := lookupIP(host, resolver)
|
|
if len(ips) > 0 {
|
|
for _, ip := range ips {
|
|
data.NewContent = append(data.NewContent, fmt.Sprintf("%s\t%s", ip, host))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func slicesEqual(a, b []string) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := range a {
|
|
if a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func dedupeSlice(slice []string) []string {
|
|
newSlice := make([]string, 0, len(slice))
|
|
seen := make(map[string]bool)
|
|
for _, value := range slice {
|
|
if !seen[value] {
|
|
seen[value] = true
|
|
newSlice = append(newSlice, value)
|
|
}
|
|
}
|
|
return newSlice
|
|
}
|