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..7d3ce96c7 --- /dev/null +++ b/.golangci.yml @@ -0,0 +1,48 @@ +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 + +formatters: + enable: + - gofmt + - goimports diff --git a/announce.go b/announce.go index 7cbb356cd..db012078c 100644 --- a/announce.go +++ b/announce.go @@ -1,7 +1,5 @@ package dht -// get_peers and announce_peers. - import ( "context" "fmt" @@ -45,7 +43,7 @@ func (a *Announce) NumContacted() uint32 { } func (a *Announce) TraversalStats() TraversalStats { - return *a.traversal.Stats() + return a.traversal.LoadStats() } // Server.Announce option @@ -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{ @@ -99,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, @@ -108,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() @@ -130,14 +128,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() } @@ -174,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/announce_port_test.go b/announce_port_test.go new file mode 100644 index 000000000..4c6ad1f97 --- /dev/null +++ b/announce_port_test.go @@ -0,0 +1,96 @@ +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: "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}, + } { + 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/announce_test.go b/announce_test.go index a614348dd..5b5e1db0e 100644 --- a/announce_test.go +++ b/announce_test.go @@ -1,7 +1,6 @@ package dht import ( - "context" "crypto/rand" "net" "regexp" @@ -39,21 +38,43 @@ 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 -// 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") + defer silent.Close() + 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()), + }) + qt.Assert(t, qt.IsNil(err)) + defer s.Close() + a, err := s.AnnounceTraversal([20]byte{9}) + qt.Assert(t, qt.IsNil(err)) + 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 new file mode 100644 index 000000000..8c9c6baec --- /dev/null +++ b/bep44/cas_test.go @@ -0,0 +1,111 @@ +package bep44 + +import ( + "crypto/ed25519" + "errors" + "testing" + "time" +) + +// 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) { + 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{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{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{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) + } +} + +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 TestWrapperConcurrentCASAllowsOneUpdate(t *testing.T) { + _, priv, err := ed25519.GenerateKey(nil) + if err != nil { + t.Fatal(err) + } + initial, err := NewItem("initial", nil, 1, 0, priv) + if err != nil { + t.Fatal(err) + } + first, err := NewItem("first", nil, 2, 1, priv) + if err != nil { + t.Fatal(err) + } + 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) + } + 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 f87314102..f393b9cad 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 { @@ -149,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), @@ -164,14 +173,5 @@ 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 { - return ErrCasHashMismatched - } - return nil } diff --git a/bep44/memory.go b/bep44/memory.go index fce3b2e41..535e1bf36 100644 --- a/bep44/memory.go +++ b/bep44/memory.go @@ -19,17 +19,19 @@ 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 } 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/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/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/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..01678bbde 100644 --- a/bootstrap.go +++ b/bootstrap.go @@ -31,20 +31,18 @@ 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.) + nodes, err := s.TraversalStartingNodes() + if err != nil { + return + } t := traversal.Start(traversal.OperationInput{ 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, }) - nodes, err := s.TraversalStartingNodes() - if err != nil { - return - } t.AddNodes(nodes) s.mu.Lock() s.lastBootstrap = time.Now() @@ -54,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.LoadStats(), err } diff --git a/bugs_test.go b/bugs_test.go new file mode 100644 index 000000000..a937b3679 --- /dev/null +++ b/bugs_test.go @@ -0,0 +1,133 @@ +package dht + +import ( + "context" + "errors" + "net" + "net/netip" + "sync" + "testing" + "time" + + "github.com/anacrolix/torrent/iplist" + "golang.org/x/time/rate" + + "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, + SendLimiter: rate.NewLimiter(rate.Inf, 0), + 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 !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 } + +func (swapList) Lookup(net.IP) (iplist.Range, bool) { return iplist.Range{}, false } +func (s swapList) NumRanges() int { return s.n } + +// 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"), + 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() +} + +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, + SendLimiter: rate.NewLimiter(rate.Inf, 0), + 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..ae218a66d --- /dev/null +++ b/callback_test.go @@ -0,0 +1,505 @@ +package dht + +import ( + "context" + "net" + "sync/atomic" + "testing" + "time" + + "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" + 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 + cfg.SendLimiter = rate.NewLimiter(rate.Inf, 0) + s, err := NewServer(cfg) + 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 +} + +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) { + store := new(callbackTestStore) + cfg := NewDefaultServerConfig() + 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 = newCallbackTestServer(t, cfg) + + 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 + 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", + Y: "q", + 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() +} + +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() + called := false + cfg.PeerStore = &callbackTestPeerStore{get: func(peer_store.InfoHash) []krpc.NodeAddr { + _ = s.Stats() + called = true + 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}}, + }) + if !called { + t.Fatal("get_peers did not exercise the reentrant peer store") + } + 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{}) + 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 { + 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") + } + if lookups.Load() == 0 { + t.Fatal("receive path skipped the reentrant blocklist lookup") + } + 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 + calls *atomic.Uint32 +} + +func (m callbackTestMarshaler) MarshalBencode() ([]byte, error) { + _ = m.server.Stats() + m.calls.Add(1) + return []byte("i1e"), nil +} + +func TestStoreValueMarshalerCanReenterStats(t *testing.T) { + store := new(callbackTestStore) + cfg := NewDefaultServerConfig() + cfg.Store = store + s := newCallbackTestServer(t, cfg) + 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/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/close_test.go b/cmd/dht-server/close_test.go new file mode 100644 index 000000000..6b4112ba0 --- /dev/null +++ b/cmd/dht-server/close_test.go @@ -0,0 +1,139 @@ +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) { + 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) + } + defer conn.Close() + err = initServer(conn) + if err == nil { + t.Fatal("expected missing table file") + } + 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 a811e6282..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" @@ -32,6 +33,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,36 +75,28 @@ 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, 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() + 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) } @@ -89,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-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/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 75d0a9cc0..92f0f3668 100644 --- a/cmd/dht/main.go +++ b/cmd/dht/main.go @@ -31,6 +31,26 @@ type serverParams struct { } func main() { + if code := runMain(); code != 0 { + os.Exit(code) + } +} + +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) ctx, stopSignalNotify := signal.NotifyContext(ctx, os.Interrupt) @@ -40,194 +60,209 @@ 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 { + 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)...) + if err := validateMutableKey(true, subArgs.Key.Bytes); 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) + 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 - }) - 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 } - } - conn, err := net.ListenPacket(serverArgs.Network, ":0") - if err != nil { - err = fmt.Errorf("listening: %w", err) - return + return + }), + ).RanSubCmd { + return errors.New("expected subcommand") } - cfg.Conn = conn - all, err := publicip.Get(context.TODO(), serverArgs.Network) - if err == nil { - cfg.PublicIP = all[0] - log.Printf("public ip: %q", cfg.PublicIP) - cfg.NoSecurity = !serverArgs.Secure + 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)...) + 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 } - if len(serverArgs.BootstrapAddr) != 0 { - cfg.StartingNodes = func() ([]dht.Addr, error) { - return dht.ResolveHostPorts(serverArgs.BootstrapAddr) - } + 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, + })) } - s, err = dht.NewServer(cfg) - if err != nil { - return err + if subArgs.Scrape { + announceOpts = append(announceOpts, dht.Scrape()) } - 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 := resolveUDPAddr(ctx, 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 := resolveUDPAddr(ctx, 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) + nodes, err := returnedNodeAddresses(res) + if err != nil { + return err + } + return ping(ctx, pingArgs{ + Network: serverArgs.Network, + Nodes: nodes, + 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/main_test.go b/cmd/dht/main_test.go new file mode 100644 index 000000000..57600f08c --- /dev/null +++ b/cmd/dht/main_test.go @@ -0,0 +1,117 @@ +package main + +import ( + "context" + "errors" + "net" + "os" + "strings" + "sync" + "testing" + "time" + + "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) + } + }) + } +} + +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.go b/cmd/dht/ping.go index def989b56..c9ae63bb0 100644 --- a/cmd/dht/ping.go +++ b/cmd/dht/ping.go @@ -2,10 +2,10 @@ package main import ( - "errors" + "context" "fmt" - "log" "net" + "net/netip" "sync" "time" @@ -19,55 +19,110 @@ 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 { - var wg sync.WaitGroup - defaults := dht.DefaultGlobalBootstrapHostPorts - if !args.Defaults { - defaults = nil +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) } - for _, a := range append(args.Nodes, defaults...) { - func(a string) { - ua, err := net.ResolveUDPAddr(args.Network, a) - if err != nil { - log.Fatal(err) + ip := ips[0] + if ipNetwork == "ip" { + for _, candidate := range ips { + if candidate.Is4() { + ip = candidate + break } - 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) + } + } + 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...) + } + var wg sync.WaitGroup + for _, a := range nodes { + if err := ctx.Err(); err != nil { + cancel() + wg.Wait() + return err + } + ua, err := resolveUDPAddr(ctx, 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() { + addr := dht.NewAddr(ua) + res := s.Query(ctx, addr, "ping", dht.QueryInput{}) + if err := res.ToError(); err != nil { + fmt.Printf("%s: %s: %s\n", a, time.Since(started), err) + return + } + id := res.Reply.SenderID() + if id == nil { + 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 = '✔' + } + 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{}) - if args.Timeout != 0 { - go func() { - time.Sleep(args.Timeout) - close(timeout) - }() - } select { case <-done: + if err := ctx.Err(); err != nil { + return err + } return nil - case <-timeout: - return errors.New("timed out") + case <-ctx.Done(): + cancel() + <-done + return ctx.Err() } } diff --git a/cmd/dht/ping_test.go b/cmd/dht/ping_test.go new file mode 100644 index 000000000..0477b4515 --- /dev/null +++ b/cmd/dht/ping_test.go @@ -0,0 +1,310 @@ +package main + +import ( + "context" + "errors" + "net" + "sync" + "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(context.Background(), pingArgs{ + Network: "udp", + Nodes: []string{pc.LocalAddr().String()}, + }, s) + if err != nil { + 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) + } +} + +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"}, + {"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) + 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-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 81b38893e..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) @@ -41,7 +52,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 @@ -51,21 +62,15 @@ func put(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 { - 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, @@ -82,7 +87,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/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) + } +} 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..3ac31b747 100644 --- a/dht_test.go +++ b/dht_test.go @@ -6,6 +6,8 @@ import ( "io" "math/big" "net" + "runtime" + "strings" "testing" "time" @@ -169,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)) @@ -177,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" { @@ -244,24 +246,57 @@ func TestBadGetPeersResponse(t *testing.T) { }) qt.Assert(t, qt.IsNil(err)) defer s.Close() - go func() { - b := make([]byte, 1024) - n, addr, err := pc.ReadFrom(b) - qt.Assert(t, qt.IsNil(err)) - var rm krpc.Msg - bencode.Unmarshal(b[:n], &rm) - m := krpc.Msg{ - R: &krpc.Return{}, - T: rm.T, + 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") } - b, err = bencode.Marshal(m) - qt.Assert(t, qt.IsNil(err)) - pc.WriteTo(b, addr) + }) + replied := make(chan error, 1) + go func() { + defer close(responderDone) + 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") } } @@ -282,19 +317,27 @@ func TestBootstrapRace(t *testing.T) { qt.Assert(t, qt.IsNil(err)) defer s.Close() go func() { - for i := 0; i < defaultMaxQuerySends-1; i++ { - remotePc.ReadFrom(nil) + for range defaultMaxQuerySends - 1 { + _, _, _ = 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 +385,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 { @@ -353,3 +398,81 @@ 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)) + t.Cleanup(a.Close) + 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/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..80c851635 100644 --- a/exts/getput/getput.go +++ b/exts/getput/getput.go @@ -24,11 +24,32 @@ 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 r.V == nil { + return GetResult{}, false + } + 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, ) ( 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, @@ -41,43 +62,24 @@ 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() op.AddNodes(nodes) return } @@ -93,70 +95,87 @@ 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() - stats = op.Stats() + <-op.Stopped() + loaded := op.LoadStats() + stats = &loaded return } 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, ) ( 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() + loaded := op.LoadStats() + stats = &loaded + 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) { - wg.Add(1) - go func() { - defer wg.Done() - // This is enforced by startGetTraversal. + 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{}) err := res.ToError() @@ -165,9 +184,17 @@ notDone: } else { logger.Levelf(log.Debug, "put to %v [token=%q]", elem.Addr, token) } - }() + results <- err + }) }) wg.Wait() - stats = op.Stats() - 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 new file mode 100644 index 000000000..89285ee1f --- /dev/null +++ b/exts/getput/getput_test.go @@ -0,0 +1,284 @@ +package getput + +import ( + "context" + "crypto/ed25519" + "crypto/sha1" + "errors" + "net" + "runtime" + "strings" + "testing" + "time" + + "github.com/anacrolix/torrent/bencode" + + "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) +} + +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)) + }) + } +} + +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/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= 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/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/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/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/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..9591d146f 100644 --- a/krpc/nodeaddr.go +++ b/krpc/nodeaddr.go @@ -1,7 +1,6 @@ package krpc import ( - "bytes" "encoding/binary" "fmt" "net" @@ -33,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]) @@ -52,10 +53,14 @@ 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 + 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 } func (me NodeAddr) MarshalBencode() ([]byte, error) { diff --git a/krpc/nodeaddr_test.go b/krpc/nodeaddr_test.go index 1a55b676d..7f561a446 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,54 @@ 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 + 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 +99,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/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/lifecycle_test.go b/lifecycle_test.go new file mode 100644 index 000000000..30bbc1d91 --- /dev/null +++ b/lifecycle_test.go @@ -0,0 +1,108 @@ +package dht + +import ( + "context" + "errors" + "runtime" + "strings" + "testing" + "time" + + "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. +func numTraversalGoroutines() (num int) { + 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, "dht/v2/traversal.") { + num++ + } + } + return +} + +// 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) +} + +// 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("127.0.0.1:0") + t.Cleanup(func() { _ = silent.Close() }) + cfg := NewDefaultServerConfig() + cfg.Conn = mustListen("127.0.0.1:0") + cfg.Logger = log.Default.WithNames(t.Name()) + 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)) + 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)) +} 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..b885ed0c9 100644 --- a/server.go +++ b/server.go @@ -1,6 +1,7 @@ package dht import ( + "bytes" "context" "crypto/rand" "errors" @@ -10,6 +11,7 @@ import ( "runtime/pprof" "slices" "strings" + "sync/atomic" "text/tabwriter" "time" @@ -20,7 +22,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 +46,16 @@ 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 + // 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 - sendLimit *rate.Limiter lastBootstrap time.Time bootstrappingNow bool @@ -81,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) { @@ -224,8 +231,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, @@ -240,6 +246,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 @@ -252,10 +262,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) } } @@ -266,18 +273,30 @@ func (s *Server) String() string { } // Packets to and from any address matching a range in the list are dropped. +// 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 { + 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) { - // log.Printf("got packet %q", b) if len(b) < 2 || b[0] != 'd' { // KRPC messages are bencoded dicts. readNotKRPCDict.Add(1) @@ -285,31 +304,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() @@ -319,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 } @@ -328,19 +335,40 @@ 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) - // 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++ }) } +// 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 { + 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 { @@ -360,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 } @@ -380,10 +403,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 } @@ -396,37 +420,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,228 +444,239 @@ 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 }) } - 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 }) + if shouldReturnNodes6(wants, querySource.IP()) { + r.Nodes6 = s.closestGoodNodeInfos(8, targetInt160, func(krpc.NodeAddr) bool { return true }) } - if shouldReturnNodes6(queryMsg.A.Want, querySource.IP()) { - r.Nodes6 = s.makeReturnNodes(target, func(krpc.NodeAddr) bool { return true }) +} + +// 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 + } + return krpc.Error{ + Code: krpc.ErrorCodeGenericError, + Msg: err.Error(), } - return nil } 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) } - }() - s.updateNode(source, m.SenderID(), !m.ReadOnly, func(n *node) { + 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 { - propagate := s.config.OnQuery(&m, source.Raw()) - if !propagate { + if onQuery := s.config.OnQuery; onQuery != nil { + propagate := false + s.withServerLockReleased(func() { + propagate = onQuery(&m, source.Raw()) + }) + if s.closed.IsSet() || !propagate { 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 { + 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 + } + 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 || 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) + } + 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 + } + 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 + } + 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(), +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 + 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 + } + if err != nil { + s.sendError(source, t, storeError(err)) + return + } + r.Seq = &item.Seq + if args.Seq == nil || item.Seq > *args.Seq { + var encodedValue []byte + s.withServerLockReleased(func() { + encodedValue = bencode.MustMarshal(item.V) }) - 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 + if s.closed.IsSet() { + return } - - r.V = bencode.MustMarshal(item.V) + r.V = encodedValue 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) { @@ -688,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) } @@ -772,7 +793,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 { @@ -782,26 +803,21 @@ 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() { - 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.ipBlockList; 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 } - // s.config.Logger.WithValues(log.Debug).Printf("writing to %s: %q", node.String(), b) + if s.closed.IsSet() { + return false, errors.New("server is closed") + } if rate { if wait { err = s.config.SendLimiter.Wait(ctx) @@ -825,10 +841,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 +860,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 +921,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 +939,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 +984,21 @@ 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))) + // 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() { - 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 +1027,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 +1085,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 @@ -1137,15 +1136,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. @@ -1179,6 +1181,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() @@ -1225,7 +1229,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 +1277,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 +1309,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 @@ -1330,7 +1320,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{ @@ -1342,9 +1332,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) @@ -1353,8 +1343,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: @@ -1362,10 +1355,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() @@ -1375,7 +1369,7 @@ wait: } s.mu.RLock() } - return op.Stats() + return } func (s *Server) shouldBootstrap() bool { @@ -1393,14 +1387,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,14 +1418,11 @@ 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 } - 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() @@ -1464,7 +1453,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,19 +1475,13 @@ 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 } - -// func (s *Server) refreshBucket(bucketIndex int) { -// targetId := s.table.randomIdForBucket(bucketIndex) -// } diff --git a/server_test.go b/server_test.go index 736a3e149..2471635a3 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,106 @@ 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} + cfg.NoSecurity = true + s, err := NewServer(cfg) + qt.Assert(t, qt.IsNil(err)) + 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 ids { + 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, target.AsByteArray(), []krpc.Want{krpc.WantNodes}, + NewAddr(&net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1})) + s.mu.Unlock() + 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 { 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/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) + } +} diff --git a/table.go b/table.go index 0d3398a3e..23e22170a 100644 --- a/table.go +++ b/table.go @@ -3,6 +3,7 @@ package dht import ( "errors" "fmt" + "slices" "github.com/anacrolix/dht/v2/int160" ) @@ -27,15 +28,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,20 +82,23 @@ 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) + if k <= 0 { + return nil + } + // 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) } - }(); bi >= 0 && len(ret) < k; bi-- { - for n := range tbl.buckets[bi].nodes { - if filter(n) { - ret = append(ret, n) - } + 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 } - } - // TODO: Keep only the closest. + return a.Addr.KRPC().ToNodeAddrPort().Compare(b.Addr.KRPC().ToNodeAddrPort()) + }) if len(ret) > k { ret = ret[:k] } diff --git a/table_test.go b/table_test.go index 96efcb41e..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" @@ -61,3 +63,147 @@ func TestRandomIdInBucket(t *testing.T) { qt.Assert(t, qt.Equals(tbl.bucketIndex(id), i)) } } + +// 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() + 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) + } + 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. + 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) + } + // 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 + } + 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) + } + } + }) + } +} + +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])) + } + }) + } +} 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/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/loadstats_test.go b/traversal/loadstats_test.go new file mode 100644 index 000000000..76790289b --- /dev/null +++ b/traversal/loadstats_test.go @@ -0,0 +1,41 @@ +package traversal + +import ( + "runtime" + "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 + 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 range updates { + atomic.AddUint32(&op.stats.NumAddrsTried, 1) + atomic.AddUint32(&op.stats.NumResponses, 1) + runtime.Gosched() + } + }) + <-started + var last Stats + 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() + } + wg.Wait() + 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 90abd8807..3adcbd1ee 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() @@ -90,21 +85,28 @@ 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() { 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 @@ -169,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 } @@ -210,7 +221,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) { @@ -225,8 +236,13 @@ func (op *Operation) addClosest(node krpc.NodeInfo, data interface{}) { }) } +// 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() { @@ -240,7 +256,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/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 } 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") } }