]> Cypherpunks.ru repositories - nncp.git/blob - src/check.go
.hdr files
[nncp.git] / src / check.go
1 /*
2 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
3 Copyright (C) 2016-2021 Sergey Matveev <stargrave@stargrave.org>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, version 3 of the License.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18 package nncp
19
20 import (
21         "bufio"
22         "bytes"
23         "errors"
24         "io"
25         "log"
26         "os"
27         "path/filepath"
28
29         "golang.org/x/crypto/blake2b"
30 )
31
32 const NoCKSuffix = ".nock"
33
34 func Check(src io.Reader, checksum []byte, les LEs, showPrgrs bool) (bool, error) {
35         hsh, err := blake2b.New256(nil)
36         if err != nil {
37                 log.Fatalln(err)
38         }
39         if _, err = CopyProgressed(hsh, bufio.NewReader(src), "check", les, showPrgrs); err != nil {
40                 return false, err
41         }
42         return bytes.Compare(hsh.Sum(nil), checksum) == 0, nil
43 }
44
45 func (ctx *Ctx) checkXxIsBad(nodeId *NodeId, xx TRxTx) bool {
46         isBad := false
47         for job := range ctx.Jobs(nodeId, xx) {
48                 les := LEs{
49                         {"XX", string(xx)},
50                         {"Node", nodeId},
51                         {"Pkt", Base32Codec.EncodeToString(job.HshValue[:])},
52                         {"FullSize", job.Size},
53                 }
54                 fd, err := os.Open(job.Path)
55                 if err != nil {
56                         ctx.LogE("check", les, err, "")
57                         return true
58                 }
59                 gut, err := Check(fd, job.HshValue[:], les, ctx.ShowPrgrs)
60                 fd.Close() // #nosec G104
61                 if err != nil {
62                         ctx.LogE("check", les, err, "")
63                         return true
64                 }
65                 if !gut {
66                         isBad = true
67                         ctx.LogE("check", les, errors.New("bad"), "")
68                 }
69         }
70         return isBad
71 }
72
73 func (ctx *Ctx) Check(nodeId *NodeId) bool {
74         return !(ctx.checkXxIsBad(nodeId, TRx) || ctx.checkXxIsBad(nodeId, TTx))
75 }
76
77 func (ctx *Ctx) CheckNoCK(nodeId *NodeId, hshValue *[32]byte) (int64, error) {
78         dirToSync := filepath.Join(ctx.Spool, nodeId.String(), string(TRx))
79         pktName := Base32Codec.EncodeToString(hshValue[:])
80         pktPath := filepath.Join(dirToSync, pktName)
81         fd, err := os.Open(pktPath + NoCKSuffix)
82         if err != nil {
83                 return 0, err
84         }
85         defer fd.Close()
86         fi, err := fd.Stat()
87         if err != nil {
88                 return 0, err
89         }
90         defer fd.Close()
91         size := fi.Size()
92         les := LEs{
93                 {"XX", string(TRx)},
94                 {"Node", nodeId},
95                 {"Pkt", pktName},
96                 {"FullSize", size},
97         }
98         gut, err := Check(fd, hshValue[:], les, ctx.ShowPrgrs)
99         if err != nil || !gut {
100                 return 0, errors.New("checksum mismatch")
101         }
102         if err = os.Rename(pktPath+NoCKSuffix, pktPath); err != nil {
103                 return 0, err
104         }
105         if err = DirSync(dirToSync); err != nil {
106                 return size, err
107         }
108         if ctx.HdrUsage {
109                 if _, err = fd.Seek(0, io.SeekStart); err != nil {
110                         return size, err
111                 }
112                 _, pktEncRaw, err := ctx.HdrRead(fd)
113                 if err != nil {
114                         return size, err
115                 }
116                 ctx.HdrWrite(pktEncRaw, pktPath)
117         }
118         return size, err
119 }