src/pkt_test.go

   1 // NNCP -- Node to Node copy, utilities for store-and-forward data exchange
   2 // Copyright (C) 2016-2024 Sergey Matveev <stargrave@stargrave.org>
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, version 3 of the License.
   7 //
   8 // This program is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 // GNU General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU General Public License
  14 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15
  16 package nncp
  17
  18 import (
  19         "bytes"
  20         "crypto/rand"
  21         "io"
  22         "testing"
  23         "testing/quick"
  24
  25         xdr "github.com/davecgh/go-xdr/xdr2"
  26 )
  27
  28 func TestPktEncWrite(t *testing.T) {
  29         nodeOur, err := NewNodeGenerate()
  30         if err != nil {
  31                 panic(err)
  32         }
  33         nodeTheir, err := NewNodeGenerate()
  34         if err != nil {
  35                 panic(err)
  36         }
  37         f := func(
  38                 path string,
  39                 pathSize uint8,
  40                 dataSize uint32,
  41                 size, minSize uint16,
  42                 wrappers uint8,
  43         ) bool {
  44                 dataSize %= 1 << 20
  45                 data := make([]byte, dataSize)
  46                 if _, err = io.ReadFull(rand.Reader, data); err != nil {
  47                         panic(err)
  48                 }
  49                 var ct bytes.Buffer
  50                 if len(path) > int(pathSize) {
  51                         path = path[:int(pathSize)]
  52                 }
  53                 nice := uint8(123)
  54                 pkt, err := NewPkt(PktTypeFile, nice, []byte(path))
  55                 if err != nil {
  56                         panic(err)
  57                 }
  58                 wrappers %= 8
  59                 _, _, err = PktEncWrite(
  60                         nodeOur,
  61                         nodeTheir.Their(),
  62                         pkt,
  63                         nice,
  64                         int64(minSize),
  65                         MaxFileSize,
  66                         int(wrappers),
  67                         bytes.NewReader(data),
  68                         &ct,
  69                 )
  70                 if err != nil {
  71                         return false
  72                 }
  73                 var pktEnc PktEnc
  74                 if _, err = xdr.Unmarshal(&ct, &pktEnc); err != nil {
  75                         return false
  76                 }
  77                 if *pktEnc.Sender != *nodeOur.Id {
  78                         return false
  79                 }
  80                 return true
  81         }
  82         if err := quick.Check(f, nil); err != nil {
  83                 t.Error(err)
  84         }
  85 }
  86
  87 func TestPktEncRead(t *testing.T) {
  88         node1, err := NewNodeGenerate()
  89         if err != nil {
  90                 panic(err)
  91         }
  92         node2, err := NewNodeGenerate()
  93         if err != nil {
  94                 panic(err)
  95         }
  96         f := func(
  97                 path string,
  98                 pathSize uint8,
  99                 dataSize uint32,
 100                 minSize uint16,
 101                 wrappers uint8,
 102         ) bool {
 103                 dataSize %= 1 << 20
 104                 data := make([]byte, dataSize)
 105                 if _, err = io.ReadFull(rand.Reader, data); err != nil {
 106                         panic(err)
 107                 }
 108                 var ct bytes.Buffer
 109                 if len(path) > int(pathSize) {
 110                         path = path[:int(pathSize)]
 111                 }
 112                 nice := uint8(123)
 113                 pkt, err := NewPkt(PktTypeFile, nice, []byte(path))
 114                 if err != nil {
 115                         panic(err)
 116                 }
 117                 wrappers %= 8
 118                 _, _, err = PktEncWrite(
 119                         node1,
 120                         node2.Their(),
 121                         pkt,
 122                         nice,
 123                         int64(minSize),
 124                         MaxFileSize,
 125                         int(wrappers),
 126                         bytes.NewReader(data),
 127                         &ct,
 128                 )
 129                 if err != nil {
 130                         return false
 131                 }
 132                 var pt bytes.Buffer
 133                 nodes := make(map[NodeId]*Node)
 134                 nodes[*node1.Id] = node1.Their()
 135                 _, node, sizeGot, err := PktEncRead(node2, nodes, &ct, &pt, true, nil)
 136                 if err != nil {
 137                         return false
 138                 }
 139                 if *node.Id != *node1.Id {
 140                         return false
 141                 }
 142                 if sizeGot != int64(len(data)+int(PktOverhead)) {
 143                         return false
 144                 }
 145                 var pktBuf bytes.Buffer
 146                 xdr.Marshal(&pktBuf, &pkt)
 147                 return bytes.Equal(pt.Bytes(), append(pktBuf.Bytes(), data...))
 148         }
 149         if err := quick.Check(f, nil); err != nil {
 150                 t.Error(err)
 151         }
 152 }