libgo/go/net/dial.go

   1 // Copyright 2010 The Go Authors.  All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package net
   6
   7 func resolveNetAddr(op, net, addr string) (a Addr, err error) {
   8         if addr == "" {
   9                 return nil, &OpError{op, net, nil, errMissingAddress}
  10         }
  11         switch net {
  12         case "tcp", "tcp4", "tcp6":
  13                 a, err = ResolveTCPAddr(net, addr)
  14         case "udp", "udp4", "udp6":
  15                 a, err = ResolveUDPAddr(net, addr)
  16         case "unix", "unixgram", "unixpacket":
  17                 a, err = ResolveUnixAddr(net, addr)
  18         case "ip", "ip4", "ip6":
  19                 a, err = ResolveIPAddr(net, addr)
  20         default:
  21                 err = UnknownNetworkError(net)
  22         }
  23         if err != nil {
  24                 return nil, &OpError{op, net + " " + addr, nil, err}
  25         }
  26         return
  27 }
  28
  29 // Dial connects to the address addr on the network net.
  30 //
  31 // Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only),
  32 // "udp", "udp4" (IPv4-only), "udp6" (IPv6-only), "ip", "ip4"
  33 // (IPv4-only), "ip6" (IPv6-only), "unix" and "unixgram".
  34 //
  35 // For IP networks, addresses have the form host:port.  If host is
  36 // a literal IPv6 address, it must be enclosed in square brackets.
  37 // The functions JoinHostPort and SplitHostPort manipulate
  38 // addresses in this form.
  39 //
  40 // Examples:
  41 //      Dial("tcp", "12.34.56.78:80")
  42 //      Dial("tcp", "google.com:80")
  43 //      Dial("tcp", "[de:ad:be:ef::ca:fe]:80")
  44 //
  45 func Dial(net, addr string) (c Conn, err error) {
  46         addri, err := resolveNetAddr("dial", net, addr)
  47         if err != nil {
  48                 return nil, err
  49         }
  50         switch ra := addri.(type) {
  51         case *TCPAddr:
  52                 c, err = DialTCP(net, nil, ra)
  53         case *UDPAddr:
  54                 c, err = DialUDP(net, nil, ra)
  55         case *UnixAddr:
  56                 c, err = DialUnix(net, nil, ra)
  57         case *IPAddr:
  58                 c, err = DialIP(net, nil, ra)
  59         default:
  60                 err = &OpError{"dial", net + " " + addr, nil, UnknownNetworkError(net)}
  61         }
  62         if err != nil {
  63                 return nil, err
  64         }
  65         return
  66 }
  67
  68 // Listen announces on the local network address laddr.
  69 // The network string net must be a stream-oriented
  70 // network: "tcp", "tcp4", "tcp6", or "unix", or "unixpacket".
  71 func Listen(net, laddr string) (l Listener, err error) {
  72         switch net {
  73         case "tcp", "tcp4", "tcp6":
  74                 var la *TCPAddr
  75                 if laddr != "" {
  76                         if la, err = ResolveTCPAddr(net, laddr); err != nil {
  77                                 return nil, err
  78                         }
  79                 }
  80                 l, err := ListenTCP(net, la)
  81                 if err != nil {
  82                         return nil, err
  83                 }
  84                 return l, nil
  85         case "unix", "unixpacket":
  86                 var la *UnixAddr
  87                 if laddr != "" {
  88                         if la, err = ResolveUnixAddr(net, laddr); err != nil {
  89                                 return nil, err
  90                         }
  91                 }
  92                 l, err := ListenUnix(net, la)
  93                 if err != nil {
  94                         return nil, err
  95                 }
  96                 return l, nil
  97         }
  98         return nil, UnknownNetworkError(net)
  99 }
 100
 101 // ListenPacket announces on the local network address laddr.
 102 // The network string net must be a packet-oriented network:
 103 // "udp", "udp4", "udp6", or "unixgram".
 104 func ListenPacket(net, laddr string) (c PacketConn, err error) {
 105         switch net {
 106         case "udp", "udp4", "udp6":
 107                 var la *UDPAddr
 108                 if laddr != "" {
 109                         if la, err = ResolveUDPAddr(net, laddr); err != nil {
 110                                 return nil, err
 111                         }
 112                 }
 113                 c, err := ListenUDP(net, la)
 114                 if err != nil {
 115                         return nil, err
 116                 }
 117                 return c, nil
 118         case "unixgram":
 119                 var la *UnixAddr
 120                 if laddr != "" {
 121                         if la, err = ResolveUnixAddr(net, laddr); err != nil {
 122                                 return nil, err
 123                         }
 124                 }
 125                 c, err := DialUnix(net, la, nil)
 126                 if err != nil {
 127                         return nil, err
 128                 }
 129                 return c, nil
 130         }
 131
 132         var rawnet string
 133         if rawnet, _, err = splitNetProto(net); err != nil {
 134                 switch rawnet {
 135                 case "ip", "ip4", "ip6":
 136                         var la *IPAddr
 137                         if laddr != "" {
 138                                 if la, err = ResolveIPAddr(rawnet, laddr); err != nil {
 139                                         return nil, err
 140                                 }
 141                         }
 142                         c, err := ListenIP(net, la)
 143                         if err != nil {
 144                                 return nil, err
 145                         }
 146                         return c, nil
 147                 }
 148         }
 149
 150         return nil, UnknownNetworkError(net)
 151 }