by nroos@webware-experts.de:

When reading from a TLS encrypted websocket connection with websocket.Read(), and the
connection gets closed, the Read() does not return an error (does not return at all).

What steps will reproduce the problem?
1. Generate a key and certificate:
   openssl req -x509 -nodes -days 365 -subj '/C=US/ST=Oregon/L=Portland/CN=websocket.com' -newkey rsa:1024 -keyout key -out cert

2. Compile the server and client, source code below

3. Run the server

4. Run the client; it opens a websocket connection to the server, after 2 seconds, the
connection gets closed

What is the expected output?

Client should say "Expecting EOF: EOF"

What do you see instead?

"Expecting EOF:"

Which compiler are you using (5g, 6g, 8g, gccgo)?

8g

Which operating system are you using?

Linux (Kubuntu)

Which revision are you using?  (hg identify)

998062d21eea tip

Please provide any additional information below.

--- Server ---

package main

import (
    "fmt"
    "http"
    "websocket"
)

func server(ws *websocket.Conn) {
    fmt.Printf("new connection\n")
    buf := make([]byte, 100)
    for {
        if _, err := ws.Read(buf); err != nil {
            fmt.Printf("%s", err.String())
            break
        }
    }
    fmt.Printf(" => closing connection\n", )
    ws.Close()
}

func main() {
    http.Handle("/websocket", websocket.Handler(server))
    err := http.ListenAndServeTLS(":12345", "cert", "key", nil)
//  err := http.ListenAndServe(":12345", nil)
    if err != nil {
        panic("ListenAndServe: " + err.String())
    }
}

--- Client ---

package main

import (
    "fmt"
    "time"
    "websocket"
)

func main() {
    ws, err := websocket.Dial("wss://localhost:12345/websocket", "", "http://localhost/";)
//  ws, err := websocket.Dial("ws://localhost:12345/websocket", "",
"http://localhost/";)
    if err != nil {
        panic("Dial: " + err.String())
    }
    go readFromServer(ws)
    time.Sleep(2000000000)
    fmt.Printf("Expecting EOF: ")
    ws.Close()
    time.Sleep(60000000000)
}

func readFromServer(ws *websocket.Conn) {
    buf := make([]byte, 1000)
    for {
        if _, err := ws.Read(buf); err != nil {
            fmt.Printf("%s\n", err.String())
            break
        }
    }
}

--- ---

Unencrypted connections work as intended; uncomment the lines in the server and client
to check this