// 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 { l, err := utp.Listen("utp", localAddr) 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() }
// Listen announces on the local network address laddr. // The Multiaddr must be a "ThinWaist" stream-oriented network: // ip4/tcp, ip6/tcp, (TODO: unix, unixpacket) // See Dial for the syntax of laddr. func Listen(laddr ma.Multiaddr) (Listener, error) { // get the net.Listen friendly arguments from the remote addr lnet, lnaddr, err := DialArgs(laddr) if err != nil { return nil, err } var nl net.Listener switch lnet { case "utp": nl, err = utp.Listen(lnet, lnaddr) default: nl, err = net.Listen(lnet, lnaddr) } if err != nil { return nil, err } return &maListener{ Listener: nl, laddr: laddr, }, nil }
func c2s(l int64, stream bool) float64 { ln, err := utp.Listen("utp", "127.0.0.1:0") if err != nil { log.Fatal(err) } raddr, err := utp.ResolveUTPAddr("utp", ln.Addr().String()) if err != nil { log.Fatal(err) } c, err := utp.DialUTPTimeout("utp", nil, raddr, 1000*time.Millisecond) if err != nil { log.Fatal(err) } defer c.Close() if err != nil { log.Fatal(err) } s, err := ln.Accept() if err != nil { log.Fatal(err) } defer s.Close() ln.Close() rch := make(chan int) sendHash := md5.New() readHash := md5.New() counter := ByteCounter{} var bps float64 if stream { go func() { defer c.Close() io.Copy(io.MultiWriter(c, sendHash, &counter), io.LimitReader(RandReader{}, l)) }() go func() { io.Copy(readHash, s) close(rch) }() 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 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() io.Copy(c, &sendBuf) }() go func() { io.Copy(&readBuf, s) rch <- 0 }() start := time.Now() <-rch 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 }