Serving a websocket in Go

I'm starting to play around with websockets + go and well I think I'm misunderstanding something quite basic with websockets in Go.

I'd like to simply listen for a websocket connection and process accordingly. However all examples I see in Go using websocket is serving the web page that then connects to the websocket, is this a requirement?

The following is a basic echo server I have setup:

package main

import (
  "fmt"
  "code.google.com/p/go.net/websocket"
  "net/http"
)

func webHandler(ws *websocket.Conn) {
  var s string
  fmt.Fscan(ws, &s)
  fmt.Println("Received: ", s)
}

func main() {
  fmt.Println("Starting websock server: ")
  http.Handle("/echo", websocket.Handler(webHandler))
  err := http.ListenAndServe(":8080", nil)
  if err != nil {
    panic("ListenAndServe: " + err.Error())
  }
}

This is the javascript used to connect:

ws = new WebSocket("ws://localhost:8080/echo");
ws.onmessage = function(e) {
    console.log("websock: " + e.data);
};

However this results in:
WebSocket connection to 'ws://localhost:8080/echo' failed: Unexpected response code: 403

When working with websockets from Javascript, you will seldom have to read the frames directly. To be honest, I am not even sure how to do that.

Fortunately, the websocket package already has a type, Codec that does this for you. My suggestion is to use the predefined websocket.Message codec to Recieve and Send messages instead.

>Message is a codec to send/receive text/binary data in a frame on WebSocket connection. To send/receive text frame, use string type. To send/receive binary frame, use []byte type.

Using websocket.Message, your webHandler would look something like this:

func webHandler(ws *websocket.Conn) {
	var in []byte
	if err := websocket.Message.Receive(ws, &in); err != nil {
		return
	}
	fmt.Printf("Received: %s\n", string(in))
	websocket.Message.Send(ws, in)    	
}

And, no, it is not a requirement that Go serves the webpage. The 403 error you received does not have to do with Go or the websocket package.

I had a similar issue and the 403 error problem is related to how Go treats the http Origin header:

> Handler is a simple interface to a WebSocket browser client. It checks if Origin header is valid URL by default. You might want to verify websocket.Conn.Config().Origin in the func. If you use Server instead of Handler, you could call websocket.Origin and check the origin in your Handshake func. So, if you want to accept non-browser client, which doesn't send Origin header, you could use Server . that doesn't check origin in its Handshake.

In order to disable the Origin check, you must use something like:

http.HandleFunc("/echo",
	func (w http.ResponseWriter, req *http.Request) {
		s := websocket.Server{Handler: websocket.Handler(webHandler)}
		s.ServeHTTP(w, req)
	});

At least that solved the issue for me (server to server WebSocket communication) and I think it could solve the problem as well if the origin header does not match.