func GetGoogleClaims(tokenString string) (*GoogleClaim, error) {
	googleClaim := GoogleClaim{}
	googleToken.Lock()
	defer googleToken.Unlock()
check_again:
	if googleToken.certs == nil || len(googleToken.certs) == 0 {
		resp, err := http.Get(googleCertificateURL)
		if err != nil {
			log.Printf("Error connecting to %s", googleCertificateURL)
			return nil, err
		}
		defer resp.Body.Close()
		bytes, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			log.Printf("Error reading from %s", googleCertificateURL)
			return nil, err
		}
		err = json.Unmarshal(bytes, &googleToken.certs)
		if err != nil {
			log.Printf("Unable to unmarshal from %s", googleCertificateURL)
			return nil, err
		}
		for _, value := range resp.Header.Values("Cache-Control") {
			if strings.Contains(value, "max-age") {
				allValues := strings.Split(value, ",")
				var maxAgeVal string
				for _, val := range allValues {
					if strings.Contains(val, "max-age") {
						maxAgeVal = val
						break
					}
				}
				val, err := strconv.ParseInt(strings.Split(maxAgeVal, "=")[1], 10, 64)
				if err != nil {
					val = 0
				}
				log.Printf("Setting google's cert timeout value to %d seconds\n", val)
				googleToken.timeout = time.Now().Unix() + val
			}
		}
	} else if googleToken.timeout <= time.Now().Unix() {
		googleToken.certs = nil
		goto check_again
	}
	//ParseWithClaims requires either a signing key or
	//the public key. Since we're using the PEM format
	//the public key needs to be extraced from the certificate
	//presented by google.
	token, err := jwt.ParseWithClaims(tokenString, &googleClaim,
		func(token *jwt.Token) (interface{}, error) {
			var publicCert string
			if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
				return nil, fmt.Errorf("unexpected signing method %v", token.Header["alg"])
			}
			//Get the public key from the certificate
			//which signed this token. Which certificate
			//to use is identified by the "kid" field in
			//token. (kid = key identifier)
			publicCert = googleToken.certs[token.Header["kid"].(string)].(string)
			publicKey, err := jwt.ParseRSAPublicKeyFromPEM([]byte(publicCert))
			if err != nil {
				log.Printf("Not a valid RSA Key %s\n", publicCert)
				return nil, errors.New("Invalid RSA key found")
			}
			return publicKey, nil
		})
	if err != nil {
		log.Printf("error parsing %v\n", err)
		log.Printf("token = %v\n", token)
		return nil, errors.New("Invalid google token")
	}
	if claims, ok := token.Claims.(*GoogleClaim); ok && token.Valid {
		log.Printf("Claims are valid %v", claims)
		return &googleClaim, nil
	}
	return nil, errors.New("Invalid google token")
}