From 4906793a62626011978d37ba0d733848e8080d08 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 00:49:09 +0530 Subject: [PATCH 01/18] Bump go directive to 1.26 and upgrade dependencies Require Go 1.26 and upgrade direct dependencies to their latest releases. Drops the direct dependencies on anacrolix/multiless, bradfitz/iter, docopt-go and golang.org/x/exp in favour of the standard library. --- go.mod | 144 +++++++------ go.sum | 649 +++++++++++++++++---------------------------------------- 2 files changed, 263 insertions(+), 530 deletions(-) diff --git a/go.mod b/go.mod index 76ce8b298..28cfcb5c4 100644 --- a/go.mod +++ b/go.mod @@ -1,88 +1,98 @@ module github.com/anacrolix/dht/v2 -go 1.23 +go 1.26.0 require ( - filippo.io/edwards25519 v1.0.0-rc.1 - github.com/anacrolix/args v0.5.1-0.20220509024600-c3b77d0b61ac - github.com/anacrolix/bargle/v2 v2.0.0-20240909020204-5265698a6040 - github.com/anacrolix/chansync v0.3.0 - github.com/anacrolix/envpprof v1.2.1 - github.com/anacrolix/generics v0.0.0-20230816105729-c755655aee45 - github.com/anacrolix/gostdapp v0.1.0 - github.com/anacrolix/log v0.15.2 - github.com/anacrolix/missinggo/v2 v2.7.1 - github.com/anacrolix/multiless v0.3.1-0.20221221005021-2d12701f83f7 - github.com/anacrolix/publicip v0.2.0 - github.com/anacrolix/sync v0.4.0 - github.com/anacrolix/tagflag v1.3.0 - github.com/anacrolix/torrent v1.48.1-0.20230103142631-c20f73d53e9f - github.com/benbjohnson/immutable v0.4.1-0.20221220213129-8932b999621d - github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 + filippo.io/edwards25519 v1.2.0 + github.com/anacrolix/args v0.5.0 + github.com/anacrolix/bargle/v2 v2.0.0 + github.com/anacrolix/chansync v0.8.0 + github.com/anacrolix/envpprof v1.6.0 + github.com/anacrolix/generics v0.2.0 + github.com/anacrolix/gostdapp v0.3.0 + github.com/anacrolix/log v0.17.1-0.20251118025802-918f1157b7bb + github.com/anacrolix/missinggo/v2 v2.11.0 + github.com/anacrolix/publicip v0.3.1 + github.com/anacrolix/sync v0.6.0 + github.com/anacrolix/tagflag v1.4.0 + github.com/anacrolix/torrent v1.61.0 + github.com/benbjohnson/immutable v0.4.3 github.com/davecgh/go-spew v1.1.1 - github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 github.com/go-quicktest/qt v1.102.0 - github.com/multiformats/go-base36 v0.1.0 - github.com/rs/dnscache v0.0.0-20211102005908-e0241e321417 - golang.org/x/exp v0.0.0-20221217163422-3c43f8badb15 - golang.org/x/sys v0.6.0 - golang.org/x/time v0.0.0-20220609170525-579cf78fd858 + github.com/multiformats/go-base36 v0.2.0 + github.com/rs/dnscache v0.0.0-20230804202142-fc85eb664529 + golang.org/x/sys v0.48.0 + golang.org/x/time v0.16.0 ) require ( github.com/anacrolix/backtrace v0.0.0-20221205112523-22a61db8f82e // indirect github.com/anacrolix/missinggo v1.3.0 // indirect github.com/anacrolix/missinggo/perf v1.0.0 // indirect - github.com/cenkalti/backoff/v4 v4.1.3 // indirect + github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 // indirect + github.com/cenkalti/backoff/v5 v5.0.3 // indirect github.com/dustin/go-humanize v1.0.0 // indirect + github.com/ebitengine/purego v0.9.1 // indirect github.com/edsrzf/mmap-go v1.1.0 // indirect - github.com/go-logr/logr v1.2.3 // indirect + github.com/felixge/fgprof v0.9.5 // indirect + github.com/go-logr/logr v1.4.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/go-ole/go-ole v1.2.6 // indirect - github.com/golang/protobuf v1.5.3 // indirect - github.com/google/go-cmp v0.6.0 // indirect - github.com/grpc-ecosystem/grpc-gateway/v2 v2.12.0 // indirect - github.com/honeycombio/honeycomb-opentelemetry-go v0.3.0 // indirect - github.com/honeycombio/opentelemetry-go-contrib/launcher v0.0.0-20221031150637-a3c60ed98d54 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/google/go-cmp v0.7.0 // indirect + github.com/google/pprof v0.0.0-20240227163752-401108e1b7e7 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 // indirect + github.com/honeycombio/honeycomb-opentelemetry-go v0.11.0 // indirect + github.com/honeycombio/otel-config-go v1.17.0 // indirect github.com/huandu/xstrings v1.3.2 // indirect + github.com/klauspost/cpuid/v2 v2.2.3 // indirect github.com/kr/pretty v0.3.1 // indirect github.com/kr/text v0.2.0 // indirect - github.com/lufia/plan9stats v0.0.0-20220913051719-115f729f3c8c // indirect + github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 // indirect + github.com/minio/sha256-simd v1.0.0 // indirect + github.com/mr-tron/base58 v1.2.0 // indirect + github.com/multiformats/go-multihash v0.2.3 // indirect + github.com/multiformats/go-varint v0.0.6 // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/power-devops/perfstat v0.0.0-20220216144756-c35f1ee13d7c // indirect - github.com/rogpeppe/go-internal v1.12.0 // indirect - github.com/sethvargo/go-envconfig v0.8.2 // indirect - github.com/shirou/gopsutil/v3 v3.22.9 // indirect - github.com/tklauser/go-sysconf v0.3.10 // indirect - github.com/tklauser/numcpus v0.5.0 // indirect - github.com/yusufpapurcu/wmi v1.2.2 // indirect - go.opentelemetry.io/contrib/instrumentation/host v0.36.4 // indirect - go.opentelemetry.io/contrib/instrumentation/runtime v0.36.4 // indirect - go.opentelemetry.io/contrib/propagators/b3 v1.11.1 // indirect - go.opentelemetry.io/contrib/propagators/ot v1.11.1 // indirect - go.opentelemetry.io/otel v1.11.1 // indirect - go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.11.1 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.33.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.33.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v0.33.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.11.1 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.11.1 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.11.1 // indirect - go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.11.1 // indirect - go.opentelemetry.io/otel/metric v0.33.0 // indirect - go.opentelemetry.io/otel/sdk v1.11.1 // indirect - go.opentelemetry.io/otel/sdk/metric v0.33.0 // indirect - go.opentelemetry.io/otel/trace v1.11.1 // indirect - go.opentelemetry.io/proto/otlp v0.19.0 // indirect - go.uber.org/atomic v1.10.0 // indirect - go.uber.org/multierr v1.8.0 // indirect - golang.org/x/net v0.8.0 // indirect - golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 // indirect - golang.org/x/text v0.8.0 // indirect + github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect + github.com/rogpeppe/go-internal v1.14.1 // indirect + github.com/sethvargo/go-envconfig v1.3.0 // indirect + github.com/shirou/gopsutil/v4 v4.25.10 // indirect + github.com/spaolacci/murmur3 v1.1.0 // indirect + github.com/tklauser/go-sysconf v0.3.16 // indirect + github.com/tklauser/numcpus v0.11.0 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect + go.opentelemetry.io/auto/sdk v1.2.1 // indirect + go.opentelemetry.io/contrib/instrumentation/host v0.63.0 // indirect + go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0 // indirect + go.opentelemetry.io/contrib/processors/baggage/baggagetrace v0.1.0 // indirect + go.opentelemetry.io/contrib/processors/baggagecopy v0.11.0 // indirect + go.opentelemetry.io/contrib/propagators/b3 v1.38.0 // indirect + go.opentelemetry.io/contrib/propagators/ot v1.38.0 // indirect + go.opentelemetry.io/otel v1.38.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.38.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 // indirect + go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.38.0 // indirect + go.opentelemetry.io/otel/log v0.14.0 // indirect + go.opentelemetry.io/otel/metric v1.38.0 // indirect + go.opentelemetry.io/otel/sdk v1.38.0 // indirect + go.opentelemetry.io/otel/sdk/log v0.14.0 // indirect + go.opentelemetry.io/otel/sdk/metric v1.38.0 // indirect + go.opentelemetry.io/otel/trace v1.38.0 // indirect + go.opentelemetry.io/proto/otlp v1.9.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + golang.org/x/crypto v0.44.0 // indirect + golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6 // indirect + golang.org/x/net v0.47.0 // indirect + golang.org/x/sync v0.18.0 // indirect + golang.org/x/text v0.31.0 // indirect golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f // indirect - google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20230526203410-71b5a4ffd15e // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e // indirect - google.golang.org/grpc v1.55.0 // indirect - google.golang.org/protobuf v1.30.0 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20251124214823-79d6a2a48846 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 // indirect + google.golang.org/grpc v1.77.0 // indirect + google.golang.org/protobuf v1.36.10 // indirect + lukechampine.com/blake3 v1.1.6 // indirect ) diff --git a/go.sum b/go.sum index 9603679cd..0d9ec2b0c 100644 --- a/go.sum +++ b/go.sum @@ -1,43 +1,10 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= -cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= -cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= -cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= -cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= -cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= -cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= -cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= -cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= -cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= -cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= -cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= -cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= -cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= -cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= -cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= -cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= -cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= -cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= -cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= -cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= -cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= -cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= -cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= -cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= -cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= -cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= -cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= -cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= -cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= crawshaw.io/iox v0.0.0-20181124134642-c51c3df30797/go.mod h1:sXBiorCo8c46JlQV3oXPKINnZ8mcqnye1EkVkqsectk= crawshaw.io/sqlite v0.3.2/go.mod h1:igAO5JulrQ1DbdZdtVq48mnZUBAPOeFzer7VhDWNtW4= -dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= -filippo.io/edwards25519 v1.0.0-rc.1 h1:m0VOOB23frXZvAOK44usCgLWvtsxIoMCTBGJZlpmGfU= -filippo.io/edwards25519 v1.0.0-rc.1/go.mod h1:N1IkdkCkiLB6tki+MYJoSx2JTY9NUlxZE7eHn5EwJns= +filippo.io/edwards25519 v1.2.0 h1:crnVqOiS4jqYleHd9vaKZ+HKtHfllngJIiOpNpoJsjo= +filippo.io/edwards25519 v1.2.0/go.mod h1:xzAOLCNug/yB62zG1bQ8uziwrIqIuxhctzJT18Q77mc= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= -github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/RoaringBitmap/roaring v0.4.7/go.mod h1:8khRDP4HmeXns4xIj9oGrKSz7XTQiJx2zgh7AcNke4w= github.com/RoaringBitmap/roaring v0.4.17/go.mod h1:D3qVegWTmfCaX4Bl5CrBE9hfrSrrXIr8KVNvRsDi1NI= github.com/RoaringBitmap/roaring v0.4.23/go.mod h1:D0gp8kJQgE1A4LQ5wFLggQEyvDi06Mq5mKs52e1TwOo= @@ -47,29 +14,27 @@ github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuy github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= -github.com/alexflint/go-arg v1.4.2/go.mod h1:9iRbDxne7LcR/GSvEr7ma++GLpdIU1zrghf2y2768kM= -github.com/alexflint/go-scalar v1.0.0/go.mod h1:GpHzbCOZXEKMEcygYQ5n/aa4Aq84zbxjy3MxYW0gjYw= -github.com/anacrolix/args v0.5.1-0.20220509024600-c3b77d0b61ac h1:XWoepbk3zgOQ8jMO3vpOnohd6MfENPbFZPivB2L7myc= -github.com/anacrolix/args v0.5.1-0.20220509024600-c3b77d0b61ac/go.mod h1:Fj/N2PehEwTBE5t/V/9xgTcxDkuYQ+5IBoFw/8gkldI= +github.com/anacrolix/args v0.5.0 h1:bZCkbtn4QMB4ow2g34R/oqTFwrI6IojysKop6+ZcOSs= +github.com/anacrolix/args v0.5.0/go.mod h1:Fj/N2PehEwTBE5t/V/9xgTcxDkuYQ+5IBoFw/8gkldI= github.com/anacrolix/backtrace v0.0.0-20221205112523-22a61db8f82e h1:A0Ty9UeyBDIo29ZMnk0AvPqWDIa4HVvCaJqWNlCrMXA= github.com/anacrolix/backtrace v0.0.0-20221205112523-22a61db8f82e/go.mod h1:4YFqy+788tLJWtin2jNliYVJi+8aDejG9zcu/2/pONw= -github.com/anacrolix/bargle/v2 v2.0.0-20240909020204-5265698a6040 h1:gneDM+Y60h9YY5xyG1buJss/OWjBZa+eYFO/Go3e7ro= -github.com/anacrolix/bargle/v2 v2.0.0-20240909020204-5265698a6040/go.mod h1:rKvwnOHgcXKPJTINj5RmkifgpxgEGC9bkJiv5kM4ctM= -github.com/anacrolix/chansync v0.3.0 h1:lRu9tbeuw3wl+PhMu/r+JJCRu5ArFXIluOgdF0ao6/U= -github.com/anacrolix/chansync v0.3.0/go.mod h1:DZsatdsdXxD0WiwcGl0nJVwyjCKMDv+knl1q2iBjA2k= +github.com/anacrolix/bargle/v2 v2.0.0 h1:jeKsKOCiAWKMi0HJdlrux/+V12I7PVX5dny/HxQ3xZw= +github.com/anacrolix/bargle/v2 v2.0.0/go.mod h1:rKvwnOHgcXKPJTINj5RmkifgpxgEGC9bkJiv5kM4ctM= +github.com/anacrolix/chansync v0.8.0 h1:Z/YLVXRDMTy3jFfHKSwzCRVD88ldnFoM4THdWqLjNxM= +github.com/anacrolix/chansync v0.8.0/go.mod h1:RT3KIkmAanMPsiKC/HTBOrSlgB4TQ8DW8dxgDOnQGsg= github.com/anacrolix/envpprof v0.0.0-20180404065416-323002cec2fa/go.mod h1:KgHhUaQMc8cC0+cEflSgCFNFbKwi5h54gqtVn8yhP7c= github.com/anacrolix/envpprof v1.0.0/go.mod h1:KgHhUaQMc8cC0+cEflSgCFNFbKwi5h54gqtVn8yhP7c= github.com/anacrolix/envpprof v1.1.0/go.mod h1:My7T5oSqVfEn4MD4Meczkw/f5lSIndGAKu/0SM/rkf4= -github.com/anacrolix/envpprof v1.2.1 h1:25TJe6t/i0AfzzldiGFKCpD+s+dk8lONBcacJZB2rdE= -github.com/anacrolix/envpprof v1.2.1/go.mod h1:My7T5oSqVfEn4MD4Meczkw/f5lSIndGAKu/0SM/rkf4= -github.com/anacrolix/generics v0.0.0-20230816105729-c755655aee45 h1:Kmcl3I9K2+5AdnnR7hvrnVT0TLeFWWMa9bxnm55aVIg= -github.com/anacrolix/generics v0.0.0-20230816105729-c755655aee45/go.mod h1:ff2rHB/joTV03aMSSn/AZNnaIpUw0h3njetGsaXcMy8= -github.com/anacrolix/gostdapp v0.1.0 h1:sZC+gSLhA7Hdalak5rPCkhO0YSEl0tt/lsovxh6qka4= -github.com/anacrolix/gostdapp v0.1.0/go.mod h1:2pstbgWcpBCY3rFUldM0NbDCrP86vWsh61wj8yY517E= +github.com/anacrolix/envpprof v1.6.0 h1:PaLpAyn7p56DJJFIsMBH/6M8QJrrLl94kZ2REJeZ1ew= +github.com/anacrolix/envpprof v1.6.0/go.mod h1:+DpWtwPY0MrphcvsEaal3Y5gybePAmd/Y4axV0/EQrI= +github.com/anacrolix/generics v0.2.0 h1:gPwGOs14irokFN9kUP1i1A0Bn0FPT7/hWWD3hHKSKNw= +github.com/anacrolix/generics v0.2.0/go.mod h1:NGehhfeXJPBujPx0s6cstSj8B+TERsTY32Xckfx5ftc= +github.com/anacrolix/gostdapp v0.3.0 h1:DodiMqK090HI9Zj9htFvcOONOdHgSQBuVCqF5QGC+PU= +github.com/anacrolix/gostdapp v0.3.0/go.mod h1:HamXfNHg2qYDW7Trq9N8zPqhQGFocF/TLB1NngI6mAM= github.com/anacrolix/log v0.3.0/go.mod h1:lWvLTqzAnCWPJA08T2HCstZi0L1y2Wyvm3FJgwU9jwU= github.com/anacrolix/log v0.6.0/go.mod h1:lWvLTqzAnCWPJA08T2HCstZi0L1y2Wyvm3FJgwU9jwU= -github.com/anacrolix/log v0.15.2 h1:LTSf5Wm6Q4GNWPFMBP7NPYV6UBVZzZLKckL+/Lj72Oo= -github.com/anacrolix/log v0.15.2/go.mod h1:m0poRtlr41mriZlXBQ9SOVZ8yZBkLjOkDhd5Li5pITA= +github.com/anacrolix/log v0.17.1-0.20251118025802-918f1157b7bb h1:nGNLCQbxFQZz7/9PXLGQ9GmavI/W+eX66pSwVeUwugU= +github.com/anacrolix/log v0.17.1-0.20251118025802-918f1157b7bb/go.mod h1:YjBZbwe2v3RsU7WdoBlVSPVpfKuOAno9SRQ/8tIl+hk= github.com/anacrolix/missinggo v1.1.0/go.mod h1:MBJu3Sk/k3ZfGYcS7z18gwfu72Ey/xopPFJJbTi5yIo= github.com/anacrolix/missinggo v1.1.2-0.20190815015349-b888af804467/go.mod h1:MBJu3Sk/k3ZfGYcS7z18gwfu72Ey/xopPFJJbTi5yIo= github.com/anacrolix/missinggo v1.2.1/go.mod h1:J5cMhif8jPmFoC3+Uvob3OXXNIhOUikzMt+uUjeM21Y= @@ -79,28 +44,25 @@ github.com/anacrolix/missinggo/perf v1.0.0 h1:7ZOGYziGEBytW49+KmYGTaNfnwUqP1HBsy github.com/anacrolix/missinggo/perf v1.0.0/go.mod h1:ljAFWkBuzkO12MQclXzZrosP5urunoLS0Cbvb4V0uMQ= github.com/anacrolix/missinggo/v2 v2.2.0/go.mod h1:o0jgJoYOyaoYQ4E2ZMISVa9c88BbUBVQQW4QeRkNCGY= github.com/anacrolix/missinggo/v2 v2.5.1/go.mod h1:WEjqh2rmKECd0t1VhQkLGTdIWXO6f6NLjp5GlMZ+6FA= -github.com/anacrolix/missinggo/v2 v2.7.1 h1:Y+wL0JC6D2icpwhDpcrRM4THQB/uFcPNYUtZMbYvQgI= -github.com/anacrolix/missinggo/v2 v2.7.1/go.mod h1:2IZIvmRTizALNYFYXsPR7ofXPzJgyBpKZ4kMqMEICkI= -github.com/anacrolix/multiless v0.3.1-0.20221221005021-2d12701f83f7 h1:lOtCD+LzoD1g7bowhYJNR++uV+FyY5bTZXKwnPex9S8= -github.com/anacrolix/multiless v0.3.1-0.20221221005021-2d12701f83f7/go.mod h1:zJv1JF9AqdZiHwxqPgjuOZDGWER6nyE48WBCi/OOrMM= -github.com/anacrolix/publicip v0.2.0 h1:n/BmRxXRlOT/wQFd6Xhu57r9uTU+Xvb9MyEkLooh3TU= -github.com/anacrolix/publicip v0.2.0/go.mod h1:67G1lVkLo8UjdEcJkwScWVTvlJ35OCDsRJoWXl/wi4g= +github.com/anacrolix/missinggo/v2 v2.6.0/go.mod h1:2IZIvmRTizALNYFYXsPR7ofXPzJgyBpKZ4kMqMEICkI= +github.com/anacrolix/missinggo/v2 v2.11.0 h1:9vYHTNHa5q8tLeDbA6XWFyYeKrxrhfw7GZe9KpS2Wnw= +github.com/anacrolix/missinggo/v2 v2.11.0/go.mod h1:gcZICf9xhHZEuLIaxXG1gRg4hpbL7lqgVrq5jsYtQU4= +github.com/anacrolix/publicip v0.3.1 h1:a8tXUS4L6dG3mBFp4ZhvzmEztEEPThJDLTaF2KOAz0g= +github.com/anacrolix/publicip v0.3.1/go.mod h1:tF1kAG96Ao3t9Q8zyfA7Lso1wOEfHHEcZQTRI+PMm4k= github.com/anacrolix/stm v0.2.0/go.mod h1:zoVQRvSiGjGoTmbM0vSLIiaKjWtNPeTvXUSdJQA4hsg= -github.com/anacrolix/sync v0.3.0/go.mod h1:BbecHL6jDSExojhNtgTFSBcdGerzNc64tz3DCOj/I0g= -github.com/anacrolix/sync v0.4.0 h1:T+MdO/u87ir/ijWsTFsPYw5jVm0SMm4kVpg8t4KF38o= -github.com/anacrolix/sync v0.4.0/go.mod h1:BbecHL6jDSExojhNtgTFSBcdGerzNc64tz3DCOj/I0g= +github.com/anacrolix/sync v0.6.0 h1:W8jXs9tlj/oHhvLys2Cu8ncDAw6NVjm413t0BHp3LVo= +github.com/anacrolix/sync v0.6.0/go.mod h1:zigHZiBXkcjo9uNACGCpovT+wNKMbzjO1qN2+eehq8Y= github.com/anacrolix/tagflag v0.0.0-20180109131632-2146c8d41bf0/go.mod h1:1m2U/K6ZT+JZG0+bdMK6qauP49QT4wE5pmhJXOKKCHw= github.com/anacrolix/tagflag v1.0.0/go.mod h1:1m2U/K6ZT+JZG0+bdMK6qauP49QT4wE5pmhJXOKKCHw= github.com/anacrolix/tagflag v1.1.0/go.mod h1:Scxs9CV10NQatSmbyjqmqmeQNwGzlNe0CMUMIxqHIG8= -github.com/anacrolix/tagflag v1.3.0 h1:5NI+9CniDnEH0BWA4UcQbERyFPjKJqZnVkItGVIDy/s= -github.com/anacrolix/tagflag v1.3.0/go.mod h1:Scxs9CV10NQatSmbyjqmqmeQNwGzlNe0CMUMIxqHIG8= -github.com/anacrolix/torrent v1.48.1-0.20230103142631-c20f73d53e9f h1:5fPzkRgj1BFYzQinFQqilCPM9A/EuPUXzSC3utjMVGc= -github.com/anacrolix/torrent v1.48.1-0.20230103142631-c20f73d53e9f/go.mod h1:PwdFzmApEr96LcqogJhuw41XOdd1oHGkp+qE9hhXyDc= -github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/anacrolix/tagflag v1.4.0 h1:OlpkharT7bRqLyMkZs0XAkdb2QM/eG7Aagg0c/8Kijs= +github.com/anacrolix/tagflag v1.4.0/go.mod h1:jNpc4zGvJgIXIw9xcOtYLMz4iSRYn1XKUkTlbPwwZGg= +github.com/anacrolix/torrent v1.61.0 h1:vxo+B4SwnoP5AQWbhvnTYIaTgPSX+llYUVuQVsN4Jg8= +github.com/anacrolix/torrent v1.61.0/go.mod h1:yKUKuZSSDdyOsCbuH+rDOpswl/g546gICapdrU7aUmQ= github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= github.com/benbjohnson/immutable v0.2.0/go.mod h1:uc6OHo6PN2++n98KHLxW8ef4W42ylHiQSENghE1ezxI= -github.com/benbjohnson/immutable v0.4.1-0.20221220213129-8932b999621d h1:2qVb9bsAMtmAfnxXltm+6eBzrrS7SZ52c3SedsulaMI= -github.com/benbjohnson/immutable v0.4.1-0.20221220213129-8932b999621d/go.mod h1:iAr8OjJGLnLmVUr9MZ/rz4PWUy6Ouc2JLYuMArmvAJM= +github.com/benbjohnson/immutable v0.4.3 h1:GYHcksoJ9K6HyAUpGxwZURrbTkXA0Dh4otXGqbhdrjA= +github.com/benbjohnson/immutable v0.4.3/go.mod h1:qJIKKSmdqz1tVzNtst1DZzvaqOU1onk1rc03IeM3Owk= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= @@ -108,27 +70,20 @@ github.com/bradfitz/iter v0.0.0-20140124041915-454541ec3da2/go.mod h1:PyRFw1Lt2w github.com/bradfitz/iter v0.0.0-20190303215204-33e6a9893b0c/go.mod h1:PyRFw1Lt2wKX4ZVSQ2mk+PeDa1rxyObEDlApuIsUKuo= github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 h1:GKTyiRCL6zVf5wWaqKnf+7Qs6GbEPfd4iMOitWzXJx8= github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8/go.mod h1:spo1JLcs67NmW1aVLEgtA8Yy1elc+X8y5SRW1sFW4Og= -github.com/cenkalti/backoff/v4 v4.1.3 h1:cFAlzYUlVYDysBEH2T5hyJZMh3+5+WCBvSnK6Q8UtC4= -github.com/cenkalti/backoff/v4 v4.1.3/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= -github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= +github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM= +github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= -github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= -github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/chromedp/cdproto v0.0.0-20230802225258-3cf4e6d46a89/go.mod h1:GKljq0VrfU4D5yc+2qA6OVr8pmO/MBbPEWqWQ/oqGEs= +github.com/chromedp/chromedp v0.9.2/go.mod h1:LkSXJKONWTCHAfQasKFUZI+mxqS4tZqhmtGzzhLsnLs= +github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww= +github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ= +github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk= +github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= -github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= -github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= -github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 h1:bWDMxwH3px2JBh6AyO7hdCn/PkvCZXii8TGj7sbtEbQ= github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= github.com/dustin/go-humanize v0.0.0-20180421182945-02af3965c54e/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo= @@ -136,164 +91,138 @@ github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25Kn github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs= github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU= github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= +github.com/ebitengine/purego v0.9.1 h1:a/k2f2HQU3Pi399RPW1MOaZyhKJL9w/xFpKAg4q1s0A= +github.com/ebitengine/purego v0.9.1/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= github.com/edsrzf/mmap-go v1.1.0 h1:6EUwBLQ/Mcr1EYLE4Tn1VdW1A4ckqCQWZBw8Hr0kjpQ= github.com/edsrzf/mmap-go v1.1.0/go.mod h1:19H/e8pUPLicwkyNgOykDXkJ9F0MHE+Z52B8EIth78Q= -github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= -github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= -github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= -github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= -github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= -github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/felixge/fgprof v0.9.5 h1:8+vR6yu2vvSKn08urWyEuxx75NWPEvybbkBirEpsbVY= +github.com/felixge/fgprof v0.9.5/go.mod h1:yKl+ERSa++RYOs32d8K6WEXCB4uXdLls4ZaZPpayhMM= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/glycerine/go-unsnap-stream v0.0.0-20180323001048-9f0cb55181dd/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE= github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE= github.com/glycerine/go-unsnap-stream v0.0.0-20190901134440-81cf024a9e0a/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE= github.com/glycerine/goconvey v0.0.0-20180728074245-46e3a41ad493/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24= github.com/glycerine/goconvey v0.0.0-20190315024820-982ee783a72e/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24= github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24= -github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= -github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= -github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0= -github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= +github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= github.com/go-quicktest/qt v1.102.0 h1:HSQxCeh5YZH3EL3W39ixjtyaEhcWSXQHtHnMBzSs474= github.com/go-quicktest/qt v1.102.0/go.mod h1:p4lGIVX+8Wa6ZPNDvqcxq36XpUDLh42FLetFU7odllI= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM= +github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw= +github.com/gobwas/ws v1.2.1/go.mod h1:hRKAFb8wOxFROYNsT1bqfWnhX+b5MFeJM9r2ZSwg/KY= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= -github.com/golang/glog v1.1.0 h1:/d3pCKDPWNnvIWe0vVUpNP32qc8U3PDVxySP/y360qE= -github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP3NQ= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= -github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= -github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= -github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= -github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= -github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= -github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/btree v0.0.0-20180124185431-e89373fe6b4a/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= -github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= -github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= -github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= -github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= -github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/google/pprof v0.0.0-20240227163752-401108e1b7e7 h1:y3N7Bm7Y9/CtpiVkw/ZWj6lSlDF3F74SfKwfTCer72Q= +github.com/google/pprof v0.0.0-20240227163752-401108e1b7e7/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gopherjs/gopherjs v0.0.0-20190309154008-847fc94819f9/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= -github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.12.0 h1:kr3j8iIMR4ywO/O0rvksXaJvauGGCMg2zAZIiNZ9uIQ= -github.com/grpc-ecosystem/grpc-gateway/v2 v2.12.0/go.mod h1:ummNFgdgLhhX7aIiy35vVmQNS0rWXknfPE0qe6fmFXg= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/honeycombio/honeycomb-opentelemetry-go v0.3.0 h1:3qotL5cFNAiuLk/YZsUGNmz9ywnXqGP9hGFQoNo5PdA= -github.com/honeycombio/honeycomb-opentelemetry-go v0.3.0/go.mod h1:qzzIv/RAGWhyRgyRwwRaxmn5tZMkc/bbTX3zit4sBGI= -github.com/honeycombio/opentelemetry-go-contrib/launcher v0.0.0-20221031150637-a3c60ed98d54 h1:CFyJMKF0jR2dv+3Cpj/GuRa5XBXKnJqiqmWMYifTzok= -github.com/honeycombio/opentelemetry-go-contrib/launcher v0.0.0-20221031150637-a3c60ed98d54/go.mod h1:30UdGSqrIP+QzOGVyFiK6konkG1bQzs342GvLicmmnY= +github.com/honeycombio/honeycomb-opentelemetry-go v0.11.0 h1:x0DndAGP+m1rk9JrlPLnrnAjJotoq/EbWtg9agwnl7I= +github.com/honeycombio/honeycomb-opentelemetry-go v0.11.0/go.mod h1:2DZt7DdTnnd1o7biwC9Ab0Z3OAGXId56gYVPR7LsLQs= +github.com/honeycombio/otel-config-go v1.17.0 h1:3/zig0L3IGnfgiCrEfAwBsM0rF57+TKTyJ/a8yqW2eM= +github.com/honeycombio/otel-config-go v1.17.0/go.mod h1:g2mMdfih4sYKfXBtz2mNGvo3HiQYqX4Up4pdA8JOF2s= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/huandu/xstrings v1.0.0/go.mod h1:4qWG/gcEcfX4z/mBDHJ++3ReCw9ibxbsNJbcucJdbSo= github.com/huandu/xstrings v1.2.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63UyNX5k4= github.com/huandu/xstrings v1.3.1/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= github.com/huandu/xstrings v1.3.2 h1:L18LIDzqlW6xN2rEkpdV8+oL/IXWJ1APd+vsdYy4Wdw= github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= -github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20230524184225-eabc099b10ab/go.mod h1:gx7rwoVhcfuVKG5uya9Hs3Sxj7EIvldVofAWIUtGouw= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= -github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU= +github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= -github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I= -github.com/lufia/plan9stats v0.0.0-20220913051719-115f729f3c8c h1:VtwQ41oftZwlMnOEbMWQtSEUgU64U4s+GHk7hZK+jtY= -github.com/lufia/plan9stats v0.0.0-20220913051719-115f729f3c8c/go.mod h1:JKx41uQRwqlTZabZc+kILPrO/3jlKnQ2Z8b7YiVw5cE= +github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs= +github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 h1:PwQumkgq4/acIiZhtifTV5OUqqiP82UAl0h87xj/l9k= +github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= +github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g= +github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= +github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg= github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOlotKw= -github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4= -github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM= +github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0= +github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4= +github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U= +github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM= +github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY= +github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw= +github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0= github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= @@ -303,9 +232,8 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= -github.com/power-devops/perfstat v0.0.0-20220216144756-c35f1ee13d7c h1:NRoLoZvkBTKvR5gQLgA3e0hqjkY9u1wm+iOL45VN/qI= -github.com/power-devops/perfstat v0.0.0-20220216144756-c35f1ee13d7c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= +github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= @@ -313,7 +241,6 @@ github.com/prometheus/client_golang v1.5.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3O github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= @@ -324,25 +251,26 @@ github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsT github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4= -github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= -github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= +github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= -github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= -github.com/rs/dnscache v0.0.0-20211102005908-e0241e321417 h1:Lt9DzQALzHoDwMBGJ6v8ObDPR0dzr2a6sXTB1Fq7IHs= -github.com/rs/dnscache v0.0.0-20211102005908-e0241e321417/go.mod h1:qe5TWALJ8/a1Lqznoc5BDHpYX/8HU60Hm2AwRmqzxqA= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/rs/dnscache v0.0.0-20230804202142-fc85eb664529 h1:18kd+8ZUlt/ARXhljq+14TwAoKa61q6dX8jtwOf6DH8= +github.com/rs/dnscache v0.0.0-20230804202142-fc85eb664529/go.mod h1:qe5TWALJ8/a1Lqznoc5BDHpYX/8HU60Hm2AwRmqzxqA= github.com/ryszard/goskiplist v0.0.0-20150312221310-2dfbae5fcf46/go.mod h1:uAQ5PCi+MFsC7HjREoAz1BU+Mq60+05gifQSsHSDG/8= -github.com/sethvargo/go-envconfig v0.8.2 h1:DDUVuG21RMgeB/bn4leclUI/837y6cQCD4w8hb5797k= -github.com/sethvargo/go-envconfig v0.8.2/go.mod h1:Iz1Gy1Sf3T64TQlJSvee81qDhf7YIlt8GMUX6yyNFs0= -github.com/shirou/gopsutil/v3 v3.22.9 h1:yibtJhIVEMcdw+tCTbOPiF1VcsuDeTE4utJ8Dm4c5eA= -github.com/shirou/gopsutil/v3 v3.22.9/go.mod h1:bBYl1kjgEJpWpxeHmLI+dVHWtyAwfcmSBLDsp2TNT8A= +github.com/sethvargo/go-envconfig v1.3.0 h1:gJs+Fuv8+f05omTpwWIu6KmuseFAXKrIaOZSh8RMt0U= +github.com/sethvargo/go-envconfig v1.3.0/go.mod h1:JLd0KFWQYzyENqnEPWWZ49i4vzZo/6nRidxI8YvGiHw= +github.com/shirou/gopsutil/v4 v4.25.10 h1:at8lk/5T1OgtuCp+AwrDofFRjnvosn0nkN2OLQ6g8tA= +github.com/shirou/gopsutil/v4 v4.25.10/go.mod h1:+kSwyC8DRUD9XXEHCAFjK+0nuArFJM0lva+StQAcskM= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= github.com/smartystreets/assertions v0.0.0-20190215210624-980c5ac6f3ac/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s= github.com/smartystreets/goconvey v0.0.0-20190306220146-200a235640ff/go.mod h1:KSQcGKpxUMHk3nbYzs/tIBAM2iDooCn0BmttHOJEbLs= -github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= +github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= @@ -350,116 +278,84 @@ github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= -github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE= github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE= github.com/tinylib/msgp v1.1.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE= -github.com/tklauser/go-sysconf v0.3.10 h1:IJ1AZGZRWbY8T5Vfk04D9WOA5WSejdflXxP03OUqALw= -github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYaQ2hGm7jmxEFk= -github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ= -github.com/tklauser/numcpus v0.5.0 h1:ooe7gN0fg6myJ0EKoTAf5hebTZrH52px3New/D9iJ+A= -github.com/tklauser/numcpus v0.5.0/go.mod h1:OGzpTxpcIMNGYQdit2BYL1pvk/dSOaJWjKoflh+RQjo= +github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA= +github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI= +github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw= +github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ= github.com/willf/bitset v1.1.9/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= -github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yusufpapurcu/wmi v1.2.2 h1:KBNDSne4vP5mbSWnJbO+51IMOXJB67QiYCSBrubbPRg= -github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= -go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= -go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= -go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opentelemetry.io/contrib/instrumentation/host v0.36.4 h1:2D0q/69KewnkCkOI9I9uXgi1XQXvwQIfMebMcPft0no= -go.opentelemetry.io/contrib/instrumentation/host v0.36.4/go.mod h1:IQdse+GFHec/g2M4wtj6cE4uA5PJGQjjXP/602LjHBQ= -go.opentelemetry.io/contrib/instrumentation/runtime v0.36.4 h1:7AY5NdRzyU5s1ek3E4VK3FBnPtQ6La1i7sIn9hNgjsk= -go.opentelemetry.io/contrib/instrumentation/runtime v0.36.4/go.mod h1:yFSLOnffweT7Es+IzY1DF5KP0xa2Wl15SJfKqAyDXq8= -go.opentelemetry.io/contrib/propagators/b3 v1.11.1 h1:icQ6ttRV+r/2fnU46BIo/g/mPu6Rs5Ug8Rtohe3KqzI= -go.opentelemetry.io/contrib/propagators/b3 v1.11.1/go.mod h1:ECIveyMXgnl4gorxFcA7RYjJY/Ql9n20ubhbfDc3QfA= -go.opentelemetry.io/contrib/propagators/ot v1.11.1 h1:iezQwYW2sAaXwbXXA6Zg+PLjNnzc+M4hLKvOR6Q/CvI= -go.opentelemetry.io/contrib/propagators/ot v1.11.1/go.mod h1:oBced35DewKV7xvvIWC/oCaCFvthvTa6zjyvP2JhPAY= -go.opentelemetry.io/otel v1.11.1 h1:4WLLAmcfkmDk2ukNXJyq3/kiz/3UzCaYq6PskJsaou4= -go.opentelemetry.io/otel v1.11.1/go.mod h1:1nNhXBbWSD0nsL38H6btgnFN2k4i0sNLHNNMZMSbUGE= -go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.11.1 h1:X2GndnMCsUPh6CiY2a+frAbNsXaPLbB0soHRYhAZ5Ig= -go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.11.1/go.mod h1:i8vjiSzbiUC7wOQplijSXMYUpNM93DtlS5CbUT+C6oQ= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.33.0 h1:OT/UjHcjog4A1s1UMCtyehIKS+vpjM5Du0r7KGsH6TE= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.33.0/go.mod h1:0XctNDHEWmiSDIU8NPbJElrK05gBJFcYlGP4FMGo4g4= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.33.0 h1:1SVtGtRsNyGgv1fRfNXfh+sJowIwzF0gkf+61lvTgdg= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.33.0/go.mod h1:ryB27ubOBXsiqfh6MwtSdx5knzbSZtjvPnMMmt3AykQ= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v0.33.0 h1:NoG4v01cdLZfOeNGBQmSe4f4SeP+fx8I/0qzRgTKsGI= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v0.33.0/go.mod h1:6anbDXBcTp3Qit87pfFmT0paxTJ8sWRccTNYVywN/H8= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.11.1 h1:MEQNafcNCB0uQIti/oHgU7CZpUMYQ7qigBwMVKycHvc= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.11.1/go.mod h1:19O5I2U5iys38SsmT2uDJja/300woyzE1KPIQxEUBUc= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.11.1 h1:LYyG/f1W/jzAix16jbksJfMQFpOH/Ma6T639pVPMgfI= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.11.1/go.mod h1:QrRRQiY3kzAoYPNLP0W/Ikg0gR6V3LMc+ODSxr7yyvg= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.11.1 h1:tFl63cpAAcD9TOU6U8kZU7KyXuSRYAZlbx1C61aaB74= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.11.1/go.mod h1:X620Jww3RajCJXw/unA+8IRTgxkdS7pi+ZwK9b7KUJk= -go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.11.1 h1:3Yvzs7lgOw8MmbxmLRsQGwYdCubFmUHSooKaEhQunFQ= -go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.11.1/go.mod h1:pyHDt0YlyuENkD2VwHsiRDf+5DfI3EH7pfhUYW6sQUE= -go.opentelemetry.io/otel/metric v0.33.0 h1:xQAyl7uGEYvrLAiV/09iTJlp1pZnQ9Wl793qbVvED1E= -go.opentelemetry.io/otel/metric v0.33.0/go.mod h1:QlTYc+EnYNq/M2mNk1qDDMRLpqCOj2f/r5c7Fd5FYaI= -go.opentelemetry.io/otel/sdk v1.11.1 h1:F7KmQgoHljhUuJyA+9BiU+EkJfyX5nVVF4wyzWZpKxs= -go.opentelemetry.io/otel/sdk v1.11.1/go.mod h1:/l3FE4SupHJ12TduVjUkZtlfFqDCQJlOlithYrdktys= -go.opentelemetry.io/otel/sdk/metric v0.33.0 h1:oTqyWfksgKoJmbrs2q7O7ahkJzt+Ipekihf8vhpa9qo= -go.opentelemetry.io/otel/sdk/metric v0.33.0/go.mod h1:xdypMeA21JBOvjjzDUtD0kzIcHO/SPez+a8HOzJPGp0= -go.opentelemetry.io/otel/trace v1.11.1 h1:ofxdnzsNrGBYXbP7t7zpUK281+go5rF7dvdIZXF8gdQ= -go.opentelemetry.io/otel/trace v1.11.1/go.mod h1:f/Q9G7vzk5u91PhbmKbg1Qn0rzH1LJ4vbPHFGkTPtOk= -go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= -go.opentelemetry.io/proto/otlp v0.19.0 h1:IVN6GR+mhC4s5yfcTbmzHYODqvWAp3ZedA2SJPI1Nnw= -go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= -go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ= -go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= -go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= -go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo= -go.uber.org/multierr v1.8.0 h1:dg6GjLku4EH+249NNmoIciG9N/jURbDG+pFlTkhzIC8= -go.uber.org/multierr v1.8.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak= +go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= +go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= +go.opentelemetry.io/contrib/detectors/aws/lambda v0.53.0 h1:KG6fOUk3EwSH1dEpsAbsLKFbn3cFwN9xDu8plGu55zI= +go.opentelemetry.io/contrib/detectors/aws/lambda v0.53.0/go.mod h1:bSd579exEkh/P5msRcom8YzVB6NsUxYKyV+D/FYOY7Y= +go.opentelemetry.io/contrib/instrumentation/host v0.63.0 h1:zsaUrWypCf0NtYSUby+/BS6QqhXVNxMQD5w4dLczKCQ= +go.opentelemetry.io/contrib/instrumentation/host v0.63.0/go.mod h1:Ru+kuFO+ToZqBKwI59rCStOhW6LWrbGisYrFaX61bJk= +go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0 h1:PeBoRj6af6xMI7qCupwFvTbbnd49V7n5YpG6pg8iDYQ= +go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0/go.mod h1:ingqBCtMCe8I4vpz/UVzCW6sxoqgZB37nao91mLQ3Bw= +go.opentelemetry.io/contrib/processors/baggage/baggagetrace v0.1.0 h1:Q9kJxbstjL5DwlvCyQnTYbMvOftoVANnQcSzqYeA0AQ= +go.opentelemetry.io/contrib/processors/baggage/baggagetrace v0.1.0/go.mod h1:2rK1JRWN+pfF/E9OhEjUczWwbX7oELQdsKyUgOTEliw= +go.opentelemetry.io/contrib/processors/baggagecopy v0.11.0 h1:kCgcpaw83eiQq3q9kC0mlSF+2/GFj979aphWGlHmxRw= +go.opentelemetry.io/contrib/processors/baggagecopy v0.11.0/go.mod h1:HA84H6DSS0J6sbXzDj8bjmrooSK1UhPZvh3Dijltw5A= +go.opentelemetry.io/contrib/propagators/b3 v1.38.0 h1:uHsCCOSKl0kLrV2dLkFK+8Ywk9iKa/fptkytc6aFFEo= +go.opentelemetry.io/contrib/propagators/b3 v1.38.0/go.mod h1:wMRSZJZcY8ya9mApLLhwIMjqmApy2o/Ml+62lhvxyHU= +go.opentelemetry.io/contrib/propagators/ot v1.38.0 h1:k4gSyyohaDXI8F9BDXYC3uO2vr5sRNeQFMsN9Zn0EoI= +go.opentelemetry.io/contrib/propagators/ot v1.38.0/go.mod h1:2hDsuiHRO39SRUMhYGqmj64z/IuMRoxE4bBSFR82Lo8= +go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8= +go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0 h1:vl9obrcoWVKp/lwl8tRE33853I8Xru9HFbw/skNeLs8= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0/go.mod h1:GAXRxmLJcVM3u22IjTg74zWBrRCKq8BnOqUVLodpcpw= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.38.0 h1:Oe2z/BCg5q7k4iXC3cqJxKYg0ieRiOqF0cecFYdPTwk= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v1.38.0/go.mod h1:ZQM5lAJpOsKnYagGg/zV2krVqTtaVdYdDkhMoX6Oalg= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 h1:GqRJVj7UmLjCVyVJ3ZFLdPRmhDUp2zFmQe3RHIOsw24= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0/go.mod h1:ri3aaHSmCTVYu2AWv44YMauwAQc0aqI9gHKIcSbI1pU= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0 h1:lwI4Dc5leUqENgGuQImwLo4WnuXFPetmPpkLi2IrX54= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0/go.mod h1:Kz/oCE7z5wuyhPxsXDuaPteSWqjSBD5YaSdbxZYGbGk= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 h1:aTL7F04bJHUlztTsNGJ2l+6he8c+y/b//eR0jjjemT4= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0/go.mod h1:kldtb7jDTeol0l3ewcmd8SDvx3EmIE7lyvqbasU3QC4= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.38.0 h1:kJxSDN4SgWWTjG/hPp3O7LCGLcHXFlvS2/FFOrwL+SE= +go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.38.0/go.mod h1:mgIOzS7iZeKJdeB8/NYHrJ48fdGc71Llo5bJ1J4DWUE= +go.opentelemetry.io/otel/log v0.14.0 h1:2rzJ+pOAZ8qmZ3DDHg73NEKzSZkhkGIua9gXtxNGgrM= +go.opentelemetry.io/otel/log v0.14.0/go.mod h1:5jRG92fEAgx0SU/vFPxmJvhIuDU9E1SUnEQrMlJpOno= +go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA= +go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI= +go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E= +go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg= +go.opentelemetry.io/otel/sdk/log v0.14.0 h1:JU/U3O7N6fsAXj0+CXz21Czg532dW2V4gG1HE/e8Zrg= +go.opentelemetry.io/otel/sdk/log v0.14.0/go.mod h1:imQvII+0ZylXfKU7/wtOND8Hn4OpT3YUoIgqJVksUkM= +go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM= +go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA= +go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE= +go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs= +go.opentelemetry.io/proto/otlp v1.9.0 h1:l706jCMITVouPOqEnii2fIAuO3IVGBRPV5ICjceRb/A= +go.opentelemetry.io/proto/otlp v1.9.0/go.mod h1:xE+Cx5E/eEHw+ISFkwPLwCZefwVjY+pqKg1qcK03+/4= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.44.0 h1:A97SsFvM3AIwEEmTBiaxPPTYpDC47w720rdiiUvgoAU= +golang.org/x/crypto v0.44.0/go.mod h1:013i+Nw79BMiQiMsOPcVCB5ZIJbYkerPrGnOa00tvmc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= -golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= -golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= -golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= -golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= -golang.org/x/exp v0.0.0-20221217163422-3c43f8badb15 h1:5oN1Pz/eDhCpbMbLstvIPa0b/BEQo6g6nwV3pLjfM6w= -golang.org/x/exp v0.0.0-20221217163422-3c43f8badb15/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= -golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= -golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6 h1:zfMcR1Cs4KNuomFFgGefv5N0czO2XZpUbxGUy8i8ug0= +golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6/go.mod h1:46edojNIoXTNOhySWIWdix628clX9ODXwPsQuG6hsK0= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= -golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= -golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= -golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= -golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= -golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -468,244 +364,80 @@ golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ= -golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= +golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY= +golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I= +golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= +golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68= -golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= -golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20220609170525-579cf78fd858 h1:Dpdu/EMxGMFgq0CeYMh4fazTD2vtlZRYE7wyynxJb9U= -golang.org/x/time v0.0.0-20220609170525-579cf78fd858/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM= +golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM= +golang.org/x/time v0.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE= +golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= -golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f h1:uF6paiQQebLeSXkrTqHqz0MXhXXS1KgF41eUdBNvxK0= golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk= +gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E= google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk= -google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= -google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= -google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= -google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= -google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= -google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= -google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= -google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= -google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= -google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= -google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc h1:8DyZCyvI8mE1IdLy/60bS+52xfymkE72wv1asokgtao= -google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:xZnkP7mREFX5MORlOPEzLMr+90PPZQ2QWzrVTWfAq64= -google.golang.org/genproto/googleapis/api v0.0.0-20230526203410-71b5a4ffd15e h1:AZX1ra8YbFMSb7+1pI8S9v4rrgRR7jU1FmuFSSjTVcQ= -google.golang.org/genproto/googleapis/api v0.0.0-20230526203410-71b5a4ffd15e/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e h1:NumxXLPfHSndr3wBBdeKiVHjGVFzi9RX2HwwQke94iY= -google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= +google.golang.org/genproto/googleapis/api v0.0.0-20251124214823-79d6a2a48846 h1:ZdyUkS9po3H7G0tuh955QVyyotWvOD4W0aEapeGeUYk= +google.golang.org/genproto/googleapis/api v0.0.0-20251124214823-79d6a2a48846/go.mod h1:Fk4kyraUvqD7i5H6S43sj2W98fbZa75lpZz/eUyhfO0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846 h1:Wgl1rcDNThT+Zn47YyCXOXyX/COgMTIdhJ717F0l4xk= +google.golang.org/genproto/googleapis/rpc v0.0.0-20251124214823-79d6a2a48846/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= -google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= -google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= -google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= -google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= -google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= -google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= -google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= -google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc v1.55.0 h1:3Oj82/tFSCeUrRTg/5E/7d/W5A1tj6Ky1ABAuZuv5ag= -google.golang.org/grpc v1.55.0/go.mod h1:iYEXKGkEBhg1PjZQvoYEVPTDkHo1/bjTnfwTeGONTY8= +google.golang.org/grpc v1.77.0 h1:wVVY6/8cGA6vvffn+wWK5ToddbgdU3d8MNENr4evgXM= +google.golang.org/grpc v1.77.0/go.mod h1:z0BY1iVj0q8E1uSQCjL9cppRj+gnZjzDnzV0dHhrNig= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= -google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= -google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng= -google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE= +google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -715,21 +447,12 @@ gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMy gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= -honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= -rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= -rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +lukechampine.com/blake3 v1.1.6 h1:H3cROdztr7RCfoaTpGZFQsrqvweFLrqS73j7L7cmR5c= +lukechampine.com/blake3 v1.1.6/go.mod h1:tkKEOtDkNtklkXtLNEOGNq5tcV90tJiA1vAA12R78LA= From d10f7402d087092ee1deeca2fd1e37ef51552263 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 00:49:09 +0530 Subject: [PATCH 02/18] Modernize CI and add golangci-lint v2 config Test on Go 1.26, the minimum declared in go.mod, and on the latest stable release with current action versions. Run go vet, and add a golangci-lint job that uses the go.mod Go version. --- .github/workflows/go.yml | 43 ++++++++++++++++++++++++--------- .golangci.yml | 52 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 84 insertions(+), 11 deletions(-) create mode 100644 .golangci.yml diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 18e9756bf..b23cb476d 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -2,20 +2,41 @@ name: Go on: [push, pull_request] -jobs: +permissions: + contents: read - build: +jobs: + test: runs-on: ubuntu-latest + strategy: + matrix: + # The minimum version declared in go.mod, and the latest release. + go-version: ['1.26', stable] steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v7 + + - uses: actions/setup-go@v6 + with: + go-version: ${{ matrix.go-version }} + + - name: Vet + run: go vet ./... - - name: Set up Go - uses: actions/setup-go@v4 - with: - go-version: '1.23' + - name: Test + run: go test -race -count 2 ./... + + - name: Bench + run: go test -run @ -bench . -benchtime 1x ./... + + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 - - name: Test - run: go test -race -count 2 -bench . ./... + - uses: actions/setup-go@v6 + with: + go-version-file: go.mod - - name: Bench - run: go test -run @ -bench . ./... + - uses: golangci/golangci-lint-action@v9 + with: + version: v2.13.2 diff --git a/.golangci.yml b/.golangci.yml new file mode 100644 index 000000000..a52452cd0 --- /dev/null +++ b/.golangci.yml @@ -0,0 +1,52 @@ +version: "2" + +linters: + default: standard + enable: + - errorlint + - misspell + - modernize + - nolintlint + - unconvert + settings: + errcheck: + exclude-functions: + - (hash.Hash).Write + - (io.Writer).Write + - crypto/rand.Read + - fmt.Fprint + - fmt.Fprintf + - fmt.Fprintln + - io.WriteString + staticcheck: + checks: + - all + # Package names such as k_nearest_nodes and peer_store are part of the public API. + - -ST1003 + # Receiver names follow the existing "me" convention in many types. + - -ST1016 + # Exported identifiers without doc comments. + - -ST1000 + - -ST1020 + - -ST1021 + - -ST1022 + # TransactionTimeout is exported API. + - -ST1012 + # Explicit embedded-field selectors such as NodeAndTime.Time read more clearly. + - -QF1008 + exclusions: + presets: + - std-error-handling + rules: + # Tests compare raw IP bytes on purpose. + - path: _test\.go + text: SA1021 + # Test fixtures deliberately ignore I/O errors on throwaway sockets and decoders. + - path: _test\.go + linters: + - errcheck + +formatters: + enable: + - gofmt + - goimports From b9dcf0df135e4842bdf484587aeb698ad9aea46c Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 00:49:09 +0530 Subject: [PATCH 03/18] Fix query handler crashes and modernize the codebase Bug fixes: - Queries that require arguments (announce_peer, put, get) no longer dereference a nil arguments dict, which let any remote packet crash the server. They now get a protocol error, as get_peers and find_node already did. - find_node and get replies returned the nodes closest to the (unset) info_hash instead of the queried target. - Server.Put ignored its QueryRateLimiting argument. - getput.Get and getput.Put dereferenced a nil seq in unsigned responses, ignored errors from TraversalStartingNodes, and didn't wait for the traversal to stop before reading its stats. - krpc.Error decoding no longer relies on recover to reject malformed errors, and NodeInfo decoding checks its input length. Refactors: - Split handleQuery into a handler per query method. - Use the standard library in place of multiless, bradfitz/iter, docopt, x/exp/constraints and ioutil: cmp, slices, maps, math/rand/v2, errors.AsType, sync.OnceValue, WaitGroup.Go, atomic.Uint64, binary.Append*, range over int. - Replace the big.Int in int160.BitLen with math/bits, and cache the Castagnoli CRC table used for node ID security checks. - Remove dead code, unused fields, commented-out code, and stale or editorializing comments. Move test-only helpers into _test.go files. - Rename k-nearest-nodes/k-nearest-nodes.go.go. Adds regression tests for the argument-less queries and the find_node target, plus int160 tests. --- announce.go | 11 +- bep44/item.go | 22 +- bep44/memory.go | 4 +- bep44/put.go | 15 +- bitcount_test.go | 2 +- bootstrap.go | 2 - cmd/dht-announce/main.go | 15 +- cmd/dht-secure-id/main.go | 24 +- cmd/dht-server/main.go | 9 +- cmd/dht/get-peers.go | 52 +- cmd/dht/main.go | 2 +- cmd/dht/ping.go | 59 +-- cmd/dht/put.go | 17 +- cmd/dht2/main.go | 2 +- dht.go | 29 +- dht_test.go | 2 +- dns.go | 33 +- errnos_windows.go | 5 +- exts/getput/getput.go | 147 +++--- hash-tuple_test.go | 3 +- int160/int160.go | 33 +- int160/int160_test.go | 48 ++ ...nearest-nodes.go.go => k-nearest-nodes.go} | 57 +-- krpc/CompactIPv4NodeInfo.go | 7 - krpc/compact_helpers.go | 12 +- krpc/error.go | 45 +- krpc/fuzz_test.go | 1 - krpc/id.go | 5 +- krpc/msg.go | 6 +- krpc/msg_test.go | 4 +- krpc/node-addr-port.go | 10 +- krpc/nodeaddr.go | 8 +- krpc/nodeinfo.go | 26 +- misc.go | 17 - misc_test.go | 19 + nearest-nodes.go | 1 - node.go | 13 +- nodes_file.go | 32 +- nodes_file_test.go | 12 +- peer-store/in-memory.go | 56 +-- peer-store/in-memory_test.go | 13 +- security.go | 66 +-- server.go | 467 +++++++----------- server_test.go | 89 +++- table.go | 21 +- tokens.go | 31 +- transactions/key-issuer.go | 14 +- traversal/operation.go | 43 +- types/addr-maybe-id.go | 20 +- types/addr-maybe-id_test.go | 16 +- 50 files changed, 722 insertions(+), 925 deletions(-) create mode 100644 int160/int160_test.go rename k-nearest-nodes/{k-nearest-nodes.go.go => k-nearest-nodes.go} (54%) delete mode 100644 nearest-nodes.go diff --git a/announce.go b/announce.go index 7cbb356cd..8576cf207 100644 --- a/announce.go +++ b/announce.go @@ -1,7 +1,5 @@ package dht -// get_peers and announce_peers. - import ( "context" "fmt" @@ -73,10 +71,11 @@ func AnnouncePeer(opts AnnouncePeerOpts) AnnounceOpt { } } -// Deprecated: Use Server.AnnounceTraversal. // Traverses the DHT graph toward nodes that store peers for the infohash, streaming them to the // caller, and announcing the local node to each responding node if port is non-zero or impliedPort // is true. +// +// Deprecated: Use Server.AnnounceTraversal with AnnouncePeer. func (s *Server) Announce(infoHash [20]byte, port int, impliedPort bool, opts ...AnnounceOpt) (_ *Announce, err error) { if port != 0 || impliedPort { opts = append([]AnnounceOpt{AnnouncePeer(AnnouncePeerOpts{ @@ -130,14 +129,12 @@ func (s *Server) AnnounceTraversal(infoHash [20]byte, opts ...AnnounceOpt) (_ *A func (a *Announce) announceClosest() { var wg sync.WaitGroup a.traversal.Closest().Range(func(elem dhtutil.Elem) { - wg.Add(1) - go func() { + wg.Go(func() { a.logger().Levelf(log.Debug, "announce_peer to %v: %v", elem, a.announcePeer(elem), ) - wg.Done() - }() + }) }) wg.Wait() } diff --git a/bep44/item.go b/bep44/item.go index f87314102..f8a03d5d0 100644 --- a/bep44/item.go +++ b/bep44/item.go @@ -17,7 +17,7 @@ type Item struct { created time.Time // Value to be stored - V interface{} + V any // 32 byte ed25519 public key K [32]byte @@ -54,7 +54,7 @@ func (i *Item) ToPut() Put { // // The optional seq field specifies that an item's value should only be sent if its // sequence number is greater than the given value. -func NewItem(value interface{}, salt []byte, seq, cas int64, k ed25519.PrivateKey) (*Item, error) { +func NewItem(value any, salt []byte, seq, cas int64, k ed25519.PrivateKey) (*Item, error) { v, err := bencode.Marshal(value) if err != nil { return nil, err @@ -82,13 +82,13 @@ func NewItem(value interface{}, salt []byte, seq, cas int64, k ed25519.PrivateKe func (i *Item) Target() Target { if i.IsMutable() { - return sha1.Sum(append(i.K[:], i.Salt...)) + return MakeMutableTarget(i.K, i.Salt) } return sha1.Sum(bencode.MustMarshal(i.V)) } -func (i *Item) Modify(value interface{}, k ed25519.PrivateKey) bool { +func (i *Item) Modify(value any, k ed25519.PrivateKey) bool { if !i.IsMutable() { return false } @@ -107,20 +107,18 @@ func (i *Item) Modify(value interface{}, k ed25519.PrivateKey) bool { return true } -func (s *Item) IsMutable() bool { - return s.K != Empty32ByteArray +func (i *Item) IsMutable() bool { + return i.K != Empty32ByteArray } func bufferToSign(salt, bv []byte, seq int64) []byte { var bts []byte if len(salt) != 0 { - bts = append(bts, []byte("4:salt")...) - x := bencode.MustMarshal(salt) - bts = append(bts, x...) + bts = append(bts, "4:salt"...) + bts = append(bts, bencode.MustMarshal(salt)...) } - bts = append(bts, []byte(fmt.Sprintf("3:seqi%de1:v", seq))...) - bts = append(bts, bv...) - return bts + bts = fmt.Appendf(bts, "3:seqi%de1:v", seq) + return append(bts, bv...) } func Check(i *Item) error { diff --git a/bep44/memory.go b/bep44/memory.go index fce3b2e41..a9fd9235e 100644 --- a/bep44/memory.go +++ b/bep44/memory.go @@ -28,8 +28,8 @@ func (m *Memory) Put(i *Item) error { } func (m *Memory) Get(t Target) (*Item, error) { - m.mu.Lock() - defer m.mu.Unlock() + m.mu.RLock() + defer m.mu.RUnlock() i, ok := m.m[t] if !ok { diff --git a/bep44/put.go b/bep44/put.go index d654fa358..33eef6aea 100644 --- a/bep44/put.go +++ b/bep44/put.go @@ -8,7 +8,7 @@ import ( ) type Put struct { - V interface{} + V any K *[32]byte Salt []byte Sig [64]byte @@ -34,14 +34,13 @@ func (p *Put) Sign(k ed25519.PrivateKey) { copy(p.Sig[:], Sign(k, p.Salt, p.Seq, bencode.MustMarshal(p.V))) } -func (i *Put) Target() Target { - if i.IsMutable() { - return MakeMutableTarget(*i.K, i.Salt) - } else { - return sha1.Sum(bencode.MustMarshal(i.V)) +func (p *Put) Target() Target { + if p.IsMutable() { + return MakeMutableTarget(*p.K, p.Salt) } + return sha1.Sum(bencode.MustMarshal(p.V)) } -func (s *Put) IsMutable() bool { - return s.K != nil +func (p *Put) IsMutable() bool { + return p.K != nil } diff --git a/bitcount_test.go b/bitcount_test.go index 05f7d8b85..f98c12e3e 100644 --- a/bitcount_test.go +++ b/bitcount_test.go @@ -6,7 +6,7 @@ package dht // How many bits? func bitCount(b []byte) int { - var count int = 0 + var count int for _, c := range b { count += int(bitCounts[c]) } diff --git a/bootstrap.go b/bootstrap.go index 5ac9cb433..286eac7db 100644 --- a/bootstrap.go +++ b/bootstrap.go @@ -31,8 +31,6 @@ func (s *Server) BootstrapContext(ctx context.Context) (_ TraversalStats, err er defer s.mu.Unlock() s.bootstrappingNow = false }() - // Track number of responses, for STM use. (It's available via atomic in TraversalStats but that - // won't let wake up STM transactions that are observing the value.) t := traversal.Start(traversal.OperationInput{ Target: s.id.AsByteArray(), K: 16, diff --git a/cmd/dht-announce/main.go b/cmd/dht-announce/main.go index 456eb61de..81cba9a39 100644 --- a/cmd/dht-announce/main.go +++ b/cmd/dht-announce/main.go @@ -56,15 +56,16 @@ func mainErr() int { var wg sync.WaitGroup ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt) defer cancel() + var opts []dht.AnnounceOpt + if flags.Port != 0 { + opts = append(opts, dht.AnnouncePeer(dht.AnnouncePeerOpts{Port: flags.Port})) + } + if flags.Scrape { + opts = append(opts, dht.Scrape()) + } addrs := make(map[[20]byte]map[string]struct{}, len(flags.Infohash)) for _, ih := range flags.Infohash { - // PSA: Go sucks. - a, err := s.Announce(ih, flags.Port, false, func() (ret []dht.AnnounceOpt) { - if flags.Scrape { - ret = append(ret, dht.Scrape()) - } - return - }()...) + a, err := s.AnnounceTraversal(ih, opts...) if err != nil { log.Printf("error announcing %s: %s", ih, err) continue diff --git a/cmd/dht-secure-id/main.go b/cmd/dht-secure-id/main.go index 38752fc4d..1f049481b 100644 --- a/cmd/dht-secure-id/main.go +++ b/cmd/dht-secure-id/main.go @@ -1,3 +1,4 @@ +// Command dht-secure-id outputs the node ID secured with the IP. package main import ( @@ -6,32 +7,31 @@ import ( "net" "os" - "github.com/docopt/docopt-go" - "github.com/anacrolix/dht/v2" "github.com/anacrolix/dht/v2/krpc" ) func main() { - args, _ := docopt.Parse(`dht-secure-id outputs the node ID secured with the IP. - -Usage: dht-secure-id `, nil, true, "", false) - id, err := hex.DecodeString(args[""].(string)) + if len(os.Args) != 3 { + fmt.Fprintf(os.Stderr, "dht-secure-id outputs the node ID secured with the IP.\n\nUsage: dht-secure-id \n") + os.Exit(2) + } + b, err := hex.DecodeString(os.Args[1]) if err != nil { fmt.Fprintf(os.Stderr, "bad id: %s\n", err) os.Exit(2) } - if len(id) != 20 { + var id krpc.ID + if len(b) != len(id) { fmt.Fprintf(os.Stderr, "bad id: wrong length\n") os.Exit(2) } - ip := net.ParseIP(args[""].(string)) + ip := net.ParseIP(os.Args[2]) if ip == nil { fmt.Fprintf(os.Stderr, "bad ip\n") os.Exit(2) } - var _id krpc.ID - copy(_id[:], id) - dht.SecureNodeId(&_id, ip) - fmt.Printf("%x\n", _id) + copy(id[:], b) + dht.SecureNodeId(&id, ip) + fmt.Printf("%x\n", id) } diff --git a/cmd/dht-server/main.go b/cmd/dht-server/main.go index a811e6282..5e2d78b3b 100644 --- a/cmd/dht-server/main.go +++ b/cmd/dht-server/main.go @@ -71,13 +71,8 @@ func mainErr() error { } log.Printf("dht server on %s, ID is %x", s.Addr(), s.ID()) - ctx, cancel := context.WithCancel(context.Background()) - go func() { - ch := make(chan os.Signal, 1) - signal.Notify(ch, os.Interrupt) - log.Printf("got signal: %v", <-ch) - cancel() - }() + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt) + defer stop() if !flags.NoBootstrap { go func() { if tried, err := s.Bootstrap(); err != nil { diff --git a/cmd/dht/get-peers.go b/cmd/dht/get-peers.go index ab6f94b50..beda7d6f2 100644 --- a/cmd/dht/get-peers.go +++ b/cmd/dht/get-peers.go @@ -1,6 +1,7 @@ package main import ( + "cmp" "context" "encoding/json" "net/netip" @@ -8,14 +9,12 @@ import ( "slices" "github.com/anacrolix/log" - "golang.org/x/exp/constraints" "github.com/anacrolix/dht/v2" ) func GetPeers(ctx context.Context, s *dht.Server, ih [20]byte, opts ...dht.AnnounceOpt) error { addrs := make(map[string]int) - // PSA: Go sucks. a, err := s.AnnounceTraversal(ih, opts...) if err != nil { return err @@ -62,10 +61,7 @@ getPeers: }) } slices.SortFunc(addrCountSlice, func(a, b addrFreq) int { - // Looks like I got sick of anacrolix/multiless. - return ordered(a.Frequency, b.Frequency).Then( - lesser(a.Addr.Addr(), b.Addr.Addr())).Then( - ordered(a.Addr.Port(), b.Addr.Port())).ToInt() + return cmp.Or(cmp.Compare(a.Frequency, b.Frequency), a.Addr.Compare(b.Addr)) }) je := json.NewEncoder(os.Stdout) je.SetIndent("", " ") @@ -89,47 +85,3 @@ type addrFreq struct { Addr netip.AddrPort Frequency int } - -func lesser[T interface{ Less(T) bool }](a, b T) Ordering { - if a.Less(b) { - return less(true) - } - if b.Less(a) { - return less(false) - } - return equal -} - -func ordered[T constraints.Ordered](a T, b T) Ordering { - if a == b { - return equal - } - return less(a < b) -} - -var equal = Ordering{equal: true} - -func less(a bool) Ordering { return Ordering{less: a} } - -type Ordering struct { - less bool - equal bool -} - -func (me Ordering) Then(other Ordering) Ordering { - if me.equal { - return other - } else { - return me - } -} - -func (me Ordering) ToInt() int { - if me.equal { - return 0 - } else if me.less { - return -1 - } else { - return 1 - } -} diff --git a/cmd/dht/main.go b/cmd/dht/main.go index 75d0a9cc0..fab583b7a 100644 --- a/cmd/dht/main.go +++ b/cmd/dht/main.go @@ -211,7 +211,7 @@ func main() { return } cfg.Conn = conn - all, err := publicip.Get(context.TODO(), serverArgs.Network) + all, err := publicip.Get(ctx, serverArgs.Network) if err == nil { cfg.PublicIP = all[0] log.Printf("public ip: %q", cfg.PublicIP) diff --git a/cmd/dht/ping.go b/cmd/dht/ping.go index def989b56..4a9604792 100644 --- a/cmd/dht/ping.go +++ b/cmd/dht/ping.go @@ -4,7 +4,6 @@ package main import ( "errors" "fmt" - "log" "net" "sync" "time" @@ -20,49 +19,39 @@ type pingArgs struct { } func ping(args pingArgs, s *dht.Server) error { - var wg sync.WaitGroup - defaults := dht.DefaultGlobalBootstrapHostPorts - if !args.Defaults { - defaults = nil + nodes := args.Nodes + if args.Defaults { + nodes = append(nodes, dht.DefaultGlobalBootstrapHostPorts...) } - for _, a := range append(args.Nodes, defaults...) { - func(a string) { - ua, err := net.ResolveUDPAddr(args.Network, a) - if err != nil { - log.Fatal(err) + var wg sync.WaitGroup + for _, a := range nodes { + ua, err := net.ResolveUDPAddr(args.Network, a) + if err != nil { + return err + } + started := time.Now() + wg.Go(func() { + res := s.Ping(ua) + if res.Err != nil { + fmt.Printf("%s: %s: %s\n", a, time.Since(started), res.Err) + return + } + id := *res.Reply.SenderID() + secure := '✘' + if dht.NodeIdSecure(id, ua.IP) { + secure = '✔' } - started := time.Now() - wg.Add(1) - go func() { - defer wg.Done() - res := s.Ping(ua) - err := res.Err - if err != nil { - fmt.Printf("%s: %s: %s\n", a, time.Since(started), err) - return - } - id := *res.Reply.SenderID() - fmt.Printf("%s: %x %c: %s\n", a, id, func() rune { - if dht.NodeIdSecure(id, ua.IP) { - return '✔' - } else { - return '✘' - } - }(), time.Since(started)) - }() - }(a) + fmt.Printf("%s: %x %c: %s\n", a, id, secure, time.Since(started)) + }) } done := make(chan struct{}) go func() { wg.Wait() close(done) }() - timeout := make(chan struct{}) + var timeout <-chan time.Time if args.Timeout != 0 { - go func() { - time.Sleep(args.Timeout) - close(timeout) - }() + timeout = time.After(args.Timeout) } select { case <-done: diff --git a/cmd/dht/put.go b/cmd/dht/put.go index 81b38893e..7a33997a5 100644 --- a/cmd/dht/put.go +++ b/cmd/dht/put.go @@ -52,20 +52,11 @@ func put(cmd *PutCmd) (err error) { } mutable := cmd.Mutable || len(cmd.Key.Bytes) != 0 || cmd.Cas != 0 || len(cmd.Salt) != 0 for _, data := range cmd.Data { - putBytes := []byte(data) - var v interface{} + var v any if cmd.Strings { - var s interface{} = string(putBytes) - v = s - putBytes, err = bencode.Marshal(v) - if err != nil { - return fmt.Errorf("marshalling string arg to bytes: %w", err) - } - } else { - err = bencode.Unmarshal(putBytes, &v) - if err != nil { - return - } + v = data + } else if err = bencode.Unmarshal([]byte(data), &v); err != nil { + return fmt.Errorf("parsing value bencode: %w", err) } put := bep44.Put{ V: v, diff --git a/cmd/dht2/main.go b/cmd/dht2/main.go index 6a9f32412..eacd87c36 100644 --- a/cmd/dht2/main.go +++ b/cmd/dht2/main.go @@ -54,7 +54,7 @@ func mainErr(ctx context.Context) (err error) { res := s.Query(ctx, dht.NewAddr(udpAddr), q.Unwrap(), input) spew.Dump(res) default: - parser.Fail() + _ = parser.Fail() } parser.DoHelpIfHelping() return parser.Err() diff --git a/dht.go b/dht.go index df67cce53..388d90e4c 100644 --- a/dht.go +++ b/dht.go @@ -2,10 +2,9 @@ package dht import ( "context" - "crypto" - _ "crypto/sha1" + "crypto/sha1" "errors" - "math/rand" + "fmt" "net" "time" @@ -29,8 +28,7 @@ type transactionKey = transactions.Key type StartingNodesGetter func() ([]Addr, error) -// ServerConfig allows setting up a configuration of the `Server` instance to be created with -// NewServer. +// ServerConfig configures a Server created with NewServer. type ServerConfig struct { // Set NodeId Manually. Caller must ensure that if NodeId does not conform // to DHT Security Extensions, that NoSecurity is also set. @@ -62,7 +60,7 @@ type ServerConfig struct { // How long to wait before resending queries that haven't received a response. Defaults to 2s. // After the last send, a query is aborted after this time. QueryResendDelay func() time.Duration - // TODO: Expose Peers, to return NodeInfo for received get_peers queries. + // Stores peers announced to us, and provides the values for get_peers responses. PeerStore peer_store.Interface // BEP-44: Storing arbitrary data in the DHT. If not store provided, a default in-memory // implementation will be used. @@ -96,10 +94,6 @@ type ServerStats struct { OutboundQueriesAttempted int64 } -func jitterDuration(average time.Duration, plusMinus time.Duration) time.Duration { - return average - plusMinus/2 + time.Duration(rand.Int63n(int64(plusMinus))) -} - type Peer = krpc.NodeAddr var DefaultGlobalBootstrapHostPorts = []string{ @@ -120,17 +114,15 @@ func GlobalBootstrapAddrs(network string) ([]Addr, error) { } // Resolves host:port strings to dht.Addrs, using the dht DNS resolver cache. Suitable for use with -// ServerConfig.BootstrapAddrs. +// ServerConfig.StartingNodes. func ResolveHostPorts(hostPorts []string) (addrs []Addr, err error) { - initDnsResolver() for _, s := range hostPorts { host, port, err := net.SplitHostPort(s) if err != nil { - panic(err) + return nil, fmt.Errorf("parsing %q: %w", s, err) } - hostAddrs, err := dnsResolver.LookupHost(context.Background(), host) + hostAddrs, err := dnsResolver().LookupHost(context.Background(), host) if err != nil { - // log.Default.WithDefaultLevel(log.Debug).Printf("error looking up %q: %v", s, err) continue } for _, a := range hostAddrs { @@ -148,15 +140,14 @@ func ResolveHostPorts(hostPorts []string) (addrs []Addr, err error) { return } -// Deprecated: Use function from krpc. +// Deprecated: Use krpc.RandomNodeID. func RandomNodeID() (id krpc.ID) { return krpc.RandomNodeID() } +// Returns a secure node ID derived from the SHA-1 of the public address. func MakeDeterministicNodeID(public net.Addr) (id krpc.ID) { - h := crypto.SHA1.New() - h.Write([]byte(public.String())) - h.Sum(id[:0:20]) + id = sha1.Sum([]byte(public.String())) SecureNodeId(&id, addrIP(public)) return } diff --git a/dht_test.go b/dht_test.go index 97a84200b..0b7f56825 100644 --- a/dht_test.go +++ b/dht_test.go @@ -282,7 +282,7 @@ func TestBootstrapRace(t *testing.T) { qt.Assert(t, qt.IsNil(err)) defer s.Close() go func() { - for i := 0; i < defaultMaxQuerySends-1; i++ { + for range defaultMaxQuerySends - 1 { remotePc.ReadFrom(nil) } var b [1024]byte diff --git a/dns.go b/dns.go index 61d3e5b50..b84700938 100644 --- a/dns.go +++ b/dns.go @@ -7,25 +7,16 @@ import ( "github.com/rs/dnscache" ) -var ( - // A cache to prevent wasteful/excessive use of DNS when trying to bootstrap. - dnsResolver *dnscache.Resolver - dnsResolverInit sync.Once -) - -func dnsResolverRefresher() { - ticker := time.NewTicker(5 * time.Minute) - defer ticker.Stop() - for { - <-ticker.C - dnsResolver.Refresh(false) - } -} - +// A cache to prevent wasteful/excessive use of DNS when trying to bootstrap. // https://github.com/anacrolix/dht/issues/43 -func initDnsResolver() { - dnsResolverInit.Do(func() { - dnsResolver = &dnscache.Resolver{} - go dnsResolverRefresher() - }) -} +var dnsResolver = sync.OnceValue(func() *dnscache.Resolver { + r := &dnscache.Resolver{} + go func() { + ticker := time.NewTicker(5 * time.Minute) + defer ticker.Stop() + for range ticker.C { + r.Refresh(false) + } + }() + return r +}) diff --git a/errnos_windows.go b/errnos_windows.go index 7dbdca6ad..350846601 100644 --- a/errnos_windows.go +++ b/errnos_windows.go @@ -9,8 +9,7 @@ import ( // See https://github.com/anacrolix/dht/issues/16. func ignoreReadFromError(err error) bool { - var errno syscall.Errno - if errors.As(err, &errno) { + if errno, ok := errors.AsType[syscall.Errno](err); ok { switch errno { case windows.WSAENETRESET, @@ -18,7 +17,7 @@ func ignoreReadFromError(err error) bool { windows.WSAECONNABORTED, windows.WSAECONNREFUSED, windows.WSAENETUNREACH, - windows.WSAETIMEDOUT: // Why does Go have braindead syntax? + windows.WSAETIMEDOUT: return true } } diff --git a/exts/getput/getput.go b/exts/getput/getput.go index fa9bc2d50..efc12700f 100644 --- a/exts/getput/getput.go +++ b/exts/getput/getput.go @@ -24,6 +24,20 @@ type GetResult struct { Mutable bool } +// Returns the item carried by r if it is the immutable item for target, or a correctly signed +// mutable item for target and salt. +func verifiedResult(r *krpc.Return, target bep44.Target, salt []byte) (GetResult, bool) { + if sha1.Sum(r.V) == target { + return GetResult{V: r.V, Sig: r.Sig}, true + } + if r.Seq != nil && + bep44.MakeMutableTarget(r.K, salt) == target && + bep44.Verify(r.K[:], salt, *r.Seq, r.V, r.Sig[:]) { + return GetResult{Seq: *r.Seq, V: r.V, Sig: r.Sig, Mutable: true}, true + } + return GetResult{}, false +} + func startGetTraversal( target bep44.Target, s *dht.Server, seq *int64, salt []byte, ) ( @@ -41,43 +55,29 @@ func startGetTraversal( logger.Levelf(log.Debug, "error querying %v: %v", addr, err) } if r := res.Reply.R; r != nil { - rv := r.V - bv := rv - if sha1.Sum(bv) == target { - select { - case vChan <- GetResult{ - V: rv, - Sig: r.Sig, - Mutable: false, - }: - case <-ctx.Done(): - } - } else if sha1.Sum(append(r.K[:], salt...)) == target && bep44.Verify(r.K[:], salt, *r.Seq, bv, r.Sig[:]) { + if v, ok := verifiedResult(r, target, salt); ok { select { - case vChan <- GetResult{ - Seq: *r.Seq, - V: rv, - Sig: r.Sig, - Mutable: true, - }: + case vChan <- v: case <-ctx.Done(): } - } else if rv != nil { - logger.Levelf(log.Debug, "get response item hash didn't match target: %q", rv) + } else if r.V != nil { + logger.Levelf(log.Debug, "get response item hash didn't match target: %q", r.V) } } - tqr := res.TraversalQueryResult(addr) - // Filter replies from nodes that don't have a string token. This doesn't look prettier - // with generics. "The token value should be a short binary string." ¯\_(ツ)_/¯ (BEP 5). - tqr.ClosestData, _ = tqr.ClosestData.(string) - if tqr.ClosestData == nil { - tqr.ResponseFrom = nil - } - return tqr + return res.TraversalQueryResult(addr) }, NodeFilter: s.TraversalNodeFilter, + // Only nodes that gave us a token can be put to. + DataFilter: func(data any) bool { + _, ok := data.(string) + return ok + }, }) nodes, err := s.TraversalStartingNodes() + if err != nil { + op.Stop() + return nil, nil, err + } op.AddNodes(nodes) return } @@ -93,27 +93,31 @@ func Get( } ret.Seq = math.MinInt64 gotValue := false -receiveResults: - select { - case <-op.Stalled(): - if !gotValue { - err = errors.New("value not found") - } - case v := <-vChan: - log.ContextLogger(ctx).Levelf(log.Debug, "received %#v", v) - gotValue = true - if !v.Mutable { - ret = v - break - } - if v.Seq >= ret.Seq { - ret = v +receive: + for { + select { + case <-op.Stalled(): + if !gotValue { + err = errors.New("value not found") + } + break receive + case v := <-vChan: + log.ContextLogger(ctx).Levelf(log.Debug, "received %#v", v) + gotValue = true + if !v.Mutable { + ret = v + break receive + } + if v.Seq >= ret.Seq { + ret = v + } + case <-ctx.Done(): + err = ctx.Err() + break receive } - goto receiveResults - case <-ctx.Done(): - err = ctx.Err() } op.Stop() + <-op.Stopped() stats = op.Stats() return } @@ -126,48 +130,49 @@ func Put( stats *traversal.Stats, err error, ) { logger := log.ContextLogger(ctx) - vChan, op, err := startGetTraversal(target, s, - // When we do a get traversal for a put, we don't care what seq the peers have? - nil, - // This is duplicated with the put, but we need it to filter responses for autoSeq. - salt) + // The seq filter is irrelevant for a put, but the salt is needed to verify responses for the + // automatic sequence number. + vChan, op, err := startGetTraversal(target, s, nil, salt) if err != nil { return } var autoSeq int64 -notDone: - select { - case v := <-vChan: - if v.Mutable && v.Seq > autoSeq { - autoSeq = v.Seq +receive: + for { + select { + case v := <-vChan: + // TODO: Set CAS automatically, and republish the existing seq if the content already + // matches. + if v.Mutable && v.Seq > autoSeq { + autoSeq = v.Seq + } + case <-op.Stalled(): + break receive + case <-ctx.Done(): + err = ctx.Err() + break receive } - // There are more optimizations that can be done here. We can set CAS automatically, and we - // can skip updating the sequence number if the existing content already matches (and - // presumably republish the existing seq). - goto notDone - case <-op.Stalled(): - case <-ctx.Done(): - err = ctx.Err() } op.Stop() + <-op.Stopped() + stats = op.Stats() + if err != nil { + return + } var wg sync.WaitGroup put := seqToPut(autoSeq) op.Closest().Range(func(elem k_nearest_nodes.Elem) { - wg.Add(1) - go func() { - defer wg.Done() - // This is enforced by startGetTraversal. + wg.Go(func() { + // This is enforced by the DataFilter in startGetTraversal. token := elem.Data.(string) res := s.Put(ctx, dht.NewAddr(elem.Addr.UDP()), put, token, dht.QueryRateLimiting{}) - err := res.ToError() - if err != nil { + if err := res.ToError(); err != nil { logger.Levelf(log.Warning, "error putting to %v [token=%q]: %v", elem.Addr, token, err) } else { logger.Levelf(log.Debug, "put to %v [token=%q]", elem.Addr, token) } - }() + }) }) wg.Wait() - stats = op.Stats() return } diff --git a/hash-tuple_test.go b/hash-tuple_test.go index f98f955fe..69615f707 100644 --- a/hash-tuple_test.go +++ b/hash-tuple_test.go @@ -1,5 +1,4 @@ //go:build go1.18 -// +build go1.18 package dht @@ -19,7 +18,7 @@ func FuzzHashTuple(f *testing.F) { if HashTuple(b) == HashTuple() { t.FailNow() } - if bytes.Compare(a, b) != 0 { + if !bytes.Equal(a, b) { if HashTuple(a) == HashTuple(b) { t.FailNow() } diff --git a/int160/int160.go b/int160/int160.go index 8d034817d..5cc053990 100644 --- a/int160/int160.go +++ b/int160/int160.go @@ -1,9 +1,10 @@ package int160 import ( + "bytes" "encoding/hex" "math" - "math/big" + "math/bits" ) type T struct { @@ -23,9 +24,12 @@ func (me *T) ByteString() string { } func (me *T) BitLen() int { - var a big.Int - a.SetBytes(me.bits[:]) - return a.BitLen() + for i, b := range me.bits { + if b != 0 { + return (len(me.bits)-i)*8 - bits.LeadingZeros8(b) + } + } + return 0 } func (me *T) SetBytes(b []byte) { @@ -53,14 +57,7 @@ func (me T) Bytes() []byte { } func (l T) Cmp(r T) int { - for i := range l.bits { - if l.bits[i] < r.bits[i] { - return -1 - } else if l.bits[i] > r.bits[i] { - return 1 - } - } - return 0 + return bytes.Compare(l.bits[:], r.bits[:]) } func (me *T) SetMax() { @@ -76,12 +73,7 @@ func (me *T) Xor(a, b *T) { } func (me *T) IsZero() bool { - for _, b := range me.bits { - if b != 0 { - return false - } - } - return true + return me.bits == [20]uint8{} } func FromBytes(b []byte) (ret T) { @@ -89,9 +81,8 @@ func FromBytes(b []byte) (ret T) { return } -func FromByteArray(b [20]byte) (ret T) { - ret.SetBytes(b[:]) - return +func FromByteArray(b [20]byte) T { + return T{bits: b} } func FromByteString(s string) (ret T) { diff --git a/int160/int160_test.go b/int160/int160_test.go new file mode 100644 index 000000000..4552365f8 --- /dev/null +++ b/int160/int160_test.go @@ -0,0 +1,48 @@ +package int160 + +import ( + "crypto/rand" + "math/big" + "testing" + + "github.com/go-quicktest/qt" +) + +func TestBitLen(t *testing.T) { + check := func(x T) { + t.Helper() + qt.Check(t, qt.Equals(x.BitLen(), new(big.Int).SetBytes(x.bits[:]).BitLen()), qt.Commentf("%v", x)) + } + check(T{}) + var max T + max.SetMax() + check(max) + for i := range 160 { + var x T + x.SetBit(i, true) + check(x) + } + for range 100 { + var b [20]byte + rand.Read(b[:]) + check(FromByteArray(b)) + } +} + +func TestCmp(t *testing.T) { + var a, b T + qt.Check(t, qt.Equals(a.Cmp(b), 0)) + b.SetBit(159, true) + qt.Check(t, qt.Equals(a.Cmp(b), -1)) + qt.Check(t, qt.Equals(b.Cmp(a), 1)) + a.SetBit(0, true) + qt.Check(t, qt.Equals(a.Cmp(b), 1)) +} + +func BenchmarkBitLen(b *testing.B) { + var x T + x.SetBit(100, true) + for b.Loop() { + _ = x.BitLen() + } +} diff --git a/k-nearest-nodes/k-nearest-nodes.go.go b/k-nearest-nodes/k-nearest-nodes.go similarity index 54% rename from k-nearest-nodes/k-nearest-nodes.go.go rename to k-nearest-nodes/k-nearest-nodes.go index 7a77e5e78..b48a9541c 100644 --- a/k-nearest-nodes/k-nearest-nodes.go.go +++ b/k-nearest-nodes/k-nearest-nodes.go @@ -1,9 +1,9 @@ package k_nearest_nodes import ( + "cmp" "hash/maphash" - "github.com/anacrolix/multiless" "github.com/benbjohnson/immutable" "github.com/anacrolix/dht/v2/int160" @@ -14,7 +14,7 @@ type Key = krpc.NodeInfoAddrPort type Elem struct { Key - Data interface{} + Data any } type Type struct { @@ -23,31 +23,30 @@ type Type struct { } func New(target int160.T, k int) Type { - seed := maphash.MakeSeed() return Type{ - k: k, - inner: immutable.NewSortedMap[Key, any](lessComparer[Key]{less: func(l, r Key) bool { - return multiless.New().Cmp( - l.ID.Int160().Distance(target).Cmp(r.ID.Int160().Distance(target)), - ).Lazy(func() multiless.Computation { - var lh, rh maphash.Hash - lh.SetSeed(seed) - rh.SetSeed(seed) - lh.WriteString(l.Addr.String()) - rh.WriteString(r.Addr.String()) - return multiless.New().Int64(int64(lh.Sum64()), int64(rh.Sum64())) - }).Less() - }}), + k: k, + inner: immutable.NewSortedMap[Key, any](comparer{target: target, seed: maphash.MakeSeed()}), } } +// Orders keys by distance to target, breaking ties with a seeded hash of the address so that +// distinct addresses sharing an ID are retained. +type comparer struct { + target int160.T + seed maphash.Seed +} + +func (c comparer) Compare(l, r Key) int { + if d := l.ID.Int160().Distance(c.target).Cmp(r.ID.Int160().Distance(c.target)); d != 0 { + return d + } + return cmp.Compare(maphash.String(c.seed, l.Addr.String()), maphash.String(c.seed, r.Addr.String())) +} + func (me *Type) Range(f func(Elem)) { iter := me.inner.Iterator() - for { - key, value, ok := iter.Next() - if !ok { - break - } + for !iter.Done() { + key, value, _ := iter.Next() f(Elem{ Key: key, Data: value, @@ -86,19 +85,3 @@ func (me Type) Farthest() (elem Elem) { func (me Type) Full() bool { return me.Len() >= me.k } - -type lessFunc[K any] func(l, r K) bool - -type lessComparer[K any] struct { - less lessFunc[K] -} - -func (me lessComparer[K]) Compare(i, j K) int { - if me.less(i, j) { - return -1 - } else if me.less(j, i) { - return 1 - } else { - return 0 - } -} diff --git a/krpc/CompactIPv4NodeInfo.go b/krpc/CompactIPv4NodeInfo.go index 60d593d1f..b66effdaf 100644 --- a/krpc/CompactIPv4NodeInfo.go +++ b/krpc/CompactIPv4NodeInfo.go @@ -8,13 +8,6 @@ func (CompactIPv4NodeInfo) ElemSize() int { return 26 } -// func (me *CompactIPv4NodeInfo) Scrub() { -// slices.FilterInPlace(me, func(ni *NodeInfo) bool { -// ni.Addr.IP = ni.Addr.IP.To4() -// return ni.Addr.IP != nil -// }) -// } - func (me CompactIPv4NodeInfo) MarshalBinary() ([]byte, error) { return marshalBinarySlice(mapSlice(me, func(ni NodeInfo) NodeInfo { ni.Addr.IP = ni.Addr.IP.To4() diff --git a/krpc/compact_helpers.go b/krpc/compact_helpers.go index 4953e86ff..e9e4cbf34 100644 --- a/krpc/compact_helpers.go +++ b/krpc/compact_helpers.go @@ -4,6 +4,7 @@ import ( "encoding" "fmt" "reflect" + "slices" "github.com/anacrolix/torrent/bencode" ) @@ -41,7 +42,7 @@ func unmarshalBinarySlice(slice elemSizer, b []byte) (err error) { err = fmt.Errorf("%d trailing bytes < %d required for element", len(b), bytesPerElem) break } - if bu, ok := elem.Interface().(encoding.BinaryUnmarshaler); ok { + if bu, ok := reflect.TypeAssert[encoding.BinaryUnmarshaler](elem); ok { err = bu.UnmarshalBinary(b[:bytesPerElem]) } else if elem.Elem().Len() == bytesPerElem { reflect.Copy(elem.Elem(), reflect.ValueOf(b[:bytesPerElem])) @@ -83,12 +84,7 @@ func bencodeBytesResult(b []byte, err error) ([]byte, error) { return bencode.Marshal(b) } -// returns position of x in v, or -1 if not found +// Returns the position of x in v, or -1 if not found. func addrIndex(v []NodeAddr, x NodeAddr) int { - for i := 0; i < len(v); i += 1 { - if v[i].Equal(x) { - return i - } - } - return -1 + return slices.IndexFunc(v, x.Equal) } diff --git a/krpc/error.go b/krpc/error.go index de8a4d4e5..e1fc55f99 100644 --- a/krpc/error.go +++ b/krpc/error.go @@ -37,35 +37,36 @@ var ( _ error = Error{} ) -func (e *Error) UnmarshalBencode(_b []byte) (err error) { - var _v interface{} - err = bencode.Unmarshal(_b, &_v) - if err != nil { - return +func (e *Error) UnmarshalBencode(b []byte) error { + var v any + if err := bencode.Unmarshal(b, &v); err != nil { + return err } - switch v := _v.(type) { - case []interface{}: - func() { - defer func() { - r := recover() - if r == nil { - return - } - err = fmt.Errorf("unpacking %#v: %s", v, r) - }() - e.Code = int(v[0].(int64)) - e.Msg = v[1].(string) - }() + switch v := v.(type) { + case []any: + if len(v) < 2 { + return fmt.Errorf("unpacking %#v: expected code and message", v) + } + code, ok := v[0].(int64) + if !ok { + return fmt.Errorf("unpacking %#v: code has type %T", v, v[0]) + } + msg, ok := v[1].(string) + if !ok { + return fmt.Errorf("unpacking %#v: message has type %T", v, v[1]) + } + e.Code = int(code) + e.Msg = msg case string: e.Msg = v default: - err = fmt.Errorf(`KRPC error bencode value has unexpected type: %T`, _v) + return fmt.Errorf("KRPC error bencode value has unexpected type: %T", v) } - return + return nil } -func (e Error) MarshalBencode() (ret []byte, err error) { - return bencode.Marshal([]interface{}{e.Code, e.Msg}) +func (e Error) MarshalBencode() ([]byte, error) { + return bencode.Marshal([]any{e.Code, e.Msg}) } func (e Error) Error() string { diff --git a/krpc/fuzz_test.go b/krpc/fuzz_test.go index 7027757fe..530addeea 100644 --- a/krpc/fuzz_test.go +++ b/krpc/fuzz_test.go @@ -1,5 +1,4 @@ //go:build go1.18 -// +build go1.18 package krpc diff --git a/krpc/id.go b/krpc/id.go index 1eabaa7d5..18fe6a4dc 100644 --- a/krpc/id.go +++ b/krpc/id.go @@ -5,6 +5,7 @@ import ( "encoding" "encoding/hex" "fmt" + "io" "github.com/anacrolix/torrent/bencode" @@ -27,9 +28,9 @@ var ( _ fmt.Formatter = ID{} ) -func (h ID) Format(f fmt.State, c rune) { +func (id ID) Format(f fmt.State, c rune) { // See metainfo.Hash. - f.Write([]byte(h.String())) + io.WriteString(f, id.String()) } func IdFromString(s string) (id ID) { diff --git a/krpc/msg.go b/krpc/msg.go index b94c0bf94..66cfbaad1 100644 --- a/krpc/msg.go +++ b/krpc/msg.go @@ -51,7 +51,7 @@ type MsgArgs struct { // I don't know if we should use bencode.Bytes for this. If we unmarshalled bytes that didn't // marshal back the same, our hashes will not match. But this might also serve to prevent abuse. - V interface{} `bencode:"v,omitempty"` + V any `bencode:"v,omitempty"` // Why is this optional? Because I think we need to know if it wasn't set rather than use a // default value. Seq *int64 `bencode:"seq,omitempty"` @@ -135,8 +135,8 @@ func (m Msg) SenderID() *ID { return nil } -// This does not return an error, but (*Error)(nil) is still a non-nil error. You have been warned! -// This language is evil. +// Returns the error for an error-type message, or nil. The result is deliberately not of type +// error: a nil *Error stored in an error interface would compare non-nil. func (m Msg) Error() *Error { if m.Y != "e" { return nil diff --git a/krpc/msg_test.go b/krpc/msg_test.go index 11a706c38..29112c430 100644 --- a/krpc/msg_test.go +++ b/krpc/msg_test.go @@ -1,10 +1,10 @@ package krpc import ( + "crypto/rand" "encoding/hex" "fmt" "math" - "math/rand" "net" "strings" "testing" @@ -125,7 +125,7 @@ func TestMarshalUnmarshalMsg(t *testing.T) { testMarshalUnmarshalMsg(t, Msg{ R: &Return{ Bep44Return: Bep44Return{ - V: bencode.MustMarshal([]interface{}{"tee", "hee"}), + V: bencode.MustMarshal([]any{"tee", "hee"}), Seq: new(int64), K: k, Sig: sig, diff --git a/krpc/node-addr-port.go b/krpc/node-addr-port.go index 90172f96d..a82e6ca17 100644 --- a/krpc/node-addr-port.go +++ b/krpc/node-addr-port.go @@ -3,8 +3,6 @@ package krpc import ( "net" "net/netip" - - "github.com/anacrolix/multiless" ) // This is a comparable replacement for NodeAddr. @@ -27,9 +25,7 @@ func (me NodeAddrPort) IP() net.IP { return me.Addr().AsSlice() } -func (l NodeAddrPort) Compare(r NodeAddrPort) int { - return multiless.EagerOrdered( - multiless.New().Cmp(l.Addr().Compare(r.Addr())), - l.Port(), r.Port(), - ).OrderingInt() +// Orders by address, then port. +func (me NodeAddrPort) Compare(r NodeAddrPort) int { + return me.AddrPort.Compare(r.AddrPort) } diff --git a/krpc/nodeaddr.go b/krpc/nodeaddr.go index e3f86649c..63f0116dc 100644 --- a/krpc/nodeaddr.go +++ b/krpc/nodeaddr.go @@ -1,7 +1,6 @@ package krpc import ( - "bytes" "encoding/binary" "fmt" "net" @@ -52,10 +51,9 @@ func (me *NodeAddr) UnmarshalBencode(b []byte) (err error) { } func (me NodeAddr) MarshalBinary() ([]byte, error) { - var b bytes.Buffer - b.Write(me.IP) - binary.Write(&b, binary.BigEndian, uint16(me.Port)) - return b.Bytes(), nil + b := make([]byte, 0, len(me.IP)+2) + b = append(b, me.IP...) + return binary.BigEndian.AppendUint16(b, uint16(me.Port)), nil } func (me NodeAddr) MarshalBencode() ([]byte, error) { diff --git a/krpc/nodeinfo.go b/krpc/nodeinfo.go index 6b07e729f..acaa99a68 100644 --- a/krpc/nodeinfo.go +++ b/krpc/nodeinfo.go @@ -1,12 +1,12 @@ package krpc import ( - "bytes" + "crypto/rand" "encoding" "encoding/binary" "fmt" "math" - "math/rand" + mathrand "math/rand/v2" "net" ) @@ -27,7 +27,7 @@ func RandomNodeInfo(ipLen int) (ni NodeInfo) { rand.Read(ni.ID[:]) ni.Addr.IP = make(net.IP, ipLen) rand.Read(ni.Addr.IP) - ni.Addr.Port = rand.Intn(math.MaxUint16 + 1) + ni.Addr.Port = mathrand.IntN(math.MaxUint16 + 1) return } @@ -36,15 +36,17 @@ var _ interface { encoding.BinaryUnmarshaler } = (*NodeInfo)(nil) -func (ni NodeInfo) MarshalBinary() ([]byte, error) { - var w bytes.Buffer - w.Write(ni.ID[:]) - w.Write(ni.Addr.IP) - binary.Write(&w, binary.BigEndian, uint16(ni.Addr.Port)) - return w.Bytes(), nil +func (me NodeInfo) MarshalBinary() ([]byte, error) { + b := make([]byte, 0, len(me.ID)+len(me.Addr.IP)+2) + b = append(b, me.ID[:]...) + b = append(b, me.Addr.IP...) + return binary.BigEndian.AppendUint16(b, uint16(me.Addr.Port)), nil } -func (ni *NodeInfo) UnmarshalBinary(b []byte) error { - copy(ni.ID[:], b) - return ni.Addr.UnmarshalBinary(b[20:]) +func (me *NodeInfo) UnmarshalBinary(b []byte) error { + if len(b) < len(me.ID) { + return fmt.Errorf("unmarshal NodeInfo from %d bytes: need at least %d", len(b), len(me.ID)) + } + copy(me.ID[:], b) + return me.Addr.UnmarshalBinary(b[len(me.ID):]) } diff --git a/misc.go b/misc.go index c2521f431..7a528975f 100644 --- a/misc.go +++ b/misc.go @@ -1,28 +1,11 @@ package dht import ( - "net" - "github.com/anacrolix/dht/v2/int160" "github.com/anacrolix/dht/v2/krpc" "github.com/anacrolix/dht/v2/types" ) -func mustListen(addr string) net.PacketConn { - ret, err := net.ListenPacket("udp", addr) - if err != nil { - panic(err) - } - return ret -} - -func addrResolver(addr string) func() ([]Addr, error) { - return func() ([]Addr, error) { - ua, err := net.ResolveUDPAddr("udp", addr) - return []Addr{NewAddr(ua)}, err - } -} - type addrMaybeId = types.AddrMaybeId func randomIdInBucket(rootId int160.T, bucketIndex int) int160.T { diff --git a/misc_test.go b/misc_test.go index 745a87dc6..5077b927c 100644 --- a/misc_test.go +++ b/misc_test.go @@ -1 +1,20 @@ package dht + +import ( + "net" +) + +func mustListen(addr string) net.PacketConn { + ret, err := net.ListenPacket("udp", addr) + if err != nil { + panic(err) + } + return ret +} + +func addrResolver(addr string) func() ([]Addr, error) { + return func() ([]Addr, error) { + ua, err := net.ResolveUDPAddr("udp", addr) + return []Addr{NewAddr(ua)}, err + } +} diff --git a/nearest-nodes.go b/nearest-nodes.go deleted file mode 100644 index 745a87dc6..000000000 --- a/nearest-nodes.go +++ /dev/null @@ -1 +0,0 @@ -package dht diff --git a/node.go b/node.go index ae656b678..cc64ec7a1 100644 --- a/node.go +++ b/node.go @@ -34,16 +34,11 @@ func (n *node) IsSecure() bool { return NodeIdSecure(n.Id.AsByteArray(), n.Addr.IP()) } -func (n *node) idString() string { - return n.Id.ByteString() -} - -func (n *node) NodeInfo() (ret krpc.NodeInfo) { - ret.Addr = n.Addr.KRPC() - if n := copy(ret.ID[:], n.idString()); n != 20 { - panic(n) +func (n *node) NodeInfo() krpc.NodeInfo { + return krpc.NodeInfo{ + ID: n.Id.AsByteArray(), + Addr: n.Addr.KRPC(), } - return } // Per the spec in BEP 5. diff --git a/nodes_file.go b/nodes_file.go index 31704ea0a..e756c5bbe 100644 --- a/nodes_file.go +++ b/nodes_file.go @@ -1,43 +1,25 @@ package dht import ( - "io/ioutil" "os" "github.com/anacrolix/dht/v2/krpc" ) -func WriteNodesToFile(ns []krpc.NodeInfo, fileName string) (err error) { +func WriteNodesToFile(ns []krpc.NodeInfo, fileName string) error { b, err := krpc.CompactIPv6NodeInfo(ns).MarshalBinary() if err != nil { - return + return err } - f, err := os.OpenFile(fileName, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640) - if err != nil { - return - } - defer func() { - closeErr := f.Close() - if err == nil { - err = closeErr - } - }() - _, err = f.Write(b) - return + return os.WriteFile(fileName, b, 0o640) } -func ReadNodesFromFile(fileName string) (ns []krpc.NodeInfo, err error) { - f, err := os.Open(fileName) - if err != nil { - return - } - defer f.Close() - b, err := ioutil.ReadAll(f) +func ReadNodesFromFile(fileName string) ([]krpc.NodeInfo, error) { + b, err := os.ReadFile(fileName) if err != nil { - return + return nil, err } var cnis krpc.CompactIPv6NodeInfo err = cnis.UnmarshalBinary(b) - ns = cnis - return + return cnis, err } diff --git a/nodes_file_test.go b/nodes_file_test.go index 544970317..6dcd1ec4d 100644 --- a/nodes_file_test.go +++ b/nodes_file_test.go @@ -1,8 +1,7 @@ package dht import ( - "io/ioutil" - "os" + "path/filepath" "testing" "github.com/anacrolix/dht/v2/krpc" @@ -11,13 +10,10 @@ import ( ) func TestSaveLoadNodesFile(t *testing.T) { - f, err := ioutil.TempFile("", "") - qt.Assert(t, qt.IsNil(err)) - defer os.Remove(f.Name()) - f.Close() + name := filepath.Join(t.TempDir(), "nodes") ns := []krpc.NodeInfo{krpc.RandomNodeInfo(4), krpc.RandomNodeInfo(16)} - qt.Assert(t, qt.IsNil(WriteNodesToFile(ns, f.Name()))) - _ns, err := ReadNodesFromFile(f.Name()) + qt.Assert(t, qt.IsNil(WriteNodesToFile(ns, name))) + _ns, err := ReadNodesFromFile(name) qt.Check(t, qt.IsNil(err)) _ns[0].Addr.IP = _ns[0].Addr.IP.To4() qt.Check(t, qt.DeepEquals(_ns, ns)) diff --git a/peer-store/in-memory.go b/peer-store/in-memory.go index 6a0520838..6466aa70e 100644 --- a/peer-store/in-memory.go +++ b/peer-store/in-memory.go @@ -2,14 +2,14 @@ package peer_store import ( "bytes" + "cmp" "fmt" "io" - "sort" + "maps" + "slices" "sync" "time" - "github.com/anacrolix/multiless" - "github.com/anacrolix/dht/v2/int160" "github.com/anacrolix/dht/v2/krpc" ) @@ -25,12 +25,9 @@ type InMemory struct { // authoritative for endpoint and timestamp data. type indexValue = map[string]NodeAndTime -type debugWriterInterface interface { - WriteDebug(w io.Writer) -} - var _ interface { - debugWriterInterface + Interface + WriteDebug(w io.Writer) } = (*InMemory)(nil) func (me *InMemory) GetPeers(ih InfoHash) (ret []krpc.NodeAddr) { @@ -40,11 +37,9 @@ func (me *InMemory) GetPeers(ih InfoHash) (ret []krpc.NodeAddr) { if len(nodes) == 0 { return } - ret = make([]krpc.NodeAddr, len(nodes)) - i := 0 + ret = make([]krpc.NodeAddr, 0, len(nodes)) for _, v := range nodes { - ret[i] = v.NodeAddr - i++ + ret = append(ret, v.NodeAddr) } return } @@ -74,9 +69,7 @@ func (me *InMemory) GetAll() (ret map[InfoHash][]NodeAndTime) { defer me.mu.RUnlock() ret = make(map[InfoHash][]NodeAndTime, len(me.index)) for ih, nodes := range me.index { - for _, v := range nodes { - ret[ih] = append(ret[ih], v) - } + ret[ih] = slices.Collect(maps.Values(nodes)) } return } @@ -84,29 +77,24 @@ func (me *InMemory) GetAll() (ret map[InfoHash][]NodeAndTime) { func (me *InMemory) WriteDebug(w io.Writer) { all := me.GetAll() var totalCount int - type sliceElem struct { - InfoHash - addrs []NodeAndTime - } - var allSlice []sliceElem - for ih, addrs := range all { + for _, addrs := range all { totalCount += len(addrs) - allSlice = append(allSlice, sliceElem{ih, addrs}) } fmt.Fprintf(w, "total count: %v\n\n", totalCount) - sort.Slice(allSlice, func(i, j int) bool { - return int160.Distance(int160.FromByteArray(allSlice[i].InfoHash), me.RootId).Cmp( - int160.Distance(int160.FromByteArray(allSlice[j].InfoHash), me.RootId)) < 0 + infoHashes := slices.SortedFunc(maps.Keys(all), func(l, r InfoHash) int { + return int160.Distance(int160.FromByteArray(l), me.RootId).Cmp( + int160.Distance(int160.FromByteArray(r), me.RootId)) }) - for _, elem := range allSlice { - addrs := elem.addrs - fmt.Fprintf(w, "%v (count %v):\n", elem.InfoHash, len(addrs)) - sort.Slice(addrs, func(i, j int) bool { - return multiless.New().Cmp( - bytes.Compare(addrs[i].IP, addrs[j].IP)).Int64( - addrs[j].Time.UnixNano(), addrs[i].Time.UnixNano()).Int( - addrs[i].Port, addrs[j].Port, - ).MustLess() + for _, ih := range infoHashes { + addrs := all[ih] + fmt.Fprintf(w, "%v (count %v):\n", ih, len(addrs)) + // By IP, then most recent first, then port. + slices.SortFunc(addrs, func(l, r NodeAndTime) int { + return cmp.Or( + bytes.Compare(l.IP, r.IP), + r.Time.Compare(l.Time), + cmp.Compare(l.Port, r.Port), + ) }) for _, na := range addrs { fmt.Fprintf(w, "\t%v (age: %v)\n", na.NodeAddr, time.Since(na.Time)) diff --git a/peer-store/in-memory_test.go b/peer-store/in-memory_test.go index 5e4eaf01a..9bb469505 100644 --- a/peer-store/in-memory_test.go +++ b/peer-store/in-memory_test.go @@ -196,20 +196,15 @@ func TestInMemoryPeerStoreConcurrentAccess(t *testing.T) { var readers sync.WaitGroup for _, endpoint := range endpoints { - endpoint := endpoint - writers.Add(1) - go func() { - defer writers.Done() + writers.Go(func() { <-start for range 100 { store.AddPeer(ih, endpoint) } - }() + }) } for range 4 { - readers.Add(1) - go func() { - defer readers.Done() + readers.Go(func() { <-start for { select { @@ -229,7 +224,7 @@ func TestInMemoryPeerStoreConcurrentAccess(t *testing.T) { } } } - }() + }) } close(start) diff --git a/security.go b/security.go index d1537e948..2c599092b 100644 --- a/security.go +++ b/security.go @@ -7,13 +7,13 @@ import ( "github.com/anacrolix/dht/v2/krpc" ) +var castagnoliTable = crc32.MakeTable(crc32.Castagnoli) + func maskForIP(ip net.IP) []byte { - switch { - case ip.To4() != nil: + if ip.To4() != nil { return []byte{0x03, 0x0f, 0x3f, 0xff} - default: - return []byte{0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff} } + return []byte{0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff} } // Generate the CRC used to make or validate secure node ID. @@ -21,15 +21,13 @@ func crcIP(ip net.IP, rand uint8) uint32 { if ip4 := ip.To4(); ip4 != nil { ip = ip4 } - // Copy IP so we can make changes. Go sux at this. - ip = append(make(net.IP, 0, len(ip)), ip...) mask := maskForIP(ip) + masked := make([]byte, len(mask)) for i := range mask { - ip[i] &= mask[i] + masked[i] = ip[i] & mask[i] } - r := rand & 7 - ip[0] |= r << 5 - return crc32.Checksum(ip[:len(mask)], crc32.MakeTable(crc32.Castagnoli)) + masked[0] |= (rand & 7) << 5 + return crc32.Checksum(masked, castagnoliTable) } // Makes a node ID secure, in-place. The ID is 20 raw bytes. @@ -47,23 +45,17 @@ func NodeIdSecure(id [20]byte, ip net.IP) bool { if isLocalNetwork(ip) { return true } - if ip4 := ip.To4(); ip4 != nil { - ip = ip4 - } crc := crcIP(ip, id[19]) - if id[0] != byte(crc>>24&0xff) { - return false - } - if id[1] != byte(crc>>16&0xff) { - return false - } - if id[2]&0xf8 != byte(crc>>8&0xf8) { - return false - } - return true + return id[0] == byte(crc>>24&0xff) && + id[1] == byte(crc>>16&0xff) && + id[2]&0xf8 == byte(crc>>8&0xf8) } -var classA, classB, classC *net.IPNet +var localNetworks = []*net.IPNet{ + mustParseCIDRIPNet("10.0.0.0/8"), + mustParseCIDRIPNet("172.16.0.0/12"), + mustParseCIDRIPNet("192.168.0.0/16"), +} func mustParseCIDRIPNet(s string) *net.IPNet { _, ret, err := net.ParseCIDR(s) @@ -73,30 +65,14 @@ func mustParseCIDRIPNet(s string) *net.IPNet { return ret } -func init() { - classA = mustParseCIDRIPNet("10.0.0.0/8") - classB = mustParseCIDRIPNet("172.16.0.0/12") - classC = mustParseCIDRIPNet("192.168.0.0/16") -} - // Per http://www.libtorrent.org/dht_sec.html#enforcement, the IP is // considered a local network address and should be exempted from node ID // verification. func isLocalNetwork(ip net.IP) bool { - if classA.Contains(ip) { - return true - } - if classB.Contains(ip) { - return true - } - if classC.Contains(ip) { - return true - } - if ip.IsLinkLocalUnicast() { - return true - } - if ip.IsLoopback() { - return true + for _, n := range localNetworks { + if n.Contains(ip) { + return true + } } - return false + return ip.IsLinkLocalUnicast() || ip.IsLoopback() } diff --git a/server.go b/server.go index 0e935785c..4f08fb5e9 100644 --- a/server.go +++ b/server.go @@ -20,7 +20,6 @@ import ( "github.com/anacrolix/torrent/bencode" "github.com/anacrolix/torrent/iplist" "github.com/anacrolix/torrent/metainfo" - "golang.org/x/time/rate" "github.com/anacrolix/dht/v2/bep44" "github.com/anacrolix/dht/v2/int160" @@ -45,14 +44,12 @@ type Server struct { mu sync.RWMutex transactions transactions.Dispatcher[*transaction] - nextT uint64 // unique "t" field for outbound queries table table closed chansync.SetOnce ipBlockList iplist.Ranger tokenServer tokenServer // Manages tokens we issue to our queriers. config ServerConfig stats ServerStats - sendLimit *rate.Limiter lastBootstrap time.Time bootstrappingNow bool @@ -252,10 +249,7 @@ func (s *Server) serveUntilClosed() { err := s.serve() s.mu.Lock() defer s.mu.Unlock() - if s.closed.IsSet() { - return - } - if err != nil { + if !s.closed.IsSet() { panic(err) } } @@ -277,7 +271,6 @@ func (s *Server) IPBlocklist() iplist.Ranger { } func (s *Server) processPacket(b []byte, addr Addr) { - // log.Printf("got packet %q", b) if len(b) < 2 || b[0] != 'd' { // KRPC messages are bencoded dicts. readNotKRPCDict.Add(1) @@ -285,31 +278,13 @@ func (s *Server) processPacket(b []byte, addr Addr) { } var d krpc.Msg err := bencode.Unmarshal(b, &d) - if _, ok := err.(bencode.ErrUnusedTrailingBytes); ok { - // log.Printf("%s: received message packet with %d trailing bytes: %q", s, _err.NumUnusedBytes, b[len(b)-_err.NumUnusedBytes:]) + if _, ok := errors.AsType[bencode.ErrUnusedTrailingBytes](err); ok { expvars.Add("processed packets with trailing bytes", 1) } else if err != nil { readUnmarshalError.Add(1) - // log.Printf("%s: received bad krpc message from %s: %s: %+q", s, addr, err, b) - func() { - if se, ok := err.(*bencode.SyntaxError); ok { - // The message was truncated. - if int(se.Offset) == len(b) { - return - } - // Some messages seem to drop to nul chars abruptly. - if int(se.Offset) < len(b) && b[se.Offset] == 0 { - return - } - // The message isn't bencode from the first. - if se.Offset == 0 { - return - } - } - // if missinggo.CryHeard() { - log.Printf("%s: received bad krpc message from %s: %s: %+q", s, addr, err, b) - // } - }() + if !uninterestingUnmarshalError(err, b) { + s.logger().Printf("received bad krpc message from %s: %s: %+q", addr, err, b) + } return } s.mu.Lock() @@ -332,15 +307,25 @@ func (s *Server) processPacket(b []byte, addr Addr) { return } t := s.transactions.Pop(tk) - // s.logger().Printf("received response for transaction %q from %v", d.T, addr) go t.handleResponse(d) - s.updateNode(addr, d.SenderID(), !d.ReadOnly, func(n *node) { + _ = s.updateNode(addr, d.SenderID(), !d.ReadOnly, func(n *node) { n.lastGotResponse = time.Now() n.failedLastQuestionablePing = false n.numReceivesFrom++ }) } +// Reports whether a bencode decoding error is common junk not worth logging: truncated messages, +// messages that drop to NUL bytes abruptly, or data that isn't bencode at all. +func uninterestingUnmarshalError(err error, b []byte) bool { + se, ok := errors.AsType[*bencode.SyntaxError](err) + if !ok { + return false + } + off := int(se.Offset) + return off == 0 || off == len(b) || off < len(b) && b[off] == 0 +} + func (s *Server) serve() error { var b [0x10000]byte for { @@ -396,37 +381,23 @@ func (s *Server) AddNode(ni krpc.NodeInfo) error { } s.mu.Lock() defer s.mu.Unlock() - return s.updateNode(NewAddr(ni.Addr.UDP()), (*krpc.ID)(&ni.ID), true, func(*node) {}) -} - -func wantsContain(ws []krpc.Want, w krpc.Want) bool { - for _, _w := range ws { - if _w == w { - return true - } - } - return false + return s.updateNode(NewAddr(ni.Addr.UDP()), &ni.ID, true, func(*node) {}) } func shouldReturnNodes(queryWants []krpc.Want, querySource net.IP) bool { if len(queryWants) != 0 { - return wantsContain(queryWants, krpc.WantNodes) + return slices.Contains(queryWants, krpc.WantNodes) } - // Is it possible to be over IPv6 with IPv4 endpoints? return querySource.To4() != nil } func shouldReturnNodes6(queryWants []krpc.Want, querySource net.IP) bool { if len(queryWants) != 0 { - return wantsContain(queryWants, krpc.WantNodes6) + return slices.Contains(queryWants, krpc.WantNodes6) } return querySource.To4() == nil } -func (s *Server) makeReturnNodes(target int160.T, filter func(krpc.NodeAddr) bool) []krpc.NodeInfo { - return s.closestGoodNodeInfos(8, target, filter) -} - var krpcErrMissingArguments = krpc.Error{ Code: krpc.ErrorCodeProtocolError, Msg: "missing arguments dict", @@ -434,47 +405,44 @@ var krpcErrMissingArguments = krpc.Error{ // Filters peers per BEP 32 to return in the values field to a get_peers query. func filterPeers(querySourceIp net.IP, queryWants []krpc.Want, allPeers []krpc.NodeAddr) (filtered []krpc.NodeAddr) { - // The logic here is common with nodes, see BEP 32. retain4 := shouldReturnNodes(queryWants, querySourceIp) retain6 := shouldReturnNodes6(queryWants, querySourceIp) for _, peer := range allPeers { - if ip, ok := func(ip net.IP) (net.IP, bool) { - as4 := peer.IP.To4() - as16 := peer.IP.To16() - switch { - case retain4 && len(ip) == net.IPv4len: - return ip, true - case retain6 && len(ip) == net.IPv6len: - return ip, true - case retain4 && as4 != nil: - // Is it possible that we're converting to an IPv4 address when the transport in use - // is IPv6? - return as4, true - case retain6 && as16 != nil: - // Couldn't any IPv4 address be converted to IPv6, but isn't listening over IPv6? - return as16, true - default: - return nil, false - } - }(peer.IP); ok { - filtered = append(filtered, krpc.NodeAddr{IP: ip, Port: peer.Port}) + ip := peer.IP + switch { + case retain4 && len(ip) == net.IPv4len, retain6 && len(ip) == net.IPv6len: + case retain4 && ip.To4() != nil: + ip = ip.To4() + case retain6 && ip.To16() != nil: + ip = ip.To16() + default: + continue } + filtered = append(filtered, krpc.NodeAddr{IP: ip, Port: peer.Port}) } return } -func (s *Server) setReturnNodes(r *krpc.Return, queryMsg krpc.Msg, querySource Addr) *krpc.Error { - if queryMsg.A == nil { - return &krpcErrMissingArguments +// Sets the BEP 32 node fields of r to the good nodes closest to target. +func (s *Server) setReturnNodes(r *krpc.Return, target krpc.ID, wants []krpc.Want, querySource Addr) { + targetInt160 := target.Int160() + if shouldReturnNodes(wants, querySource.IP()) { + r.Nodes = s.closestGoodNodeInfos(8, targetInt160, func(na krpc.NodeAddr) bool { return na.IP.To4() != nil }) + } + if shouldReturnNodes6(wants, querySource.IP()) { + r.Nodes6 = s.closestGoodNodeInfos(8, targetInt160, func(krpc.NodeAddr) bool { return true }) } - target := int160.FromByteArray(queryMsg.A.InfoHash) - if shouldReturnNodes(queryMsg.A.Want, querySource.IP()) { - r.Nodes = s.makeReturnNodes(target, func(na krpc.NodeAddr) bool { return na.IP.To4() != nil }) +} + +// Converts an error from the BEP 44 store into one suitable for returning to the querying node. +func storeError(err error) krpc.Error { + if kerr, ok := errors.AsType[krpc.Error](err); ok { + return kerr } - if shouldReturnNodes6(queryMsg.A.Want, querySource.IP()) { - r.Nodes6 = s.makeReturnNodes(target, func(krpc.NodeAddr) bool { return true }) + return krpc.Error{ + Code: krpc.ErrorCodeGenericError, + Msg: err.Error(), } - return nil } func (s *Server) handleQuery(source Addr, m krpc.Msg) { @@ -489,173 +457,145 @@ func (s *Server) handleQuery(source Addr, m krpc.Msg) { } } }() - s.updateNode(source, m.SenderID(), !m.ReadOnly, func(n *node) { + _ = s.updateNode(source, m.SenderID(), !m.ReadOnly, func(n *node) { n.lastGotQuery = time.Now() n.numReceivesFrom++ }) - if s.config.OnQuery != nil { - propagate := s.config.OnQuery(&m, source.Raw()) - if !propagate { - return - } + if s.config.OnQuery != nil && !s.config.OnQuery(&m, source.Raw()) { + return } - // Don't respond. if s.config.Passive { return } - // TODO: Should we disallow replying to ourself? - args := m.A + var handle func(source Addr, t string, args *krpc.MsgArgs) switch m.Q { case "ping": s.reply(source, m.T, krpc.Return{}) + return case "get_peers": - // Check for the naked m.A.Want deref below. - if m.A == nil { - s.sendError(source, m.T, krpcErrMissingArguments) - break - } - var r krpc.Return - if ps := s.config.PeerStore; ps != nil { - r.Values = filterPeers(source.IP(), m.A.Want, ps.GetPeers(peer_store.InfoHash(args.InfoHash))) - r.Token = func() *string { - t := s.createToken(source) - return &t - }() - } - if len(r.Values) == 0 { - if err := s.setReturnNodes(&r, m, source); err != nil { - s.sendError(source, m.T, *err) - break - } - } - s.reply(source, m.T, r) + handle = s.handleGetPeers case "find_node": - var r krpc.Return - if err := s.setReturnNodes(&r, m, source); err != nil { - s.sendError(source, m.T, *err) - break - } - s.reply(source, m.T, r) + handle = s.handleFindNode case "announce_peer": - if !s.validToken(args.Token, source) { - expvars.Add("received announce_peer with invalid token", 1) - return - } - expvars.Add("received announce_peer with valid token", 1) + handle = s.handleAnnouncePeer + case "put": + handle = s.handlePut + case "get": + handle = s.handleGet + default: + // TODO: http://libtorrent.org/dht_extensions.html#forward-compatibility + s.sendError(source, m.T, krpc.ErrorMethodUnknown) + return + } + if m.A == nil { + s.sendError(source, m.T, krpcErrMissingArguments) + return + } + handle(source, m.T, m.A) +} - var port int - portOk := false - if args.Port != nil { - port = *args.Port - portOk = true - } - if args.ImpliedPort { - expvars.Add("received announce_peer with implied_port", 1) - port = source.Port() - portOk = true - } - if !portOk { - expvars.Add("received announce_peer with no derivable port", 1) - } +func (s *Server) handleGetPeers(source Addr, t string, args *krpc.MsgArgs) { + var r krpc.Return + if ps := s.config.PeerStore; ps != nil { + r.Values = filterPeers(source.IP(), args.Want, ps.GetPeers(peer_store.InfoHash(args.InfoHash))) + token := s.createToken(source) + r.Token = &token + } + if len(r.Values) == 0 { + s.setReturnNodes(&r, args.InfoHash, args.Want, source) + } + s.reply(source, t, r) +} - if h := s.config.OnAnnouncePeer; h != nil { - go h(metainfo.Hash(args.InfoHash), source.IP(), port, portOk) - } - if ps := s.config.PeerStore; ps != nil { - go ps.AddPeer( - peer_store.InfoHash(args.InfoHash), - krpc.NodeAddr{IP: source.IP(), Port: port}, - ) - } +func (s *Server) handleFindNode(source Addr, t string, args *krpc.MsgArgs) { + var r krpc.Return + s.setReturnNodes(&r, args.Target, args.Want, source) + s.reply(source, t, r) +} - s.reply(source, m.T, krpc.Return{}) - case "put": - if !s.validToken(args.Token, source) { - expvars.Add("received put with invalid token", 1) - return - } - expvars.Add("received put with valid token", 1) +func (s *Server) handleAnnouncePeer(source Addr, t string, args *krpc.MsgArgs) { + if !s.validToken(args.Token, source) { + expvars.Add("received announce_peer with invalid token", 1) + return + } + expvars.Add("received announce_peer with valid token", 1) + var port int + portOk := false + if args.Port != nil { + port = *args.Port + portOk = true + } + if args.ImpliedPort { + expvars.Add("received announce_peer with implied_port", 1) + port = source.Port() + portOk = true + } + if !portOk { + expvars.Add("received announce_peer with no derivable port", 1) + } + if h := s.config.OnAnnouncePeer; h != nil { + go h(metainfo.Hash(args.InfoHash), source.IP(), port, portOk) + } + if ps := s.config.PeerStore; ps != nil { + go ps.AddPeer( + peer_store.InfoHash(args.InfoHash), + krpc.NodeAddr{IP: source.IP(), Port: port}, + ) + } + s.reply(source, t, krpc.Return{}) +} +func (s *Server) handlePut(source Addr, t string, args *krpc.MsgArgs) { + if !s.validToken(args.Token, source) { + expvars.Add("received put with invalid token", 1) + return + } + expvars.Add("received put with valid token", 1) + i := &bep44.Item{ + V: args.V, + K: args.K, + Salt: args.Salt, + Sig: args.Sig, + Cas: args.Cas, + } + if i.IsMutable() { if args.Seq == nil { - s.sendError(source, m.T, krpc.Error{ + s.sendError(source, t, krpc.Error{ Code: krpc.ErrorCodeProtocolError, - Msg: "expected seq argument", + Msg: "expected seq argument for mutable item", }) return } + i.Seq = *args.Seq + } + if err := s.store.Put(i); err != nil { + s.sendError(source, t, storeError(err)) + return + } + s.reply(source, t, krpc.Return{}) +} - i := &bep44.Item{ - V: args.V, - K: args.K, - Salt: args.Salt, - Sig: args.Sig, - Cas: args.Cas, - Seq: *args.Seq, - } - - if err := s.store.Put(i); err != nil { - kerr, ok := err.(krpc.Error) - if !ok { - s.sendError(source, m.T, krpc.ErrorMethodUnknown) - break - } - - s.sendError(source, m.T, kerr) - break - } - - s.reply(source, m.T, krpc.Return{ - ID: s.ID(), - }) - case "get": - var r krpc.Return - if err := s.setReturnNodes(&r, m, source); err != nil { - s.sendError(source, m.T, *err) - break - } - - t := s.createToken(source) - r.Token = &t - - item, err := s.store.Get(bep44.Target(args.Target)) - if err == bep44.ErrItemNotFound { - s.reply(source, m.T, r) - break - } - - if kerr, ok := err.(krpc.Error); ok { - s.sendError(source, m.T, kerr) - break - } - - if err != nil { - s.sendError(source, m.T, krpc.Error{ - Code: krpc.ErrorCodeGenericError, - Msg: err.Error(), - }) - break - } - - r.Seq = &item.Seq - - if args.Seq != nil && item.Seq <= *args.Seq { - s.reply(source, m.T, r) - break - } - +func (s *Server) handleGet(source Addr, t string, args *krpc.MsgArgs) { + var r krpc.Return + s.setReturnNodes(&r, args.Target, args.Want, source) + token := s.createToken(source) + r.Token = &token + item, err := s.store.Get(bep44.Target(args.Target)) + if errors.Is(err, bep44.ErrItemNotFound) { + s.reply(source, t, r) + return + } + if err != nil { + s.sendError(source, t, storeError(err)) + return + } + r.Seq = &item.Seq + if args.Seq == nil || item.Seq > *args.Seq { r.V = bencode.MustMarshal(item.V) r.K = item.K r.Sig = item.Sig - - s.reply(source, m.T, r) - // case "sample_infohashes": - // // Nodes supporting this extension should always include the samples field in the response, - // // even when it is zero-length. This lets indexing nodes to distinguish nodes supporting this - // // extension from those that respond to unknown query types which contain a target field [2]. - default: - // TODO: http://libtorrent.org/dht_extensions.html#forward-compatibility - s.sendError(source, m.T, krpc.ErrorMethodUnknown) } + s.reply(source, t, r) } func (s *Server) sendError(addr Addr, t string, e krpc.Error) { @@ -772,7 +712,7 @@ func (s *Server) nodeErr(n *node) error { if n.Id.IsZero() { return errors.New("has zero id") } - if !(s.config.NoSecurity || n.IsSecure()) { + if !s.config.NoSecurity && !n.IsSecure() { return errors.New("not secure") } if n.failedLastQuestionablePing { @@ -783,8 +723,6 @@ func (s *Server) nodeErr(n *node) error { func (s *Server) writeToNode(ctx context.Context, b []byte, node Addr, wait, rate bool) (wrote bool, err error) { func() { - // This is a pain. It would be better if the blocklist returned an error if it was closed - // instead. s.mu.RLock() defer s.mu.RUnlock() if s.closed.IsSet() { @@ -801,7 +739,6 @@ func (s *Server) writeToNode(ctx context.Context, b []byte, node Addr, wait, rat if err != nil { return } - // s.config.Logger.WithValues(log.Debug).Printf("writing to %s: %q", node.String(), b) if rate { if wait { err = s.config.SendLimiter.Wait(ctx) @@ -825,10 +762,10 @@ func (s *Server) writeToNode(ctx context.Context, b []byte, node Addr, wait, rat if err != nil { writeErrors.Add(1) if rate { - // Give the token back. nfi if this will actually work. + // Return the token consumed by the failed write. s.config.SendLimiter.AllowN(time.Now(), -1) } - err = fmt.Errorf("error writing %d bytes to %s: %s", len(b), node, err) + err = fmt.Errorf("writing %d bytes to %s: %w", len(b), node, err) return } wrote = true @@ -844,9 +781,7 @@ func (s *Server) nextTransactionID() string { } func (s *Server) deleteTransaction(k transactionKey) { - if s.transactions.Have(k) { - s.transactions.Pop(k) - } + s.transactions.Delete(k) } func (s *Server) addTransaction(k transactionKey, t *transaction) { @@ -907,8 +842,8 @@ func (qr QueryResult) ToError() error { } // Converts a Server QueryResult to a traversal.QueryResult. -func (me QueryResult) TraversalQueryResult(addr krpc.NodeAddr) (ret traversal.QueryResult) { - r := me.Reply.R +func (qr QueryResult) TraversalQueryResult(addr krpc.NodeAddr) (ret traversal.QueryResult) { + r := qr.Reply.R if r == nil { return } @@ -925,9 +860,7 @@ func (me QueryResult) TraversalQueryResult(addr krpc.NodeAddr) (ret traversal.Qu } // Rate-limiting to be applied to writes for a given query. Queries occur inside transactions that -// will attempt to send several times. If the STM rate-limiting helpers are used, the first send is -// often already accounted for in the rate-limiting machinery before the query method that does the -// IO is invoked. +// may send several times. type QueryRateLimiting struct { // Don't rate-limit the first send for a query. NotFirst bool @@ -972,20 +905,17 @@ func (s *Server) Query(ctx context.Context, addr Addr, q string, input QueryInpu tk.T = tid s.addTransaction(tk, t) s.mu.Unlock() - // Receives a non-nil error from the sender, and closes when the sender completes. + // Receives the sender's terminal error, and closes when the sender completes. sendErr := make(chan error, 1) sendCtx, cancelSend := context.WithCancel(pprof.WithLabels(ctx, pprof.Labels("q", q))) go func() { - err := s.transactionQuerySender( + sendErr <- s.transactionQuerySender( sendCtx, s.makeQueryBytes(q, input.MsgArgs, tid), &ret.Writes, addr, input.RateLimiting, input.NumTries) - if err != nil { - sendErr <- err - } close(sendErr) }() expvars.Add(fmt.Sprintf("outbound %s queries", q), 1) @@ -1014,30 +944,16 @@ func (s *Server) transactionQuerySender( rateLimiting QueryRateLimiting, numTries int, ) error { - // log.Printf("sending %q", b) err := transactionSender( sendCtx, func() error { - wrote, err := s.writeToNode(sendCtx, b, addr, - // We only wait for the first write by default if rate-limiting is enabled for this - // query. - func() bool { - if *writes == 0 { - return !rateLimiting.NoWaitFirst - } else { - return rateLimiting.WaitOnRetries - } - }(), - func() bool { - if rateLimiting.NotAny { - return false - } - if *writes == 0 { - return !rateLimiting.NotFirst - } - return true - }(), - ) + first := *writes == 0 + wait := rateLimiting.WaitOnRetries + if first { + wait = !rateLimiting.NoWaitFirst + } + rate := !rateLimiting.NotAny && (!first || !rateLimiting.NotFirst) + wrote, err := s.writeToNode(sendCtx, b, addr, wait, rate) if wrote { *writes++ } @@ -1086,13 +1002,13 @@ func (s *Server) Put(ctx context.Context, node Addr, i bep44.Put, token string, qi := QueryInput{ MsgArgs: krpc.MsgArgs{ Cas: i.Cas, - ID: s.ID(), Salt: i.Salt, Seq: &i.Seq, Sig: i.Sig, Token: token, V: i.V, }, + RateLimiting: rl, } if i.K != nil { qi.MsgArgs.K = *i.K @@ -1225,7 +1141,6 @@ func (s *Server) GetPeers( func (s *Server) Get(ctx context.Context, addr Addr, target bep44.Target, seq *int64, rl QueryRateLimiting) QueryResult { return s.Query(ctx, addr, "get", QueryInput{ MsgArgs: krpc.MsgArgs{ - ID: s.ID(), Target: target, Seq: seq, Want: []krpc.Want{krpc.WantNodes, krpc.WantNodes6}, @@ -1274,8 +1189,6 @@ func (s *Server) TraversalStartingNodes() (nodes []addrMaybeId, err error) { addrs, err := s.config.StartingNodes() if err != nil { return nil, fmt.Errorf("getting starting nodes: %w", err) - } else { - // log.Printf("resolved %v addresses", len(addrs)) } for _, a := range addrs { nodes = append(nodes, addrMaybeId{Addr: a.KRPC().ToNodeAddrPort()}) @@ -1308,17 +1221,6 @@ func (s *Server) PeerStore() peer_store.Interface { return s.config.PeerStore } -func (s *Server) getQuestionableNode() (ret *node) { - s.table.forNodes(func(n *node) bool { - if s.IsQuestionable(n) { - ret = n - return false - } - return true - }) - return -} - func (s *Server) shouldStopRefreshingBucket(bucketIndex int) bool { if s.closed.IsSet() { return true @@ -1393,14 +1295,12 @@ func (s *Server) pingQuestionableNodesInBucket(bucketIndex int) { var wg sync.WaitGroup b.EachNode(func(n *node) bool { if s.IsQuestionable(n) { - wg.Add(1) - go func() { - defer wg.Done() + wg.Go(func() { err := s.questionableNodePing(context.TODO(), n.Addr, n.Id.AsByteArray()).Err if err != nil { s.logger().WithDefaultLevel(log.Debug).Printf("error pinging questionable node in bucket %v: %v", bucketIndex, err) } - }() + }) } return true }) @@ -1426,9 +1326,6 @@ func (s *Server) TableMaintainer() { s.mu.RLock() for i := range s.table.buckets { s.pingQuestionableNodesInBucket(i) - // if time.Since(b.lastChanged) < 15*time.Minute { - // continue - // } if s.shouldStopRefreshingBucket(i) { continue } @@ -1464,7 +1361,7 @@ func (s *Server) questionableNodePing(ctx context.Context, addr Addr, id krpc.ID s.NodeRespondedToPing(addr, res.Reply.R.ID.Int160()) } else { s.mu.Lock() - s.updateNode(addr, &id, false, func(n *node) { + _ = s.updateNode(addr, &id, false, func(n *node) { n.failedLastQuestionablePing = true }) s.mu.Unlock() @@ -1486,14 +1383,12 @@ func (s *Server) TraversalNodeFilter(node addrMaybeId) bool { return s.config.NoSecurity || NodeIdSecure(node.Id.Value.AsByteArray(), node.Addr.IP()) } -func validNodeAddr(addr net.Addr) bool { - // At least for UDP addresses, we know what doesn't work. - ua := addr.(*net.UDPAddr) +func validNodeAddr(ua *net.UDPAddr) bool { if ua.Port == 0 { return false } + // 0.0.0.0/8 addresses "this network" and can't be a destination (RFC 1122). if ip4 := ua.IP.To4(); ip4 != nil && ip4[0] == 0 { - // Why? return false } return true diff --git a/server_test.go b/server_test.go index 736a3e149..286a9a8b0 100644 --- a/server_test.go +++ b/server_test.go @@ -3,13 +3,18 @@ package dht import ( "context" "crypto/ed25519" + "net" "testing" + "time" "github.com/anacrolix/log" "github.com/anacrolix/torrent/bencode" "github.com/go-quicktest/qt" + "golang.org/x/time/rate" "github.com/anacrolix/dht/v2/bep44" + "github.com/anacrolix/dht/v2/int160" + "github.com/anacrolix/dht/v2/krpc" ) func TestPutGet(t *testing.T) { @@ -92,10 +97,92 @@ func TestPutGet(t *testing.T) { qt.Assert(t, qt.Equals(*qr.Reply.R.Seq, int64(2))) } +// Queries without an arguments dict must get a protocol error rather than crash the server. +func TestQueryWithoutArguments(t *testing.T) { + s := newServer(t, log.Default.WithNames(t.Name())) + conn := mustListen("localhost:0") + defer conn.Close() + for _, q := range []string{"get_peers", "find_node", "announce_peer", "put", "get"} { + t.Run(q, func(t *testing.T) { + b := bencode.MustMarshal(map[string]string{"t": q, "y": "q", "q": q}) + _, err := conn.WriteTo(b, s.Addr()) + qt.Assert(t, qt.IsNil(err)) + qt.Assert(t, qt.IsNil(conn.SetReadDeadline(time.Now().Add(5*time.Second)))) + buf := make([]byte, 0x10000) + n, _, err := conn.ReadFrom(buf) + qt.Assert(t, qt.IsNil(err)) + var m krpc.Msg + qt.Assert(t, qt.IsNil(bencode.Unmarshal(buf[:n], &m))) + qt.Check(t, qt.Equals(m.T, q)) + qt.Assert(t, qt.IsNotNil(m.Error())) + qt.Check(t, qt.Equals(m.Error().Code, krpc.ErrorCodeProtocolError)) + }) + } +} + +// BEP 44 immutable puts carry no seq; only mutable puts require one. +func TestPutSeqOnlyRequiredForMutable(t *testing.T) { + l := log.Default.WithNames(t.Name()) + s1 := newServer(t, l.WithNames("s1")) + s2 := newServer(t, l.WithNames("s2")) + s2Addr := NewAddr(s2.Addr()) + + item, err := bep44.NewItem("immutable", nil, 0, 0, nil) + qt.Assert(t, qt.IsNil(err)) + qr := s1.Get(context.TODO(), s2Addr, item.Target(), nil, QueryRateLimiting{}) + qt.Assert(t, qt.IsNil(qr.ToError())) + qt.Assert(t, qt.IsNotNil(qr.Reply.R)) + qt.Assert(t, qt.IsNotNil(qr.Reply.R.Token)) + token := *qr.Reply.R.Token + + qr = s1.Query(context.TODO(), s2Addr, "put", QueryInput{ + MsgArgs: krpc.MsgArgs{Token: token, V: item.V}, + }) + qt.Assert(t, qt.IsNil(qr.ToError())) + stored, err := s2.store.Get(item.Target()) + qt.Assert(t, qt.IsNil(err)) + qt.Check(t, qt.Equals(stored.V, "immutable")) + + qr = s1.Query(context.TODO(), s2Addr, "put", QueryInput{ + MsgArgs: krpc.MsgArgs{Token: token, V: "mutable", K: [32]byte{1}}, + }) + qt.Assert(t, qt.IsNotNil(qr.Reply.Error())) + qt.Check(t, qt.Equals(qr.Reply.Error().Code, krpc.ErrorCodeProtocolError)) +} + +// find_node and get replies must contain nodes near the queried target, not near the (unset) info +// hash. +func TestSetReturnNodesUsesTarget(t *testing.T) { + cfg := NewDefaultServerConfig() + cfg.Conn = mustListen("localhost:0") + cfg.NodeId = krpc.ID{19: 1} + s, err := NewServer(cfg) + qt.Assert(t, qt.IsNil(err)) + defer s.Close() + far := s.id + far.SetBit(0, true) + near := s.id + near.SetBit(158, true) + s.mu.Lock() + for i, id := range []int160.T{far, near} { + n := &node{ + nodeKey: nodeKey{Id: id, Addr: NewAddr(&net.UDPAddr{IP: net.IPv4(1, 2, 3, byte(i)), Port: 1})}, + lastGotResponse: time.Now(), + } + qt.Assert(t, qt.IsNil(s.table.addNode(n))) + } + var r krpc.Return + s.setReturnNodes(&r, far.AsByteArray(), []krpc.Want{krpc.WantNodes}, NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1})) + s.mu.Unlock() + qt.Assert(t, qt.HasLen(r.Nodes, 1)) + qt.Check(t, qt.Equals(r.Nodes[0].ID, far.AsByteArray())) +} + func newServer(t *testing.T, l log.Logger) *Server { cfg := NewDefaultServerConfig() cfg.WaitToReply = true - + // The default limiter is shared process-wide, and error replies don't wait for it. + cfg.SendLimiter = rate.NewLimiter(rate.Inf, 0) cfg.Conn = mustListen("localhost:0") cfg.Logger = l s, err := NewServer(cfg) diff --git a/table.go b/table.go index 0d3398a3e..04ff10670 100644 --- a/table.go +++ b/table.go @@ -27,15 +27,6 @@ func (tbl *table) randomIdForBucket(bucketIndex int) int160.T { return randomId } -func (tbl *table) addrNodes(addr Addr) []*node { - a := tbl.addrs[addr.String()] - ret := make([]*node, 0, len(a)) - for id := range a { - ret = append(ret, tbl.getNode(addr, id)) - } - return ret -} - func (tbl *table) dropNode(n *node) { as := n.Addr.String() if _, ok := tbl.addrs[as][n.Id]; !ok { @@ -90,13 +81,11 @@ func (tbl *table) getNode(addr Addr, id int160.T) *node { } func (tbl *table) closestNodes(k int, target int160.T, filter func(*node) bool) (ret []*node) { - for bi := func() int { - if target == tbl.rootID { - return len(tbl.buckets) - 1 - } else { - return tbl.bucketIndex(target) - } - }(); bi >= 0 && len(ret) < k; bi-- { + bi := len(tbl.buckets) - 1 + if target != tbl.rootID { + bi = tbl.bucketIndex(target) + } + for ; bi >= 0 && len(ret) < k; bi-- { for n := range tbl.buckets[bi].nodes { if filter(n) { ret = append(ret, n) diff --git a/tokens.go b/tokens.go index 40c98fbbc..cbe71dd24 100644 --- a/tokens.go +++ b/tokens.go @@ -4,8 +4,6 @@ import ( "crypto/sha1" "encoding/binary" "time" - - "github.com/bradfitz/iter" ) // Manages creation and validation of tokens issued to querying nodes. @@ -19,39 +17,36 @@ type tokenServer struct { timeNow func() time.Time } -func (me tokenServer) CreateToken(addr Addr) string { - return me.createToken(addr, me.getTimeNow()) +func (ts *tokenServer) CreateToken(addr Addr) string { + return ts.createToken(addr, ts.getTimeNow()) } -func (me tokenServer) createToken(addr Addr, t time.Time) string { +func (ts *tokenServer) createToken(addr Addr, t time.Time) string { h := sha1.New() ip := addr.IP().To16() if len(ip) != 16 { panic(ip) } h.Write(ip) - ti := t.UnixNano() / int64(me.interval) - var b [8]byte - binary.BigEndian.PutUint64(b[:], uint64(ti)) - h.Write(b[:]) - h.Write(me.secret) + h.Write(binary.BigEndian.AppendUint64(nil, uint64(t.UnixNano()/int64(ts.interval)))) + h.Write(ts.secret) return string(h.Sum(nil)) } -func (me *tokenServer) ValidToken(token string, addr Addr) bool { - t := me.getTimeNow() - for range iter.N(me.maxIntervalDelta + 1) { - if me.createToken(addr, t) == token { +func (ts *tokenServer) ValidToken(token string, addr Addr) bool { + t := ts.getTimeNow() + for range ts.maxIntervalDelta + 1 { + if ts.createToken(addr, t) == token { return true } - t = t.Add(-me.interval) + t = t.Add(-ts.interval) } return false } -func (me *tokenServer) getTimeNow() time.Time { - if me.timeNow == nil { +func (ts *tokenServer) getTimeNow() time.Time { + if ts.timeNow == nil { return time.Now() } - return me.timeNow() + return ts.timeNow() } diff --git a/transactions/key-issuer.go b/transactions/key-issuer.go index ceeee5724..f125d327b 100644 --- a/transactions/key-issuer.go +++ b/transactions/key-issuer.go @@ -2,7 +2,7 @@ package transactions import ( "encoding/binary" - "sync" + "sync/atomic" ) type IdIssuer interface { @@ -11,17 +11,11 @@ type IdIssuer interface { var DefaultIdIssuer varintIdIssuer +// Issues sequential IDs encoded as unsigned varints, so they stay short. Safe for concurrent use. type varintIdIssuer struct { - mu sync.Mutex - buf [binary.MaxVarintLen64]byte - next uint64 + next atomic.Uint64 } func (me *varintIdIssuer) Issue() Id { - me.mu.Lock() - n := binary.PutUvarint(me.buf[:], me.next) - me.next++ - id := string(me.buf[:n]) - me.mu.Unlock() - return id + return string(binary.AppendUvarint(nil, me.next.Add(1)-1)) } diff --git a/traversal/operation.go b/traversal/operation.go index 90abd8807..6730e2827 100644 --- a/traversal/operation.go +++ b/traversal/operation.go @@ -20,10 +20,9 @@ type QueryResult struct { // This is set non-nil if a query reply is a response-type as defined by the DHT BEP 5 (contains // "r") ResponseFrom *krpc.NodeInfo - // Data associated with a closest node. Is this ever not a string? I think using generics for - // this leaks throughout the entire Operation. Hardly worth it. It's still possible to handle - // invalid token types at runtime. - ClosestData interface{} + // Data associated with a closest node, typically the token from the reply. Filtered by + // OperationInput.DataFilter. + ClosestData any Nodes []krpc.NodeInfo Nodes6 []krpc.NodeInfo } @@ -44,29 +43,25 @@ type OperationInput struct { type defaultsAppliedOperationInput OperationInput func Start(input OperationInput) *Operation { - herp := defaultsAppliedOperationInput(input) - if herp.Alpha == 0 { - herp.Alpha = 3 + in := defaultsAppliedOperationInput(input) + if in.Alpha == 0 { + in.Alpha = 3 } - if herp.K == 0 { - herp.K = 8 + if in.K == 0 { + in.K = 8 } - if herp.NodeFilter == nil { - herp.NodeFilter = func(types.AddrMaybeId) bool { - return true - } + if in.NodeFilter == nil { + in.NodeFilter = func(types.AddrMaybeId) bool { return true } } - if herp.DataFilter == nil { - herp.DataFilter = func(_ any) bool { - return true - } + if in.DataFilter == nil { + in.DataFilter = func(any) bool { return true } } - targetInt160 := herp.Target.Int160() + targetInt160 := in.Target.Int160() op := &Operation{ targetInt160: targetInt160, - input: herp, + input: in, queried: make(map[addrString]struct{}), - closest: k_nearest_nodes.New(targetInt160, herp.K), + closest: k_nearest_nodes.New(targetInt160, in.K), unqueried: containers.NewImmutableAddrMaybeIdsByDistance(targetInt160), } go op.run() @@ -101,10 +96,7 @@ func (op *Operation) Stop() { defer op.stopped.Set() op.mu.Lock() defer op.mu.Unlock() - for { - if op.outstanding == 0 { - break - } + for op.outstanding != 0 { cond := op.cond.Signaled() op.mu.Unlock() <-cond @@ -210,7 +202,7 @@ func (op *Operation) run() { } } -func (op *Operation) addClosest(node krpc.NodeInfo, data interface{}) { +func (op *Operation) addClosest(node krpc.NodeInfo, data any) { var ami types.AddrMaybeId ami.FromNodeInfo(node) if !op.input.NodeFilter(ami) { @@ -240,7 +232,6 @@ func (op *Operation) startQuery() { op.outstanding-- op.cond.Broadcast() }() - // log.Printf("traversal querying %v", a) atomic.AddUint32(&op.stats.NumAddrsTried, 1) ctx, cancel := context.WithCancel(context.Background()) go func() { diff --git a/types/addr-maybe-id.go b/types/addr-maybe-id.go index eff04cf48..acc65e1c5 100644 --- a/types/addr-maybe-id.go +++ b/types/addr-maybe-id.go @@ -4,7 +4,6 @@ import ( "fmt" "github.com/anacrolix/generics" - "github.com/anacrolix/multiless" "github.com/anacrolix/dht/v2/int160" "github.com/anacrolix/dht/v2/krpc" @@ -48,19 +47,20 @@ func (me *AddrMaybeId) FromNodeInfo(ni krpc.NodeInfo) { func (me AddrMaybeId) String() string { if !me.Id.Ok { return fmt.Sprintf("unknown id at %s", me.Addr) - } else { - return fmt.Sprintf("%v at %v", me.Id.Value, me.Addr) } + return fmt.Sprintf("%v at %v", me.Id.Value, me.Addr) } +// Reports whether l sorts before r when ordering by distance to target. Entries with known IDs +// come first, then by distance, then by address. This is a total order. func (l AddrMaybeId) CloserThan(r AddrMaybeId, target int160.T) bool { - ml := multiless.New().Bool(!l.Id.Ok, !r.Id.Ok) - if l.Id.Ok && r.Id.Ok { - ml = ml.Cmp(l.Id.Value.Distance(target).Cmp(r.Id.Value.Distance(target))) + if l.Id.Ok != r.Id.Ok { + return l.Id.Ok } - if !ml.Ok() { - ml = ml.Cmp(l.Addr.Addr().Compare(r.Addr.Addr())) - ml = multiless.EagerOrdered(ml, l.Addr.Port(), r.Addr.Port()) + if l.Id.Ok { + if c := l.Id.Value.Distance(target).Cmp(r.Id.Value.Distance(target)); c != 0 { + return c < 0 + } } - return ml.Less() + return l.Addr.Compare(r.Addr) < 0 } diff --git a/types/addr-maybe-id_test.go b/types/addr-maybe-id_test.go index a0f0ebdd3..3fe0f2f53 100644 --- a/types/addr-maybe-id_test.go +++ b/types/addr-maybe-id_test.go @@ -1,11 +1,11 @@ package types import ( - "math/rand" + "math" + "math/rand/v2" "net" "testing" - "github.com/bradfitz/iter" "github.com/go-quicktest/qt" "github.com/anacrolix/dht/v2/krpc" @@ -25,7 +25,7 @@ func TestNoIdFarther(tb *testing.T) { b.Id = a.Id qt.Assert(tb, qt.IsFalse(a.CloserThan(b, target))) id := a.Id.UnwrapPtr() - for i := range iter.N(160) { + for i := range 160 { if target.GetBit(i) != id.GetBit(i) { id.SetBit(i, target.GetBit(i)) break @@ -46,7 +46,7 @@ func TestCloserThanId(tb *testing.T) { b.Id.SetSomeZeroValue() b.Id = a.Id qt.Assert(tb, qt.IsFalse(a.CloserThan(b, target))) - for i := range iter.N(160) { + for i := range 160 { if target.GetBit(i) != a.Id.UnwrapPtr().GetBit(i) { a.Id.UnwrapPtr().SetBit(i, target.GetBit(i)) break @@ -61,20 +61,20 @@ func TestCloserThanId(tb *testing.T) { func BenchmarkDeterministicAddr(tb *testing.B) { ip := net.ParseIP("1.2.3.4") target := krpc.RandomNodeID().Int160() - for range iter.N(tb.N) { + for tb.Loop() { a := AddrMaybeId{ Addr: krpc.NodeAddr{ IP: ip, - Port: rand.Int(), + Port: rand.IntN(math.MaxUint16 + 1), }.ToNodeAddrPort(), } b := AddrMaybeId{ Addr: krpc.NodeAddr{ IP: ip, - Port: rand.Int(), + Port: rand.IntN(math.MaxUint16 + 1), }.ToNodeAddrPort(), } - if a.CloserThan(b, target) != a.CloserThan(b, target) { + if first := a.CloserThan(b, target); a.CloserThan(b, target) != first { tb.Fatal("not deterministic") } } From 671719bbb332966aa41304a05d69965ed32118a1 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 01:13:41 +0530 Subject: [PATCH 04/18] Get starting nodes before starting traversals BootstrapContext started a traversal and then returned without stopping it when TraversalStartingNodes failed, leaving the operation's run goroutine blocked forever. Fetch starting nodes first in Bootstrap, AnnounceTraversal and getput so the error paths never start a traversal, and add tests that check no traversal goroutine survives those failures. --- announce.go | 9 +++--- bootstrap.go | 8 +++--- exts/getput/getput.go | 9 +++--- exts/getput/getput_test.go | 57 ++++++++++++++++++++++++++++++++++++ lifecycle_test.go | 59 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 128 insertions(+), 14 deletions(-) create mode 100644 exts/getput/getput_test.go create mode 100644 lifecycle_test.go diff --git a/announce.go b/announce.go index 8576cf207..eb27a633d 100644 --- a/announce.go +++ b/announce.go @@ -98,6 +98,10 @@ func (s *Server) AnnounceTraversal(infoHash [20]byte, opts ...AnnounceOpt) (_ *A for _, opt := range opts { opt(a) } + nodes, err := s.TraversalStartingNodes() + if err != nil { + return + } a.traversal = traversal.Start(traversal.OperationInput{ Target: infoHash, DoQuery: a.getPeers, @@ -107,11 +111,6 @@ func (s *Server) AnnounceTraversal(infoHash [20]byte, opts ...AnnounceOpt) (_ *A return ok }, }) - nodes, err := s.TraversalStartingNodes() - if err != nil { - a.traversal.Stop() - return - } a.traversal.AddNodes(nodes) go func() { <-a.traversal.Stalled() diff --git a/bootstrap.go b/bootstrap.go index 286eac7db..279c9f405 100644 --- a/bootstrap.go +++ b/bootstrap.go @@ -31,6 +31,10 @@ func (s *Server) BootstrapContext(ctx context.Context) (_ TraversalStats, err er defer s.mu.Unlock() s.bootstrappingNow = false }() + nodes, err := s.TraversalStartingNodes() + if err != nil { + return + } t := traversal.Start(traversal.OperationInput{ Target: s.id.AsByteArray(), K: 16, @@ -39,10 +43,6 @@ func (s *Server) BootstrapContext(ctx context.Context) (_ TraversalStats, err er }, NodeFilter: s.TraversalNodeFilter, }) - nodes, err := s.TraversalStartingNodes() - if err != nil { - return - } t.AddNodes(nodes) s.mu.Lock() s.lastBootstrap = time.Now() diff --git a/exts/getput/getput.go b/exts/getput/getput.go index efc12700f..374898830 100644 --- a/exts/getput/getput.go +++ b/exts/getput/getput.go @@ -43,6 +43,10 @@ func startGetTraversal( ) ( vChan chan GetResult, op *traversal.Operation, err error, ) { + nodes, err := s.TraversalStartingNodes() + if err != nil { + return nil, nil, err + } vChan = make(chan GetResult) op = traversal.Start(traversal.OperationInput{ Alpha: 15, @@ -73,11 +77,6 @@ func startGetTraversal( return ok }, }) - nodes, err := s.TraversalStartingNodes() - if err != nil { - op.Stop() - return nil, nil, err - } op.AddNodes(nodes) return } diff --git a/exts/getput/getput_test.go b/exts/getput/getput_test.go new file mode 100644 index 000000000..a6f4f94fa --- /dev/null +++ b/exts/getput/getput_test.go @@ -0,0 +1,57 @@ +package getput + +import ( + "context" + "errors" + "net" + "runtime" + "strings" + "testing" + "time" + + "github.com/anacrolix/dht/v2" + "github.com/anacrolix/dht/v2/bep44" + "github.com/anacrolix/dht/v2/krpc" + "github.com/go-quicktest/qt" +) + +func numTraversalGoroutines() int { + buf := make([]byte, 1<<20) + for { + n := runtime.Stack(buf, true) + if n < len(buf) { + return strings.Count(string(buf[:n]), "traversal.(*Operation).run(") + } + buf = make([]byte, 2*len(buf)) + } +} + +func assertTraversalGoroutines(t *testing.T, want int) { + t.Helper() + deadline := time.Now().Add(time.Second) + for numTraversalGoroutines() != want && time.Now().Before(deadline) { + time.Sleep(10 * time.Millisecond) + } + qt.Assert(t, qt.Equals(numTraversalGoroutines(), want)) +} + +// A traversal must not outlive a failure to get starting nodes. +func TestStartingNodesErrorDoesNotLeak(t *testing.T) { + conn, err := net.ListenPacket("udp", "localhost:0") + qt.Assert(t, qt.IsNil(err)) + cfg := dht.NewDefaultServerConfig() + cfg.Conn = conn + cfg.StartingNodes = func() ([]dht.Addr, error) { return nil, errors.New("no starting nodes") } + s, err := dht.NewServer(cfg) + qt.Assert(t, qt.IsNil(err)) + defer s.Close() + before := numTraversalGoroutines() + + _, _, err = Get(context.Background(), bep44.Target{1}, s, nil, nil) + qt.Assert(t, qt.IsNotNil(err)) + assertTraversalGoroutines(t, before) + + _, err = Put(context.Background(), krpc.ID{1}, s, nil, func(int64) bep44.Put { return bep44.Put{} }) + qt.Assert(t, qt.IsNotNil(err)) + assertTraversalGoroutines(t, before) +} diff --git a/lifecycle_test.go b/lifecycle_test.go new file mode 100644 index 000000000..db06b50ae --- /dev/null +++ b/lifecycle_test.go @@ -0,0 +1,59 @@ +package dht + +import ( + "errors" + "runtime" + "strings" + "testing" + "time" + + "github.com/anacrolix/log" + "github.com/go-quicktest/qt" +) + +// Counts goroutines currently running a traversal operation loop. +func numTraversalGoroutines() int { + buf := make([]byte, 1<<20) + for { + n := runtime.Stack(buf, true) + if n < len(buf) { + return strings.Count(string(buf[:n]), "traversal.(*Operation).run(") + } + buf = make([]byte, 2*len(buf)) + } +} + +// Waits briefly for the traversal goroutine count to settle back to want. +func assertTraversalGoroutines(t *testing.T, want int) { + t.Helper() + deadline := time.Now().Add(time.Second) + for numTraversalGoroutines() != want && time.Now().Before(deadline) { + time.Sleep(10 * time.Millisecond) + } + qt.Assert(t, qt.Equals(numTraversalGoroutines(), want)) +} + +func newServerWithoutStartingNodes(t *testing.T) *Server { + cfg := NewDefaultServerConfig() + cfg.Conn = mustListen("localhost:0") + cfg.Logger = log.Default.WithNames(t.Name()) + cfg.StartingNodes = func() ([]Addr, error) { return nil, errors.New("no starting nodes") } + s, err := NewServer(cfg) + qt.Assert(t, qt.IsNil(err)) + t.Cleanup(s.Close) + return s +} + +// A traversal must not outlive a failure to get starting nodes. +func TestTraversalStartingNodesErrorDoesNotLeak(t *testing.T) { + s := newServerWithoutStartingNodes(t) + before := numTraversalGoroutines() + + _, err := s.Bootstrap() + qt.Assert(t, qt.IsNotNil(err)) + assertTraversalGoroutines(t, before) + + _, err = s.AnnounceTraversal([20]byte{1}) + qt.Assert(t, qt.IsNotNil(err)) + assertTraversalGoroutines(t, before) +} From c940be734d2b5f130adc7f242ed54cf65820609e Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 01:18:37 +0530 Subject: [PATCH 05/18] Check errors in tests instead of excluding errcheck Drop the blanket errcheck exclusion for _test.go. The only findings were in dht_test.go; they now assert or return on error. TestBootstrapRace unmarshalled the whole read buffer rather than the bytes read. --- .golangci.yml | 4 ---- dht_test.go | 25 ++++++++++++++++++------- 2 files changed, 18 insertions(+), 11 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index a52452cd0..7d3ce96c7 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -41,10 +41,6 @@ linters: # Tests compare raw IP bytes on purpose. - path: _test\.go text: SA1021 - # Test fixtures deliberately ignore I/O errors on throwaway sockets and decoders. - - path: _test\.go - linters: - - errcheck formatters: enable: diff --git a/dht_test.go b/dht_test.go index 0b7f56825..ed37fc76b 100644 --- a/dht_test.go +++ b/dht_test.go @@ -249,14 +249,15 @@ func TestBadGetPeersResponse(t *testing.T) { n, addr, err := pc.ReadFrom(b) qt.Assert(t, qt.IsNil(err)) var rm krpc.Msg - bencode.Unmarshal(b[:n], &rm) + qt.Assert(t, qt.IsNil(bencode.Unmarshal(b[:n], &rm))) m := krpc.Msg{ R: &krpc.Return{}, T: rm.T, } b, err = bencode.Marshal(m) qt.Assert(t, qt.IsNil(err)) - pc.WriteTo(b, addr) + _, err = pc.WriteTo(b, addr) + qt.Assert(t, qt.IsNil(err)) }() a, err := s.Announce([20]byte{}, 0, true) qt.Assert(t, qt.IsNil(err)) @@ -283,18 +284,26 @@ func TestBootstrapRace(t *testing.T) { defer s.Close() go func() { for range defaultMaxQuerySends - 1 { - remotePc.ReadFrom(nil) + _, _, _ = remotePc.ReadFrom(nil) } var b [1024]byte - _, addr, _ := remotePc.ReadFrom(b[:]) + n, addr, err := remotePc.ReadFrom(b[:]) + if err != nil { + // The remote is closed when the test ends. + return + } var m krpc.Msg - bencode.Unmarshal(b[:], &m) + if err := bencode.Unmarshal(b[:n], &m); err != nil { + panic(err) + } m.Y = "r" rb, err := bencode.Marshal(m) if err != nil { panic(err) } - remotePc.WriteTo(rb, addr) + if _, err := remotePc.WriteTo(rb, addr); err != nil { + panic(err) + } }() ts, err := s.Bootstrap() t.Logf("%#v", ts) @@ -342,7 +351,9 @@ func (me *bootstrapRacePacketConn) WriteTo(b []byte, addr net.Addr) (int, error) log.Printf("wrote %d times", me.writes) if me.writes == defaultMaxQuerySends { var m krpc.Msg - bencode.Unmarshal(b[:], &m) + if err := bencode.Unmarshal(b, &m); err != nil { + panic(err) + } m.Y = "r" rb, err := bencode.Marshal(m) if err != nil { From 1135f582a40231c382666549215a16257cb0b72f Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 01:26:41 +0530 Subject: [PATCH 06/18] Wait for bootstrap traversals to stop when cancelled BootstrapContext returned as soon as its context was done, leaving outstanding find_node queries running until they timed out. Bootstrap and bucket refresh queries now use the traversal's context so stopping cancels them, and BootstrapContext always waits for the traversal to stop, returning its stats along with any context error. --- bootstrap.go | 10 +++------- lifecycle_test.go | 39 ++++++++++++++++++++++++++++++++++++--- server.go | 13 ++++++++----- 3 files changed, 47 insertions(+), 15 deletions(-) diff --git a/bootstrap.go b/bootstrap.go index 279c9f405..b659cfccc 100644 --- a/bootstrap.go +++ b/bootstrap.go @@ -39,7 +39,7 @@ func (s *Server) BootstrapContext(ctx context.Context) (_ TraversalStats, err er Target: s.id.AsByteArray(), K: 16, DoQuery: func(ctx context.Context, addr krpc.NodeAddr) traversal.QueryResult { - return s.FindNode(NewAddr(addr.UDP()), s.id, QueryRateLimiting{}).TraversalQueryResult(addr) + return s.findNode(ctx, NewAddr(addr.UDP()), s.id, QueryRateLimiting{}).TraversalQueryResult(addr) }, NodeFilter: s.TraversalNodeFilter, }) @@ -52,12 +52,8 @@ func (s *Server) BootstrapContext(ctx context.Context) (_ TraversalStats, err er err = ctx.Err() case <-t.Stalled(): } + // Stopping cancels outstanding queries, so this doesn't wait for them to time out. t.Stop() - if err != nil { - // Could test for Stopped and return stats here but the interface doesn't tell the caller if - // we were successful in taking the stats. We could also take a snapshot instead. - return - } <-t.Stopped() - return *t.Stats(), nil + return *t.Stats(), err } diff --git a/lifecycle_test.go b/lifecycle_test.go index db06b50ae..8487106af 100644 --- a/lifecycle_test.go +++ b/lifecycle_test.go @@ -1,6 +1,7 @@ package dht import ( + "context" "errors" "runtime" "strings" @@ -11,16 +12,23 @@ import ( "github.com/go-quicktest/qt" ) -// Counts goroutines currently running a traversal operation loop. -func numTraversalGoroutines() int { +// Counts goroutines with a frame in the traversal package: operation loops and their queries. +func numTraversalGoroutines() (num int) { buf := make([]byte, 1<<20) for { n := runtime.Stack(buf, true) if n < len(buf) { - return strings.Count(string(buf[:n]), "traversal.(*Operation).run(") + buf = buf[:n] + break } buf = make([]byte, 2*len(buf)) } + for g := range strings.SplitSeq(string(buf), "\n\n") { + if strings.Contains(g, "dht/v2/traversal.") { + num++ + } + } + return } // Waits briefly for the traversal goroutine count to settle back to want. @@ -57,3 +65,28 @@ func TestTraversalStartingNodesErrorDoesNotLeak(t *testing.T) { qt.Assert(t, qt.IsNotNil(err)) assertTraversalGoroutines(t, before) } + +// Cancelling a bootstrap must stop its outstanding queries before returning, rather than leaving +// them to run until they time out. +func TestBootstrapContextCancelWaitsForTraversal(t *testing.T) { + silent := mustListen("localhost:0") + defer silent.Close() + cfg := NewDefaultServerConfig() + cfg.Conn = mustListen("localhost:0") + cfg.Logger = log.Default.WithNames(t.Name()) + cfg.QueryResendDelay = func() time.Duration { return time.Minute } + cfg.StartingNodes = addrResolver(silent.LocalAddr().String()) + s, err := NewServer(cfg) + qt.Assert(t, qt.IsNil(err)) + defer s.Close() + before := numTraversalGoroutines() + + ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) + defer cancel() + started := time.Now() + stats, err := s.BootstrapContext(ctx) + qt.Assert(t, qt.ErrorIs(err, context.DeadlineExceeded)) + qt.Check(t, qt.IsTrue(time.Since(started) < 10*time.Second)) + qt.Check(t, qt.Equals(stats.NumAddrsTried, uint32(1))) + assertTraversalGoroutines(t, before) +} diff --git a/server.go b/server.go index 4f08fb5e9..eb4e3e738 100644 --- a/server.go +++ b/server.go @@ -1053,15 +1053,18 @@ func (s *Server) announcePeer( // Sends a find_node query to addr. targetID is the node we're looking for. The Server makes use of // some of the response fields. -func (s *Server) FindNode(addr Addr, targetID int160.T, rl QueryRateLimiting) (ret QueryResult) { - ret = s.Query(context.TODO(), addr, "find_node", QueryInput{ +func (s *Server) FindNode(addr Addr, targetID int160.T, rl QueryRateLimiting) QueryResult { + return s.findNode(context.TODO(), addr, targetID, rl) +} + +func (s *Server) findNode(ctx context.Context, addr Addr, targetID int160.T, rl QueryRateLimiting) QueryResult { + return s.Query(ctx, addr, "find_node", QueryInput{ MsgArgs: krpc.MsgArgs{ Target: targetID.AsByteArray(), Want: s.config.DefaultWant, }, RateLimiting: rl, }) - return } // Returns how many nodes are in the node table. @@ -1244,9 +1247,9 @@ func (s *Server) refreshBucket(bucketIndex int) *traversal.Stats { // as soon as the bucket is good. K: s.table.K(), DoQuery: func(ctx context.Context, addr krpc.NodeAddr) traversal.QueryResult { - res := s.FindNode(NewAddr(addr.UDP()), id, QueryRateLimiting{}) + res := s.findNode(ctx, NewAddr(addr.UDP()), id, QueryRateLimiting{}) err := res.Err - if err != nil && !errors.Is(err, TransactionTimeout) { + if err != nil && !errors.Is(err, TransactionTimeout) && !errors.Is(err, context.Canceled) { s.logger().Levelf(log.Debug, "error doing find node while refreshing bucket: %v", err) } return res.TraversalQueryResult(addr) From 73f0abcac2d82129ca4a2f004c07cf65f8b946de Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 01:54:43 +0530 Subject: [PATCH 07/18] Read bucket-refresh stats only after the traversal stops Go evaluates a return statement's results before deferred functions run, so refreshBucket called Operation.Stats before Stopped. The named result is now assigned after the traversal stops, and a test checks the traversal goroutine is gone when refresh returns. --- lifecycle_test.go | 10 ++++++++++ server.go | 11 +++++------ 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/lifecycle_test.go b/lifecycle_test.go index 8487106af..2eb24a614 100644 --- a/lifecycle_test.go +++ b/lifecycle_test.go @@ -90,3 +90,13 @@ func TestBootstrapContextCancelWaitsForTraversal(t *testing.T) { qt.Check(t, qt.Equals(stats.NumAddrsTried, uint32(1))) assertTraversalGoroutines(t, before) } + +// refreshBucket must stop its traversal before returning stats, and must not leave the traversal +// goroutine running. +func TestRefreshBucketStopsBeforeStats(t *testing.T) { + s := newServerWithoutStartingNodes(t) + before := numTraversalGoroutines() + stats := s.refreshBucket(0) + qt.Assert(t, qt.IsNotNil(stats)) + assertTraversalGoroutines(t, before) +} diff --git a/server.go b/server.go index eb4e3e738..4348442c6 100644 --- a/server.go +++ b/server.go @@ -1235,7 +1235,7 @@ func (s *Server) shouldStopRefreshingBucket(bucketIndex int) bool { }) } -func (s *Server) refreshBucket(bucketIndex int) *traversal.Stats { +func (s *Server) refreshBucket(bucketIndex int) (stats *traversal.Stats) { s.mu.RLock() id := s.table.randomIdForBucket(bucketIndex) op := traversal.Start(traversal.OperationInput{ @@ -1258,8 +1258,11 @@ func (s *Server) refreshBucket(bucketIndex int) *traversal.Stats { }) defer func() { s.mu.RUnlock() + // Assign stats only after Stopped. A result in the return statement would be + // evaluated first, and Operation.Stats must not be read until the traversal stops. op.Stop() <-op.Stopped() + stats = op.Stats() }() b := &s.table.buckets[bucketIndex] wait: @@ -1280,7 +1283,7 @@ wait: } s.mu.RLock() } - return op.Stats() + return } func (s *Server) shouldBootstrap() bool { @@ -1396,7 +1399,3 @@ func validNodeAddr(ua *net.UDPAddr) bool { } return true } - -// func (s *Server) refreshBucket(bucketIndex int) { -// targetId := s.table.randomIdForBucket(bucketIndex) -// } From f00aff864832c1256e043249c94095833f703982 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 02:01:29 +0530 Subject: [PATCH 08/18] Copy traversal counters with atomic loads Announce.TraversalStats copied the stats struct while queries update the same fields with atomic adds, which races. LoadStats reads both counters atomically, and the announce, bootstrap, and get/put snapshots use it. --- announce.go | 2 +- announce_test.go | 22 ++++++++++++++++++++++ bootstrap.go | 2 +- exts/getput/getput.go | 6 ++++-- lifecycle_test.go | 4 ++-- traversal/loadstats_test.go | 35 +++++++++++++++++++++++++++++++++++ traversal/operation.go | 12 +++++++++++- 7 files changed, 76 insertions(+), 7 deletions(-) create mode 100644 traversal/loadstats_test.go diff --git a/announce.go b/announce.go index eb27a633d..dd2632f05 100644 --- a/announce.go +++ b/announce.go @@ -43,7 +43,7 @@ func (a *Announce) NumContacted() uint32 { } func (a *Announce) TraversalStats() TraversalStats { - return *a.traversal.Stats() + return a.traversal.LoadStats() } // Server.Announce option diff --git a/announce_test.go b/announce_test.go index a614348dd..5d65b9853 100644 --- a/announce_test.go +++ b/announce_test.go @@ -57,3 +57,25 @@ func TestRateLimiterInadequate(t *testing.T) { time.AfterFunc(2*time.Millisecond, cancel) qt.Check(t, qt.Equals(rl.Wait(ctx), context.Canceled)) } + +// Stats can be read while a query is still outstanding. +func TestTraversalStatsDuringQuery(t *testing.T) { + silent := mustListen("localhost:0") + defer silent.Close() + s, err := NewServer(&ServerConfig{ + Conn: mustListen("localhost:0"), + NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + StartingNodes: addrResolver(silent.LocalAddr().String()), + }) + qt.Assert(t, qt.IsNil(err)) + defer s.Close() + a, err := s.AnnounceTraversal([20]byte{9}) + qt.Assert(t, qt.IsNil(err)) + defer a.Close() + deadline := time.Now().Add(50 * time.Millisecond) + for time.Now().Before(deadline) { + _ = a.TraversalStats() + _ = a.NumContacted() + } +} diff --git a/bootstrap.go b/bootstrap.go index b659cfccc..01678bbde 100644 --- a/bootstrap.go +++ b/bootstrap.go @@ -55,5 +55,5 @@ func (s *Server) BootstrapContext(ctx context.Context) (_ TraversalStats, err er // Stopping cancels outstanding queries, so this doesn't wait for them to time out. t.Stop() <-t.Stopped() - return *t.Stats(), err + return t.LoadStats(), err } diff --git a/exts/getput/getput.go b/exts/getput/getput.go index 374898830..1bec1300e 100644 --- a/exts/getput/getput.go +++ b/exts/getput/getput.go @@ -117,7 +117,8 @@ receive: } op.Stop() <-op.Stopped() - stats = op.Stats() + loaded := op.LoadStats() + stats = &loaded return } @@ -154,7 +155,8 @@ receive: } op.Stop() <-op.Stopped() - stats = op.Stats() + loaded := op.LoadStats() + stats = &loaded if err != nil { return } diff --git a/lifecycle_test.go b/lifecycle_test.go index 2eb24a614..064c7d698 100644 --- a/lifecycle_test.go +++ b/lifecycle_test.go @@ -91,8 +91,8 @@ func TestBootstrapContextCancelWaitsForTraversal(t *testing.T) { assertTraversalGoroutines(t, before) } -// refreshBucket must stop its traversal before returning stats, and must not leave the traversal -// goroutine running. +// The traversal goroutine must be gone when refreshBucket returns. This does not observe the +// stats-before-Stopped ordering; that return is assigned only after Stopped in refreshBucket. func TestRefreshBucketStopsBeforeStats(t *testing.T) { s := newServerWithoutStartingNodes(t) before := numTraversalGoroutines() diff --git a/traversal/loadstats_test.go b/traversal/loadstats_test.go new file mode 100644 index 000000000..02c0c08cb --- /dev/null +++ b/traversal/loadstats_test.go @@ -0,0 +1,35 @@ +package traversal + +import ( + "sync" + "sync/atomic" + "testing" +) + +// The counters are updated with atomic adds while a traversal runs. Copying them must use atomic +// loads; a plain struct copy races with those adds. +func TestLoadStatsDuringUpdates(t *testing.T) { + var op Operation + var wg sync.WaitGroup + stop := make(chan struct{}) + wg.Go(func() { + for { + select { + case <-stop: + return + default: + atomic.AddUint32(&op.stats.NumAddrsTried, 1) + atomic.AddUint32(&op.stats.NumResponses, 1) + } + } + }) + var last Stats + for range 10000 { + last = op.LoadStats() + } + close(stop) + wg.Wait() + if last.NumAddrsTried == 0 || last.NumResponses == 0 { + t.Fatalf("expected counters to move, got %+v", last) + } +} diff --git a/traversal/operation.go b/traversal/operation.go index 6730e2827..a3c662323 100644 --- a/traversal/operation.go +++ b/traversal/operation.go @@ -85,11 +85,21 @@ type Operation struct { stopped chansync.SetOnce } -// I don't think you should access this until the Stopped event. +// Stats returns the operation counters. While the operation is running, the fields are updated +// with atomic adds. Read them with sync/atomic, or take a copy with LoadStats. A plain field read +// is safe only after Stopped. func (op *Operation) Stats() *Stats { return &op.stats } +// LoadStats copies the counters with atomic loads. Safe to call while the operation is running. +func (op *Operation) LoadStats() Stats { + return Stats{ + NumAddrsTried: atomic.LoadUint32(&op.stats.NumAddrsTried), + NumResponses: atomic.LoadUint32(&op.stats.NumResponses), + } +} + func (op *Operation) Stop() { if op.stopping.Set() { go func() { From 2d2e6679351ddebc3bd11f678c51513681ba9cc5 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 02:08:23 +0530 Subject: [PATCH 09/18] Unblock announce shutdown when Peers is unread getPeers waited on traversal.Stopped while that query was still outstanding, so Close never reached Finished if nobody received from Peers. The send now also selects on the query context, which Stop cancels. The stats race test waits for the writer to increment before it loads. --- announce.go | 5 ++- dht_test.go | 79 +++++++++++++++++++++++++++++++++++++ traversal/loadstats_test.go | 7 ++++ 3 files changed, 90 insertions(+), 1 deletion(-) diff --git a/announce.go b/announce.go index dd2632f05..db012078c 100644 --- a/announce.go +++ b/announce.go @@ -170,9 +170,12 @@ func (a *Announce) getPeers(ctx context.Context, addr krpc.NodeAddr) traversal.Q }, Return: *r, } + // Stop waits for this query to return before Stopped fires, so waiting on + // Stopped here deadlocks when nobody is receiving from Peers. The query + // context is cancelled when the traversal stops. select { case a.Peers <- peersValues: - case <-a.traversal.Stopped(): + case <-ctx.Done(): } } return res.TraversalQueryResult(addr) diff --git a/dht_test.go b/dht_test.go index ed37fc76b..3b6e24e00 100644 --- a/dht_test.go +++ b/dht_test.go @@ -6,6 +6,8 @@ import ( "io" "math/big" "net" + "runtime" + "strings" "testing" "time" @@ -364,3 +366,80 @@ func (me *bootstrapRacePacketConn) WriteTo(b []byte, addr net.Addr) (int, error) } return len(b), nil } + +// getPeers is inside its send select, not still inside the query that produced the reply. +func getPeersBlockedSending() bool { + buf := make([]byte, 1<<20) + for { + n := runtime.Stack(buf, true) + if n < len(buf) { + buf = buf[:n] + break + } + buf = make([]byte, 2*len(buf)) + } + for g := range strings.SplitSeq(string(buf), "\n\n") { + if strings.Contains(g, "(*Announce).getPeers") && !strings.Contains(g, "(*Server).Query") { + return true + } + } + return false +} + +// Closing an announce must finish even when the caller never reads Peers. A reply has to be in +// hand first: getPeers only blocks on the send after the query returns. +func TestAnnounceCloseWithoutReadingPeers(t *testing.T) { + pc, err := net.ListenPacket("udp", "localhost:0") + qt.Assert(t, qt.IsNil(err)) + defer pc.Close() + s, err := NewServer(&ServerConfig{ + StartingNodes: func() ([]Addr, error) { + return []Addr{NewAddr(pc.LocalAddr().(*net.UDPAddr))}, nil + }, + Conn: mustListen("localhost:0"), + NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + }) + qt.Assert(t, qt.IsNil(err)) + defer s.Close() + replied := make(chan struct{}) + go func() { + b := make([]byte, 1024) + n, addr, err := pc.ReadFrom(b) + if err != nil { + return + } + var rm krpc.Msg + if err := bencode.Unmarshal(b[:n], &rm); err != nil { + return + } + rb, err := bencode.Marshal(krpc.Msg{R: &krpc.Return{}, T: rm.T}) + if err != nil { + return + } + if _, err := pc.WriteTo(rb, addr); err != nil { + return + } + close(replied) + }() + a, err := s.AnnounceTraversal([20]byte{1}) + qt.Assert(t, qt.IsNil(err)) + select { + case <-replied: + case <-time.After(2 * time.Second): + t.Fatal("remote never answered get_peers") + } + deadline := time.Now().Add(2 * time.Second) + for !getPeersBlockedSending() && time.Now().Before(deadline) { + time.Sleep(time.Millisecond) + } + if !getPeersBlockedSending() { + t.Fatal("getPeers did not block sending the peer result") + } + a.Close() + select { + case <-a.Finished(): + case <-time.After(2 * time.Second): + t.Fatal("Finished did not fire after Close with an unread Peers channel") + } +} diff --git a/traversal/loadstats_test.go b/traversal/loadstats_test.go index 02c0c08cb..39de7ee5e 100644 --- a/traversal/loadstats_test.go +++ b/traversal/loadstats_test.go @@ -1,6 +1,7 @@ package traversal import ( + "runtime" "sync" "sync/atomic" "testing" @@ -12,7 +13,11 @@ func TestLoadStatsDuringUpdates(t *testing.T) { var op Operation var wg sync.WaitGroup stop := make(chan struct{}) + started := make(chan struct{}) wg.Go(func() { + atomic.AddUint32(&op.stats.NumAddrsTried, 1) + atomic.AddUint32(&op.stats.NumResponses, 1) + close(started) for { select { case <-stop: @@ -23,9 +28,11 @@ func TestLoadStatsDuringUpdates(t *testing.T) { } } }) + <-started var last Stats for range 10000 { last = op.LoadStats() + runtime.Gosched() } close(stop) wg.Wait() From 1d25d21fa8d3517fc7e74459fe4b4492a65bb489 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 02:26:53 +0530 Subject: [PATCH 10/18] Close the announce if the unread-Peers test fails early TestAnnounceCloseWithoutReadingPeers only called Close after the send was blocked, so a failure before that left the traversal running. --- dht_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/dht_test.go b/dht_test.go index 3b6e24e00..819cd22e6 100644 --- a/dht_test.go +++ b/dht_test.go @@ -424,6 +424,7 @@ func TestAnnounceCloseWithoutReadingPeers(t *testing.T) { }() a, err := s.AnnounceTraversal([20]byte{1}) qt.Assert(t, qt.IsNil(err)) + t.Cleanup(a.Close) select { case <-replied: case <-time.After(2 * time.Second): From 32e0213340bc495ae6d1a4a25ee58ad051726e30 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 03:27:30 +0530 Subject: [PATCH 11/18] Stop queries on Close and correct closest-node and BEP 44 checks Close did not cancel an in-flight query, so a ping that had already been sent waited out the resend delay. Query now ends when the server context is cancelled or the caller context ends. closestNodes kept an arbitrary prefix of a bucket. It keeps the nearest nodes by XOR distance. Operation.Closest raced query updates and now returns a snapshot taken under the operation lock. The block list was written under the server lock and read without it, so it is published atomically. BEP 44 cas was compared with the previous write's cas instead of the stored sequence number. Wrapper.Put holds one lock across that read and the write. ping no longer dereferences a response with no id, and dht-server closes the node when loading its table fails so the deferred socket close does not panic the serve loop. --- bep44/cas_test.go | 110 +++++++++++++++++++++++++++++++++ bep44/item.go | 10 ++- bep44/store.go | 8 +++ bugs_test.go | 90 +++++++++++++++++++++++++++ cmd/dht-server/close_test.go | 23 +++++++ cmd/dht-server/main.go | 36 +++++++---- cmd/dht/ping.go | 10 ++- cmd/dht/ping_test.go | 59 ++++++++++++++++++ server.go | 49 ++++++++++++--- table.go | 18 ++++-- table_test.go | 64 +++++++++++++++++++ traversal/closest_race_test.go | 58 +++++++++++++++++ traversal/operation.go | 7 ++- 13 files changed, 505 insertions(+), 37 deletions(-) create mode 100644 bep44/cas_test.go create mode 100644 bugs_test.go create mode 100644 cmd/dht-server/close_test.go create mode 100644 cmd/dht/ping_test.go create mode 100644 traversal/closest_race_test.go diff --git a/bep44/cas_test.go b/bep44/cas_test.go new file mode 100644 index 000000000..2c2142f6b --- /dev/null +++ b/bep44/cas_test.go @@ -0,0 +1,110 @@ +package bep44 + +import ( + "crypto/ed25519" + "errors" + "sync" + "testing" + "time" +) + +// BEP 44: when cas is present it is the sequence number being overwritten, compared to the +// sequence currently stored. It is not compared to the cas stored with the previous write. +// A zero cas is absent on the wire (bencode omitempty). +func TestCheckIncomingCASComparesStoredSequence(t *testing.T) { + stored := &Item{Seq: 1, V: "a"} + if err := CheckIncoming(stored, &Item{Seq: 2, Cas: 1, V: "b"}); err != nil { + t.Fatalf("cas equal to the stored sequence was rejected: %v", err) + } + if err := CheckIncoming(stored, &Item{Seq: 2, Cas: 9, V: "b"}); !errors.Is(err, ErrCasHashMismatched) { + t.Fatalf("cas 9 against stored seq 1: got %v, want mismatch", err) + } + if err := CheckIncoming(stored, &Item{Seq: 2, V: "b"}); err != nil { + t.Fatalf("absent cas was rejected: %v", err) + } + // The previous writer sent cas 4. The current sequence is 5. A correct replacement + // names cas 5, not 4. + stored.Cas = 4 + stored.Seq = 5 + if err := CheckIncoming(stored, &Item{Seq: 6, Cas: 5, V: "c"}); err != nil { + t.Fatalf("cas was compared to stored.Cas (%d) instead of stored.Seq: %v", stored.Cas, err) + } +} + +// Wrapper.Put reads the current item and writes the new one as two store calls. Overlapping +// calls can both observe the old sequence and then write out of order. +type overlapStore struct { + mu sync.Mutex + depth int + overlapped bool + item *Item +} + +func (s *overlapStore) begin() { + s.mu.Lock() + s.depth++ + if s.depth > 1 { + s.overlapped = true + } + s.mu.Unlock() + time.Sleep(30 * time.Millisecond) +} + +func (s *overlapStore) end() { + s.mu.Lock() + s.depth-- + s.mu.Unlock() +} + +func (s *overlapStore) Get(Target) (*Item, error) { + s.begin() + defer s.end() + s.mu.Lock() + defer s.mu.Unlock() + if s.item == nil { + return nil, ErrItemNotFound + } + return s.item, nil +} + +func (s *overlapStore) Put(i *Item) error { + s.begin() + defer s.end() + s.mu.Lock() + defer s.mu.Unlock() + s.item = i + return nil +} + +func (s *overlapStore) Del(Target) error { return nil } + +func TestWrapperPutDoesNotOverlap(t *testing.T) { + _, priv, err := ed25519.GenerateKey(nil) + if err != nil { + t.Fatal(err) + } + i1, err := NewItem("one", nil, 1, 0, priv) + if err != nil { + t.Fatal(err) + } + i2, err := NewItem("two", nil, 2, 0, priv) + if err != nil { + t.Fatal(err) + } + i3, err := NewItem("three", nil, 3, 0, priv) + if err != nil { + t.Fatal(err) + } + st := &overlapStore{item: i1} + w := NewWrapper(st, time.Hour) + var wg sync.WaitGroup + wg.Go(func() { _ = w.Put(i2) }) + wg.Go(func() { _ = w.Put(i3) }) + wg.Wait() + if st.overlapped { + t.Fatal("two Wrapper.Put calls overlapped inside the store; a lower sequence can overwrite a higher one") + } + if st.item.Seq != 3 { + t.Fatalf("stored seq %d, want 3", st.item.Seq) + } +} diff --git a/bep44/item.go b/bep44/item.go index f8a03d5d0..ce5263343 100644 --- a/bep44/item.go +++ b/bep44/item.go @@ -162,12 +162,10 @@ func CheckIncoming(stored, incoming *Item) error { return ErrSequenceNumberLessThanCurrent } - // Cas should be ignored if not present - if stored.Cas == 0 { - return nil - } - - if stored.Cas != incoming.Cas { + // cas is optional. A zero value is omitted on the wire, so zero means absent. When present, + // BEP 44 requires it to equal the sequence number currently stored, not the cas recorded on + // the previous write. Callers skip this check when nothing is stored yet. + if incoming.Cas != 0 && incoming.Cas != stored.Seq { return ErrCasHashMismatched } diff --git a/bep44/store.go b/bep44/store.go index 6118349c2..0bbd4b36f 100644 --- a/bep44/store.go +++ b/bep44/store.go @@ -2,6 +2,7 @@ package bep44 import ( "errors" + "sync" "time" ) @@ -17,6 +18,7 @@ type Store interface { // decide when to store, or ignore them depending of the BEP 44 definition. // It is also in charge of removing expired items. type Wrapper struct { + mu sync.Mutex s Store exp time.Duration } @@ -26,6 +28,10 @@ func NewWrapper(s Store, exp time.Duration) *Wrapper { } func (w *Wrapper) Put(i *Item) error { + // Hold the lock from the read through the write. Two puts that both observe the same + // sequence can otherwise store the lower one last. + w.mu.Lock() + defer w.mu.Unlock() if err := Check(i); err != nil { return err } @@ -48,6 +54,8 @@ func (w *Wrapper) Put(i *Item) error { } func (w *Wrapper) Get(t Target) (*Item, error) { + w.mu.Lock() + defer w.mu.Unlock() i, err := w.s.Get(t) if err != nil { return nil, err diff --git a/bugs_test.go b/bugs_test.go new file mode 100644 index 000000000..1a81f7581 --- /dev/null +++ b/bugs_test.go @@ -0,0 +1,90 @@ +package dht + +import ( + "net" + "net/netip" + "sync" + "testing" + "time" + + "github.com/anacrolix/torrent/iplist" + + "github.com/anacrolix/dht/v2/krpc" +) + +// Close is documented to stop the server network activity. A ping that has already been written +// waits out QueryResendDelay unless Close cancels it. An hour-long delay must not stick. +func TestPingReturnsAfterClose(t *testing.T) { + pc, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { pc.Close() }) + sent := make(chan struct{}) + go func() { + b := make([]byte, 1500) + if _, _, err := pc.ReadFrom(b); err == nil { + close(sent) + } + }() + s, err := NewServer(&ServerConfig{ + Conn: mustListen("127.0.0.1:0"), + NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + done := make(chan QueryResult, 1) + go func() { + done <- s.Ping(pc.LocalAddr().(*net.UDPAddr)) + }() + select { + case <-sent: + case <-time.After(2 * time.Second): + t.Fatal("ping was not written") + } + s.Close() + select { + case res := <-done: + if res.Err == nil { + t.Fatal("ping succeeded after Close") + } + case <-time.After(2 * time.Second): + t.Fatal("Ping did not return after Close") + } +} + +type swapList struct{ n int } + +func (swapList) Lookup(net.IP) (iplist.Range, bool) { return iplist.Range{}, false } +func (s swapList) NumRanges() int { return s.n } + +// SetIPBlockList stores the list under s.mu, but IPBlocklist and TraversalNodeFilter read it +// without that lock. Concurrent replacement must not race. +func TestIPBlocklistConcurrentRead(t *testing.T) { + s, err := NewServer(&ServerConfig{ + Conn: mustListen("127.0.0.1:0"), + NoSecurity: true, + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + node := addrMaybeId{Addr: krpc.NodeAddrPort{AddrPort: netip.AddrPortFrom(netip.MustParseAddr("8.8.8.8"), 6881)}} + var wg sync.WaitGroup + wg.Go(func() { + for range 2000 { + s.SetIPBlockList(swapList{1}) + s.SetIPBlockList(nil) + } + }) + wg.Go(func() { + for range 2000 { + _ = s.IPBlocklist() + _ = s.TraversalNodeFilter(node) + } + }) + wg.Wait() +} diff --git a/cmd/dht-server/close_test.go b/cmd/dht-server/close_test.go new file mode 100644 index 000000000..1eb6b9570 --- /dev/null +++ b/cmd/dht-server/close_test.go @@ -0,0 +1,23 @@ +package main + +import ( + "net" + "testing" + "time" +) + +// A missing table file used to return after NewServer without Close. The deferred socket close +// then made serveUntilClosed panic: read on a closed connection while the server was still open. +func TestTableLoadErrorDoesNotPanic(t *testing.T) { + flags.TableFile = "no-such-dht-table-file" + conn, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + defer conn.Close() + err = initServer(conn) + if err == nil { + t.Fatal("expected missing table file") + } + time.Sleep(300 * time.Millisecond) +} diff --git a/cmd/dht-server/main.go b/cmd/dht-server/main.go index 5e2d78b3b..e37cb02d0 100644 --- a/cmd/dht-server/main.go +++ b/cmd/dht-server/main.go @@ -32,6 +32,28 @@ func loadTable() (err error) { return } +// initServer starts the node on conn and loads flags.TableFile when set. A load error closes the +// server before returning, so the caller's deferred conn.Close cannot race an open serve loop. +func initServer(conn net.PacketConn) error { + cfg := dht.NewDefaultServerConfig() + cfg.Conn = conn + cfg.Logger = log.Default.FilterLevel(log.Info) + cfg.NoSecurity = false + var err error + s, err = dht.NewServer(cfg) + if err != nil { + return err + } + if flags.TableFile == "" { + return nil + } + if err = loadTable(); err != nil { + s.Close() + return err + } + return nil +} + func saveTable() error { return dht.WriteNodesToFile(s.Nodes(), flags.TableFile) } @@ -52,23 +74,13 @@ func mainErr() error { return err } defer conn.Close() - cfg := dht.NewDefaultServerConfig() - cfg.Conn = conn - cfg.Logger = log.Default.FilterLevel(log.Info) - cfg.NoSecurity = false - s, err = dht.NewServer(cfg) - if err != nil { + if err = initServer(conn); err != nil { return err } + defer s.Close() http.HandleFunc("/debug/dht", func(w http.ResponseWriter, r *http.Request) { s.WriteStatus(w) }) - if flags.TableFile != "" { - err = loadTable() - if err != nil { - return err - } - } log.Printf("dht server on %s, ID is %x", s.Addr(), s.ID()) ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt) diff --git a/cmd/dht/ping.go b/cmd/dht/ping.go index 4a9604792..2e6e54b0b 100644 --- a/cmd/dht/ping.go +++ b/cmd/dht/ping.go @@ -36,12 +36,16 @@ func ping(args pingArgs, s *dht.Server) error { fmt.Printf("%s: %s: %s\n", a, time.Since(started), res.Err) return } - id := *res.Reply.SenderID() + id := res.Reply.SenderID() + if id == nil { + fmt.Printf("%s: response has no id: %s\n", a, time.Since(started)) + return + } secure := '✘' - if dht.NodeIdSecure(id, ua.IP) { + if dht.NodeIdSecure(*id, ua.IP) { secure = '✔' } - fmt.Printf("%s: %x %c: %s\n", a, id, secure, time.Since(started)) + fmt.Printf("%s: %x %c: %s\n", a, *id, secure, time.Since(started)) }) } done := make(chan struct{}) diff --git a/cmd/dht/ping_test.go b/cmd/dht/ping_test.go new file mode 100644 index 000000000..f381f6c42 --- /dev/null +++ b/cmd/dht/ping_test.go @@ -0,0 +1,59 @@ +package main + +import ( + "net" + "testing" + "time" + + "github.com/anacrolix/torrent/bencode" + + "github.com/anacrolix/dht/v2" + "github.com/anacrolix/dht/v2/krpc" +) + +// A response without an id is a successful KRPC reply. SenderID is nil, and ping must not +// dereference it. PingQueryInput already skips a nil id. +func TestPingResponseWithoutID(t *testing.T) { + pc, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { pc.Close() }) + go func() { + b := make([]byte, 1500) + n, addr, err := pc.ReadFrom(b) + if err != nil { + return + } + var q krpc.Msg + if err := bencode.Unmarshal(b[:n], &q); err != nil { + return + } + rb, err := bencode.Marshal(krpc.Msg{Y: krpc.YResponse, T: q.T}) + if err != nil { + return + } + _, _ = pc.WriteTo(rb, addr) + }() + conn, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { conn.Close() }) + s, err := dht.NewServer(&dht.ServerConfig{ + Conn: conn, + NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + err = ping(pingArgs{ + Network: "udp", + Nodes: []string{pc.LocalAddr().String()}, + }, s) + if err != nil { + t.Fatal(err) + } +} diff --git a/server.go b/server.go index 4348442c6..0c1dadaee 100644 --- a/server.go +++ b/server.go @@ -10,6 +10,7 @@ import ( "runtime/pprof" "slices" "strings" + "sync/atomic" "text/tabwriter" "time" @@ -46,7 +47,11 @@ type Server struct { transactions transactions.Dispatcher[*transaction] table table closed chansync.SetOnce - ipBlockList iplist.Ranger + // Cancelled at the start of Close, before s.mu is taken. Query combines it with the + // caller context so an in-flight send ends when the server shuts down. + serverCtx context.Context + cancelServer context.CancelFunc + ipBlockList atomic.Pointer[ipBlocklist] tokenServer tokenServer // Manages tokens we issue to our queriers. config ServerConfig stats ServerStats @@ -221,8 +226,7 @@ func NewServer(c *ServerConfig) (s *Server, err error) { } s = &Server{ - config: *c, - ipBlockList: c.IPBlocklist, + config: *c, tokenServer: tokenServer{ maxIntervalDelta: 2, interval: 5 * time.Minute, @@ -237,6 +241,10 @@ func NewServer(c *ServerConfig) (s *Server, err error) { s.socket = c.Conn s.id = int160.FromByteArray(c.NodeId) s.table.rootID = s.id + s.serverCtx, s.cancelServer = context.WithCancel(context.Background()) + if c.IPBlocklist != nil { + s.ipBlockList.Store(&ipBlocklist{list: c.IPBlocklist}) + } s.resendDelay = s.config.QueryResendDelay if s.resendDelay == nil { s.resendDelay = defaultQueryResendDelay @@ -260,14 +268,28 @@ func (s *Server) String() string { } // Packets to and from any address matching a range in the list are dropped. +// Published atomically. ipBlocked runs both under s.mu and outside it, and writeToNode calls it +// while already holding s.mu.RLock, so this list is not guarded by s.mu. +type ipBlocklist struct{ list iplist.Ranger } + +func (s *Server) blocklist() iplist.Ranger { + h := s.ipBlockList.Load() + if h == nil { + return nil + } + return h.list +} + func (s *Server) SetIPBlockList(list iplist.Ranger) { - s.mu.Lock() - defer s.mu.Unlock() - s.ipBlockList = list + if list == nil { + s.ipBlockList.Store(nil) + return + } + s.ipBlockList.Store(&ipBlocklist{list: list}) } func (s *Server) IPBlocklist() iplist.Ranger { - return s.ipBlockList + return s.blocklist() } func (s *Server) processPacket(b []byte, addr Addr) { @@ -365,10 +387,11 @@ func (s *Server) serve() error { } func (s *Server) ipBlocked(ip net.IP) (blocked bool) { - if s.ipBlockList == nil { + list := s.blocklist() + if list == nil { return } - _, blocked = s.ipBlockList.Lookup(ip) + _, blocked = list.Lookup(ip) return } @@ -729,7 +752,7 @@ func (s *Server) writeToNode(ctx context.Context, b []byte, node Addr, wait, rat err = errors.New("server is closed") return } - if list := s.ipBlockList; list != nil { + if list := s.blocklist(); list != nil { if r, ok := list.Lookup(node.IP()); ok { err = fmt.Errorf("write to %v blocked by %v", node, r) return @@ -908,6 +931,10 @@ func (s *Server) Query(ctx context.Context, addr Addr, q string, input QueryInpu // Receives the sender's terminal error, and closes when the sender completes. sendErr := make(chan error, 1) sendCtx, cancelSend := context.WithCancel(pprof.WithLabels(ctx, pprof.Labels("q", q))) + // Close cancels serverCtx. Either that or the caller context ends the send. The callback + // only cancels sendCtx, so it does not take s.mu. + stopServer := context.AfterFunc(s.serverCtx, cancelSend) + defer stopServer() go func() { sendErr <- s.transactionQuerySender( sendCtx, @@ -1098,6 +1125,8 @@ func (s *Server) notBadNodes() (nis []krpc.NodeInfo) { // Stops the server network activity. This is all that's required to clean-up a Server. func (s *Server) Close() { + // Cancel before taking s.mu. In-flight queries must observe it without this method holding the lock. + s.cancelServer() s.mu.Lock() defer s.mu.Unlock() s.closed.Set() diff --git a/table.go b/table.go index 04ff10670..bf95948d3 100644 --- a/table.go +++ b/table.go @@ -3,6 +3,7 @@ package dht import ( "errors" "fmt" + "slices" "github.com/anacrolix/dht/v2/int160" ) @@ -85,16 +86,23 @@ func (tbl *table) closestNodes(k int, target int160.T, filter func(*node) bool) if target != tbl.rootID { bi = tbl.bucketIndex(target) } + // Buckets are ordered by XOR magnitude: every node in an earlier bucket is closer than every + // node in a later one. Inside a bucket the map order is not distance order, so a partial + // bucket is sorted and only the nearest remaining slots are kept. for ; bi >= 0 && len(ret) < k; bi-- { + var bucketNodes []*node for n := range tbl.buckets[bi].nodes { if filter(n) { - ret = append(ret, n) + bucketNodes = append(bucketNodes, n) } } - } - // TODO: Keep only the closest. - if len(ret) > k { - ret = ret[:k] + slices.SortFunc(bucketNodes, func(a, b *node) int { + return a.Id.Distance(target).Cmp(b.Id.Distance(target)) + }) + if need := k - len(ret); len(bucketNodes) > need { + bucketNodes = bucketNodes[:need] + } + ret = append(ret, bucketNodes...) } return } diff --git a/table_test.go b/table_test.go index 96efcb41e..4ac6f8dbf 100644 --- a/table_test.go +++ b/table_test.go @@ -61,3 +61,67 @@ func TestRandomIdInBucket(t *testing.T) { qt.Assert(t, qt.Equals(tbl.bucketIndex(id), i)) } } + +// BEP 5 replies must contain the k nodes closest to the target. closestNodes walks buckets and +// then cuts the list at k, so a partially included bucket keeps whichever nodes the map yields +// first rather than the nearest ones. +func TestClosestNodesKeepsNearestInBucket(t *testing.T) { + var root int160.T + tbl := table{rootID: root, k: 8} + var target int160.T + target.SetBit(10, true) + + add := func(bucket, extra, port int) { + t.Helper() + var id int160.T + id.SetBit(bucket, true) + if extra >= 0 { + id.SetBit(extra, true) + } + if got := tbl.bucketIndex(id); got != bucket { + t.Fatalf("bit %d extra %d is bucket %d, want %d", bucket, extra, got, bucket) + } + n := &node{nodeKey: nodeKey{ + Id: id, + Addr: NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: port}), + }} + if err := tbl.addNode(n); err != nil { + t.Fatal(err) + } + } + // Three nodes in the target's bucket. Every one of them is closer than every node in the next + // bucket, so all three must be kept. + for i, bit := range []int{20, 30, 40} { + add(10, bit, 1000+i) + } + // Eight nodes in the next bucket. Only the five closest fit in the remaining slots. + for _, bit := range []int{20, 30, 40, 50, 60, 70, 80, 90} { + add(9, bit, 2000+bit) + } + want := map[int]bool{1000: true, 1001: true, 1002: true, 2090: true, 2080: true, 2070: true, 2060: true, 2050: true} + + for try := range 30 { + got := tbl.closestNodes(8, target, func(*node) bool { return true }) + if len(got) != 8 { + t.Fatalf("try %d: got %d nodes", try, len(got)) + } + var prev int160.T + seen := map[int]bool{} + for i, n := range got { + d := n.Id.Distance(target) + if i > 0 && prev.Cmp(d) > 0 { + t.Fatalf("try %d: result is not ordered by XOR distance", try) + } + prev = d + seen[n.Addr.Port()] = true + } + if len(seen) != len(want) { + t.Fatalf("try %d: ports %v, want %v", try, seen, want) + } + for port := range want { + if !seen[port] { + t.Fatalf("try %d: dropped closer node on port %d; got %v", try, port, seen) + } + } + } +} diff --git a/traversal/closest_race_test.go b/traversal/closest_race_test.go new file mode 100644 index 000000000..0de7419d3 --- /dev/null +++ b/traversal/closest_race_test.go @@ -0,0 +1,58 @@ +package traversal + +import ( + "context" + "net/netip" + "testing" + "time" + + "github.com/anacrolix/generics" + + "github.com/anacrolix/dht/v2/int160" + k_nearest_nodes "github.com/anacrolix/dht/v2/k-nearest-nodes" + "github.com/anacrolix/dht/v2/krpc" + "github.com/anacrolix/dht/v2/types" +) + +// Closest hands out the live struct. A query response replaces it while a caller ranges it. +func TestClosestDoesNotRaceQuery(t *testing.T) { + started := make(chan struct{}) + release := make(chan struct{}) + var responder int160.T + responder.SetBit(3, true) + op := Start(OperationInput{ + Alpha: 1, + K: 8, + DoQuery: func(context.Context, krpc.NodeAddr) QueryResult { + close(started) + <-release + ni := krpc.NodeInfo{ + ID: responder.AsByteArray(), + Addr: krpc.NodeAddr{IP: netip.MustParseAddr("1.2.3.4").AsSlice(), Port: 1}, + } + return QueryResult{ResponseFrom: &ni, ClosestData: "token"} + }, + }) + var id int160.T + id.SetBit(4, true) + op.AddNodes([]types.AddrMaybeId{{ + Addr: krpc.NodeAddrPort{AddrPort: netip.AddrPortFrom(netip.MustParseAddr("1.2.3.4"), 1)}, + Id: generics.Some(id), + }}) + select { + case <-started: + case <-time.After(2 * time.Second): + t.Fatal("query did not start") + } + done := make(chan struct{}) + go func() { + defer close(done) + for range 20000 { + op.Closest().Range(func(k_nearest_nodes.Elem) {}) + } + }() + close(release) + <-done + op.Stop() + <-op.Stopped() +} diff --git a/traversal/operation.go b/traversal/operation.go index a3c662323..f05cdbab4 100644 --- a/traversal/operation.go +++ b/traversal/operation.go @@ -227,8 +227,13 @@ func (op *Operation) addClosest(node krpc.NodeInfo, data any) { }) } +// Closest returns a snapshot of the closest responding nodes. The snapshot stays valid while +// later responses update the operation. It is not itself updated. func (op *Operation) Closest() *k_nearest_nodes.Type { - return &op.closest + op.mu.Lock() + defer op.mu.Unlock() + c := op.closest + return &c } func (op *Operation) startQuery() { From a28a2e279c3bee17d7b8cbe06278c3146ad46436 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 15:38:33 +0530 Subject: [PATCH 12/18] Correct target-wide node selection and callback shutdown lifetimes Rank eligible nodes across the entire routing table. Release the server lock around configurable callbacks, store access, marshaling and status output, preserving veto and closed-state checks. Cancel and join CLI queries and bootstrap before returning or saving state. Check mutable CAS before sequence handling and compute Memory targets outside its mutex. Replace implementation-pinning tests with reproduced behavioral regressions and deterministic lifecycle handshakes. --- announce_test.go | 26 +- bep44/cas_test.go | 139 +++++----- bep44/item.go | 22 +- bep44/memory.go | 4 +- bep44/store_test.go | 55 ++++ bugs_test.go | 48 +++- callback_test.go | 481 +++++++++++++++++++++++++++++++++++ cmd/dht-server/close_test.go | 118 ++++++++- cmd/dht-server/main.go | 15 +- cmd/dht/get.go | 7 +- cmd/dht/main.go | 387 +++++++++++++++------------- cmd/dht/ping.go | 34 ++- cmd/dht/ping_test.go | 178 ++++++++++++- cmd/dht/put-bep46.go | 4 +- cmd/dht/put.go | 4 +- dht_test.go | 51 ++-- exts/getput/getput_test.go | 45 ++++ server.go | 238 ++++++++++------- server_test.go | 34 ++- table.go | 34 ++- table_test.go | 40 +++ 21 files changed, 1542 insertions(+), 422 deletions(-) create mode 100644 callback_test.go diff --git a/announce_test.go b/announce_test.go index 5d65b9853..128879be4 100644 --- a/announce_test.go +++ b/announce_test.go @@ -39,10 +39,15 @@ func TestAnnounceStopsNoPending(t *testing.T) { }, }) qt.Assert(t, qt.IsNil(err)) + t.Cleanup(s.Close) a, err := s.Announce(randomInfohash(), 0, true) qt.Assert(t, qt.IsNil(err)) - defer a.Close() - <-a.Peers + t.Cleanup(a.Close) + select { + case <-a.Finished(): + case <-time.After(2 * time.Second): + t.Fatal("empty traversal did not finish") + } } // Assert that rate.Limiter won't wake-up waiters once they have determined a @@ -72,10 +77,17 @@ func TestTraversalStatsDuringQuery(t *testing.T) { defer s.Close() a, err := s.AnnounceTraversal([20]byte{9}) qt.Assert(t, qt.IsNil(err)) - defer a.Close() - deadline := time.Now().Add(50 * time.Millisecond) - for time.Now().Before(deadline) { - _ = a.TraversalStats() - _ = a.NumContacted() + t.Cleanup(a.Close) + qt.Assert(t, qt.IsNil(silent.SetReadDeadline(time.Now().Add(2*time.Second)))) + var packet [1500]byte + _, _, err = silent.ReadFrom(packet[:]) + qt.Assert(t, qt.IsNil(err)) + qt.Assert(t, qt.Equals(a.TraversalStats().NumAddrsTried, uint32(1))) + qt.Assert(t, qt.Equals(a.NumContacted(), uint32(1))) + a.Close() + select { + case <-a.Finished(): + case <-time.After(2 * time.Second): + t.Fatal("stats traversal did not finish") } } diff --git a/bep44/cas_test.go b/bep44/cas_test.go index 2c2142f6b..8c9c6baec 100644 --- a/bep44/cas_test.go +++ b/bep44/cas_test.go @@ -3,108 +3,109 @@ package bep44 import ( "crypto/ed25519" "errors" - "sync" "testing" "time" ) -// BEP 44: when cas is present it is the sequence number being overwritten, compared to the -// sequence currently stored. It is not compared to the cas stored with the previous write. -// A zero cas is absent on the wire (bencode omitempty). +// The current public API and KRPC Cas fields are int64, and KRPC encodes Cas with omitempty. Thus +// cas=0 cannot be distinguished from omission; this is a representation limitation, not a BEP 44 +// rule that a present cas of zero is absent. func TestCheckIncomingCASComparesStoredSequence(t *testing.T) { - stored := &Item{Seq: 1, V: "a"} - if err := CheckIncoming(stored, &Item{Seq: 2, Cas: 1, V: "b"}); err != nil { + var key [32]byte + key[0] = 1 + stored := &Item{K: key, Seq: 1, V: "a"} + if err := CheckIncoming(stored, &Item{K: key, Seq: 2, Cas: 1, V: "b"}); err != nil { t.Fatalf("cas equal to the stored sequence was rejected: %v", err) } - if err := CheckIncoming(stored, &Item{Seq: 2, Cas: 9, V: "b"}); !errors.Is(err, ErrCasHashMismatched) { + if err := CheckIncoming(stored, &Item{K: key, Seq: 2, Cas: 9, V: "b"}); !errors.Is(err, ErrCasHashMismatched) { t.Fatalf("cas 9 against stored seq 1: got %v, want mismatch", err) } - if err := CheckIncoming(stored, &Item{Seq: 2, V: "b"}); err != nil { + if err := CheckIncoming(stored, &Item{K: key, Seq: 2, V: "b"}); err != nil { t.Fatalf("absent cas was rejected: %v", err) } // The previous writer sent cas 4. The current sequence is 5. A correct replacement // names cas 5, not 4. stored.Cas = 4 stored.Seq = 5 - if err := CheckIncoming(stored, &Item{Seq: 6, Cas: 5, V: "c"}); err != nil { + if err := CheckIncoming(stored, &Item{K: key, Seq: 6, Cas: 5, V: "c"}); err != nil { t.Fatalf("cas was compared to stored.Cas (%d) instead of stored.Seq: %v", stored.Cas, err) } } -// Wrapper.Put reads the current item and writes the new one as two store calls. Overlapping -// calls can both observe the old sequence and then write out of order. -type overlapStore struct { - mu sync.Mutex - depth int - overlapped bool - item *Item -} - -func (s *overlapStore) begin() { - s.mu.Lock() - s.depth++ - if s.depth > 1 { - s.overlapped = true - } - s.mu.Unlock() - time.Sleep(30 * time.Millisecond) -} - -func (s *overlapStore) end() { - s.mu.Lock() - s.depth-- - s.mu.Unlock() -} - -func (s *overlapStore) Get(Target) (*Item, error) { - s.begin() - defer s.end() - s.mu.Lock() - defer s.mu.Unlock() - if s.item == nil { - return nil, ErrItemNotFound - } - return s.item, nil -} - -func (s *overlapStore) Put(i *Item) error { - s.begin() - defer s.end() - s.mu.Lock() - defer s.mu.Unlock() - s.item = i - return nil +func TestCheckIncomingCASMismatchPrecedesSequenceCheck(t *testing.T) { + var key [32]byte + key[0] = 1 + stored := &Item{K: key, Seq: 5, V: "same"} + for _, incoming := range []*Item{ + {K: key, Seq: 5, Cas: 4, V: "same"}, + {K: key, Seq: 5, Cas: 4, V: "different"}, + {K: key, Seq: 4, Cas: 4, V: "older"}, + } { + if err := CheckIncoming(stored, incoming); !errors.Is(err, ErrCasHashMismatched) { + t.Errorf("CheckIncoming(%+v) = %v, want CAS mismatch", incoming, err) + } + } } -func (s *overlapStore) Del(Target) error { return nil } - -func TestWrapperPutDoesNotOverlap(t *testing.T) { +func TestWrapperConcurrentCASAllowsOneUpdate(t *testing.T) { _, priv, err := ed25519.GenerateKey(nil) if err != nil { t.Fatal(err) } - i1, err := NewItem("one", nil, 1, 0, priv) + initial, err := NewItem("initial", nil, 1, 0, priv) if err != nil { t.Fatal(err) } - i2, err := NewItem("two", nil, 2, 0, priv) + first, err := NewItem("first", nil, 2, 1, priv) if err != nil { t.Fatal(err) } - i3, err := NewItem("three", nil, 3, 0, priv) + second, err := NewItem("second", nil, 2, 1, priv) + if err != nil { + t.Fatal(err) + } + + memory := NewMemory() + wrapper := NewWrapper(memory, time.Hour) + if err := wrapper.Put(initial); err != nil { + t.Fatal(err) + } + + type result struct { + item *Item + err error + } + start := make(chan struct{}) + results := make(chan result, 2) + for _, item := range []*Item{first, second} { + go func(item *Item) { + <-start + results <- result{item: item, err: wrapper.Put(item)} + }(item) + } + close(start) + + var winner *Item + successes := 0 + for range 2 { + got := <-results + if got.err == nil { + winner = got.item + successes++ + } else if !errors.Is(got.err, ErrCasHashMismatched) { + t.Errorf("Wrapper.Put(%q) error = %v, want CAS mismatch", got.item.V, got.err) + } + } + if successes != 1 { + t.Fatalf("successful concurrent CAS writes = %d, want exactly one", successes) + } + + stored, err := memory.Get(initial.Target()) if err != nil { t.Fatal(err) } - st := &overlapStore{item: i1} - w := NewWrapper(st, time.Hour) - var wg sync.WaitGroup - wg.Go(func() { _ = w.Put(i2) }) - wg.Go(func() { _ = w.Put(i3) }) - wg.Wait() - if st.overlapped { - t.Fatal("two Wrapper.Put calls overlapped inside the store; a lower sequence can overwrite a higher one") - } - if st.item.Seq != 3 { - t.Fatalf("stored seq %d, want 3", st.item.Seq) + if stored.Seq != 2 || stored.V != winner.V { + t.Fatalf("stored item = (seq %d, value %q), want the accepted write (seq 2, value %q)", + stored.Seq, stored.V, winner.V) } } diff --git a/bep44/item.go b/bep44/item.go index ce5263343..f393b9cad 100644 --- a/bep44/item.go +++ b/bep44/item.go @@ -147,8 +147,19 @@ func Check(i *Item) error { } func CheckIncoming(stored, incoming *Item) error { - // If the sequence number is equal, and the value is also the same, - // the node SHOULD reset its timeout counter. + // BEP 44 requires a CAS mismatch to fail even when the sequence number is also stale or the + // value is unchanged, so check CAS before sequence-number rules. CAS only applies to mutable + // puts. + // + // Cas is an int64 in the public API and KRPC arguments; KRPC also omits zero values. A present + // cas=0 is therefore indistinguishable from an absent cas and cannot be checked here. Supporting + // present zero requires presence-aware CAS fields across the API and wire representation. + if incoming.IsMutable() && incoming.Cas != 0 && incoming.Cas != stored.Seq { + return ErrCasHashMismatched + } + + // If the sequence number is equal, and the value is also the same, the node SHOULD reset its + // timeout counter. if stored.Seq == incoming.Seq { if bytes.Equal( bencode.MustMarshal(stored.V), @@ -162,12 +173,5 @@ func CheckIncoming(stored, incoming *Item) error { return ErrSequenceNumberLessThanCurrent } - // cas is optional. A zero value is omitted on the wire, so zero means absent. When present, - // BEP 44 requires it to equal the sequence number currently stored, not the cas recorded on - // the previous write. Callers skip this check when nothing is stored yet. - if incoming.Cas != 0 && incoming.Cas != stored.Seq { - return ErrCasHashMismatched - } - return nil } diff --git a/bep44/memory.go b/bep44/memory.go index a9fd9235e..535e1bf36 100644 --- a/bep44/memory.go +++ b/bep44/memory.go @@ -19,10 +19,12 @@ func NewMemory() *Memory { } func (m *Memory) Put(i *Item) error { + target := i.Target() + m.mu.Lock() defer m.mu.Unlock() - m.m[i.Target()] = i + m.m[target] = i return nil } diff --git a/bep44/store_test.go b/bep44/store_test.go index 64cc79352..5047f33db 100644 --- a/bep44/store_test.go +++ b/bep44/store_test.go @@ -2,6 +2,8 @@ package bep44 import ( "encoding/hex" + "errors" + "sync" "testing" "time" @@ -38,3 +40,56 @@ func TestWrapperTimeout(t *testing.T) { _, err = w.Get(i.Target()) qt.Assert(t, qt.Equals(err, ErrItemNotFound)) } + +type reentrantMemoryValue struct { + memory *Memory + getErr chan error + once sync.Once +} + +func (v *reentrantMemoryValue) MarshalBencode() ([]byte, error) { + v.once.Do(func() { + _, err := v.memory.Get(Target{}) + v.getErr <- err + }) + return []byte("1:x"), nil +} + +func TestMemoryPutAllowsMarshalerToCallGet(t *testing.T) { + memory := NewMemory() + value := &reentrantMemoryValue{ + memory: memory, + getErr: make(chan error, 1), + } + item := &Item{V: value} + putErr := make(chan error, 1) + go func() { + putErr <- memory.Put(item) + }() + + select { + case err := <-putErr: + if err != nil { + t.Fatalf("Memory.Put returned an error: %v", err) + } + case <-time.After(time.Second): + t.Fatal("Memory.Put did not complete when MarshalBencode called Memory.Get") + } + + select { + case err := <-value.getErr: + if !errors.Is(err, ErrItemNotFound) { + t.Fatalf("Memory.Get from MarshalBencode error = %v, want %v", err, ErrItemNotFound) + } + case <-time.After(time.Second): + t.Fatal("MarshalBencode did not complete its Memory.Get call") + } + + stored, err := memory.Get(item.Target()) + if err != nil { + t.Fatal(err) + } + if stored != item { + t.Fatalf("Memory.Get returned %p, want stored item %p", stored, item) + } +} diff --git a/bugs_test.go b/bugs_test.go index 1a81f7581..eb4cfb0bf 100644 --- a/bugs_test.go +++ b/bugs_test.go @@ -1,6 +1,8 @@ package dht import ( + "context" + "errors" "net" "net/netip" "sync" @@ -48,12 +50,15 @@ func TestPingReturnsAfterClose(t *testing.T) { s.Close() select { case res := <-done: - if res.Err == nil { - t.Fatal("ping succeeded after Close") + if !errors.Is(res.Err, context.Canceled) { + t.Fatalf("Ping after Close: got %v, want cancellation", res.Err) } case <-time.After(2 * time.Second): t.Fatal("Ping did not return after Close") } + if got := s.Stats().OutstandingTransactions; got != 0 { + t.Fatalf("Close left %d active transactions", got) + } } type swapList struct{ n int } @@ -61,8 +66,7 @@ type swapList struct{ n int } func (swapList) Lookup(net.IP) (iplist.Range, bool) { return iplist.Range{}, false } func (s swapList) NumRanges() int { return s.n } -// SetIPBlockList stores the list under s.mu, but IPBlocklist and TraversalNodeFilter read it -// without that lock. Concurrent replacement must not race. +// Concurrent block-list replacement must be safe for both public readers. func TestIPBlocklistConcurrentRead(t *testing.T) { s, err := NewServer(&ServerConfig{ Conn: mustListen("127.0.0.1:0"), @@ -88,3 +92,39 @@ func TestIPBlocklistConcurrentRead(t *testing.T) { }) wg.Wait() } + +func TestQueryCallerCancellation(t *testing.T) { + peer := mustListen("127.0.0.1:0") + t.Cleanup(func() { _ = peer.Close() }) + s, err := NewServer(&ServerConfig{ + Conn: mustListen("127.0.0.1:0"), NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + }) + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + done := make(chan QueryResult, 1) + go func() { done <- s.Query(ctx, NewAddr(peer.LocalAddr()), "ping", QueryInput{}) }() + if err := peer.SetReadDeadline(time.Now().Add(2 * time.Second)); err != nil { + t.Fatal(err) + } + var packet [1500]byte + if _, _, err := peer.ReadFrom(packet[:]); err != nil { + t.Fatal(err) + } + cancel() + select { + case res := <-done: + if !errors.Is(res.Err, context.Canceled) { + t.Fatalf("Query returned %v, want caller cancellation", res.Err) + } + case <-time.After(2 * time.Second): + t.Fatal("Query ignored caller cancellation") + } + if got := s.Stats().OutstandingTransactions; got != 0 { + t.Fatalf("cancelled Query left %d active transactions", got) + } +} diff --git a/callback_test.go b/callback_test.go new file mode 100644 index 000000000..bfa89fc6f --- /dev/null +++ b/callback_test.go @@ -0,0 +1,481 @@ +package dht + +import ( + "context" + "net" + "testing" + "time" + + "github.com/anacrolix/log" + "github.com/anacrolix/torrent/bencode" + "github.com/anacrolix/torrent/iplist" + + "github.com/anacrolix/dht/v2/bep44" + "github.com/anacrolix/dht/v2/krpc" + peer_store "github.com/anacrolix/dht/v2/peer-store" +) + +type callbackTestStore struct { + gets int + puts int + item *bep44.Item + onGet func() + onPut func(*bep44.Item) +} + +func (s *callbackTestStore) Put(item *bep44.Item) error { + s.puts++ + if s.onPut != nil { + s.onPut(item) + } + s.item = item + return nil +} +func (s *callbackTestStore) Get(bep44.Target) (*bep44.Item, error) { + s.gets++ + if s.onGet != nil { + s.onGet() + } + if s.item != nil { + return s.item, nil + } + return nil, bep44.ErrItemNotFound +} +func (*callbackTestStore) Del(bep44.Target) error { return nil } + +func newCallbackTestServer(t *testing.T, cfg *ServerConfig) *Server { + t.Helper() + conn, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = conn.Close() }) + cfg.Conn = conn + s, err := NewServer(cfg) + if err != nil { + t.Fatal(err) + } + return s +} + +func processCallbackTestPacket(t *testing.T, s *Server, query krpc.Msg) { + t.Helper() + packet := bencode.MustMarshal(query) + processed := make(chan struct{}) + go func() { + s.processPacket(packet, NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1})) + close(processed) + }() + select { + case <-processed: + case <-time.After(2 * time.Second): + t.Fatal("packet processing deadlocked") + } +} +func TestOnQueryCanReenterStatsAndClose(t *testing.T) { + conn, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + defer conn.Close() + + store := new(callbackTestStore) + cfg := NewDefaultServerConfig() + cfg.Conn = conn + cfg.Store = store + var s *Server + var callbackCalls int + callbackDone := make(chan struct{}) + cfg.OnQuery = func(query *krpc.Msg, _ net.Addr) bool { + callbackCalls++ + query.Q = "get" + _ = s.Stats() + s.Close() + close(callbackDone) + return true + } + s, err = NewServer(cfg) + if err != nil { + t.Fatal(err) + } + + packet := bencode.MustMarshal(krpc.Msg{ + T: "1", + Y: "q", + Q: "ping", + A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, + }) + processed := make(chan struct{}) + go func() { + s.processPacket(packet, NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1})) + close(processed) + }() + + select { + case <-processed: + case <-time.After(2 * time.Second): + t.Fatal("packet processing deadlocked when OnQuery reentered Server.Stats and Server.Close") + } + select { + case <-callbackDone: + default: + t.Fatal("packet processing returned before the OnQuery callback completed") + } + if callbackCalls != 1 { + t.Fatalf("OnQuery called %d times, want 1", callbackCalls) + } + if got := store.gets; got != 0 { + t.Fatalf("default handler accessed the store after callback closed the server: %d calls", got) + } + + // A packet presented after Close must be discarded before the callback or default handlers run. + s.processPacket(packet, NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1})) + if callbackCalls != 1 { + t.Errorf("OnQuery called after server close: %d calls, want 1", callbackCalls) + } +} + +var _ bep44.Store = (*callbackTestStore)(nil) + +func TestOnQueryMutationAndVeto(t *testing.T) { + tests := []struct { + name string + propagate bool + wantGets int + }{ + {name: "mutation propagates", propagate: true, wantGets: 1}, + {name: "veto skips default handler", propagate: false}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + store := new(callbackTestStore) + cfg := NewDefaultServerConfig() + cfg.Store = store + cfg.OnQuery = func(query *krpc.Msg, _ net.Addr) bool { + query.Q = "get" + return test.propagate + } + s := newCallbackTestServer(t, cfg) + processCallbackTestPacket(t, s, krpc.Msg{ + T: "1", + Y: "q", + Q: "ping", + A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, + }) + if got := store.gets; got != test.wantGets { + t.Errorf("store Get calls = %d, want %d", got, test.wantGets) + } + s.Close() + }) + } +} + +type callbackTestLogHandler struct { + onLog func() +} + +func (h callbackTestLogHandler) Handle(log.Record) { h.onLog() } + +func TestPacketLoggerCanReenterStats(t *testing.T) { + cfg := NewDefaultServerConfig() + cfg.Passive = true + cfg.Logger = log.NewLogger() + var s *Server + cfg.Logger.SetHandlers(callbackTestLogHandler{onLog: func() { _ = s.Stats() }}) + s = newCallbackTestServer(t, cfg) + processCallbackTestPacket(t, s, krpc.Msg{ + T: "1", + Y: "q", + Q: "ping", + A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, + }) + s.Close() +} + +type callbackTestWriter struct { + server *Server + writes int +} + +func (w *callbackTestWriter) Write(p []byte) (int, error) { + _ = w.server.Stats() + w.writes++ + return len(p), nil +} + +func TestWriteStatusWriterCanReenterStats(t *testing.T) { + s := newCallbackTestServer(t, NewDefaultServerConfig()) + writer := &callbackTestWriter{server: s} + done := make(chan struct{}) + go func() { + s.WriteStatus(writer) + close(done) + }() + select { + case <-done: + case <-time.After(2 * time.Second): + t.Fatal("WriteStatus deadlocked when its writer reentered Server.Stats") + } + if writer.writes == 0 { + t.Error("WriteStatus did not write output") + } + s.Close() +} + +type callbackTestPeerStore struct { + get func(peer_store.InfoHash) []krpc.NodeAddr +} + +func (*callbackTestPeerStore) AddPeer(peer_store.InfoHash, krpc.NodeAddr) {} +func (s *callbackTestPeerStore) GetPeers(ih peer_store.InfoHash) []krpc.NodeAddr { + return s.get(ih) +} + +func TestPeerStoreCanReenterStats(t *testing.T) { + var s *Server + cfg := NewDefaultServerConfig() + cfg.PeerStore = &callbackTestPeerStore{get: func(peer_store.InfoHash) []krpc.NodeAddr { + _ = s.Stats() + return nil + }} + s = newCallbackTestServer(t, cfg) + processCallbackTestPacket(t, s, krpc.Msg{ + T: "1", + Y: "q", + Q: "get_peers", + A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, + }) + s.Close() +} + +func TestStoreGetCanReenterStats(t *testing.T) { + var s *Server + store := &callbackTestStore{onGet: func() { _ = s.Stats() }} + cfg := NewDefaultServerConfig() + cfg.Store = store + s = newCallbackTestServer(t, cfg) + processCallbackTestPacket(t, s, krpc.Msg{ + T: "1", + Y: "q", + Q: "get", + A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, + }) + if store.gets != 1 { + t.Errorf("store Get calls = %d, want 1", store.gets) + } + s.Close() +} + +func TestStorePutCanReenterStats(t *testing.T) { + var s *Server + store := &callbackTestStore{onPut: func(*bep44.Item) { _ = s.Stats() }} + cfg := NewDefaultServerConfig() + cfg.Store = store + s = newCallbackTestServer(t, cfg) + item, err := bep44.NewItem("callback store item", nil, 1, 1, nil) + if err != nil { + t.Fatal(err) + } + source := NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1}) + processCallbackTestPacket(t, s, krpc.Msg{ + T: "1", + Y: "q", + Q: "put", + A: &krpc.MsgArgs{ + ID: krpc.ID{19: 1}, + Token: s.createToken(source), + V: item.V, + }, + }) + if store.puts != 1 { + t.Errorf("store Put calls = %d, want 1", store.puts) + } + s.Close() +} + +type callbackTestRanger struct { + lookup func(net.IP) + blocked bool + calls int +} + +func (r *callbackTestRanger) Lookup(ip net.IP) (iplist.Range, bool) { + r.calls++ + if r.lookup != nil { + r.lookup(ip) + } + return iplist.Range{}, r.blocked +} + +func (*callbackTestRanger) NumRanges() int { return 1 } + +func TestBlocklistLookupOnWriteCanReenterStats(t *testing.T) { + ranger := &callbackTestRanger{blocked: true} + cfg := NewDefaultServerConfig() + cfg.IPBlocklist = ranger + var s *Server + ranger.lookup = func(net.IP) { _ = s.Stats() } + s = newCallbackTestServer(t, cfg) + done := make(chan error, 1) + go func() { + _, err := s.writeToNode(context.Background(), nil, NewAddr(&net.UDPAddr{ + IP: net.IPv4(127, 0, 0, 1), Port: 1, + }), false, false) + done <- err + }() + select { + case err := <-done: + if err == nil { + t.Error("writeToNode succeeded for an address blocked by the Ranger") + } + case <-time.After(2 * time.Second): + t.Fatal("blocklist Lookup deadlocked when it reentered Server.Stats during write") + } + if ranger.calls != 1 { + t.Errorf("Ranger Lookup calls = %d, want 1", ranger.calls) + } + s.Close() +} + +func TestBlocklistLookupOnReadCanReenterStats(t *testing.T) { + ranger := &callbackTestRanger{} + cfg := NewDefaultServerConfig() + cfg.IPBlocklist = ranger + var s *Server + serverReady := make(chan struct{}) + ranger.lookup = func(net.IP) { + <-serverReady + _ = s.Stats() + } + queryReceived := make(chan struct{}) + cfg.OnQuery = func(*krpc.Msg, net.Addr) bool { + close(queryReceived) + return false + } + s = newCallbackTestServer(t, cfg) + close(serverReady) + sender, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + defer sender.Close() + packet := bencode.MustMarshal(krpc.Msg{ + T: "1", + Y: "q", + Q: "ping", + A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, + }) + if _, err := sender.WriteTo(packet, s.Addr()); err != nil { + t.Fatal(err) + } + select { + case <-queryReceived: + case <-time.After(2 * time.Second): + t.Fatal("receive path deadlocked when blocklist Lookup reentered Server.Stats") + } + s.Close() +} + +func TestTableMaintainerLoggerCanReenterStats(t *testing.T) { + var s *Server + logHandled := make(chan struct{}, 1) + cfg := NewDefaultServerConfig() + cfg.Logger = log.NewLogger() + cfg.Logger.SetHandlers(callbackTestLogHandler{onLog: func() { + _ = s.Stats() + select { + case logHandled <- struct{}{}: + default: + } + }}) + s = newCallbackTestServer(t, cfg) + s.mu.Lock() + s.lastBootstrap = time.Now() + s.mu.Unlock() + + done := make(chan struct{}) + go func() { + s.TableMaintainer() + close(done) + }() + select { + case <-logHandled: + case <-time.After(2 * time.Second): + t.Fatal("TableMaintainer logger deadlocked when its handler reentered Server.Stats") + } + s.Close() + select { + case <-done: + case <-time.After(2 * time.Second): + t.Fatal("TableMaintainer did not stop after Server.Close") + } +} + +func TestRefreshBucketNodeFilterCanReenterStats(t *testing.T) { + var s *Server + lookupStarted := make(chan struct{}, 1) + ranger := &callbackTestRanger{lookup: func(net.IP) { + select { + case lookupStarted <- struct{}{}: + default: + } + _ = s.Stats() + }} + cfg := NewDefaultServerConfig() + cfg.IPBlocklist = ranger + cfg.QueryResendDelay = func() time.Duration { return time.Millisecond } + s = newCallbackTestServer(t, cfg) + if err := s.AddNode(krpc.NodeInfo{ + Addr: krpc.NodeAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1}, + ID: krpc.ID{19: 1}, + }); err != nil { + t.Fatal(err) + } + + done := make(chan struct{}) + go func() { + s.refreshBucket(0) + close(done) + }() + select { + case <-lookupStarted: + case <-time.After(2 * time.Second): + t.Fatal("refreshBucket did not run its node filter") + } + select { + case <-done: + case <-time.After(2 * time.Second): + t.Fatal("refreshBucket's node filter deadlocked when Ranger.Lookup reentered Server.Stats") + } + s.Close() +} + +type callbackTestMarshaler struct { + server *Server +} + +func (m callbackTestMarshaler) MarshalBencode() ([]byte, error) { + _ = m.server.Stats() + return []byte("i1e"), nil +} + +func TestStoreValueMarshalerCanReenterStats(t *testing.T) { + store := new(callbackTestStore) + cfg := NewDefaultServerConfig() + cfg.Store = store + s := newCallbackTestServer(t, cfg) + item, err := bep44.NewItem(callbackTestMarshaler{server: s}, nil, 1, 1, nil) + if err != nil { + t.Fatal(err) + } + if err := s.store.Put(item); err != nil { + t.Fatal(err) + } + processCallbackTestPacket(t, s, krpc.Msg{ + T: "1", + Y: "q", + Q: "get", + A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, + }) + s.Close() +} diff --git a/cmd/dht-server/close_test.go b/cmd/dht-server/close_test.go index 1eb6b9570..6b4112ba0 100644 --- a/cmd/dht-server/close_test.go +++ b/cmd/dht-server/close_test.go @@ -1,15 +1,32 @@ package main import ( + "context" + "errors" + "fmt" "net" + "net/http" + "os" + "path/filepath" + "sync" + "sync/atomic" "testing" "time" + + "github.com/anacrolix/dht/v2" ) +var bootstrapTestSequence atomic.Uint64 + // A missing table file used to return after NewServer without Close. The deferred socket close // then made serveUntilClosed panic: read on a closed connection while the server was still open. func TestTableLoadErrorDoesNotPanic(t *testing.T) { - flags.TableFile = "no-such-dht-table-file" + oldFlags, oldServer := flags, s + t.Cleanup(func() { + flags = oldFlags + s = oldServer + }) + flags.TableFile = filepath.Join(t.TempDir(), "missing-table") conn, err := net.ListenPacket("udp", "127.0.0.1:0") if err != nil { t.Fatal(err) @@ -21,3 +38,102 @@ func TestTableLoadErrorDoesNotPanic(t *testing.T) { } time.Sleep(300 * time.Millisecond) } + +func TestBootstrapJoinedBeforeSavingTable(t *testing.T) { + oldFlags := flags + oldServer := s + oldArgs := os.Args + oldMux := http.DefaultServeMux + oldResolver := net.DefaultResolver + oldBootstrapHosts := dht.DefaultGlobalBootstrapHostPorts + defer func() { + flags = oldFlags + s = oldServer + os.Args = oldArgs + http.DefaultServeMux = oldMux + net.DefaultResolver = oldResolver + dht.DefaultGlobalBootstrapHostPorts = oldBootstrapHosts + }() + + tableFile := filepath.Join(t.TempDir(), "nodes") + if err := dht.WriteNodesToFile(nil, tableFile); err != nil { + t.Fatal(err) + } + flags.Addr = "127.0.0.1:0" + flags.TableFile = tableFile + flags.NoBootstrap = false + s = nil + os.Args = []string{"dht-server"} + http.DefaultServeMux = http.NewServeMux() + // The DHT resolver caches failures across repeated tests in this process. + dht.DefaultGlobalBootstrapHostPorts = []string{ + fmt.Sprintf("blocked-bootstrap-%d.invalid:6881", bootstrapTestSequence.Add(1)), + } + + dnsStarted := make(chan struct{}) + releaseDNS := make(chan struct{}) + var started sync.Once + net.DefaultResolver = &net.Resolver{ + PreferGo: true, + Dial: func(context.Context, string, string) (net.Conn, error) { + started.Do(func() { close(dnsStarted) }) + <-releaseDNS + return nil, errors.New("injected DNS failure") + }, + } + + done := make(chan error, 1) + finished, released, signalSent := false, false, false + proc, err := os.FindProcess(os.Getpid()) + if err != nil { + t.Fatal(err) + } + defer func() { + if !released { + close(releaseDNS) + } + if !finished { + if !signalSent { + _ = proc.Signal(os.Interrupt) + } + select { + case <-done: + case <-time.After(time.Second): + t.Error("server did not stop during test cleanup") + } + } + }() + go func() { done <- mainErr() }() + select { + case <-dnsStarted: + case <-time.After(time.Second): + t.Fatal("bootstrap did not reach the controlled DNS lookup") + } + if err := os.Remove(tableFile); err != nil { + t.Fatal(err) + } + if err := proc.Signal(os.Interrupt); err != nil { + t.Fatal(err) + } + signalSent = true + select { + case err := <-done: + finished = true + t.Fatalf("server returned before bootstrap completed: %v", err) + case <-time.After(50 * time.Millisecond): + } + if _, err := os.Stat(tableFile); !os.IsNotExist(err) { + t.Errorf("table file was saved while bootstrap was still running: stat error %v", err) + } + close(releaseDNS) + released = true + select { + case err := <-done: + finished = true + if err != nil { + t.Fatalf("mainErr(): %v", err) + } + case <-time.After(time.Second): + t.Fatal("server did not return after bootstrap was released") + } +} diff --git a/cmd/dht-server/main.go b/cmd/dht-server/main.go index e37cb02d0..7602d9081 100644 --- a/cmd/dht-server/main.go +++ b/cmd/dht-server/main.go @@ -2,6 +2,7 @@ package main import ( "context" + "errors" stdLog "log" "net" "net/http" @@ -85,10 +86,17 @@ func mainErr() error { ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt) defer stop() + var bootstrapDone <-chan struct{} if !flags.NoBootstrap { + done := make(chan struct{}) + bootstrapDone = done go func() { - if tried, err := s.Bootstrap(); err != nil { - log.Printf("error bootstrapping: %s", err) + defer close(done) + tried, err := s.BootstrapContext(ctx) + if err != nil { + if !errors.Is(err, context.Canceled) { + log.Printf("error bootstrapping: %s", err) + } } else { log.Printf("finished bootstrapping: %#v", tried) } @@ -96,6 +104,9 @@ func mainErr() error { } <-ctx.Done() s.Close() + if bootstrapDone != nil { + <-bootstrapDone + } if flags.TableFile != "" { if err := saveTable(); err != nil { diff --git a/cmd/dht/get.go b/cmd/dht/get.go index 475472d10..880cab55b 100644 --- a/cmd/dht/get.go +++ b/cmd/dht/get.go @@ -21,7 +21,7 @@ type GetCmd struct { ExtractInfohash bool `help:"extract and print the mutable torrent infohash in hex"` } -func get(cmd *GetCmd) (err error) { +func get(ctx context.Context, cmd *GetCmd) (err error) { s, err := dht.NewServer(nil) if err != nil { return @@ -32,9 +32,12 @@ func get(cmd *GetCmd) (err error) { } for _, t := range cmd.Target { log.Printf("getting %v", t) - v, _, err := getput.Get(context.Background(), t, s, cmd.Seq, []byte(cmd.Salt)) + v, _, err := getput.Get(ctx, t, s, cmd.Seq, []byte(cmd.Salt)) if err != nil { log.Printf("error getting %v: %v", t, err) + if ctx.Err() != nil { + return ctx.Err() + } continue } log.Printf("got result [seq=%v, mutable=%v]", v.Seq, v.Mutable) diff --git a/cmd/dht/main.go b/cmd/dht/main.go index fab583b7a..701670b94 100644 --- a/cmd/dht/main.go +++ b/cmd/dht/main.go @@ -31,6 +31,12 @@ type serverParams struct { } func main() { + if code := runMain(); code != 0 { + os.Exit(code) + } +} + +func runMain() int { logger := log.Default.WithNames("main") ctx := log.ContextWithLogger(context.Background(), logger) ctx, stopSignalNotify := signal.NotifyContext(ctx, os.Interrupt) @@ -40,194 +46,211 @@ func main() { Network: "udp", Secure: false, } - args.Main{ - Params: append( - args.FromStruct(&serverArgs), - args.Subcommand("derive-put-target", func(sub args.SubCmdCtx) (err error) { - var put bep44.Put - if !sub.Parse( - args.Subcommand("mutable", func(sub args.SubCmdCtx) (err error) { - var subArgs struct { - Private bool - // We want "required" but it's not supported I think. - Key targets.Hex `arity:"+"` - Salt string - } - sub.Parse(args.FromStruct(&subArgs)...) - put.Salt = []byte(subArgs.Salt) - put.K = (*[32]byte)(subArgs.Key.Bytes) - if subArgs.Private { - privKey := ed25519.NewKeyFromSeed(subArgs.Key.Bytes) - pubKey := privKey.Public().(ed25519.PublicKey) - log.Printf("public key: %x", pubKey) - put.K = (*[32]byte)(pubKey) - } - return nil - }), - args.Subcommand("immutable", func(sub args.SubCmdCtx) (err error) { - var subArgs struct { - String bool - Value string `arg:"positional"` - } - sub.Parse(args.FromStruct(&subArgs)...) - if subArgs.String { - put.V = subArgs.Value - } else { - err = bencode.Unmarshal([]byte(subArgs.Value), &put.V) - if err != nil { - err = fmt.Errorf("parsing value bencode: %w", err) - } - } - return - }), - ).RanSubCmd { - return errors.New("expected subcommand") - } - fmt.Printf("%x\n", put.Target()) - return nil - }), - args.Subcommand("put", func(ctx args.SubCmdCtx) (err error) { - var putOpt PutCmd - ctx.Parse(args.FromStruct(&putOpt)...) - switch len(putOpt.Key.Bytes) { - case 0, 32: - default: - return fmt.Errorf("key has bad length %v", len(putOpt.Key.Bytes)) - } - ctx.Defer(func() error { return put(&putOpt) }) - return nil - }), - args.Subcommand("put-mutable-infohash", func(ctx args.SubCmdCtx) (err error) { - var putOpt PutMutableInfohash - var ih infohash.T - ctx.Parse(append( - args.FromStruct(&putOpt), - args.Opt(args.OptOpt{ - Long: "info hash", - Target: &ih, - Required: true, - }))...) - ctx.Defer(func() error { return putMutableInfohash(&putOpt, ih) }) - return nil - }), - args.Subcommand("get", func(ctx args.SubCmdCtx) error { - var getOpt GetCmd - ctx.Parse(args.FromStruct(&getOpt)...) - ctx.Defer(func() error { return get(&getOpt) }) - return nil - }), - args.Subcommand("ping", func(ctx args.SubCmdCtx) (err error) { - var pa pingArgs - pa.Network = serverArgs.Network - ctx.Parse(args.FromStruct(&pa)...) - ctx.Defer(func() error { - return ping(pa, s) - }) - return nil - }), - args.Subcommand("get-peers", func(sub args.SubCmdCtx) (err error) { - var subArgs = struct { - AnnouncePort int - Scrape bool - InfoHash infohash.T `arity:"+"` - }{} - sub.Parse(args.FromStruct(&subArgs)...) - var announceOpts []dht.AnnounceOpt - if subArgs.AnnouncePort != 0 { - announceOpts = append(announceOpts, dht.AnnouncePeer(dht.AnnouncePeerOpts{ - Port: subArgs.AnnouncePort, - })) - } - if subArgs.Scrape { - announceOpts = append(announceOpts, dht.Scrape()) - } - sub.Defer(func() error { - return GetPeers(ctx, s, subArgs.InfoHash, announceOpts...) - }) - return nil - }), - args.Subcommand("query", func(sub args.SubCmdCtx) (err error) { - var subArgs = struct { - Addr string `arg:"positional"` - Q string `arg:"positional"` - Target krpc.ID - }{} - sub.Parse(args.FromStruct(&subArgs)...) - sub.Defer(func() error { - addr, err := net.ResolveUDPAddr(serverArgs.Network, subArgs.Addr) - if err != nil { - return err + params := append( + args.FromStruct(&serverArgs), + args.Subcommand("derive-put-target", func(sub args.SubCmdCtx) (err error) { + var put bep44.Put + if !sub.Parse( + args.Subcommand("mutable", func(sub args.SubCmdCtx) (err error) { + var subArgs struct { + Private bool + // We want "required" but it's not supported I think. + Key targets.Hex `arity:"+"` + Salt string + } + sub.Parse(args.FromStruct(&subArgs)...) + put.Salt = []byte(subArgs.Salt) + put.K = (*[32]byte)(subArgs.Key.Bytes) + if subArgs.Private { + privKey := ed25519.NewKeyFromSeed(subArgs.Key.Bytes) + pubKey := privKey.Public().(ed25519.PublicKey) + log.Printf("public key: %x", pubKey) + put.K = (*[32]byte)(pubKey) } - input := dht.QueryInput{} - input.MsgArgs.Target = subArgs.Target - res := s.Query(ctx, dht.NewAddr(addr), subArgs.Q, input) - spew.Dump(res) return nil - }) - return nil - }), - args.Subcommand("ping-nodes", func(sub args.SubCmdCtx) (err error) { - var subArgs = struct { - Timeout time.Duration - Addr string `arg:"positional"` - Q string `arg:"positional"` - Target krpc.ID - }{} - sub.Parse(args.FromStruct(&subArgs)...) - sub.Defer(func() error { - addr, err := net.ResolveUDPAddr(serverArgs.Network, subArgs.Addr) - if err != nil { - return err + }), + args.Subcommand("immutable", func(sub args.SubCmdCtx) (err error) { + var subArgs struct { + String bool + Value string `arg:"positional"` } - input := dht.QueryInput{} - input.MsgArgs.Target = subArgs.Target - res := s.Query(ctx, dht.NewAddr(addr), subArgs.Q, input) - err = res.ToError() - if err != nil { - return err + sub.Parse(args.FromStruct(&subArgs)...) + if subArgs.String { + put.V = subArgs.Value + } else { + err = bencode.Unmarshal([]byte(subArgs.Value), &put.V) + if err != nil { + err = fmt.Errorf("parsing value bencode: %w", err) + } } - return ping(pingArgs{ - Network: serverArgs.Network, - Nodes: func() (ret []string) { - res.Reply.R.ForAllNodes(func(info krpc.NodeInfo) { - ret = append(ret, info.Addr.String()) - }) - return - }(), - Timeout: subArgs.Timeout, - }, s) - }) - return nil - }), - ), - AfterParse: func() (err error) { - cfg := dht.NewDefaultServerConfig() - if serverArgs.QueryResendDelay != 0 { - cfg.QueryResendDelay = func() time.Duration { return serverArgs.QueryResendDelay } + return + }), + ).RanSubCmd { + return errors.New("expected subcommand") } - conn, err := net.ListenPacket(serverArgs.Network, ":0") - if err != nil { - err = fmt.Errorf("listening: %w", err) - return + fmt.Printf("%x\n", put.Target()) + return nil + }), + args.Subcommand("put", func(sub args.SubCmdCtx) (err error) { + var putOpt PutCmd + sub.Parse(args.FromStruct(&putOpt)...) + switch len(putOpt.Key.Bytes) { + case 0, 32: + default: + return fmt.Errorf("key has bad length %v", len(putOpt.Key.Bytes)) } - cfg.Conn = conn - all, err := publicip.Get(ctx, serverArgs.Network) - if err == nil { - cfg.PublicIP = all[0] - log.Printf("public ip: %q", cfg.PublicIP) - cfg.NoSecurity = !serverArgs.Secure + sub.Defer(func() error { return put(ctx, &putOpt) }) + return nil + }), + args.Subcommand("put-mutable-infohash", func(sub args.SubCmdCtx) (err error) { + var putOpt PutMutableInfohash + var ih infohash.T + sub.Parse(append( + args.FromStruct(&putOpt), + args.Opt(args.OptOpt{ + Long: "info hash", + Target: &ih, + Required: true, + }))...) + sub.Defer(func() error { return putMutableInfohash(ctx, &putOpt, ih) }) + return nil + }), + args.Subcommand("get", func(sub args.SubCmdCtx) error { + var getOpt GetCmd + sub.Parse(args.FromStruct(&getOpt)...) + sub.Defer(func() error { return get(ctx, &getOpt) }) + return nil + }), + args.Subcommand("ping", func(sub args.SubCmdCtx) (err error) { + var pa pingArgs + pa.Network = serverArgs.Network + sub.Parse(args.FromStruct(&pa)...) + sub.Defer(func() error { + return ping(ctx, pa, s) + }) + return nil + }), + args.Subcommand("get-peers", func(sub args.SubCmdCtx) (err error) { + var subArgs = struct { + AnnouncePort int + Scrape bool + InfoHash infohash.T `arity:"+"` + }{} + sub.Parse(args.FromStruct(&subArgs)...) + var announceOpts []dht.AnnounceOpt + if subArgs.AnnouncePort != 0 { + announceOpts = append(announceOpts, dht.AnnouncePeer(dht.AnnouncePeerOpts{ + Port: subArgs.AnnouncePort, + })) } - if len(serverArgs.BootstrapAddr) != 0 { - cfg.StartingNodes = func() ([]dht.Addr, error) { - return dht.ResolveHostPorts(serverArgs.BootstrapAddr) - } + if subArgs.Scrape { + announceOpts = append(announceOpts, dht.Scrape()) } - s, err = dht.NewServer(cfg) - if err != nil { - return err - } - log.Printf("dht server on %s with id %x", s.Addr(), s.ID()) - return - }, - }.Do() + sub.Defer(func() error { + return GetPeers(ctx, s, subArgs.InfoHash, announceOpts...) + }) + return nil + }), + args.Subcommand("query", func(sub args.SubCmdCtx) (err error) { + var subArgs = struct { + Addr string `arg:"positional"` + Q string `arg:"positional"` + Target krpc.ID + }{} + sub.Parse(args.FromStruct(&subArgs)...) + sub.Defer(func() error { + addr, err := net.ResolveUDPAddr(serverArgs.Network, subArgs.Addr) + if err != nil { + return err + } + input := dht.QueryInput{} + input.MsgArgs.Target = subArgs.Target + res := s.Query(ctx, dht.NewAddr(addr), subArgs.Q, input) + spew.Dump(res) + return nil + }) + return nil + }), + args.Subcommand("ping-nodes", func(sub args.SubCmdCtx) (err error) { + var subArgs = struct { + Timeout time.Duration + Addr string `arg:"positional"` + Q string `arg:"positional"` + Target krpc.ID + }{} + sub.Parse(args.FromStruct(&subArgs)...) + sub.Defer(func() error { + addr, err := net.ResolveUDPAddr(serverArgs.Network, subArgs.Addr) + if err != nil { + return err + } + input := dht.QueryInput{} + input.MsgArgs.Target = subArgs.Target + res := s.Query(ctx, dht.NewAddr(addr), subArgs.Q, input) + err = res.ToError() + if err != nil { + return err + } + return ping(ctx, pingArgs{ + Network: serverArgs.Network, + Nodes: func() (ret []string) { + res.Reply.R.ForAllNodes(func(info krpc.NodeInfo) { + ret = append(ret, info.Addr.String()) + }) + return + }(), + Timeout: subArgs.Timeout, + }, s) + }) + return nil + }), + ) + parsed := args.Parse(os.Args[1:], params...) + if errors.Is(parsed.Err, args.ErrHelped) { + return 0 + } + if parsed.Err != nil { + log.Printf("error parsing args in main: %v", parsed.Err) + return 2 + } + if !parsed.RanSubCmd { + parsed.Parser.PrintChoices(os.Stderr) + return 2 + } + + cfg := dht.NewDefaultServerConfig() + if serverArgs.QueryResendDelay != 0 { + cfg.QueryResendDelay = func() time.Duration { return serverArgs.QueryResendDelay } + } + conn, err := net.ListenPacket(serverArgs.Network, ":0") + if err != nil { + log.Printf("listening: %v", err) + return 1 + } + cfg.Conn = conn + all, err := publicip.Get(ctx, serverArgs.Network) + if err == nil { + cfg.PublicIP = all[0] + log.Printf("public ip: %q", cfg.PublicIP) + cfg.NoSecurity = !serverArgs.Secure + } + if len(serverArgs.BootstrapAddr) != 0 { + cfg.StartingNodes = func() ([]dht.Addr, error) { + return dht.ResolveHostPorts(serverArgs.BootstrapAddr) + } + } + s, err = dht.NewServer(cfg) + if err != nil { + conn.Close() + log.Printf("creating server: %v", err) + return 1 + } + defer s.Close() + log.Printf("dht server on %s with id %x", s.Addr(), s.ID()) + + if err := parsed.Run(); err != nil { + log.Printf("error running main parse result: %v", err) + return 2 + } + return 0 } diff --git a/cmd/dht/ping.go b/cmd/dht/ping.go index 2e6e54b0b..ed7e0b578 100644 --- a/cmd/dht/ping.go +++ b/cmd/dht/ping.go @@ -2,6 +2,7 @@ package main import ( + "context" "errors" "fmt" "net" @@ -18,20 +19,35 @@ type pingArgs struct { Nodes []string `arg:"positional" arity:"*" help:"nodes to ping e.g. router.bittorrent.com:6881"` } -func ping(args pingArgs, s *dht.Server) error { +func ping(ctx context.Context, args pingArgs, s *dht.Server) error { + ctx, cancel := context.WithCancel(ctx) + defer cancel() nodes := args.Nodes if args.Defaults { nodes = append(nodes, dht.DefaultGlobalBootstrapHostPorts...) } var wg sync.WaitGroup for _, a := range nodes { + if err := ctx.Err(); err != nil { + cancel() + wg.Wait() + return err + } ua, err := net.ResolveUDPAddr(args.Network, a) if err != nil { + cancel() + wg.Wait() + return err + } + if err := ctx.Err(); err != nil { + cancel() + wg.Wait() return err } started := time.Now() wg.Go(func() { - res := s.Ping(ua) + addr := dht.NewAddr(ua) + res := s.Query(ctx, addr, "ping", dht.QueryInput{}) if res.Err != nil { fmt.Printf("%s: %s: %s\n", a, time.Since(started), res.Err) return @@ -41,6 +57,7 @@ func ping(args pingArgs, s *dht.Server) error { fmt.Printf("%s: response has no id: %s\n", a, time.Since(started)) return } + s.NodeRespondedToPing(addr, id.Int160()) secure := '✘' if dht.NodeIdSecure(*id, ua.IP) { secure = '✔' @@ -55,12 +72,23 @@ func ping(args pingArgs, s *dht.Server) error { }() var timeout <-chan time.Time if args.Timeout != 0 { - timeout = time.After(args.Timeout) + timer := time.NewTimer(args.Timeout) + defer timer.Stop() + timeout = timer.C } select { case <-done: + if err := ctx.Err(); err != nil { + return err + } return nil + case <-ctx.Done(): + cancel() + <-done + return ctx.Err() case <-timeout: + cancel() + <-done return errors.New("timed out") } } diff --git a/cmd/dht/ping_test.go b/cmd/dht/ping_test.go index f381f6c42..6d7454ecf 100644 --- a/cmd/dht/ping_test.go +++ b/cmd/dht/ping_test.go @@ -1,7 +1,10 @@ package main import ( + "context" + "errors" "net" + "sync" "testing" "time" @@ -49,7 +52,7 @@ func TestPingResponseWithoutID(t *testing.T) { t.Fatal(err) } t.Cleanup(s.Close) - err = ping(pingArgs{ + err = ping(context.Background(), pingArgs{ Network: "udp", Nodes: []string{pc.LocalAddr().String()}, }, s) @@ -57,3 +60,176 @@ func TestPingResponseWithoutID(t *testing.T) { t.Fatal(err) } } + +func newPingLifecycleTestServer(t *testing.T) *dht.Server { + t.Helper() + conn, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + s, err := dht.NewServer(&dht.ServerConfig{ + Conn: conn, + NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + }) + if err != nil { + conn.Close() + t.Fatal(err) + } + t.Cleanup(func() { + s.Close() + deadline := time.Now().Add(time.Second) + for s.Stats().OutstandingTransactions != 0 && time.Now().Before(deadline) { + time.Sleep(time.Millisecond) + } + }) + return s +} + +func newPingBlackhole(t *testing.T) (net.PacketConn, <-chan struct{}) { + t.Helper() + pc, err := net.ListenPacket("udp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { pc.Close() }) + gotQuery := make(chan struct{}, 1) + go func() { + b := make([]byte, 1500) + for { + if _, _, err := pc.ReadFrom(b); err != nil { + return + } + select { + case gotQuery <- struct{}{}: + default: + } + } + }() + return pc, gotQuery +} + +func waitForPingQuery(t *testing.T, gotQuery <-chan struct{}) { + t.Helper() + select { + case <-gotQuery: + case <-time.After(time.Second): + t.Fatal("ping query was not sent") + } +} + +func TestPingTimeoutCancelsAndJoinsWorkers(t *testing.T) { + pc, gotQuery := newPingBlackhole(t) + s := newPingLifecycleTestServer(t) + done := make(chan error, 1) + go func() { + done <- ping(context.Background(), pingArgs{ + Network: "udp", + Timeout: 25 * time.Millisecond, + Nodes: []string{pc.LocalAddr().String()}, + }, s) + }() + waitForPingQuery(t, gotQuery) + select { + case err := <-done: + if err == nil { + t.Fatal("ping returned nil error after timeout") + } + case <-time.After(time.Second): + t.Fatal("ping did not return after its timeout") + } + if got := s.Stats().OutstandingTransactions; got != 0 { + t.Errorf("outstanding transactions after ping returned = %d, want 0", got) + } +} + +func TestPingResolveErrorCancelsAndJoinsWorkers(t *testing.T) { + pc, gotQuery := newPingBlackhole(t) + s := newPingLifecycleTestServer(t) + + oldResolver := net.DefaultResolver + t.Cleanup(func() { net.DefaultResolver = oldResolver }) + resolverStarted := make(chan struct{}) + releaseResolver := make(chan struct{}) + var resolverStart sync.Once + net.DefaultResolver = &net.Resolver{ + PreferGo: true, + Dial: func(context.Context, string, string) (net.Conn, error) { + resolverStart.Do(func() { close(resolverStarted) }) + <-releaseResolver + return nil, errors.New("injected DNS failure") + }, + } + + done := make(chan error, 1) + released, finished := false, false + t.Cleanup(func() { + if !released { + close(releaseResolver) + } + if !finished { + select { + case <-done: + case <-time.After(time.Second): + t.Error("ping did not stop during test cleanup") + } + } + }) + go func() { + done <- ping(context.Background(), pingArgs{ + Network: "udp", + Nodes: []string{ + pc.LocalAddr().String(), + "resolve-failure.invalid:6881", + }, + }, s) + }() + select { + case <-resolverStarted: + case <-time.After(time.Second): + t.Fatal("ping did not reach the controlled DNS lookup") + } + waitForPingQuery(t, gotQuery) + close(releaseResolver) + released = true + select { + case err := <-done: + finished = true + if err == nil { + t.Fatal("ping returned nil error after address resolution failed") + } + case <-time.After(time.Second): + t.Fatal("ping did not return after address resolution failed") + } + if got := s.Stats().OutstandingTransactions; got != 0 { + t.Errorf("outstanding transactions after ping returned = %d, want 0", got) + } +} + +func TestPingContextCancellationCancelsAndJoinsWorkers(t *testing.T) { + pc, gotQuery := newPingBlackhole(t) + s := newPingLifecycleTestServer(t) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + done := make(chan error, 1) + go func() { + done <- ping(ctx, pingArgs{ + Network: "udp", + Timeout: time.Hour, + Nodes: []string{pc.LocalAddr().String()}, + }, s) + }() + waitForPingQuery(t, gotQuery) + cancel() + select { + case err := <-done: + if !errors.Is(err, context.Canceled) { + t.Fatalf("ping error after context cancellation = %v, want context.Canceled", err) + } + case <-time.After(time.Second): + t.Fatal("ping did not return after context cancellation") + } + if got := s.Stats().OutstandingTransactions; got != 0 { + t.Errorf("outstanding transactions after ping returned = %d, want 0", got) + } +} diff --git a/cmd/dht/put-bep46.go b/cmd/dht/put-bep46.go index 2e429bb80..6541869a4 100644 --- a/cmd/dht/put-bep46.go +++ b/cmd/dht/put-bep46.go @@ -27,7 +27,7 @@ type PutMutableInfohash struct { AutoSeq bool } -func putMutableInfohash(cmd *PutMutableInfohash, ih infohash.T) (err error) { +func putMutableInfohash(ctx context.Context, cmd *PutMutableInfohash, ih infohash.T) (err error) { s, err := dht.NewServer(nil) if err != nil { return @@ -50,7 +50,7 @@ func putMutableInfohash(cmd *PutMutableInfohash, ih infohash.T) (err error) { log.Printf("putting %q to %x", put.V, target) var stats *traversal.Stats stats, err = getput.Put( - context.Background(), + ctx, target, s, put.Salt, diff --git a/cmd/dht/put.go b/cmd/dht/put.go index 7a33997a5..d379ffeb3 100644 --- a/cmd/dht/put.go +++ b/cmd/dht/put.go @@ -41,7 +41,7 @@ func makeSeqToPut(autoSeq, mutable bool, put bep44.Put, privKey ed25519.PrivateK } } -func put(cmd *PutCmd) (err error) { +func put(ctx context.Context, cmd *PutCmd) (err error) { s, err := dht.NewServer(nil) if err != nil { return @@ -73,7 +73,7 @@ func put(cmd *PutCmd) (err error) { log.Printf("putting %q to %x", v, target) var stats *traversal.Stats stats, err = getput.Put( - context.Background(), + ctx, target, s, put.Salt, diff --git a/dht_test.go b/dht_test.go index 819cd22e6..37d875318 100644 --- a/dht_test.go +++ b/dht_test.go @@ -246,25 +246,46 @@ func TestBadGetPeersResponse(t *testing.T) { }) qt.Assert(t, qt.IsNil(err)) defer s.Close() + replied := make(chan error, 1) go func() { - b := make([]byte, 1024) - n, addr, err := pc.ReadFrom(b) - qt.Assert(t, qt.IsNil(err)) - var rm krpc.Msg - qt.Assert(t, qt.IsNil(bencode.Unmarshal(b[:n], &rm))) - m := krpc.Msg{ - R: &krpc.Return{}, - T: rm.T, - } - b, err = bencode.Marshal(m) - qt.Assert(t, qt.IsNil(err)) - _, err = pc.WriteTo(b, addr) - qt.Assert(t, qt.IsNil(err)) + replied <- func() error { + b := make([]byte, 1024) + n, addr, err := pc.ReadFrom(b) + if err != nil { + return err + } + var rm krpc.Msg + if err := bencode.Unmarshal(b[:n], &rm); err != nil { + return err + } + // Intentionally omit Y: PR #19 covers a reply whose SenderID is nil. + b, err = bencode.Marshal(krpc.Msg{R: &krpc.Return{}, T: rm.T}) + if err != nil { + return err + } + _, err = pc.WriteTo(b, addr) + return err + }() }() a, err := s.Announce([20]byte{}, 0, true) qt.Assert(t, qt.IsNil(err)) - // Drain the Announce until it closes. - for range a.Peers { + t.Cleanup(a.Close) + select { + case err := <-replied: + qt.Assert(t, qt.IsNil(err)) + case <-time.After(2 * time.Second): + t.Fatal("responder did not complete") + } + select { + case _, ok := <-a.Peers: + qt.Assert(t, qt.IsTrue(ok)) + case <-time.After(2 * time.Second): + t.Fatal("malformed reply did not produce a peer result") + } + select { + case <-a.Finished(): + case <-time.After(2 * time.Second): + t.Fatal("announce did not finish after malformed reply") } } diff --git a/exts/getput/getput_test.go b/exts/getput/getput_test.go index a6f4f94fa..a3a8dc924 100644 --- a/exts/getput/getput_test.go +++ b/exts/getput/getput_test.go @@ -55,3 +55,48 @@ func TestStartingNodesErrorDoesNotLeak(t *testing.T) { qt.Assert(t, qt.IsNotNil(err)) assertTraversalGoroutines(t, before) } + +func TestCancelActiveTraversal(t *testing.T) { + for _, operation := range []string{"get", "put"} { + t.Run(operation, func(t *testing.T) { + peer, err := net.ListenPacket("udp", "127.0.0.1:0") + qt.Assert(t, qt.IsNil(err)) + t.Cleanup(func() { _ = peer.Close() }) + conn, err := net.ListenPacket("udp", "127.0.0.1:0") + qt.Assert(t, qt.IsNil(err)) + s, err := dht.NewServer(&dht.ServerConfig{ + Conn: conn, NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + StartingNodes: func() ([]dht.Addr, error) { + return []dht.Addr{dht.NewAddr(peer.LocalAddr())}, nil + }, + }) + qt.Assert(t, qt.IsNil(err)) + t.Cleanup(s.Close) + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + done := make(chan error, 1) + go func() { + if operation == "get" { + _, _, err := Get(ctx, bep44.Target{1}, s, nil, nil) + done <- err + } else { + _, err := Put(ctx, krpc.ID{1}, s, nil, func(int64) bep44.Put { return bep44.Put{} }) + done <- err + } + }() + qt.Assert(t, qt.IsNil(peer.SetReadDeadline(time.Now().Add(2*time.Second)))) + var packet [1500]byte + _, _, err = peer.ReadFrom(packet[:]) + qt.Assert(t, qt.IsNil(err)) + cancel() + select { + case err := <-done: + qt.Assert(t, qt.IsTrue(errors.Is(err, context.Canceled))) + case <-time.After(2 * time.Second): + t.Fatal("cancelled traversal did not return") + } + qt.Assert(t, qt.Equals(s.Stats().OutstandingTransactions, 0)) + }) + } +} diff --git a/server.go b/server.go index 0c1dadaee..e77066051 100644 --- a/server.go +++ b/server.go @@ -1,6 +1,7 @@ package dht import ( + "bytes" "context" "crypto/rand" "errors" @@ -83,56 +84,60 @@ func prettySince(t time.Time) string { } func (s *Server) WriteStatus(w io.Writer) { - fmt.Fprintf(w, "Listening on %s\n", s.Addr()) - s.mu.Lock() - defer s.mu.Unlock() - fmt.Fprintf(w, "Nodes in table: %d good, %d total\n", s.numGoodNodes(), s.numNodes()) - fmt.Fprintf(w, "Ongoing transactions: %d\n", s.transactions.NumActive()) - fmt.Fprintf(w, "Server node ID: %x\n", s.id.Bytes()) - buckets := &s.table.buckets - for i := range s.table.buckets { - b := &buckets[i] - if b.Len() == 0 && b.lastChanged.IsZero() { - continue - } - fmt.Fprintf(w, - "b# %v: %v nodes, last updated: %v\n", - i, b.Len(), prettySince(b.lastChanged)) - if b.Len() > 0 { - tw := tabwriter.NewWriter(w, 0, 0, 1, ' ', 0) - fmt.Fprintf(tw, " node id\taddr\tlast query\tlast response\trecv\tdiscard\tflags\n") - // Bucket nodes ordered by distance from server ID. - nodes := slices.SortedFunc(b.NodeIter(), func(l *node, r *node) int { - return l.Id.Distance(s.id).Cmp(r.Id.Distance(s.id)) - }) - for _, n := range nodes { - var flags []string - if s.IsQuestionable(n) { - flags = append(flags, "q10e") - } - if s.nodeIsBad(n) { - flags = append(flags, "bad") - } - if s.IsGood(n) { - flags = append(flags, "good") - } - if n.IsSecure() { - flags = append(flags, "sec") + var buf bytes.Buffer + fmt.Fprintf(&buf, "Listening on %s\n", s.Addr()) + func() { + s.mu.Lock() + defer s.mu.Unlock() + fmt.Fprintf(&buf, "Nodes in table: %d good, %d total\n", s.numGoodNodes(), s.numNodes()) + fmt.Fprintf(&buf, "Ongoing transactions: %d\n", s.transactions.NumActive()) + fmt.Fprintf(&buf, "Server node ID: %x\n", s.id.Bytes()) + buckets := &s.table.buckets + for i := range s.table.buckets { + b := &buckets[i] + if b.Len() == 0 && b.lastChanged.IsZero() { + continue + } + fmt.Fprintf(&buf, + "b# %v: %v nodes, last updated: %v\n", + i, b.Len(), prettySince(b.lastChanged)) + if b.Len() > 0 { + tw := tabwriter.NewWriter(&buf, 0, 0, 1, ' ', 0) + fmt.Fprintf(tw, " node id\taddr\tlast query\tlast response\trecv\tdiscard\tflags\n") + // Bucket nodes ordered by distance from server ID. + nodes := slices.SortedFunc(b.NodeIter(), func(l *node, r *node) int { + return l.Id.Distance(s.id).Cmp(r.Id.Distance(s.id)) + }) + for _, n := range nodes { + var flags []string + if s.IsQuestionable(n) { + flags = append(flags, "q10e") + } + if s.nodeIsBad(n) { + flags = append(flags, "bad") + } + if s.IsGood(n) { + flags = append(flags, "good") + } + if n.IsSecure() { + flags = append(flags, "sec") + } + fmt.Fprintf(tw, " %x\t%s\t%s\t%s\t%d\t%v\t%v\n", + n.Id.Bytes(), + n.Addr, + prettySince(n.lastGotQuery), + prettySince(n.lastGotResponse), + n.numReceivesFrom, + n.failedLastQuestionablePing, + strings.Join(flags, ","), + ) } - fmt.Fprintf(tw, " %x\t%s\t%s\t%s\t%d\t%v\t%v\n", - n.Id.Bytes(), - n.Addr, - prettySince(n.lastGotQuery), - prettySince(n.lastGotResponse), - n.numReceivesFrom, - n.failedLastQuestionablePing, - strings.Join(flags, ","), - ) + tw.Flush() } - tw.Flush() } - } - fmt.Fprintln(w) + fmt.Fprintln(&buf) + }() + _, _ = buf.WriteTo(w) } func (s *Server) numNodes() (num int) { @@ -268,8 +273,7 @@ func (s *Server) String() string { } // Packets to and from any address matching a range in the list are dropped. -// Published atomically. ipBlocked runs both under s.mu and outside it, and writeToNode calls it -// while already holding s.mu.RLock, so this list is not guarded by s.mu. +// Published atomically; Ranger methods run without s.mu held because a Ranger may execute user code. type ipBlocklist struct{ list iplist.Ranger } func (s *Server) blocklist() iplist.Ranger { @@ -316,7 +320,13 @@ func (s *Server) processPacket(b []byte, addr Addr) { } if d.Y == "q" { expvars.Add("received queries", 1) - s.logger().Printf("received query %q from %v", d.Q, addr) + logger := s.logger() + s.withServerLockReleased(func() { + logger.Printf("received query %q from %v", d.Q, addr) + }) + if s.closed.IsSet() { + return + } s.handleQuery(addr, d) return } @@ -325,7 +335,10 @@ func (s *Server) processPacket(b []byte, addr Addr) { T: d.T, } if !s.transactions.Have(tk) { - s.logger().Printf("received response for untracked transaction %q from %v", d.T, addr) + logger := s.logger() + s.withServerLockReleased(func() { + logger.Printf("received response for untracked transaction %q from %v", d.T, addr) + }) return } t := s.transactions.Pop(tk) @@ -337,6 +350,14 @@ func (s *Server) processPacket(b []byte, addr Addr) { }) } +// withServerLockReleased calls fn without s.mu held and restores the caller's lock before returning. +// Call only from a path that entered with s.mu locked. +func (s *Server) withServerLockReleased(fn func()) { + s.mu.Unlock() + defer s.mu.Lock() + fn() +} + // Reports whether a bencode decoding error is common junk not worth logging: truncated messages, // messages that drop to NUL bytes abruptly, or data that isn't bencode at all. func uninterestingUnmarshalError(err error, b []byte) bool { @@ -367,18 +388,13 @@ func (s *Server) serve() error { readZeroPort.Add(1) continue } - blocked, err := func() (bool, error) { - s.mu.RLock() - defer s.mu.RUnlock() - if s.closed.IsSet() { - return false, errors.New("server is closed") - } - return s.ipBlocked(addrIP(addr)), nil - }() - if err != nil { - return err + s.mu.RLock() + closed := s.closed.IsSet() + s.mu.RUnlock() + if closed { + return errors.New("server is closed") } - if blocked { + if s.ipBlocked(addrIP(addr)) { readBlocked.Add(1) continue } @@ -469,23 +485,33 @@ func storeError(err error) krpc.Error { } func (s *Server) handleQuery(source Addr, m krpc.Msg) { - go func() { - expvars.Add(fmt.Sprintf("received query %q", m.Q), 1) - if a := m.A; a != nil { - if a.NoSeed != 0 { - expvars.Add("received argument noseed", 1) - } - if a.Scrape != 0 { - expvars.Add("received argument scrape", 1) - } + query := m.Q + var noSeed, scrape bool + if a := m.A; a != nil { + noSeed = a.NoSeed != 0 + scrape = a.Scrape != 0 + } + go func(query string, noSeed, scrape bool) { + expvars.Add(fmt.Sprintf("received query %q", query), 1) + if noSeed { + expvars.Add("received argument noseed", 1) } - }() + if scrape { + expvars.Add("received argument scrape", 1) + } + }(query, noSeed, scrape) _ = s.updateNode(source, m.SenderID(), !m.ReadOnly, func(n *node) { n.lastGotQuery = time.Now() n.numReceivesFrom++ }) - if s.config.OnQuery != nil && !s.config.OnQuery(&m, source.Raw()) { - return + if onQuery := s.config.OnQuery; onQuery != nil { + propagate := false + s.withServerLockReleased(func() { + propagate = onQuery(&m, source.Raw()) + }) + if s.closed.IsSet() || !propagate { + return + } } if s.config.Passive { return @@ -520,7 +546,14 @@ func (s *Server) handleQuery(source Addr, m krpc.Msg) { func (s *Server) handleGetPeers(source Addr, t string, args *krpc.MsgArgs) { var r krpc.Return if ps := s.config.PeerStore; ps != nil { - r.Values = filterPeers(source.IP(), args.Want, ps.GetPeers(peer_store.InfoHash(args.InfoHash))) + var peers []krpc.NodeAddr + s.withServerLockReleased(func() { + peers = ps.GetPeers(peer_store.InfoHash(args.InfoHash)) + }) + if s.closed.IsSet() { + return + } + r.Values = filterPeers(source.IP(), args.Want, peers) token := s.createToken(source) r.Token = &token } @@ -591,7 +624,14 @@ func (s *Server) handlePut(source Addr, t string, args *krpc.MsgArgs) { } i.Seq = *args.Seq } - if err := s.store.Put(i); err != nil { + var err error + s.withServerLockReleased(func() { + err = s.store.Put(i) + }) + if s.closed.IsSet() { + return + } + if err != nil { s.sendError(source, t, storeError(err)) return } @@ -603,7 +643,14 @@ func (s *Server) handleGet(source Addr, t string, args *krpc.MsgArgs) { s.setReturnNodes(&r, args.Target, args.Want, source) token := s.createToken(source) r.Token = &token - item, err := s.store.Get(bep44.Target(args.Target)) + var item *bep44.Item + var err error + s.withServerLockReleased(func() { + item, err = s.store.Get(bep44.Target(args.Target)) + }) + if s.closed.IsSet() { + return + } if errors.Is(err, bep44.ErrItemNotFound) { s.reply(source, t, r) return @@ -614,7 +661,14 @@ func (s *Server) handleGet(source Addr, t string, args *krpc.MsgArgs) { } r.Seq = &item.Seq if args.Seq == nil || item.Seq > *args.Seq { - r.V = bencode.MustMarshal(item.V) + var encodedValue []byte + s.withServerLockReleased(func() { + encodedValue = bencode.MustMarshal(item.V) + }) + if s.closed.IsSet() { + return + } + r.V = encodedValue r.K = item.K r.Sig = item.Sig } @@ -745,22 +799,17 @@ func (s *Server) nodeErr(n *node) error { } func (s *Server) writeToNode(ctx context.Context, b []byte, node Addr, wait, rate bool) (wrote bool, err error) { - func() { - s.mu.RLock() - defer s.mu.RUnlock() - if s.closed.IsSet() { - err = errors.New("server is closed") + s.mu.RLock() + closed := s.closed.IsSet() + s.mu.RUnlock() + if closed { + return false, errors.New("server is closed") + } + if list := s.blocklist(); list != nil { + if r, ok := list.Lookup(node.IP()); ok { + err = fmt.Errorf("write to %v blocked by %v", node, r) return } - if list := s.blocklist(); list != nil { - if r, ok := list.Lookup(node.IP()); ok { - err = fmt.Errorf("write to %v blocked by %v", node, r) - return - } - } - }() - if err != nil { - return } if rate { if wait { @@ -1299,10 +1348,11 @@ wait: if s.shouldStopRefreshingBucket(bucketIndex) { break wait } - op.AddNodes(types.AddrMaybeIdSliceFromNodeInfoSlice(s.notBadNodes())) + nodes := types.AddrMaybeIdSliceFromNodeInfoSlice(s.notBadNodes()) bucketChanged := b.changed.Signaled() serverClosed := s.closed.Done() s.mu.RUnlock() + op.AddNodes(nodes) select { case <-op.Stalled(): s.mu.RLock() @@ -1364,8 +1414,8 @@ func (s *Server) TableMaintainer() { if s.shouldStopRefreshingBucket(i) { continue } - logger.Levelf(log.Debug, "refreshing bucket %v", i) s.mu.RUnlock() + logger.Levelf(log.Debug, "refreshing bucket %v", i) stats := s.refreshBucket(i) logger.Levelf(log.Debug, "finished refreshing bucket %v: %v", i, stats) s.mu.RLock() diff --git a/server_test.go b/server_test.go index 286a9a8b0..2471635a3 100644 --- a/server_test.go +++ b/server_test.go @@ -156,26 +156,40 @@ func TestSetReturnNodesUsesTarget(t *testing.T) { cfg := NewDefaultServerConfig() cfg.Conn = mustListen("localhost:0") cfg.NodeId = krpc.ID{19: 1} + cfg.NoSecurity = true s, err := NewServer(cfg) qt.Assert(t, qt.IsNil(err)) - defer s.Close() - far := s.id - far.SetBit(0, true) - near := s.id - near.SetBit(158, true) + t.Cleanup(s.Close) + target := s.id + target.SetBit(0, true) + ids := []int160.T{target} + // More than K candidates: a lookup near zero must exclude target, whereas a lookup + // for target must include it. Do not depend on bucket traversal or response order. + for bit := 150; bit < 158; bit++ { + id := s.id + id.SetBit(bit, true) + ids = append(ids, id) + } s.mu.Lock() - for i, id := range []int160.T{far, near} { + for i, id := range ids { n := &node{ - nodeKey: nodeKey{Id: id, Addr: NewAddr(&net.UDPAddr{IP: net.IPv4(1, 2, 3, byte(i)), Port: 1})}, + nodeKey: nodeKey{Id: id, Addr: NewAddr(&net.UDPAddr{ + IP: net.IPv4(1, 2, 3, byte(i)), Port: 1, + })}, lastGotResponse: time.Now(), } qt.Assert(t, qt.IsNil(s.table.addNode(n))) } var r krpc.Return - s.setReturnNodes(&r, far.AsByteArray(), []krpc.Want{krpc.WantNodes}, NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1})) + s.setReturnNodes(&r, target.AsByteArray(), []krpc.Want{krpc.WantNodes}, + NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1})) s.mu.Unlock() - qt.Assert(t, qt.HasLen(r.Nodes, 1)) - qt.Check(t, qt.Equals(r.Nodes[0].ID, far.AsByteArray())) + for _, n := range r.Nodes { + if n.ID == target.AsByteArray() { + return + } + } + t.Fatal("response omitted the exact queried target in favor of nodes near zero") } func newServer(t *testing.T, l log.Logger) *Server { diff --git a/table.go b/table.go index bf95948d3..23e22170a 100644 --- a/table.go +++ b/table.go @@ -82,27 +82,25 @@ func (tbl *table) getNode(addr Addr, id int160.T) *node { } func (tbl *table) closestNodes(k int, target int160.T, filter func(*node) bool) (ret []*node) { - bi := len(tbl.buckets) - 1 - if target != tbl.rootID { - bi = tbl.bucketIndex(target) + if k <= 0 { + return nil } - // Buckets are ordered by XOR magnitude: every node in an earlier bucket is closer than every - // node in a later one. Inside a bucket the map order is not distance order, so a partial - // bucket is sorted and only the nearest remaining slots are kept. - for ; bi >= 0 && len(ret) < k; bi-- { - var bucketNodes []*node - for n := range tbl.buckets[bi].nodes { - if filter(n) { - bucketNodes = append(bucketNodes, n) - } + // Buckets are relative to rootID, not target. Even a higher-index bucket can contain + // a closer eligible node, so rank candidates from the entire table. + tbl.forNodes(func(n *node) bool { + if filter(n) { + ret = append(ret, n) } - slices.SortFunc(bucketNodes, func(a, b *node) int { - return a.Id.Distance(target).Cmp(b.Id.Distance(target)) - }) - if need := k - len(ret); len(bucketNodes) > need { - bucketNodes = bucketNodes[:need] + return true + }) + slices.SortFunc(ret, func(a, b *node) int { + if d := a.Id.Distance(target).Cmp(b.Id.Distance(target)); d != 0 { + return d } - ret = append(ret, bucketNodes...) + return a.Addr.KRPC().ToNodeAddrPort().Compare(b.Addr.KRPC().ToNodeAddrPort()) + }) + if len(ret) > k { + ret = ret[:k] } return } diff --git a/table_test.go b/table_test.go index 4ac6f8dbf..1ea87c72c 100644 --- a/table_test.go +++ b/table_test.go @@ -125,3 +125,43 @@ func TestClosestNodesKeepsNearestInBucket(t *testing.T) { } } } + +func TestClosestNodesAcrossRootBuckets(t *testing.T) { + tbl := table{k: 8} + var target int160.T + target.SetBit(10, true) + makeNode := func(bits ...int) *node { + var id int160.T + for _, bit := range bits { + id.SetBit(bit, true) + } + n := &node{nodeKey: nodeKey{Id: id, Addr: NewAddr(&net.UDPAddr{ + IP: net.IPv4(127, 0, 0, 1), Port: bits[0] + 1, + })}} + qt.Assert(t, qt.IsNil(tbl.addNode(n))) + return n + } + near := makeNode(10, 20) + middle := makeNode(11) + far := makeNode(9) + for _, tc := range []struct { + name string + k int + excluded *node + want []*node + }{ + {"target bucket", 1, nil, []*node{near}}, + {"higher root bucket", 1, near, []*node{middle}}, + {"all buckets", 8, nil, []*node{near, middle, far}}, + {"zero limit", 0, nil, nil}, + {"negative limit", -1, nil, nil}, + } { + t.Run(tc.name, func(t *testing.T) { + got := tbl.closestNodes(tc.k, target, func(n *node) bool { return n != tc.excluded }) + qt.Assert(t, qt.Equals(len(got), len(tc.want))) + for i := range got { + qt.Assert(t, qt.Equals(got[i], tc.want[i])) + } + }) + } +} From 6bccb09c2e33b1e7d7245f6d252473318653586c Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 15:42:12 +0530 Subject: [PATCH 13/18] Isolate lifecycle tests from the shared send limiter Wait for an actual bootstrap packet before cancellation and assert transaction cleanup. Give callback and cancellation fixtures their own limiter so unrelated tests cannot terminate their traversal through rate limiting. --- announce_test.go | 1 + bugs_test.go | 3 +++ callback_test.go | 2 ++ lifecycle_test.go | 46 +++++++++++++++++++++++++++++++--------------- 4 files changed, 37 insertions(+), 15 deletions(-) diff --git a/announce_test.go b/announce_test.go index 128879be4..fcfdbd138 100644 --- a/announce_test.go +++ b/announce_test.go @@ -70,6 +70,7 @@ func TestTraversalStatsDuringQuery(t *testing.T) { s, err := NewServer(&ServerConfig{ Conn: mustListen("localhost:0"), NoSecurity: true, + SendLimiter: rate.NewLimiter(rate.Inf, 0), QueryResendDelay: func() time.Duration { return time.Hour }, StartingNodes: addrResolver(silent.LocalAddr().String()), }) diff --git a/bugs_test.go b/bugs_test.go index eb4cfb0bf..a937b3679 100644 --- a/bugs_test.go +++ b/bugs_test.go @@ -10,6 +10,7 @@ import ( "time" "github.com/anacrolix/torrent/iplist" + "golang.org/x/time/rate" "github.com/anacrolix/dht/v2/krpc" ) @@ -32,6 +33,7 @@ func TestPingReturnsAfterClose(t *testing.T) { s, err := NewServer(&ServerConfig{ Conn: mustListen("127.0.0.1:0"), NoSecurity: true, + SendLimiter: rate.NewLimiter(rate.Inf, 0), QueryResendDelay: func() time.Duration { return time.Hour }, }) if err != nil { @@ -98,6 +100,7 @@ func TestQueryCallerCancellation(t *testing.T) { t.Cleanup(func() { _ = peer.Close() }) s, err := NewServer(&ServerConfig{ Conn: mustListen("127.0.0.1:0"), NoSecurity: true, + SendLimiter: rate.NewLimiter(rate.Inf, 0), QueryResendDelay: func() time.Duration { return time.Hour }, }) if err != nil { diff --git a/callback_test.go b/callback_test.go index bfa89fc6f..000276e5f 100644 --- a/callback_test.go +++ b/callback_test.go @@ -9,6 +9,7 @@ import ( "github.com/anacrolix/log" "github.com/anacrolix/torrent/bencode" "github.com/anacrolix/torrent/iplist" + "golang.org/x/time/rate" "github.com/anacrolix/dht/v2/bep44" "github.com/anacrolix/dht/v2/krpc" @@ -51,6 +52,7 @@ func newCallbackTestServer(t *testing.T, cfg *ServerConfig) *Server { } t.Cleanup(func() { _ = conn.Close() }) cfg.Conn = conn + cfg.SendLimiter = rate.NewLimiter(rate.Inf, 0) s, err := NewServer(cfg) if err != nil { t.Fatal(err) diff --git a/lifecycle_test.go b/lifecycle_test.go index 064c7d698..72599f1fa 100644 --- a/lifecycle_test.go +++ b/lifecycle_test.go @@ -10,6 +10,7 @@ import ( "github.com/anacrolix/log" "github.com/go-quicktest/qt" + "golang.org/x/time/rate" ) // Counts goroutines with a frame in the traversal package: operation loops and their queries. @@ -69,26 +70,41 @@ func TestTraversalStartingNodesErrorDoesNotLeak(t *testing.T) { // Cancelling a bootstrap must stop its outstanding queries before returning, rather than leaving // them to run until they time out. func TestBootstrapContextCancelWaitsForTraversal(t *testing.T) { - silent := mustListen("localhost:0") - defer silent.Close() + silent := mustListen("127.0.0.1:0") + t.Cleanup(func() { _ = silent.Close() }) cfg := NewDefaultServerConfig() - cfg.Conn = mustListen("localhost:0") + cfg.Conn = mustListen("127.0.0.1:0") cfg.Logger = log.Default.WithNames(t.Name()) - cfg.QueryResendDelay = func() time.Duration { return time.Minute } + cfg.SendLimiter = rate.NewLimiter(rate.Inf, 0) + cfg.QueryResendDelay = func() time.Duration { return time.Hour } cfg.StartingNodes = addrResolver(silent.LocalAddr().String()) s, err := NewServer(cfg) qt.Assert(t, qt.IsNil(err)) - defer s.Close() - before := numTraversalGoroutines() - - ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) - defer cancel() - started := time.Now() - stats, err := s.BootstrapContext(ctx) - qt.Assert(t, qt.ErrorIs(err, context.DeadlineExceeded)) - qt.Check(t, qt.IsTrue(time.Since(started) < 10*time.Second)) - qt.Check(t, qt.Equals(stats.NumAddrsTried, uint32(1))) - assertTraversalGoroutines(t, before) + t.Cleanup(s.Close) + ctx, cancel := context.WithCancel(context.Background()) + t.Cleanup(cancel) + type result struct { + tried uint32 + err error + } + done := make(chan result, 1) + go func() { + stats, err := s.BootstrapContext(ctx) + done <- result{stats.NumAddrsTried, err} + }() + qt.Assert(t, qt.IsNil(silent.SetReadDeadline(time.Now().Add(2*time.Second)))) + var packet [1500]byte + _, _, err = silent.ReadFrom(packet[:]) + qt.Assert(t, qt.IsNil(err)) + cancel() + select { + case got := <-done: + qt.Assert(t, qt.ErrorIs(got.err, context.Canceled)) + qt.Assert(t, qt.Equals(got.tried, uint32(1))) + case <-time.After(2 * time.Second): + t.Fatal("bootstrap did not stop its active query after cancellation") + } + qt.Assert(t, qt.Equals(s.Stats().OutstandingTransactions, 0)) } // The traversal goroutine must be gone when refreshBucket returns. This does not observe the From 651c25d49b8294f4f6ea9a9daa310e3a90bd799b Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 16:15:01 +0530 Subject: [PATCH 14/18] Strengthen nearest-node oracle and responder cleanup regressions --- dht_test.go | 11 ++++++ table_test.go | 94 +++++++++++++++++++++++++++++++++++++-------------- 2 files changed, 79 insertions(+), 26 deletions(-) diff --git a/dht_test.go b/dht_test.go index 37d875318..11c444a2b 100644 --- a/dht_test.go +++ b/dht_test.go @@ -246,8 +246,19 @@ func TestBadGetPeersResponse(t *testing.T) { }) qt.Assert(t, qt.IsNil(err)) defer s.Close() + qt.Assert(t, qt.IsNil(pc.SetReadDeadline(time.Now().Add(2*time.Second)))) + responderDone := make(chan struct{}) + t.Cleanup(func() { + // Deferred pc.Close has already unblocked ReadFrom on an early test failure. + select { + case <-responderDone: + case <-time.After(2 * time.Second): + t.Error("responder goroutine did not exit") + } + }) replied := make(chan error, 1) go func() { + defer close(responderDone) replied <- func() error { b := make([]byte, 1024) n, addr, err := pc.ReadFrom(b) diff --git a/table_test.go b/table_test.go index 1ea87c72c..97ffbfe2d 100644 --- a/table_test.go +++ b/table_test.go @@ -1,7 +1,9 @@ package dht import ( + "bytes" "net" + "slices" "testing" "github.com/go-quicktest/qt" @@ -62,14 +64,13 @@ func TestRandomIdInBucket(t *testing.T) { } } -// BEP 5 replies must contain the k nodes closest to the target. closestNodes walks buckets and -// then cuts the list at k, so a partially included bucket keeps whichever nodes the map yields -// first rather than the nearest ones. +// Check exact nearest-K membership against a full-table oracle, independently of result order. func TestClosestNodesKeepsNearestInBucket(t *testing.T) { var root int160.T tbl := table{rootID: root, k: 8} var target int160.T target.SetBit(10, true) + var candidates []*node add := func(bucket, extra, port int) { t.Helper() @@ -88,6 +89,7 @@ func TestClosestNodesKeepsNearestInBucket(t *testing.T) { if err := tbl.addNode(n); err != nil { t.Fatal(err) } + candidates = append(candidates, n) } // Three nodes in the target's bucket. Every one of them is closer than every node in the next // bucket, so all three must be kept. @@ -98,31 +100,71 @@ func TestClosestNodesKeepsNearestInBucket(t *testing.T) { for _, bit := range []int{20, 30, 40, 50, 60, 70, 80, 90} { add(9, bit, 2000+bit) } - want := map[int]bool{1000: true, 1001: true, 1002: true, 2090: true, 2080: true, 2070: true, 2060: true, 2050: true} - - for try := range 30 { - got := tbl.closestNodes(8, target, func(*node) bool { return true }) - if len(got) != 8 { - t.Fatalf("try %d: got %d nodes", try, len(got)) - } - var prev int160.T - seen := map[int]bool{} - for i, n := range got { - d := n.Id.Distance(target) - if i > 0 && prev.Cmp(d) > 0 { - t.Fatalf("try %d: result is not ordered by XOR distance", try) + // Include buckets above the target bucket too: those were skipped by the old walk. + add(11, 120, 3011) + add(159, -1, 3159) + for _, tc := range []struct { + name string + target int160.T + k int + filter func(*node) bool + }{ + {"partial bucket", target, 8, func(*node) bool { return true }}, + {"filtered candidates", target, 8, func(n *node) bool { return n.Addr.Port()%2 != 0 }}, + {"local target", root, 8, func(*node) bool { return true }}, + {"all eligible", target, len(candidates) + 1, func(*node) bool { return true }}, + } { + t.Run(tc.name, func(t *testing.T) { + // Bytewise XOR is independent of the production int160 distance calculation. + distance := func(n *node) [20]byte { + d := n.Id.AsByteArray() + targetBytes := tc.target.AsByteArray() + for i := range d { + d[i] ^= targetBytes[i] + } + return d } - prev = d - seen[n.Addr.Port()] = true - } - if len(seen) != len(want) { - t.Fatalf("try %d: ports %v, want %v", try, seen, want) - } - for port := range want { - if !seen[port] { - t.Fatalf("try %d: dropped closer node on port %d; got %v", try, port, seen) + var want []*node + for _, n := range candidates { + if tc.filter(n) { + want = append(want, n) + } } - } + slices.SortFunc(want, func(a, b *node) int { + ad, bd := distance(a), distance(b) + return bytes.Compare(ad[:], bd[:]) + }) + if len(want) > tc.k { + want = want[:tc.k] + } + got := tbl.closestNodes(tc.k, tc.target, tc.filter) + qt.Assert(t, qt.Equals(len(got), len(want))) + type identity struct { + id [20]byte + addr string + } + remaining := make(map[identity]bool, len(want)) + for _, n := range want { + remaining[identity{n.Id.AsByteArray(), n.Addr.String()}] = true + } + for _, n := range got { + key := identity{n.Id.AsByteArray(), n.Addr.String()} + if !remaining[key] { + t.Errorf("unexpected or duplicate nearest node: id=%x addr=%s", key.id, key.addr) + } + delete(remaining, key) + } + for key := range remaining { + t.Errorf("missing nearest node: id=%x addr=%s", key.id, key.addr) + } + // Keep ordering independent: a sorted but incorrect subset must still fail above. + for i := 1; i < len(got); i++ { + prev, next := distance(got[i-1]), distance(got[i]) + if bytes.Compare(prev[:], next[:]) > 0 { + t.Errorf("XOR distance decreased at index %d: %x > %x", i, prev, next) + } + } + }) } } From 987041ff64eaf3de842f62aaf004139236d28ace Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 17:18:09 +0530 Subject: [PATCH 15/18] Reject malformed DHT endpoints and propagate publication failures Require complete compact addresses and present BEP44 values. Report errors when no remote put succeeds, preserving remote protocol errors. Reject invalid announce ports, cancel rate-limited replies on Close, and prevent writes after a blocklist callback closes the server. --- announce_port_test.go | 95 +++++++++++++++++++ exts/getput/getput.go | 27 +++++- exts/getput/getput_test.go | 182 +++++++++++++++++++++++++++++++++++++ krpc/nodeaddr.go | 6 +- krpc/nodeaddr_test.go | 29 +++++- server.go | 13 ++- shutdown_edges_test.go | 71 +++++++++++++++ 7 files changed, 413 insertions(+), 10 deletions(-) create mode 100644 announce_port_test.go create mode 100644 shutdown_edges_test.go diff --git a/announce_port_test.go b/announce_port_test.go new file mode 100644 index 000000000..f9fce2924 --- /dev/null +++ b/announce_port_test.go @@ -0,0 +1,95 @@ +package dht + +import ( + "net" + "testing" + "time" + + "github.com/anacrolix/dht/v2/krpc" + peer_store "github.com/anacrolix/dht/v2/peer-store" + "github.com/anacrolix/torrent/bencode" + "golang.org/x/time/rate" +) + +type announcedPortStore struct{ added chan krpc.NodeAddr } + +func (s announcedPortStore) AddPeer(_ peer_store.InfoHash, addr krpc.NodeAddr) { s.added <- addr } +func (s announcedPortStore) GetPeers(peer_store.InfoHash) []krpc.NodeAddr { return nil } + +func TestAnnouncePeerPortValidation(t *testing.T) { + for _, tc := range []struct { + name string + port int + present, implied, valid bool + }{ + {name: "missing"}, + {name: "zero", present: true}, + {name: "too large", port: 65536, present: true}, + {name: "maximum", port: 65535, present: true, valid: true}, + {name: "implied overrides explicit", port: 65536, present: true, implied: true, valid: true}, + } { + t.Run(tc.name, func(t *testing.T) { + peer := mustListen("127.0.0.1:0") + t.Cleanup(func() { _ = peer.Close() }) + store := announcedPortStore{added: make(chan krpc.NodeAddr, 1)} + s, err := NewServer(&ServerConfig{Conn: mustListen("127.0.0.1:0"), NoSecurity: true, PeerStore: store, SendLimiter: rate.NewLimiter(rate.Inf, 0)}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + source := NewAddr(peer.LocalAddr()) + s.mu.Lock() + token := s.createToken(source) + s.mu.Unlock() + args := &krpc.MsgArgs{ID: krpc.ID{19: 1}, InfoHash: krpc.ID{1}, Token: token, ImpliedPort: tc.implied} + if tc.present { + args.Port = &tc.port + } + packet, err := bencode.Marshal(krpc.Msg{Y: krpc.YQuery, Q: "announce_peer", T: "test", A: args}) + if err != nil { + t.Fatal(err) + } + if _, err = peer.WriteTo(packet, s.Addr()); err != nil { + t.Fatal(err) + } + if err = peer.SetReadDeadline(time.Now().Add(2 * time.Second)); err != nil { + t.Fatal(err) + } + var buf [1500]byte + n, _, err := peer.ReadFrom(buf[:]) + if err != nil { + t.Fatal(err) + } + var reply krpc.Msg + if err = bencode.Unmarshal(buf[:n], &reply); err != nil { + t.Fatal(err) + } + if !tc.valid { + if reply.E == nil || reply.E.Code != krpc.ErrorCodeProtocolError { + t.Fatalf("invalid port got response %+v, want protocol error", reply) + } + select { + case addr := <-store.added: + t.Fatalf("stored invalid peer %v", addr) + default: + } + return + } + if reply.R == nil || reply.E != nil { + t.Fatalf("valid announce failed: %+v", reply) + } + want := tc.port + if tc.implied { + want = peer.LocalAddr().(*net.UDPAddr).Port + } + select { + case addr := <-store.added: + if addr.Port != want { + t.Fatalf("stored port %d, want %d", addr.Port, want) + } + case <-time.After(2 * time.Second): + t.Fatal("valid announcement was not stored") + } + }) + } +} diff --git a/exts/getput/getput.go b/exts/getput/getput.go index 1bec1300e..80c851635 100644 --- a/exts/getput/getput.go +++ b/exts/getput/getput.go @@ -27,6 +27,9 @@ type GetResult struct { // Returns the item carried by r if it is the immutable item for target, or a correctly signed // mutable item for target and salt. func verifiedResult(r *krpc.Return, target bep44.Target, salt []byte) (GetResult, bool) { + if r.V == nil { + return GetResult{}, false + } if sha1.Sum(r.V) == target { return GetResult{V: r.V, Sig: r.Sig}, true } @@ -124,6 +127,9 @@ receive: type SeqToPut func(seq int64) bep44.Put +// Put attempts to store the item at the closest token-eligible nodes and waits for all attempts. +// It succeeds when at least one node accepts the item. With no accepting nodes it returns an +// error, preserving remote protocol errors for errors.Is/As. func Put( ctx context.Context, target krpc.ID, s *dht.Server, salt []byte, seqToPut SeqToPut, ) ( @@ -160,20 +166,35 @@ receive: if err != nil { return } + closest := op.Closest() + if closest.Len() == 0 { + return stats, errors.New("no token-eligible nodes found") + } + results := make(chan error, closest.Len()) var wg sync.WaitGroup put := seqToPut(autoSeq) - op.Closest().Range(func(elem k_nearest_nodes.Elem) { + closest.Range(func(elem k_nearest_nodes.Elem) { wg.Go(func() { // This is enforced by the DataFilter in startGetTraversal. token := elem.Data.(string) res := s.Put(ctx, dht.NewAddr(elem.Addr.UDP()), put, token, dht.QueryRateLimiting{}) - if err := res.ToError(); err != nil { + err := res.ToError() + if err != nil { logger.Levelf(log.Warning, "error putting to %v [token=%q]: %v", elem.Addr, token, err) } else { logger.Levelf(log.Debug, "put to %v [token=%q]", elem.Addr, token) } + results <- err }) }) wg.Wait() - return + var putErrors []error + for range closest.Len() { + if putErr := <-results; putErr == nil { + return stats, nil + } else { + putErrors = append(putErrors, putErr) + } + } + return stats, errors.Join(putErrors...) } diff --git a/exts/getput/getput_test.go b/exts/getput/getput_test.go index a3a8dc924..89285ee1f 100644 --- a/exts/getput/getput_test.go +++ b/exts/getput/getput_test.go @@ -2,6 +2,8 @@ package getput import ( "context" + "crypto/ed25519" + "crypto/sha1" "errors" "net" "runtime" @@ -9,6 +11,8 @@ import ( "testing" "time" + "github.com/anacrolix/torrent/bencode" + "github.com/anacrolix/dht/v2" "github.com/anacrolix/dht/v2/bep44" "github.com/anacrolix/dht/v2/krpc" @@ -100,3 +104,181 @@ func TestCancelActiveTraversal(t *testing.T) { }) } } + +func TestVerifiedResultRejectsAbsentMutableValue(t *testing.T) { + privateKey := ed25519.NewKeyFromSeed(make([]byte, ed25519.SeedSize)) + var publicKey [ed25519.PublicKeySize]byte + copy(publicKey[:], privateKey.Public().(ed25519.PublicKey)) + seq := int64(1) + var signature [ed25519.SignatureSize]byte + copy(signature[:], bep44.Sign(privateKey, nil, seq, nil)) + response := &krpc.Return{ + Bep44Return: krpc.Bep44Return{ + K: publicKey, + Sig: signature, + Seq: &seq, + }, + } + + _, ok := verifiedResult(response, bep44.MakeMutableTarget(publicKey, nil), nil) + qt.Assert(t, qt.IsFalse(ok)) +} + +func TestVerifiedResultAcceptsEmptyBencodedValue(t *testing.T) { + var response krpc.Msg + qt.Assert(t, qt.IsNil(bencode.Unmarshal([]byte("d1:rd1:v0:ee"), &response))) + qt.Assert(t, qt.IsNotNil(response.R)) + + target := sha1.Sum([]byte("0:")) + got, ok := verifiedResult(response.R, target, nil) + qt.Assert(t, qt.IsTrue(ok)) + qt.Check(t, qt.Equals(string(got.V), "0:")) +} + +func TestGetRejectsResponseWithoutValue(t *testing.T) { + peer, err := net.ListenPacket("udp", "127.0.0.1:0") + qt.Assert(t, qt.IsNil(err)) + t.Cleanup(func() { _ = peer.Close() }) + conn, err := net.ListenPacket("udp", "127.0.0.1:0") + qt.Assert(t, qt.IsNil(err)) + s, err := dht.NewServer(&dht.ServerConfig{ + Conn: conn, NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + StartingNodes: func() ([]dht.Addr, error) { + return []dht.Addr{dht.NewAddr(peer.LocalAddr())}, nil + }, + }) + qt.Assert(t, qt.IsNil(err)) + t.Cleanup(s.Close) + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + t.Cleanup(cancel) + type getResult struct { + value GetResult + err error + } + done := make(chan getResult, 1) + go func() { + target := sha1.Sum(nil) + value, _, err := Get(ctx, target, s, nil, nil) + done <- getResult{value: value, err: err} + }() + + qt.Assert(t, qt.IsNil(peer.SetReadDeadline(time.Now().Add(5*time.Second)))) + var packet [1500]byte + n, source, err := peer.ReadFrom(packet[:]) + qt.Assert(t, qt.IsNil(err)) + var request krpc.Msg + qt.Assert(t, qt.IsNil(bencode.Unmarshal(packet[:n], &request))) + qt.Assert(t, qt.Equals(request.Q, "get")) + reply, err := bencode.Marshal(krpc.Msg{ + T: request.T, Y: krpc.YResponse, + R: &krpc.Return{ID: krpc.ID{1}}, + }) + qt.Assert(t, qt.IsNil(err)) + _, err = peer.WriteTo(reply, source) + qt.Assert(t, qt.IsNil(err)) + + select { + case result := <-done: + qt.Assert(t, qt.IsNotNil(result.err)) + qt.Check(t, qt.IsFalse(errors.Is(result.err, context.DeadlineExceeded))) + qt.Check(t, qt.IsNil(result.value.V)) + case <-ctx.Done(): + t.Fatal("Get did not finish after response without a value") + } +} + +func TestPutReportsRemoteOutcome(t *testing.T) { + for _, test := range []struct { + name string + returnToken bool + rejectPut bool + }{ + {name: "no eligible nodes"}, + {name: "all nodes reject", returnToken: true, rejectPut: true}, + {name: "accepted", returnToken: true}, + } { + t.Run(test.name, func(t *testing.T) { + peer, err := net.ListenPacket("udp", "127.0.0.1:0") + qt.Assert(t, qt.IsNil(err)) + t.Cleanup(func() { _ = peer.Close() }) + conn, err := net.ListenPacket("udp", "127.0.0.1:0") + qt.Assert(t, qt.IsNil(err)) + s, err := dht.NewServer(&dht.ServerConfig{ + Conn: conn, NoSecurity: true, + QueryResendDelay: func() time.Duration { return time.Hour }, + StartingNodes: func() ([]dht.Addr, error) { + return []dht.Addr{dht.NewAddr(peer.LocalAddr())}, nil + }, + }) + qt.Assert(t, qt.IsNil(err)) + t.Cleanup(s.Close) + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + t.Cleanup(cancel) + done := make(chan error, 1) + go func() { + _, err := Put(ctx, krpc.ID{1}, s, nil, func(int64) bep44.Put { + return bep44.Put{V: "value"} + }) + done <- err + }() + + var responseErr error + for _, expectedQuery := range []string{"get", "put"} { + if expectedQuery == "put" && !test.returnToken { + break + } + qt.Assert(t, qt.IsNil(peer.SetReadDeadline(time.Now().Add(5*time.Second)))) + var packet [1500]byte + n, source, err := peer.ReadFrom(packet[:]) + qt.Assert(t, qt.IsNil(err)) + var request krpc.Msg + qt.Assert(t, qt.IsNil(bencode.Unmarshal(packet[:n], &request))) + qt.Assert(t, qt.Equals(request.Q, expectedQuery)) + + var reply krpc.Msg + reply.T = request.T + if expectedQuery == "get" { + reply.Y = krpc.YResponse + returned := &krpc.Return{ID: krpc.ID{1}} + if test.returnToken { + token := "write-token" + returned.Token = &token + } + reply.R = returned + } else if test.rejectPut { + reply.Y = krpc.YError + reply.E = &krpc.Error{ + Code: krpc.ErrorCodeInvalidSignature, + Msg: "invalid signature", + } + } else { + reply.Y = krpc.YResponse + reply.R = &krpc.Return{ID: krpc.ID{1}} + } + encoded, err := bencode.Marshal(reply) + qt.Assert(t, qt.IsNil(err)) + _, err = peer.WriteTo(encoded, source) + qt.Assert(t, qt.IsNil(err)) + } + select { + case err := <-done: + if test.returnToken && !test.rejectPut { + qt.Assert(t, qt.IsNil(err)) + } else { + qt.Assert(t, qt.IsNotNil(err)) + } + if test.rejectPut { + var remoteErr *krpc.Error + qt.Assert(t, qt.IsTrue(errors.As(err, &remoteErr))) + qt.Check(t, qt.Equals(remoteErr.Code, krpc.ErrorCodeInvalidSignature)) + } + case <-ctx.Done(): + responseErr = ctx.Err() + } + qt.Assert(t, qt.IsNil(responseErr)) + }) + } +} diff --git a/krpc/nodeaddr.go b/krpc/nodeaddr.go index 63f0116dc..d61aa899e 100644 --- a/krpc/nodeaddr.go +++ b/krpc/nodeaddr.go @@ -32,8 +32,10 @@ func (me NodeAddr) String() string { } func (me *NodeAddr) UnmarshalBinary(b []byte) error { - if len(b) < 2 { - return fmt.Errorf("unmarshal NodeAddr from %d bytes: need at least 2", len(b)) + switch len(b) { + case net.IPv4len + 2, net.IPv6len + 2: + default: + return fmt.Errorf("unmarshal NodeAddr from %d bytes: need 6-byte IPv4 or 18-byte IPv6 compact address", len(b)) } me.IP = make(net.IP, len(b)-2) copy(me.IP, b[:len(b)-2]) diff --git a/krpc/nodeaddr_test.go b/krpc/nodeaddr_test.go index 1a55b676d..5eae5b4a9 100644 --- a/krpc/nodeaddr_test.go +++ b/krpc/nodeaddr_test.go @@ -24,7 +24,6 @@ func TestNodeAddrBinaryRoundTrip(t *testing.T) { {"global IPv6", NodeAddr{IP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, Port: 6881}}, {"link-local IPv6", NodeAddr{IP: net.IP{0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, Port: 1}}, {"unspecified IPv6", NodeAddr{IP: net.IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, Port: 0}}, - {"nil IP", NodeAddr{IP: nil, Port: 65535}}, } for _, test := range tests { @@ -40,6 +39,32 @@ func TestNodeAddrBinaryRoundTrip(t *testing.T) { } } +func TestNodeAddrUnmarshalBinaryRejectsInvalidLengths(t *testing.T) { + tests := []struct { + name string + data []byte + }{ + {"port only", []byte{0x1a, 0xe1}}, + {"three bytes", make([]byte, 3)}, + {"four bytes", make([]byte, 4)}, + {"short IPv4", make([]byte, 5)}, + {"extra IPv4 byte", make([]byte, 7)}, + {"short IPv6", make([]byte, 17)}, + {"extra IPv6 byte", make([]byte, 19)}, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + original := NodeAddr{IP: net.IP{192, 0, 2, 1}, Port: 6881} + got := NodeAddr{IP: bytes.Clone(original.IP), Port: original.Port} + + qt.Assert(t, qt.IsNotNil(got.UnmarshalBinary(test.data))) + qt.Check(t, qt.IsTrue(bytes.Equal(got.IP, original.IP))) + qt.Check(t, qt.Equals(got.Port, original.Port)) + }) + } +} + func FuzzNodeAddrUnmarshalBinary(f *testing.F) { f.Add([]byte{}) f.Add([]byte{1}) @@ -52,7 +77,7 @@ func FuzzNodeAddrUnmarshalBinary(f *testing.F) { got := NodeAddr{IP: bytes.Clone(original.IP), Port: original.Port} err := got.UnmarshalBinary(b) - if len(b) < 2 { + if len(b) != 6 && len(b) != 18 { qt.Assert(t, qt.IsNotNil(err)) qt.Check(t, qt.IsTrue(bytes.Equal(got.IP, original.IP)), qt.Commentf("receiver IP changed from %x to %x", original.IP, got.IP)) qt.Check(t, qt.Equals(got.Port, original.Port)) diff --git a/server.go b/server.go index e77066051..b885ed0c9 100644 --- a/server.go +++ b/server.go @@ -586,8 +586,12 @@ func (s *Server) handleAnnouncePeer(source Addr, t string, args *krpc.MsgArgs) { port = source.Port() portOk = true } - if !portOk { - expvars.Add("received announce_peer with no derivable port", 1) + if !portOk || port < 1 || port > 65535 { + s.sendError(source, t, krpc.Error{ + Code: krpc.ErrorCodeProtocolError, + Msg: "invalid announce_peer port", + }) + return } if h := s.config.OnAnnouncePeer; h != nil { go h(metainfo.Hash(args.InfoHash), source.IP(), port, portOk) @@ -705,7 +709,7 @@ func (s *Server) reply(addr Addr, t string, r krpc.Return) { } b := bencode.MustMarshal(m) log.Fmsg("replying to %q", addr).Log(s.logger()) - wrote, err := s.writeToNode(context.Background(), b, addr, s.config.WaitToReply, true) + wrote, err := s.writeToNode(s.serverCtx, b, addr, s.config.WaitToReply, true) if err != nil { s.config.Logger.Printf("error replying to %s: %s", addr, err) } @@ -811,6 +815,9 @@ func (s *Server) writeToNode(ctx context.Context, b []byte, node Addr, wait, rat return } } + if s.closed.IsSet() { + return false, errors.New("server is closed") + } if rate { if wait { err = s.config.SendLimiter.Wait(ctx) diff --git a/shutdown_edges_test.go b/shutdown_edges_test.go new file mode 100644 index 000000000..6d1489e50 --- /dev/null +++ b/shutdown_edges_test.go @@ -0,0 +1,71 @@ +package dht + +import ( + "context" + "net" + "sync/atomic" + "testing" + "time" + + "github.com/anacrolix/dht/v2/krpc" + "golang.org/x/time/rate" +) + +func TestCloseCancelsRateLimitedReply(t *testing.T) { + limiter := rate.NewLimiter(rate.Every(time.Hour), 1) + if !limiter.Allow() { + t.Fatal("could not consume initial token") + } + s, err := NewServer(&ServerConfig{Conn: mustListen("127.0.0.1:0"), NoSecurity: true, WaitToReply: true, SendLimiter: limiter}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + s.reply(NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1}), "test", krpc.Return{}) + deadline := time.Now().Add(time.Second) + for limiter.Tokens() >= 0 && time.Now().Before(deadline) { + time.Sleep(time.Millisecond) + } + if limiter.Tokens() >= 0 { + t.Fatal("reply did not reserve a rate-limit token") + } + s.Close() + deadline = time.Now().Add(time.Second) + for limiter.Tokens() < 0 && time.Now().Before(deadline) { + time.Sleep(time.Millisecond) + } + if limiter.Tokens() < 0 { + t.Fatal("Close left reply waiting on its rate-limit reservation") + } +} + +type countingWriteConn struct { + net.PacketConn + writes atomic.Int32 +} + +func (c *countingWriteConn) WriteTo(b []byte, addr net.Addr) (int, error) { + c.writes.Add(1) + return c.PacketConn.WriteTo(b, addr) +} + +func TestBlocklistClosePreventsWrite(t *testing.T) { + conn := &countingWriteConn{PacketConn: mustListen("127.0.0.1:0")} + var s *Server + cfg := NewDefaultServerConfig() + cfg.Conn = conn + cfg.IPBlocklist = &callbackTestRanger{lookup: func(net.IP) { s.Close() }} + var err error + s, err = NewServer(cfg) + if err != nil { + t.Fatal(err) + } + t.Cleanup(s.Close) + wrote, err := s.writeToNode(context.Background(), []byte("query"), NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1}), false, false) + if wrote || err == nil { + t.Fatalf("write after callback Close: wrote=%v err=%v", wrote, err) + } + if got := conn.writes.Load(); got != 0 { + t.Fatalf("WriteTo called %d times after callback closed server", got) + } +} From 1be3da8a4eb101d7fab2a847a17463f4ddb3e3d8 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 17:18:21 +0530 Subject: [PATCH 16/18] Validate mutable keys and include DNS in ping deadlines Reject malformed mutable keys and node-list responses instead of panicking. Preserve numeric-address semantics while resolving hostnames with the command context. Surface KRPC errors and prevent automatic sequence overflow. --- cmd/dht/main.go | 34 +++++++++++++------- cmd/dht/main_test.go | 51 ++++++++++++++++++++++++++++++ cmd/dht/ping.go | 62 ++++++++++++++++++++++++++++--------- cmd/dht/ping_test.go | 74 ++++++++++++++++++++++++++++++++++++++++++++ cmd/dht/put.go | 18 +++++++++-- cmd/dht/put_test.go | 15 +++++++++ 6 files changed, 227 insertions(+), 27 deletions(-) create mode 100644 cmd/dht/main_test.go create mode 100644 cmd/dht/put_test.go diff --git a/cmd/dht/main.go b/cmd/dht/main.go index 701670b94..04b4ec725 100644 --- a/cmd/dht/main.go +++ b/cmd/dht/main.go @@ -36,6 +36,20 @@ func main() { } } +func returnedNodeAddresses(res dht.QueryResult) ([]string, error) { + if err := res.ToError(); err != nil { + return nil, err + } + if res.Reply.R == nil { + return nil, errors.New("response missing return dictionary") + } + var nodes []string + res.Reply.R.ForAllNodes(func(info krpc.NodeInfo) { + nodes = append(nodes, info.Addr.String()) + }) + return nodes, nil +} + func runMain() int { logger := log.Default.WithNames("main") ctx := log.ContextWithLogger(context.Background(), logger) @@ -59,6 +73,9 @@ func runMain() int { Salt string } sub.Parse(args.FromStruct(&subArgs)...) + if err := validateMutableKey(true, subArgs.Key.Bytes); err != nil { + return err + } put.Salt = []byte(subArgs.Salt) put.K = (*[32]byte)(subArgs.Key.Bytes) if subArgs.Private { @@ -94,10 +111,10 @@ func runMain() int { args.Subcommand("put", func(sub args.SubCmdCtx) (err error) { var putOpt PutCmd sub.Parse(args.FromStruct(&putOpt)...) - switch len(putOpt.Key.Bytes) { - case 0, 32: - default: - return fmt.Errorf("key has bad length %v", len(putOpt.Key.Bytes)) + mutable := putOpt.Mutable || len(putOpt.Key.Bytes) != 0 || + putOpt.Cas != 0 || len(putOpt.Salt) != 0 + if err := validateMutableKey(mutable, putOpt.Key.Bytes); err != nil { + return err } sub.Defer(func() error { return put(ctx, &putOpt) }) return nil @@ -187,18 +204,13 @@ func runMain() int { input := dht.QueryInput{} input.MsgArgs.Target = subArgs.Target res := s.Query(ctx, dht.NewAddr(addr), subArgs.Q, input) - err = res.ToError() + nodes, err := returnedNodeAddresses(res) if err != nil { return err } return ping(ctx, pingArgs{ Network: serverArgs.Network, - Nodes: func() (ret []string) { - res.Reply.R.ForAllNodes(func(info krpc.NodeInfo) { - ret = append(ret, info.Addr.String()) - }) - return - }(), + Nodes: nodes, Timeout: subArgs.Timeout, }, s) }) diff --git a/cmd/dht/main_test.go b/cmd/dht/main_test.go new file mode 100644 index 000000000..480f430ce --- /dev/null +++ b/cmd/dht/main_test.go @@ -0,0 +1,51 @@ +package main + +import ( + "os" + "strings" + "testing" + + "github.com/anacrolix/dht/v2" + "github.com/anacrolix/dht/v2/krpc" +) + +func TestMutableCommandsRejectBadKeyLengths(t *testing.T) { + originalArgs := os.Args + t.Cleanup(func() { os.Args = originalArgs }) + for _, tc := range []struct { + name string + args []string + }{ + {"derive short", []string{"dht", "derive-put-target", "mutable", "--key", "00"}}, + {"derive long", []string{"dht", "derive-put-target", "mutable", "--key", strings.Repeat("00", 33)}}, + {"put missing", []string{"dht", "put", "--mutable", "--strings", "value"}}, + {"put short", []string{"dht", "put", "--mutable", "--key", "00", "--strings", "value"}}, + } { + t.Run(tc.name, func(t *testing.T) { + os.Args = tc.args + if got := runMain(); got != 2 { + t.Fatalf("runMain exit = %d, want usage error 2", got) + } + }) + } +} + +func TestReturnedNodeAddressesRejectsMalformedAndErrorReplies(t *testing.T) { + tests := []struct { + name string + reply krpc.Msg + }{ + {"missing return dictionary", krpc.Msg{Y: krpc.YResponse}}, + {"protocol error", krpc.Msg{ + Y: krpc.YError, + E: &krpc.Error{Code: krpc.ErrorCodeProtocolError, Msg: "bad request"}, + }}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if nodes, err := returnedNodeAddresses(dht.QueryResult{Reply: tc.reply}); err == nil { + t.Fatalf("returned nodes %v from malformed reply", nodes) + } + }) + } +} diff --git a/cmd/dht/ping.go b/cmd/dht/ping.go index ed7e0b578..c9ae63bb0 100644 --- a/cmd/dht/ping.go +++ b/cmd/dht/ping.go @@ -3,9 +3,9 @@ package main import ( "context" - "errors" "fmt" "net" + "net/netip" "sync" "time" @@ -19,9 +19,53 @@ type pingArgs struct { Nodes []string `arg:"positional" arity:"*" help:"nodes to ping e.g. router.bittorrent.com:6881"` } +func resolveUDPAddr(ctx context.Context, network, address string) (*net.UDPAddr, error) { + host, port, err := net.SplitHostPort(address) + if err != nil { + return nil, err + } + if _, err := netip.ParseAddr(host); err == nil || host == "" { + // The standard resolver does not perform DNS for literals. Keep its zone, + // family, service-port and wildcard-address handling intact. + return net.ResolveUDPAddr(network, address) + } + ipNetwork := "ip" + switch network { + case "", "udp": + case "udp4": + ipNetwork = "ip4" + case "udp6": + ipNetwork = "ip6" + default: + return nil, net.UnknownNetworkError(network) + } + ips, err := net.DefaultResolver.LookupNetIP(ctx, ipNetwork, host) + if err != nil { + return nil, err + } + if len(ips) == 0 { + return nil, fmt.Errorf("no addresses for %q", host) + } + ip := ips[0] + if ipNetwork == "ip" { + for _, candidate := range ips { + if candidate.Is4() { + ip = candidate + break + } + } + } + return net.ResolveUDPAddr(network, net.JoinHostPort(ip.String(), port)) +} + func ping(ctx context.Context, args pingArgs, s *dht.Server) error { ctx, cancel := context.WithCancel(ctx) defer cancel() + if args.Timeout != 0 { + var cancelTimeout context.CancelFunc + ctx, cancelTimeout = context.WithTimeout(ctx, args.Timeout) + defer cancelTimeout() + } nodes := args.Nodes if args.Defaults { nodes = append(nodes, dht.DefaultGlobalBootstrapHostPorts...) @@ -33,7 +77,7 @@ func ping(ctx context.Context, args pingArgs, s *dht.Server) error { wg.Wait() return err } - ua, err := net.ResolveUDPAddr(args.Network, a) + ua, err := resolveUDPAddr(ctx, args.Network, a) if err != nil { cancel() wg.Wait() @@ -48,8 +92,8 @@ func ping(ctx context.Context, args pingArgs, s *dht.Server) error { wg.Go(func() { addr := dht.NewAddr(ua) res := s.Query(ctx, addr, "ping", dht.QueryInput{}) - if res.Err != nil { - fmt.Printf("%s: %s: %s\n", a, time.Since(started), res.Err) + if err := res.ToError(); err != nil { + fmt.Printf("%s: %s: %s\n", a, time.Since(started), err) return } id := res.Reply.SenderID() @@ -70,12 +114,6 @@ func ping(ctx context.Context, args pingArgs, s *dht.Server) error { wg.Wait() close(done) }() - var timeout <-chan time.Time - if args.Timeout != 0 { - timer := time.NewTimer(args.Timeout) - defer timer.Stop() - timeout = timer.C - } select { case <-done: if err := ctx.Err(); err != nil { @@ -86,9 +124,5 @@ func ping(ctx context.Context, args pingArgs, s *dht.Server) error { cancel() <-done return ctx.Err() - case <-timeout: - cancel() - <-done - return errors.New("timed out") } } diff --git a/cmd/dht/ping_test.go b/cmd/dht/ping_test.go index 6d7454ecf..872f2225a 100644 --- a/cmd/dht/ping_test.go +++ b/cmd/dht/ping_test.go @@ -233,3 +233,77 @@ func TestPingContextCancellationCancelsAndJoinsWorkers(t *testing.T) { t.Errorf("outstanding transactions after ping returned = %d, want 0", got) } } + +func TestPingTimeoutIncludesDNSResolution(t *testing.T) { + s := newPingLifecycleTestServer(t) + oldResolver := net.DefaultResolver + t.Cleanup(func() { net.DefaultResolver = oldResolver }) + resolverStarted := make(chan struct{}) + releaseResolver := make(chan struct{}) + var once sync.Once + net.DefaultResolver = &net.Resolver{ + PreferGo: true, + Dial: func(ctx context.Context, _, _ string) (net.Conn, error) { + once.Do(func() { close(resolverStarted) }) + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-releaseResolver: + return nil, errors.New("resolver released by cleanup") + } + }, + } + done := make(chan error, 1) + finished := make(chan struct{}) + t.Cleanup(func() { + close(releaseResolver) + select { + case <-finished: + case <-time.After(time.Second): + t.Error("ping did not release its DNS lookup") + } + }) + go func() { + defer close(finished) + done <- ping(context.Background(), pingArgs{ + Network: "udp", + Timeout: 25 * time.Millisecond, + Nodes: []string{"blocked-resolution.invalid:6881"}, + }, s) + }() + select { + case <-resolverStarted: + case <-time.After(time.Second): + t.Fatal("ping did not start DNS resolution") + } + select { + case err := <-done: + if !errors.Is(err, context.DeadlineExceeded) { + t.Fatalf("ping DNS timeout error = %v, want context deadline", err) + } + case <-time.After(250 * time.Millisecond): + t.Fatal("ping timeout did not include DNS resolution") + } +} + +func TestContextResolverPreservesLiteralAddressSemantics(t *testing.T) { + for _, tc := range []struct{ network, address string }{ + {"udp", "127.0.0.1:6881"}, + {"udp6", "[::1]:6881"}, + {"udp6", "[fe80::1%en0]:6881"}, + {"udp", ":6881"}, + {"udp4", "[::1]:6881"}, + {"invalid", "127.0.0.1:6881"}, + } { + t.Run(tc.network+"/"+tc.address, func(t *testing.T) { + want, wantErr := net.ResolveUDPAddr(tc.network, tc.address) + got, gotErr := resolveUDPAddr(context.Background(), tc.network, tc.address) + if (wantErr != nil) != (gotErr != nil) { + t.Fatalf("resolution errors: got %v, standard resolver %v", gotErr, wantErr) + } + if wantErr == nil && (got.Port != want.Port || got.Zone != want.Zone || !got.IP.Equal(want.IP)) { + t.Fatalf("resolved %v, want %v", got, want) + } + }) + } +} diff --git a/cmd/dht/put.go b/cmd/dht/put.go index d379ffeb3..c7459fdb7 100644 --- a/cmd/dht/put.go +++ b/cmd/dht/put.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "log" + "math" "github.com/anacrolix/args/targets" g "github.com/anacrolix/generics" @@ -28,11 +29,21 @@ type PutCmd struct { AutoSeq bool } +func validateMutableKey(mutable bool, key []byte) error { + if mutable && len(key) != ed25519.SeedSize { + return fmt.Errorf("mutable key must be %d bytes, got %d", ed25519.SeedSize, len(key)) + } + return nil +} + func makeSeqToPut(autoSeq, mutable bool, put bep44.Put, privKey ed25519.PrivateKey) getput.SeqToPut { return func(seq int64) bep44.Put { - // Increment best seen seq by one. - if autoSeq { + if autoSeq && seq != math.MaxInt64 { put.Seq = seq + 1 + } else if autoSeq { + // BEP 44 sequence numbers must not exceed MaxInt64. Reusing the maximum lets + // identical content refresh its timeout; a changed value is rejected remotely. + put.Seq = seq } if mutable { put.Sign(privKey) @@ -51,6 +62,9 @@ func put(ctx context.Context, cmd *PutCmd) (err error) { return errors.New("no payloads given") } mutable := cmd.Mutable || len(cmd.Key.Bytes) != 0 || cmd.Cas != 0 || len(cmd.Salt) != 0 + if err := validateMutableKey(mutable, cmd.Key.Bytes); err != nil { + return err + } for _, data := range cmd.Data { var v any if cmd.Strings { diff --git a/cmd/dht/put_test.go b/cmd/dht/put_test.go new file mode 100644 index 000000000..38ffc8656 --- /dev/null +++ b/cmd/dht/put_test.go @@ -0,0 +1,15 @@ +package main + +import ( + "math" + "testing" + + "github.com/anacrolix/dht/v2/bep44" +) + +func TestAutoSequenceDoesNotWrap(t *testing.T) { + put := makeSeqToPut(true, false, bep44.Put{}, nil)(math.MaxInt64) + if put.Seq != math.MaxInt64 { + t.Fatalf("auto sequence wrapped to %d", put.Seq) + } +} From 265bf4a5fec0f6080a9a2f684b2af91cd59b264e Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 17:18:21 +0530 Subject: [PATCH 17/18] Deduplicate traversal endpoints and strengthen concurrency regressions Skip queued aliases for an already queried endpoint. Bound and yield both stats-test workloads, make callback fixture failure cleanup safe, assert callback reachability, remove vacuous external-behavior tests, and use ephemeral ports. --- announce_test.go | 14 -------- callback_test.go | 48 ++++++++++++++++++------- dht_test.go | 6 ++-- lifecycle_test.go | 10 ------ traversal/loadstats_test.go | 27 +++++++------- traversal/operation.go | 9 +++++ traversal/operation_test.go | 70 ++++++++++++++++++++++++++++++------- 7 files changed, 117 insertions(+), 67 deletions(-) diff --git a/announce_test.go b/announce_test.go index fcfdbd138..5b5e1db0e 100644 --- a/announce_test.go +++ b/announce_test.go @@ -1,7 +1,6 @@ package dht import ( - "context" "crypto/rand" "net" "regexp" @@ -50,19 +49,6 @@ func TestAnnounceStopsNoPending(t *testing.T) { } } -// Assert that rate.Limiter won't wake-up waiters once they have determined a -// delay. This means we can't use it to cancel reservations for queries that -// are successful. -func TestRateLimiterInadequate(t *testing.T) { - rl := rate.NewLimiter(rate.Every(time.Hour), 1) - qt.Check(t, qt.IsNil(rl.Wait(context.Background()))) - time.AfterFunc(time.Millisecond, func() { rl.AllowN(time.Now(), -1) }) - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - time.AfterFunc(2*time.Millisecond, cancel) - qt.Check(t, qt.Equals(rl.Wait(ctx), context.Canceled)) -} - // Stats can be read while a query is still outstanding. func TestTraversalStatsDuringQuery(t *testing.T) { silent := mustListen("localhost:0") diff --git a/callback_test.go b/callback_test.go index 000276e5f..ae218a66d 100644 --- a/callback_test.go +++ b/callback_test.go @@ -3,6 +3,7 @@ package dht import ( "context" "net" + "sync/atomic" "testing" "time" @@ -57,6 +58,13 @@ func newCallbackTestServer(t *testing.T, cfg *ServerConfig) *Server { if err != nil { t.Fatal(err) } + t.Cleanup(func() { + // A regression may strand a goroutine holding mu. Signal shutdown without + // taking that mutex so a failing test neither hangs cleanup nor panics serve. + s.cancelServer() + s.closed.Set() + _ = conn.Close() + }) return s } @@ -75,15 +83,8 @@ func processCallbackTestPacket(t *testing.T, s *Server, query krpc.Msg) { } } func TestOnQueryCanReenterStatsAndClose(t *testing.T) { - conn, err := net.ListenPacket("udp", "127.0.0.1:0") - if err != nil { - t.Fatal(err) - } - defer conn.Close() - store := new(callbackTestStore) cfg := NewDefaultServerConfig() - cfg.Conn = conn cfg.Store = store var s *Server var callbackCalls int @@ -96,10 +97,7 @@ func TestOnQueryCanReenterStatsAndClose(t *testing.T) { close(callbackDone) return true } - s, err = NewServer(cfg) - if err != nil { - t.Fatal(err) - } + s = newCallbackTestServer(t, cfg) packet := bencode.MustMarshal(krpc.Msg{ T: "1", @@ -183,7 +181,11 @@ func TestPacketLoggerCanReenterStats(t *testing.T) { cfg.Passive = true cfg.Logger = log.NewLogger() var s *Server - cfg.Logger.SetHandlers(callbackTestLogHandler{onLog: func() { _ = s.Stats() }}) + var calls atomic.Uint32 + cfg.Logger.SetHandlers(callbackTestLogHandler{onLog: func() { + _ = s.Stats() + calls.Add(1) + }}) s = newCallbackTestServer(t, cfg) processCallbackTestPacket(t, s, krpc.Msg{ T: "1", @@ -191,6 +193,9 @@ func TestPacketLoggerCanReenterStats(t *testing.T) { Q: "ping", A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, }) + if calls.Load() == 0 { + t.Fatal("packet did not exercise the reentrant logger") + } s.Close() } @@ -236,8 +241,10 @@ func (s *callbackTestPeerStore) GetPeers(ih peer_store.InfoHash) []krpc.NodeAddr func TestPeerStoreCanReenterStats(t *testing.T) { var s *Server cfg := NewDefaultServerConfig() + called := false cfg.PeerStore = &callbackTestPeerStore{get: func(peer_store.InfoHash) []krpc.NodeAddr { _ = s.Stats() + called = true return nil }} s = newCallbackTestServer(t, cfg) @@ -247,6 +254,9 @@ func TestPeerStoreCanReenterStats(t *testing.T) { Q: "get_peers", A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, }) + if !called { + t.Fatal("get_peers did not exercise the reentrant peer store") + } s.Close() } @@ -345,9 +355,11 @@ func TestBlocklistLookupOnReadCanReenterStats(t *testing.T) { cfg.IPBlocklist = ranger var s *Server serverReady := make(chan struct{}) + var lookups atomic.Uint32 ranger.lookup = func(net.IP) { <-serverReady _ = s.Stats() + lookups.Add(1) } queryReceived := make(chan struct{}) cfg.OnQuery = func(*krpc.Msg, net.Addr) bool { @@ -375,6 +387,9 @@ func TestBlocklistLookupOnReadCanReenterStats(t *testing.T) { case <-time.After(2 * time.Second): t.Fatal("receive path deadlocked when blocklist Lookup reentered Server.Stats") } + if lookups.Load() == 0 { + t.Fatal("receive path skipped the reentrant blocklist lookup") + } s.Close() } @@ -454,10 +469,12 @@ func TestRefreshBucketNodeFilterCanReenterStats(t *testing.T) { type callbackTestMarshaler struct { server *Server + calls *atomic.Uint32 } func (m callbackTestMarshaler) MarshalBencode() ([]byte, error) { _ = m.server.Stats() + m.calls.Add(1) return []byte("i1e"), nil } @@ -466,18 +483,23 @@ func TestStoreValueMarshalerCanReenterStats(t *testing.T) { cfg := NewDefaultServerConfig() cfg.Store = store s := newCallbackTestServer(t, cfg) - item, err := bep44.NewItem(callbackTestMarshaler{server: s}, nil, 1, 1, nil) + var calls atomic.Uint32 + item, err := bep44.NewItem(callbackTestMarshaler{server: s, calls: &calls}, nil, 1, 1, nil) if err != nil { t.Fatal(err) } if err := s.store.Put(item); err != nil { t.Fatal(err) } + before := calls.Load() processCallbackTestPacket(t, s, krpc.Msg{ T: "1", Y: "q", Q: "get", A: &krpc.MsgArgs{ID: krpc.ID{19: 1}}, }) + if calls.Load() == before { + t.Fatal("get response did not exercise the reentrant value marshaler") + } s.Close() } diff --git a/dht_test.go b/dht_test.go index 11c444a2b..3ac31b747 100644 --- a/dht_test.go +++ b/dht_test.go @@ -171,7 +171,7 @@ func TestEqualPointers(t *testing.T) { func TestHook(t *testing.T) { pinger, err := NewServer(&ServerConfig{ - Conn: mustListen("127.0.0.1:5678"), + Conn: mustListen("127.0.0.1:0"), PublicIP: net.IPv4(127, 0, 0, 1), }) qt.Assert(t, qt.IsNil(err)) @@ -179,9 +179,9 @@ func TestHook(t *testing.T) { // Establish server with a hook attached to "ping" hookCalled := make(chan struct{}, 1) receiver, err := NewServer(&ServerConfig{ - Conn: mustListen("127.0.0.1:5679"), + Conn: mustListen("127.0.0.1:0"), PublicIP: net.IPv4(127, 0, 0, 1), - StartingNodes: addrResolver("127.0.0.1:5678"), + StartingNodes: addrResolver(pinger.Addr().String()), OnQuery: func(m *krpc.Msg, addr net.Addr) bool { t.Logf("receiver got msg: %v", m) if m.Q == "ping" { diff --git a/lifecycle_test.go b/lifecycle_test.go index 72599f1fa..30bbc1d91 100644 --- a/lifecycle_test.go +++ b/lifecycle_test.go @@ -106,13 +106,3 @@ func TestBootstrapContextCancelWaitsForTraversal(t *testing.T) { } qt.Assert(t, qt.Equals(s.Stats().OutstandingTransactions, 0)) } - -// The traversal goroutine must be gone when refreshBucket returns. This does not observe the -// stats-before-Stopped ordering; that return is assigned only after Stopped in refreshBucket. -func TestRefreshBucketStopsBeforeStats(t *testing.T) { - s := newServerWithoutStartingNodes(t) - before := numTraversalGoroutines() - stats := s.refreshBucket(0) - qt.Assert(t, qt.IsNotNil(stats)) - assertTraversalGoroutines(t, before) -} diff --git a/traversal/loadstats_test.go b/traversal/loadstats_test.go index 39de7ee5e..76790289b 100644 --- a/traversal/loadstats_test.go +++ b/traversal/loadstats_test.go @@ -12,31 +12,30 @@ import ( func TestLoadStatsDuringUpdates(t *testing.T) { var op Operation var wg sync.WaitGroup - stop := make(chan struct{}) + const updates = 10000 started := make(chan struct{}) wg.Go(func() { atomic.AddUint32(&op.stats.NumAddrsTried, 1) atomic.AddUint32(&op.stats.NumResponses, 1) close(started) - for { - select { - case <-stop: - return - default: - atomic.AddUint32(&op.stats.NumAddrsTried, 1) - atomic.AddUint32(&op.stats.NumResponses, 1) - } + for range updates { + atomic.AddUint32(&op.stats.NumAddrsTried, 1) + atomic.AddUint32(&op.stats.NumResponses, 1) + runtime.Gosched() } }) <-started var last Stats - for range 10000 { - last = op.LoadStats() + for range updates { + current := op.LoadStats() + if current.NumAddrsTried < last.NumAddrsTried || current.NumResponses < last.NumResponses { + t.Errorf("counters went backwards: previous %+v, current %+v", last, current) + } + last = current runtime.Gosched() } - close(stop) wg.Wait() - if last.NumAddrsTried == 0 || last.NumResponses == 0 { - t.Fatalf("expected counters to move, got %+v", last) + if got := op.LoadStats(); got.NumAddrsTried != updates+1 || got.NumResponses != updates+1 { + t.Fatalf("final counters = %+v, want %d each", got, updates+1) } } diff --git a/traversal/operation.go b/traversal/operation.go index f05cdbab4..3adcbd1ee 100644 --- a/traversal/operation.go +++ b/traversal/operation.go @@ -171,6 +171,15 @@ func (op *Operation) popClosestUnqueried() types.AddrMaybeId { } func (op *Operation) haveQuery() bool { + // IDs can change or become known after an address is queued. Those candidates + // remain distinct in the distance-ordered set, but must not cause another query. + for op.unqueried.Len() != 0 { + next := op.closestUnqueried() + if _, queried := op.queried[addrString(next.Addr.String())]; !queried { + break + } + op.unqueried = op.unqueried.Delete(next) + } if op.unqueried.Len() == 0 { return false } diff --git a/traversal/operation_test.go b/traversal/operation_test.go index 129511619..1c875fb71 100644 --- a/traversal/operation_test.go +++ b/traversal/operation_test.go @@ -1,23 +1,67 @@ package traversal import ( + "context" + "net/netip" + "sync" "testing" "time" + + "github.com/anacrolix/dht/v2/int160" + "github.com/anacrolix/dht/v2/krpc" + "github.com/anacrolix/dht/v2/types" + "github.com/anacrolix/generics" ) -func TestDeferClose(t *testing.T) { - t.Parallel() - ch := make(chan struct{}) - done := make(chan struct{}) - go func() { - defer close(ch) - <-done - }() +func TestQueryEachEndpointOnce(t *testing.T) { + var mu sync.Mutex + calls := make(map[string]int) + started := make(chan struct{}) + var once sync.Once + op := Start(OperationInput{ + Alpha: 3, + DoQuery: func(_ context.Context, addr krpc.NodeAddr) QueryResult { + mu.Lock() + calls[addr.String()]++ + mu.Unlock() + once.Do(func() { close(started) }) + return QueryResult{} + }, + }) + t.Cleanup(func() { + op.Stop() + select { + case <-op.Stopped(): + case <-time.After(2 * time.Second): + t.Error("traversal did not stop") + } + }) + addr := krpc.NodeAddrPort{AddrPort: netip.MustParseAddrPort("127.0.0.1:6881")} + other := krpc.NodeAddrPort{AddrPort: netip.MustParseAddrPort("127.0.0.1:6882")} + var id1, id2 int160.T + id1.SetBit(1, true) + id2.SetBit(2, true) + op.AddNodes([]types.AddrMaybeId{ + {Addr: addr}, + {Addr: addr, Id: generics.Some(id1)}, + {Addr: addr, Id: generics.Some(id2)}, + {Addr: other, Id: generics.Some(id1)}, + }) + select { + case <-started: + case <-time.After(2 * time.Second): + t.Fatal("query did not start") + } select { - case <-ch: - t.Fatal("deferred close occurred prematurely") - case <-time.After(time.Second): + case <-op.Stalled(): + case <-time.After(2 * time.Second): + t.Fatal("traversal did not exhaust candidates") + } + mu.Lock() + defer mu.Unlock() + for _, endpoint := range []krpc.NodeAddrPort{addr, other} { + if got := calls[endpoint.String()]; got != 1 { + t.Errorf("queries to %s = %d, want 1", endpoint.String(), got) + } } - close(done) - <-ch } From fd77e0b220b23c8b50d57501b3750427a4ab78d2 Mon Sep 17 00:00:00 2001 From: shivam bansal Date: Wed, 23 Sep 2026 17:29:37 +0530 Subject: [PATCH 18/18] Cancel command DNS lookups and validate compact address marshaling Use the signal context for query and ping-nodes hostname resolution. Reject invalid generic and IPv4-family compact address encodings instead of emitting bytes the decoder refuses, and cover negative announce ports. --- announce_port_test.go | 1 + cmd/dht/main.go | 4 +-- cmd/dht/main_test.go | 66 ++++++++++++++++++++++++++++++++++++ cmd/dht/ping_test.go | 3 +- krpc/CompactIPv4NodeAddrs.go | 16 ++++++--- krpc/compact_test.go | 20 +++++------ krpc/nodeaddr.go | 5 +++ krpc/nodeaddr_test.go | 22 ++++++++++++ 8 files changed, 118 insertions(+), 19 deletions(-) diff --git a/announce_port_test.go b/announce_port_test.go index f9fce2924..4c6ad1f97 100644 --- a/announce_port_test.go +++ b/announce_port_test.go @@ -24,6 +24,7 @@ func TestAnnouncePeerPortValidation(t *testing.T) { }{ {name: "missing"}, {name: "zero", present: true}, + {name: "negative", port: -1, present: true}, {name: "too large", port: 65536, present: true}, {name: "maximum", port: 65535, present: true, valid: true}, {name: "implied overrides explicit", port: 65536, present: true, implied: true, valid: true}, diff --git a/cmd/dht/main.go b/cmd/dht/main.go index 04b4ec725..92f0f3668 100644 --- a/cmd/dht/main.go +++ b/cmd/dht/main.go @@ -176,7 +176,7 @@ func runMain() int { }{} sub.Parse(args.FromStruct(&subArgs)...) sub.Defer(func() error { - addr, err := net.ResolveUDPAddr(serverArgs.Network, subArgs.Addr) + addr, err := resolveUDPAddr(ctx, serverArgs.Network, subArgs.Addr) if err != nil { return err } @@ -197,7 +197,7 @@ func runMain() int { }{} sub.Parse(args.FromStruct(&subArgs)...) sub.Defer(func() error { - addr, err := net.ResolveUDPAddr(serverArgs.Network, subArgs.Addr) + addr, err := resolveUDPAddr(ctx, serverArgs.Network, subArgs.Addr) if err != nil { return err } diff --git a/cmd/dht/main_test.go b/cmd/dht/main_test.go index 480f430ce..57600f08c 100644 --- a/cmd/dht/main_test.go +++ b/cmd/dht/main_test.go @@ -1,9 +1,14 @@ package main import ( + "context" + "errors" + "net" "os" "strings" + "sync" "testing" + "time" "github.com/anacrolix/dht/v2" "github.com/anacrolix/dht/v2/krpc" @@ -49,3 +54,64 @@ func TestReturnedNodeAddressesRejectsMalformedAndErrorReplies(t *testing.T) { }) } } + +func TestQueryCommandsCancelDNS(t *testing.T) { + for _, command := range []string{"query", "ping-nodes"} { + t.Run(command, func(t *testing.T) { + oldArgs, oldResolver := os.Args, net.DefaultResolver + t.Cleanup(func() { os.Args, net.DefaultResolver = oldArgs, oldResolver }) + os.Args = []string{"dht", command, "blocked-command.invalid:6881", "find_node"} + started := make(chan struct{}) + release := make(chan struct{}) + var once sync.Once + net.DefaultResolver = &net.Resolver{ + PreferGo: true, + Dial: func(ctx context.Context, _, _ string) (net.Conn, error) { + once.Do(func() { close(started) }) + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-release: + return nil, errors.New("DNS released by test cleanup") + } + }, + } + done := make(chan int, 1) + finished := make(chan struct{}) + t.Cleanup(func() { + close(release) + select { + case <-finished: + case <-time.After(2 * time.Second): + t.Error("command did not stop during cleanup") + } + }) + go func() { + defer close(finished) + done <- runMain() + }() + select { + case <-started: + case code := <-done: + t.Fatalf("command exited with %d before DNS started", code) + case <-time.After(5 * time.Second): + t.Fatal("command did not reach DNS") + } + process, err := os.FindProcess(os.Getpid()) + if err != nil { + t.Fatal(err) + } + if err := process.Signal(os.Interrupt); err != nil { + t.Fatal(err) + } + select { + case code := <-done: + if code != 2 { + t.Fatalf("command exit = %d, want cancellation error exit 2", code) + } + case <-time.After(time.Second): + t.Fatal("command ignored cancellation during DNS resolution") + } + }) + } +} diff --git a/cmd/dht/ping_test.go b/cmd/dht/ping_test.go index 872f2225a..0477b4515 100644 --- a/cmd/dht/ping_test.go +++ b/cmd/dht/ping_test.go @@ -293,7 +293,8 @@ func TestContextResolverPreservesLiteralAddressSemantics(t *testing.T) { {"udp6", "[fe80::1%en0]:6881"}, {"udp", ":6881"}, {"udp4", "[::1]:6881"}, - {"invalid", "127.0.0.1:6881"}, + {"tcp", "127.0.0.1:6881"}, + {"tcp", "blocked-command.invalid:6881"}, } { t.Run(tc.network+"/"+tc.address, func(t *testing.T) { want, wantErr := net.ResolveUDPAddr(tc.network, tc.address) diff --git a/krpc/CompactIPv4NodeAddrs.go b/krpc/CompactIPv4NodeAddrs.go index 92092e35b..bc76cf494 100644 --- a/krpc/CompactIPv4NodeAddrs.go +++ b/krpc/CompactIPv4NodeAddrs.go @@ -1,16 +1,22 @@ package krpc +import "fmt" + type CompactIPv4NodeAddrs []NodeAddr func (CompactIPv4NodeAddrs) ElemSize() int { return 6 } func (me CompactIPv4NodeAddrs) MarshalBinary() ([]byte, error) { - return marshalBinarySlice(mapSlice(me, func(addr NodeAddr) NodeAddr { - if a := addr.IP.To4(); a != nil { - addr.IP = a + converted := make(CompactIPv4NodeAddrs, len(me)) + for i, addr := range me { + ip := addr.IP.To4() + if ip == nil { + return nil, fmt.Errorf("marshal compact IPv4 address from %v", addr.IP) } - return addr - })) + addr.IP = ip + converted[i] = addr + } + return marshalBinarySlice(converted) } func (me CompactIPv4NodeAddrs) MarshalBencode() ([]byte, error) { diff --git a/krpc/compact_test.go b/krpc/compact_test.go index 263ebe8fe..a719187e0 100644 --- a/krpc/compact_test.go +++ b/krpc/compact_test.go @@ -61,9 +61,9 @@ func TestNodeAddrIndex6(t *testing.T) { } var marshalIPv4SliceTests = []struct { - in CompactIPv4NodeAddrs - out []byte - panics bool + in CompactIPv4NodeAddrs + out []byte + wantErr bool }{ {[]NodeAddr{{net.IP{172, 16, 1, 1}, 3}}, []byte{172, 16, 1, 1, 0, 3}, false}, {[]NodeAddr{{net.IPv4(172, 16, 1, 1), 4}}, []byte{172, 16, 1, 1, 0, 4}, false}, @@ -77,15 +77,13 @@ var marshalIPv4SliceTests = []struct { func TestMarshalCompactIPv4NodeAddrs(t *testing.T) { for _, tc := range marshalIPv4SliceTests { - marshal := func() { - out, err := tc.in.MarshalBinary() - qt.Assert(t, qt.IsNil(err)) - qt.Check(t, qt.DeepEquals(out, tc.out), qt.Commentf("for input %v", tc.in)) - } - if tc.panics { - qt.Check(t, qt.PanicMatches(marshal, ".*")) + out, err := tc.in.MarshalBinary() + if tc.wantErr { + qt.Check(t, qt.IsNotNil(err), qt.Commentf("for input %v", tc.in)) + qt.Check(t, qt.HasLen(out, 0)) } else { - qt.Check(t, qt.Not(qt.PanicMatches(marshal, ".*"))) + qt.Check(t, qt.IsNil(err), qt.Commentf("for input %v", tc.in)) + qt.Check(t, qt.DeepEquals(out, tc.out), qt.Commentf("for input %v", tc.in)) } } } diff --git a/krpc/nodeaddr.go b/krpc/nodeaddr.go index d61aa899e..9591d146f 100644 --- a/krpc/nodeaddr.go +++ b/krpc/nodeaddr.go @@ -53,6 +53,11 @@ func (me *NodeAddr) UnmarshalBencode(b []byte) (err error) { } func (me NodeAddr) MarshalBinary() ([]byte, error) { + switch len(me.IP) { + case net.IPv4len, net.IPv6len: + default: + return nil, fmt.Errorf("marshal NodeAddr with %d IP bytes: need 4 or 16", len(me.IP)) + } b := make([]byte, 0, len(me.IP)+2) b = append(b, me.IP...) return binary.BigEndian.AppendUint16(b, uint16(me.Port)), nil diff --git a/krpc/nodeaddr_test.go b/krpc/nodeaddr_test.go index 5eae5b4a9..7f561a446 100644 --- a/krpc/nodeaddr_test.go +++ b/krpc/nodeaddr_test.go @@ -39,6 +39,28 @@ func TestNodeAddrBinaryRoundTrip(t *testing.T) { } } +func TestNodeAddrMarshalRejectsInvalidIPLengths(t *testing.T) { + for _, tc := range []struct { + name string + ip net.IP + }{ + {"nil", nil}, + {"short IPv4", make(net.IP, 3)}, + {"extra IPv4 byte", make(net.IP, 5)}, + {"short IPv6", make(net.IP, 15)}, + {"extra IPv6 byte", make(net.IP, 17)}, + } { + t.Run(tc.name, func(t *testing.T) { + addr := NodeAddr{IP: tc.ip, Port: 6881} + wire, err := addr.MarshalBinary() + qt.Assert(t, qt.IsNotNil(err)) + qt.Check(t, qt.HasLen(wire, 0)) + _, err = addr.MarshalBencode() + qt.Assert(t, qt.IsNotNil(err)) + }) + } +} + func TestNodeAddrUnmarshalBinaryRejectsInvalidLengths(t *testing.T) { tests := []struct { name string