Merge pull request #40 from nhooyr/impl

Implement handshake

Author: nhooyr

.github/CONTRIBUTING.md

@@ -0,0 +1,16 @@
+# Contributing Guidelines
+
+Please split up changes into several small descriptive commits.
+
+Please capitalize the first word in the commit message and ensure it is
+descriptive.
+
+The commit message should use the verb tense + phrase that completes the blank in
+
+> This change modifies websocket to ___________
+
+Be sure to link to an existing issue if one exists. In general, try creating an issue
+before making a PR to get some discussion going and to make sure you do not spend time
+on a PR that may be rejected.
+
+Run `test.sh` to test your changes. You only need docker and bash to run tests.

.github/fmt/entrypoint.sh

@@ -8,7 +8,6 @@ gen() {
 	go list ./... > /dev/null
 	go mod tidy
 
-	go install golang.org/x/tools/cmd/stringer
 	go generate ./...
 }
 

README.md

@@ -16,84 +16,81 @@ go get nhooyr.io/websocket@master
 
 ## Features
 
+- HTTP/2 over WebSocket's support
 - Full support of the WebSocket protocol
+- Only depends on the stdlib
 - Simple to use because of the minimal API
 - Uses the context package for cancellation
 - Uses net/http's Client to do WebSocket dials
 - Compression of text frames larger than 1024 bytes by default
-- Highly optimized
-- API will transparently work with WebSockets over HTTP/2
+- Highly optimized where it matters
 - WASM support
 
 ## Example
 
 ### Server
 
 ```go
-func main() {
-	fn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		c, err := websocket.Accept(w, r,
-			websocket.AcceptSubprotocols("test"),
-		)
-		if err != nil {
-			log.Printf("server handshake failed: %v", err)
-			return
-		}
-		defer c.Close(websocket.StatusInternalError, "")
-
-		ctx, cancel := context.WithTimeout(r.Context(), time.Second*10)
-		defer cancel()
-
-		v := map[string]interface{}{
-			"my_field": "foo",
-		}
-		err = websocket.WriteJSON(ctx, c, v)
-		if err != nil {
-			log.Printf("failed to write json: %v", err)
-			return
-		}
-
-		log.Printf("wrote %v", v)
-
-		c.Close(websocket.StatusNormalClosure, "")
-	})
-	err := http.ListenAndServe("localhost:8080", fn)
+fn := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	c, err := websocket.Accept(w, r,
+		websocket.AcceptSubprotocols("test"),
+	)
 	if err != nil {
-		log.Fatalf("failed to listen and serve: %v", err)
+		log.Printf("server handshake failed: %v", err)
+		return
 	}
- }
-```
-
-For a production quality example that shows off the low level API, see the echo example on the [godoc](https://godoc.org/nhooyr.io/websocket#Accept).
-
-### Client
+	defer c.Close(websocket.StatusInternalError, "")
 
-```go
-func main() {
-	ctx := context.Background()
-	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
+	ctx, cancel := context.WithTimeout(r.Context(), time.Second*10)
 	defer cancel()
 
-	c, _, err := websocket.Dial(ctx, "ws://localhost:8080",
-		websocket.DialSubprotocols("test"),
-	)
-	if err != nil {
-		log.Fatalf("failed to ws dial: %v", err)
+	v := map[string]interface{}{
+		"my_field": "foo",
 	}
-	defer c.Close(websocket.StatusInternalError, "")
-
-	var v interface{}
-	err = websocket.ReadJSON(ctx, c, v)
+	err = websocket.WriteJSON(ctx, c, v)
 	if err != nil {
-		log.Fatalf("failed to read json: %v", err)
+		log.Printf("failed to write json: %v", err)
+		return
 	}
 
-	log.Printf("received %v", v)
+	log.Printf("wrote %v", v)
 
 	c.Close(websocket.StatusNormalClosure, "")
+})
+err := http.ListenAndServe("localhost:8080", fn)
+if err != nil {
+	log.Fatalf("failed to listen and serve: %v", err)
 }
 ```
 
+For a production quality example that shows off the low level API, see the echo example on the [godoc](https://godoc.org/nhooyr.io/websocket#Accept).
+
+### Client
+
+```go
+ctx := context.Background()
+ctx, cancel := context.WithTimeout(ctx, time.Second*10)
+defer cancel()
+
+c, _, err := websocket.Dial(ctx, "ws://localhost:8080",
+	websocket.DialSubprotocols("test"),
+)
+if err != nil {
+	log.Fatalf("failed to ws dial: %v", err)
+}
+defer c.Close(websocket.StatusInternalError, "")
+
+var v interface{}
+err = websocket.ReadJSON(ctx, c, v)
+if err != nil {
+	log.Fatalf("failed to read json: %v", err)
+}
+
+log.Printf("received %v", v)
+
+c.Close(websocket.StatusNormalClosure, "")
+```
+
 See [example_test.go](example_test.go) for more examples.
 
 ## Design considerations
@@ -105,24 +102,28 @@ See [example_test.go](example_test.go) for more examples.
 - net.Conn is never exposed as WebSocket's over HTTP/2 will not have a net.Conn.
 - Functional options make the API very clean and easy to extend
 - Compression is very useful for JSON payloads
-- Protobuf and JSON helpers make code terse
+- JSON helpers make code terse
 - Using net/http's Client for dialing means we do not have to reinvent dialing hooks
   and configurations. Just pass in a custom net/http client if you want custom dialing.
 
 ## Comparison
 
+While I believe nhooyr/websocket has a better API than existing libraries, 
+both gorilla/websocket and gobwas/ws were extremely useful in implementing the
+WebSocket protocol correctly so big thanks to the authors of both.
+
 ### gorilla/websocket
 
 https://github.com/gorilla/websocket
 
-This package is the community standard but it is very old and over timennn
+This package is the community standard but it is very old and over time
 has accumulated cruft. There are many ways to do the same thing and the API
-overall is just not very clear. Just compare the godoc of
+is not clear. Just compare the godoc of
 [nhooyr/websocket](godoc.org/github.com/nhooyr/websocket) side by side with
 [gorilla/websocket](godoc.org/github.com/gorilla/websocket).
 
 The API for nhooyr/websocket has been designed such that there is only one way to do things
-and with HTTP/2 in mind which makes using it correctly and safely much easier.
+which makes using it correctly and safely much easier.
 
 ### x/net/websocket
 
@@ -137,12 +138,12 @@ See https://github.com/golang/go/issues/18152
 https://github.com/gobwas/ws
 
 This library has an extremely flexible API but that comes at the cost of usability
-and clarity. Its just not clear how to do things in a safe manner. 
+and clarity. Its not clear what the best way to do anything is.
 
-This library is fantastic in terms of performance though. The author put in significant
-effort to ensure its speed and I have tried to apply as many of its teachings as
+This library is fantastic in terms of performance. The author put in significant
+effort to ensure its speed and I have applied as many of its optimizations as
 I could into nhooyr/websocket.
 
 If you want a library that gives you absolute control over everything, this is the library,
 but for most users, the API provided by nhooyr/websocket will definitely fit better as it will
-be just as performant but much easier to use.
+be just as performant but much easier to use correctly.

accept.go

@@ -1,33 +1,48 @@
 package websocket
 
 import (
-	"fmt"
+	"crypto/sha1"
+	"encoding/base64"
 	"net/http"
+	"net/url"
+	"strings"
+
+	"golang.org/x/net/http/httpguts"
+	"golang.org/x/xerrors"
 )
 
 // AcceptOption is an option that can be passed to Accept.
+// The implementations of this interface are printable.
 type AcceptOption interface {
 	acceptOption()
-	fmt.Stringer
 }
 
+type acceptSubprotocols []string
+
+func (o acceptSubprotocols) acceptOption() {}
+
 // AcceptSubprotocols list the subprotocols that Accept will negotiate with a client.
 // The first protocol that a client supports will be negotiated.
-// Pass "" as a subprotocol if you would like to allow the default protocol.
+// Pass "" as a subprotocol if you would like to allow the default protocol along with
+// specific subprotocols.
 func AcceptSubprotocols(subprotocols ...string) AcceptOption {
-	panic("TODO")
+	return acceptSubprotocols(subprotocols)
 }
 
+type acceptOrigins []string
+
+func (o acceptOrigins) acceptOption() {}
+
 // AcceptOrigins lists the origins that Accept will accept.
 // Accept will always accept r.Host as the origin so you do not need to
 // specify that with this option.
 //
 // Use this option with caution to avoid exposing your WebSocket
 // server to a CSRF attack.
 // See https://stackoverflow.com/a/37837709/4283659
-// You can use a * to specify wildcards.
+// You can use a * for wildcards.
 func AcceptOrigins(origins ...string) AcceptOption {
-	panic("TODO")
+	return AcceptOrigins(origins...)
 }
 
 // Accept accepts a WebSocket handshake from a client and upgrades the
@@ -36,5 +51,126 @@ func AcceptOrigins(origins ...string) AcceptOption {
 // InsecureAcceptOrigin is passed.
 // Accept uses w to write the handshake response so the timeouts on the http.Server apply.
 func Accept(w http.ResponseWriter, r *http.Request, opts ...AcceptOption) (*Conn, error) {
-	panic("TODO")
+	var subprotocols []string
+	origins := []string{r.Host}
+	for _, opt := range opts {
+		switch opt := opt.(type) {
+		case acceptOrigins:
+			origins = []string(opt)
+		case acceptSubprotocols:
+			subprotocols = []string(opt)
+		}
+	}
+
+	if !httpguts.HeaderValuesContainsToken(r.Header["Connection"], "Upgrade") {
+		err := xerrors.Errorf("websocket: protocol violation: Connection header does not contain Upgrade: %q", r.Header.Get("Connection"))
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return nil, err
+	}
+
+	if !httpguts.HeaderValuesContainsToken(r.Header["Upgrade"], "websocket") {
+		err := xerrors.Errorf("websocket: protocol violation: Upgrade header does not contain websocket: %q", r.Header.Get("Upgrade"))
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return nil, err
+	}
+
+	if r.Method != "GET" {
+		err := xerrors.Errorf("websocket: protocol violation: handshake request method is not GET: %q", r.Method)
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return nil, err
+	}
+
+	if r.Header.Get("Sec-WebSocket-Version") != "13" {
+		err := xerrors.Errorf("websocket: unsupported protocol version: %q", r.Header.Get("Sec-WebSocket-Version"))
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return nil, err
+	}
+
+	if r.Header.Get("Sec-WebSocket-Key") == "" {
+		err := xerrors.New("websocket: protocol violation: missing Sec-WebSocket-Key")
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return nil, err
+	}
+
+	origins = append(origins, r.Host)
+
+	err := authenticateOrigin(r, origins)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusForbidden)
+		return nil, err
+	}
+
+	hj, ok := w.(http.Hijacker)
+	if !ok {
+		err = xerrors.New("websocket: response writer does not implement http.Hijacker")
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return nil, err
+	}
+
+	w.Header().Set("Upgrade", "websocket")
+	w.Header().Set("Connection", "Upgrade")
+
+	handleKey(w, r)
+
+	selectSubprotocol(w, r, subprotocols)
+
+	w.WriteHeader(http.StatusSwitchingProtocols)
+
+	netConn, brw, err := hj.Hijack()
+	if err != nil {
+		err = xerrors.Errorf("websocket: failed to hijack connection: %v", err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return nil, err
+	}
+
+	c := &Conn{
+		subprotocol: w.Header().Get("Sec-WebSocket-Protocol"),
+		br:          brw.Reader,
+		bw:          brw.Writer,
+		closer:      netConn,
+	}
+	c.init()
+
+	return c, nil
+}
+
+func selectSubprotocol(w http.ResponseWriter, r *http.Request, subprotocols []string) {
+	clientSubprotocols := strings.Split(r.Header.Get("Sec-WebSocket-Protocol"), "\n")
+	for _, sp := range subprotocols {
+		for _, cp := range clientSubprotocols {
+			if sp == strings.TrimSpace(cp) {
+				w.Header().Set("Sec-WebSocket-Protocol", sp)
+				return
+			}
+		}
+	}
+}
+
+var keyGUID = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
+
+func handleKey(w http.ResponseWriter, r *http.Request) {
+	key := r.Header.Get("Sec-WebSocket-Key")
+	h := sha1.New()
+	h.Write([]byte(key))
+	h.Write(keyGUID)
+
+	responseKey := base64.StdEncoding.EncodeToString(h.Sum(nil))
+	w.Header().Set("Sec-WebSocket-Accept", responseKey)
+}
+
+func authenticateOrigin(r *http.Request, origins []string) error {
+	origin := r.Header.Get("Origin")
+	if origin == "" {
+		return nil
+	}
+	u, err := url.Parse(origin)
+	if err != nil {
+		return xerrors.Errorf("failed to parse Origin header %q: %v", origin, err)
+	}
+	for _, o := range origins {
+		if u.Host == o {
+			return nil
+		}
+	}
+	return xerrors.New("request origin is not authorized")
 }