/*
NNCP -- Node to Node copy, utilities for store-and-forward data exchange
-Copyright (C) 2016-2022 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2016-2023 Sergey Matveev <stargrave@stargrave.org>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
src io.Reader,
pktName string,
areaId *AreaId,
-) (*Node, int64, error) {
+) (*Node, int64, string, error) {
var area *Area
if areaId != nil {
area = ctx.AreaId2Area[*areaId]
if area.Prv == nil {
- return nil, 0, errors.New("area has no encryption keys")
+ return nil, 0, "", errors.New("area has no encryption keys")
}
}
hops := make([]*Node, 0, 1+len(node.Via))
expectedSize += sizePadCalc(expectedSize, minSize, wrappers)
expectedSize = PktEncOverhead + sizeWithTags(expectedSize)
if maxSize != 0 && expectedSize > maxSize {
- return nil, 0, TooBig
+ return nil, 0, "", TooBig
}
if !ctx.IsEnoughSpace(expectedSize) {
- return nil, 0, errors.New("is not enough space")
+ return nil, 0, "", errors.New("is not enough space")
}
}
tmp, err := ctx.NewTmpFileWHash()
if err != nil {
- return nil, 0, err
+ return nil, 0, "", err
}
results := make(chan PktEncWriteResult)
r := <-results
if r.err != nil {
tmp.Fd.Close()
- return nil, 0, r.err
+ return nil, 0, "", r.err
}
if r.pktEncRaw != nil {
pktEncRaw = r.pktEncRaw
err = tmp.Commit(filepath.Join(nodePath, string(TTx)))
os.Symlink(nodePath, filepath.Join(ctx.Spool, lastNode.Name))
if err != nil {
- return lastNode, 0, err
+ return lastNode, 0, "", err
}
if ctx.HdrUsage {
ctx.HdrWrite(pktEncRaw, filepath.Join(nodePath, string(TTx), tmp.Checksum()))
}
if err = ensureDir(seenDir); err != nil {
ctx.LogE("tx-mkdir", les, err, logMsg)
- return lastNode, 0, err
+ return lastNode, 0, "", err
}
if fd, err := os.Create(seenPath); err == nil {
fd.Close()
if err = DirSync(seenDir); err != nil {
ctx.LogE("tx-dirsync", les, err, logMsg)
- return lastNode, 0, err
+ return lastNode, 0, "", err
}
}
ctx.LogI("tx-area", les, logMsg)
}
- return lastNode, payloadSize, err
+ return lastNode, payloadSize, tmp.Checksum(), err
}
type DummyCloser struct{}
fd.Close()
return w.CloseWithError(err)
}
- if _, err = io.Copy(tarWr, bufio.NewReader(fd)); err != nil {
+ if _, err = io.Copy(
+ tarWr, bufio.NewReaderSize(fd, MTHBlockSize),
+ ); err != nil {
fd.Close()
return w.CloseWithError(err)
}
if err != nil {
return err
}
- _, finalSize, err := ctx.Tx(
+ _, finalSize, pktName, err := ctx.Tx(
node, pkt, nice,
srcSize, minSize, maxSize,
- bufio.NewReader(reader), dstPath, areaId,
+ bufio.NewReaderSize(reader, MTHBlockSize), dstPath, areaId,
)
les := LEs{
{"Type", "file"},
{"Src", srcPath},
{"Dst", dstPath},
{"Size", finalSize},
+ {"Pkt", pktName},
}
logMsg := func(les LEs) string {
return fmt.Sprintf(
return err
}
- br := bufio.NewReader(reader)
+ br := bufio.NewReaderSize(reader, MTHBlockSize)
var sizeFull int64
var chunkNum int
checksums := [][MTHSize]byte{}
return err
}
hsh := MTHNew(0, 0)
- _, size, err := ctx.Tx(
+ _, size, pktName, err := ctx.Tx(
node, pkt, nice,
0, minSize, maxSize,
io.TeeReader(lr, hsh),
{"Src", srcPath},
{"Dst", path},
{"Size", size},
+ {"Pkt", pktName},
}
logMsg := func(les LEs) string {
return fmt.Sprintf(
return err
}
metaPktSize := int64(buf.Len())
- _, _, err = ctx.Tx(
+ _, _, pktName, err := ctx.Tx(
node,
pkt,
nice,
{"Src", srcPath},
{"Dst", path},
{"Size", metaPktSize},
+ {"Pkt", pktName},
}
logMsg := func(les LEs) string {
return fmt.Sprintf(
}
src := strings.NewReader(dstPath)
size := int64(src.Len())
- _, _, err = ctx.Tx(node, pkt, nice, size, minSize, MaxFileSize, src, srcPath, nil)
+ _, _, pktName, err := ctx.Tx(
+ node, pkt, nice, size, minSize, MaxFileSize, src, srcPath, nil,
+ )
les := LEs{
{"Type", "freq"},
{"Node", node.Id},
{"ReplyNice", int(replyNice)},
{"Src", srcPath},
{"Dst", dstPath},
+ {"Pkt", pktName},
}
logMsg := func(les LEs) string {
return fmt.Sprintf(
}(in)
in = pr
}
- _, size, err := ctx.Tx(node, pkt, nice, 0, minSize, maxSize, in, handle, areaId)
+ _, size, pktName, err := ctx.Tx(
+ node, pkt, nice, 0, minSize, maxSize, in, handle, areaId,
+ )
if !noCompress {
e := <-compressErr
if err == nil {
{"ReplyNice", int(replyNice)},
{"Dst", dst},
{"Size", size},
+ {"Pkt", pktName},
}
logMsg := func(les LEs) string {
return fmt.Sprintf(
nice uint8,
hsh string,
minSize int64,
-) error {
+) (pktName string, err error) {
hshRaw, err := Base32Codec.DecodeString(hsh)
if err != nil {
- return err
+ return "", err
}
if len(hshRaw) != MTHSize {
- return errors.New("Invalid packet id size")
+ return "", errors.New("Invalid packet id size")
}
pkt, err := NewPkt(PktTypeACK, nice, []byte(hshRaw))
if err != nil {
- return err
+ return "", err
}
src := bytes.NewReader([]byte{})
- _, _, err = ctx.Tx(node, pkt, nice, 0, minSize, MaxFileSize, src, hsh, nil)
+ _, _, pktName, err = ctx.Tx(
+ node, pkt, nice, 0, minSize, MaxFileSize, src, hsh, nil,
+ )
les := LEs{
{"Type", "ack"},
{"Node", node.Id},
{"Nice", int(nice)},
{"Pkt", hsh},
+ {"NewPkt", pktName},
}
logMsg := func(les LEs) string {
return fmt.Sprintf("ACK to %s of %s is sent", ctx.NodeName(node.Id), hsh)
} else {
ctx.LogE("tx", les, err, logMsg)
}
- return err
+ return
}