golang的net.Conn.Read如何停止读取？

I'm trying to write a simple sockets based go server. I'm just wondering how does the connection.Read below knows when to stop reading. (Note: this is not my code, I copied it from Unix Sockets in Go as example)

package main

import (
  "log"
  "net"
)

func echoServer(c net.Conn) {
  for {
    buf := make([]byte, 512)
    nr, err := c.Read(buf)
    if err != nil {
        return
    }

    data := buf[0:nr]
    println("Server got:", string(data))
    _, err = c.Write(data)
    if err != nil {
        log.Fatal("Write: ", err)
    }
  }
}

func main() {
  l, err := net.Listen("unix", "/tmp/echo.sock")
  if err != nil {
    log.Fatal("listen error:", err)
  }

  for {
    fd, err := l.Accept()
    if err != nil {
        log.Fatal("accept error:", err)
    }

    go echoServer(fd)
  }
 }

Is it the EOF character or there's something else? It would be really helpful if someone can point me to a link official go docs. Thanks.

This is the implementation of the default Read method on net.Conn.Read:

// Read implements the Conn Read method.
func (c *conn) Read(b []byte) (int, error) {
    if !c.ok() {
        return 0, syscall.EINVAL
    }
    n, err := c.fd.Read(b)
    if err != nil && err != io.EOF {
        err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
    }
    return n, err
}

This is the implementation of the c.fd.Read(b) that is called within the function above:

func (fd *netFD) Read(p []byte) (n int, err error) {
    if err := fd.readLock(); err != nil {
        return 0, err
    }
    defer fd.readUnlock()
    if len(p) == 0 {
        // If the caller wanted a zero byte read, return immediately
        // without trying. (But after acquiring the readLock.) Otherwise
        // syscall.Read returns 0, nil and eofError turns that into
        // io.EOF.
        // TODO(bradfitz): make it wait for readability? (Issue 15735)
        return 0, nil
    }
    if err := fd.pd.prepareRead(); err != nil {
        return 0, err
    }
    if fd.isStream && len(p) > 1<<30 {
        p = p[:1<<30]
    }
    for {
        n, err = syscall.Read(fd.sysfd, p)
        if err != nil {
            n = 0
            if err == syscall.EAGAIN {
                if err = fd.pd.waitRead(); err == nil {
                    continue
                }
            }
        }
        err = fd.eofError(n, err)
        break
    }
    if _, ok := err.(syscall.Errno); ok {
        err = os.NewSyscallError("read", err)
    }
    return
}

So, yes, an EOF will make it stop reading. But so will plenty of other non-nil errors.

It will stop reading when its underlying implementation hits any error. Error may be an actual I/O error, or it could be the operating system signaling connection closed with io.EOF, or it could be a timeout, so on.