1package peer
  2
  3import (
  4	"bufio"
  5	"context"
  6	"crypto/rand"
  7	"fmt"
  8	"io"
  9	"os"
 10
 11	"github.com/arnaucube/slowlorisdb/config"
 12	"github.com/arnaucube/slowlorisdb/node"
 13	libp2p "github.com/libp2p/go-libp2p"
 14	crypto "github.com/libp2p/go-libp2p-crypto"
 15	inet "github.com/libp2p/go-libp2p-net"
 16	peerstore "github.com/libp2p/go-libp2p-peerstore"
 17	"github.com/multiformats/go-multiaddr"
 18	log "github.com/sirupsen/logrus"
 19)
 20
 21func handleStream(stream inet.Stream) {
 22	log.Info("Got a new stream!")
 23
 24	rw := bufio.NewReadWriter(bufio.NewReader(stream), bufio.NewWriter(stream))
 25
 26	go readData(rw)
 27	go writeData(rw)
 28}
 29
 30func readData(rw *bufio.ReadWriter) {
 31	for {
 32		str, err := rw.ReadString('\n')
 33		if err != nil {
 34			log.Error("Error reading from buffer")
 35			panic(err)
 36		}
 37		if str == "" {
 38			return
 39		}
 40		if str != "\n" {
 41			fmt.Printf("\x1b[32m%s\x1b[0m> ", str)
 42		}
 43	}
 44}
 45
 46func writeData(rw *bufio.ReadWriter) {
 47	stdReader := bufio.NewReader(os.Stdin)
 48	for {
 49		fmt.Print("> ")
 50		sendData, err := stdReader.ReadString('\n')
 51		if err != nil {
 52			log.Error("Error reading from stdin")
 53			panic(err)
 54		}
 55
 56		_, err = rw.WriteString(fmt.Sprintf("%s\n", sendData))
 57		if err != nil {
 58			log.Error("Error writing to buffer")
 59			panic(err)
 60		}
 61		err = rw.Flush()
 62		if err != nil {
 63			log.Error("Error flushing buffer")
 64			panic(err)
 65		}
 66	}
 67}
 68
 69type Peer struct {
 70	n *node.Node
 71	c *config.Config
 72}
 73
 74func NewPeer(n *node.Node, conf *config.Config) *Peer {
 75	return &Peer{
 76		n: n,
 77		c: conf,
 78	}
 79}
 80func (peer *Peer) Start() error {
 81	var port int = peer.c.Port
 82	var dest string = peer.c.Dest
 83
 84	var r io.Reader
 85	r = rand.Reader
 86
 87	prvKey, _, err := crypto.GenerateKeyPairWithReader(crypto.RSA, 2048, r)
 88	if err != nil {
 89		return err
 90	}
 91
 92	sourceMultiAddr, _ := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", port))
 93
 94	host, err := libp2p.New(
 95		context.Background(),
 96		libp2p.ListenAddrs(sourceMultiAddr),
 97		libp2p.Identity(prvKey),
 98	)
 99	if err != nil {
100		return err
101	}
102	if dest == "" {
103		host.SetStreamHandler("/slowlorisdb/0.0.1", handleStream)
104
105		var port string
106		for _, la := range host.Network().ListenAddresses() {
107			if p, err := la.ValueForProtocol(multiaddr.P_TCP); err == nil {
108				port = p
109				break
110			}
111		}
112
113		if port == "" {
114			panic("was not able to find actual local port")
115		}
116
117		fmt.Printf("Run './slowlorisdb -d /ip4/127.0.0.1/tcp/%v/p2p/%s' on another console.\n", port, host.ID().Pretty())
118		fmt.Printf("\nWaiting for incoming connection\n\n")
119
120		// Hang forever
121		<-make(chan struct{})
122	} else {
123		fmt.Println("This node's multiaddresses:")
124		for _, la := range host.Addrs() {
125			fmt.Printf(" - %v\n", la)
126		}
127		fmt.Println()
128
129		maddr, err := multiaddr.NewMultiaddr(dest)
130		if err != nil {
131			log.Fatalln(err)
132		}
133
134		info, err := peerstore.InfoFromP2pAddr(maddr)
135		if err != nil {
136			log.Fatalln(err)
137		}
138
139		host.Peerstore().AddAddrs(info.ID, info.Addrs, peerstore.PermanentAddrTTL)
140
141		s, err := host.NewStream(context.Background(), info.ID, "/slowlorisdb/0.0.1")
142		if err != nil {
143			panic(err)
144		}
145
146		rw := bufio.NewReadWriter(bufio.NewReader(s), bufio.NewWriter(s))
147
148		go writeData(rw)
149		go readData(rw)
150
151		select {}
152	}
153	return nil
154}