func (d *Dialer) Dial(rnet string, raddr string) (net.Conn, error) {
if d.LocalAddr != nil {
s, err := utp.NewSocket(d.LocalAddr.Network(), d.LocalAddr.String())
if err != nil {
return nil, err
}
// zero timeout is the same as calling s.Dial()
return s.DialTimeout(raddr, d.Timeout)
}
return utp.DialTimeout(raddr, d.Timeout)
}
func main() {
defer envpprof.Stop()
listen := flag.Bool("l", false, "listen")
port := flag.Int("p", 0, "port to listen on")
flag.Parse()
var (
conn net.Conn
err error
)
if *listen {
s, err := utp.NewSocket("udp", fmt.Sprintf(":%d", *port))
if err != nil {
log.Fatal(err)
}
defer s.Close()
conn, err = s.Accept()
if err != nil {
log.Fatal(err)
}
} else {
conn, err = utp.Dial(net.JoinHostPort(flag.Arg(0), flag.Arg(1)))
if err != nil {
log.Fatal(err)
}
}
defer conn.Close()
go func() {
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt)
<-sig
conn.Close()
}()
writerDone := make(chan struct{})
go func() {
defer close(writerDone)
written, err := io.Copy(conn, os.Stdin)
if err != nil {
conn.Close()
log.Fatalf("error after writing %d bytes: %s", written, err)
}
log.Printf("wrote %d bytes", written)
conn.Close()
}()
n, err := io.Copy(os.Stdout, conn)
if err != nil {
log.Fatal(err)
}
log.Printf("received %d bytes", n)
// <-writerDone
}
func Listen(network string, laddr string) (net.Listener, error) {
switch network {
case "utp", "utp4", "utp6":
s, err := utp.NewSocket("udp"+network[3:], laddr)
if err != nil {
return nil, err
}
return &Listener{s}, nil
default:
return nil, errors.New("unrecognized network: " + network)
}
}
func (t *UtpTransport) newConn(addr ma.Multiaddr, opts ...DialOpt) (*UtpSocket, error) {
network, netaddr, err := manet.DialArgs(addr)
if err != nil {
return nil, err
}
s, err := utp.NewSocket("udp"+network[3:], netaddr)
if err != nil {
return nil, err
}
laddr, err := manet.FromNetAddr(mautp.MakeAddr(s.LocalAddr()))
if err != nil {
return nil, err
}
return &UtpSocket{
s: s,
laddr: laddr,
transport: t,
}, nil
}