nncp-call -list option

diff --git a/doc/cmds.texi b/doc/cmds.texi
index 9628fa0b2f2a7a41d62afce76acc35f4c30ee076..4e8210257863840baee6d6c58c84fecc09a62edb 100644 (file)
--- a/doc/cmds.texi
+++ b/doc/cmds.texi
@@ -95,6 +95,7 @@ their integrity.
     [-onlinedeadline INT]
     [-maxonlinetime INT]
     [-rx|-tx]
+    [-list]
     [-rxrate INT]
     [-txrate INT]
     NODE[:ADDR] [FORCEADDR]
@@ -113,7 +114,8 @@ only outbound transmission is performed. @option{-onlinedeadline}
 overrides @ref{CfgOnlineDeadline, @emph{onlinedeadline}}.
 @option{-maxonlinetime} overrides @ref{CfgMaxOnlineTime,
 @emph{maxonlinetime}}. @option{-rxrate}/@option{-txrate} override
-@ref{CfgXxRate, rxrate/txrate}.
+@ref{CfgXxRate, rxrate/txrate}. @option{-list} option allows you to list
+packets of remote node, without any transmission.
 
 @node nncp-caller
 @section nncp-caller

diff --git a/doc/news.ru.texi b/doc/news.ru.texi
index 4ac73b1419e4e48dd66866c9b35a76c25dd0797b..4eb8fecab28fee1d7669e185de11b3c2b102a0a4 100644 (file)
--- a/doc/news.ru.texi
+++ b/doc/news.ru.texi
@@ -14,6 +14,9 @@
 Проверка доступного места перед копированием во время работы
 @command{nncp-xfer}, @command{nncp-daemon}, @command{nncp-call(er)}.
 @item
+@command{nncp-call} теперь может только показывать список пакетов на
+удалённой машине, без их передачи.
+@item
 Зависимые библиотеки обновлены.
 @item
 Небольшие исправления ошибок.

diff --git a/doc/news.texi b/doc/news.texi
index 602942d96cddd8041aad9ab09aed21227ea44d22..571a094065f20a31912db59f264c62ec0aa583d5 100644 (file)
--- a/doc/news.texi
+++ b/doc/news.texi
@@ -15,6 +15,9 @@ decrypted data to external command. Older versions are not supported.
 Available free space checking before copying in @command{nncp-xfer},
 @command{nncp-daemon}, @command{nncp-call(er)}.
 @item
+@command{nncp-call} has ability only to listen packets on remote node,
+without its transmission.
+@item
 Dependant libraries are updated.
 @item
 Minor bugfixes.

diff --git a/src/cypherpunks.ru/nncp/call.go b/src/cypherpunks.ru/nncp/call.go
index da16fa433554bb6c8e29909a752cfb106bfd1be8..853dbaec3df58d9b5b512818c2be6d1b78bd1a9c 100644 (file)
--- a/src/cypherpunks.ru/nncp/call.go
+++ b/src/cypherpunks.ru/nncp/call.go
@@ -42,7 +42,8 @@ func (ctx *Ctx) CallNode(
        nice uint8,
        xxOnly TRxTx,
        rxRate, txRate int,
-       onlineDeadline, maxOnlineTime uint) (isGood bool) {
+       onlineDeadline, maxOnlineTime uint,
+       listOnly bool) (isGood bool) {
        for _, addr := range addrs {
                sds := SDS{"node": node.Id, "addr": addr}
                ctx.LogD("call", sds, "dialing")
@@ -61,6 +62,7 @@ func (ctx *Ctx) CallNode(
                        txRate,
                        onlineDeadline,
                        maxOnlineTime,
+                       listOnly,
                )
                if err == nil {
                        ctx.LogI("call-start", sds, "connected")

diff --git a/src/cypherpunks.ru/nncp/cmd/nncp-call/main.go b/src/cypherpunks.ru/nncp/cmd/nncp-call/main.go
index 1734539467283cde918905269a294c7ba6ee7e69..d853443e381a469cc455ad676e895707e32cb9e4 100644 (file)
--- a/src/cypherpunks.ru/nncp/cmd/nncp-call/main.go
+++ b/src/cypherpunks.ru/nncp/cmd/nncp-call/main.go
@@ -43,6 +43,7 @@ func main() {
                niceRaw   = flag.String("nice", nncp.NicenessFmt(255), "Minimal required niceness")
                rxOnly    = flag.Bool("rx", false, "Only receive packets")
                txOnly    = flag.Bool("tx", false, "Only transmit packets")
+               listOnly  = flag.Bool("list", false, "Only list remote packets")
                rxRate    = flag.Int("rxrate", 0, "Maximal receive rate, pkts/sec")
                txRate    = flag.Int("txrate", 0, "Maximal transmit rate, pkts/sec")
                spoolPath = flag.String("spool", "", "Override path to spool")
@@ -132,6 +133,7 @@ func main() {
                *txRate,
                *onlineDeadline,
                *maxOnlineTime,
+               *listOnly,
        ) {
                os.Exit(1)
        }

diff --git a/src/cypherpunks.ru/nncp/cmd/nncp-caller/main.go b/src/cypherpunks.ru/nncp/cmd/nncp-caller/main.go
index ed7ee754d717ecad043568bea22739289c3ac9e5..24334cf9b198651b6d5d60bde38f50570b006e3a 100644 (file)
--- a/src/cypherpunks.ru/nncp/cmd/nncp-caller/main.go
+++ b/src/cypherpunks.ru/nncp/cmd/nncp-caller/main.go
@@ -132,6 +132,7 @@ func main() {
                                                        call.TxRate,
                                                        call.OnlineDeadline,
                                                        call.MaxOnlineTime,
+                                                       false,
                                                )
                                                node.Lock()
                                                node.Busy = false

diff --git a/src/cypherpunks.ru/nncp/humanizer.go b/src/cypherpunks.ru/nncp/humanizer.go
index 34ec158bcd913971d810796408bbb2c64735f11e..68031d833a982174e463f3c33517f5013893c92b 100644 (file)
--- a/src/cypherpunks.ru/nncp/humanizer.go
+++ b/src/cypherpunks.ru/nncp/humanizer.go
@@ -198,6 +198,29 @@ func (ctx *Ctx) Humanize(s string) string {
                        humanize.IBytes(uint64(rx)), humanize.IBytes(uint64(rxs)),
                        humanize.IBytes(uint64(tx)), humanize.IBytes(uint64(txs)),
                )
+       case "sp-info":
+               nice, err := NicenessParse(sds["nice"])
+               if err != nil {
+                       return s
+               }
+               msg = fmt.Sprintf(
+                       "Packet %s (%s) (nice %s)",
+                       sds["hash"],
+                       size,
+                       NicenessFmt(nice),
+               )
+               offsetParsed, err := strconv.ParseUint(sds["offset"], 10, 64)
+               if err != nil {
+                       return s
+               }
+               sizeParsed, err := strconv.ParseUint(sds["size"], 10, 64)
+               if err != nil {
+                       return s
+               }
+               msg += fmt.Sprintf(": %d%%", 100*offsetParsed/sizeParsed)
+               if len(rem) > 0 {
+                       msg += ": " + rem
+               }
        case "sp-infos":
                switch sds["xx"] {
                case "rx":

diff --git a/src/cypherpunks.ru/nncp/sp.go b/src/cypherpunks.ru/nncp/sp.go
index e309b982f487903bef518fcbb25992da55666dcc..22078c55110a41dfe2096a05d317211acee07cdc 100644 (file)
--- a/src/cypherpunks.ru/nncp/sp.go
+++ b/src/cypherpunks.ru/nncp/sp.go
@@ -197,6 +197,7 @@ type SPState struct {
        rxRate         int
        txRate         int
        isDead         bool
+       listOnly       bool
        sync.RWMutex
 }
 
@@ -286,20 +287,21 @@ func (ctx *Ctx) StartI(
        nice uint8,
        xxOnly TRxTx,
        rxRate, txRate int,
-       onlineDeadline, maxOnlineTime uint) (*SPState, error) {
+       onlineDeadline, maxOnlineTime uint,
+       listOnly bool) (*SPState, error) {
        err := ctx.ensureRxDir(nodeId)
        if err != nil {
                return nil, err
        }
        var rxLock *os.File
-       if xxOnly == "" || xxOnly == TRx {
+       if !listOnly && (xxOnly == "" || xxOnly == TRx) {
                rxLock, err = ctx.LockDir(nodeId, TRx)
                if err != nil {
                        return nil, err
                }
        }
        var txLock *os.File
-       if xxOnly == "" || xxOnly == TTx {
+       if !listOnly && (xxOnly == "" || xxOnly == TTx) {
                txLock, err = ctx.LockDir(nodeId, TTx)
                if err != nil {
                        return nil, err
@@ -337,10 +339,11 @@ func (ctx *Ctx) StartI(
                xxOnly:         xxOnly,
                rxRate:         rxRate,
                txRate:         txRate,
+               listOnly:       listOnly,
        }
 
        var infosPayloads [][]byte
-       if xxOnly == "" || xxOnly == TTx {
+       if !listOnly && (xxOnly == "" || xxOnly == TTx) {
                infosPayloads = ctx.infosOur(nodeId, nice, &state.infosOurSeen)
        }
        var firstPayload []byte
@@ -543,7 +546,7 @@ func (state *SPState) StartWorkers(
                }
        }()
 
-       if state.xxOnly == "" || state.xxOnly == TTx {
+       if !state.listOnly && (state.xxOnly == "" || state.xxOnly == TTx) {
                go func() {
                        for range time.Tick(time.Second) {
                                if state.NotAlive() {
@@ -788,13 +791,14 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                        sdsp = SdsAdd(sds, SDS{
                                "hash": ToBase32(info.Hash[:]),
                                "size": strconv.FormatInt(int64(info.Size), 10),
+                               "nice": strconv.Itoa(int(info.Nice)),
                        })
-                       if info.Nice > state.nice {
+                       if !state.listOnly && info.Nice > state.nice {
                                state.ctx.LogD("sp-process", sdsp, "too nice")
                                continue
                        }
                        state.ctx.LogD("sp-process", sdsp, "received")
-                       if state.xxOnly == TTx {
+                       if !state.listOnly && state.xxOnly == TTx {
                                continue
                        }
                        state.Lock()
@@ -808,39 +812,42 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                ToBase32(info.Hash[:]),
                        )
                        if _, err = os.Stat(pktPath); err == nil {
-                               state.ctx.LogD("sp-process", sdsp, "already done")
-                               replies = append(replies, MarshalSP(SPTypeDone, SPDone{info.Hash}))
+                               state.ctx.LogI("sp-info", sdsp, "already done")
+                               if !state.listOnly {
+                                       replies = append(replies, MarshalSP(SPTypeDone, SPDone{info.Hash}))
+                               }
                                continue
                        }
                        if _, err = os.Stat(pktPath + SeenSuffix); err == nil {
-                               state.ctx.LogD("sp-process", sdsp, "already seen")
-                               replies = append(replies, MarshalSP(SPTypeDone, SPDone{info.Hash}))
+                               state.ctx.LogI("sp-info", sdsp, "already seen")
+                               if !state.listOnly {
+                                       replies = append(replies, MarshalSP(SPTypeDone, SPDone{info.Hash}))
+                               }
                                continue
                        }
                        fi, err := os.Stat(pktPath + PartSuffix)
                        var offset int64
                        if err == nil {
                                offset = fi.Size()
-                               state.ctx.LogD(
-                                       "sp-process",
-                                       SdsAdd(sdsp, SDS{"offset": strconv.FormatInt(offset, 10)}),
-                                       "part exists",
-                               )
                        }
                        if !state.ctx.IsEnoughSpace(int64(info.Size) - offset) {
-                               state.ctx.LogI("sp-process", sdsp, "not enough space")
+                               state.ctx.LogI("sp-info", sdsp, "not enough space")
                                continue
                        }
-                       replies = append(replies, MarshalSP(
-                               SPTypeFreq,
-                               SPFreq{info.Hash, uint64(offset)},
-                       ))
-               case SPTypeFile:
-                       state.ctx.LogD(
-                               "sp-process",
-                               SdsAdd(sds, SDS{"type": "file"}),
-                               "unmarshaling packet",
+                       state.ctx.LogI(
+                               "sp-info",
+                               SdsAdd(sdsp, SDS{"offset": strconv.FormatInt(offset, 10)}),
+                               "",
                        )
+                       if !state.listOnly {
+                               replies = append(replies, MarshalSP(
+                                       SPTypeFreq,
+                                       SPFreq{info.Hash, uint64(offset)},
+                               ))
+                       }
+               case SPTypeFile:
+                       sdsp := SdsAdd(sds, SDS{"type": "file"})
+                       state.ctx.LogD("sp-process", sdsp, "unmarshaling packet")
                        var file SPFile
                        if _, err = xdr.Unmarshal(r, &file); err != nil {
                                state.ctx.LogE("sp-process", SdsAdd(sds, SDS{
@@ -849,11 +856,9 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                }), "")
                                return nil, err
                        }
-                       sdsp := SdsAdd(sds, SDS{
-                               "xx":   string(TRx),
-                               "hash": ToBase32(file.Hash[:]),
-                               "size": strconv.Itoa(len(file.Payload)),
-                       })
+                       sdsp["xx"] = string(TRx)
+                       sdsp["hash"] = ToBase32(file.Hash[:])
+                       sdsp["size"] = strconv.Itoa(len(file.Payload))
                        filePath := filepath.Join(
                                state.ctx.Spool,
                                state.Node.Id.String(),
@@ -927,11 +932,8 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                }()
                        }()
                case SPTypeDone:
-                       state.ctx.LogD(
-                               "sp-process",
-                               SdsAdd(sds, SDS{"type": "done"}),
-                               "unmarshaling packet",
-                       )
+                       sdsp := SdsAdd(sds, SDS{"type": "done"})
+                       state.ctx.LogD("sp-process", sdsp, "unmarshaling packet")
                        var done SPDone
                        if _, err = xdr.Unmarshal(r, &done); err != nil {
                                state.ctx.LogE("sp-process", SdsAdd(sds, SDS{
@@ -940,7 +942,7 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                }), "")
                                return nil, err
                        }
-                       sdsp := SdsAdd(sds, SDS{"hash": ToBase32(done.Hash[:])})
+                       sdsp["hash"] = ToBase32(done.Hash[:])
                        state.ctx.LogD("sp-done", sdsp, "removing")
                        err := os.Remove(filepath.Join(
                                state.ctx.Spool,
@@ -948,10 +950,11 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                string(TTx),
                                ToBase32(done.Hash[:]),
                        ))
+                       sdsp["xx"] = string(TTx)
                        if err == nil {
-                               state.ctx.LogI("sp-done", SdsAdd(sdsp, SDS{"xx": string(TTx)}), "")
+                               state.ctx.LogI("sp-done", sdsp, "")
                        } else {
-                               state.ctx.LogE("sp-done", SdsAdd(sdsp, SDS{"xx": string(TTx)}), "")
+                               state.ctx.LogE("sp-done", sdsp, "")
                        }
                case SPTypeFreq:
                        sdsp := SdsAdd(sds, SDS{"type": "freq"})
@@ -961,10 +964,9 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                state.ctx.LogE("sp-process", SdsAdd(sdsp, SDS{"err": err}), "")
                                return nil, err
                        }
-                       state.ctx.LogD("sp-process", SdsAdd(sdsp, SDS{
-                               "hash":   ToBase32(freq.Hash[:]),
-                               "offset": strconv.FormatInt(int64(freq.Offset), 10),
-                       }), "queueing")
+                       sdsp["hash"] = ToBase32(freq.Hash[:])
+                       sdsp["offset"] = strconv.FormatInt(int64(freq.Offset), 10)
+                       state.ctx.LogD("sp-process", sdsp, "queueing")
                        nice, exists := state.infosOurSeen[*freq.Hash]
                        if exists {
                                state.Lock()
@@ -980,14 +982,10 @@ func (state *SPState) ProcessSP(payload []byte) ([][]byte, error) {
                                state.queueTheir[insertIdx] = &FreqWithNice{&freq, nice}
                                state.Unlock()
                        } else {
-                               state.ctx.LogD("sp-process", SdsAdd(sdsp, SDS{
-                                       "hash":   ToBase32(freq.Hash[:]),
-                                       "offset": strconv.FormatInt(int64(freq.Offset), 10),
-                               }), "unknown")
+                               state.ctx.LogD("sp-process", sdsp, "unknown")
                        }
                case SPTypeHalt:
-                       sdsp := SdsAdd(sds, SDS{"type": "halt"})
-                       state.ctx.LogD("sp-process", sdsp, "")
+                       state.ctx.LogD("sp-process", SdsAdd(sds, SDS{"type": "halt"}), "")
                        state.Lock()
                        state.queueTheir = nil
                        state.Unlock()