mirror of
				https://source.quilibrium.com/quilibrium/ceremonyclient.git
				synced 2025-11-04 07:07:26 +00:00 
			
		
		
		
	
		
			
				
	
	
		
			290 lines
		
	
	
		
			8.4 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
			
		
		
	
	
			290 lines
		
	
	
		
			8.4 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
package holepunch
 | 
						|
 | 
						|
import (
 | 
						|
	"context"
 | 
						|
	"errors"
 | 
						|
	"fmt"
 | 
						|
	"sync"
 | 
						|
	"time"
 | 
						|
 | 
						|
	"github.com/libp2p/go-libp2p/core/host"
 | 
						|
	"github.com/libp2p/go-libp2p/core/network"
 | 
						|
	"github.com/libp2p/go-libp2p/core/peer"
 | 
						|
	"github.com/libp2p/go-libp2p/p2p/protocol/holepunch/pb"
 | 
						|
	"github.com/libp2p/go-libp2p/p2p/protocol/identify"
 | 
						|
	"github.com/libp2p/go-msgio/pbio"
 | 
						|
	ma "github.com/multiformats/go-multiaddr"
 | 
						|
	manet "github.com/multiformats/go-multiaddr/net"
 | 
						|
)
 | 
						|
 | 
						|
//go:generate protoc --proto_path=$PWD:$PWD/../../.. --go_out=. --go_opt=Mpb/holepunch.proto=./pb pb/holepunch.proto
 | 
						|
 | 
						|
// ErrHolePunchActive is returned from DirectConnect when another hole punching attempt is currently running
 | 
						|
var ErrHolePunchActive = errors.New("another hole punching attempt to this peer is active")
 | 
						|
 | 
						|
const (
 | 
						|
	dialTimeout = 5 * time.Second
 | 
						|
	maxRetries  = 3
 | 
						|
)
 | 
						|
 | 
						|
// The holePuncher is run on the peer that's behind a NAT / Firewall.
 | 
						|
// It observes new incoming connections via a relay that it has a reservation with,
 | 
						|
// and initiates the DCUtR protocol with them.
 | 
						|
// It then first tries to establish a direct connection, and if that fails, it
 | 
						|
// initiates a hole punch.
 | 
						|
type holePuncher struct {
 | 
						|
	ctx       context.Context
 | 
						|
	ctxCancel context.CancelFunc
 | 
						|
 | 
						|
	host     host.Host
 | 
						|
	refCount sync.WaitGroup
 | 
						|
 | 
						|
	ids identify.IDService
 | 
						|
 | 
						|
	// active hole punches for deduplicating
 | 
						|
	activeMx sync.Mutex
 | 
						|
	active   map[peer.ID]struct{}
 | 
						|
 | 
						|
	closeMx sync.RWMutex
 | 
						|
	closed  bool
 | 
						|
 | 
						|
	tracer *tracer
 | 
						|
	filter AddrFilter
 | 
						|
}
 | 
						|
 | 
						|
func newHolePuncher(h host.Host, ids identify.IDService, tracer *tracer, filter AddrFilter) *holePuncher {
 | 
						|
	hp := &holePuncher{
 | 
						|
		host:   h,
 | 
						|
		ids:    ids,
 | 
						|
		active: make(map[peer.ID]struct{}),
 | 
						|
		tracer: tracer,
 | 
						|
		filter: filter,
 | 
						|
	}
 | 
						|
	hp.ctx, hp.ctxCancel = context.WithCancel(context.Background())
 | 
						|
	h.Network().Notify((*netNotifiee)(hp))
 | 
						|
	return hp
 | 
						|
}
 | 
						|
 | 
						|
func (hp *holePuncher) beginDirectConnect(p peer.ID) error {
 | 
						|
	hp.closeMx.RLock()
 | 
						|
	defer hp.closeMx.RUnlock()
 | 
						|
	if hp.closed {
 | 
						|
		return ErrClosed
 | 
						|
	}
 | 
						|
 | 
						|
	hp.activeMx.Lock()
 | 
						|
	defer hp.activeMx.Unlock()
 | 
						|
	if _, ok := hp.active[p]; ok {
 | 
						|
		return ErrHolePunchActive
 | 
						|
	}
 | 
						|
 | 
						|
	hp.active[p] = struct{}{}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// DirectConnect attempts to make a direct connection with a remote peer.
 | 
						|
// It first attempts a direct dial (if we have a public address of that peer), and then
 | 
						|
// coordinates a hole punch over the given relay connection.
 | 
						|
func (hp *holePuncher) DirectConnect(p peer.ID) error {
 | 
						|
	if err := hp.beginDirectConnect(p); err != nil {
 | 
						|
		return err
 | 
						|
	}
 | 
						|
 | 
						|
	defer func() {
 | 
						|
		hp.activeMx.Lock()
 | 
						|
		delete(hp.active, p)
 | 
						|
		hp.activeMx.Unlock()
 | 
						|
	}()
 | 
						|
 | 
						|
	return hp.directConnect(p)
 | 
						|
}
 | 
						|
 | 
						|
func (hp *holePuncher) directConnect(rp peer.ID) error {
 | 
						|
	// short-circuit check to see if we already have a direct connection
 | 
						|
	if getDirectConnection(hp.host, rp) != nil {
 | 
						|
		return nil
 | 
						|
	}
 | 
						|
 | 
						|
	// short-circuit hole punching if a direct dial works.
 | 
						|
	// attempt a direct connection ONLY if we have a public address for the remote peer
 | 
						|
	for _, a := range hp.host.Peerstore().Addrs(rp) {
 | 
						|
		if manet.IsPublicAddr(a) && !isRelayAddress(a) {
 | 
						|
			forceDirectConnCtx := network.WithForceDirectDial(hp.ctx, "hole-punching")
 | 
						|
			dialCtx, cancel := context.WithTimeout(forceDirectConnCtx, dialTimeout)
 | 
						|
 | 
						|
			tstart := time.Now()
 | 
						|
			// This dials *all* public addresses from the peerstore.
 | 
						|
			err := hp.host.Connect(dialCtx, peer.AddrInfo{ID: rp})
 | 
						|
			dt := time.Since(tstart)
 | 
						|
			cancel()
 | 
						|
 | 
						|
			if err != nil {
 | 
						|
				hp.tracer.DirectDialFailed(rp, dt, err)
 | 
						|
				break
 | 
						|
			}
 | 
						|
			hp.tracer.DirectDialSuccessful(rp, dt)
 | 
						|
			log.Debugw("direct connection to peer successful, no need for a hole punch", "peer", rp)
 | 
						|
			return nil
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	log.Debugw("got inbound proxy conn", "peer", rp)
 | 
						|
 | 
						|
	// hole punch
 | 
						|
	for i := 1; i <= maxRetries; i++ {
 | 
						|
		addrs, obsAddrs, rtt, err := hp.initiateHolePunch(rp)
 | 
						|
		if err != nil {
 | 
						|
			log.Debugw("hole punching failed", "peer", rp, "error", err)
 | 
						|
			hp.tracer.ProtocolError(rp, err)
 | 
						|
			return err
 | 
						|
		}
 | 
						|
		synTime := rtt / 2
 | 
						|
		log.Debugf("peer RTT is %s; starting hole punch in %s", rtt, synTime)
 | 
						|
 | 
						|
		// wait for sync to reach the other peer and then punch a hole for it in our NAT
 | 
						|
		// by attempting a connect to it.
 | 
						|
		timer := time.NewTimer(synTime)
 | 
						|
		select {
 | 
						|
		case start := <-timer.C:
 | 
						|
			pi := peer.AddrInfo{
 | 
						|
				ID:    rp,
 | 
						|
				Addrs: addrs,
 | 
						|
			}
 | 
						|
			hp.tracer.StartHolePunch(rp, addrs, rtt)
 | 
						|
			hp.tracer.HolePunchAttempt(pi.ID)
 | 
						|
			err := holePunchConnect(hp.ctx, hp.host, pi, true)
 | 
						|
			dt := time.Since(start)
 | 
						|
			hp.tracer.EndHolePunch(rp, dt, err)
 | 
						|
			if err == nil {
 | 
						|
				log.Debugw("hole punching with successful", "peer", rp, "time", dt)
 | 
						|
				hp.tracer.HolePunchFinished("initiator", i, addrs, obsAddrs, getDirectConnection(hp.host, rp))
 | 
						|
				return nil
 | 
						|
			}
 | 
						|
		case <-hp.ctx.Done():
 | 
						|
			timer.Stop()
 | 
						|
			return hp.ctx.Err()
 | 
						|
		}
 | 
						|
		if i == maxRetries {
 | 
						|
			hp.tracer.HolePunchFinished("initiator", maxRetries, addrs, obsAddrs, nil)
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return fmt.Errorf("all retries for hole punch with peer %s failed", rp)
 | 
						|
}
 | 
						|
 | 
						|
// initiateHolePunch opens a new hole punching coordination stream,
 | 
						|
// exchanges the addresses and measures the RTT.
 | 
						|
func (hp *holePuncher) initiateHolePunch(rp peer.ID) ([]ma.Multiaddr, []ma.Multiaddr, time.Duration, error) {
 | 
						|
	hpCtx := network.WithUseTransient(hp.ctx, "hole-punch")
 | 
						|
	sCtx := network.WithNoDial(hpCtx, "hole-punch")
 | 
						|
 | 
						|
	str, err := hp.host.NewStream(sCtx, rp, Protocol)
 | 
						|
	if err != nil {
 | 
						|
		return nil, nil, 0, fmt.Errorf("failed to open hole-punching stream: %w", err)
 | 
						|
	}
 | 
						|
	defer str.Close()
 | 
						|
 | 
						|
	addr, obsAddr, rtt, err := hp.initiateHolePunchImpl(str)
 | 
						|
	if err != nil {
 | 
						|
		log.Debugf("%s", err)
 | 
						|
		str.Reset()
 | 
						|
		return addr, obsAddr, rtt, err
 | 
						|
	}
 | 
						|
	return addr, obsAddr, rtt, err
 | 
						|
}
 | 
						|
 | 
						|
func (hp *holePuncher) initiateHolePunchImpl(str network.Stream) ([]ma.Multiaddr, []ma.Multiaddr, time.Duration, error) {
 | 
						|
	if err := str.Scope().SetService(ServiceName); err != nil {
 | 
						|
		return nil, nil, 0, fmt.Errorf("error attaching stream to holepunch service: %s", err)
 | 
						|
	}
 | 
						|
 | 
						|
	if err := str.Scope().ReserveMemory(maxMsgSize, network.ReservationPriorityAlways); err != nil {
 | 
						|
		return nil, nil, 0, fmt.Errorf("error reserving memory for stream: %s", err)
 | 
						|
	}
 | 
						|
	defer str.Scope().ReleaseMemory(maxMsgSize)
 | 
						|
 | 
						|
	w := pbio.NewDelimitedWriter(str)
 | 
						|
	rd := pbio.NewDelimitedReader(str, maxMsgSize)
 | 
						|
 | 
						|
	str.SetDeadline(time.Now().Add(StreamTimeout))
 | 
						|
 | 
						|
	// send a CONNECT and start RTT measurement.
 | 
						|
	obsAddrs := removeRelayAddrs(hp.ids.OwnObservedAddrs())
 | 
						|
	if hp.filter != nil {
 | 
						|
		obsAddrs = hp.filter.FilterLocal(str.Conn().RemotePeer(), obsAddrs)
 | 
						|
	}
 | 
						|
	if len(obsAddrs) == 0 {
 | 
						|
		return nil, nil, 0, errors.New("aborting hole punch initiation as we have no public address")
 | 
						|
	}
 | 
						|
 | 
						|
	start := time.Now()
 | 
						|
	if err := w.WriteMsg(&pb.HolePunch{
 | 
						|
		Type:     pb.HolePunch_CONNECT.Enum(),
 | 
						|
		ObsAddrs: addrsToBytes(obsAddrs),
 | 
						|
	}); err != nil {
 | 
						|
		str.Reset()
 | 
						|
		return nil, nil, 0, err
 | 
						|
	}
 | 
						|
 | 
						|
	// wait for a CONNECT message from the remote peer
 | 
						|
	var msg pb.HolePunch
 | 
						|
	if err := rd.ReadMsg(&msg); err != nil {
 | 
						|
		return nil, nil, 0, fmt.Errorf("failed to read CONNECT message from remote peer: %w", err)
 | 
						|
	}
 | 
						|
	rtt := time.Since(start)
 | 
						|
	if t := msg.GetType(); t != pb.HolePunch_CONNECT {
 | 
						|
		return nil, nil, 0, fmt.Errorf("expect CONNECT message, got %s", t)
 | 
						|
	}
 | 
						|
 | 
						|
	addrs := removeRelayAddrs(addrsFromBytes(msg.ObsAddrs))
 | 
						|
	if hp.filter != nil {
 | 
						|
		addrs = hp.filter.FilterRemote(str.Conn().RemotePeer(), addrs)
 | 
						|
	}
 | 
						|
 | 
						|
	if len(addrs) == 0 {
 | 
						|
		return nil, nil, 0, errors.New("didn't receive any public addresses in CONNECT")
 | 
						|
	}
 | 
						|
 | 
						|
	if err := w.WriteMsg(&pb.HolePunch{Type: pb.HolePunch_SYNC.Enum()}); err != nil {
 | 
						|
		return nil, nil, 0, fmt.Errorf("failed to send SYNC message for hole punching: %w", err)
 | 
						|
	}
 | 
						|
	return addrs, obsAddrs, rtt, nil
 | 
						|
}
 | 
						|
 | 
						|
func (hp *holePuncher) Close() error {
 | 
						|
	hp.closeMx.Lock()
 | 
						|
	hp.closed = true
 | 
						|
	hp.closeMx.Unlock()
 | 
						|
	hp.ctxCancel()
 | 
						|
	hp.refCount.Wait()
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
type netNotifiee holePuncher
 | 
						|
 | 
						|
func (nn *netNotifiee) Connected(_ network.Network, conn network.Conn) {
 | 
						|
	hs := (*holePuncher)(nn)
 | 
						|
 | 
						|
	// Hole punch if it's an inbound proxy connection.
 | 
						|
	// If we already have a direct connection with the remote peer, this will be a no-op.
 | 
						|
	if conn.Stat().Direction == network.DirInbound && isRelayAddress(conn.RemoteMultiaddr()) {
 | 
						|
		hs.refCount.Add(1)
 | 
						|
		go func() {
 | 
						|
			defer hs.refCount.Done()
 | 
						|
 | 
						|
			select {
 | 
						|
			// waiting for Identify here will allow us to access the peer's public and observed addresses
 | 
						|
			// that we can dial to for a hole punch.
 | 
						|
			case <-hs.ids.IdentifyWait(conn):
 | 
						|
			case <-hs.ctx.Done():
 | 
						|
				return
 | 
						|
			}
 | 
						|
 | 
						|
			_ = hs.DirectConnect(conn.RemotePeer())
 | 
						|
		}()
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (nn *netNotifiee) Disconnected(_ network.Network, v network.Conn) {}
 | 
						|
func (nn *netNotifiee) Listen(n network.Network, a ma.Multiaddr)       {}
 | 
						|
func (nn *netNotifiee) ListenClose(n network.Network, a ma.Multiaddr)  {}
 |