Callback Handle

callback.go

package main

import (
  "encoding/base64"
	"fmt"
	"io/ioutil"
	"net/http"
	gourl "net/url"
	"qbox.us/api"
	"qbox.us/digest_auth"
	"qbox.us/errors"
	"qbox.us/log"
	"qbox.us/net/httputil"
	"strings"
)

var (
	//SECRET_KEY = []byte("EZUwWLGLfbq0y94SLteofzzqKc60Dxg5kc1Rv2ct")
	SECRET_KEY = []byte("xxxxxxxxxxxxx")
)

func incBody(req *http.Request) bool {

	if req.ContentLength == 0 {
		return false
	}

	if ct, ok := req.Header["Content-Type"]; ok {
		switch ct[0] {
		case "application/x-www-form-urlencoded":
			return true
		}
	}
	return false
}

func authDigest(token string, req *http.Request) (err error) {
	pos := strings.Index(token, ":")
	if pos == -1 {
		err = errors.Info(api.EBadToken, "DigestAuth", token)
		return
	}

	sumCalc, err := digest_auth.Checksum(req, SECRET_KEY, incBody(req))
	if err != nil {
		err = errors.Info(err, "DigestAuth").Detail(err)
		return
	}

	sumExp := token[pos+1:]
	if sumCalc != sumExp {
		err = errors.Info(api.EBadToken, "DigestAuth: checksum error", sumCalc, sumExp)
	}
	return
}

func callback(w http.ResponseWriter, req *http.Request) {
	var err error
	authInfo := req.Header.Get("Authorization")
	if authInfo != "" {
		if !strings.HasPrefix(authInfo, "QBox ") {
			err = httputil.NewError(api.InvalidArgs, "no right authInfo")
			httputil.Error(w, err)
			return
		}
		token := authInfo[5:]
		err = authDigest(token, req)
		if err != nil {
			log.Warn("authDigest failed:", errors.Detail(err))
			err = httputil.NewError(api.BadToken, "auth failed")
			httputil.Error(w, err)
			return
		}
	}
	bs, _ := ioutil.ReadAll(req.Body)
	fmt.Println("Body:")
	fmt.Println(string(bs))
	m, err := gourl.ParseQuery(string(bs))
	if err != nil {
		err = httputil.NewError(api.InvalidArgs, "invalid query body")
		httputil.Error(w, err)
		return
	}
	httputil.Reply(w, 200, m)
}

func redirect(w http.ResponseWriter, req *http.Request) {
	err := req.ParseForm()
	if err != nil {
		err = httputil.NewError(api.InvalidArgs, "invalid query string")
		httputil.Error(w, err)
		return
	}
	errorStr := req.FormValue("error")
	if errorStr != "" {
		ctx := map[string]string{
			"code": req.FormValue("code"),
			"error": errorStr,
		}
		httputil.Reply(w, 200, ctx)
		return
	}
	uploadRet := req.FormValue("upload_ret")
	if uploadRet == "" {
		err = httputil.NewError(api.InvalidArgs, "no upload info")
		httputil.Error(w, err)
		return
	}
	jsonStr, err := base64.URLEncoding.DecodeString(uploadRet)
	if err != nil {
		err = httputil.NewError(api.InvalidArgs, "decode upload ret failed")
		httputil.Error(w, err)
		return
	}
	fmt.Println("Upload Ret:")
	fmt.Println(string(jsonStr))
	httputil.ReplyWith(w, 200, "application/json", jsonStr)
}

func pfop(w http.ResponseWriter, req *http.Request) {
	bs, _ := ioutil.ReadAll(req.Body)
	fmt.Println("Body:")
	fmt.Println(string(bs))
	httputil.ReplyWithCode(w, 200)
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/callback", callback)
	mux.HandleFunc("/redirect", redirect)
	mux.HandleFunc("/pfop", pfop)
	err := http.ListenAndServe(":31415", mux)
	log.Warn(err)
}