Ignore many errors

github.com/securego/gosec/cmd/gosec utility used.

diff --git a/src/call.go b/src/call.go
index 339549825004f97da322b5cd00a3d44eb6c0fb07..65d7d5f0a535f0447f19d62483f5cb41f8af5ae1 100644 (file)
--- a/src/call.go
+++ b/src/call.go
@@ -84,11 +84,11 @@ func (ctx *Ctx) CallNode(
                                "txspeed":  state.TxSpeed,
                        }, "")
                        isGood = true
-                       conn.Close()
+                       conn.Close() // #nosec G104
                        break
                } else {
                        ctx.LogE("call-start", sds, err, "")
-                       conn.Close()
+                       conn.Close() // #nosec G104
                }
        }
        return

diff --git a/src/cfg.go b/src/cfg.go
index dabb510a9a3e552b6cf646ce42e5aef9d868c5ac..df26f1e3c775f5526a1c30ef02c5ebc1eca1e5a4 100644 (file)
--- a/src/cfg.go
+++ b/src/cfg.go
@@ -376,12 +376,12 @@ func NewNodeOur(cfg *NodeOurJSON) (*NodeOur, error) {
 func CfgParse(data []byte) (*Ctx, error) {
        var err error
        if bytes.Compare(data[:8], MagicNNCPBv3[:]) == 0 {
-               os.Stderr.WriteString("Passphrase:")
+               os.Stderr.WriteString("Passphrase:") // #nosec G104
                password, err := terminal.ReadPassword(0)
                if err != nil {
                        log.Fatalln(err)
                }
-               os.Stderr.WriteString("\n")
+               os.Stderr.WriteString("\n") // #nosec G104
                data, err = DeEBlob(data, password)
                if err != nil {
                        return nil, err

diff --git a/src/check.go b/src/check.go
index 9bdc2864051ccd88537c622bba0520265000f13e..824f0c706558a5c4f0f8c81c2c63205a1a7a73d9 100644 (file)
--- a/src/check.go
+++ b/src/check.go
@@ -48,7 +48,7 @@ func (ctx *Ctx) checkXxIsBad(nodeId *NodeId, xx TRxTx) bool {
                        "fullsize": job.Size,
                }
                gut, err := Check(job.Fd, job.HshValue[:], sds, ctx.ShowPrgrs)
-               job.Fd.Close()
+               job.Fd.Close() // #nosec G104
                if err != nil {
                        ctx.LogE("check", sds, err, "")
                        return true

diff --git a/src/cmd/nncp-bundle/main.go b/src/cmd/nncp-bundle/main.go
index c3613bd7d9d32a1fafe5782c602c9846c17f5afc..1cfdd45088ff9df995b653119030c764429eac8b 100644 (file)
--- a/src/cmd/nncp-bundle/main.go
+++ b/src/cmd/nncp-bundle/main.go
@@ -127,7 +127,7 @@ func main() {
                                sds["pkt"] = pktName
                                if job.PktEnc.Nice > nice {
                                        ctx.LogD("nncp-bundle", sds, "too nice")
-                                       job.Fd.Close()
+                                       job.Fd.Close() // #nosec G104
                                        continue
                                }
                                if err = tarWr.WriteHeader(&tar.Header{
@@ -162,7 +162,7 @@ func main() {
                                ); err != nil {
                                        log.Fatalln("Error during copying to tar:", err)
                                }
-                               job.Fd.Close()
+                               job.Fd.Close() // #nosec G104
                                if err = tarWr.Flush(); err != nil {
                                        log.Fatalln("Error during tar flushing:", err)
                                }
@@ -194,11 +194,13 @@ func main() {
                                if err == io.EOF {
                                        break
                                }
-                               bufStdin.Discard(bufStdin.Buffered() - (len(nncp.NNCPBundlePrefix) - 1))
+                               bufStdin.Discard(bufStdin.Buffered() - (len(nncp.NNCPBundlePrefix) - 1)) // #nosec G104
                                continue
                        }
-                       bufStdin.Discard(prefixIdx)
-                       tarR = tar.NewReader(bufStdin)
+                       if _, err = bufStdin.Discard(prefixIdx); err != nil {
+                               panic(err)
+                       }
+                       tarR := tar.NewReader(bufStdin)
                        sds["xx"] = string(nncp.TRx)
                        entry, err := tarR.Next()
                        if err != nil {
@@ -294,7 +296,7 @@ func main() {
                                if nncp.Base32Codec.EncodeToString(hsh.Sum(nil)) == pktName {
                                        ctx.LogI("nncp-bundle", sds, "removed")
                                        if !*dryRun {
-                                               os.Remove(dstPath)
+                                               os.Remove(dstPath) // #nosec G104
                                        }
                                } else {
                                        ctx.LogE("nncp-bundle", sds, errors.New("bad checksum"), "")
@@ -387,7 +389,9 @@ func main() {
                                        if err = tmp.Sync(); err != nil {
                                                log.Fatalln("Error during syncing:", err)
                                        }
-                                       tmp.Close()
+                                       if err = tmp.Close(); err != nil {
+                                               log.Fatalln("Error during closing:", err)
+                                       }
                                        if err = os.MkdirAll(selfPath, os.FileMode(0777)); err != nil {
                                                log.Fatalln("Error during mkdir:", err)
                                        }

diff --git a/src/cmd/nncp-cfgenc/main.go b/src/cmd/nncp-cfgenc/main.go
index 7cedca0d94204e5cf41ddf4cd7214485d3b2bbc2..036a4c8e967d304a28a58820cc44c2cc8c6624df 100644 (file)
--- a/src/cmd/nncp-cfgenc/main.go
+++ b/src/cmd/nncp-cfgenc/main.go
@@ -86,40 +86,42 @@ func main() {
                fmt.Printf("Number of rounds: %d\n", eblob.TCost)
                fmt.Printf("Number of parallel jobs: %d\n", eblob.PCost)
                fmt.Printf("Blob size: %d\n", len(eblob.Blob))
-               os.Exit(0)
+               return
+       }
+
+       os.Stderr.WriteString("Passphrase:") // #nosec G104
+       password, err := terminal.ReadPassword(0)
+       if err != nil {
+               log.Fatalln(err)
        }
+       os.Stderr.WriteString("\n") // #nosec G104
+
        if *decrypt {
-               os.Stderr.WriteString("Passphrase:")
-               password, err := terminal.ReadPassword(0)
-               if err != nil {
-                       log.Fatalln(err)
-               }
-               os.Stderr.WriteString("\n")
                cfgRaw, err := nncp.DeEBlob(data, password)
                if err != nil {
                        log.Fatalln(err)
                }
-               os.Stdout.Write(cfgRaw)
-       } else {
-               os.Stderr.WriteString("Passphrase:")
-               password1, err := terminal.ReadPassword(0)
-               if err != nil {
-                       log.Fatalln(err)
-               }
-               os.Stderr.WriteString("\n")
-               os.Stderr.WriteString("Repeat passphrase:")
-               password2, err := terminal.ReadPassword(0)
-               if err != nil {
-                       log.Fatalln(err)
-               }
-               os.Stderr.WriteString("\n")
-               if bytes.Compare(password1, password2) != 0 {
-                       log.Fatalln(errors.New("Passphrases do not match"))
-               }
-               eblob, err := nncp.NewEBlob(*sOpt, *tOpt, *pOpt, password1, data)
-               if err != nil {
-                       log.Fatalln(err)
-               }
-               os.Stdout.Write(eblob)
+               os.Stdout.Write(cfgRaw) // #nosec G104
+               return
+       }
+
+       password1, err := terminal.ReadPassword(0)
+       if err != nil {
+               log.Fatalln(err)
+       }
+       os.Stderr.WriteString("\n")                 // #nosec G104
+       os.Stderr.WriteString("Repeat passphrase:") // #nosec G104
+       password2, err := terminal.ReadPassword(0)
+       if err != nil {
+               log.Fatalln(err)
+       }
+       os.Stderr.WriteString("\n") // #nosec G104
+       if bytes.Compare(password1, password2) != 0 {
+               log.Fatalln(errors.New("Passphrases do not match"))
+       }
+       eblob, err := nncp.NewEBlob(*sOpt, *tOpt, *pOpt, password1, data)
+       if err != nil {
+               log.Fatalln(err)
        }
+       os.Stdout.Write(eblob) // #nosec G104
 }

diff --git a/src/cmd/nncp-daemon/main.go b/src/cmd/nncp-daemon/main.go
index 2d52fcf418a48ecac5cf8955c670d159592cc687..9d614f7edcf2fe791857c61fb25049fbddf17164 100644 (file)
--- a/src/cmd/nncp-daemon/main.go
+++ b/src/cmd/nncp-daemon/main.go
@@ -60,7 +60,7 @@ func (c InetdConn) SetWriteDeadline(t time.Time) error {
 
 func (c InetdConn) Close() error {
        if err := c.r.Close(); err != nil {
-               c.w.Close()
+               c.w.Close() // #nosec G104
                return err
        }
        return c.w.Close()
@@ -140,10 +140,10 @@ func main() {
        ctx.Umask()
 
        if *inetd {
-               os.Stderr.Close()
+               os.Stderr.Close() // #nosec G104
                conn := &InetdConn{os.Stdin, os.Stdout}
                performSP(ctx, conn, nice)
-               conn.Close()
+               conn.Close() // #nosec G104
                return
        }
 
@@ -160,7 +160,7 @@ func main() {
                ctx.LogD("daemon", nncp.SDS{"addr": conn.RemoteAddr()}, "accepted")
                go func(conn net.Conn) {
                        performSP(ctx, conn, nice)
-                       conn.Close()
+                       conn.Close() // #nosec G104
                }(conn)
        }
 }

diff --git a/src/cmd/nncp-reass/main.go b/src/cmd/nncp-reass/main.go
index f39d5ace3475a3af79600fca91bcd0fd3fd34d46..8e1ba0b9e1166e9a247617df6aa6921ae3773e8f 100644 (file)
--- a/src/cmd/nncp-reass/main.go
+++ b/src/cmd/nncp-reass/main.go
@@ -61,7 +61,7 @@ func process(ctx *nncp.Ctx, path string, keep, dryRun, stdout, dumpMeta bool) bo
                ctx.LogE("nncp-reass", nncp.SDS{"path": path}, err, "bad meta file")
                return false
        }
-       fd.Close()
+       fd.Close() // #nosec G104
        if metaPkt.Magic != nncp.MagicNNCPMv1 {
                ctx.LogE("nncp-reass", nncp.SDS{"path": path}, nncp.BadMagic, "")
                return false
@@ -154,7 +154,7 @@ func process(ctx *nncp.Ctx, path string, keep, dryRun, stdout, dumpMeta bool) bo
                ); err != nil {
                        log.Fatalln(err)
                }
-               fd.Close()
+               fd.Close() // #nosec G104
                if bytes.Compare(hsh.Sum(nil), metaPkt.Checksums[chunkNum][:]) != 0 {
                        ctx.LogE(
                                "nncp-reass",
@@ -209,7 +209,7 @@ func process(ctx *nncp.Ctx, path string, keep, dryRun, stdout, dumpMeta bool) bo
                ); err != nil {
                        log.Fatalln(err)
                }
-               fd.Close()
+               fd.Close() // #nosec G104
                if !keep {
                        if err = os.Remove(chunkPath); err != nil {
                                ctx.LogE("nncp-reass", nncp.SdsAdd(sds, nncp.SDS{"chunk": chunkNum}), err, "")
@@ -224,7 +224,9 @@ func process(ctx *nncp.Ctx, path string, keep, dryRun, stdout, dumpMeta bool) bo
                if err = tmp.Sync(); err != nil {
                        log.Fatalln("Can not sync:", err)
                }
-               tmp.Close()
+               if err = tmp.Close(); err != nil {
+                       log.Fatalln("Can not close:", err)
+               }
        }
        ctx.LogD("nncp-reass", sds, "written")
        if !keep {
@@ -269,7 +271,7 @@ func findMetas(ctx *nncp.Ctx, dirPath string) []string {
                return nil
        }
        fis, err := dir.Readdir(0)
-       dir.Close()
+       dir.Close() // #nosec G104
        if err != nil {
                ctx.LogE("nncp-reass", nncp.SDS{"path": dirPath}, err, "")
                return nil

diff --git a/src/cmd/nncp-stat/main.go b/src/cmd/nncp-stat/main.go
index d80999595411b14abd6790412636174f0c5142b6..fa33d4c40c98deafb6611e096ee98d7548a7bf8a 100644 (file)
--- a/src/cmd/nncp-stat/main.go
+++ b/src/cmd/nncp-stat/main.go
@@ -99,7 +99,7 @@ func main() {
                rxNums := make(map[uint8]int)
                rxBytes := make(map[uint8]int64)
                for job := range ctx.Jobs(node.Id, nncp.TRx) {
-                       job.Fd.Close()
+                       job.Fd.Close() // #nosec G104
                        if *showPkt {
                                jobPrint(nncp.TRx, job)
                        }
@@ -109,7 +109,7 @@ func main() {
                txNums := make(map[uint8]int)
                txBytes := make(map[uint8]int64)
                for job := range ctx.Jobs(node.Id, nncp.TTx) {
-                       job.Fd.Close()
+                       job.Fd.Close() // #nosec G104
                        if *showPkt {
                                jobPrint(nncp.TRx, job)
                        }

diff --git a/src/cmd/nncp-xfer/main.go b/src/cmd/nncp-xfer/main.go
index 1a2351d4ed92526bd01c61eba8f58fad9efcc79a..77cd9c6d86349ca6cc40ac3d6b578a0b5f8ead5c 100644 (file)
--- a/src/cmd/nncp-xfer/main.go
+++ b/src/cmd/nncp-xfer/main.go
@@ -128,7 +128,7 @@ func main() {
                goto Tx
        }
        fis, err = dir.Readdir(0)
-       dir.Close()
+       dir.Close() // #nosec G104
        if err != nil {
                ctx.LogE("nncp-xfer", sds, err, "read")
                isBad = true
@@ -159,7 +159,7 @@ func main() {
                        continue
                }
                fisInt, err := dir.Readdir(0)
-               dir.Close()
+               dir.Close() // #nosec G104
                if err != nil {
                        ctx.LogE("nncp-xfer", sds, err, "read")
                        isBad = true
@@ -186,21 +186,23 @@ func main() {
                        _, err = xdr.Unmarshal(fd, &pktEnc)
                        if err != nil || pktEnc.Magic != nncp.MagicNNCPEv4 {
                                ctx.LogD("nncp-xfer", sds, "is not a packet")
-                               fd.Close()
+                               fd.Close() // #nosec G104
                                continue
                        }
                        if pktEnc.Nice > nice {
                                ctx.LogD("nncp-xfer", sds, "too nice")
-                               fd.Close()
+                               fd.Close() // #nosec G104
                                continue
                        }
                        sds["size"] = fiInt.Size()
                        if !ctx.IsEnoughSpace(fiInt.Size()) {
                                ctx.LogE("nncp-xfer", sds, errors.New("is not enough space"), "")
-                               fd.Close()
+                               fd.Close() // #nosec G104
                                continue
                        }
-                       fd.Seek(0, 0)
+                       if _, err = fd.Seek(0, 0); err != nil {
+                               log.Fatalln(err)
+                       }
                        tmp, err := ctx.NewTmpFileWHash()
                        if err != nil {
                                log.Fatalln(err)
@@ -209,11 +211,12 @@ func main() {
                        go func() {
                                _, err := io.CopyN(w, bufio.NewReader(fd), fiInt.Size())
                                if err == nil {
-                                       w.Close()
-                                       return
+                                       err = w.Close()
+                               }
+                               if err != nil {
+                                       ctx.LogE("nncp-xfer", sds, err, "copy")
+                                       w.CloseWithError(err) // #nosec G104
                                }
-                               ctx.LogE("nncp-xfer", sds, err, "copy")
-                               w.CloseWithError(err)
                        }()
                        if _, err = nncp.CopyProgressed(
                                tmp.W, r, "Rx",
@@ -226,7 +229,7 @@ func main() {
                                ctx.LogE("nncp-xfer", sds, err, "copy")
                                isBad = true
                        }
-                       fd.Close()
+                       fd.Close() // #nosec G104
                        if isBad {
                                tmp.Cancel()
                                continue
@@ -313,23 +316,23 @@ Tx:
                        sds["pkt"] = pktName
                        if job.PktEnc.Nice > nice {
                                ctx.LogD("nncp-xfer", sds, "too nice")
-                               job.Fd.Close()
+                               job.Fd.Close() // #nosec G104
                                continue
                        }
                        if _, err = os.Stat(filepath.Join(dstPath, pktName)); err == nil || !os.IsNotExist(err) {
                                ctx.LogD("nncp-xfer", sds, "already exists")
-                               job.Fd.Close()
+                               job.Fd.Close() // #nosec G104
                                continue
                        }
                        if _, err = os.Stat(filepath.Join(dstPath, pktName+nncp.SeenSuffix)); err == nil || !os.IsNotExist(err) {
                                ctx.LogD("nncp-xfer", sds, "already exists")
-                               job.Fd.Close()
+                               job.Fd.Close() // #nosec G104
                                continue
                        }
                        tmp, err := nncp.TempFile(dstPath, "xfer")
                        if err != nil {
                                ctx.LogE("nncp-xfer", sds, err, "mktemp")
-                               job.Fd.Close()
+                               job.Fd.Close() // #nosec G104
                                isBad = true
                                break
                        }
@@ -341,26 +344,28 @@ Tx:
                                nncp.SdsAdd(sds, nncp.SDS{"fullsize": job.Size}),
                                ctx.ShowPrgrs,
                        )
-                       job.Fd.Close()
+                       job.Fd.Close() // #nosec G104
                        if err != nil {
                                ctx.LogE("nncp-xfer", sds, err, "copy")
-                               tmp.Close()
+                               tmp.Close() // #nosec G104
                                isBad = true
                                continue
                        }
                        if err = bufW.Flush(); err != nil {
-                               tmp.Close()
+                               tmp.Close() // #nosec G104
                                ctx.LogE("nncp-xfer", sds, err, "flush")
                                isBad = true
                                continue
                        }
                        if err = tmp.Sync(); err != nil {
-                               tmp.Close()
+                               tmp.Close() // #nosec G104
                                ctx.LogE("nncp-xfer", sds, err, "sync")
                                isBad = true
                                continue
                        }
-                       tmp.Close()
+                       if err = tmp.Close(); err != nil {
+                               ctx.LogE("nncp-xfer", sds, err, "sync")
+                       }
                        if err = os.Rename(tmp.Name(), filepath.Join(dstPath, pktName)); err != nil {
                                ctx.LogE("nncp-xfer", sds, err, "rename")
                                isBad = true
@@ -371,7 +376,7 @@ Tx:
                                isBad = true
                                continue
                        }
-                       os.Remove(filepath.Join(dstPath, pktName+".part"))
+                       os.Remove(filepath.Join(dstPath, pktName+".part")) // #nosec G104
                        delete(sds, "tmp")
                        ctx.LogI("nncp-xfer", nncp.SdsAdd(sds, nncp.SDS{"size": copied}), "")
                        if !*keep {

diff --git a/src/ctx.go b/src/ctx.go
index c1625a1dc5642e8a6427fec5b8bc6a9a60066af2..91969302a2ab101edb045390fbac20e0ee93da5a 100644 (file)
--- a/src/ctx.go
+++ b/src/ctx.go
@@ -73,8 +73,7 @@ func (ctx *Ctx) ensureRxDir(nodeId *NodeId) error {
                ctx.LogE("dir-ensure", SDS{"dir": dirPath}, err, "")
                return err
        }
-       fd.Close()
-       return nil
+       return fd.Close()
 }
 
 func CtxFromCmdline(

diff --git a/src/jobs.go b/src/jobs.go
index bbc9946b38166b97fbe28bbf31bd6c27d887d2a7..d7363ed6565e9d5decb417c339130be06da65b84 100644 (file)
--- a/src/jobs.go
+++ b/src/jobs.go
@@ -49,7 +49,7 @@ func (ctx *Ctx) Jobs(nodeId *NodeId, xx TRxTx) chan Job {
                        return
                }
                fis, err := dir.Readdir(0)
-               dir.Close()
+               dir.Close() // #nosec G104
                if err != nil {
                        return
                }
@@ -64,10 +64,13 @@ func (ctx *Ctx) Jobs(nodeId *NodeId, xx TRxTx) chan Job {
                        }
                        var pktEnc PktEnc
                        if _, err = xdr.Unmarshal(fd, &pktEnc); err != nil || pktEnc.Magic != MagicNNCPEv4 {
-                               fd.Close()
+                               fd.Close() // #nosec G104
+                               continue
+                       }
+                       if _, err = fd.Seek(0, io.SeekStart); err != nil {
+                               fd.Close() // #nosec G104
                                continue
                        }
-                       fd.Seek(0, io.SeekStart)
                        ctx.LogD("jobs", SDS{
                                "xx":   string(xx),
                                "node": pktEnc.Sender,

diff --git a/src/lockdir.go b/src/lockdir.go
index f87e6c6afbf67dd132d992b9eb144c1ea4fc8e17..38144eea6f5b8d73164dfc05388dd8841390446b 100644 (file)
--- a/src/lockdir.go
+++ b/src/lockdir.go
@@ -39,7 +39,7 @@ func (ctx *Ctx) LockDir(nodeId *NodeId, lockCtx string) (*os.File, error) {
        err = unix.Flock(int(dirLock.Fd()), unix.LOCK_EX|unix.LOCK_NB)
        if err != nil {
                ctx.LogE("lockdir", SDS{"path": lockPath}, err, "")
-               dirLock.Close()
+               dirLock.Close() // #nosec G104
                return nil, err
        }
        return dirLock, nil
@@ -47,7 +47,7 @@ func (ctx *Ctx) LockDir(nodeId *NodeId, lockCtx string) (*os.File, error) {
 
 func (ctx *Ctx) UnlockDir(fd *os.File) {
        if fd != nil {
-               unix.Flock(int(fd.Fd()), unix.LOCK_UN)
-               fd.Close()
+               unix.Flock(int(fd.Fd()), unix.LOCK_UN) // #nosec G104
+               fd.Close() // #nosec G104
        }
 }

diff --git a/src/log.go b/src/log.go
index a5bef48b9d5d7765da62213eb45c313b78b3e633..dfa2a4c6e0c5780501fd7422c62e1a2eb342c82b 100644 (file)
--- a/src/log.go
+++ b/src/log.go
@@ -91,8 +91,8 @@ func (ctx *Ctx) Log(msg string) {
                fmt.Fprintln(os.Stderr, "Can not open log:", err)
                return
        }
-       fd.WriteString(msg)
-       fd.Close()
+       fd.WriteString(msg) // #nosec G104
+       fd.Close()          // #nosec G104
 }
 
 func (ctx *Ctx) LogD(who string, sds SDS, msg string) {

diff --git a/src/pipe.go b/src/pipe.go
index 1b50573bf75fb983283452f9b2c746f844a7ab2d..a117bc8ac140ebce4d2ae4aaa595b1f0cc96306e 100644 (file)
--- a/src/pipe.go
+++ b/src/pipe.go
@@ -65,9 +65,11 @@ func (c PipeConn) SetWriteDeadline(t time.Time) error {
 }
 
 func (c PipeConn) Close() (err error) {
-       c.r.Close()
+       err = c.r.Close()
        err = c.w.Close()
        go c.cmd.Wait()
-       time.AfterFunc(time.Duration(10*time.Second), func() { c.cmd.Process.Kill() })
+       time.AfterFunc(time.Duration(10*time.Second), func() {
+               c.cmd.Process.Kill() // #nosec G104
+       })
        return
 }

diff --git a/src/sp.go b/src/sp.go
index dc1d9c4796bff3b80c9571300efd69477d2b7eec..21a4a2e0a0f6de59649e3f71d39f6db4c0baa0a9 100644 (file)
--- a/src/sp.go
+++ b/src/sp.go
@@ -290,7 +290,7 @@ func (ctx *Ctx) infosOur(nodeId *NodeId, nice uint8, seen *map[[32]byte]uint8) [
        var infos []*SPInfo
        var totalSize int64
        for job := range ctx.Jobs(nodeId, TTx) {
-               job.Fd.Close()
+               job.Fd.Close() // #nosec G104
                if job.PktEnc.Nice > nice {
                        continue
                }
@@ -392,14 +392,14 @@ func (state *SPState) StartI(conn ConnDeadlined) error {
        }
        sds := SDS{"node": nodeId, "nice": int(state.Nice)}
        state.Ctx.LogD("sp-start", sds, "sending first message")
-       conn.SetWriteDeadline(time.Now().Add(DefaultDeadline))
+       conn.SetWriteDeadline(time.Now().Add(DefaultDeadline)) // #nosec G104
        if err = state.WriteSP(conn, buf, false); err != nil {
                state.Ctx.LogE("sp-start", sds, err, "")
                state.dirUnlock()
                return err
        }
        state.Ctx.LogD("sp-start", sds, "waiting for first message")
-       conn.SetReadDeadline(time.Now().Add(DefaultDeadline))
+       conn.SetReadDeadline(time.Now().Add(DefaultDeadline)) // #nosec G104
        if buf, err = state.ReadSP(conn); err != nil {
                state.Ctx.LogE("sp-start", sds, err, "")
                state.dirUnlock()
@@ -446,7 +446,7 @@ func (state *SPState) StartR(conn ConnDeadlined) error {
        var buf []byte
        var payload []byte
        state.Ctx.LogD("sp-start", SDS{"nice": int(state.Nice)}, "waiting for first message")
-       conn.SetReadDeadline(time.Now().Add(DefaultDeadline))
+       conn.SetReadDeadline(time.Now().Add(DefaultDeadline)) // #nosec G104
        if buf, err = state.ReadSP(conn); err != nil {
                state.Ctx.LogE("sp-start", SDS{}, err, "")
                return err
@@ -514,7 +514,7 @@ func (state *SPState) StartR(conn ConnDeadlined) error {
                state.dirUnlock()
                return err
        }
-       conn.SetWriteDeadline(time.Now().Add(DefaultDeadline))
+       conn.SetWriteDeadline(time.Now().Add(DefaultDeadline)) // #nosec G104
        if err = state.WriteSP(conn, buf, false); err != nil {
                state.Ctx.LogE("sp-start", sds, err, "")
                state.dirUnlock()
@@ -597,7 +597,7 @@ func (state *SPState) StartWorkers(
                                        (state.maxOnlineTime > 0 && state.mustFinishAt.Before(now)) ||
                                        (now.Sub(state.RxLastSeen) >= 2*PingTimeout) {
                                        state.SetDead()
-                                       conn.Close()
+                                       conn.Close() // #nosec G104
                                }
                        case now := <-pingTicker.C:
                                if now.After(state.TxLastSeen.Add(PingTimeout)) {
@@ -713,7 +713,7 @@ func (state *SPState) StartWorkers(
                                        buf = buf[:n]
                                        state.Ctx.LogD("sp-file", SdsAdd(sdsp, SDS{"size": n}), "read")
                                }
-                               fd.Close()
+                               fd.Close() // #nosec G104
                                payload = MarshalSP(SPTypeFile, SPFile{
                                        Hash:    freq.Hash,
                                        Offset:  freq.Offset,
@@ -743,7 +743,7 @@ func (state *SPState) StartWorkers(
                                state.Unlock()
                        }
                        state.Ctx.LogD("sp-xmit", SdsAdd(sds, SDS{"size": len(payload)}), "sending")
-                       conn.SetWriteDeadline(time.Now().Add(DefaultDeadline))
+                       conn.SetWriteDeadline(time.Now().Add(DefaultDeadline)) // #nosec G104
                        if err := state.WriteSP(conn, state.csOur.Encrypt(nil, nil, payload), ping); err != nil {
                                state.Ctx.LogE("sp-xmit", sds, err, "")
                                return
@@ -759,7 +759,7 @@ func (state *SPState) StartWorkers(
                                break
                        }
                        state.Ctx.LogD("sp-recv", sds, "waiting for payload")
-                       conn.SetReadDeadline(time.Now().Add(DefaultDeadline))
+                       conn.SetReadDeadline(time.Now().Add(DefaultDeadline)) // #nosec G104
                        payload, err := state.ReadSP(conn)
                        if err != nil {
                                if err == io.EOF {
@@ -814,7 +814,7 @@ func (state *SPState) StartWorkers(
                state.SetDead()
                state.wg.Done()
                state.SetDead()
-               conn.Close()
+               conn.Close() // #nosec G104
        }()
 
        return nil
@@ -962,14 +962,14 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                        )
                        if _, err = fd.Seek(int64(file.Offset), io.SeekStart); err != nil {
                                state.Ctx.LogE("sp-file", sdsp, err, "")
-                               fd.Close()
+                               fd.Close() // #nosec G104
                                return nil, err
                        }
                        state.Ctx.LogD("sp-file", sdsp, "writing")
                        _, err = fd.Write(file.Payload)
                        if err != nil {
                                state.Ctx.LogE("sp-file", sdsp, err, "")
-                               fd.Close()
+                               fd.Close() // #nosec G104
                                return nil, err
                        }
                        ourSize := int64(file.Offset + uint64(len(file.Payload)))
@@ -986,7 +986,7 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                Progress("Rx", sdsp)
                        }
                        if fullsize != ourSize {
-                               fd.Close()
+                               fd.Close() // #nosec G104
                                continue
                        }
                        spWorkersGroup.Wait()
@@ -994,7 +994,7 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                        go func() {
                                if err := fd.Sync(); err != nil {
                                        state.Ctx.LogE("sp-file", sdsp, err, "sync")
-                                       fd.Close()
+                                       fd.Close() // #nosec G104
                                        return
                                }
                                state.wg.Add(1)
@@ -1002,7 +1002,7 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                fd.Seek(0, io.SeekStart)
                                state.Ctx.LogD("sp-file", sdsp, "checking")
                                gut, err := Check(fd, file.Hash[:], sdsp, state.Ctx.ShowPrgrs)
-                               fd.Close()
+                               fd.Close() // #nosec G104
                                if err != nil || !gut {
                                        state.Ctx.LogE("sp-file", sdsp, errors.New("checksum mismatch"), "")
                                        return

diff --git a/src/tmp.go b/src/tmp.go
index 272fbb3ec4bcac76a4bfc0f7556d2aa8ed1525af..91850d746566bdd5d4603db85776932a9ea1a3e9 100644 (file)
--- a/src/tmp.go
+++ b/src/tmp.go
@@ -74,9 +74,9 @@ func (ctx *Ctx) NewTmpFileWHash() (*TmpFileWHash, error) {
 }
 
 func (tmp *TmpFileWHash) Cancel() {
-       tmp.Fd.Truncate(0)
-       tmp.Fd.Close()
-       os.Remove(tmp.Fd.Name())
+       tmp.Fd.Truncate(0) // #nosec G104
+       tmp.Fd.Close() // #nosec G104
+       os.Remove(tmp.Fd.Name()) // #nosec G104
 }
 
 func DirSync(dirPath string) error {
@@ -86,7 +86,7 @@ func DirSync(dirPath string) error {
        }
        err = fd.Sync()
        if err != nil {
-               fd.Close()
+               fd.Close() // #nosec G104
                return err
        }
        return fd.Close()
@@ -98,11 +98,11 @@ func (tmp *TmpFileWHash) Commit(dir string) error {
                return err
        }
        if err = tmp.W.Flush(); err != nil {
-               tmp.Fd.Close()
+               tmp.Fd.Close() // #nosec G104
                return err
        }
        if err = tmp.Fd.Sync(); err != nil {
-               tmp.Fd.Close()
+               tmp.Fd.Close() // #nosec G104
                return err
        }
        tmp.Fd.Close()

diff --git a/src/toss.go b/src/toss.go
index 0bedecae7a76440b3812519b5fe37c433e4fbcbd..a7cb4570da5238586ec94647b076eb5d0f3e84dc 100644 (file)
--- a/src/toss.go
+++ b/src/toss.go
@@ -188,7 +188,7 @@ func (ctx *Ctx) Toss(
                        if !dryRun {
                                if doSeen {
                                        if fd, err := os.Create(job.Fd.Name() + SeenSuffix); err == nil {
-                                               fd.Close()
+                                               fd.Close() // #nosec G104
                                        }
                                }
                                if err = os.Remove(job.Fd.Name()); err != nil {
@@ -239,13 +239,13 @@ func (ctx *Ctx) Toss(
                                        goto Closing
                                }
                                if err = bufW.Flush(); err != nil {
-                                       tmp.Close()
+                                       tmp.Close() // #nosec G104
                                        ctx.LogE("rx", sds, err, "copy")
                                        isBad = true
                                        goto Closing
                                }
                                if err = tmp.Sync(); err != nil {
-                                       tmp.Close()
+                                       tmp.Close() // #nosec G104
                                        ctx.LogE("rx", sds, err, "copy")
                                        isBad = true
                                        goto Closing
@@ -280,7 +280,7 @@ func (ctx *Ctx) Toss(
                        if !dryRun {
                                if doSeen {
                                        if fd, err := os.Create(job.Fd.Name() + SeenSuffix); err == nil {
-                                               fd.Close()
+                                               fd.Close() // #nosec G104
                                        }
                                }
                                if err = os.Remove(job.Fd.Name()); err != nil {
@@ -347,7 +347,7 @@ func (ctx *Ctx) Toss(
                        if !dryRun {
                                if doSeen {
                                        if fd, err := os.Create(job.Fd.Name() + SeenSuffix); err == nil {
-                                               fd.Close()
+                                               fd.Close() // #nosec G104
                                        }
                                }
                                if err = os.Remove(job.Fd.Name()); err != nil {
@@ -391,7 +391,7 @@ func (ctx *Ctx) Toss(
                        if !dryRun {
                                if doSeen {
                                        if fd, err := os.Create(job.Fd.Name() + SeenSuffix); err == nil {
-                                               fd.Close()
+                                               fd.Close() // #nosec G104
                                        }
                                }
                                if err = os.Remove(job.Fd.Name()); err != nil {
@@ -404,7 +404,7 @@ func (ctx *Ctx) Toss(
                        isBad = true
                }
        Closing:
-               pipeR.Close()
+               pipeR.Close() // #nosec G104
        }
        return isBad
 }

diff --git a/src/tx.go b/src/tx.go
index 831cb6fde721eac9eb982ab83c80a074d7ee79d7..80357e74ae3fcee8fa59b64fb84d5fb0105d2de3 100644 (file)
--- a/src/tx.go
+++ b/src/tx.go
@@ -86,7 +86,7 @@ func (ctx *Ctx) Tx(
                        "size": size,
                }, "wrote")
                errs <- PktEncWrite(ctx.Self, hops[0], pkt, nice, size, padSize, src, dst)
-               dst.Close()
+               dst.Close() // #nosec G104
        }(curSize, src, pipeW)
        curSize = PktEncOverhead + PktSizeOverhead + sizeWithTags(PktOverhead+curSize) + padSize
 
@@ -102,7 +102,7 @@ func (ctx *Ctx) Tx(
                                "size": size,
                        }, "trns wrote")
                        errs <- PktEncWrite(ctx.Self, node, pkt, nice, size, 0, src, dst)
-                       dst.Close()
+                       dst.Close() // #nosec G104
                }(hops[i], pktTrns, curSize, pipeRPrev, pipeW)
                curSize = PktEncOverhead + PktSizeOverhead + sizeWithTags(PktOverhead+curSize)
        }
@@ -117,13 +117,13 @@ func (ctx *Ctx) Tx(
        for i := 0; i <= len(hops); i++ {
                err = <-errs
                if err != nil {
-                       tmp.Fd.Close()
+                       tmp.Fd.Close() // #nosec G104
                        return nil, err
                }
        }
        nodePath := filepath.Join(ctx.Spool, lastNode.Id.String())
        err = tmp.Commit(filepath.Join(nodePath, string(TTx)))
-       os.Symlink(nodePath, filepath.Join(ctx.Spool, lastNode.Name))
+       os.Symlink(nodePath, filepath.Join(ctx.Spool, lastNode.Name)) // #nosec G104
        return lastNode, err
 }
 
@@ -140,7 +140,7 @@ func prepareTxFile(srcPath string) (reader io.Reader, closer io.Closer, fileSize
                        rerr = err
                        return
                }
-               os.Remove(src.Name())
+               os.Remove(src.Name()) // #nosec G104
                tmpW := bufio.NewWriter(src)
                tmpKey := make([]byte, chacha20poly1305.KeySize)
                if _, rerr = rand.Read(tmpKey[:]); rerr != nil {
@@ -165,7 +165,7 @@ func prepareTxFile(srcPath string) (reader io.Reader, closer io.Closer, fileSize
                r, w := io.Pipe()
                go func() {
                        if _, err := aeadProcess(aead, nonce, false, bufio.NewReader(src), w); err != nil {
-                               w.CloseWithError(err)
+                               w.CloseWithError(err) // #nosec G104
                        }
                }()
                reader = r
@@ -244,7 +244,7 @@ func prepareTxFile(srcPath string) (reader io.Reader, closer io.Closer, fileSize
        closer = DummyCloser{}
        fileSize += 2 * TarBlockSize // termination block
 
-       go func() {
+       go func() error {
                tarWr := tar.NewWriter(w)
                hdr := tar.Header{
                        Typeflag: tar.TypeDir,
@@ -258,7 +258,7 @@ func prepareTxFile(srcPath string) (reader io.Reader, closer io.Closer, fileSize
                        hdr.Name = basePath + e.path[len(rootPath):]
                        hdr.ModTime = e.modTime
                        if err = tarWr.WriteHeader(&hdr); err != nil {
-                               w.CloseWithError(err)
+                               return w.CloseWithError(err)
                        }
                }
                hdr.Typeflag = tar.TypeReg
@@ -268,7 +268,7 @@ func prepareTxFile(srcPath string) (reader io.Reader, closer io.Closer, fileSize
                        hdr.ModTime = e.modTime
                        hdr.Size = e.size
                        if err = tarWr.WriteHeader(&hdr); err != nil {
-                               w.CloseWithError(err)
+                               return w.CloseWithError(err)
                        }
                        fd, err := os.Open(e.path)
                        if err != nil {
@@ -546,6 +546,6 @@ func (ctx *Ctx) TxTrns(node *Node, nice uint8, size int64, src io.Reader) error
        } else {
                ctx.LogI("tx", SdsAdd(sds, SDS{"err": err}), "sent")
        }
-       os.Symlink(nodePath, filepath.Join(ctx.Spool, node.Name))
+       os.Symlink(nodePath, filepath.Join(ctx.Spool, node.Name)) // #nosec G104
        return err
 }