From 2fe8999b2de4c24ef7eeef3bd2c0a483ec966718 Mon Sep 17 00:00:00 2001 From: Edznux Date: Sun, 28 Oct 2018 17:42:25 +0100 Subject: [PATCH] revert ! --- core/core_test.go | 115 +++++++++++++++-- firewall/firewall_darwin.go | 15 +-- firewall/firewall_linux.go | 9 +- firewall/firewall_windows.go | 6 +- modules/any_proxy.go | 18 +-- modules/api_rest.go | 30 ++--- modules/api_rest_controller.go | 9 +- modules/arp_spoof.go | 18 +-- modules/ble_recon.go | 3 +- modules/ble_recon_events.go | 3 +- modules/ble_recon_view.go | 3 +- modules/dns_spoof.go | 18 +-- modules/events_view_http.go | 12 +- modules/gps.go | 6 +- modules/http_proxy.go | 18 +-- modules/http_proxy_base.go | 12 +- modules/http_proxy_base_cookietracker.go | 6 +- modules/http_proxy_base_filters.go | 6 +- modules/http_proxy_base_sslstriper.go | 5 +- modules/http_proxy_js_response.go | 6 +- modules/http_proxy_script.go | 13 +- modules/https_proxy.go | 30 ++--- modules/mac_changer.go | 9 +- modules/mysql_server.go | 27 ++-- modules/net_probe.go | 21 ++-- modules/net_probe_mdns.go | 3 +- modules/net_recon_show.go | 18 ++- modules/net_sniff.go | 3 +- modules/net_sniff_parsers.go | 24 ++-- modules/net_sniff_views.go | 3 +- modules/packet_proxy_linux_amd64.go | 36 ++---- modules/tcp_proxy.go | 33 ++--- modules/ticker.go | 6 +- modules/wifi.go | 28 ++--- modules/wifi_ap.go | 15 +-- modules/wifi_show.go | 53 ++++---- modules/wol.go | 15 +-- network/lan_endpoint.go | 17 +-- network/net_gateway.go | 15 +-- network/net_linux.go | 6 +- network/wifi.go | 12 +- network/wifi_station.go | 5 +- packets/dhcp6.go | 6 +- packets/queue.go | 3 +- session/command_handler.go | 3 +- session/command_handler_test.go | 10 +- session/environment.go | 6 +- session/environment_test.go | 153 ++++++++++------------- session/events.go | 3 +- session/module.go | 58 ++++----- session/module_param.go | 22 ++-- session/session.go | 16 ++- session/session_core_handlers.go | 19 +-- session/session_parse.go | 6 +- 54 files changed, 473 insertions(+), 542 deletions(-) diff --git a/core/core_test.go b/core/core_test.go index 972f690e..8572d26f 100644 --- a/core/core_test.go +++ b/core/core_test.go @@ -2,13 +2,53 @@ package core import ( "bytes" - "github.com/evilsocket/islazy/fs" - "github.com/evilsocket/islazy/str" "io" "os" + "os/user" + "path/filepath" "testing" ) +func TestCoreTrim(t *testing.T) { + var units = []struct { + from string + to string + }{ + {"\t ", ""}, + {" ", ""}, + {" hello world", "hello world"}, + {"hello world ", "hello world"}, + {" hello world\t", "hello world"}, + } + + for _, u := range units { + got := Trim(u.from) + if got != u.to { + t.Fatalf("expected '%s', got '%s'", u.to, got) + } + } +} + +func TestCoreTrimRight(t *testing.T) { + var units = []struct { + from string + to string + }{ + {"\t ", ""}, + {" ", ""}, + {" hello world", " hello world"}, + {"hello world ", "hello world"}, + {" hello world\t", " hello world"}, + } + + for _, u := range units { + got := TrimRight(u.from) + if got != u.to { + t.Fatalf("expected '%s', got '%s'", u.to, got) + } + } +} + func hasInt(a []int, v int) bool { for _, n := range a { if n == v { @@ -92,6 +132,30 @@ func sameStrings(a []string, b []string) bool { return true } +func TestCoreSepSplitAndCommaSplit(t *testing.T) { + var units = []struct { + from string + to []string + }{ + {"foo", []string{"foo"}}, + {"foo#bar", []string{"foo#bar"}}, + {"foo,bar", []string{"foo", "bar"}}, + {"foo,bar,", []string{"foo", "bar"}}, + {"foo,bar,", []string{"foo", "bar"}}, + {"foo,,bar,", []string{"foo", "bar"}}, + {"foo,,bar,,,,", []string{"foo", "bar"}}, + {"foo,bar@wut,.ok", []string{"foo", "bar@wut", ".ok"}}, + } + + for _, u := range units { + if got := SepSplit(u.from, ","); !sameStrings(got, u.to) { + t.Fatalf("expected '%v', got '%v'", u.to, got) + } else if got = CommaSplit(u.from); !sameStrings(got, u.to) { + t.Fatalf("expected '%v', got '%v'", u.to, got) + } + } +} + func TestCoreExec(t *testing.T) { var units = []struct { exec string @@ -118,20 +182,16 @@ func TestCoreExec(t *testing.T) { io.Copy(&buf, r) os.Stdout = oldStdout - gotStdout := str.Trim(buf.String()) + gotStdout := Trim(buf.String()) if gotOut != u.out { t.Fatalf("expected output '%s', got '%s'", u.out, gotOut) - } - if u.err == "" && gotErr != nil { + } else if u.err == "" && gotErr != nil { t.Fatalf("expected no error, got '%s'", gotErr) - } - if u.err != "" && gotErr == nil { + } else if u.err != "" && gotErr == nil { t.Fatalf("expected error '%s', got none", u.err) - } - if u.err != "" && gotErr != nil && gotErr.Error() != u.err { + } else if u.err != "" && gotErr != nil && gotErr.Error() != u.err { t.Fatalf("expected error '%s', got '%s'", u.err, gotErr) - } - if gotStdout != "" { + } else if gotStdout != "" { t.Fatalf("expected empty stdout, got '%s'", gotStdout) } } @@ -148,7 +208,7 @@ func TestCoreExec(t *testing.T) { io.Copy(&buf, r) os.Stdout = oldStdout - gotStdout := str.Trim(buf.String()) + gotStdout := Trim(buf.String()) if gotOut != u.out { t.Fatalf("expected output '%s', got '%s'", u.out, gotOut) } else if u.err == "" && gotErr != nil { @@ -176,9 +236,38 @@ func TestCoreExists(t *testing.T) { } for _, u := range units { - got := fs.Exists(u.what) + got := Exists(u.what) if got != u.exists { t.Fatalf("expected '%v', got '%v'", u.exists, got) } } } + +func TestCoreExpandPath(t *testing.T) { + base, _ := filepath.Abs(".") + usr, _ := user.Current() + + var units = []struct { + from string + to string + err string + }{ + {"", "", ""}, + {"/lulz", "/lulz", ""}, + {".", base, ""}, + {"~", usr.HomeDir, ""}, + } + + for _, u := range units { + gotPath, gotErr := ExpandPath(u.from) + if gotPath != u.to { + t.Fatalf("expected path '%s', got '%s'", u.to, gotPath) + } else if u.err == "" && gotErr != nil { + t.Fatalf("expected no error, got '%v'", gotErr) + } else if u.err != "" && gotErr == nil { + t.Fatalf("expected error '%s', got none", u.err) + } else if u.err != "" && gotErr != nil && gotErr.Error() != u.err { + t.Fatalf("expected error '%s', got '%s'", u.err, gotErr.Error()) + } + } +} diff --git a/firewall/firewall_darwin.go b/firewall/firewall_darwin.go index ab5f6bc9..ac91b370 100644 --- a/firewall/firewall_darwin.go +++ b/firewall/firewall_darwin.go @@ -43,11 +43,11 @@ func Make(iface *network.Endpoint) FirewallManager { func (f PfFirewall) sysCtlRead(param string) (string, error) { if out, err := core.ExecSilent("sysctl", []string{param}); err != nil { return "", err - } - if m := sysCtlParser.FindStringSubmatch(out); len(m) == 3 && m[1] == param { + } else if m := sysCtlParser.FindStringSubmatch(out); len(m) == 3 && m[1] == param { return m[2], nil + } else { + return "", fmt.Errorf("Unexpected sysctl output: %s", out) } - return "", fmt.Errorf("Unexpected sysctl output: %s", out) } func (f PfFirewall) sysCtlWrite(param string, value string) (string, error) { @@ -60,11 +60,11 @@ func (f PfFirewall) sysCtlWrite(param string, value string) (string, error) { // make sure we actually wrote the value if out, err := f.sysCtlRead(param); err != nil { return "", err - } - if out != value { + } else if out != value { return "", fmt.Errorf("Expected value for '%s' is %s, found %s", param, value, out) + } else { + return out, nil } - return out, nil } func (f PfFirewall) IsForwardingEnabled() bool { @@ -87,8 +87,9 @@ func (f PfFirewall) enableParam(param string, enabled bool) error { if _, err := f.sysCtlWrite(param, value); err != nil { return err + } else { + return nil } - return nil } func (f PfFirewall) EnableForwarding(enabled bool) error { diff --git a/firewall/firewall_linux.go b/firewall/firewall_linux.go index bc50c6ea..b5772a87 100644 --- a/firewall/firewall_linux.go +++ b/firewall/firewall_linux.go @@ -53,11 +53,11 @@ func (f LinuxFirewall) enableFeature(filename string, enable bool) error { func (f LinuxFirewall) IsForwardingEnabled() bool { - out, err := ioutil.ReadFile(IPV4ForwardingFile) - if err != nil { + if out, err := ioutil.ReadFile(IPV4ForwardingFile); err != nil { return false + } else { + return str.Trim(string(out)) == "1" } - return str.Trim(string(out)) == "1" } func (f LinuxFirewall) EnableForwarding(enabled bool) error { @@ -111,8 +111,7 @@ func (f *LinuxFirewall) EnableRedirection(r *Redirection, enabled bool) error { // accept all if _, err := core.Exec("iptables", []string{"-P", "FORWARD", "ACCEPT"}); err != nil { return err - } - if _, err := core.Exec("iptables", cmdLine); err != nil { + } else if _, err := core.Exec("iptables", cmdLine); err != nil { return err } } else { diff --git a/firewall/firewall_windows.go b/firewall/firewall_windows.go index 6dd55ecd..74188afc 100644 --- a/firewall/firewall_windows.go +++ b/firewall/firewall_windows.go @@ -30,8 +30,9 @@ func (f WindowsFirewall) IsForwardingEnabled() bool { if out, err := core.Exec("netsh", []string{"interface", "ipv4", "dump"}); err != nil { fmt.Printf("%s\n", err) return false + } else { + return strings.Contains(out, "forwarding=enabled") } - return strings.Contains(out, "forwarding=enabled") } func (f WindowsFirewall) EnableForwarding(enabled bool) error { @@ -87,8 +88,7 @@ func (f *WindowsFirewall) AllowPort(port int, address string, proto string, allo func (f *WindowsFirewall) EnableRedirection(r *Redirection, enabled bool) error { if err := f.AllowPort(r.SrcPort, r.DstAddress, r.Protocol, enabled); err != nil { return err - } - if err := f.AllowPort(r.DstPort, r.DstAddress, r.Protocol, enabled); err != nil { + } else if err := f.AllowPort(r.DstPort, r.DstAddress, r.Protocol, enabled); err != nil { return err } diff --git a/modules/any_proxy.go b/modules/any_proxy.go index 475867c1..7ec73443 100644 --- a/modules/any_proxy.go +++ b/modules/any_proxy.go @@ -82,23 +82,17 @@ func (p *AnyProxy) Configure() error { if p.Running() { return session.ErrAlreadyStarted - } - if err, iface = p.StringParam("any.proxy.iface"); err != nil { + } else if err, iface = p.StringParam("any.proxy.iface"); err != nil { return err - } - if err, protocol = p.StringParam("any.proxy.protocol"); err != nil { + } else if err, protocol = p.StringParam("any.proxy.protocol"); err != nil { return err - } - if err, srcPort = p.IntParam("any.proxy.src_port"); err != nil { + } else if err, srcPort = p.IntParam("any.proxy.src_port"); err != nil { return err - } - if err, dstPort = p.IntParam("any.proxy.dst_port"); err != nil { + } else if err, dstPort = p.IntParam("any.proxy.dst_port"); err != nil { return err - } - if err, srcAddress = p.StringParam("any.proxy.src_address"); err != nil { + } else if err, srcAddress = p.StringParam("any.proxy.src_address"); err != nil { return err - } - if err, dstAddress = p.StringParam("any.proxy.dst_address"); err != nil { + } else if err, dstAddress = p.StringParam("any.proxy.dst_address"); err != nil { return err } diff --git a/modules/api_rest.go b/modules/api_rest.go index edf6ce20..7a87e503 100644 --- a/modules/api_rest.go +++ b/modules/api_rest.go @@ -128,35 +128,25 @@ func (api *RestAPI) Configure() error { if api.Running() { return session.ErrAlreadyStarted - } - if err, ip = api.StringParam("api.rest.address"); err != nil { + } else if err, ip = api.StringParam("api.rest.address"); err != nil { return err - } - if err, port = api.IntParam("api.rest.port"); err != nil { + } else if err, port = api.IntParam("api.rest.port"); err != nil { return err - } - if err, api.allowOrigin = api.StringParam("api.rest.alloworigin"); err != nil { + } else if err, api.allowOrigin = api.StringParam("api.rest.alloworigin"); err != nil { return err - } - if err, api.certFile = api.StringParam("api.rest.certificate"); err != nil { + } else if err, api.certFile = api.StringParam("api.rest.certificate"); err != nil { return err - } - if api.certFile, err = fs.Expand(api.certFile); err != nil { + } else if api.certFile, err = fs.Expand(api.certFile); err != nil { return err - } - if err, api.keyFile = api.StringParam("api.rest.key"); err != nil { + } else if err, api.keyFile = api.StringParam("api.rest.key"); err != nil { return err - } - if api.keyFile, err = fs.Expand(api.keyFile); err != nil { + } else if api.keyFile, err = fs.Expand(api.keyFile); err != nil { return err - } - if err, api.username = api.StringParam("api.rest.username"); err != nil { + } else if err, api.username = api.StringParam("api.rest.username"); err != nil { return err - } - if err, api.password = api.StringParam("api.rest.password"); err != nil { + } else if err, api.password = api.StringParam("api.rest.password"); err != nil { return err - } - if err, api.useWebsocket = api.BoolParam("api.rest.websocket"); err != nil { + } else if err, api.useWebsocket = api.BoolParam("api.rest.websocket"); err != nil { return err } diff --git a/modules/api_rest_controller.go b/modules/api_rest_controller.go index 1586dfb2..52e8b059 100644 --- a/modules/api_rest_controller.go +++ b/modules/api_rest_controller.go @@ -51,8 +51,7 @@ func (api *RestAPI) checkAuth(r *http.Request) bool { // timing attack my ass if subtle.ConstantTimeCompare([]byte(user), []byte(api.username)) != 1 { return false - } - if subtle.ConstantTimeCompare([]byte(pass), []byte(api.password)) != 1 { + } else if subtle.ConstantTimeCompare([]byte(pass), []byte(api.password)) != 1 { return false } } @@ -185,12 +184,10 @@ func (api *RestAPI) sessionRoute(w http.ResponseWriter, r *http.Request) { if !api.checkAuth(r) { setAuthFailed(w, r) return - } - if r.Method == "POST" { + } else if r.Method == "POST" { api.runSessionCommand(w, r) return - } - if r.Method != "GET" { + } else if r.Method != "GET" { http.Error(w, "Bad Request", 400) return } diff --git a/modules/arp_spoof.go b/modules/arp_spoof.go index f4be0167..983d38d6 100644 --- a/modules/arp_spoof.go +++ b/modules/arp_spoof.go @@ -92,17 +92,13 @@ func (p *ArpSpoofer) Configure() error { if err, p.internal = p.BoolParam("arp.spoof.internal"); err != nil { return err - } - if err, targets = p.StringParam("arp.spoof.targets"); err != nil { + } else if err, targets = p.StringParam("arp.spoof.targets"); err != nil { return err - } - if err, whitelist = p.StringParam("arp.spoof.whitelist"); err != nil { + } else if err, whitelist = p.StringParam("arp.spoof.whitelist"); err != nil { return err - } - if p.addresses, p.macs, err = network.ParseTargets(targets, p.Session.Lan.Aliases()); err != nil { + } else if p.addresses, p.macs, err = network.ParseTargets(targets, p.Session.Lan.Aliases()); err != nil { return err - } - if p.wAddresses, p.wMacs, err = network.ParseTargets(whitelist, p.Session.Lan.Aliases()); err != nil { + } else if p.wAddresses, p.wMacs, err = network.ParseTargets(whitelist, p.Session.Lan.Aliases()); err != nil { return err } @@ -240,12 +236,10 @@ func (p *ArpSpoofer) sendArp(saddr net.IP, smac net.HardwareAddr, check_running for ip, mac := range targets { if check_running && !p.Running() { return - } - if p.isWhitelisted(ip, mac) { + } else if p.isWhitelisted(ip, mac) { log.Debug("%s (%s) is whitelisted, skipping from spoofing loop.", ip, mac) continue - } - if saddr.String() == ip { + } else if saddr.String() == ip { continue } diff --git a/modules/ble_recon.go b/modules/ble_recon.go index 040c432c..c082e0b7 100644 --- a/modules/ble_recon.go +++ b/modules/ble_recon.go @@ -184,8 +184,7 @@ func (d *BLERecon) enumAllTheThings(mac string) error { dev, found := d.Session.BLE.Get(mac) if !found || dev == nil { return fmt.Errorf("BLE device with address %s not found.", mac) - } - if d.Running() { + } else if d.Running() { d.gattDevice.StopScanning() } diff --git a/modules/ble_recon_events.go b/modules/ble_recon_events.go index 465eb584..11216785 100644 --- a/modules/ble_recon_events.go +++ b/modules/ble_recon_events.go @@ -43,8 +43,7 @@ func (d *BLERecon) onPeriphConnected(p gatt.Peripheral, err error) { if err != nil { log.Warning("Connected to %s but with error: %s", p.ID(), err) return - } - if d.currDevice == nil { + } else if d.currDevice == nil { // timed out log.Warning("Connected to %s but after the timeout :(", p.ID()) return diff --git a/modules/ble_recon_view.go b/modules/ble_recon_view.go index 0f3272f2..13740f90 100644 --- a/modules/ble_recon_view.go +++ b/modules/ble_recon_view.go @@ -117,8 +117,9 @@ func parseRawData(raw []byte) string { return fmt.Sprintf("%x", raw) } else if b == 0 { break + } else { + s += fmt.Sprintf("%c", b) } - s += fmt.Sprintf("%c", b) } return tui.Yellow(s) diff --git a/modules/dns_spoof.go b/modules/dns_spoof.go index e84b3100..ea95cc3d 100644 --- a/modules/dns_spoof.go +++ b/modules/dns_spoof.go @@ -89,23 +89,17 @@ func (s *DNSSpoofer) Configure() error { if s.Running() { return session.ErrAlreadyStarted - } - if s.Handle, err = pcap.OpenLive(s.Session.Interface.Name(), 65536, true, pcap.BlockForever); err != nil { + } else if s.Handle, err = pcap.OpenLive(s.Session.Interface.Name(), 65536, true, pcap.BlockForever); err != nil { return err - } - if err = s.Handle.SetBPFFilter("udp"); err != nil { + } else if err = s.Handle.SetBPFFilter("udp"); err != nil { return err - } - if err, s.All = s.BoolParam("dns.spoof.all"); err != nil { + } else if err, s.All = s.BoolParam("dns.spoof.all"); err != nil { return err - } - if err, address = s.IPParam("dns.spoof.address"); err != nil { + } else if err, address = s.IPParam("dns.spoof.address"); err != nil { return err - } - if err, domains = s.ListParam("dns.spoof.domains"); err != nil { + } else if err, domains = s.ListParam("dns.spoof.domains"); err != nil { return err - } - if err, hostsFile = s.StringParam("dns.spoof.hosts"); err != nil { + } else if err, hostsFile = s.StringParam("dns.spoof.hosts"); err != nil { return err } diff --git a/modules/events_view_http.go b/modules/events_view_http.go index 7c30ecad..65913842 100644 --- a/modules/events_view_http.go +++ b/modules/events_view_http.go @@ -40,14 +40,11 @@ func (s *EventsStream) shouldDumpHttpRequest(req HTTPRequest) bool { func (s *EventsStream) shouldDumpHttpResponse(res HTTPResponse) bool { if s.dumpHttpResp { return true - } - if strings.Contains(res.ContentType, "text/plain") { + } else if strings.Contains(res.ContentType, "text/plain") { return true - } - if strings.Contains(res.ContentType, "application/json") { + } else if strings.Contains(res.ContentType, "application/json") { return true - } - if strings.Contains(res.ContentType, "text/xml") { + } else if strings.Contains(res.ContentType, "text/xml") { return true } // search for interesting headers @@ -93,8 +90,7 @@ func (s *EventsStream) dumpGZIP(body []byte) string { reader, err := gzip.NewReader(buffer) if err != nil { return s.dumpRaw(body) - } - if _, err = uncompressed.ReadFrom(reader); err != nil { + } else if _, err = uncompressed.ReadFrom(reader); err != nil { return s.dumpRaw(body) } return s.dumpRaw(uncompressed.Bytes()) diff --git a/modules/gps.go b/modules/gps.go index 353035c3..9ed030da 100644 --- a/modules/gps.go +++ b/modules/gps.go @@ -74,11 +74,9 @@ func (gps *GPS) Author() string { func (gps *GPS) Configure() (err error) { if gps.Running() { return session.ErrAlreadyStarted - } - if err, gps.serialPort = gps.StringParam("gps.device"); err != nil { + } else if err, gps.serialPort = gps.StringParam("gps.device"); err != nil { return err - } - if err, gps.baudRate = gps.IntParam("gps.baudrate"); err != nil { + } else if err, gps.baudRate = gps.IntParam("gps.baudrate"); err != nil { return err } diff --git a/modules/http_proxy.go b/modules/http_proxy.go index f176915b..cdd42f56 100644 --- a/modules/http_proxy.go +++ b/modules/http_proxy.go @@ -80,23 +80,17 @@ func (p *HttpProxy) Configure() error { if p.Running() { return session.ErrAlreadyStarted - } - if err, address = p.StringParam("http.proxy.address"); err != nil { + } else if err, address = p.StringParam("http.proxy.address"); err != nil { return err - } - if err, proxyPort = p.IntParam("http.proxy.port"); err != nil { + } else if err, proxyPort = p.IntParam("http.proxy.port"); err != nil { return err - } - if err, httpPort = p.IntParam("http.port"); err != nil { + } else if err, httpPort = p.IntParam("http.port"); err != nil { return err - } - if err, scriptPath = p.StringParam("http.proxy.script"); err != nil { + } else if err, scriptPath = p.StringParam("http.proxy.script"); err != nil { return err - } - if err, stripSSL = p.BoolParam("http.proxy.sslstrip"); err != nil { + } else if err, stripSSL = p.BoolParam("http.proxy.sslstrip"); err != nil { return err - } - if err, jsToInject = p.StringParam("http.proxy.injectjs"); err != nil { + } else if err, jsToInject = p.StringParam("http.proxy.injectjs"); err != nil { return err } diff --git a/modules/http_proxy_base.go b/modules/http_proxy_base.go index 9523588b..a1c91120 100644 --- a/modules/http_proxy_base.go +++ b/modules/http_proxy_base.go @@ -119,11 +119,11 @@ func (p *HTTPProxy) Configure(address string, proxyPort int, httpPort int, scrip if strings.HasPrefix(jsToInject, "http://") || strings.HasPrefix(jsToInject, "https://") { p.jsHook = fmt.Sprintf("", jsToInject) } else if fs.Exists(jsToInject) { - data, err := ioutil.ReadFile(jsToInject) - if err != nil { + if data, err := ioutil.ReadFile(jsToInject); err != nil { return err + } else { + jsToInject = string(data) } - jsToInject = string(data) } if p.jsHook == "" && jsToInject != "" { @@ -134,11 +134,11 @@ func (p *HTTPProxy) Configure(address string, proxyPort int, httpPort int, scrip } if scriptPath != "" { - err, p.Script = LoadHttpProxyScript(scriptPath, p.sess) - if err != nil { + if err, p.Script = LoadHttpProxyScript(scriptPath, p.sess); err != nil { return err + } else { + log.Debug("Proxy script %s loaded.", scriptPath) } - log.Debug("Proxy script %s loaded.", scriptPath) } p.Server = &http.Server{ diff --git a/modules/http_proxy_base_cookietracker.go b/modules/http_proxy_base_cookietracker.go index 95c132c1..d60f7802 100644 --- a/modules/http_proxy_base_cookietracker.go +++ b/modules/http_proxy_base_cookietracker.go @@ -24,12 +24,12 @@ func NewCookieTracker() *CookieTracker { } func (t *CookieTracker) domainOf(req *http.Request) string { - parsed, err := tld.Parse(req.Host) - if err != nil { + if parsed, err := tld.Parse(req.Host); err != nil { log.Warning("Could not parse host %s: %s", req.Host, err) return req.Host + } else { + return fmt.Sprintf("%s.%s", parsed.Domain, parsed.TLD) } - return fmt.Sprintf("%s.%s", parsed.Domain, parsed.TLD) } func (t *CookieTracker) keyOf(req *http.Request) string { diff --git a/modules/http_proxy_base_filters.go b/modules/http_proxy_base_filters.go index a791bd10..de7110fa 100644 --- a/modules/http_proxy_base_filters.go +++ b/modules/http_proxy_base_filters.go @@ -43,8 +43,7 @@ func (p *HTTPProxy) onRequestFilter(req *http.Request, ctx *goproxy.ProxyCtx) (* // the request has been changed by the script p.logRequestAction(req, jsreq) return jsreq.ToRequest(), nil - } - if jsres != nil { + } else if jsres != nil { // a fake response has been returned by the script p.logResponseAction(req, jsres) return req, jsres.ToResponse(req) @@ -99,8 +98,7 @@ func (p *HTTPProxy) doScriptInjection(res *http.Response, cType string) (error, raw, err := ioutil.ReadAll(res.Body) if err != nil { return err, nil - } - if html := string(raw); strings.Contains(html, "") { + } else if html := string(raw); strings.Contains(html, "") { log.Info("(%s) > injecting javascript (%d bytes) into %s (%d bytes) for %s", tui.Green(p.Name), len(p.jsHook), diff --git a/modules/http_proxy_base_sslstriper.go b/modules/http_proxy_base_sslstriper.go index 5e790a3b..77bea60f 100644 --- a/modules/http_proxy_base_sslstriper.go +++ b/modules/http_proxy_base_sslstriper.go @@ -272,9 +272,10 @@ func (s *SSLStripper) isMaxRedirs(hostname string) bool { // reset delete(s.redirs, hostname) return true + } else { + // increment + s.redirs[hostname]++ } - // increment - s.redirs[hostname]++ } else { // start tracking redirections s.redirs[hostname] = 1 diff --git a/modules/http_proxy_js_response.go b/modules/http_proxy_js_response.go index b91ed45d..0931c51c 100644 --- a/modules/http_proxy_js_response.go +++ b/modules/http_proxy_js_response.go @@ -65,12 +65,10 @@ func (j *JSResponse) WasModified() bool { if j.bodyRead { // body was read return true - } - if j.bodyClear { + } else if j.bodyClear { // body was cleared manually return true - } - if j.Body != "" { + } else if j.Body != "" { // body was not read but just set return true } diff --git a/modules/http_proxy_script.go b/modules/http_proxy_script.go index 4c082836..0a33b9e5 100644 --- a/modules/http_proxy_script.go +++ b/modules/http_proxy_script.go @@ -58,12 +58,10 @@ func (s *HttpProxyScript) OnRequest(original *http.Request) (jsreq *JSRequest, j if _, err := s.Call("onRequest", jsreq, jsres); err != nil { log.Error("%s", err) return nil, nil - } - if jsreq.WasModified() { + } else if jsreq.WasModified() { jsreq.UpdateHash() return jsreq, nil - } - if jsres.WasModified() { + } else if jsres.WasModified() { jsres.UpdateHash() return nil, jsres } @@ -91,13 +89,10 @@ func (s *HttpProxyScript) OnResponse(res *http.Response) (jsreq *JSRequest, jsre func (s *HttpProxyScript) OnCommand(cmd string) bool { if s.doOnCommand { - ret, err := s.Call("onCommand", cmd) - if err != nil { + if ret, err := s.Call("onCommand", cmd); err != nil { log.Error("Error while executing onCommand callback: %+v", err) return false - } - v, ok := ret.(bool) - if ok { + } else if v, ok := ret.(bool); ok { return v } } diff --git a/modules/https_proxy.go b/modules/https_proxy.go index 4fab774a..ee32b2a5 100644 --- a/modules/https_proxy.go +++ b/modules/https_proxy.go @@ -98,35 +98,25 @@ func (p *HttpsProxy) Configure() error { if p.Running() { return session.ErrAlreadyStarted - } - if err, address = p.StringParam("https.proxy.address"); err != nil { + } else if err, address = p.StringParam("https.proxy.address"); err != nil { return err - } - if err, proxyPort = p.IntParam("https.proxy.port"); err != nil { + } else if err, proxyPort = p.IntParam("https.proxy.port"); err != nil { return err - } - if err, httpPort = p.IntParam("https.port"); err != nil { + } else if err, httpPort = p.IntParam("https.port"); err != nil { return err - } - if err, stripSSL = p.BoolParam("https.proxy.sslstrip"); err != nil { + } else if err, stripSSL = p.BoolParam("https.proxy.sslstrip"); err != nil { return err - } - if err, certFile = p.StringParam("https.proxy.certificate"); err != nil { + } else if err, certFile = p.StringParam("https.proxy.certificate"); err != nil { return err - } - if certFile, err = fs.Expand(certFile); err != nil { + } else if certFile, err = fs.Expand(certFile); err != nil { return err - } - if err, keyFile = p.StringParam("https.proxy.key"); err != nil { + } else if err, keyFile = p.StringParam("https.proxy.key"); err != nil { return err - } - if keyFile, err = fs.Expand(keyFile); err != nil { + } else if keyFile, err = fs.Expand(keyFile); err != nil { return err - } - if err, scriptPath = p.StringParam("https.proxy.script"); err != nil { + } else if err, scriptPath = p.StringParam("https.proxy.script"); err != nil { return err - } - if err, jsToInject = p.StringParam("https.proxy.injectjs"); err != nil { + } else if err, jsToInject = p.StringParam("https.proxy.injectjs"); err != nil { return err } diff --git a/modules/mac_changer.go b/modules/mac_changer.go index 6ed6f1d5..ccab733c 100644 --- a/modules/mac_changer.go +++ b/modules/mac_changer.go @@ -68,8 +68,7 @@ func (mc *MacChanger) Configure() (err error) { if err, mc.iface = mc.StringParam("mac.changer.iface"); err != nil { return err - } - if err, changeTo = mc.StringParam("mac.changer.address"); err != nil { + } else if err, changeTo = mc.StringParam("mac.changer.address"); err != nil { return err } @@ -106,11 +105,9 @@ func (mc *MacChanger) setMac(mac net.HardwareAddr) error { func (mc *MacChanger) Start() error { if mc.Running() { return session.ErrAlreadyStarted - } - if err := mc.Configure(); err != nil { + } else if err := mc.Configure(); err != nil { return err - } - if err := mc.setMac(mc.fakeMac); err != nil { + } else if err := mc.setMac(mc.fakeMac); err != nil { return err } diff --git a/modules/mysql_server.go b/modules/mysql_server.go index a68e2271..96a34b5e 100644 --- a/modules/mysql_server.go +++ b/modules/mysql_server.go @@ -82,23 +82,17 @@ func (mysql *MySQLServer) Configure() error { if mysql.Running() { return session.ErrAlreadyStarted - } - if err, mysql.infile = mysql.StringParam("mysql.server.infile"); err != nil { + } else if err, mysql.infile = mysql.StringParam("mysql.server.infile"); err != nil { return err - } - if err, mysql.outfile = mysql.StringParam("mysql.server.outfile"); err != nil { + } else if err, mysql.outfile = mysql.StringParam("mysql.server.outfile"); err != nil { return err - } - if err, address = mysql.StringParam("mysql.server.address"); err != nil { + } else if err, address = mysql.StringParam("mysql.server.address"); err != nil { return err - } - if err, port = mysql.IntParam("mysql.server.port"); err != nil { + } else if err, port = mysql.IntParam("mysql.server.port"); err != nil { return err - } - if mysql.address, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil { + } else if mysql.address, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil { return err - } - if mysql.listener, err = net.ListenTCP("tcp", mysql.address); err != nil { + } else if mysql.listener, err = net.ListenTCP("tcp", mysql.address); err != nil { return err } return nil @@ -147,16 +141,13 @@ func (mysql *MySQLServer) Start() error { if _, err := conn.Write(packets.MySQLFirstResponseOK); err != nil { log.Warning("[%s] error while writing server first response ok: %s", tui.Green("mysql.server"), err) continue - } - if _, err := reader.Read(readBuffer); err != nil { + } else if _, err := reader.Read(readBuffer); err != nil { log.Warning("[%s] error while reading client message: %s", tui.Green("mysql.server"), err) continue - } - if _, err := conn.Write(packets.MySQLGetFile(mysql.infile)); err != nil { + } else if _, err := conn.Write(packets.MySQLGetFile(mysql.infile)); err != nil { log.Warning("[%s] error while writing server get file request: %s", tui.Green("mysql.server"), err) continue - } - if read, err = reader.Read(readBuffer); err != nil { + } else if read, err = reader.Read(readBuffer); err != nil { log.Warning("[%s] error while readind buffer: %s", tui.Green("mysql.server"), err) continue } diff --git a/modules/net_probe.go b/modules/net_probe.go index 976ccdbf..a3c5a152 100644 --- a/modules/net_probe.go +++ b/modules/net_probe.go @@ -82,20 +82,17 @@ func (p *Prober) Configure() error { var err error if err, p.throttle = p.IntParam("net.probe.throttle"); err != nil { return err - } - if err, p.probes.NBNS = p.BoolParam("net.probe.nbns"); err != nil { + } else if err, p.probes.NBNS = p.BoolParam("net.probe.nbns"); err != nil { return err - } - if err, p.probes.MDNS = p.BoolParam("net.probe.mdns"); err != nil { + } else if err, p.probes.MDNS = p.BoolParam("net.probe.mdns"); err != nil { return err - } - if err, p.probes.UPNP = p.BoolParam("net.probe.upnp"); err != nil { + } else if err, p.probes.UPNP = p.BoolParam("net.probe.upnp"); err != nil { return err - } - if err, p.probes.WSD = p.BoolParam("net.probe.wsd"); err != nil { + } else if err, p.probes.WSD = p.BoolParam("net.probe.wsd"); err != nil { return err + } else { + log.Debug("Throttling packets of %d ms.", p.throttle) } - log.Debug("Throttling packets of %d ms.", p.throttle) return nil } @@ -139,12 +136,10 @@ func (p *Prober) Start() error { for _, ip := range addresses { if !p.Running() { return - } - if p.Session.Skip(ip) { + } else if p.Session.Skip(ip) { log.Debug("skipping address %s from probing.", ip) continue - } - if p.probes.NBNS { + } else if p.probes.NBNS { p.sendProbeNBNS(from, from_hw, ip) } time.Sleep(throttle) diff --git a/modules/net_probe_mdns.go b/modules/net_probe_mdns.go index 693d4d15..14af0e2d 100644 --- a/modules/net_probe_mdns.go +++ b/modules/net_probe_mdns.go @@ -12,8 +12,7 @@ func (p *Prober) sendProbeMDNS(from net.IP, from_hw net.HardwareAddr) { if err != nil { log.Error("error while sending mdns probe: %v", err) return - } - if err := p.Session.Queue.Send(raw); err != nil { + } else if err := p.Session.Queue.Send(raw); err != nil { log.Error("error sending mdns packet: %s", err) } else { log.Debug("sent %d bytes of MDNS probe", len(raw)) diff --git a/modules/net_recon_show.go b/modules/net_recon_show.go index 89e86a2f..f44e027c 100644 --- a/modules/net_recon_show.go +++ b/modules/net_recon_show.go @@ -88,8 +88,7 @@ func (d *Discovery) getRow(e *network.Endpoint, withMeta bool) [][]string { if !withMeta { return [][]string{row} - } - if e.Meta.Empty() { + } else if e.Meta.Empty() { return [][]string{append(row, tui.Dim("-"))} } @@ -121,14 +120,13 @@ func (d *Discovery) Show(by string, expr string) (err error) { targets = d.Session.Lan.List() } - switch by { - case "seen": + if by == "seen" { sort.Sort(BySeenSorter(targets)) - case "sent": + } else if by == "sent" { sort.Sort(BySentSorter(targets)) - case "rcvd": + } else if by == "rcvd" { sort.Sort(ByRcvdSorter(targets)) - default: + } else { sort.Sort(ByAddressSorter(targets)) } @@ -141,11 +139,9 @@ func (d *Discovery) Show(by string, expr string) (err error) { } hasMeta := false - err, showMeta := d.BoolParam("net.show.meta") - if err != nil { + if err, showMeta := d.BoolParam("net.show.meta"); err != nil { return err - } - if showMeta { + } else if showMeta { for _, t := range targets { if !t.Meta.Empty() { hasMeta = true diff --git a/modules/net_sniff.go b/modules/net_sniff.go index e6c62dc3..25f59633 100644 --- a/modules/net_sniff.go +++ b/modules/net_sniff.go @@ -112,8 +112,7 @@ func (s *Sniffer) Configure() error { if s.Running() { return session.ErrAlreadyStarted - } - if err, s.Ctx = s.GetContext(); err != nil { + } else if err, s.Ctx = s.GetContext(); err != nil { if s.Ctx != nil { s.Ctx.Close() s.Ctx = nil diff --git a/modules/net_sniff_parsers.go b/modules/net_sniff_parsers.go index 402a1d77..086efc1e 100644 --- a/modules/net_sniff_parsers.go +++ b/modules/net_sniff_parsers.go @@ -17,14 +17,11 @@ func tcpParser(ip *layers.IPv4, pkt gopacket.Packet, verbose bool) { if sniParser(ip, pkt, tcp) { return - } - if ntlmParser(ip, pkt, tcp) { + } else if ntlmParser(ip, pkt, tcp) { return - } - if httpParser(ip, pkt, tcp) { + } else if httpParser(ip, pkt, tcp) { return - } - if verbose { + } else if verbose { NewSnifferEvent( pkt.Metadata().Timestamp, "tcp", @@ -49,17 +46,13 @@ func udpParser(ip *layers.IPv4, pkt gopacket.Packet, verbose bool) { if dnsParser(ip, pkt, udp) { return - } - if mdnsParser(ip, pkt, udp) { + } else if mdnsParser(ip, pkt, udp) { return - } - if krb5Parser(ip, pkt, udp) { + } else if krb5Parser(ip, pkt, udp) { return - } - if upnpParser(ip, pkt, udp) { + } else if upnpParser(ip, pkt, udp) { return - } - if verbose { + } else if verbose { NewSnifferEvent( pkt.Metadata().Timestamp, "udp", @@ -125,8 +118,7 @@ func mainParser(pkt gopacket.Packet, verbose bool) bool { unkParser(ip, pkt, verbose) } return true - } - if ok, radiotap, dot11 := packets.Dot11Parse(pkt); ok { + } else if ok, radiotap, dot11 := packets.Dot11Parse(pkt); ok { // are we sniffing in monitor mode? dot11Parser(radiotap, dot11, pkt, verbose) return true diff --git a/modules/net_sniff_views.go b/modules/net_sniff_views.go index 183cad31..2a0239df 100644 --- a/modules/net_sniff_views.go +++ b/modules/net_sniff_views.go @@ -13,8 +13,7 @@ import ( func vIP(ip net.IP) string { if session.I.Interface.IP.Equal(ip) { return tui.Dim("local") - } - if session.I.Gateway.IP.Equal(ip) { + } else if session.I.Gateway.IP.Equal(ip) { return "gateway" } diff --git a/modules/packet_proxy_linux_amd64.go b/modules/packet_proxy_linux_amd64.go index cc165c2c..c3ee0fb2 100644 --- a/modules/packet_proxy_linux_amd64.go +++ b/modules/packet_proxy_linux_amd64.go @@ -135,21 +135,17 @@ func (pp *PacketProxy) Configure() (err error) { if err, pp.queueNum = pp.IntParam("packet.proxy.queue.num"); err != nil { return - } - if err, pp.chainName = pp.StringParam("packet.proxy.chain"); err != nil { + } else if err, pp.chainName = pp.StringParam("packet.proxy.chain"); err != nil { return - } - if err, pp.rule = pp.StringParam("packet.proxy.rule"); err != nil { + } else if err, pp.rule = pp.StringParam("packet.proxy.rule"); err != nil { return - } - if err, pp.pluginPath = pp.StringParam("packet.proxy.plugin"); err != nil { + } else if err, pp.pluginPath = pp.StringParam("packet.proxy.plugin"); err != nil { return } if pp.pluginPath == "" { return fmt.Errorf("The parameter %s can not be empty.", tui.Bold("packet.proxy.plugin")) - } - if !fs.Exists(pp.pluginPath) { + } else if !fs.Exists(pp.pluginPath) { return fmt.Errorf("%s does not exist.", pp.pluginPath) } @@ -160,34 +156,26 @@ func (pp *PacketProxy) Configure() (err error) { if pp.plugin, err = plugin.Open(pp.pluginPath); err != nil { return - } - if sym, err = pp.plugin.Lookup("OnPacket"); err != nil { + } else if sym, err = pp.plugin.Lookup("OnPacket"); err != nil { return - } - if pp.queueCb, ok = sym.(func(*nfqueue.Payload) int); !ok { + } else if pp.queueCb, ok = sym.(func(*nfqueue.Payload) int); !ok { return fmt.Errorf("Symbol OnPacket is not a valid callback function.") } pp.queue = new(nfqueue.Queue) if err = pp.queue.SetCallback(dummyCallback); err != nil { return - } - if err = pp.queue.Init(); err != nil { + } else if err = pp.queue.Init(); err != nil { return - } - if err = pp.queue.Unbind(syscall.AF_INET); err != nil { + } else if err = pp.queue.Unbind(syscall.AF_INET); err != nil { return - } - if err = pp.queue.Bind(syscall.AF_INET); err != nil { + } else if err = pp.queue.Bind(syscall.AF_INET); err != nil { return - } - if err = pp.queue.CreateQueue(pp.queueNum); err != nil { + } else if err = pp.queue.CreateQueue(pp.queueNum); err != nil { return - } - if err = pp.queue.SetMode(nfqueue.NFQNL_COPY_PACKET); err != nil { + } else if err = pp.queue.SetMode(nfqueue.NFQNL_COPY_PACKET); err != nil { return - } - if err = pp.runRule(true); err != nil { + } else if err = pp.runRule(true); err != nil { return } diff --git a/modules/tcp_proxy.go b/modules/tcp_proxy.go index ece2a62e..f651fa32 100644 --- a/modules/tcp_proxy.go +++ b/modules/tcp_proxy.go @@ -97,38 +97,27 @@ func (p *TcpProxy) Configure() error { if p.Running() { return session.ErrAlreadyStarted - } - if err, address = p.StringParam("tcp.address"); err != nil { + } else if err, address = p.StringParam("tcp.address"); err != nil { return err - } - if err, proxyAddress = p.StringParam("tcp.proxy.address"); err != nil { + } else if err, proxyAddress = p.StringParam("tcp.proxy.address"); err != nil { return err - } - if err, proxyPort = p.IntParam("tcp.proxy.port"); err != nil { + } else if err, proxyPort = p.IntParam("tcp.proxy.port"); err != nil { return err - } - if err, port = p.IntParam("tcp.port"); err != nil { + } else if err, port = p.IntParam("tcp.port"); err != nil { return err - } - if err, tunnelAddress = p.StringParam("tcp.tunnel.address"); err != nil { + } else if err, tunnelAddress = p.StringParam("tcp.tunnel.address"); err != nil { return err - } - if err, tunnelPort = p.IntParam("tcp.tunnel.port"); err != nil { + } else if err, tunnelPort = p.IntParam("tcp.tunnel.port"); err != nil { return err - } - if err, scriptPath = p.StringParam("tcp.proxy.script"); err != nil { + } else if err, scriptPath = p.StringParam("tcp.proxy.script"); err != nil { return err - } - if p.localAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", proxyAddress, proxyPort)); err != nil { + } else if p.localAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", proxyAddress, proxyPort)); err != nil { return err - } - if p.remoteAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil { + } else if p.remoteAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil { return err - } - if p.tunnelAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", tunnelAddress, tunnelPort)); err != nil { + } else if p.tunnelAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", tunnelAddress, tunnelPort)); err != nil { return err - } - if p.listener, err = net.ListenTCP("tcp", p.localAddr); err != nil { + } else if p.listener, err = net.ListenTCP("tcp", p.localAddr); err != nil { return err } diff --git a/modules/ticker.go b/modules/ticker.go index 703f8478..dd7e49c7 100644 --- a/modules/ticker.go +++ b/modules/ticker.go @@ -61,11 +61,9 @@ func (t *Ticker) Configure() error { if t.Running() { return session.ErrAlreadyStarted - } - if err, commands = t.StringParam("ticker.commands"); err != nil { + } else if err, commands = t.StringParam("ticker.commands"); err != nil { return err - } - if err, period = t.IntParam("ticker.period"); err != nil { + } else if err, period = t.IntParam("ticker.period"); err != nil { return err } diff --git a/modules/wifi.go b/modules/wifi.go index 22d626c1..7facf0a4 100644 --- a/modules/wifi.go +++ b/modules/wifi.go @@ -72,9 +72,7 @@ func NewWiFiModule(s *session.Session) *WiFiModule { bssid, err := net.ParseMAC(args[0]) if err != nil { return err - } - ap, found := w.Session.WiFi.Get(bssid.String()) - if found { + } else if ap, found := w.Session.WiFi.Get(bssid.String()); found { w.ap = ap w.stickChan = ap.Channel() return nil @@ -106,8 +104,9 @@ func NewWiFiModule(s *session.Session) *WiFiModule { func(args []string) error { if err := w.parseApConfig(); err != nil { return err + } else { + return w.startAp() } - return w.startAp() })) w.AddParam(session.NewStringParameter("wifi.ap.ssid", @@ -151,11 +150,11 @@ func NewWiFiModule(s *session.Session) *WiFiModule { } } else { // No channels setted, retrieve frequencies supported by the card - frequencies, err := network.GetSupportedFrequencies(w.Session.Interface.Name()) - if err != nil { + if frequencies, err := network.GetSupportedFrequencies(w.Session.Interface.Name()); err != nil { return err + } else { + newfrequencies = frequencies } - newfrequencies = frequencies } w.frequencies = newfrequencies @@ -212,22 +211,18 @@ func (w *WiFiModule) Configure() error { if err = ihandle.SetRFMon(true); err != nil { return fmt.Errorf("Error while setting interface %s in monitor mode: %s", tui.Bold(w.Session.Interface.Name()), err) - } - if err = ihandle.SetSnapLen(65536); err != nil { + } else if err = ihandle.SetSnapLen(65536); err != nil { return err - } - if err = ihandle.SetTimeout(pcap.BlockForever); err != nil { + } else if err = ihandle.SetTimeout(pcap.BlockForever); err != nil { return err - } - if w.handle, err = ihandle.Activate(); err != nil { + } else if w.handle, err = ihandle.Activate(); err != nil { return err } } if err, w.skipBroken = w.BoolParam("wifi.skip-broken"); err != nil { return err - } - if err, hopPeriod = w.IntParam("wifi.hop.period"); err != nil { + } else if err, hopPeriod = w.IntParam("wifi.hop.period"); err != nil { return err } @@ -300,8 +295,7 @@ func (w *WiFiModule) Start() error { for packet := range w.pktSourceChan { if !w.Running() { break - } - if packet == nil { + } else if packet == nil { continue } diff --git a/modules/wifi_ap.go b/modules/wifi_ap.go index 45e8e10d..68556128 100644 --- a/modules/wifi_ap.go +++ b/modules/wifi_ap.go @@ -19,17 +19,13 @@ func (w *WiFiModule) parseApConfig() (err error) { var bssid string if err, w.apConfig.SSID = w.StringParam("wifi.ap.ssid"); err != nil { return - } - if err, bssid = w.StringParam("wifi.ap.bssid"); err != nil { + } else if err, bssid = w.StringParam("wifi.ap.bssid"); err != nil { return - } - if w.apConfig.BSSID, err = net.ParseMAC(network.NormalizeMac(bssid)); err != nil { + } else if w.apConfig.BSSID, err = net.ParseMAC(network.NormalizeMac(bssid)); err != nil { return - } - if err, w.apConfig.Channel = w.IntParam("wifi.ap.channel"); err != nil { + } else if err, w.apConfig.Channel = w.IntParam("wifi.ap.channel"); err != nil { return - } - if err, w.apConfig.Encryption = w.BoolParam("wifi.ap.encryption"); err != nil { + } else if err, w.apConfig.Encryption = w.BoolParam("wifi.ap.encryption"); err != nil { return } return @@ -39,8 +35,7 @@ func (w *WiFiModule) startAp() error { // we need channel hopping and packet injection for this if !w.Running() { return errNoRecon - } - if w.apRunning { + } else if w.apRunning { return session.ErrAlreadyStarted } diff --git a/modules/wifi_show.go b/modules/wifi_show.go index 6338077d..74783b0b 100644 --- a/modules/wifi_show.go +++ b/modules/wifi_show.go @@ -84,29 +84,30 @@ func (w *WiFiModule) getRow(station *network.Station) ([]string, bool) { recvd, seen, }, include - } - // this is ugly, but necessary in order to have this - // method handle both access point and clients - // transparently - clients := "" - if ap, found := w.Session.WiFi.Get(station.HwAddress); found { - if ap.NumClients() > 0 { - clients = strconv.Itoa(ap.NumClients()) + } else { + // this is ugly, but necessary in order to have this + // method handle both access point and clients + // transparently + clients := "" + if ap, found := w.Session.WiFi.Get(station.HwAddress); found { + if ap.NumClients() > 0 { + clients = strconv.Itoa(ap.NumClients()) + } } - } - return []string{ - fmt.Sprintf("%d dBm", station.RSSI), - bssid, - ssid, - /* station.Vendor, */ - encryption, - strconv.Itoa(station.Channel()), - clients, - sent, - recvd, - seen, - }, include + return []string{ + fmt.Sprintf("%d dBm", station.RSSI), + bssid, + ssid, + /* station.Vendor, */ + encryption, + strconv.Itoa(station.Channel()), + clients, + sent, + recvd, + seen, + }, include + } } func (w *WiFiModule) Show(by string) error { @@ -122,14 +123,14 @@ func (w *WiFiModule) Show(by string) error { } else { stations = w.Session.WiFi.Stations() } - switch by { - case "seen": + + if by == "seen" { sort.Sort(ByWiFiSeenSorter(stations)) - case "essid": + } else if by == "essid" { sort.Sort(ByEssidSorter(stations)) - case "channel": + } else if by == "channel" { sort.Sort(ByChannelSorter(stations)) - default: + } else { sort.Sort(ByRSSISorter(stations)) } diff --git a/modules/wol.go b/modules/wol.go index ab5e76c7..8476b32e 100644 --- a/modules/wol.go +++ b/modules/wol.go @@ -31,21 +31,21 @@ func NewWOL(s *session.Session) *WOL { w.AddHandler(session.NewModuleHandler("wol.eth MAC", "wol.eth(\\s.+)?", "Send a WOL as a raw ethernet packet of type 0x0847 (if no MAC is specified, ff:ff:ff:ff:ff:ff will be used).", func(args []string) error { - mac, err := parseMAC(args) - if err != nil { + if mac, err := parseMAC(args); err != nil { return err + } else { + return w.wolETH(mac) } - return w.wolETH(mac) })) w.AddHandler(session.NewModuleHandler("wol.udp MAC", "wol.udp(\\s.+)?", "Send a WOL as an IPv4 broadcast packet to UDP port 9 (if no MAC is specified, ff:ff:ff:ff:ff:ff will be used).", func(args []string) error { - mac, err := parseMAC(args) - if err != nil { + if mac, err := parseMAC(args); err != nil { return err + } else { + return w.wolUDP(mac) } - return w.wolUDP(mac) })) return w @@ -58,8 +58,9 @@ func parseMAC(args []string) (string, error) { if tmp != "" { if !reMAC.MatchString(tmp) { return "", fmt.Errorf("%s is not a valid MAC address.", tmp) + } else { + mac = tmp } - mac = tmp } } diff --git a/network/lan_endpoint.go b/network/lan_endpoint.go index a9dd299d..025995cb 100644 --- a/network/lan_endpoint.go +++ b/network/lan_endpoint.go @@ -147,11 +147,9 @@ func (t *Endpoint) String() string { if t.HwAddress == "" { return t.IpAddress - } - if t.Vendor == "" { + } else if t.Vendor == "" { return fmt.Sprintf("%s%s", ipPart, t.HwAddress) - } - if t.Hostname == "" { + } else if t.Hostname == "" { return fmt.Sprintf("%s%s ( %s )", ipPart, t.HwAddress, t.Vendor) } return fmt.Sprintf("%s%s ( %s ) - %s", ipPart, t.HwAddress, t.Vendor, tui.Bold(t.Hostname)) @@ -161,13 +159,10 @@ func (t *Endpoint) OnMeta(meta map[string]string) { host := "" for k, v := range meta { // simple heuristics to get the longest candidate name - if len(v) > len(host) { - if strings.HasSuffix(k, ":hostname") { - host = v - } - if k == "mdns:md" { - host = v - } + if strings.HasSuffix(k, ":hostname") && len(v) > len(host) { + host = v + } else if k == "mdns:md" && len(v) > len(host) { + host = v } t.Meta.Set(k, v) } diff --git a/network/net_gateway.go b/network/net_gateway.go index 931bd4c1..4b2cb268 100644 --- a/network/net_gateway.go +++ b/network/net_gateway.go @@ -31,14 +31,15 @@ func FindGateway(iface *Endpoint) (*Endpoint, error) { if gateway == iface.IpAddress { Debug("gateway is the interface") return iface, nil + } else { + // we have the address, now we need its mac + mac, err := ArpLookup(ifName, gateway, false) + if err != nil { + return nil, err + } + Debug("gateway is %s[%s]", gateway, mac) + return NewEndpoint(gateway, mac), nil } - // we have the address, now we need its mac - mac, err := ArpLookup(ifName, gateway, false) - if err != nil { - return nil, err - } - Debug("gateway is %s[%s]", gateway, mac) - return NewEndpoint(gateway, mac), nil }) } } diff --git a/network/net_linux.go b/network/net_linux.go index 302fc232..decbc022 100644 --- a/network/net_linux.go +++ b/network/net_linux.go @@ -50,8 +50,7 @@ func SetInterfaceChannel(iface string, channel int) error { out, err := core.Exec("iwconfig", []string{iface, "channel", fmt.Sprintf("%d", channel)}) if err != nil { return err - } - if out != "" { + } else if out != "" { return fmt.Errorf("Unexpected output while setting interface %s to channel %d: %s", iface, channel, out) } @@ -64,8 +63,7 @@ func processSupportedFrequencies(output string, err error) ([]int, error) { freqs := make([]int, 0) if err != nil { return freqs, err - } - if output != "" { + } else if output != "" { scanner := bufio.NewScanner(strings.NewReader(output)) for scanner.Scan() { line := scanner.Text() diff --git a/network/wifi.go b/network/wifi.go index ba1f4738..389b8960 100644 --- a/network/wifi.go +++ b/network/wifi.go @@ -10,11 +10,9 @@ import ( func Dot11Freq2Chan(freq int) int { if freq <= 2472 { return ((freq - 2412) / 5) + 1 - } - if freq == 2484 { + } else if freq == 2484 { return 14 - } - if freq >= 5035 && freq <= 5865 { + } else if freq >= 5035 && freq <= 5865 { return ((freq - 5035) / 5) + 7 } return 0 @@ -23,11 +21,9 @@ func Dot11Freq2Chan(freq int) int { func Dot11Chan2Freq(channel int) int { if channel <= 13 { return ((channel - 1) * 5) + 2412 - } - if channel == 14 { + } else if channel == 14 { return 2484 - } - if channel <= 173 { + } else if channel <= 173 { return ((channel - 7) * 5) + 5035 } diff --git a/network/wifi_station.go b/network/wifi_station.go index 2bd5848f..df734538 100644 --- a/network/wifi_station.go +++ b/network/wifi_station.go @@ -19,10 +19,11 @@ func cleanESSID(essid string) string { res := "" for _, c := range essid { - if !strconv.IsPrint(c) { + if strconv.IsPrint(c) { + res += string(c) + } else { break } - res += string(c) } return res } diff --git a/packets/dhcp6.go b/packets/dhcp6.go index 1b67e471..01056597 100644 --- a/packets/dhcp6.go +++ b/packets/dhcp6.go @@ -38,11 +38,11 @@ func DHCP6For(what dhcp6.MessageType, to dhcp6.Packet, duid []byte) (err error, } var rawCID []byte - raw, found := to.Options[dhcp6.OptionClientID] - if !found || len(raw) < 1 { + if raw, found := to.Options[dhcp6.OptionClientID]; !found || len(raw) < 1 { return ErrNoCID, p + } else { + rawCID = raw[0] } - rawCID = raw[0] p.Options.AddRaw(dhcp6.OptionClientID, rawCID) p.Options.AddRaw(dhcp6.OptionServerID, duid) diff --git a/packets/queue.go b/packets/queue.go index 5035d67a..94aef1a1 100644 --- a/packets/queue.go +++ b/packets/queue.go @@ -233,8 +233,9 @@ func (q *Queue) Send(raw []byte) error { if err := q.handle.WritePacketData(raw); err != nil { q.TrackError() return err + } else { + q.TrackSent(uint64(len(raw))) } - q.TrackSent(uint64(len(raw))) return nil } diff --git a/session/command_handler.go b/session/command_handler.go index 677238d4..e7efad17 100644 --- a/session/command_handler.go +++ b/session/command_handler.go @@ -27,6 +27,7 @@ func (h *CommandHandler) Parse(line string) (bool, []string) { result := h.Parser.FindStringSubmatch(line) if len(result) == h.Parser.NumSubexp()+1 { return true, result[1:] + } else { + return false, nil } - return false, nil } diff --git a/session/command_handler_test.go b/session/command_handler_test.go index 7b3e94fe..21a4f9bb 100644 --- a/session/command_handler_test.go +++ b/session/command_handler_test.go @@ -46,15 +46,11 @@ func TestSessionCommandHandler(t *testing.T) { shouldNotParse := "simple123" shouldParse := "simple 123" - parsed, _ := c.Parse(shouldNotParse) - if parsed { + if parsed, _ := c.Parse(shouldNotParse); parsed { t.Fatalf("should not parse '%s'", shouldNotParse) - } - parsed, parts := c.Parse(shouldParse) - if !parsed { + } else if parsed, parts := c.Parse(shouldParse); !parsed { t.Fatalf("should parse '%s'", shouldParse) - } - if !sameStrings(parts, u.parsed) { + } else if !sameStrings(parts, u.parsed) { t.Fatalf("expected '%v', got '%v'", u.parsed, parts) } } diff --git a/session/environment.go b/session/environment.go index 331e899e..7f8d48b0 100644 --- a/session/environment.go +++ b/session/environment.go @@ -112,11 +112,11 @@ func (env *Environment) Get(name string) (bool, string) { func (env *Environment) GetInt(name string) (error, int) { if found, value := env.Get(name); found { - i, err := strconv.Atoi(value) - if err != nil { + if i, err := strconv.Atoi(value); err == nil { + return nil, i + } else { return err, 0 } - return nil, i } return fmt.Errorf("Not found."), 0 diff --git a/session/environment_test.go b/session/environment_test.go index fad128a3..b3b3bb85 100644 --- a/session/environment_test.go +++ b/session/environment_test.go @@ -22,20 +22,17 @@ func setup(t testing.TB, envFile bool, envFileData bool) { teardown(t) if envFile { - fp, err := os.OpenFile(testEnvFile, os.O_RDONLY|os.O_CREATE, 0666) - if err != nil { + if fp, err := os.OpenFile(testEnvFile, os.O_RDONLY|os.O_CREATE, 0666); err == nil { + fp.Close() + } else { panic(err) } - fp.Close() } if envFileData { - raw, err := json.Marshal(testEnvData) - if err != nil { + if raw, err := json.Marshal(testEnvData); err != nil { panic(err) - } - err = ioutil.WriteFile(testEnvFile, raw, 0755) - if err != nil { + } else if err = ioutil.WriteFile(testEnvFile, raw, 0755); err != nil { panic(err) } } @@ -48,71 +45,64 @@ func teardown(t testing.TB) { } func TestSessionEnvironmentWithoutFile(t *testing.T) { - env, err := NewEnvironment("") - if err != nil { + if env, err := NewEnvironment(""); env == nil { + t.Fatal("expected valid environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if len(env.Data) != 0 { + } else if len(env.Data) != 0 { t.Fatalf("expected empty environment, found %d elements", len(env.Data)) } - t.Log("expected valid environment") } func TestSessionEnvironmentWithInvalidFile(t *testing.T) { - env, err := NewEnvironment("/idontexist") - if err != nil { + if env, err := NewEnvironment("/idontexist"); env == nil { + t.Fatal("expected valid environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if len(env.Data) != 0 { + } else if len(env.Data) != 0 { t.Fatalf("expected empty environment, found %d elements", len(env.Data)) } - t.Log("expected valid environment") } func TestSessionEnvironmentWithEmptyFile(t *testing.T) { setup(t, true, false) defer teardown(t) - env, err := NewEnvironment(testEnvFile) - if err != nil { + if env, err := NewEnvironment(testEnvFile); env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if len(env.Data) != 0 { + } else if len(env.Data) != 0 { t.Fatalf("expected empty environment, found %d elements", len(env.Data)) } - - t.Log("expected environment") } func TestSessionEnvironmentWithDataFile(t *testing.T) { setup(t, true, true) defer teardown(t) - env, err := NewEnvironment(testEnvFile) - if err != nil { + if env, err := NewEnvironment(testEnvFile); env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if len(env.Data) != len(testEnvData) { + } else if len(env.Data) != len(testEnvData) { t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) - } - if !reflect.DeepEqual(env.Data, testEnvData) { + } else if !reflect.DeepEqual(env.Data, testEnvData) { t.Fatalf("unexpected contents: %v", env.Data) } - t.Log("expected environment") } func TestSessionEnvironmentSaveWithError(t *testing.T) { setup(t, false, false) defer teardown(t) - env, err := NewEnvironment(testEnvFile) - if err != nil { + if env, err := NewEnvironment(testEnvFile); env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if err = env.Save("/lulz/nope"); err == nil { + } else if err = env.Save("/lulz/nope"); err == nil { t.Fatal("expected error") } - t.Log("expected environment") } func TestSessionEnvironmentSave(t *testing.T) { @@ -120,24 +110,24 @@ func TestSessionEnvironmentSave(t *testing.T) { defer teardown(t) env, err := NewEnvironment(testEnvFile) - if err != nil { + if env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) } - t.Log("expected environment") env.Data["new"] = "value" if err = env.Save(testEnvFile); err != nil { t.Fatalf("unexpected error: %v", err) } - env, err = NewEnvironment(testEnvFile) - if err != nil { + if env, err := NewEnvironment(testEnvFile); env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if !reflect.DeepEqual(env.Data, map[string]string{"new": "value"}) { + } else if !reflect.DeepEqual(env.Data, map[string]string{"new": "value"}) { t.Fatalf("unexpected contents: %v", env.Data) } - t.Log("expected environment") } func TestSessionEnvironmentHas(t *testing.T) { @@ -145,13 +135,13 @@ func TestSessionEnvironmentHas(t *testing.T) { defer teardown(t) env, err := NewEnvironment(testEnvFile) - if err != nil { + if env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if len(env.Data) != len(testEnvData) { + } else if len(env.Data) != len(testEnvData) { t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) } - t.Log("expected environment") for k := range testEnvData { if !env.Has(k) { @@ -171,24 +161,19 @@ func TestSessionEnvironmentSet(t *testing.T) { defer teardown(t) env, err := NewEnvironment(testEnvFile) - if err != nil { + if env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - old := env.Set("people", "ok") - if old != "shit" { + } else if old := env.Set("people", "ok"); old != "shit" { t.Fatalf("unexpected old value: %s", old) - } - if env.Data["people"] != "ok" { + } else if env.Data["people"] != "ok" { t.Fatalf("unexpected new value: %s", env.Data["people"]) - } - old = env.Set("newkey", "nk") - if old != "" { + } else if old := env.Set("newkey", "nk"); old != "" { t.Fatalf("unexpected old value: %s", old) - } - if env.Data["newkey"] != "nk" { + } else if env.Data["newkey"] != "nk" { t.Fatalf("unexpected new value: %s", env.Data["newkey"]) } - t.Log("expected environment") } func TestSessionEnvironmentSetWithCallback(t *testing.T) { @@ -196,10 +181,11 @@ func TestSessionEnvironmentSetWithCallback(t *testing.T) { defer teardown(t) env, err := NewEnvironment(testEnvFile) - if err != nil { + if env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) } - t.Log("expected environment") cbCalled := false old := env.WithCallback("people", "ok", func(newValue string) { @@ -213,8 +199,7 @@ func TestSessionEnvironmentSetWithCallback(t *testing.T) { old = env.Set("people", "shitagain") if old != "ok" { t.Fatalf("unexpected old value: %s", old) - } - if !cbCalled { + } else if !cbCalled { t.Fatal("callback has not been called") } @@ -230,27 +215,24 @@ func TestSessionEnvironmentGet(t *testing.T) { defer teardown(t) env, err := NewEnvironment(testEnvFile) - if err != nil { + if env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if len(env.Data) != len(testEnvData) { + } else if len(env.Data) != len(testEnvData) { t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) } - t.Log("expected environment") for k, v := range testEnvData { - found, vv := env.Get(k) - if !found { + if found, vv := env.Get(k); !found { t.Fatalf("should have found %s", k) - } - if v != vv { + } else if v != vv { t.Fatalf("unexpected value found: %s", vv) } } for _, k := range []string{"these", "keys", "should", "not", "be", "found"} { - found, _ := env.Get(k) - if found { + if found, _ := env.Get(k); found { t.Fatalf("should not have found %s", k) } } @@ -261,13 +243,13 @@ func TestSessionEnvironmentGetInt(t *testing.T) { defer teardown(t) env, err := NewEnvironment(testEnvFile) - if err != nil { + if env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if len(env.Data) != len(testEnvData) { + } else if len(env.Data) != len(testEnvData) { t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) } - t.Log("expected environment") for k := range testEnvData { if err, _ := env.GetInt(k); err == nil { @@ -276,11 +258,9 @@ func TestSessionEnvironmentGetInt(t *testing.T) { } env.Data["num"] = "1234" - err, i := env.GetInt("num") - if err != nil { + if err, i := env.GetInt("num"); err != nil { t.Fatalf("unexpected error: %v", err) - } - if i != 1234 { + } else if i != 1234 { t.Fatalf("unexpected integer: %d", i) } } @@ -290,14 +270,13 @@ func TestSessionEnvironmentSorted(t *testing.T) { defer teardown(t) env, err := NewEnvironment(testEnvFile) - if err != nil { + if env == nil { + t.Fatal("expected environment") + } else if err != nil { t.Fatalf("unexpected error: %v", err) - } - if len(env.Data) != len(testEnvData) { + } else if len(env.Data) != len(testEnvData) { t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) - } - if sorted := env.Sorted(); !reflect.DeepEqual(sorted, testEnvSorted) { + } else if sorted := env.Sorted(); !reflect.DeepEqual(sorted, testEnvSorted) { t.Fatalf("unexpected sorted keys: %v", sorted) } - t.Log("expected environment") } diff --git a/session/events.go b/session/events.go index 77b4c1a0..c5b1c97f 100644 --- a/session/events.go +++ b/session/events.go @@ -118,8 +118,7 @@ func (p *EventPool) Add(tag string, data interface{}) { func (p *EventPool) Log(level log.Verbosity, format string, args ...interface{}) { if level == log.DEBUG && !p.debug { return - } - if level < log.ERROR && p.silent { + } else if level < log.ERROR && p.silent { return } diff --git a/session/module.go b/session/module.go index 64d77622..f0c877bd 100644 --- a/session/module.go +++ b/session/module.go @@ -61,59 +61,60 @@ func (m *SessionModule) Param(name string) *ModuleParam { func (m SessionModule) ListParam(name string) (err error, values []string) { values = make([]string, 0) - err, list := m.StringParam(name) - if err != nil { + list := "" + if err, list = m.StringParam(name); err != nil { return - } - - parts := strings.Split(list, ",") - for _, part := range parts { - part = str.Trim(part) - if part != "" { - values = append(values, part) + } else { + parts := strings.Split(list, ",") + for _, part := range parts { + part = str.Trim(part) + if part != "" { + values = append(values, part) + } } } return } func (m SessionModule) StringParam(name string) (error, string) { - p, found := m.params[name] - if found { - err, v := p.Get(m.Session) - if err != nil { + if p, found := m.params[name]; found { + if err, v := p.Get(m.Session); err != nil { return err, "" + } else { + return nil, v.(string) } - return nil, v.(string) + } else { + return fmt.Errorf("Parameter %s does not exist.", name), "" } - return fmt.Errorf("Parameter %s does not exist.", name), "" } func (m SessionModule) IPParam(name string) (error, net.IP) { - err, v := m.StringParam(name) - if err != nil { + if err, v := m.StringParam(name); err != nil { return err, nil + } else { + return nil, net.ParseIP(v) } - return nil, net.ParseIP(v) } func (m SessionModule) IntParam(name string) (error, int) { - p, found := m.params[name] - if found { - err, v := p.Get(m.Session) - if err != nil { + if p, found := m.params[name]; found { + if err, v := p.Get(m.Session); err != nil { return err, 0 + } else { + return nil, v.(int) } - return nil, v.(int) + + } else { + return fmt.Errorf("Parameter %s does not exist.", name), 0 } - return fmt.Errorf("Parameter %s does not exist.", name), 0 } func (m SessionModule) BoolParam(name string) (error, bool) { - err, v := m.params[name].Get(m.Session) - if err != nil { + if err, v := m.params[name].Get(m.Session); err != nil { return err, false + } else { + return nil, v.(bool) } - return nil, v.(bool) } func (m *SessionModule) AddHandler(h ModuleHandler) { @@ -136,8 +137,9 @@ func (m *SessionModule) SetRunning(running bool, cb func()) error { if running == m.Running() { if m.Started { return ErrAlreadyStarted + } else { + return ErrAlreadyStopped } - return ErrAlreadyStopped } m.StatusLock.Lock() diff --git a/session/module_param.go b/session/module_param.go index e846767f..dd38fc95 100644 --- a/session/module_param.go +++ b/session/module_param.go @@ -64,19 +64,18 @@ func (p ModuleParam) Validate(value string) (error, interface{}) { } } - switch p.Type { - case STRING: + if p.Type == STRING { return nil, value - case BOOL: + } else if p.Type == BOOL { lvalue := strings.ToLower(value) if lvalue == "true" { return nil, true - } - if lvalue == "false" { + } else if lvalue == "false" { return nil, false + } else { + return fmt.Errorf("Can't typecast '%s' to boolean.", value), nil } - return fmt.Errorf("Can't typecast '%s' to boolean.", value), nil - case INT: + } else if p.Type == INT { i, err := strconv.Atoi(value) return err, i } @@ -91,14 +90,13 @@ const ParamRandomMAC = "" func (p ModuleParam) Get(s *Session) (error, interface{}) { _, v := s.Env.Get(p.Name) - switch v { - case ParamIfaceName: + if v == ParamIfaceName { v = s.Interface.Name() - case ParamIfaceAddress: + } else if v == ParamIfaceAddress { v = s.Interface.IpAddress - case ParamSubnet: + } else if v == ParamSubnet { v = s.Interface.CIDR() - case ParamRandomMAC: + } else if v == ParamRandomMAC { hw := make([]byte, 6) rand.Read(hw) v = net.HardwareAddr(hw).String() diff --git a/session/session.go b/session/session.go index 37234650..e7069171 100644 --- a/session/session.go +++ b/session/session.go @@ -119,11 +119,9 @@ func New() (*Session, error) { } if *s.Options.CpuProfile != "" { - f, err := os.Create(*s.Options.CpuProfile) - if err != nil { + if f, err := os.Create(*s.Options.CpuProfile); err != nil { return nil, err - } - if err := pprof.StartCPUProfile(f); err != nil { + } else if err := pprof.StartCPUProfile(f); err != nil { return nil, err } } @@ -279,11 +277,9 @@ func (s *Session) Start() error { func (s *Session) Skip(ip net.IP) bool { if ip.IsLoopback() { return true - } - if ip.Equal(s.Interface.IP) { + } else if ip.Equal(s.Interface.IP) { return true - } - if ip.Equal(s.Gateway.IP) { + } else if ip.Equal(s.Gateway.IP) { return true } return false @@ -328,7 +324,9 @@ func parseCapletCommand(line string) (is bool, caplet *caplets.Caplet, argv []st // check for any arguments if argc > 1 { file = str.Trim(parts[0]) - argv = parts[1:] + if argc >= 2 { + argv = parts[1:] + } } if err, cap := caplets.Load(file); err == nil { diff --git a/session/session_core_handlers.go b/session/session_core_handlers.go index 955b551e..c2317d49 100644 --- a/session/session_core_handlers.go +++ b/session/session_core_handlers.go @@ -46,9 +46,11 @@ func (s *Session) generalHelp() { pad = "%" + strconv.Itoa(maxLen) + "s" for _, m := range s.Modules { - status := tui.Red("not running") + status := "" if m.Running() { status = tui.Green("running") + } else { + status = tui.Red("not running") } fmt.Printf(" "+tui.Yellow(pad)+" > %s\n", m.Name(), status) } @@ -63,11 +65,12 @@ func (s *Session) moduleHelp(filter string) error { } fmt.Println() - status := tui.Red("not running") + status := "" if m.Running() { status = tui.Green("running") + } else { + status = tui.Red("not running") } - fmt.Printf("%s (%s): %s\n\n", tui.Yellow(m.Name()), status, tui.Dim(m.Description())) maxLen := 0 @@ -162,11 +165,12 @@ func (s *Session) exitHandler(args []string, sess *Session) error { } func (s *Session) sleepHandler(args []string, sess *Session) error { - secs, err := strconv.Atoi(args[0]) - if err == nil { + if secs, err := strconv.Atoi(args[0]); err == nil { time.Sleep(time.Duration(secs) * time.Second) + return nil + } else { + return err } - return err } func (s *Session) getHandler(args []string, sess *Session) error { @@ -273,8 +277,9 @@ func (s *Session) aliasHandler(args []string, sess *Session) error { if s.Lan.SetAliasFor(mac, alias) { return nil + } else { + return fmt.Errorf("Could not find endpoint %s", mac) } - return fmt.Errorf("Could not find endpoint %s", mac) } func (s *Session) addHandler(h CommandHandler, c *readline.PrefixCompleter) { diff --git a/session/session_parse.go b/session/session_parse.go index 9953a51f..98c43b24 100644 --- a/session/session_parse.go +++ b/session/session_parse.go @@ -74,11 +74,11 @@ func ParseCommands(line string) []string { func (s *Session) parseEnvTokens(str string) (string, error) { for _, m := range reEnvVarCapture.FindAllString(str, -1) { varName := strings.Trim(strings.Replace(m, "env.", "", -1), "{}") - found, value := s.Env.Get(varName) - if !found { + if found, value := s.Env.Get(varName); found { + str = strings.Replace(str, m, value, -1) + } else { return "", fmt.Errorf("variable '%s' is not defined", varName) } - str = strings.Replace(str, m, value, -1) } return str, nil }