Streamed NNCPE format

[nncp.git] / src / cmd / nncp-pkt / main.go

diff --git a/src/cmd/nncp-pkt/main.go b/src/cmd/nncp-pkt/main.go
index 49c23a246df01248921dc321b824e14e9ecfa77c..c22b1f71038e209bda406fe3c5bf5903420c6291 100644 (file)
--- a/src/cmd/nncp-pkt/main.go
+++ b/src/cmd/nncp-pkt/main.go
@@ -29,7 +29,7 @@ import (
 
        xdr "github.com/davecgh/go-xdr/xdr2"
        "github.com/klauspost/compress/zstd"
-       "go.cypherpunks.ru/nncp/v7"
+       "go.cypherpunks.ru/nncp/v8"
 )
 
 func usage() {
@@ -40,7 +40,7 @@ func usage() {
        fmt.Fprintln(os.Stderr, "Packet is read from stdin.")
 }
 
-func doPlain(pkt nncp.Pkt, dump, decompress bool) {
+func doPlain(ctx *nncp.Ctx, pkt nncp.Pkt, dump, decompress bool) {
        if dump {
                bufW := bufio.NewWriter(os.Stdout)
                var r io.Reader
@@ -68,22 +68,30 @@ func doPlain(pkt nncp.Pkt, dump, decompress bool) {
                payloadType = "file request"
        case nncp.PktTypeExec:
                payloadType = "exec compressed"
-       case nncp.PktTypeExecFat:
-               payloadType = "exec uncompressed"
        case nncp.PktTypeTrns:
                payloadType = "transitional"
+       case nncp.PktTypeExecFat:
+               payloadType = "exec uncompressed"
+       case nncp.PktTypeArea:
+               payloadType = "area"
        }
        var path string
        switch pkt.Type {
        case nncp.PktTypeExec, nncp.PktTypeExecFat:
                path = string(bytes.Replace(
-                       pkt.Path[:pkt.PathLen],
-                       []byte{0},
-                       []byte(" "),
-                       -1,
+                       pkt.Path[:pkt.PathLen], []byte{0}, []byte(" "), -1,
                ))
        case nncp.PktTypeTrns:
                path = nncp.Base32Codec.EncodeToString(pkt.Path[:pkt.PathLen])
+               node, err := ctx.FindNode(path)
+               if err == nil {
+                       path = fmt.Sprintf("%s (%s)", path, node.Name)
+               }
+       case nncp.PktTypeArea:
+               path = nncp.Base32Codec.EncodeToString(pkt.Path[:pkt.PathLen])
+               if areaId, err := nncp.AreaIdFromString(path); err == nil {
+                       path = fmt.Sprintf("%s (%s)", path, ctx.AreaName(areaId))
+               }
        default:
                path = string(pkt.Path[:pkt.PathLen])
        }
@@ -94,31 +102,64 @@ func doPlain(pkt nncp.Pkt, dump, decompress bool) {
        return
 }
 
-func doEncrypted(pktEnc nncp.PktEnc, dump bool, cfgPath string, beginning []byte) {
+func doEncrypted(
+       ctx *nncp.Ctx,
+       pktEnc nncp.PktEnc,
+       dump bool,
+       beginning []byte,
+) {
+       senderName := "unknown"
+       senderNode := ctx.Neigh[*pktEnc.Sender]
+       if senderNode != nil {
+               senderName = senderNode.Name
+       }
+
+       recipientName := "unknown"
+       var area *nncp.Area
+       recipientNode := ctx.Neigh[*pktEnc.Recipient]
+       if recipientNode == nil {
+               area = ctx.AreaId2Area[nncp.AreaId(*pktEnc.Recipient)]
+               if area != nil {
+                       recipientName = "area " + area.Name
+               }
+       } else {
+               recipientName = recipientNode.Name
+       }
+
        if !dump {
-               fmt.Printf(
-                       "Packet type: encrypted\nNiceness: %s (%d)\nSender: %s\nRecipient: %s\n",
-                       nncp.NicenessFmt(pktEnc.Nice), pktEnc.Nice, pktEnc.Sender, pktEnc.Recipient,
+               fmt.Printf(`Packet type: encrypted
+Niceness: %s (%d)
+Sender: %s (%s)
+Recipient: %s (%s)
+`,
+                       nncp.NicenessFmt(pktEnc.Nice), pktEnc.Nice,
+                       pktEnc.Sender, senderName,
+                       pktEnc.Recipient, recipientName,
                )
                return
        }
-       ctx, err := nncp.CtxFromCmdline(cfgPath, "", "", false, false, false, false)
-       if err != nil {
-               log.Fatalln("Error during initialization:", err)
-       }
        if ctx.Self == nil {
                log.Fatalln("Config lacks private keys")
        }
        bufW := bufio.NewWriter(os.Stdout)
-       if _, _, err = nncp.PktEncRead(
-               ctx.Self,
-               ctx.Neigh,
-               io.MultiReader(
-                       bytes.NewReader(beginning),
-                       bufio.NewReader(os.Stdin),
-               ),
-               bufW,
-       ); err != nil {
+       var err error
+       if area == nil {
+               _, _, _, err = nncp.PktEncRead(
+                       ctx.Self, ctx.Neigh,
+                       io.MultiReader(bytes.NewReader(beginning), bufio.NewReader(os.Stdin)),
+                       bufW, senderNode != nil, nil,
+               )
+       } else {
+               areaNode := nncp.NodeOur{Id: new(nncp.NodeId), ExchPrv: new([32]byte)}
+               copy(areaNode.Id[:], area.Id[:])
+               copy(areaNode.ExchPrv[:], area.Prv[:])
+               _, _, _, err = nncp.PktEncRead(
+                       &areaNode, ctx.Neigh,
+                       io.MultiReader(bytes.NewReader(beginning), bufio.NewReader(os.Stdin)),
+                       bufW, senderNode != nil, nil,
+               )
+       }
+       if err != nil {
                log.Fatalln(err)
        }
        if err = bufW.Flush(); err != nil {
@@ -147,6 +188,11 @@ func main() {
                return
        }
 
+       ctx, err := nncp.CtxFromCmdline(*cfgPath, "", "", false, false, false, false)
+       if err != nil {
+               log.Fatalln("Error during initialization:", err)
+       }
+
        if *overheads {
                fmt.Printf(
                        "Plain: %d\nEncrypted: %d\nSize: %d\n",
@@ -158,24 +204,12 @@ func main() {
        }
 
        beginning := make([]byte, nncp.PktOverhead)
-       if _, err := io.ReadFull(os.Stdin, beginning); err != nil {
+       if _, err := io.ReadFull(os.Stdin, beginning[:nncp.PktEncOverhead]); err != nil {
                log.Fatalln("Not enough data to read")
        }
-       var pkt nncp.Pkt
-       if _, err := xdr.Unmarshal(bytes.NewReader(beginning), &pkt); err == nil {
-               switch pkt.Magic {
-               case nncp.MagicNNCPPv1.B:
-                       log.Fatalln(nncp.MagicNNCPPv1.TooOld())
-               case nncp.MagicNNCPPv2.B:
-                       log.Fatalln(nncp.MagicNNCPPv2.TooOld())
-               case nncp.MagicNNCPPv3.B:
-                       doPlain(pkt, *dump, *decompress)
-                       return
-               }
-       }
        var pktEnc nncp.PktEnc
        if _, err := xdr.Unmarshal(bytes.NewReader(beginning), &pktEnc); err == nil {
-               switch pkt.Magic {
+               switch pktEnc.Magic {
                case nncp.MagicNNCPEv1.B:
                        log.Fatalln(nncp.MagicNNCPEv1.TooOld())
                case nncp.MagicNNCPEv2.B:
@@ -185,7 +219,25 @@ func main() {
                case nncp.MagicNNCPEv4.B:
                        log.Fatalln(nncp.MagicNNCPEv4.TooOld())
                case nncp.MagicNNCPEv5.B:
-                       doEncrypted(pktEnc, *dump, *cfgPath, beginning)
+                       log.Fatalln(nncp.MagicNNCPEv5.TooOld())
+               case nncp.MagicNNCPEv6.B:
+                       doEncrypted(ctx, pktEnc, *dump, beginning[:nncp.PktEncOverhead])
+                       return
+               }
+       }
+
+       if _, err := io.ReadFull(os.Stdin, beginning[nncp.PktEncOverhead:]); err != nil {
+               log.Fatalln("Not enough data to read")
+       }
+       var pkt nncp.Pkt
+       if _, err := xdr.Unmarshal(bytes.NewReader(beginning), &pkt); err == nil {
+               switch pkt.Magic {
+               case nncp.MagicNNCPPv1.B:
+                       log.Fatalln(nncp.MagicNNCPPv1.TooOld())
+               case nncp.MagicNNCPPv2.B:
+                       log.Fatalln(nncp.MagicNNCPPv2.TooOld())
+               case nncp.MagicNNCPPv3.B:
+                       doPlain(ctx, pkt, *dump, *decompress)
                        return
                }
        }