make linter happy

Signed-off-by: Florian Lehner <[email protected]>

Author: florianl

goNetViz-reconstruct.go

@@ -3,14 +3,15 @@ package main
 import (
 	"bufio"
 	"fmt"
-	"github.com/google/gopacket"
-	"github.com/google/gopacket/layers"
-	"github.com/google/gopacket/pcapgo"
-	"golang.org/x/sync/errgroup"
 	"os"
 	"reflect"
 	"regexp"
 	"strconv"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcapgo"
+	"golang.org/x/sync/errgroup"
 )
 
 // reconstructOptions represents all options for reconstruction
@@ -66,7 +67,7 @@ func createPacket(ch chan<- []byte, packet []int, bpP int) error {
 			buf = append(buf, byte(tmp))
 		}
 	default:
-		return fmt.Errorf("This format is not supported so far")
+		return fmt.Errorf("this format is not supported so far")
 	}
 
 	ch <- buf
@@ -87,7 +88,7 @@ func checkVersion(parse *[]svgOptions, version string) (string, error) {
 		*parse = append([]svgOptions{lValue}, *parse...)
 		lGate := svgOptions{regex: "\\s+LogicGate=\"([a-zA-Z]+)\"", reconstructOption: "LogicGate"}
 		*parse = append([]svgOptions{lGate}, *parse...)
-		return "", fmt.Errorf("Can't decode version 0.0.4 at the moment.")
+		return "", fmt.Errorf("can't decode version 0.0.4 at the moment")
 	case "0.0.3":
 		filter := svgOptions{regex: "\\s+Filter=\"(\\w+)\"", reconstructOption: "Filter"}
 		*parse = append([]svgOptions{filter}, *parse...)
@@ -96,7 +97,7 @@ func checkVersion(parse *[]svgOptions, version string) (string, error) {
 		dtg := svgOptions{regex: "\\s+DTG=\"([0-9. :a-zA-Z]+)\"", reconstructOption: "Dtg"}
 		*parse = append([]svgOptions{dtg}, *parse...)
 	default:
-		return "", fmt.Errorf("Unrecognized version: %s", version)
+		return "", fmt.Errorf("unrecognized version: %s", version)
 	}
 	return version, nil
 }
@@ -128,13 +129,13 @@ func checkHeader(svg *bufio.Scanner) (reconstructOptions, error) {
 	for svg.Scan() {
 		line := svg.Text()
 		switch {
-		case options.LimitX == 0 && options.LimitY == 0 && header == false:
+		case options.LimitX == 0 && options.LimitY == 0 && !header:
 			matches := limits.FindStringSubmatch(line)
 			if len(matches) == 3 {
 				options.LimitX, _ = strconv.Atoi(matches[1])
 				options.LimitY, _ = strconv.Atoi(matches[2])
 			}
-		case header == false:
+		case !header:
 			if headerStart.MatchString(line) {
 				header = true
 			}
@@ -148,7 +149,7 @@ func checkHeader(svg *bufio.Scanner) (reconstructOptions, error) {
 			}
 		default:
 			if optionIndex > len(parseOptions) {
-				return options, fmt.Errorf("Option index is out of range")
+				return options, fmt.Errorf("option index is out of range")
 			}
 			regex, err := regexp.Compile(parseOptions[optionIndex].regex)
 			if err != nil {
@@ -165,7 +166,7 @@ func checkHeader(svg *bufio.Scanner) (reconstructOptions, error) {
 				case reflect.String:
 					option.SetString(matches[1])
 				default:
-					return options, fmt.Errorf("Unhandeld option type")
+					return options, fmt.Errorf("unhandeld option type")
 				}
 				optionIndex++
 			} else {
@@ -175,13 +176,13 @@ func checkHeader(svg *bufio.Scanner) (reconstructOptions, error) {
 			}
 		}
 	}
-	return options, fmt.Errorf("No end of header found")
+	return options, fmt.Errorf("no end of header found")
 }
 
 func extractInformation(g *errgroup.Group, ch chan []byte, cfg configs) error {
 	inputfile, err := os.Open(cfg.input)
 	if err != nil {
-		return fmt.Errorf("Could not open file %s: %s\n", cfg.input, err.Error())
+		return fmt.Errorf("could not open file %s: %s", cfg.input, err.Error())
 	}
 	defer inputfile.Close()
 	svg := bufio.NewScanner(inputfile)
@@ -217,7 +218,7 @@ func extractInformation(g *errgroup.Group, ch chan []byte, cfg configs) error {
 				packet = packet[:0]
 			}
 			if pixelX >= opt.LimitX {
-				return fmt.Errorf("x-coordinate (%d) is bigger than the limit (%d)\n", pixelX, opt.LimitX)
+				return fmt.Errorf("x-coordinate (%d) is bigger than the limit (%d)", pixelX, opt.LimitX)
 			}
 			r, _ := strconv.Atoi(matches[3])
 			g, _ := strconv.Atoi(matches[4])
@@ -237,7 +238,7 @@ func createPcap(g *errgroup.Group, ch chan []byte, cfg configs) error {
 	filename += ".pcap"
 	output, err := os.Create(filename)
 	if err != nil {
-		return fmt.Errorf("Could not create file %s: %s\n", filename, err.Error())
+		return fmt.Errorf("could not create file %s: %s", filename, err.Error())
 	}
 	defer output.Close()
 	w := pcapgo.NewWriter(output)

goNetViz-reconstruct_test.go

@@ -4,12 +4,13 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"golang.org/x/sync/errgroup"
 	"io/ioutil"
 	"os"
 	"regexp"
 	"sync"
 	"testing"
+
+	"golang.org/x/sync/errgroup"
 )
 
 func TestReconstruct(t *testing.T) {
@@ -41,7 +42,7 @@ func TestReconstruct(t *testing.T) {
 		cfg  configs
 		err  string
 	}{
-		{name: "solder", cfg: configs{1, 2, 0, 0, solder, 1, 1500, "", fmt.Sprintf("%s", fakePcap.Name()), fmt.Sprintf("%s/solder", tdir), logic}},
+		{name: "solder", cfg: configs{1, 2, 0, 0, solder, 1, 1500, "", fakePcap.Name(), fmt.Sprintf("%s/solder", tdir), logic}},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
@@ -122,7 +123,7 @@ func TestCreatePacket(t *testing.T) {
 		{name: "24 BitsPerPixel", recv: []byte{8, 16, 32, 64, 128}, packet: []int{8, 16, 32, 64, 128}, bpP: 24},
 		{name: "12 BitPerPixel", recv: []byte{1, 2, 5, 13, 18, 57, 153}, packet: []int{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233}, bpP: 12},
 		{name: "3 BitPerPixel", recv: []byte{5, 49, 14}, packet: []int{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 144, 89, 55, 34, 21, 13, 8, 5, 3, 2, 1, 1, 0}, bpP: 3},
-		{name: "2 BitsPerPixel", recv: []byte{}, packet: []int{8, 16, 32, 64, 128}, bpP: 2, err: "This format is not supported so far"},
+		{name: "2 BitsPerPixel", recv: []byte{}, packet: []int{8, 16, 32, 64, 128}, bpP: 2, err: "this format is not supported so far"},
 		{name: "1 BitPerPixel", recv: []byte{1, 8}, packet: []int{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0}, bpP: 1},
 	}
 
@@ -134,10 +135,8 @@ func TestCreatePacket(t *testing.T) {
 			var recv []byte
 			go func() {
 				defer wg.Done()
-				select {
-				case v, _ := <-ch:
-					recv = append(recv, v...)
-				}
+				v := <-ch
+				recv = append(recv, v...)
 				close(ch)
 			}()
 			err := createPacket(ch, tc.packet, tc.bpP)
@@ -153,7 +152,7 @@ func TestCreatePacket(t *testing.T) {
 				t.Fatalf("Expected error, got none")
 			}
 			wg.Wait()
-			if bytes.Compare(recv, tc.recv) != 0 {
+			if !bytes.Equal(recv, tc.recv) {
 				t.Fatalf("Expected: %v \t Got: %v", tc.recv, recv)
 			}
 		})
@@ -234,12 +233,12 @@ func TestExtractInformation(t *testing.T) {
 		recv []byte
 		err  string
 	}{
-		{name: "No file", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", "noFile", fmt.Sprintf("%s/noFile", dir), logic}, err: "Could not open file"},
-		{name: "Not a svg", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", fmt.Sprintf("%s", notSvgFile.Name()), fmt.Sprintf("%s/not_a_svg", dir), logic}, err: "No end of header found"},
-		{name: "Without Comment", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", fmt.Sprintf("%s", withoutCommentFile.Name()), fmt.Sprintf("%s/without_comment", dir), logic}, err: "No end of header found"},
-		{name: "Valid003 svg", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", fmt.Sprintf("%s", validSvgFile003.Name()), fmt.Sprintf("%s/valid_003_svg", dir), logic}, recv: []byte{0, 0}},
-		{name: "Valid004 svg", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", fmt.Sprintf("%s", validSvgFile004.Name()), fmt.Sprintf("%s/valid_004_svg", dir), logic}, err: "Can't decode version"},
-		{name: "Invalid version", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", fmt.Sprintf("%s", invalidVersionFile.Name()), fmt.Sprintf("%s/invalid_version", dir), logic}, err: "Unrecognized version"},
+		{name: "No file", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", "noFile", fmt.Sprintf("%s/noFile", dir), logic}, err: "could not open file"},
+		{name: "Not a svg", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", notSvgFile.Name(), fmt.Sprintf("%s/not_a_svg", dir), logic}, err: "no end of header found"},
+		{name: "Without Comment", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", withoutCommentFile.Name(), fmt.Sprintf("%s/without_comment", dir), logic}, err: "no end of header found"},
+		{name: "Valid003 svg", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", validSvgFile003.Name(), fmt.Sprintf("%s/valid_003_svg", dir), logic}, recv: []byte{0, 0}},
+		{name: "Valid004 svg", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", validSvgFile004.Name(), fmt.Sprintf("%s/valid_004_svg", dir), logic}, err: "can't decode version"},
+		{name: "Invalid version", cfg: configs{1, 0, 0, 0, 0, 1, 1500, "", invalidVersionFile.Name(), fmt.Sprintf("%s/invalid_version", dir), logic}, err: "unrecognized version"},
 	}
 
 	for _, tc := range tests {
@@ -267,7 +266,7 @@ func TestExtractInformation(t *testing.T) {
 				t.Fatalf("Expected error, got none")
 			}
 			wg.Wait()
-			if bytes.Compare(recv, tc.recv) != 0 {
+			if !bytes.Equal(recv, tc.recv) {
 				t.Fatalf("Expected: %v \t Got: %v", tc.recv, recv)
 			}
 		})

goNetViz.go

@@ -194,39 +194,39 @@ func createTerminalVisualization(pkt1, pkt2 data, cfg configs) {
 
 func createImage(filename string, width, height int, content string, cfg configs) error {
 	if len(content) == 0 {
-		return fmt.Errorf("No content to write")
+		return fmt.Errorf("no content to write")
 	}
 
 	f, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0644)
 	if err != nil {
-		return fmt.Errorf("Could not open file %s: %s", filename, err.Error())
+		return fmt.Errorf("could not open file %s: %s", filename, err.Error())
 	}
 
 	if _, err := f.WriteString(fmt.Sprintf("<?xml version=\"1.0\"?>\n<svg width=\"%d\" height=\"%d\">\n", width, height)); err != nil {
 		f.Close()
-		return fmt.Errorf("Could not write header: %s", err.Error())
+		return fmt.Errorf("could not write header: %s", err.Error())
 	}
 
 	var source = cfg.input
 
 	if _, err := f.WriteString(fmt.Sprintf("<!--\n\tgoNetViz \"%s\"\n\tScale=%d\n\tBitsPerPixel=%d\n\tDTG=\"%s\"\n\tSource=\"%s\"\n\tFilter=\"%s\"\n\tLogicGate=\"%s\"\n\tLogicValue=0x%X\n-->\n",
 		Version, cfg.scale, cfg.bpP, time.Now().UTC(), source, cfg.filter, cfg.logicOp.name, cfg.logicOp.value)); err != nil {
 		f.Close()
-		return fmt.Errorf("Could not write additional information: %s", err.Error())
+		return fmt.Errorf("could not write additional information: %s", err.Error())
 	}
 
 	if _, err := f.WriteString(content); err != nil {
 		f.Close()
-		return fmt.Errorf("Could not write content: %s", err.Error())
+		return fmt.Errorf("could not write content: %s", err.Error())
 	}
 
 	if _, err := f.WriteString("</svg>"); err != nil {
 		f.Close()
-		return fmt.Errorf("Could not write closing information: %s", err.Error())
+		return fmt.Errorf("could not write closing information: %s", err.Error())
 	}
 
 	if err := f.Close(); err != nil {
-		return fmt.Errorf("Could not close file %s: %s", filename, err.Error())
+		return fmt.Errorf("could not close file %s: %s", filename, err.Error())
 	}
 	return nil
 }
@@ -314,7 +314,6 @@ func handlePackets(g *errgroup.Group, input source, cfg configs, ch chan<- data)
 
 		ch <- data{len: plen, toa: toa, payload: logicGate(bytes, logicValue)}
 	}
-	return
 }
 
 func initPcapSource(input, filter string, device bool) (source, error) {
@@ -355,17 +354,17 @@ func initSource(input, filter string, pcap bool) (handle source, err error) {
 		device = true
 	}
 
-	if len(filter) > 0 || pcap == true {
+	if len(filter) > 0 || pcap {
 		return initPcapSource(input, filter, device)
 	}
 
 	if device {
-		return nil, fmt.Errorf("Please open networking interface with pcap support")
+		return nil, fmt.Errorf("please open networking interface with pcap support")
 	}
 
 	fi, err := os.Lstat(input)
 	if err != nil {
-		return nil, fmt.Errorf("Could not get file information")
+		return nil, fmt.Errorf("could not get file information")
 	}
 	mode := fi.Mode()
 
@@ -401,7 +400,7 @@ func getOperand(val string) (byte, error) {
 	}
 
 	if err != nil {
-		return 0x00, fmt.Errorf("Could not convert %s", val)
+		return 0x00, fmt.Errorf("could not convert %s", val)
 	}
 
 	if i < 0 || i > 255 {