Exemplo n.º 1
0
func main() {
	flag.Parse()

	if flag.NArg() < 1 {
		fmt.Fprintf(os.Stderr, "Usage: %s [URL]\n", os.Args[0])
		os.Exit(1)
	}

	u := "http://kon.tl/create.php"
	d := map[string]string{"url": flag.Arg(0)}

	fmt.Println(" Long URL:", flag.Arg(0))

	r, err := http.PostForm(u, d)
	if err != nil {
		log.Fatalln(err)
	}
	defer r.Body.Close()

	b, err := ioutil.ReadAll(r.Body)
	if err != nil {
		log.Fatalln(err)
	}

	s := string(b)
	x := regexp.MustCompile("<a href=(.*) target=_blank>")
	m := x.FindStringSubmatch(s)[1]

	fmt.Println("Short URL:", m)
}
Exemplo n.º 2
0
func (c *Client) request(credentials *Credentials, url string, param web.ParamMap) (*Credentials, web.ParamMap, os.Error) {
	c.SignParam(credentials, "POST", url, param)
	resp, err := http.PostForm(url, param.StringMap())
	if err != nil {
		return nil, nil, err
	}
	p, err := ioutil.ReadAll(resp.Body)
	resp.Body.Close()
	if err != nil {
		return nil, nil, err
	}
	if resp.StatusCode != 200 {
		return nil, nil, os.NewError(fmt.Sprintf("OAuth server status %d, %s", resp.StatusCode, string(p)))
	}
	m := make(web.ParamMap)
	err = m.ParseFormEncodedBytes(p)
	if err != nil {
		return nil, nil, err
	}
	credentials = &Credentials{Token: m.Get("oauth_token"), Secret: m.Get("oauth_token_secret")}
	if credentials.Token == "" {
		return nil, nil, os.NewError("No OAuth token in server result")
	}
	if credentials.Secret == "" {
		return nil, nil, os.NewError("No OAuth secret in server result")
	}
	return credentials, m, nil
}
Exemplo n.º 3
0
func verifyAssertion(params map[string]string) bool {
	fields := map[string]string{"openid.mode": "check_authentication"}
	for k, v := range params {
		if k != "openid.mode" {
			fields[k] = v
		}
	}

	resp, err := http.PostForm(params["openid.op_endpoint"], fields)
	if err != nil {
		log.Println(err.String())
		return false
	}
	defer resp.Body.Close()

	content, err := ioutil.ReadAll(resp.Body)
	response := string(content)
	log.Println(response)
	lines := strings.Split(response, "\n", -1)
	for _, l := range lines {
		if l == "is_valid:true" {
			return true
		}
	}
	return false
}
Exemplo n.º 4
0
func processStats() {
	for {
		sr, ok := <-statReportChannel

		if !ok {
			done <- true
			break
		}

                if Verbose {
                        log.Printf("posting stat to stathat: %s, %v", sr.url(), sr.values())
                }

		if testingEnv {
			testPostChannel <- &testPost{sr.url(), sr.values()}
			continue
		}

		r, err := http.PostForm(sr.url(), sr.values())
		if err != nil {
			log.Printf("error posting stat to stathat: %s", err)
			continue
		}

                if Verbose {
                        body, _ := ioutil.ReadAll(r.Body)
                        log.Printf("stathat post result: %s", body)
                }

		r.Body.Close()
	}
}
Exemplo n.º 5
0
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)
}
Exemplo n.º 6
0
Arquivo: dnd.go Projeto: gaxxx/funx
func bye(ctx *web.Context) {
	res, err := http.PostForm("http://fantasyherald.com/quiz/dand/index.php", ctx.Request.Params)
	if err == nil {
		io.Copy(ctx, res.Body)
		defer res.Body.Close()
	}
	return
}
Exemplo n.º 7
0
func post() {
	url := fmt.Sprintf("http://%s/add", hosts[rand.Intn(len(hosts))])
	r, err := http.PostForm(url, map[string]string{"url": fooUrl})
	if err != nil {
		log.Println("post:", err)
		return
	}
	defer r.Body.Close()
	b, err := ioutil.ReadAll(r.Body)
	if err != nil {
		log.Println("post:", err)
		return
	}
	newURL <- string(b)
	stat.In <- "put"
}
Exemplo n.º 8
0
func updateTokens(params map[string][]string) (err os.Error) {
	println("Call: " + TOKENS_ENDPOINT)
	response, _ := http.PostForm(TOKENS_ENDPOINT, params)
	b, _ := ioutil.ReadAll(response.Body)
	println(string(b))

	var responseJson map[string]interface{}
	json.Unmarshal(b, &responseJson)
	if errorMessage, ok := responseJson["error"]; ok {
		return os.ErrorString(errorMessage.(string))
	} else {
		currentTokens = &tokens{responseJson["access_token"].(string), responseJson["refresh_token"].(string)}
		currentTokens.store()
		return nil
	}
	return os.ErrorString("access_token is null")
}
Exemplo n.º 9
0
Arquivo: twty.go Projeto: newblue/twty
func postTweet(token *oauth.Credentials, url string, opt map[string]string) os.Error {
	param := make(web.Values)
	for k, v := range opt {
		param.Set(k, v)
	}
	oauthClient.SignParam(token, "POST", url, param)
	res, err := http.PostForm(url, http.Values(param))
	if err != nil {
		log.Println("failed to post tweet:", err)
		return err
	}
	defer res.Body.Close()
	if res.StatusCode != 200 {
		log.Println("failed to get timeline:", err)
		return err
	}
	return nil
}
Exemplo n.º 10
0
// Login to the minecraft.net website using HTTPS.
func (c *minecraftClient) Login(username, password string) (err os.Error) {
	param := make(web.ParamMap)
	param.Set("username", username)
	param.Set("password", password)
	param.Set("use_secure", "true")
	url := MINECRAFT_LOGIN_URL + "?" + param.FormEncodedString()

	var resp *http.Response
	done := make(chan bool, 1)
	go func() {
		resp, err = http.PostForm(url, param.StringMap())
		done <- true
	}()

	timeout := time.After(MINECRAFT_NET_TIMEOUT * 1e9) //
	select {
	case <-done:
		break
	case <-timeout:
		return os.NewError("Login attempt timed out - " + MINECRAFT_LOGIN_URL)
	}
	if resp == nil {
		return os.NewError("Login server responded with a null body.")
	}

	switch resp.StatusCode {
	// A successful minecraft.net login is followed by a 302.
	case 302:
		if r, ok := resp.Header["Location"]; ok && len(r) > 0 {
			if r[0] == "https://www.minecraft.net/" {
				log.Println("Login successful.")
				return nil
			} else {
				return os.NewError("Login redirecting to unknown page: " + r[0])
			}
		}
	case 200:
		return os.NewError("Login failed.")
	}
	return os.NewError("Login return code: " + string(resp.StatusCode))
}
Exemplo n.º 11
0
// authLogin return auth code from AuthSub server.
// see: http://code.google.com/apis/accounts/docs/AuthForWebApps.html
func authLogin(config map[string]string) (auth string) {
	res, err := http.PostForm(
		"https://www.google.com/accounts/ClientLogin",
		map[string]string{
			"accountType": "GOOGLE",
			"Email":       config["email"],
			"Passwd":      config["password"],
			"service":     "code",
			"source":      "golang-goissue-" + version,
		})
	if err != nil {
		log.Fatal("failed to authenticate:", err)
	}
	defer res.Body.Close()
	b, _ := ioutil.ReadAll(res.Body)
	if res.StatusCode != 200 {
		log.Fatal("failed to authenticate:", res.Status)
	}
	lines := strings.Split(string(b), "\n", -1)
	return lines[2]
}
Exemplo n.º 12
0
func pingUser(twitterId int64, pingUrl string) {
	fmt.Printf("Pinging for update by user %d...\n", twitterId)

	resp, postErr := http.PostForm(
		pingUrl,
		url.Values{
			"update_twitter_id": {fmt.Sprintf("%d", twitterId)},
			"secret":            {*streamSpigotSecret},
		})
	if postErr != nil {
		fmt.Printf("   ...got error %s when trying to POST ping\n", postErr)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		fmt.Printf("  ...got HTTP status %d when trying to POST ping\n", resp.StatusCode)
		return
	}

	fmt.Printf("   ...success\n")
}
Exemplo n.º 13
0
// Data in param must be URL escaped already.
func (tw *twitterClient) twitterPost(url string, param web.ParamMap) (p []byte, err os.Error) {
	oauthClient.SignParam(tw.twitterToken, "POST", url, param)

	// TODO: remove this dupe.
	var resp *http.Response
	done := make(chan bool, 1)
	go func() {
		resp, err = http.PostForm(url, param.StringMap())
		done <- true
	}()

	timeout := time.After(TWITTER_GET_TIMEOUT * 1e9) // post in this case.
	select {
	case <-done:
		break
	case <-timeout:
		return nil, os.NewError("http POST timed out - " + url)
	}
	if resp == nil {
		panic("oops")
	}
	return readHttpResponse(resp, err)
}
Exemplo n.º 14
0
// dash runs the given method and command on the dashboard.
// If args is not nil, it is the query or post parameters.
// If resp is not nil, dash unmarshals the body as JSON into resp.
func dash(meth, cmd string, resp interface{}, args param) os.Error {
	var r *http.Response
	var err os.Error
	if *verbose {
		log.Println("dash", cmd, args)
	}
	cmd = "http://" + *dashboard + "/" + cmd
	vals := make(url.Values)
	for k, v := range args {
		vals.Add(k, v)
	}
	switch meth {
	case "GET":
		if q := vals.Encode(); q != "" {
			cmd += "?" + q
		}
		r, err = http.Get(cmd)
	case "POST":
		r, err = http.PostForm(cmd, vals)
	default:
		return fmt.Errorf("unknown method %q", meth)
	}
	if err != nil {
		return err
	}
	defer r.Body.Close()
	var buf bytes.Buffer
	buf.ReadFrom(r.Body)
	if resp != nil {
		if err = json.Unmarshal(buf.Bytes(), resp); err != nil {
			log.Printf("json unmarshal %#q: %s\n", buf.Bytes(), err)
			return err
		}
	}
	return nil
}
Exemplo n.º 15
0
// dash runs the given method and command on the dashboard.
// If args is not nil, it is the query or post parameters.
// If resp is not nil, dash unmarshals the body as JSON into resp.
func dash(meth, cmd string, resp interface{}, args param) os.Error {
	var r *http.Response
	var err os.Error
	if *verbose {
		log.Println("dash", cmd, args)
	}
	cmd = "http://" + *dashboard + "/" + cmd
	switch meth {
	case "GET":
		if args != nil {
			m := make(map[string][]string)
			for k, v := range args {
				m[k] = []string{v}
			}
			cmd += "?" + http.EncodeQuery(m)
		}
		r, err = http.Get(cmd)
	case "POST":
		r, err = http.PostForm(cmd, args)
	default:
		return fmt.Errorf("unknown method %q", meth)
	}
	if err != nil {
		return err
	}
	defer r.Body.Close()
	var buf bytes.Buffer
	buf.ReadFrom(r.Body)
	if resp != nil {
		if err = json.Unmarshal(buf.Bytes(), resp); err != nil {
			log.Printf("json unmarshal %#q: %s\n", buf.Bytes(), err)
			return err
		}
	}
	return nil
}
Exemplo n.º 16
0
func SmushFiles(response http.ResponseWriter, request *http.Request) {
	var requiredParams = []string{"name", "source"}

	if request.Method != "POST" {
		http.Error(response, "Must post from main Smush form", http.StatusInternalServerError)
		return
	}

	if !RequireParams(request, requiredParams) {
		http.Error(response, "Missing required params", http.StatusInternalServerError)
		return
	}

	var source []string

	source = request.Form["source"]
	sourceStrings := make([]string, len(source))
	i := 0

	// move the source urls into a new array so we can preserve the order, but skip blank entries
	for _, v := range source {
		if v != "" {
			sourceStrings[i] = v
			i++
		}
	}

	compileParamString := "compilation_level=SIMPLE_OPTIMIZATIONS"
	compileParamString += "&output_format=text"
	compileParamString += "&output_info=compiled_code"

	for _, v := range sourceStrings[:i] {
		compileParamString += "&code_url=" + v
	}

	compileParams, _ := url.ParseQuery(compileParamString)
	compileResponse, _ := http.PostForm(compilerURL, compileParams)

	result, _ := ReadWholeFile(compileResponse.Body)
	if len(result) == 1 {
		http.Error(response, "Something went wrong with the Closure Compiler", http.StatusInternalServerError)
		return
	}

	currentTime := time.LocalTime().Nanoseconds()

	dirName := "out/" + strconv.Itoa64(currentTime)
	fileName := dirName + "/" + request.Form["name"][0] + ".min.js"
	if err := os.Mkdir(dirName, uint32(0777)); err != nil {
		http.Error(response, "Couldn't create output folder", http.StatusInternalServerError)
		return
	}
	outputFile, err := os.Create(fileName)
	if err != nil {
		http.Error(response, "Couldn't create output file", http.StatusInternalServerError)
		return
	}
	_, err = outputFile.WriteString(result)
	if err != nil {
		http.Error(response, "Couldn't write output to file", http.StatusInternalServerError)
		return
	}

	http.Redirect(response, request, "/"+fileName, http.StatusFound)
}
Exemplo n.º 17
0
func PostFacebookStatus(text string) {
	u := make(url.Values)
	u.Set("access_token", accessToken)
	u.Set("message", url.QueryEscape(text))
	http.PostForm(postURL, u)
}