nncp-pkt is able to parse .hdr

[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..fbfc6dafac0b7bd5e3a34eca16a23970f0da7047 100644 (file)
--- a/src/cmd/nncp-pkt/main.go
+++ b/src/cmd/nncp-pkt/main.go
@@ -77,10 +77,7 @@ func doPlain(pkt nncp.Pkt, dump, decompress bool) {
        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])
@@ -95,17 +92,27 @@ func doPlain(pkt nncp.Pkt, dump, decompress bool) {
 }
 
 func doEncrypted(pktEnc nncp.PktEnc, dump bool, cfgPath string, beginning []byte) {
+       ctx, err := nncp.CtxFromCmdline(cfgPath, "", "", false, false, false, false)
+       if err != nil {
+               log.Fatalln("Error during initialization:", err)
+       }
        if !dump {
+               senderS := "unknown"
+               recipientS := "unknown"
+               if n, ok := ctx.Neigh[*pktEnc.Sender]; ok {
+                       senderS = n.Name
+               }
+               if n, ok := ctx.Neigh[*pktEnc.Recipient]; ok {
+                       recipientS = n.Name
+               }
                fmt.Printf(
-                       "Packet type: encrypted\nNiceness: %s (%d)\nSender: %s\nRecipient: %s\n",
-                       nncp.NicenessFmt(pktEnc.Nice), pktEnc.Nice, pktEnc.Sender, pktEnc.Recipient,
+                       "Packet type: encrypted\nNiceness: %s (%d)\nSender: %s (%s)\nRecipient: %s (%s)\n",
+                       nncp.NicenessFmt(pktEnc.Nice), pktEnc.Nice,
+                       pktEnc.Sender, senderS,
+                       pktEnc.Recipient, recipientS,
                )
                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")
        }
@@ -158,24 +165,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 +180,23 @@ func main() {
                case nncp.MagicNNCPEv4.B:
                        log.Fatalln(nncp.MagicNNCPEv4.TooOld())
                case nncp.MagicNNCPEv5.B:
-                       doEncrypted(pktEnc, *dump, *cfgPath, beginning)
+                       doEncrypted(pktEnc, *dump, *cfgPath, 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(pkt, *dump, *decompress)
                        return
                }
        }