* hole punching protocol
* implement the new retry logic (opening a new stream per hole punch)
* rename the holepunch.HolePunchService to holepunch.Service
* remove stream handler when closing
* remove misleading comment from protobuf, add link to spec
* remove unnecessary netNotifiee.HolePunchService
* simplify receiving from the timer channel
* don't defer the closing of the hole punching stream
* only accept hole punch streams from relayed peers
* refactor error logging
* fix incorrect counting of incoming hole punch attempts
* rename HolePunch to DirectConnect
* fix usage of the wait group to close the hole punch service
* use a gc to the garbage collect the holepunch tracer
* check directionality of connection when accepting the hole punch stream
* add comment why we only call Connect once
* move deduplication logic to the holepunch service
Co-authored-by: aarshkshah1992 <aarshkshah1992@gmail.com>
Unfortunately, lotus relies on this and we don't have a good alternative
at the moment.
1. The "correct" way to get the status is to subscribe to the
"discoverability" events and read the first event (you're guaranteed to
see a "current status" event). However, this is a bit annoying.
2. Ideally, you'd call host.Addrs() to get the list of "good" addresses.
Unfortunately, we don't feed enough information back into the Host from
AutoNAT for this to be truly useful (yet).
1. Don't write "nil". Not all writers handle this well.
2. Write/read an entire string.
3. Improve debuggability.
4. Move the sleep. We _don't_ need to wait for disconnect notifications.
We _do_ need to wait for the protocol event change to propagate.
fix#7947
move `BasicHost.AutoNat` to a private field (it has no public method and shouldn't be accessed afaik.
Instead add a setter for config that sets it while holding the address mutex to prevent reads of the
field at the same time.
This patch updates go-libp2p for the stream interface changes in go-libp2p-core
0.7.0. This is a _significant_ breaking change to streams and all users should
read https://github.com/libp2p/go-libp2p-core/releases/tag/v0.7.0. In practice,
this change should remove a significant footgun.
TL;DR:
* `Stream.Close` now behaves like `net.TCPConn.Close`.
* There is a new `Stream.CloseWrite` (send an EOF) and `Stream.CloseRead` (close
for reading), behaving like their counterparts in `net.TCPConn`.
Previously, we'd construct addresses like `/ip4/.../udp/...` instead of
`/ip4/.../udp/.../quic` because we'd use mapped addr (ip + transport + port)
instead of the full external address (ip + transport + port + other
transports...).
* fix: use all interface addresses when we can't find the default route
* fix: don't add advertise unspecified addresses
* fix: resolve addresses before looking up observed addresses
* fix: only advertise global unicast
* fix: filter link-local addresses from advertisement
* test: fix basic host addr tests
Before, we would:
1. Receive a "listen close" event from an event handler, after the teardown started.
2. Try to add a child process to handle the event. This would block because we
were in the teardown.
3. In the teardown, try to unregister the event handler and deadlock
I've now:
* Removed the teardown.
* Switched to a single event loop.
Ideally, we'd remove goprocess entirely. But we'd need to refactor natmgr.
fixes#933
We switched `listenAddrs` from the _interface_ addresses to the raw addresses we
were listening on. Unfortunately, we needed the resolved addresses later in the
function when resolving port mappings.
0. NEVER call `peerstore.SetProtocols(p)` (clear the protocol set). Given the
new identify events, if someone looked in the peerstore at the wrong time, they
could decide that the peer no longer speaks some protocol.
1. Reliably wait for identify before trying to open a stream. The old logic was
_really_ racy.
2. Avoids potentially calling identify on the same connection multiple times.
3. Calls identify as early as possible. Previously, we'd invoke identify on
inbound connections using an event that was only invoked _after_ all `Connected`
event handlers completed. Now we invoke identify from a `Connected` handler.