func TestProtoMatching(t *testing.T) {
tcp1, _ := ma.NewMultiaddr("/ip4/1.2.3.4/tcp/1234")
tcp2, _ := ma.NewMultiaddr("/ip4/1.2.3.4/tcp/2345")
tcp3, _ := ma.NewMultiaddr("/ip4/1.2.3.4/tcp/4567")
utp, _ := ma.NewMultiaddr("/ip4/1.2.3.4/udp/1234/utp")
if !identify.HasConsistentTransport(tcp1, []ma.Multiaddr{tcp2, tcp3, utp}) {
t.Fatal("expected match")
}
if identify.HasConsistentTransport(utp, []ma.Multiaddr{tcp2, tcp3}) {
t.Fatal("expected mismatch")
}
}
func assertMismatches(t *testing.T, p Pattern, args ...[]string) {
for _, argset := range args {
for _, s := range argset {
addr, err := ma.NewMultiaddr(s)
if err != nil {
t.Fatal(err)
}
if p.Matches(addr) {
t.Fatal("incorrect match!", s, p)
}
}
}
}
func assertMatches(t *testing.T, p Pattern, args ...[]string) {
t.Logf("testing assertions for %q", p)
for _, argset := range args {
for _, s := range argset {
addr, err := ma.NewMultiaddr(s)
if err != nil {
t.Fatal(err)
}
if !p.Matches(addr) {
t.Fatal("mismatch!", s, p)
}
}
}
}
func (m *mapping) ExternalAddr() (ma.Multiaddr, error) {
m.cacheLk.Lock()
ctime := m.cacheTime
cval := m.cached
m.cacheLk.Unlock()
if time.Since(ctime) < CacheTime {
return cval, nil
}
if m.ExternalPort() == 0 { // dont even try right now.
return nil, ErrNoMapping
}
m.nat.natmu.Lock()
ip, err := m.nat.nat.GetExternalAddress()
m.nat.natmu.Unlock()
if err != nil {
return nil, err
}
ipmaddr, err := manet.FromIP(ip)
if err != nil {
return nil, fmt.Errorf("error parsing ip")
}
// call m.ExternalPort again, as mapping may have changed under our feet. (tocttou)
extport := m.ExternalPort()
if extport == 0 {
return nil, ErrNoMapping
}
tcp, err := ma.NewMultiaddr(fmt.Sprintf("/%s/%d", m.Protocol(), extport))
if err != nil {
return nil, err
}
maddr2 := ipmaddr.Encapsulate(tcp)
m.cacheLk.Lock()
m.cached = maddr2
m.cacheTime = time.Now()
m.cacheLk.Unlock()
return maddr2, nil
}
func main() {
laddr, err := ma.NewMultiaddr("/ip4/0.0.0.0/tcp/5555")
if err != nil {
fatal(err)
}
// create a new swarm with a dummy peer ID, no private key, and no stream muxer
s := swarm.NewBlankSwarm(context.Background(), "bob", nil, nil)
// Add a TCP transport to it
s.AddTransport(tcpt.NewTCPTransport())
// Add an address to start listening on
err = s.AddListenAddr(laddr)
if err != nil {
fatal(err)
}
// Set a handler for incoming connections
s.SetConnHandler(func(c *swarm.Conn) {
fmt.Println("Got a new connection!")
defer c.Close()
buf := make([]byte, 1024)
for {
n, err := c.RawConn().Read(buf)
if err != nil {
fmt.Println(err)
return
}
fmt.Printf("read: %q\n", string(buf[:n]))
_, err = c.RawConn().Write(buf[:n])
if err != nil {
fmt.Println(err)
return
}
}
})
// Wait forever
<-make(chan bool)
}
// create a 'Host' with a random peer to listen on the given address
func makeBasicHost(listen string, secio bool) (host.Host, error) {
addr, err := ma.NewMultiaddr(listen)
if err != nil {
return nil, err
}
ps := pstore.NewPeerstore()
var pid peer.ID
if secio {
ident, err := testutil.RandIdentity()
if err != nil {
return nil, err
}
ident.PrivateKey()
ps.AddPrivKey(ident.ID(), ident.PrivateKey())
ps.AddPubKey(ident.ID(), ident.PublicKey())
pid = ident.ID()
} else {
fakepid, err := testutil.RandPeerID()
if err != nil {
return nil, err
}
pid = fakepid
}
ctx := context.Background()
// create a new swarm to be used by the service host
netw, err := swarm.NewNetwork(ctx, []ma.Multiaddr{addr}, pid, ps, nil)
if err != nil {
return nil, err
}
log.Printf("I am %s/ipfs/%s\n", addr, pid.Pretty())
return bhost.New(netw), nil
}
func main() {
golog.SetAllLoggers(gologging.INFO) // Change to DEBUG for extra info
listenF := flag.Int("l", 0, "wait for incoming connections")
target := flag.String("d", "", "target peer to dial")
secio := flag.Bool("secio", false, "enable secio")
flag.Parse()
if *listenF == 0 {
log.Fatal("Please provide a port to bind on with -l")
}
listenaddr := fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", *listenF)
ha, err := makeBasicHost(listenaddr, *secio)
if err != nil {
log.Fatal(err)
}
// Set a stream handler on host A
ha.SetStreamHandler("/echo/1.0.0", func(s net.Stream) {
log.Println("Got a new stream!")
defer s.Close()
doEcho(s)
})
if *target == "" {
log.Println("listening for connections")
select {} // hang forever
}
// This is where the listener code ends
ipfsaddr, err := ma.NewMultiaddr(*target)
if err != nil {
log.Fatalln(err)
}
pid, err := ipfsaddr.ValueForProtocol(ma.P_IPFS)
if err != nil {
log.Fatalln(err)
}
peerid, err := peer.IDB58Decode(pid)
if err != nil {
log.Fatalln(err)
}
tptaddr := strings.Split(ipfsaddr.String(), "/ipfs/")[0]
// This creates a MA with the "/ip4/ipaddr/tcp/port" part of the target
tptmaddr, err := ma.NewMultiaddr(tptaddr)
if err != nil {
log.Fatalln(err)
}
// We need to add the target to our peerstore, so we know how we can
// contact it
ha.Peerstore().AddAddr(peerid, tptmaddr, peerstore.PermanentAddrTTL)
log.Println("opening stream")
// make a new stream from host B to host A
// it should be handled on host A by the handler we set above
s, err := ha.NewStream(context.Background(), peerid, "/echo/1.0.0")
if err != nil {
log.Fatalln(err)
}
_, err = s.Write([]byte("Hello, world!"))
if err != nil {
log.Fatalln(err)
}
out, err := ioutil.ReadAll(s)
if err != nil {
log.Fatalln(err)
}
log.Printf("read reply: %q\n", out)
}
// TestObsAddrSet
func TestObsAddrSet(t *testing.T) {
m := func(s string) ma.Multiaddr {
m, err := ma.NewMultiaddr(s)
if err != nil {
t.Error(err)
}
return m
}
addrsMarch := func(a, b []ma.Multiaddr) bool {
for _, aa := range a {
found := false
for _, bb := range b {
if aa.Equal(bb) {
found = true
break
}
}
if !found {
return false
}
}
return true
}
a1 := m("/ip4/1.2.3.4/tcp/1231")
a2 := m("/ip4/1.2.3.4/tcp/1232")
a3 := m("/ip4/1.2.3.4/tcp/1233")
a4 := m("/ip4/1.2.3.4/tcp/1234")
a5 := m("/ip4/1.2.3.4/tcp/1235")
a6 := m("/ip4/1.2.3.6/tcp/1236")
a7 := m("/ip4/1.2.3.7/tcp/1237")
oas := ObservedAddrSet{}
if !addrsMarch(oas.Addrs(), nil) {
t.Error("addrs should be empty")
}
oas.Add(a1, a4)
oas.Add(a2, a4)
oas.Add(a3, a4)
// these are all different so we should not yet get them.
if !addrsMarch(oas.Addrs(), nil) {
t.Error("addrs should _still_ be empty (once)")
}
// same observer, so should not yet get them.
oas.Add(a1, a4)
oas.Add(a2, a4)
oas.Add(a3, a4)
if !addrsMarch(oas.Addrs(), nil) {
t.Error("addrs should _still_ be empty (same obs)")
}
// different observer, but same observer group.
oas.Add(a1, a5)
oas.Add(a2, a5)
oas.Add(a3, a5)
if !addrsMarch(oas.Addrs(), nil) {
t.Error("addrs should _still_ be empty (same obs group)")
}
oas.Add(a1, a6)
if !addrsMarch(oas.Addrs(), []ma.Multiaddr{a1}) {
t.Error("addrs should only have a1")
}
oas.Add(a2, a5)
oas.Add(a1, a5)
oas.Add(a1, a5)
oas.Add(a2, a6)
oas.Add(a1, a6)
oas.Add(a1, a6)
oas.Add(a2, a7)
oas.Add(a1, a7)
oas.Add(a1, a7)
if !addrsMarch(oas.Addrs(), []ma.Multiaddr{a1, a2}) {
t.Error("addrs should only have a1, a2")
}
// change the timeout constant so we can time it out.
oas.SetTTL(time.Millisecond * 200)
<-time.After(time.Millisecond * 210)
if !addrsMarch(oas.Addrs(), []ma.Multiaddr{nil}) {
t.Error("addrs should have timed out")
}
}
func main() {
listenF := flag.Int("l", 0, "wait for incoming connections")
target := flag.String("d", "", "target peer to dial")
secio := flag.Bool("secio", false, "enable secio")
flag.Parse()
listenaddr := fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", *listenF)
ha, err := makeDummyHost(listenaddr, *secio)
if err != nil {
log.Fatal(err)
}
// Set a stream handler on host A
ha.SetStreamHandler("/echo/1.0.0", func(s net.Stream) {
log.Println("Got a new stream!")
defer s.Close()
})
if *target == "" {
log.Println("listening for connections...")
select {} // hang forever
}
ipfsaddr, err := ma.NewMultiaddr(*target)
if err != nil {
log.Fatalln(err)
}
pid, err := ipfsaddr.ValueForProtocol(ma.P_IPFS)
if err != nil {
log.Fatalln(err)
}
peerid, err := peer.IDB58Decode(pid)
if err != nil {
log.Fatalln(err)
}
tptaddr := strings.Split(ipfsaddr.String(), "/ipfs/")[0]
tptmaddr, err := ma.NewMultiaddr(tptaddr)
if err != nil {
log.Fatalln(err)
}
pi := pstore.PeerInfo{
ID: peerid,
Addrs: []ma.Multiaddr{tptmaddr},
}
log.Println("connecting to target")
err = ha.Connect(context.Background(), pi)
if err != nil {
log.Fatalln(err)
}
log.Println("opening stream...")
// make a new stream from host B to host A
// it should be handled on host A by the handler we set
s, err := ha.NewStream(context.Background(), peerid, "/hello/1.0.0")
if err != nil {
log.Fatalln(err)
}
_, err = s.Write([]byte("Hello world of peer two peer"))
if err != nil {
log.Fatalln(err)
}
out, err := ioutil.ReadAll(s)
if err != nil {
log.Fatalln(err)
}
log.Println("GOT: ", string(out))
}