if areaId != nil {
area = ctx.AreaId2Area[*areaId]
if area.Prv == nil {
- return nil, errors.New("unknown area id")
+ return nil, errors.New("area has no encryption keys")
}
}
hops := make([]*Node, 0, 1+len(node.Via))
)
pktEncRaws <- pktEncRaw
errs <- err
- dst.Close() // #nosec G104
+ dst.Close()
}(curSize, src, pipeW)
curSize = PktEncOverhead + PktSizeOverhead + sizeWithTags(PktOverhead+curSize)
curSize += padSize
)
pktEncRaws <- pktEncRaw
errs <- err
- dst.Close() // #nosec G104
+ dst.Close()
}(curSize, padSize, src, pipeW)
curSize = PktEncOverhead + PktSizeOverhead + sizeWithTags(PktOverhead+curSize)
curSize += padSize
)
pktEncRaws <- pktEncRaw
errs <- err
- dst.Close() // #nosec G104
+ dst.Close()
}(curSize, pipeRPrev, pipeW)
curSize = PktEncOverhead + PktSizeOverhead + sizeWithTags(PktOverhead+curSize)
}
pktEncRaw, err := PktEncWrite(ctx.Self, node, pkt, nice, size, 0, src, dst)
pktEncRaws <- pktEncRaw
errs <- err
- dst.Close() // #nosec G104
+ dst.Close()
}(hops[i], pktTrns, curSize, pipeRPrev, pipeW)
curSize = PktEncOverhead + PktSizeOverhead + sizeWithTags(PktOverhead+curSize)
}
for i := 0; i <= wrappers; i++ {
err = <-errs
if err != nil {
- tmp.Fd.Close() // #nosec G104
+ tmp.Fd.Close()
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)) // #nosec G104
+ os.Symlink(nodePath, filepath.Join(ctx.Spool, lastNode.Name))
if err != nil {
return lastNode, err
}
seenDir := filepath.Join(
ctx.Spool, ctx.SelfId.String(), AreaDir, areaId.String(),
)
- seenPath := filepath.Join(seenDir, msgHash+SeenSuffix)
+ seenPath := filepath.Join(seenDir, msgHash)
les := LEs{
{"Node", node.Id},
{"Nice", int(nice)},
msgHash,
)
}
- if err = os.MkdirAll(seenDir, os.FileMode(0777)); err != nil {
+ if err = ensureDir(seenDir); err != nil {
ctx.LogE("tx-mkdir", les, err, logMsg)
return lastNode, err
}
rerr = err
return
}
- os.Remove(src.Name()) // #nosec G104
+ os.Remove(src.Name())
tmpW := bufio.NewWriter(src)
tmpKey := make([]byte, chacha20poly1305.KeySize)
if _, rerr = rand.Read(tmpKey[:]); rerr != nil {
}
r, w := io.Pipe()
go func() {
+ for i := 0; i < aead.NonceSize(); i++ {
+ nonce[i] = 0
+ }
if _, err := aeadProcess(aead, nonce, nil, false, bufio.NewReader(src), w); err != nil {
- w.CloseWithError(err) // #nosec G104
+ w.CloseWithError(err)
}
}()
reader = r
}
fd, err := os.Open(e.path)
if err != nil {
- fd.Close() // #nosec G104
+ fd.Close()
return w.CloseWithError(err)
}
if _, err = io.Copy(tarWr, bufio.NewReader(fd)); err != nil {
- fd.Close() // #nosec G104
+ fd.Close()
return w.CloseWithError(err)
}
- fd.Close() // #nosec G104
+ fd.Close()
}
if err = tarWr.Close(); err != nil {
return w.CloseWithError(err)
if noCompress {
pktType = PktTypeExecFat
}
- pkt, err := NewPkt(pktType, replyNice, bytes.Join(path, []byte{0}))
- if err != nil {
- return err
+ pkt, rerr := NewPkt(pktType, replyNice, bytes.Join(path, []byte{0}))
+ if rerr != nil {
+ return rerr
}
var size int64
return err
}
if _, err = io.Copy(compressor, in); err != nil {
- compressor.Close() // #nosec G104
+ compressor.Close()
return err
}
if err = compressor.Close(); err != nil {
return err
}
size = int64(compressed.Len())
- _, err = ctx.Tx(node, pkt, nice, size, minSize, &compressed, handle, areaId)
+ _, rerr = ctx.Tx(node, pkt, nice, size, minSize, &compressed, handle, areaId)
}
if noCompress && !useTmp {
var data bytes.Buffer
- if _, err = io.Copy(&data, in); err != nil {
+ if _, err := io.Copy(&data, in); err != nil {
return err
}
size = int64(data.Len())
- _, err = ctx.Tx(node, pkt, nice, size, minSize, &data, handle, areaId)
+ _, rerr = ctx.Tx(node, pkt, nice, size, minSize, &data, handle, areaId)
}
if !noCompress && useTmp {
r, w := io.Pipe()
go func() {
_, err := io.Copy(compressor, in)
if err != nil {
- compressor.Close() // #nosec G104
+ compressor.Close()
copyErr <- err
}
err = compressor.Close()
return err
}
size = fileSize
- _, err = ctx.Tx(node, pkt, nice, size, minSize, tmpReader, handle, areaId)
+ _, rerr = ctx.Tx(node, pkt, nice, size, minSize, tmpReader, handle, areaId)
}
if noCompress && useTmp {
tmpReader, closer, fileSize, err := throughTmpFile(in)
return err
}
size = fileSize
- _, err = ctx.Tx(node, pkt, nice, size, minSize, tmpReader, handle, areaId)
+ _, rerr = ctx.Tx(node, pkt, nice, size, minSize, tmpReader, handle, areaId)
}
dst := strings.Join(append([]string{handle}, args...), " ")
ctx.NodeName(node.Id), dst, humanize.IBytes(uint64(size)),
)
}
- if err == nil {
+ if rerr == nil {
ctx.LogI("tx", les, logMsg)
} else {
- ctx.LogE("tx", les, err, logMsg)
+ ctx.LogE("tx", les, rerr, logMsg)
}
- return err
+ return rerr
}
func (ctx *Ctx) TxTrns(node *Node, nice uint8, size int64, src io.Reader) error {
} else {
ctx.LogI("tx", append(les, LE{"Err", err}), logMsg)
}
- os.Symlink(nodePath, filepath.Join(ctx.Spool, node.Name)) // #nosec G104
+ os.Symlink(nodePath, filepath.Join(ctx.Spool, node.Name))
return err
}