Handling connection reset errors in Go

On a plain Go HTTP handler, if I disconnect a client while still writting to the response, http.ResponseWritter.Write will return an error with a message like write tcp 127.0.0.1:60702: connection reset by peer.

Now from the syscall package, I have sysca.ECONNRESET, which has the message connection reset by peer, so they're not exactly the same.

How can I match them, so I know not to panic if it occurs ? On other ocasions I have been doing

if err == syscall.EAGAIN {
  /* handle error differently */
}

for instance, and that worked fine, but I can't do it with syscall.ECONNRESET.

Update:

Because I'm desperate for a solution, for the time being I'll be doing this very dirty hack:

if strings.Contains(err.Error(), syscall.ECONNRESET.Error()) {
	println("it's a connection reset by peer!")
	return
}

The error you get has the underlying type *net.OpError, built here, for example.

You should be able to type-assert the error to its concrete type like this:

operr, ok := err.(*net.OpError)

And then access its Err field, which should correspond to the syscall error you need:

operr.Err.Error() == syscall.ECONNRESET.Error()

The answer by @zian is more useful than the accepted answer, but now on Go 1.13+ it is preferable to avoid manually unwrapping the errors:

if errors.Is(opErr,syscall.ECONNRESET) {
	fmt.Println("Found a ECONNRESET")
}

This has the benefit that you can also use it more generally, such as after:

resp, err := http.Get("http://127.0.0.1:4444")

Here this err would otherwise have an extra layer of wrapping (*url.Error) and would be missed by the condition @zian used without explicitly unwrapping it a third time.

I came across this issue and the accepted answer was sufficient to point me in the right direction. However, the code it provides to check if the Error embedded inside *net.OpError is ECONNRESET is not complete, at least not for Golang 1.9.

The error embedded at OpError.Err is actually of type *os.SyscallError (https://golang.org/pkg/os/#SyscallError). The Write() function implemented by struct *net.netFD (which is what's being written to when sending a response over the network) looks like this:

func (fd *netFD) Write(p []byte) (nn int, err error) {
    nn, err = fd.pfd.Write(p)
    runtime.KeepAlive(fd)
    return nn, wrapSyscallError("write", err)
}

And wrapSyscallError:

func wrapSyscallError(name string, err error) error {
    if _, ok := err.(syscall.Errno); ok {
	    err = os.NewSyscallError(name, err)
    }
    return err
}

The error inside the *os.SyscallError struct can be directly compared against syscall.ECONNRESET.

So, given an error returned from a network write (e.g. a call to http.ResponseWritter.Write), the full code block to determine if that error is ECONNRESET is:

if opErr, ok := err.(*net.OpError); ok {
    if syscallErr, ok := opErr.Err.(*os.SyscallError); ok {
	    if syscallErr.Err == syscall.ECONNRESET {
            fmt.Println("Found a ECONNRESET")
        }
    }
}

@zian - thanks for your good solution to João Pinto's (and my) question : How can I match them, so I know not to panic if it occurs ?
As at go version 1.13, an improvement is to use the errors.Is function which does error unwrapping and testing sequentially 'under the hood'. For example :

if errors.Is(opErr,syscall.ECONNRESET) {
	fmt.Println("Found a ECONNRESET")
}

@SteveCoffman - adding to your good answer, cheers!

Working with Errors in Go 1.13 - The Go Blog - Golang