// writeCookies writes the wire representation of the cookies
// to w. Each cookie is written on a separate "Cookie: " line.
// This choice is made because HTTP parsers tend to have a limit on
// line-length, so it seems safer to place cookies on separate lines.
func writeCookies(w io.Writer, kk []*http.Cookie) os.Error {
lines := make([]string, 0, len(kk))
var b bytes.Buffer
for _, c := range kk {
b.Reset()
n := c.Name
// TODO(petar): c.Value (below) should be unquoted if it is recognized as quoted
fmt.Fprintf(&b, "%s=%s", http.CanonicalHeaderKey(n), c.Value)
if len(c.Path) > 0 {
fmt.Fprintf(&b, "; $Path=%s", url.QueryEscape(c.Path))
}
if len(c.Domain) > 0 {
fmt.Fprintf(&b, "; $Domain=%s", url.QueryEscape(c.Domain))
}
if c.HttpOnly {
fmt.Fprintf(&b, "; $HttpOnly")
}
lines = append(lines, "Cookie: "+b.String()+"\r\n")
}
sort.Strings(lines)
for _, l := range lines {
if _, err := io.WriteString(w, l); err != nil {
return err
}
}
return nil
}
func PostFacebookLink(text string, urls []string) {
u := make(url.Values)
u.Add("access_token", accessToken)
u.Add("link", url.QueryEscape(urls[0]))
u.Add("message", url.QueryEscape(text))
http.PostForm(linkURL, u)
}
func (b *HttpRequestBuilder) getResponse() (*http.Response, os.Error) {
var paramBody string
if b.params != nil && len(b.params) > 0 {
var buf bytes.Buffer
for k, v := range b.params {
buf.WriteString(url.QueryEscape(k))
buf.WriteByte('=')
buf.WriteString(url.QueryEscape(v))
buf.WriteByte('&')
}
paramBody = buf.String()
paramBody = paramBody[0 : len(paramBody)-1]
}
if b.req.Method == "GET" && len(paramBody) > 0 {
if strings.Index(b.url, "?") != -1 {
b.url += "&" + paramBody
} else {
b.url = b.url + "?" + paramBody
}
} else if b.req.Method == "POST" && b.req.Body == nil && len(paramBody) > 0 {
b.Header("Content-Type", "application/x-www-form-urlencoded")
b.req.Body = nopCloser{bytes.NewBufferString(paramBody)}
b.req.ContentLength = int64(len(paramBody))
}
conn, resp, err := getResponse(b.url, b.req)
b.clientConn = conn
return resp, err
}
func CreateAuthenticationRequest(OPEndPoint, ClaimedID, Realm, ReturnTo string) string {
var p = make(map[string]string)
p["openid.ns"] = "http://specs.openid.net/auth/2.0"
p["openid.mode"] = "checkid_setup"
if len(ClaimedID) == 0 {
p["openid.claimed_id"] = "http://specs.openid.net/auth/2.0/identifier_select"
p["openid.identity"] = "http://specs.openid.net/auth/2.0/identifier_select"
} else {
p["openid.claimed_id"] = ClaimedID
p["openid.identity"] = ClaimedID
}
p["openid.return_to"] = Realm + ReturnTo
p["openid.realm"] = Realm
var url_ string
url_ = OPEndPoint + "?"
for k, v := range p {
url_ += url.QueryEscape(k) + "=" + url.QueryEscape(v) + "&"
}
return url_
}
func Urlencode(data map[string]string) string {
var buf bytes.Buffer
for k, v := range data {
buf.WriteString(url.QueryEscape(k))
buf.WriteByte('=')
buf.WriteString(url.QueryEscape(v))
buf.WriteByte('&')
}
s := buf.String()
return s[0 : len(s)-1]
}
func RetrieveActivityList(client oauth2_client.OAuth2Client, userId, collection string, m url.Values) (*ActivityListResponse, os.Error) {
if userId == "" {
userId = "me"
}
if collection == "" {
collection = "public"
}
p := new(ActivityListResponse)
uri := ACTIVITY_LIST_ENDPOINT + url.QueryEscape(userId) + "/activities/" + url.QueryEscape(collection)
err := retrieveInfo(client, uri, m, p)
return p, err
}
func signupPost(w http.ResponseWriter, r *http.Request) {
responseType, client, err := params(r)
if err != nil {
err.WriteTo(w)
return
}
email, password := r.FormValue("email"), r.FormValue("password")
emailRegexp := regexp.MustCompile(`^[a-z0-9._%\-+]+@[a-z0-9.\-]+\.[a-z]+$`)
msgs := make([]string, 0, 5)
if !emailRegexp.MatchString(email) {
msgs = append(msgs, "Invalid email address")
}
if len(password) < 6 {
msgs = append(msgs, "Password is too short")
}
// Also check if email already exists
user := model.NewUser(email)
context := appengine.NewContext(r)
countExists, e := datastore.NewQuery("User").Filter("EmailHash =", user.EmailHash).Count(context)
if e != nil {
context.Errorf("%v", e)
http.Error(w, e.String(), http.StatusInternalServerError)
return
}
if countExists > 0 {
msgs = append(msgs, "Email already exists")
}
if msgsLen := len(msgs); msgsLen > 0 {
http.RedirectHandler("/oauth2/signup?response_type="+url.QueryEscape(responseType)+"&client_id="+
url.QueryEscape(client.Id)+"&msgs="+url.QueryEscape(strings.Join(msgs, "|")), 303).ServeHTTP(w, r)
} else {
userKey, err := datastore.Put(context, datastore.NewIncompleteKey(context, "User", nil), user)
if err != nil {
context.Errorf("Error saving: %v", err)
w.Write([]byte("Error saving: " + err.String()))
return
}
auth := model.NewPasswordAuth(userKey, password)
if _, err = datastore.Put(context, datastore.NewIncompleteKey(context, "Authentication", nil), auth); err != nil {
context.Errorf("Error saving: %v", err)
w.Write([]byte("Error saving: " + err.String()))
return
}
key := newCodeKey(userKey.StringID(), client.Id, context)
http.RedirectHandler(client.redirectUrl(key), 303).ServeHTTP(w, r)
}
}
// Obtain a URL which will allow the current user to authorize access to their
// OAuth-protected data.
func (c *UserConfig) GetAuthorizeURL(service *Service) (string, os.Error) {
if c.RequestTokenKey == "" || c.RequestTokenSecret == "" {
return "", os.NewError("No configured request token")
}
token := url.QueryEscape(c.RequestTokenKey)
return service.AuthorizeURL + "?oauth_token=" + token, nil
}
func remoteSearch(query string) (res *http.Response, err os.Error) {
search := "/search?f=text&q=" + url.QueryEscape(query)
// list of addresses to try
var addrs []string
if *serverAddr != "" {
// explicit server address - only try this one
addrs = []string{*serverAddr}
} else {
addrs = []string{
defaultAddr,
"golang.org",
}
}
// remote search
for _, addr := range addrs {
url := "http://" + addr + search
res, err = http.Get(url)
if err == nil && res.StatusCode == http.StatusOK {
break
}
}
if err == nil && res.StatusCode != http.StatusOK {
err = os.NewError(res.Status)
}
return
}
func renameTag(req *web.Request) {
// oldTag := req.Param.Get("oldTag")
newTag := req.Param.Get("newTag")
// updateTag(oldTag, newTag)
url := fmt.Sprintf("/tag/%s", url.QueryEscape(newTag))
req.Redirect(url, false)
}
func (i *Item) getLinkUrl(handlerFunc interface{}, values interface{}) string {
valueStubs, _, needsHash := makeStubs(values, false)
stubs := allStubs{Func: getFunctionName(handlerFunc), Values: valueStubs}
hashQuery := ""
if needsHash {
hash := getHash(stubs)
stubs.Hash = hash
hashQuery = "&_hash=" + hash
}
qstring := ""
for _, v := range stubs.Values {
if len(qstring) == 0 {
qstring += "?"
} else {
qstring += "&"
}
qstring += v.N + "=" + url.QueryEscape(toString(v.V))
}
href := "/" + stubs.Func + qstring + hashQuery
return href
}
func shorten(long string) (short string) {
key := "R_e659dbb5514e34edc3540a7c95b0041b"
login := "******"
long = url.QueryEscape(long)
url_ := fmt.Sprintf("http://api.bit.ly/v3/shorten?login=%s&apiKey=%s&longUrl=%s&format=json", login, key, long)
r, err := http.Get(url_)
defer r.Body.Close()
if err != nil {
return "Error connecting to bit.ly"
}
b, err := ioutil.ReadAll(r.Body)
if err != nil {
return "Error reading bit.ly response"
}
var j map[string]interface{}
err = json.Unmarshal(b, &j)
if err != nil {
return "Unable to shorten URL."
}
var data map[string]interface{} = j["data"].(map[string]interface{})
return data["url"].(string)
}
// Returns a map of all of the oauth_* (including signature) parameters for the
// given request, and the signature base string used to generate the signature.
func (s *HmacSha1Signer) GetOAuthParams(request *http.Request, clientConfig *ClientConfig, userConfig *UserConfig, nonce string, timestamp string) (map[string]string, string) {
request.ParseForm()
oauthParams := map[string]string{
"oauth_consumer_key": clientConfig.ConsumerKey,
"oauth_nonce": nonce,
"oauth_signature_method": "HMAC-SHA1",
"oauth_timestamp": timestamp,
"oauth_version": "1.0",
}
tokenKey, tokenSecret := userConfig.GetToken()
if tokenKey != "" {
oauthParams["oauth_token"] = tokenKey
}
signingParams := map[string]string{}
for key, value := range oauthParams {
signingParams[key] = value
}
for key, value := range request.URL.Query() {
//TODO: Support multiple parameters with the same name.
signingParams[key] = value[0]
}
for key, value := range request.Form {
//TODO: Support multiple parameters with the same name.
signingParams[key] = value[0]
}
signingUrl := fmt.Sprintf("%v://%v%v", request.URL.Scheme, request.URL.RawAuthority, request.URL.Path)
signatureParts := []string{
request.Method,
url.QueryEscape(signingUrl),
s.encodeParameters(signingParams)}
signatureBase := strings.Join(signatureParts, "&")
oauthParams["oauth_signature"] = s.GetSignature(clientConfig.ConsumerSecret, tokenSecret, signatureBase)
return oauthParams, signatureBase
}
func slurpURL(urlStr string) []byte {
diskFile := filepath.Join(os.TempDir(), "google-api-cache-"+url.QueryEscape(urlStr))
if *useCache {
bs, err := ioutil.ReadFile(diskFile)
if err == nil && len(bs) > 0 {
return bs
}
}
req, err := http.NewRequest("GET", urlStr, nil)
if err != nil {
log.Fatal(err)
}
if *publicOnly {
req.Header.Add("X-User-IP", "0.0.0.0") // hack
}
res, err := http.DefaultClient.Do(req)
if err != nil {
log.Fatalf("Error fetching URL %s: %v", urlStr, err)
}
bs, err := ioutil.ReadAll(res.Body)
if err != nil {
log.Fatalf("Error reading body of URL %s: %v", urlStr, err)
}
if *useCache {
if err := ioutil.WriteFile(diskFile, bs, 0666); err != nil {
log.Printf("Warning: failed to write JSON of %s to disk file %s: %v", urlStr, diskFile, err)
}
}
return bs
}
func addQueryVariables(url_ string, variables map[string]string) string {
var addition string
newUrl := url_
i := 0
for key, value := range variables {
if i == 0 {
addition = fmt.Sprintf("?%s=%s", key, url.QueryEscape(value))
} else {
addition = fmt.Sprintf("&%s=%s", key, url.QueryEscape(value))
}
newUrl += addition
i++
}
return newUrl
}
func loadPage(title string) (*Page, os.Error) {
filename := viewRoot + url.QueryEscape(title) + ".txt"
body, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
return &Page{Title: title, Body: body}, nil
}
func RetrieveActivity(client oauth2_client.OAuth2Client, activityId string, m url.Values) (*Activity, os.Error) {
if activityId == "" {
return nil, os.NewError("activityId cannot be empty")
}
p := new(Activity)
uri := ACTIVITY_ENDPOINT + url.QueryEscape(activityId)
err := retrieveInfo(client, uri, m, p)
return p, err
}
func delayedDelete(c appengine.Context, fi *FileInfo) {
if key := string(fi.Key); key != "" {
task := &taskqueue.Task{
Path: "/" + url.QueryEscape(key) + "/-",
Method: "DELETE", Delay: EXPIRATION_TIME * 1000000,
}
taskqueue.Add(c, task, "")
}
}
func (fi *FileInfo) CreateUrls(r *http.Request, c appengine.Context) {
u := &url.URL{
Scheme: r.URL.Scheme,
Host: appengine.DefaultVersionHostname(c),
}
u.Path = "/" + url.QueryEscape(string(fi.Key)) + "/" +
url.QueryEscape(string(fi.Name))
fi.Url = u.String()
fi.DeleteUrl = fi.Url
fi.DeleteType = "DELETE"
if fi.ThumbnailUrl != "" && -1 == strings.Index(
r.Header.Get("Accept"),
"application/json",
) {
u.Path = "/thumbnails/" + url.QueryEscape(string(fi.Key))
fi.ThumbnailUrl = u.String()
}
}
func RetrieveContact(client oauth2_client.OAuth2Client, userId string, m url.Values) (*Person, os.Error) {
if userId == "" {
userId = "me"
}
p := new(Person)
uri := PERSON_ENDPOINT + url.QueryEscape(userId)
err := retrieveInfo(client, uri, m, p)
return p, err
}
// FormEncodedBytes returns a buffer containing the URL form encoding of the
// map.
func (m Values) FormEncodedBytes() []byte {
var b bytes.Buffer
sep := false
for key, values := range m {
escapedKey := url.QueryEscape(key)
for _, value := range values {
if sep {
b.WriteByte('&')
} else {
sep = true
}
b.WriteString(escapedKey)
b.WriteByte('=')
b.WriteString(url.QueryEscape(value))
}
}
return b.Bytes()
}
func UpdateGroup(client oauth2_client.OAuth2Client, userId, projection string, original, value *ContactGroup) (response *GroupResponse, 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")
headers.Set("If-Match", original.Etag)
m := make(url.Values)
if len(m.Get(CONTACTS_ALT_PARAM)) <= 0 {
m.Set(CONTACTS_ALT_PARAM, "json")
}
uri := GOOGLE_GROUPS_API_ENDPOINT
for _, s := range []string{useUserId, projection, original.GroupId()} {
if len(s) > 0 {
if uri[len(uri)-1] != '/' {
uri += "/"
}
uri += s
}
}
entry := &GroupEntryUpdateRequest{Entry: value}
value.Xmlns = XMLNS_ATOM
value.XmlnsGcontact = XMLNS_GCONTACT
value.XmlnsBatch = XMLNS_GDATA_BATCH
value.XmlnsGd = XMLNS_GD
value.Etag = original.Etag
value.Id = original.Id
value.Updated.Value = time.UTC().Format(GOOGLE_DATETIME_FORMAT)
value.Categories = make([]AtomCategory, 1)
value.Categories[0].Scheme = ATOM_CATEGORY_SCHEME_KIND
value.Categories[0].Term = ATOM_CATEGORY_TERM_GROUP
buf, err := json.Marshal(entry)
if err != nil {
return
}
resp, _, err := oauth2_client.AuthorizedPutRequestBytes(client, headers, uri, m, buf)
if err != nil {
return
}
if resp != nil {
if resp.StatusCode >= 400 {
b, _ := ioutil.ReadAll(resp.Body)
err = os.NewError(string(b))
} else {
response = new(GroupResponse)
err = json.NewDecoder(resp.Body).Decode(response)
}
}
return
}
// URLQueryEscaper returns the escaped value of the textual representation of
// its arguments in a form suitable for embedding in a URL query.
func URLQueryEscaper(args ...interface{}) string {
s, ok := "", false
if len(args) == 1 {
s, ok = args[0].(string)
}
if !ok {
s = fmt.Sprint(args...)
}
return url.QueryEscape(s)
}
func encodeQuery(args map[string]string) string {
i := 0
s := bytes.NewBuffer(nil)
for k, v := range args {
if i != 0 {
s.WriteString("&")
}
i++
s.WriteString(k + "=" + url.QueryEscape(v))
}
return s.String()
}
func get_request_uri(param map[string]string) string {
post_body := ""
cnt := 0
for k, v := range param {
post_body += k + "=" + url.QueryEscape(v)
if cnt < len(param)-1 {
post_body += "&"
}
cnt++
}
return string(query_uri + "?" + post_body)
}
// writeSetCookies writes the wire representation of the set-cookies
// to w. Each cookie is written on a separate "Set-Cookie: " line.
// This choice is made because HTTP parsers tend to have a limit on
// line-length, so it seems safer to place cookies on separate lines.
func writeSetCookies(w io.Writer, kk []*http.Cookie) os.Error {
if kk == nil {
return nil
}
lines := make([]string, 0, len(kk))
var b bytes.Buffer
for _, c := range kk {
b.Reset()
// TODO(petar): c.Value (below) should be unquoted if it is recognized as quoted
fmt.Fprintf(&b, "%s=%s", http.CanonicalHeaderKey(c.Name), c.Value)
if len(c.Path) > 0 {
fmt.Fprintf(&b, "; Path=%s", url.QueryEscape(c.Path))
}
if len(c.Domain) > 0 {
fmt.Fprintf(&b, "; Domain=%s", url.QueryEscape(c.Domain))
}
if len(c.Expires.Zone) > 0 {
fmt.Fprintf(&b, "; Expires=%s", c.Expires.Format(time.RFC1123))
}
if c.MaxAge >= 0 {
fmt.Fprintf(&b, "; Max-Age=%d", c.MaxAge)
}
if c.HttpOnly {
fmt.Fprintf(&b, "; HttpOnly")
}
if c.Secure {
fmt.Fprintf(&b, "; Secure")
}
lines = append(lines, "Set-Cookie: "+b.String()+"\r\n")
}
sort.Strings(lines)
for _, l := range lines {
if _, err := io.WriteString(w, l); err != nil {
return err
}
}
return nil
}
func expand(short string) (long string) {
key := "R_e659dbb5514e34edc3540a7c95b0041b"
login := "******"
short = url.QueryEscape(short)
url_ := fmt.Sprintf("http://api.bit.ly/v3/expand?login=%s&apiKey=%s&shortUrl=%s&format=xml", login, key, short)
r, err := http.Get(url_)
defer r.Body.Close()
if err != nil {
return "Unable to connect to bit.ly"
}
type (
Entry struct {
Error string
Long_url string
}
Data struct {
Entry Entry
}
Response struct {
XMLName xml.Name `xml:"response"`
Data Data
}
)
var response Response
err = xml.Unmarshal(r.Body, &response)
if err != nil {
return "Unable to process response from bit.ly"
}
if response.Data.Entry.Error == "NOT_FOUND" {
return response.Data.Entry.Error
}
s := strings.TrimLeft(response.Data.Entry.Long_url, "http://")
s = strings.SplitN(s, "/", 2)[0]
if strings.Contains(s, "amazon.") {
return "amazon.com product"
} else if strings.Contains(s, "ebay.") {
return "ebay.com listing"
}
return response.Data.Entry.Long_url
}
func booruLoli(conn *irc.Conn, nick *irc.Nick, tag string, channel string) {
tag = "loli*"
tag = url.QueryEscape(tag)
site := fmt.Sprintf("http://ibsearch.i-forge.net/?action=randimage&randimage[phrase]=%s&format=xml", tag)
status := booruDoSearch(conn, channel, site)
switch {
case status == "FAIL":
say(conn, channel, "%s, you are a pervert! No loli for you! >:|", nick.Nick)
case status == "DOWN":
say(conn, channel, "booru search is down. If this keeps happening, please inform the owner.")
}
}
func booruSafeLoli(conn *irc.Conn, nick *irc.Nick, tag string, channel string) {
tag = "+loli* rating:s"
tag = url.QueryEscape(tag)
site := fmt.Sprintf("http://ibsearch.i-forge.net/?action=randimage&randimage[phrase]=%s&format=xml", tag)
status := booruDoSearch(conn, channel, site)
switch {
case status == "FAIL":
say(conn, channel, "Aww, I couldn't find anything this time... ;-;")
case status == "DOWN":
say(conn, channel, "booru search is down. If this keeps happening, please inform the owner.")
}
}
func CreateGroup(client oauth2_client.OAuth2Client, userId, projection string, value *ContactGroup) (response *GroupResponse, 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")
m := make(url.Values)
if len(m.Get(CONTACTS_ALT_PARAM)) <= 0 {
m.Set(CONTACTS_ALT_PARAM, "json")
}
uri := GOOGLE_GROUPS_API_ENDPOINT
for _, s := range []string{useUserId, projection} {
if len(s) > 0 {
if uri[len(uri)-1] != '/' {
uri += "/"
}
uri += s
}
}
entry := &GroupEntryInsertRequest{Version: "1.0", Encoding: "UTF-8", Entry: value}
value.Xmlns = XMLNS_ATOM
value.XmlnsGcontact = XMLNS_GCONTACT
value.XmlnsBatch = XMLNS_GDATA_BATCH
value.XmlnsGd = XMLNS_GD
buf, err := json.Marshal(entry)
if err != nil {
return
}
resp, _, err := oauth2_client.AuthorizedPostRequestBytes(client, headers, uri, m, buf)
if err != nil {
return
}
if resp != nil {
if resp.StatusCode >= 400 {
b, _ := ioutil.ReadAll(resp.Body)
err = os.NewError(string(b))
} else {
response = new(GroupResponse)
err = json.NewDecoder(resp.Body).Decode(response)
}
}
return
}