manet "QmRCPT5WRph8aWXmaT2Rfn6ac98YRUUJnNURpD3hNAWp4f/go-multiaddr-net" ma "QmbWxL1aXQhBjc1XGjGF1f2KGBMCBYSuT2ThA8YXnXJK83/go-multiaddr" goprocess "QmSir6qPL1tjuxd8LkR8VZq6v625ExAUVs2eCLeqQuaPGU/goprocess" periodic "QmSir6qPL1tjuxd8LkR8VZq6v625ExAUVs2eCLeqQuaPGU/goprocess/periodic" notifier "QmUtEiB6DmXs7eLJiwS9YFyTAtptqzaWutxCsjHy7UKEgo/go-notifier" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" nat "github.com/fd/go-nat" ) var ( // ErrNoMapping signals no mapping exists for an address ErrNoMapping = errors.New("mapping not established") ) var log = logging.Logger("nat") // MappingDuration is a default port mapping duration. // Port mappings are renewed every (MappingDuration / 3) const MappingDuration = time.Second * 60 // CacheTime is the time a mapping will cache an external address for const CacheTime = time.Second * 15 // DiscoverNAT looks for a NAT device in the network and // returns an object that can manage port mappings. func DiscoverNAT() *NAT { nat, err := nat.DiscoverGateway() if err != nil { log.Debug("DiscoverGateway error:", err) return nil
"errors" "fmt" "io" "sync" "time" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" context "QmacZi9WygGK7Me8mH53pypyscHzU386aUZXpr28GZgUct/context" u "Qmah3kfjwhVxBM4qGnrqJTqGzrF8svwByyhExPipA2U6LE/go-ipfs-util" ci "github.com/ipfs/go-libp2p/p2p/crypto" pb "github.com/ipfs/go-libp2p/p2p/crypto/secio/pb" peer "github.com/ipfs/go-libp2p/p2p/peer" msgio "github.com/jbenet/go-msgio" ) var log = logging.Logger("secio") // ErrUnsupportedKeyType is returned when a private key cast/type switch fails. var ErrUnsupportedKeyType = errors.New("unsupported key type") // ErrClosed signals the closing of a connection. var ErrClosed = errors.New("connection closed") // ErrEcho is returned when we're attempting to handshake with the same keys and nonces. var ErrEcho = errors.New("same keys and nonces. one side talking to self.") // HandshakeTimeout governs how long the handshake will be allowed to take place for. // Making this number large means there could be many bogus connections waiting to // timeout in flight. Typical handshakes take ~3RTTs, so it should be completed within // seconds across a typical planet in the solar system. var HandshakeTimeout = time.Second * 30
"io" "net" "time" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" ic "github.com/ipfs/go-libp2p/p2p/crypto" peer "github.com/ipfs/go-libp2p/p2p/peer" mpool "github.com/jbenet/go-msgio/mpool" ma "github.com/jbenet/go-multiaddr" manet "github.com/jbenet/go-multiaddr-net" context "golang.org/x/net/context" u "util" lgbl "util/eventlog/loggables" ) var log = logging.Logger("conn") // ReleaseBuffer puts the given byte array back into the buffer pool, // first verifying that it is the correct size func ReleaseBuffer(b []byte) { log.Debugf("Releasing buffer! (cap,size = %d, %d)", cap(b), len(b)) mpool.ByteSlicePool.Put(uint32(cap(b)), b) } // singleConn represents a single connection to another Peer (IPFS Node). type singleConn struct { local peer.ID remote peer.ID maconn manet.Conn event io.Closer }
inet "github.com/ipfs/go-libp2p/p2p/net" swarm "github.com/ipfs/go-libp2p/p2p/net/swarm" protocol "github.com/ipfs/go-libp2p/p2p/protocol" testutil "github.com/ipfs/go-libp2p/p2p/test/util" u "util" ps "github.com/jbenet/go-peerstream" context "golang.org/x/net/context" ) func init() { // change the garbage collect timeout for testing. ps.GarbageCollectTimeout = 10 * time.Millisecond } var log = logging.Logger("reconnect") func EchoStreamHandler(stream inet.Stream) { c := stream.Conn() log.Debugf("%s echoing %s", c.LocalPeer(), c.RemotePeer()) go func() { defer stream.Close() io.Copy(stream, stream) }() } type sendChans struct { send chan struct{} sent chan struct{} read chan struct{} close_ chan struct{}
"math/rand" "testing" "time" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" host "github.com/ipfs/go-libp2p/p2p/host" inet "github.com/ipfs/go-libp2p/p2p/net" peer "github.com/ipfs/go-libp2p/p2p/peer" protocol "github.com/ipfs/go-libp2p/p2p/protocol" testutil "github.com/ipfs/go-libp2p/p2p/test/util" context "golang.org/x/net/context" u "util" ) var log = logging.Logger("backpressure") // TestBackpressureStreamHandler tests whether mux handler // ratelimiting works. Meaning, since the handler is sequential // it should block senders. // // Important note: spdystream (which peerstream uses) has a set // of n workers (n=spdsystream.FRAME_WORKERS) which handle new // frames, including those starting new streams. So all of them // can be in the handler at one time. Also, the sending side // does not rate limit unless we call stream.Wait() // // // Note: right now, this happens muxer-wide. the muxer should // learn to flow control, so handlers cant block each other. func TestBackpressureStreamHandler(t *testing.T) {
package transport import ( "net" "time" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" ma "github.com/jbenet/go-multiaddr" manet "github.com/jbenet/go-multiaddr-net" ) var log = logging.Logger("transport") type Conn interface { manet.Conn Transport() Transport } type Transport interface { Dialer(laddr ma.Multiaddr, opts ...DialOpt) (Dialer, error) Listen(laddr ma.Multiaddr) (Listener, error) Matches(ma.Multiaddr) bool } type Dialer interface { Dial(raddr ma.Multiaddr) (Conn, error) Matches(ma.Multiaddr) bool } type Listener interface {
package mocknet import ( logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" context "QmacZi9WygGK7Me8mH53pypyscHzU386aUZXpr28GZgUct/context" ) var log = logging.Logger("mocknet") // WithNPeers constructs a Mocknet with N peers. func WithNPeers(ctx context.Context, n int) (Mocknet, error) { m := New(ctx) for i := 0; i < n; i++ { if _, err := m.GenPeer(); err != nil { return nil, err } } return m, nil } // FullMeshLinked constructs a Mocknet with full mesh of Links. // This means that all the peers **can** connect to each other // (not that they already are connected. you can use m.ConnectAll()) func FullMeshLinked(ctx context.Context, n int) (Mocknet, error) { m, err := WithNPeers(ctx, n) if err != nil { return nil, err } if err := m.LinkAll(); err != nil {
package host import ( logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" context "QmacZi9WygGK7Me8mH53pypyscHzU386aUZXpr28GZgUct/context" ma "QmbWxL1aXQhBjc1XGjGF1f2KGBMCBYSuT2ThA8YXnXJK83/go-multiaddr" metrics "github.com/ipfs/go-libp2p/p2p/metrics" inet "github.com/ipfs/go-libp2p/p2p/net" peer "github.com/ipfs/go-libp2p/p2p/peer" protocol "github.com/ipfs/go-libp2p/p2p/protocol" msmux "QmdrbcnPVM2FnZQQM7p2GU91XhpuyYyd1tzPouEyh1phyD/go-multistream" ) var log = logging.Logger("github.com/ipfs/go-libp2p/p2p/host") // Host is an object participating in a p2p network, which // implements protocols or provides services. It handles // requests like a Server, and issues requests like a Client. // It is called Host because it is both Server and Client (and Peer // may be confusing). type Host interface { // ID returns the (local) peer.ID associated with this Host ID() peer.ID // Peerstore returns the Host's repository of Peer Addresses and Keys. Peerstore() peer.Peerstore // Returns the listen addresses of the Host Addrs() []ma.Multiaddr
ggio "github.com/gogo/protobuf/io" ma "github.com/jbenet/go-multiaddr" msmux "github.com/whyrusleeping/go-multistream" context "golang.org/x/net/context" host "github.com/ipfs/go-libp2p/p2p/host" mstream "github.com/ipfs/go-libp2p/p2p/metrics/stream" inet "github.com/ipfs/go-libp2p/p2p/net" peer "github.com/ipfs/go-libp2p/p2p/peer" pb "github.com/ipfs/go-libp2p/p2p/protocol/identify/pb" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" lgbl "util/eventlog/loggables" ) var log = logging.Logger("net/identify") // ID is the protocol.ID of the Identify Service. const ID = "/ipfs/identify" // LibP2PVersion holds the current protocol version for a client running this code // TODO(jbenet): fix the versioning mess. const LibP2PVersion = "ipfs/0.1.0" const ClientVersion = "go-libp2p/0.1.0" // IDService is a structure that implements ProtocolIdentify. // It is a trivial service that gives the other peer some // useful information about the local peer. A sort of hello. // // The IDService sends: // * Our IPFS Protocol Version
package queue import ( logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" peer "github.com/ipfs/go-libp2p/p2p/peer" context "golang.org/x/net/context" ) var log = logging.Logger("peerqueue") // ChanQueue makes any PeerQueue synchronizable through channels. type ChanQueue struct { Queue PeerQueue EnqChan chan<- peer.ID DeqChan <-chan peer.ID } // NewChanQueue creates a ChanQueue by wrapping pq. func NewChanQueue(ctx context.Context, pq PeerQueue) *ChanQueue { cq := &ChanQueue{Queue: pq} cq.process(ctx) return cq } func (cq *ChanQueue) process(ctx context.Context) { // construct the channels here to be able to use them bidirectionally enqChan := make(chan peer.ID) deqChan := make(chan peer.ID) cq.EnqChan = enqChan cq.DeqChan = deqChan
import ( "io" "testing" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" inet "github.com/ipfs/go-libp2p/p2p/net" protocol "github.com/ipfs/go-libp2p/p2p/protocol" relay "github.com/ipfs/go-libp2p/p2p/protocol/relay" testutil "github.com/ipfs/go-libp2p/p2p/test/util" context "QmacZi9WygGK7Me8mH53pypyscHzU386aUZXpr28GZgUct/context" msmux "QmdrbcnPVM2FnZQQM7p2GU91XhpuyYyd1tzPouEyh1phyD/go-multistream" ) var log = logging.Logger("relay_test") func TestRelaySimple(t *testing.T) { ctx := context.Background() // these networks have the relay service wired in already. n1 := testutil.GenHostSwarm(t, ctx) n2 := testutil.GenHostSwarm(t, ctx) n3 := testutil.GenHostSwarm(t, ctx) n1p := n1.ID() n2p := n2.ID() n3p := n3.ID() n2pi := n2.Peerstore().PeerInfo(n2p)
package addrutil import ( "fmt" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" ma "github.com/jbenet/go-multiaddr" manet "github.com/jbenet/go-multiaddr-net" context "golang.org/x/net/context" ) var log = logging.Logger("github.com/ipfs/go-libp2p/p2p/net/swarm/addr") // SupportedTransportStrings is the list of supported transports for the swarm. // These are strings of encapsulated multiaddr protocols. E.g.: // /ip4/tcp var SupportedTransportStrings = []string{ "/ip4/tcp", "/ip6/tcp", // "/ip4/udp/utp", disabled because the lib is broken // "/ip6/udp/utp", disabled because the lib is broken // "/ip4/udp/udt", disabled because the lib doesnt work on arm // "/ip6/udp/udt", disabled because the lib doesnt work on arm } // SupportedTransportProtocols is the list of supported transports for the swarm. // These are []ma.Protocol lists. Populated at runtime from SupportedTransportStrings var SupportedTransportProtocols = [][]ma.Protocol{} func init() {
import ( "encoding/hex" "encoding/json" "fmt" "strings" b58 "QmNsoHoCVhgXcv1Yg45jtkMgimxorTAN36fV9AQMFXHHAQ/go-base58" ma "QmbWxL1aXQhBjc1XGjGF1f2KGBMCBYSuT2ThA8YXnXJK83/go-multiaddr" mh "QmdsKjp5fcCT8PZ8JBMcdFsCbbmKwSLCU5xXbsnwb5DMxy/go-multihash" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" u "Qmah3kfjwhVxBM4qGnrqJTqGzrF8svwByyhExPipA2U6LE/go-ipfs-util" ic "github.com/ipfs/go-libp2p/p2p/crypto" ) var log = logging.Logger("peer") // ID represents the identity of a peer. type ID string // Pretty returns a b58-encoded string of the ID func (id ID) Pretty() string { return IDB58Encode(id) } func (id ID) Loggable() map[string]interface{} { return map[string]interface{}{ "peerID": id.Pretty(), } }
package relay import ( "fmt" "io" mh "QmdsKjp5fcCT8PZ8JBMcdFsCbbmKwSLCU5xXbsnwb5DMxy/go-multihash" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" host "github.com/ipfs/go-libp2p/p2p/host" inet "github.com/ipfs/go-libp2p/p2p/net" peer "github.com/ipfs/go-libp2p/p2p/peer" protocol "github.com/ipfs/go-libp2p/p2p/protocol" ) var log = logging.Logger("github.com/ipfs/go-libp2p/p2p/protocol/relay") // ID is the protocol.ID of the Relay Service. const ID protocol.ID = "/ipfs/relay" // Relay is a structure that implements ProtocolRelay. // It is a simple relay service which forwards traffic // between two directly connected peers. // // the protocol is very simple: // // /ipfs/relay\n // <multihash src id> // <multihash dst id> // <data stream> //
"io/ioutil" golog "log" "net" "sync" "time" manet "QmRCPT5WRph8aWXmaT2Rfn6ac98YRUUJnNURpD3hNAWp4f/go-multiaddr-net" ma "QmbWxL1aXQhBjc1XGjGF1f2KGBMCBYSuT2ThA8YXnXJK83/go-multiaddr" "github.com/cryptix/mdns" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" "github.com/ipfs/go-libp2p/p2p/host" "github.com/ipfs/go-libp2p/p2p/peer" ) var log = logging.Logger("mdns") const ServiceTag = "discovery.ipfs.io" type Service interface { io.Closer RegisterNotifee(Notifee) UnregisterNotifee(Notifee) } type Notifee interface { HandlePeerFound(peer.PeerInfo) } type mdnsService struct { server *mdns.Server
"crypto/rand" "crypto/rsa" "crypto/sha1" "crypto/sha256" "crypto/sha512" "hash" pb "github.com/ipfs/go-libp2p/p2p/crypto/pb" proto "QmfH4HuZyN1p2wQLWWkXC91Z76435xKrBVfLQ2MY8ayG5R/gogo-protobuf/proto" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" u "Qmah3kfjwhVxBM4qGnrqJTqGzrF8svwByyhExPipA2U6LE/go-ipfs-util" ) var log = logging.Logger("crypto") var ErrBadKeyType = errors.New("invalid or unsupported key type") const ( RSA = iota ) // Key represents a crypto key that can be compared to another key type Key interface { // Bytes returns a serialized, storeable representation of this key Bytes() ([]byte, error) // Hash returns the hash of this key Hash() ([]byte, error)
transport "github.com/ipfs/go-libp2p/p2p/net/transport" peer "github.com/ipfs/go-libp2p/p2p/peer" pst "QmPxuHs2NQjz16gnvndgkzHkm5PjtqbB5rwoSpLusBkQ7Q/go-stream-muxer" psmss "QmPxuHs2NQjz16gnvndgkzHkm5PjtqbB5rwoSpLusBkQ7Q/go-stream-muxer/multistream" "QmSir6qPL1tjuxd8LkR8VZq6v625ExAUVs2eCLeqQuaPGU/goprocess" goprocessctx "QmSir6qPL1tjuxd8LkR8VZq6v625ExAUVs2eCLeqQuaPGU/goprocess/context" ps "QmTgxFwS1nDK126fH5XPnLFcxcDFsxKbPPnCBwyRWNAjDX/go-peerstream" mafilter "QmYhewVqJhkgEsm3AYVUbpT14q2P9V4Xb7np9JXKua6y7A/multiaddr-filter" context "QmacZi9WygGK7Me8mH53pypyscHzU386aUZXpr28GZgUct/context" ma "QmbWxL1aXQhBjc1XGjGF1f2KGBMCBYSuT2ThA8YXnXJK83/go-multiaddr" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" ) var log = logging.Logger("swarm2") var PSTransport pst.Transport func init() { PSTransport = psmss.NewTransport() } // Swarm is a connection muxer, allowing connections to other peers to // be opened and closed, while still using the same Chan for all // communication. The Chan sends/receives Messages, which note the // destination or source Peer. // // Uses peerstream.Swarm type Swarm struct { swarm *ps.Swarm
import ( "bytes" "io" "testing" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" u "util" testutil "util/testutil" ic "github.com/ipfs/go-libp2p/p2p/crypto" peer "github.com/ipfs/go-libp2p/p2p/peer" ma "github.com/jbenet/go-multiaddr" ) var log = logging.Logger("boguskey") // TestBogusPrivateKey is a key used for testing (to avoid expensive keygen) type TestBogusPrivateKey []byte // TestBogusPublicKey is a key used for testing (to avoid expensive keygen) type TestBogusPublicKey []byte func (pk TestBogusPublicKey) Verify(data, sig []byte) (bool, error) { log.Errorf("TestBogusPublicKey.Verify -- this better be a test!") return bytes.Equal(data, reverse(sig)), nil } func (pk TestBogusPublicKey) Bytes() ([]byte, error) { return []byte(pk), nil }
import ( "bytes" "errors" "io" "time" context "golang.org/x/net/context" logging "QmWRypnfEwrgH4k93KEHN5hng7VjKYkWmzDYRuTZeh2Mgh/go-log" host "github.com/ipfs/go-libp2p/p2p/host" inet "github.com/ipfs/go-libp2p/p2p/net" peer "github.com/ipfs/go-libp2p/p2p/peer" u "util" ) var log = logging.Logger("ping") const PingSize = 32 const ID = "/ipfs/ping" type PingService struct { Host host.Host } func NewPingService(h host.Host) *PingService { ps := &PingService{h} h.SetStreamHandler(ID, ps.PingHandler) return ps }