src/cmd/nncp-ack/main.go

   1 /*
   2 NNCP -- Node to Node copy, utilities for store-and-forward data exchange
   3 Copyright (C) 2016-2023 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 // Send packet receipt acknowledgement via NNCP.
  19 package main
  20
  21 import (
  22         "bufio"
  23         "errors"
  24         "flag"
  25         "fmt"
  26         "io"
  27         "log"
  28         "os"
  29         "path/filepath"
  30         "strings"
  31
  32         xdr "github.com/davecgh/go-xdr/xdr2"
  33         "go.cypherpunks.ru/nncp/v8"
  34 )
  35
  36 func usage() {
  37         fmt.Fprint(os.Stderr, "nncp-ack -- send packet receipt acknowledgement\n\n")
  38         fmt.Fprintf(os.Stderr, "Usage: %s [options] -all\n", os.Args[0])
  39         fmt.Fprintf(os.Stderr, "Usage: %s [options] -node NODE[,...]\n", os.Args[0])
  40         fmt.Fprintf(os.Stderr, "Usage: %s [options] -node NODE -pkt PKT\n", os.Args[0])
  41         fmt.Fprintln(os.Stderr, "Options:")
  42         flag.PrintDefaults()
  43 }
  44
  45 func main() {
  46         var (
  47                 cfgPath = flag.String("cfg", nncp.DefaultCfgPath, "Path to configuration file")
  48                 niceRaw = flag.String("nice", nncp.NicenessFmt(nncp.DefaultNiceFreq),
  49                         "Outbound packet niceness")
  50                 minSizeRaw  = flag.Int64("minsize", -1, "Minimal required resulting packet size, in KiB")
  51                 viaOverride = flag.String("via", "", "Override Via path to destination node (ignored with -all)")
  52                 spoolPath   = flag.String("spool", "", "Override path to spool")
  53                 logPath     = flag.String("log", "", "Override path to logfile")
  54                 doAll       = flag.Bool("all", false, "ACK all rx packet for all nodes")
  55                 nodesRaw    = flag.String("node", "", "ACK rx packets for that node")
  56                 pktRaw      = flag.String("pkt", "", "ACK only that packet")
  57                 quiet       = flag.Bool("quiet", false, "Print only errors")
  58                 showPrgrs   = flag.Bool("progress", false, "Force progress showing")
  59                 omitPrgrs   = flag.Bool("noprogress", false, "Omit progress showing")
  60                 debug       = flag.Bool("debug", false, "Print debug messages")
  61                 version     = flag.Bool("version", false, "Print version information")
  62                 warranty    = flag.Bool("warranty", false, "Print warranty information")
  63         )
  64         log.SetFlags(log.Lshortfile)
  65         flag.Usage = usage
  66         flag.Parse()
  67         if *warranty {
  68                 fmt.Println(nncp.Warranty)
  69                 return
  70         }
  71         if *version {
  72                 fmt.Println(nncp.VersionGet())
  73                 return
  74         }
  75         nice, err := nncp.NicenessParse(*niceRaw)
  76         if err != nil {
  77                 log.Fatalln(err)
  78         }
  79
  80         ctx, err := nncp.CtxFromCmdline(
  81                 *cfgPath,
  82                 *spoolPath,
  83                 *logPath,
  84                 *quiet,
  85                 *showPrgrs,
  86                 *omitPrgrs,
  87                 *debug,
  88         )
  89         if err != nil {
  90                 log.Fatalln("Error during initialization:", err)
  91         }
  92         if ctx.Self == nil {
  93                 log.Fatalln("Config lacks private keys")
  94         }
  95
  96         ctx.Umask()
  97
  98         var nodes []*nncp.Node
  99         if *nodesRaw != "" {
 100                 for _, nodeRaw := range strings.Split(*nodesRaw, ",") {
 101                         node, err := ctx.FindNode(nodeRaw)
 102                         if err != nil {
 103                                 log.Fatalln("Invalid -node specified:", err)
 104                         }
 105                         nodes = append(nodes, node)
 106                 }
 107         }
 108         if *doAll {
 109                 if len(nodes) != 0 {
 110                         usage()
 111                         os.Exit(1)
 112                 }
 113                 for _, node := range ctx.Neigh {
 114                         nodes = append(nodes, node)
 115                 }
 116         } else if len(nodes) == 0 {
 117                 usage()
 118                 os.Exit(1)
 119         }
 120
 121         acksCreated := os.NewFile(uintptr(4), "ACKsCreated")
 122         if acksCreated == nil {
 123                 log.Fatalln("can not open FD:4")
 124         }
 125
 126         if *pktRaw != "" {
 127                 if len(nodes) != 1 {
 128                         usage()
 129                         os.Exit(1)
 130                 }
 131                 nncp.ViaOverride(*viaOverride, ctx, nodes[0])
 132
 133                 var minSize int64
 134                 if *minSizeRaw < 0 {
 135                         minSize = nodes[0].ACKMinSize
 136                 } else if *minSizeRaw > 0 {
 137                         minSize = *minSizeRaw * 1024
 138                 }
 139
 140                 pktName, err := ctx.TxACK(nodes[0], nice, *pktRaw, minSize)
 141                 if err != nil {
 142                         log.Fatalln(err)
 143                 }
 144                 acksCreated.WriteString(nodes[0].Id.String() + "/" + pktName + "\n")
 145                 return
 146         }
 147
 148         isBad := false
 149         for _, node := range nodes {
 150                 var minSize int64
 151                 if *minSizeRaw < 0 {
 152                         minSize = node.ACKMinSize
 153                 } else if *minSizeRaw > 0 {
 154                         minSize = *minSizeRaw * 1024
 155                 }
 156                 for job := range ctx.Jobs(node.Id, nncp.TRx) {
 157                         pktName := filepath.Base(job.Path)
 158                         sender := ctx.Neigh[*job.PktEnc.Sender]
 159                         les := nncp.LEs{
 160                                 {K: "Node", V: job.PktEnc.Sender},
 161                                 {K: "Pkt", V: pktName},
 162                         }
 163                         logMsg := func(les nncp.LEs) string {
 164                                 return fmt.Sprintf(
 165                                         "ACKing %s/%s",
 166                                         ctx.NodeName(job.PktEnc.Sender), pktName,
 167                                 )
 168                         }
 169                         if sender == nil {
 170                                 err := errors.New("unknown node")
 171                                 ctx.LogE("ack-read", les, err, logMsg)
 172                                 isBad = true
 173                                 continue
 174                         }
 175                         fd, err := os.Open(job.Path)
 176                         if err != nil {
 177                                 ctx.LogE("ack-read-open", les, err, func(les nncp.LEs) string {
 178                                         return logMsg(les) + ": opening" + job.Path
 179                                 })
 180                                 isBad = true
 181                                 continue
 182                         }
 183                         pktEnc, _, err := ctx.HdrRead(fd)
 184                         if err != nil {
 185                                 fd.Close()
 186                                 ctx.LogE("ack-read-read", les, err, func(les nncp.LEs) string {
 187                                         return logMsg(les) + ": reading" + job.Path
 188                                 })
 189                                 isBad = true
 190                                 continue
 191                         }
 192                         switch pktEnc.Magic {
 193                         case nncp.MagicNNCPEv1.B:
 194                                 err = nncp.MagicNNCPEv1.TooOld()
 195                         case nncp.MagicNNCPEv2.B:
 196                                 err = nncp.MagicNNCPEv2.TooOld()
 197                         case nncp.MagicNNCPEv3.B:
 198                                 err = nncp.MagicNNCPEv3.TooOld()
 199                         case nncp.MagicNNCPEv4.B:
 200                                 err = nncp.MagicNNCPEv4.TooOld()
 201                         case nncp.MagicNNCPEv5.B:
 202                                 err = nncp.MagicNNCPEv5.TooOld()
 203                         case nncp.MagicNNCPEv6.B:
 204                         default:
 205                                 err = errors.New("is not an encrypted packet")
 206                         }
 207                         if err != nil {
 208                                 fd.Close()
 209                                 ctx.LogE("ack-read-magic", les, err, logMsg)
 210                                 isBad = true
 211                                 continue
 212                         }
 213                         if _, err = fd.Seek(0, io.SeekStart); err != nil {
 214                                 fd.Close()
 215                                 ctx.LogE("ack-read-seek", les, err, func(les nncp.LEs) string {
 216                                         return logMsg(les) + ": seeking"
 217                                 })
 218                                 isBad = true
 219                                 continue
 220                         }
 221                         pipeR, pipeW := io.Pipe()
 222                         go nncp.PktEncRead(
 223                                 ctx.Self,
 224                                 ctx.Neigh,
 225                                 bufio.NewReaderSize(fd, nncp.MTHBlockSize),
 226                                 pipeW, true, nil,
 227                         )
 228                         var pkt nncp.Pkt
 229                         _, err = xdr.Unmarshal(pipeR, &pkt)
 230                         fd.Close()
 231                         pipeW.Close()
 232                         if err != nil {
 233                                 ctx.LogE("ack-read-unmarshal", les, err, func(les nncp.LEs) string {
 234                                         return logMsg(les) + ": unmarshal"
 235                                 })
 236                                 isBad = true
 237                                 continue
 238                         }
 239                         if pkt.Type == nncp.PktTypeACK {
 240                                 ctx.LogI("ack-read-if-ack", les, func(les nncp.LEs) string {
 241                                         return logMsg(les) + ": it is ACK, skipping"
 242                                 })
 243                                 continue
 244                         }
 245                         newPktName, err := ctx.TxACK(node, nice, pktName, minSize)
 246                         if err != nil {
 247                                 log.Fatalln(err)
 248                         }
 249                         acksCreated.WriteString(node.Id.String() + "/" + newPktName + "\n")
 250                 }
 251         }
 252         if isBad {
 253                 os.Exit(1)
 254         }
 255 }