From 9eeeb599571532b6bf07705684a513ef1e69a8e5 Mon Sep 17 00:00:00 2001 From: Bruce Leidl Date: Wed, 29 Jun 2016 18:48:34 +0000 Subject: [PATCH] Update to new logging library API, Warning() -> Warningf() etc... --- dbus.go | 6 +++--- dns.go | 8 ++++---- icons.go | 6 +++--- iptables.go | 6 +++--- policy.go | 12 ++++++------ prompt.go | 4 ++-- rules.go | 16 ++++++++-------- socks_server_chain_test.go | 12 ++++++------ 8 files changed, 35 insertions(+), 35 deletions(-) diff --git a/dbus.go b/dbus.go index 074edf9..99fc432 100644 --- a/dbus.go +++ b/dbus.go @@ -90,7 +90,7 @@ func newDbusServer() (*dbusServer, error) { } func (ds *dbusServer) SetEnabled(flag bool) *dbus.Error { - log.Debug("SetEnabled(%v) called", flag) + log.Debugf("SetEnabled(%v) called", flag) ds.fw.setEnabled(flag) return nil } @@ -136,7 +136,7 @@ func (ds *dbusServer) DeleteRule(id uint32) *dbus.Error { } func (ds *dbusServer) UpdateRule(rule DbusRule) *dbus.Error { - log.Debug("UpdateRule %v", rule) + log.Debugf("UpdateRule %v", rule) ds.fw.lock.Lock() r := ds.fw.rulesById[uint(rule.Id)] ds.fw.lock.Unlock() @@ -144,7 +144,7 @@ func (ds *dbusServer) UpdateRule(rule DbusRule) *dbus.Error { tmp := new(Rule) tmp.addr = noAddress if !tmp.parseTarget(rule.Target) { - log.Warning("Unable to parse target: %s", rule.Target) + log.Warningf("Unable to parse target: %s", rule.Target) return nil } r.policy.lock.Lock() diff --git a/dns.go b/dns.go index fb6664f..57675d1 100644 --- a/dns.go +++ b/dns.go @@ -31,7 +31,7 @@ func (dc *dnsCache) processDNS(pkt *nfqueue.Packet) { return } if len(dns.question) != 1 { - log.Warning("Length of DNS Question section is not 1 as expected: %d", len(dns.question)) + log.Warningf("Length of DNS Question section is not 1 as expected: %d", len(dns.question)) return } q := dns.question[0] @@ -39,7 +39,7 @@ func (dc *dnsCache) processDNS(pkt *nfqueue.Packet) { dc.processRecordA(q.Name, dns.answer) return } - log.Info("Unhandled DNS message: %v", dns) + log.Infof("Unhandled DNS message: %v", dns) } @@ -55,10 +55,10 @@ func (dc *dnsCache) processRecordA(name string, answers []dnsRR) { } dc.ipMap[ip] = name if !logRedact { - log.Info("Adding %s: %s", name, ip) + log.Infof("Adding %s: %s", name, ip) } default: - log.Warning("Unexpected RR type in answer section of A response: %v", rec) + log.Warningf("Unexpected RR type in answer section of A response: %v", rec) } } } diff --git a/icons.go b/icons.go index 7e3db50..55a0fdc 100644 --- a/icons.go +++ b/icons.go @@ -34,12 +34,12 @@ func initIcons() { path := "/usr/share/applications" dir, err := os.Open(path) if err != nil { - log.Warning("Failed to open %s for reading: %v", path, err) + log.Warningf("Failed to open %s for reading: %v", path, err) return } names, err := dir.Readdirnames(0) if err != nil { - log.Warning("Could not read directory %s: %v", path, err) + log.Warningf("Could not read directory %s: %v", path, err) return } for _, n := range names { @@ -53,7 +53,7 @@ func initIcons() { func loadDesktopFile(path string) { bs, err := ioutil.ReadFile(path) if err != nil { - log.Warning("Error reading %s: %v", path, err) + log.Warningf("Error reading %s: %v", path, err) return } exec := "" diff --git a/iptables.go b/iptables.go index 2a4e2d0..438ad76 100644 --- a/iptables.go +++ b/iptables.go @@ -18,9 +18,9 @@ func setupIPTables() { func addIPTRules(rules ...string) { for _, r := range rules { if iptables('C', r) { - log.Info("IPTables rule already present: %s", r) + log.Infof("IPTables rule already present: %s", r) } else { - log.Info("Installing IPTables rule: %s", r) + log.Infof("Installing IPTables rule: %s", r) iptables('I', r) } } @@ -38,7 +38,7 @@ func iptables(verb rune, rule string) bool { _, err = cmd.CombinedOutput() _, exitErr := err.(*exec.ExitError) if err != nil && !exitErr { - log.Warning("Error running iptables: %v", err) + log.Warningf("Error running iptables: %v", err) } return !exitErr } diff --git a/policy.go b/policy.go index 6ad7898..1ea7b95 100644 --- a/policy.go +++ b/policy.go @@ -99,7 +99,7 @@ func (p *Policy) processPacket(pkt *nfqueue.Packet, pinfo *procsnitch.Info) { defer p.lock.Unlock() name := p.fw.dns.Lookup(pkt.Dst) if !logRedact { - log.Info("Lookup(%s): %s", pkt.Dst.String(), name) + log.Infof("Lookup(%s): %s", pkt.Dst.String(), name) } result := p.rules.filterPacket(pkt, pinfo, name) switch result { @@ -111,7 +111,7 @@ func (p *Policy) processPacket(pkt *nfqueue.Packet, pinfo *procsnitch.Info) { case FILTER_PROMPT: p.processPromptResult(&pendingPkt{pol: p, name: name, pkt: pkt, pinfo: pinfo}) default: - log.Warning("Unexpected filter result: %d", result) + log.Warningf("Unexpected filter result: %d", result) } } @@ -195,7 +195,7 @@ func (p *Policy) filterPending(rule *Rule) { remaining := []pendingConnection{} for _, pc := range p.pendingQueue { if rule.match(pc.dst(), pc.dstPort(), pc.hostname()) { - log.Info("Also applying %s to %s", rule.getString(logRedact), pc.print()) + log.Infof("Also applying %s to %s", rule.getString(logRedact), pc.print()) if rule.rtype == RULE_ALLOW { pc.accept() } else { @@ -249,11 +249,11 @@ func (fw *Firewall) filterPacket(pkt *nfqueue.Packet) { } pinfo := findProcessForPacket(pkt) if pinfo == nil { - log.Warning("No proc found for %s", printPacket(pkt, fw.dns.Lookup(pkt.Dst))) + log.Warningf("No proc found for %s", printPacket(pkt, fw.dns.Lookup(pkt.Dst))) pkt.Accept() return } - log.Debug("filterPacket [%s] %s", pinfo.ExePath, printPacket(pkt, fw.dns.Lookup(pkt.Dst))) + log.Debugf("filterPacket [%s] %s", pinfo.ExePath, printPacket(pkt, fw.dns.Lookup(pkt.Dst))) if basicAllowPacket(pkt) { pkt.Accept() return @@ -269,7 +269,7 @@ func findProcessForPacket(pkt *nfqueue.Packet) *procsnitch.Info { case nfqueue.UDP: return procsnitch.LookupUDPSocketProcess(pkt.SrcPort) default: - log.Warning("Packet has unknown protocol: %d", pkt.Protocol) + log.Warningf("Packet has unknown protocol: %d", pkt.Protocol) return nil } } diff --git a/prompt.go b/prompt.go index d0bafdd..4f556a1 100644 --- a/prompt.go +++ b/prompt.go @@ -97,7 +97,7 @@ func (p *prompter) processConnection(pc pendingConnection) { int32(pc.procInfo().Pid)) err := call.Store(&scope, &rule) if err != nil { - log.Warning("Error sending dbus RequestPrompt message: %v", err) + log.Warningf("Error sending dbus RequestPrompt message: %v", err) policy.removePending(pc) pc.drop() return @@ -105,7 +105,7 @@ func (p *prompter) processConnection(pc pendingConnection) { r, err := policy.parseRule(rule, false) if err != nil { - log.Warning("Error parsing rule string returned from dbus RequestPrompt: %v", err) + log.Warningf("Error parsing rule string returned from dbus RequestPrompt: %v", err) policy.removePending(pc) pc.drop() return diff --git a/rules.go b/rules.go index c1cc9d7..b76f470 100644 --- a/rules.go +++ b/rules.go @@ -106,7 +106,7 @@ func (rl *RuleList) filter(dst net.IP, dstPort uint16, hostname string, pinfo *p if logRedact { dstStr = "[redacted]" } - log.Info("%s (%s -> %s:%d)", r.getString(logRedact), pinfo.ExePath, dstStr, dstPort) + log.Infof("%s (%s -> %s:%d)", r.getString(logRedact), pinfo.ExePath, dstStr, dstPort) if r.rtype == RULE_DENY { return FILTER_DENY } else if r.rtype == RULE_ALLOW { @@ -205,12 +205,12 @@ func (fw *Firewall) saveRules() { p, err := rulesPath() if err != nil { - log.Warning("Failed to open %s for writing: %v", p, err) + log.Warningf("Failed to open %s for writing: %v", p, err) return } f, err := os.Create(p) if err != nil { - log.Warning("Failed to open %s for writing: %v", p, err) + log.Warningf("Failed to open %s for writing: %v", p, err) return } defer f.Close() @@ -242,7 +242,7 @@ func savePolicy(f *os.File, p *Policy) { func writeLine(f *os.File, line string) bool { _, err := f.WriteString(line + "\n") if err != nil { - log.Warning("Error writing to rule file: %v", err) + log.Warningf("Error writing to rule file: %v", err) return false } return true @@ -256,13 +256,13 @@ func (fw *Firewall) loadRules() { p, err := rulesPath() if err != nil { - log.Warning("Failed to open %s for reading: %v", p, err) + log.Warningf("Failed to open %s for reading: %v", p, err) return } bs, err := ioutil.ReadFile(p) if err != nil { if !os.IsNotExist(err) { - log.Warning("Failed to open %s for reading: %v", p, err) + log.Warningf("Failed to open %s for reading: %v", p, err) } return } @@ -287,12 +287,12 @@ func (fw *Firewall) processPathLine(line string) *Policy { func processRuleLine(policy *Policy, line string) { if policy == nil { - log.Warning("Cannot process rule line without first seeing path line: %s", line) + log.Warningf("Cannot process rule line without first seeing path line: %s", line) return } _, err := policy.parseRule(line, true) if err != nil { - log.Warning("Error parsing rule (%s): %v", line, err) + log.Warningf("Error parsing rule (%s): %v", line, err) return } } diff --git a/socks_server_chain_test.go b/socks_server_chain_test.go index 4fc71be..05ae9b1 100644 --- a/socks_server_chain_test.go +++ b/socks_server_chain_test.go @@ -43,7 +43,7 @@ func NewMortalService(network, address string, connectionCallback func(net.Conn) // Stop will kill our listener and all it's connections func (l *MortalService) Stop() { - log.Info("stopping listener service %s:%s", l.network, l.address) + log.Infof("stopping listener service %s:%s", l.network, l.address) close(l.quit) if l.listener != nil { l.listener.Close() @@ -54,10 +54,10 @@ func (l *MortalService) Stop() { func (l *MortalService) acceptLoop() { defer l.waitGroup.Done() defer func() { - log.Info("stoping listener service %s:%s", l.network, l.address) + log.Infof("stoping listener service %s:%s", l.network, l.address) for i, conn := range l.conns { if conn != nil { - log.Info("Closing connection #%d", i) + log.Infof("Closing connection #%d", i) conn.Close() } } @@ -70,7 +70,7 @@ func (l *MortalService) acceptLoop() { if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() { continue } else { - log.Info("MortalService connection accept failure: %s\n", err) + log.Infof("MortalService connection accept failure: %s\n", err) select { case <-l.quit: return @@ -130,12 +130,12 @@ func (l *MortalService) Start() error { func (l *MortalService) handleConnection(conn net.Conn, id int) error { defer func() { - log.Info("Closing connection #%d", id) + log.Infof("Closing connection #%d", id) conn.Close() l.conns[id] = nil }() - log.Info("Starting connection #%d", id) + log.Infof("Starting connection #%d", id) for { if err := l.connectionCallback(conn); err != nil {