diff --git a/README.md b/README.md index 71a144a..83cf081 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# WebsocketProxy [![GoDoc](https://godoc.org/github.com/koding/websocketproxy?status.svg)](https://godoc.org/github.com/koding/websocketproxy) [![Build Status](https://travis-ci.org/koding/websocketproxy.svg)](https://travis-ci.org/koding/websocketproxy) +# WebsocketProxy [![GoDoc](https://godoc.org/github.com/sudiptadeb/websocketproxy?status.svg)](https://godoc.org/github.com/sudiptadeb/websocketproxy) [![Build Status](https://travis-ci.org/sudiptadeb/websocketproxy.svg)](https://travis-ci.org/sudiptadeb/websocketproxy) WebsocketProxy is an http.Handler interface build on top of [gorilla/websocket](https://github.com/gorilla/websocket) that you can plug @@ -7,7 +7,7 @@ into your existing Go webserver to provide WebSocket reverse proxy. ## Install ```bash -go get github.com/koding/websocketproxy +go get github.com/sudiptadeb/websocketproxy ``` ## Example @@ -22,7 +22,7 @@ import ( "net/http" "net/url" - "github.com/koding/websocketproxy" + "github.com/sudiptadeb/websocketproxy" ) var ( @@ -32,12 +32,12 @@ var ( func main() { u, err := url.Parse(*flagBackend) if err != nil { - log.Fataln(err) + log.Fatalln(err) } - err := http.ListenAndServe(":80", websocketproxy.NewProxy(u)) + err = http.ListenAndServe(":80", websocketproxy.NewProxy(u)) if err != nil { - log.Fataln(err) + log.Fatalln(err) } } ``` diff --git a/websocketproxy.go b/websocketproxy.go index e6fc4b0..28cf7c3 100644 --- a/websocketproxy.go +++ b/websocketproxy.go @@ -2,6 +2,8 @@ package websocketproxy import ( + "errors" + "fmt" "io" "log" "net" @@ -22,6 +24,8 @@ var ( // DefaultDialer is a dialer with all fields set to the default zero values. DefaultDialer = websocket.DefaultDialer + + errNilChannelClose = errors.New("trying to close nil channel") ) // WebsocketProxy is an HTTP Handler that takes an incoming WebSocket @@ -44,6 +48,10 @@ type WebsocketProxy struct { // Dialer contains options for connecting to the backend WebSocket server. // If nil, DefaultDialer is used. Dialer *websocket.Dialer + + // Stop channels to close the websocket on demand + stopClientChan chan struct{} + stopBackendChan chan struct{} } // ProxyHandler returns a new http.Handler interface that reverse proxies the @@ -64,6 +72,22 @@ func NewProxy(target *url.URL) *WebsocketProxy { return &WebsocketProxy{Backend: backend} } +// Stop websocket proxy on demand +func (w *WebsocketProxy) CloseProxy() (err error) { + err = nil + if w.stopBackendChan != nil { + close(w.stopBackendChan) + } else { + err = errNilChannelClose + } + if w.stopClientChan != nil { + close(w.stopClientChan) + } else { + err = errNilChannelClose + } + return err +} + // ServeHTTP implements the http.Handler that proxies WebSocket connections. func (w *WebsocketProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) { if w.Backend == nil { @@ -96,6 +120,9 @@ func (w *WebsocketProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) { for _, cookie := range req.Header[http.CanonicalHeaderKey("Cookie")] { requestHeader.Add("Cookie", cookie) } + if req.Host != "" { + requestHeader.Set("Host", req.Host) + } // Pass X-Forwarded-For headers too, code below is a part of // httputil.ReverseProxy. See http://en.wikipedia.org/wiki/X-Forwarded-For @@ -133,7 +160,17 @@ func (w *WebsocketProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) { // http://tools.ietf.org/html/draft-ietf-hybi-websocket-multiplexing-01 connBackend, resp, err := dialer.Dial(backendURL.String(), requestHeader) if err != nil { - log.Printf("websocketproxy: couldn't dial to remote backend url %s\n", err) + log.Printf("websocketproxy: couldn't dial to remote backend url %s", err) + if resp != nil { + // If the WebSocket handshake fails, ErrBadHandshake is returned + // along with a non-nil *http.Response so that callers can handle + // redirects, authentication, etcetera. + if err := copyResponse(rw, resp); err != nil { + log.Printf("websocketproxy: couldn't write response after failed remote backend handshake: %s", err) + } + } else { + http.Error(rw, http.StatusText(http.StatusServiceUnavailable), http.StatusServiceUnavailable) + } return } defer connBackend.Close() @@ -143,32 +180,89 @@ func (w *WebsocketProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) { upgrader = DefaultUpgrader } - // Only pass those headers to the upgrader. + // passing all headers except those which can become duplicate upgradeHeader := http.Header{} - if hdr := resp.Header.Get("Sec-Websocket-Protocol"); hdr != "" { - upgradeHeader.Set("Sec-Websocket-Protocol", hdr) - } - if hdr := resp.Header.Get("Set-Cookie"); hdr != "" { - upgradeHeader.Set("Set-Cookie", hdr) - } + copyHeader(upgradeHeader, resp.Header) + + // These are extra header which the upgrader actually sets itself so need to remove these to avoid duplicate headers + upgradeHeader.Del("Connection") + upgradeHeader.Del("Upgrade") + upgradeHeader.Del("Sec-WebSocket-Accept") // Now upgrade the existing incoming request to a WebSocket connection. // Also pass the header that we gathered from the Dial handshake. connPub, err := upgrader.Upgrade(rw, req, upgradeHeader) if err != nil { - log.Printf("websocketproxy: couldn't upgrade %s\n", err) + log.Printf("websocketproxy: couldn't upgrade %s", err) return } defer connPub.Close() - errc := make(chan error, 2) - cp := func(dst io.Writer, src io.Reader) { - _, err := io.Copy(dst, src) - errc <- err + errClient := make(chan error, 1) + errBackend := make(chan error, 1) + replicateWebsocketConn := func(dst, src *websocket.Conn, errc chan error, stopChan chan struct{}) { + for { + // do until stopChan gets any message + select { + default: + msgType, msg, err := src.ReadMessage() + if err != nil { + m := websocket.FormatCloseMessage(websocket.CloseNormalClosure, fmt.Sprintf("%v", err)) + if e, ok := err.(*websocket.CloseError); ok { + if e.Code != websocket.CloseNoStatusReceived { + m = websocket.FormatCloseMessage(e.Code, e.Text) + } + } + errc <- err + dst.WriteMessage(websocket.CloseMessage, m) + break + } + err = dst.WriteMessage(msgType, msg) + if err != nil { + errc <- err + break + } + case <-stopChan: + dst.WriteMessage(websocket.CloseMessage, []byte("Closed by proxy")) + return + } + + } } - // Start our proxy now, everything is ready... - go cp(connBackend.UnderlyingConn(), connPub.UnderlyingConn()) - go cp(connPub.UnderlyingConn(), connBackend.UnderlyingConn()) - <-errc + // initiate the stop channels + w.stopClientChan = make(chan struct{}) + w.stopBackendChan = make(chan struct{}) + + go replicateWebsocketConn(connPub, connBackend, errClient, w.stopClientChan) + go replicateWebsocketConn(connBackend, connPub, errBackend, w.stopBackendChan) + + var message string + select { + case err = <-errClient: + message = "websocketproxy: Error when copying from backend to client: %v" + case err = <-errBackend: + message = "websocketproxy: Error when copying from client to backend: %v" + + } + if e, ok := err.(*websocket.CloseError); !ok || e.Code == websocket.CloseAbnormalClosure { + log.Printf(message, err) + } +} + +func copyHeader(dst, src http.Header) { + for k, vv := range src { + for _, v := range vv { + dst.Add(k, v) + } + } +} + +func copyResponse(rw http.ResponseWriter, resp *http.Response) error { + copyHeader(rw.Header(), resp.Header) + rw.WriteHeader(resp.StatusCode) + defer resp.Body.Close() + + _, err := io.Copy(rw, resp.Body) + return err } diff --git a/websocketproxy_test.go b/websocketproxy_test.go index 63f7861..b90e02b 100644 --- a/websocketproxy_test.go +++ b/websocketproxy_test.go @@ -45,6 +45,12 @@ func TestProxy(t *testing.T) { go func() { mux2 := http.NewServeMux() mux2.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { + // Don't upgrade if original host header isn't preserved + if r.Host != "127.0.0.1:7777" { + log.Printf("Host header set incorrectly. Expecting 127.0.0.1:7777 got %s", r.Host) + return + } + conn, err := upgrader.Upgrade(w, r, nil) if err != nil { log.Println(err)