func TestHandshake(t *testing.T) {
ska, pka, err := ci.GenerateKeyPair(ci.RSA, 512)
if err != nil {
t.Fatal(err)
}
skb, pkb, err := ci.GenerateKeyPair(ci.RSA, 512)
if err != nil {
t.Fatal(err)
}
cha := make(chan []byte, 5)
chb := make(chan []byte, 5)
ida, err := IDFromPubKey(pka)
if err != nil {
t.Fatal(err)
}
pa := &peer.Peer{
ID: ida,
PubKey: pka,
PrivKey: ska,
}
idb, err := IDFromPubKey(pkb)
if err != nil {
t.Fatal(err)
}
pb := &peer.Peer{
ID: idb,
PubKey: pkb,
PrivKey: skb,
}
go func() {
_, _, err := Handshake(pa, pb, cha, chb)
if err != nil {
t.Fatal(err)
}
}()
_, _, err = Handshake(pb, pa, chb, cha)
if err != nil {
t.Fatal(err)
}
}
func initCmd(c *commander.Command, inp []string) error {
filename, err := config.Filename(config.DefaultConfigFilePath)
if err != nil {
return errors.New("Couldn't get home directory path")
}
fi, err := os.Lstat(filename)
force := c.Flag.Lookup("f").Value.Get().(bool)
if fi != nil || (err != nil && !os.IsNotExist(err)) && !force {
return errors.New("ipfs configuration file already exists!\nReinitializing would overwrite your keys.\n(use -f to force overwrite)")
}
cfg := new(config.Config)
cfg.Datastore = config.Datastore{}
dspath, err := u.TildeExpansion("~/.go-ipfs/datastore")
if err != nil {
return err
}
cfg.Datastore.Path = dspath
cfg.Datastore.Type = "leveldb"
cfg.Identity = new(config.Identity)
// This needs thought
// cfg.Identity.Address = ""
nbits := c.Flag.Lookup("b").Value.Get().(int)
if nbits < 1024 {
return errors.New("Bitsize less than 1024 is considered unsafe.")
}
sk, pk, err := ci.GenerateKeyPair(ci.RSA, nbits)
if err != nil {
return err
}
// pretend to encrypt key, then store it unencrypted
skbytes, err := sk.Bytes()
if err != nil {
return err
}
cfg.Identity.PrivKey = base64.StdEncoding.EncodeToString(skbytes)
id, err := identify.IDFromPubKey(pk)
if err != nil {
return err
}
cfg.Identity.PeerID = id.Pretty()
path, err := u.TildeExpansion(config.DefaultConfigFilePath)
if err != nil {
return err
}
err = config.WriteConfigFile(path, cfg)
if err != nil {
return err
}
return nil
}
func makePeer(addr *ma.Multiaddr) *peer.Peer {
p := new(peer.Peer)
p.AddAddress(addr)
sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
if err != nil {
panic(err)
}
p.PrivKey = sk
p.PubKey = pk
id, err := identify.IDFromPubKey(pk)
if err != nil {
panic(err)
}
p.ID = id
return p
}
func setupDHTS(n int, t *testing.T) ([]*ma.Multiaddr, []*peer.Peer, []*IpfsDHT) {
var addrs []*ma.Multiaddr
for i := 0; i < 4; i++ {
a, err := ma.NewMultiaddr(fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", 5000+i))
if err != nil {
t.Fatal(err)
}
addrs = append(addrs, a)
}
var peers []*peer.Peer
for i := 0; i < 4; i++ {
p := new(peer.Peer)
p.AddAddress(addrs[i])
sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
if err != nil {
panic(err)
}
p.PubKey = pk
p.PrivKey = sk
id, err := identify.IDFromPubKey(pk)
if err != nil {
panic(err)
}
p.ID = id
peers = append(peers, p)
}
var dhts []*IpfsDHT
for i := 0; i < 4; i++ {
net := swarm.NewSwarm(peers[i])
err := net.Listen()
if err != nil {
t.Fatal(err)
}
d := NewDHT(peers[i], net, ds.NewMapDatastore())
dhts = append(dhts, d)
d.Start()
}
return addrs, peers, dhts
}