// Like Verify on a parsed URL
func VerifyValues(values url.Values) (grant bool, identifier string, err error) {
err = nil
var postArgs url.Values
postArgs = url.Values(map[string][]string{})
// Create the url
URLEndPoint := values.Get("openid.op_endpoint")
if URLEndPoint == "" {
log.Printf("no openid.op_endpoint")
return false, "", errors.New("no openid.op_endpoint")
}
for k, v := range values {
postArgs[k] = v
}
postArgs.Set("openid.mode", "check_authentication")
postContent := postArgs.Encode()
// Post the request
var client = new(http.Client)
postReader := bytes.NewBuffer([]byte(postContent))
response, err := client.Post(URLEndPoint, "application/x-www-form-urlencoded", postReader)
if err != nil {
log.Printf("VerifyValues failed at post")
return false, "", err
}
// Parse the response
// Convert the reader
// We limit the size of the response to 1024 bytes but it should be large enough for most cases
buffer := make([]byte, 1024)
_, err = response.Body.Read(buffer)
if err != nil {
log.Printf("VerifyValues failed reading response")
return false, "", err
}
// Check for ns
rematch := REVerifyDirectNs.FindSubmatch(buffer)
if rematch == nil {
return false, "", errors.New("VerifyValues: ns value not found on the response of the OP")
}
nsValue := string(rematch[1])
if !bytes.Equal([]byte(nsValue), []byte("http://specs.openid.net/auth/2.0")) {
return false, "", errors.New("VerifyValues: ns value not correct: " + nsValue)
}
// Check for is_valid
match, err := regexp.Match(REVerifyDirectIsValid, buffer)
if err != nil {
return false, "", err
}
identifier = values.Get("openid.claimed_id")
if !match {
log.Printf("no is_valid:true in \"%s\"", buffer)
}
return match, identifier, nil
}
// (2011-06-21) - The standard go http.Values.Escape
// works properly for SQS and S3, but it should be
// noted that at least SDB requiers more to be escaped
// than is officially standard.
//
// Sorted Escape also sorts the keys before joining them (needed
// for canonicalization).
func SortedEscape(v url.Values) (out string) {
keys := []string{}
for k := range v {
keys = append(keys, k)
}
sort.Strings(keys)
for k := range keys {
if k > 0 {
out += "&"
}
// out += http.URLEscape(keys[k]) + "=" + http.URLEscape(v.Get(keys[k]))
out += escape(keys[k]) + "=" + escape(v.Get(keys[k]))
}
return
}
func retrieveInfo(client oauth2_client.OAuth2Client, scope, userId, projection, id string, m url.Values, value interface{}) (err os.Error) {
var useUserId string
if len(userId) <= 0 {
useUserId = GOOGLE_DEFAULT_USER_ID
} else {
useUserId = url.QueryEscape(userId)
}
if len(projection) <= 0 {
projection = GOOGLE_DEFAULT_PROJECTION
}
headers := make(http.Header)
headers.Set("GData-Version", "3.0")
if m == nil {
m = make(url.Values)
}
if len(m.Get(CONTACTS_ALT_PARAM)) <= 0 {
m.Set(CONTACTS_ALT_PARAM, "json")
}
uri := GOOGLE_FEEDS_API_ENDPOINT
for _, s := range []string{scope, useUserId, projection, id} {
if len(s) > 0 {
if uri[len(uri)-1] != '/' {
uri += "/"
}
uri += s
}
}
resp, _, err := oauth2_client.AuthorizedGetRequest(client, headers, uri, m)
if err != nil {
return err
}
if resp != nil {
if resp.StatusCode >= 400 {
b, _ := ioutil.ReadAll(resp.Body)
err = os.NewError(string(b))
} else {
err = json.NewDecoder(resp.Body).Decode(value)
}
}
return err
}
