commit e781e43100151dbecdc6604d8c495ed7946e3979
Author: Aleksa Sarai <cyphar@cyphar.com>
Date:   Mon Nov 21 02:23:53 2016 +1100

    io: pipe: make CloseWithError final

    CloseWithError would previously overwrite previously set error flags,
    making a defer'd pipe.Close() set the error to EOF (clearing the
    previous error flags). This was quite confusing to users, because it
    meant that io.Pipes we're very different to channels (double-closing a
    pipe would not produce an error and would actually affect the pipe).

    Fixes: golang/go#17992
    Signed-off-by: Aleksa Sarai <cyphar@cyphar.com>

diff --git a/src/io/pipe.go b/src/io/pipe.go
index 7e98cd2eb788..f1379a8278f0 100644
--- a/src/io/pipe.go
+++ b/src/io/pipe.go
@@ -93,26 +93,34 @@ func (p *pipe) write(b []byte) (n int, err error) {
        return
 }

-func (p *pipe) rclose(err error) {
+func (p *pipe) rclose(err error) error {
        if err == nil {
                err = ErrClosedPipe
        }
        p.l.Lock()
        defer p.l.Unlock()
+       if p.rerr != nil {
+               return ErrClosedPipe
+       }
        p.rerr = err
        p.rwait.Signal()
        p.wwait.Signal()
+       return nil
 }

-func (p *pipe) wclose(err error) {
+func (p *pipe) wclose(err error) error {
        if err == nil {
                err = EOF
        }
        p.l.Lock()
        defer p.l.Unlock()
+       if p.werr != nil {
+               return ErrClosedPipe
+       }
        p.werr = err
        p.rwait.Signal()
        p.wwait.Signal()
+       return nil
 }

 // A PipeReader is the read half of a pipe.
@@ -138,8 +146,7 @@ func (r *PipeReader) Close() error {
 // CloseWithError closes the reader; subsequent writes
 // to the write half of the pipe will return the error err.
 func (r *PipeReader) CloseWithError(err error) error {
-       r.p.rclose(err)
-       return nil
+       return r.p.rclose(err)
 }

 // A PipeWriter is the write half of a pipe.
@@ -168,8 +175,7 @@ func (w *PipeWriter) Close() error {
 //
 // CloseWithError always returns nil.
 func (w *PipeWriter) CloseWithError(err error) error {
-       w.p.wclose(err)
-       return nil
+       return w.p.wclose(err)
 }

 // Pipe creates a synchronous in-memory pipe.