The types Conn, PacketConn and Listener

So far we have differentiated between the API for TCP and the API for UDP, using for example DialTCP and DialUDP returning a TCPConn and UDPConn respectively. The type Conn is an interface and both TCPConn and UDPConn implement this interface. To a large extent you can deal with this interface rather than the two types.

Instead of separate dial functions for TCP and UDP, you can use a single function

  1. func Dial(net, laddr, raddr string) (c Conn, err os.Error)

The net can be any of "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only), "udp", "udp4" (IPv4-only), "udp6" (IPv6-only), "ip", "ip4" (IPv4-only) and "ip6" IPv6-only). It will return an appropriate implementation of the Conn interface. Note that this function takes a string rather than address as raddr argument, so that programs using this can avoid working out the address type first.

Using this function makes minor changes to programs. For example, the earlier program to get HEAD information from a Web page can be re-written as

  1. /* IPGetHeadInfo
  2.  */
  3. package main
  5. import (
  6.     "bytes"
  7.     "fmt"
  8.     "io"
  9.     "io/ioutil"
  10.     "net"
  11.     "os"
  12. )
  14. func main() {
  15.     if len(os.Args) != 2 {
  16.         fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])
  17.         os.Exit(1)
  18.     }
  19.     service := os.Args[1]
  21.     conn, err := net.Dial("tcp", service)
  22.     checkError(err)
  24.     defer conn.Close()
  26.     _, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n"))
  27.     checkError(err)
  29.     result, err := ioutil.ReadAll(conn)
  30.     checkError(err)
  32.     fmt.Println(string(result))
  34.     os.Exit(0)
  35. }
  37. func checkError(err error) {
  38.     if err != nil {
  39.         fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
  40.         os.Exit(1)
  41.     }
  42. }

Writing a server can be similarly simplified using the function

  1. func Listen(net, laddr string) (l Listener, err os.Error)

which returns an object implementing the Listener interface. This interface has a method

  1. func (l Listener) Accept() (c Conn, err os.Error)

which will allow a server to be built. Using this, the multi-threaded Echo server given earlier becomes

  1. /* ThreadedIPEchoServer
  2.  */
  3. package main
  5. import (
  6.     "fmt"
  7.     "net"
  8.     "os"
  9. )
  11. func main() {
  13.     service := ":1200"
  14.     listener, err := net.Listen("tcp", service)
  15.     checkError(err)
  17.     for {
  18.         conn, err := listener.Accept()
  19.         if err != nil {
  20.             continue
  21.         }
  22.         go handleClient(conn)
  23.     }
  24. }
  26. func handleClient(conn net.Conn) {
  27.     defer conn.Close()
  29.     var buf [512]byte
  30.     for {
  31.         n, err := conn.Read(buf[0:])
  32.         if err != nil {
  33.             return
  34.         }
  35.         _, err2 := conn.Write(buf[0:n])
  36.         if err2 != nil {
  37.             return
  38.         }
  39.     }
  40. }
  42. func checkError(err error) {
  43.     if err != nil {
  44.         fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
  45.         os.Exit(1)
  46.     }
  47. }

If you want to write a UDP server, then there is an interface PacketConn and a method to return an implementation of this:

  1. func ListenPacket(net, laddr string) (c PacketConn, err os.Error)

This interface has primary methods ReadFrom and WriteTo to handle packet reads and writes.

The Go net package recommends using these interface types rather than the concrete ones. But by using them, you lose specific methods such as SetKeepAlive or TCPConn and SetReadBuffer of UDPConn, unless you do a type cast. It is your choice.