// Dial connects to a remote address and pipes all os.Stdin to the remote end.
// If localAddr is set, uses it to Dial from.
func Dial(localAddr, remoteAddr string) error {
var laddr net.Addr
var err error
if localAddr != "" {
laddr, err = utp.ResolveAddr("utp", localAddr)
if err != nil {
return fmt.Errorf("failed to resolve address %s", localAddr)
}
}
if laddr != nil {
log("dialing %s from %s", remoteAddr, laddr)
} else {
log("dialing %s", remoteAddr)
}
d := utp.Dialer{LocalAddr: laddr}
c, err := d.Dial("utp", remoteAddr)
if err != nil {
return err
}
log("connected to %s", c.RemoteAddr())
netcat(c)
return c.Close()
}
// ToNetAddr converts a Multiaddr to a net.Addr
// Must be ThinWaist. acceptable protocol stacks are:
// /ip{4,6}/{tcp, udp}
func ToNetAddr(maddr ma.Multiaddr) (net.Addr, error) {
network, host, err := DialArgs(maddr)
if err != nil {
return nil, err
}
switch network {
case "tcp", "tcp4", "tcp6":
return net.ResolveTCPAddr(network, host)
case "udp", "udp4", "udp6":
return net.ResolveUDPAddr(network, host)
case "utp", "utp4", "utp6":
return utp.ResolveAddr(network, host)
case "ip", "ip4", "ip6":
return net.ResolveIPAddr(network, host)
}
return nil, fmt.Errorf("network not supported: %s", network)
}
// Listen listens and accepts one incoming uTP connection on a given port,
// and pipes all incoming data to os.Stdout.
func Listen(localAddr string) error {
laddr, err := utp.ResolveAddr("utp", localAddr)
if err != nil {
return fmt.Errorf("failed to resolve address %s", localAddr)
}
l, err := utp.Listen("utp", laddr)
if err != nil {
return err
}
log("listening at %s", l.Addr())
c, err := l.Accept()
if err != nil {
return err
}
log("accepted connection from %s", c.RemoteAddr())
// should be able to close listener here, but utp.Listener.Close
// closes all open connections.
defer l.Close()
netcat(c)
return c.Close()
}
func c2s(l int64, stream bool) float64 {
laddr, err := utp.ResolveAddr("utp", "127.0.0.1:0")
if err != nil {
log.Fatal(err)
}
ln, err := utp.Listen("utp", laddr)
if err != nil {
log.Fatal(err)
}
cch := make(chan *utp.Conn)
go func() {
c, err := utp.DialUTPTimeout("utp", nil, ln.Addr().(*utp.Addr), 1000*time.Millisecond)
if err != nil {
log.Fatal(err)
}
if err != nil {
log.Fatal(err)
}
cch <- c
}()
s, err := ln.Accept()
if err != nil {
log.Fatal(err)
}
defer s.Close()
ln.Close()
c := <-cch
defer c.Close()
rch := make(chan int)
wch := make(chan int)
sendHash := md5.New()
readHash := md5.New()
counter := ByteCounter{}
var bps float64
if stream {
go func() {
defer c.Close()
defer close(wch)
io.Copy(io.MultiWriter(c, sendHash, &counter), io.LimitReader(RandReader{}, l))
}()
go func() {
defer close(rch)
io.Copy(readHash, s)
}()
go func() {
for {
select {
case <-time.After(time.Second):
if *h {
fmt.Printf("\r <--> %s ", humanize.IBytes(uint64(counter.Length())))
} else {
fmt.Printf("\r <--> %d ", counter.Length())
}
case <-rch:
fmt.Printf("\r")
return
}
}
}()
start := time.Now()
<-rch
<-wch
bps = float64(l*8) / (float64(time.Now().Sub(start)) / float64(time.Second))
} else {
var sendBuf, readBuf bytes.Buffer
io.Copy(io.MultiWriter(&sendBuf, sendHash), io.LimitReader(RandReader{}, l))
go func() {
defer c.Close()
defer close(wch)
io.Copy(c, &sendBuf)
}()
go func() {
defer close(rch)
io.Copy(&readBuf, s)
}()
start := time.Now()
<-rch
<-wch
bps = float64(l*8) / (float64(time.Now().Sub(start)) / float64(time.Second))
io.Copy(sendHash, &sendBuf)
io.Copy(readHash, &readBuf)
}
if !bytes.Equal(sendHash.Sum(nil), readHash.Sum(nil)) {
log.Fatal("Broken payload")
}
return bps
}