UDP Datagrams

In a connectionless protocol each message contains information about its origin and destination. There is no “session” established using a long-lived socket. UDP clients and servers make use of datagrams, which are individual messages containing source and destination information. There is no state maintained by these messages, unless the client or server does so. The messages are not guaranteed to arrive, or may arrive out of order.

The most common situation for a client is to send a message and hope that a reply arrives. The most common situation for a server would be to receive a message and then send one or more replies back to that client. In a peer-to-peer situation, though, the server may just forward messages to other peers.

The major difference between TCP and UDP handling for Go is how to deal with packets arriving from possibly multiple clients, without the cushion of a TCP session to manage things. The major calls needed are

  1. func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error)
  2. func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err os.Error)
  3. func ListenUDP(net string, laddr *UDPAddr) (c *UDPConn, err os.Error)
  4. func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error
  5. func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error)

The client for a UDP time service doesn’t need to make many changes, just changing ...TCP... calls to ...UDP... calls: 

  1. /* UDPDaytimeClient
  2.  */
  3. package main
  5. import (
  6.     "net"
  7.     "os"
  8.     "fmt"
  9. )
  11. func main() {
  12.     if len(os.Args) != 2 {
  13.         fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])
  14.         os.Exit(1)
  15.     }
  16.     service := os.Args[1]
  18.     udpAddr, err := net.ResolveUDPAddr("udp4", service)
  19.     checkError(err)
  21.     conn, err := net.DialUDP("udp", nil, udpAddr)
  22.     checkError(err)
  24.     _, err = conn.Write([]byte("anything"))
  25.     checkError(err)
  27.     var buf [512]byte
  28.     n, err := conn.Read(buf[0:])
  29.     checkError(err)
  31.     fmt.Println(string(buf[0:n]))
  33.     os.Exit(0)
  34. }
  36. func checkError(err error) {
  37.     if err != nil {
  38.         fmt.Fprintf(os.Stderr, "Fatal error %s", err.Error())
  39.         os.Exit(1)
  40.     }
  41. }

while the server has to make a few more:

  1. /* UDPDaytimeServer
  2.  */
  3. package main
  5. import (
  6.     "fmt"
  7.     "net"
  8.     "os"
  9.     "time"
  10. )
  12. func main() {
  14.     service := ":1200"
  15.     udpAddr, err := net.ResolveUDPAddr("udp4", service)
  16.     checkError(err)
  18.     conn, err := net.ListenUDP("udp", udpAddr)
  19.     checkError(err)
  21.     for {
  22.         handleClient(conn)
  23.     }
  24. }
  26. func handleClient(conn *net.UDPConn) {
  28.     var buf [512]byte
  30.     _, addr, err := conn.ReadFromUDP(buf[0:])
  31.     if err != nil {
  32.         return
  33.     }
  35.     daytime := time.Now().String()
  37.     conn.WriteToUDP([]byte(daytime), addr)
  38. }
  40. func checkError(err error) {
  41.     if err != nil {
  42.         fmt.Fprintf(os.Stderr, "Fatal error %s", err.Error())
  43.         os.Exit(1)
  44.     }
  45. }