Fix nncp-daemon segfault when SP fails

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

diff --git a/src/cmd/nncp-daemon/main.go b/src/cmd/nncp-daemon/main.go
index b2b8911ec21b2abbbc6daaf30b40d253d7b9fcc0..a1b7982a8bdab14819674323cb11299f0b764049 100644 (file)
--- a/src/cmd/nncp-daemon/main.go
+++ b/src/cmd/nncp-daemon/main.go
@@ -26,7 +26,8 @@ import (
        "os"
        "time"
 
-       "go.cypherpunks.ru/nncp/v5"
+       "github.com/dustin/go-humanize"
+       "go.cypherpunks.ru/nncp/v6"
        "golang.org/x/net/netutil"
 )
 
@@ -70,33 +71,59 @@ func performSP(
        ctx *nncp.Ctx,
        conn nncp.ConnDeadlined,
        nice uint8,
+       noCK bool,
        nodeIdC chan *nncp.NodeId,
 ) {
        state := nncp.SPState{
                Ctx:  ctx,
                Nice: nice,
+               NoCK: noCK,
        }
        if err := state.StartR(conn); err == nil {
-               ctx.LogI("call-start", nncp.SDS{"node": state.Node.Id}, "connected")
+               ctx.LogI(
+                       "call-started",
+                       nncp.LEs{{K: "Node", V: state.Node.Id}},
+                       func(les nncp.LEs) string { return "Connection with " + state.Node.Name },
+               )
                nodeIdC <- state.Node.Id
                state.Wait()
-               ctx.LogI("call-finish", nncp.SDS{
-                       "node":     state.Node.Id,
-                       "duration": int64(state.Duration.Seconds()),
-                       "rxbytes":  state.RxBytes,
-                       "txbytes":  state.TxBytes,
-                       "rxspeed":  state.RxSpeed,
-                       "txspeed":  state.TxSpeed,
-               }, "")
+               ctx.LogI("call-finished", nncp.LEs{
+                       {K: "Node", V: state.Node.Id},
+                       {K: "Duration", V: int64(state.Duration.Seconds())},
+                       {K: "RxBytes", V: state.RxBytes},
+                       {K: "TxBytes", V: state.TxBytes},
+                       {K: "RxSpeed", V: state.RxSpeed},
+                       {K: "TxSpeed", V: state.TxSpeed},
+               }, func(les nncp.LEs) string {
+                       return fmt.Sprintf(
+                               "Finished call with %s (%d:%d:%d): %s received (%s/sec), %s transferred (%s/sec)",
+                               state.Node.Name,
+                               int(state.Duration.Hours()),
+                               int(state.Duration.Minutes()),
+                               int(state.Duration.Seconds()),
+                               humanize.IBytes(uint64(state.RxBytes)),
+                               humanize.IBytes(uint64(state.RxSpeed)),
+                               humanize.IBytes(uint64(state.TxBytes)),
+                               humanize.IBytes(uint64(state.TxSpeed)),
+                       )
+               })
        } else {
-               nodeId := "unknown"
+               var nodeId string
+               var nodeName string
                if state.Node == nil {
+                       nodeId = "unknown"
+                       nodeName = "unknown"
                        nodeIdC <- nil
                } else {
-                       nodeIdC <- state.Node.Id
                        nodeId = state.Node.Id.String()
+                       nodeName = state.Node.Name
+                       nodeIdC <- state.Node.Id
                }
-               ctx.LogE("call-start", nncp.SDS{"node": nodeId}, err, "")
+               ctx.LogI(
+                       "call-started",
+                       nncp.LEs{{K: "Node", V: nodeId}},
+                       func(les nncp.LEs) string { return "Connected to " + nodeName },
+               )
        }
        close(nodeIdC)
 }
@@ -108,6 +135,7 @@ func main() {
                bind      = flag.String("bind", "[::]:5400", "Address to bind to")
                inetd     = flag.Bool("inetd", false, "Is it started as inetd service")
                maxConn   = flag.Int("maxconn", 128, "Maximal number of simultaneous connections")
+               noCK      = flag.Bool("nock", false, "Do no checksum checking")
                spoolPath = flag.String("spool", "", "Override path to spool")
                logPath   = flag.String("log", "", "Override path to logfile")
                quiet     = flag.Bool("quiet", false, "Print only errors")
@@ -160,9 +188,26 @@ func main() {
                os.Stderr.Close() // #nosec G104
                conn := &InetdConn{os.Stdin, os.Stdout}
                nodeIdC := make(chan *nncp.NodeId)
-               go performSP(ctx, conn, nice, nodeIdC)
-               <-nodeIdC    // nodeId
-               <-nodeIdC    // call completion
+               go performSP(ctx, conn, nice, *noCK, nodeIdC)
+               nodeId := <-nodeIdC
+               var autoTossFinish chan struct{}
+               var autoTossBadCode chan bool
+               if *autoToss && nodeId != nil {
+                       autoTossFinish, autoTossBadCode = ctx.AutoToss(
+                               nodeId,
+                               nice,
+                               *autoTossDoSeen,
+                               *autoTossNoFile,
+                               *autoTossNoFreq,
+                               *autoTossNoExec,
+                               *autoTossNoTrns,
+                       )
+               }
+               <-nodeIdC // call completion
+               if *autoToss {
+                       close(autoTossFinish)
+                       <-autoTossBadCode
+               }
                conn.Close() // #nosec G104
                return
        }
@@ -177,10 +222,16 @@ func main() {
                if err != nil {
                        log.Fatalln("Can not accept connection:", err)
                }
-               ctx.LogD("daemon", nncp.SDS{"addr": conn.RemoteAddr()}, "accepted")
+               ctx.LogD(
+                       "daemon-accepted",
+                       nncp.LEs{{K: "Addr", V: conn.RemoteAddr()}},
+                       func(les nncp.LEs) string {
+                               return "Accepted connection with " + conn.RemoteAddr().String()
+                       },
+               )
                go func(conn net.Conn) {
                        nodeIdC := make(chan *nncp.NodeId)
-                       go performSP(ctx, conn, nice, nodeIdC)
+                       go performSP(ctx, conn, nice, *noCK, nodeIdC)
                        nodeId := <-nodeIdC
                        var autoTossFinish chan struct{}
                        var autoTossBadCode chan bool