Passing a query parameter to the Go HTTP request handler using the MUX package

I am trying to pass an additional parameter in the request I am trying to send to the Go server -

websocket.create_connection("ws://<ip>:port/x/y?token="qwerty")

The Go server implementation is as follows -

func main() {
	err := config.Parse()
	if err != nil {
		glog.Error(err)
		os.Exit(1)
		return
	}

	flag.Parse()
	defer glog.Flush()

	router := mux.NewRouter()
	http.Handle("/", httpInterceptor(router))

	router.Handle("/v1/x", common.ErrorHandler(stats.GetS)).Methods("GET")
	router.Handle("/v1/x/y", common.ErrorHandler(stats.GetS)).Methods("GET")

	var listen = fmt.Sprintf("%s:%d", config.Config.Ip, config.Config.Port)
	err = http.ListenAndServe(listen, nil)

	if err != nil {
		glog.Error(err)
		os.Exit(1)
	}
}

func httpInterceptor(router http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		startTime := time.Now()
	
		if !auth.Auth(w, req) {
			http.Error(w, "Failed authentication", 401)
			return
		}

		router.ServeHTTP(w, req)

		finishTime := time.Now()
		elapsedTime := finishTime.Sub(startTime)

		switch req.Method {
		case "GET":
		case "POST":
		}

	})
}

How should I look and parse for the token in the Go server so that the authentication is successful?

Library function

func ParseFromRequest(req *http.Request, keyFunc Keyfunc) (token *Token, err error) {

	// Look for an Authorization header
	if ah := req.Header.Get("Authorization"); ah != "" {
		// Should be a bearer token
		if len(ah) > 6 && strings.ToUpper(ah[0:6]) == "BEARER" {
			return Parse(ah[7:], keyFunc)
		}
	}

	// Look for "access_token" parameter
	req.ParseMultipartForm(10e6)
	if tokStr := req.Form.Get("access_token"); tokStr != "" {
		return Parse(tokStr, keyFunc)
	}

	return nil, ErrNoTokenInRequest

}

Call FormValue to get a query parameter:

token := req.FormValue("token")

req is a the *http.Request

An alternative is to call ParseForm and access req.Form directly:

if err := req.ParseForm(); err != nil {
   // handle error
}
token := req.Form.Get("token")

The OP asks in a comment how to map "token" to "access_token" for an external package that's looking "access_token". Execute this code before calling the external package:

if err := req.ParseForm(); err != nil {
   // handle error
}
req.Form["access_token"] = req.Form["token"]

When the external package calls req.Form.Get("access_token"), it will get the same value as the "token" parameter.

Depending on the way you want to parse the token , if its coming from the form or the URL.

The first answer can be used if the token is being sent from the form while in case of a URL, I would suggest using this. This works for me

token := req.URL.Query().Get("token")

For url query parameters:

mux.Vars(r)["token"]