115 lines
2.3 KiB
Go
115 lines
2.3 KiB
Go
package peer
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/rand"
|
|
mrand "math/rand"
|
|
"net/netip"
|
|
"sync/atomic"
|
|
)
|
|
|
|
// A test peer.
|
|
type P struct {
|
|
cryptoKeys
|
|
RT *atomic.Pointer[routingTable]
|
|
Conn *TestUDPConn
|
|
IFace *TestIFace
|
|
ConnReader *connReader
|
|
IFReader *ifReader
|
|
}
|
|
|
|
func NewPeerForTesting(n *TestNetwork, ip byte, addr netip.AddrPort) P {
|
|
p := P{
|
|
cryptoKeys: generateKeys(),
|
|
RT: &atomic.Pointer[routingTable]{},
|
|
IFace: NewTestIFace(),
|
|
}
|
|
|
|
rt := newRoutingTable(ip, addr)
|
|
p.RT.Store(&rt)
|
|
p.Conn = n.NewUDPConn(addr)
|
|
//p.ConnWriter = NewConnWriter(p.Conn.WriteToUDPAddrPort, p.RT)
|
|
|
|
return p
|
|
}
|
|
|
|
func ConnectPeers(p1, p2 *P) {
|
|
rt1 := p1.RT.Load()
|
|
rt2 := p2.RT.Load()
|
|
|
|
ip1 := rt1.LocalIP
|
|
ip2 := rt2.LocalIP
|
|
|
|
rt1.Peers[ip2].Up = true
|
|
rt1.Peers[ip2].Direct = true
|
|
rt1.Peers[ip2].Relay = true
|
|
rt1.Peers[ip2].DirectAddr = rt2.LocalAddr
|
|
rt1.Peers[ip2].PubSignKey = p2.PubSignKey
|
|
rt1.Peers[ip2].ControlCipher = newControlCipher(p1.PrivKey, p2.PubKey)
|
|
rt1.Peers[ip2].DataCipher = newDataCipher()
|
|
|
|
rt2.Peers[ip1].Up = true
|
|
rt2.Peers[ip1].Direct = true
|
|
rt2.Peers[ip1].Relay = true
|
|
rt2.Peers[ip1].DirectAddr = rt1.LocalAddr
|
|
rt2.Peers[ip1].PubSignKey = p1.PubSignKey
|
|
rt2.Peers[ip1].ControlCipher = newControlCipher(p2.PrivKey, p1.PubKey)
|
|
rt2.Peers[ip1].DataCipher = rt1.Peers[ip2].DataCipher
|
|
}
|
|
|
|
func NewPeersForTesting() (p1, p2, p3 P) {
|
|
n := NewTestNetwork()
|
|
|
|
p1 = NewPeerForTesting(
|
|
n,
|
|
1,
|
|
netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 1}), 100))
|
|
|
|
p2 = NewPeerForTesting(
|
|
n,
|
|
2,
|
|
netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 2}), 200))
|
|
|
|
p3 = NewPeerForTesting(
|
|
n,
|
|
3,
|
|
netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 3}), 300))
|
|
|
|
ConnectPeers(&p1, &p2)
|
|
ConnectPeers(&p1, &p3)
|
|
ConnectPeers(&p2, &p3)
|
|
|
|
return
|
|
}
|
|
|
|
func RandPacket() []byte {
|
|
n := mrand.Intn(1200)
|
|
b := make([]byte, n)
|
|
rand.Read(b)
|
|
return b
|
|
}
|
|
|
|
func ModifyPacket(in []byte) []byte {
|
|
x := make([]byte, 1)
|
|
|
|
for {
|
|
rand.Read(x)
|
|
out := bytes.Clone(in)
|
|
idx := mrand.Intn(len(out))
|
|
if out[idx] != x[0] {
|
|
out[idx] = x[0]
|
|
return out
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
type UnknownControlPacket struct {
|
|
TraceID uint64
|
|
}
|
|
|
|
func (p UnknownControlPacket) Marshal(buf []byte) []byte {
|
|
return newBinWriter(buf).Byte(255).Uint64(p.TraceID).Build()
|
|
}
|