Exemplo n.º 1
0
// Worker
func worker(t *http.Transport, reqChan chan *http.Request, respChan chan Response) {
	for req := range reqChan {
		resp, err := t.RoundTrip(req)
		r := Response{resp, err}
		respChan <- r
	}
}
Exemplo n.º 2
0
func login(c *cli.Context) {
	println("echo login,", c.Args().Get(0), c.Args().Get(1))

	// client := &http.Client{}
	reqest, _ := http.NewRequest("GET", "https://passport.baidu.com", nil)

	reqest.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8")
	reqest.Header.Set("Accept-Encoding", "gzip, deflate, sdch")
	reqest.Header.Set("Accept-Language", "en-US,en;q=0.8,zh-CN;q=0.6,zh-TW;q=0.4")
	reqest.Header.Set("Connection", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.93 Safari/537.36")

	transport := http.Transport{}
	response, err := transport.RoundTrip(reqest)
	if err != nil {
		// t.Fatal(err)
	}
	// // Check if you received the status codes you expect. There may
	// // status codes other than 200 which are acceptable.
	// if resp.StatusCode != 200 && resp.StatusCode != 302 {
	//     t.Fatal("Failed with status", resp.Status)
	// }

	// response,_ := client.Do(reqest)
	if response.StatusCode == 302 {
		// body, _ := ioutil.ReadAll(response.Body)
		// bodystr := string(body);
		fmt.Println("cookie: ", response.Cookies())
	} else {
		fmt.Println("error, code=", response.StatusCode)
	}

	println("login done")
}
Exemplo n.º 3
0
func image(command *bot.Cmd, matches []string) (msg string, err error) {
	client := &http.Client{}
	request, _ := http.NewRequest("GET", fmt.Sprintf(imageURL, url.QueryEscape(matches[1])), nil)
	request.Header.Set("Ocp-Apim-Subscription-Key", bot.Config.Bing)

	response, _ := client.Do(request)
	defer response.Body.Close()
	body, _ := ioutil.ReadAll(response.Body)

	var results ImageResults
	json.Unmarshal(body, &results)

	if err != nil {
		return fmt.Sprintf("No results for %s", matches[1]), nil
	}

	if len(results.Value) == 0 {
		return fmt.Sprintf("No results for %s", matches[1]), nil
	}

	pageURL := results.Value[0].ContentURL

	transport := http.Transport{}

	request, _ = http.NewRequest("HEAD", pageURL, nil)
	response, _ = transport.RoundTrip(request)
	pageURL = response.Header.Get("Location")

	output := fmt.Sprintf("Bing | %s | %s", matches[1], pageURL)
	return output, nil
}
Exemplo n.º 4
0
func (r exampleDomainRewriter) RoundTrip(req *http.Request) (resp *http.Response, err error) {
	req.URL.Scheme = "http"
	req.URL.Host = r.RewriteURL.Host

	t := http.Transport{}
	return t.RoundTrip(req)
}
Exemplo n.º 5
0
func (srv *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) error {
	transport := new(http.Transport)
	h, ok := w.(http.Hijacker)

	if !ok {
		return errors.New("Unable to hijack connection")
	}

	r.Host = srv.addr
	r.URL.Host = r.Host

	if len(r.URL.Scheme) == 0 {
		r.URL.Scheme = "http"
	}

	response, err := transport.RoundTrip(r)

	if err != nil {
		return err
	}

	conn, _, err := h.Hijack()

	if err != nil {
		return err
	}

	defer conn.Close()
	defer response.Body.Close()
	return response.Write(conn)
}
Exemplo n.º 6
0
// Proxy the request to the given endpoint, execute observers and middlewares chains
func (l *HttpLocation) proxyToEndpoint(tr *http.Transport, o *Options, endpoint endpoint.Endpoint, req request.Request) (*http.Response, error) {

	a := &request.BaseAttempt{Endpoint: endpoint}

	l.observerChain.ObserveRequest(req)
	defer l.observerChain.ObserveResponse(req, a)
	defer req.AddAttempt(a)

	it := l.middlewareChain.GetIter()
	defer l.unwindIter(it, req, a)

	for v := it.Next(); v != nil; v = it.Next() {
		a.Response, a.Error = v.ProcessRequest(req)
		if a.Response != nil || a.Error != nil {
			// Move the iterator forward to count it again once we unwind the chain
			it.Next()
			log.Errorf("Midleware intercepted request with response=%s, error=%s", a.Response.Status, a.Error)
			return a.Response, a.Error
		}
	}

	// Forward the request and mirror the response
	start := o.TimeProvider.UtcNow()
	a.Response, a.Error = tr.RoundTrip(req.GetHttpRequest())
	a.Duration = o.TimeProvider.UtcNow().Sub(start)
	return a.Response, a.Error
}
Exemplo n.º 7
0
func (this *RequestHandler) HandleHttpRequest(transport *http.Transport, address string) (*http.Response, error) {
	this.request.URL.Scheme = "http"
	this.request.URL.Host = address

	if host, _, err := net.SplitHostPort(this.request.RemoteAddr); err == nil {
		xForwardFor := append(this.request.Header["X-Forwarded-For"], host)
		this.request.Header.Set("X-Forwarded-For", strings.Join(xForwardFor, ", "))
	} else {
		log.Println("set X-Forwarded-For error:", err)
	}

	if _, ok := this.request.Header[http.CanonicalHeaderKey("X-Request-Start")]; !ok {
		this.request.Header.Set("X-Request-Start", strconv.FormatInt(time.Now().UnixNano()/1e6, 10))
	}

	this.request.Close = true
	this.request.Header.Del("Connection")

	response, err := transport.RoundTrip(this.request)
	if err != nil {
		return response, err
	}

	for k, vv := range response.Header {
		for _, v := range vv {
			this.response.Header().Add(k, v)
		}
	}

	return response, err
}
Exemplo n.º 8
0
func TestAuthRequest(t *testing.T) {
	const backendResponse = "I am the backend"
	const backendStatus = 200
	mux := http.NewServeMux()
	mux.HandleFunc(serverConfig.ProtectPath, genericRequestHandlerAuthWrapper)
	mux.HandleFunc(serverConfig.CallbackPath, oauthCallbackHandler)
	server = httptest.NewServer(mux)

	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if len(r.TransferEncoding) > 0 {
			t.Errorf("backend got unexpected TransferEncoding: %v", r.TransferEncoding)
		}
		if r.Header.Get("X-Forwarded-For") == "" {
			t.Errorf("didn't get X-Forwarded-For header")
		}

		w.Header().Set("X-Foo", "bar")
		http.SetCookie(w, &http.Cookie{Name: "flavor", Value: "chocolateChip"})
		w.WriteHeader(backendStatus)
		w.Write([]byte(backendResponse))
	}))
	defer backend.Close()
	backendURL, err := url.Parse(backend.URL)
	if err != nil {
		t.Fatal(err)
	}

	serverConfig.ProxyURL = *backendURL
	// Test request & response
	req, _ := http.NewRequest("GET", server.URL, nil)
	req.Host = "some-name"
	req.Header.Set("Connection", "close")
	req.Close = true

	// Handle the request
	transport := new(http.Transport)
	response, err := transport.RoundTrip(req)
	if err != nil {
		t.Fatalf("Get: %v", err)
	}
	if g, e := response.StatusCode, backendStatus; g != e {
		t.Errorf("got response.StatusCode %d; expected %d", g, e)
	}
	bodyBytes, _ := ioutil.ReadAll(response.Body)
	if g, e := string(bodyBytes), backendResponse; g != e {
		t.Errorf("got body %q; expected %q", g, e)
	}
	if g, e := response.Header.Get("X-Foo"), "bar"; g != e {
		t.Errorf("got X-Foo %q; expected %q", g, e)
	}
	if cookie := response.Cookies()[0]; cookie.Name != "flavor" {
		t.Errorf("unexpected cookie %q", cookie.Name)
	}
}
Exemplo n.º 9
0
func relayHttpRequest(
	client *http.Client,
	transport *http.Transport,
	request *http.Request,
	responseWriter http.ResponseWriter) {

	// Transform received request struct before using as input to relayed request
	request.Close = false
	request.RequestURI = ""
	for _, key := range hopHeaders {
		request.Header.Del(key)
	}

	// Relay the HTTP request and get the response. Use a client when supplied,
	// otherwise a transport. A client handles cookies and redirects, and a
	// transport does not.
	var response *http.Response
	var err error
	if client != nil {
		response, err = client.Do(request)
	} else {
		response, err = transport.RoundTrip(request)
	}

	if err != nil {
		NoticeAlert("%s", common.ContextError(FilterUrlError(err)))
		forceClose(responseWriter)
		return
	}
	defer response.Body.Close()

	// Relay the remote response headers
	for _, key := range hopHeaders {
		response.Header.Del(key)
	}
	for key, _ := range responseWriter.Header() {
		responseWriter.Header().Del(key)
	}
	for key, values := range response.Header {
		for _, value := range values {
			responseWriter.Header().Add(key, value)
		}
	}

	// Relay the response code and body
	responseWriter.WriteHeader(response.StatusCode)
	_, err = io.Copy(responseWriter, response.Body)
	if err != nil {
		NoticeAlert("%s", common.ContextError(err))
		forceClose(responseWriter)
		return
	}
}
Exemplo n.º 10
0
func Fanout(transport *http.Transport, request *http.Request, endpoints []*Endpoint) (*http.Response, error) {
	body, err := ioutil.ReadAll(request.Body)
	if err != nil {
		return nil, err
	}

	responses := make(chan *http.Response, len(endpoints))
	errs := make(chan error, len(endpoints))

	for _, e := range endpoints {
		url := *request.URL
		url.Scheme = "http"
		url.Host = e.Addr

		req := *request
		req.Body = ioutil.NopCloser(bytes.NewBuffer(body))
		req.URL = &url
		req.Close = true

		request := &req

		go func() {
			response, err := transport.RoundTrip(request)

			if err != nil {
				errs <- err
			} else {
				responses <- response
			}
		}()

		defer transport.CancelRequest(request)
	}

	var fanoutErr error
	var response *http.Response

	for i := 0; i < len(endpoints); i++ {
		select {
		case fanoutErr = <-errs:
		case response = <-responses:
			if response.StatusCode < 400 {
				return response, nil
			}
		}
	}

	if response != nil {
		return response, nil
	}

	return nil, fanoutErr
}
Exemplo n.º 11
0
func RoundRobin(transport *http.Transport, request *http.Request, endpoints []*Endpoint) (*http.Response, error) {
	startingPoint := rand.Intn(len(endpoints))

	body, err := ioutil.ReadAll(request.Body)
	if err != nil {
		return nil, err
	}

	attempts := 0
	i := startingPoint

	for {
		if i == len(endpoints) {
			i = 0
		}

		url := *request.URL
		url.Scheme = "http"
		url.Host = endpoints[i].Addr

		req := *request
		req.Body = ioutil.NopCloser(bytes.NewBuffer(body))
		req.URL = &url
		req.Close = true

		request := &req

		response, err := transport.RoundTrip(request)

		attempts++
		i++

		if attempts == len(endpoints) {
			return response, err
		}

		if err != nil {
			continue
		}

		if response.StatusCode < 400 {
			return response, nil
		}

		response.Body.Close()
	}

	panic("unreachable")
}
Exemplo n.º 12
0
// BenchmarkExpand may consume all open files in server. When running this
// test, you should configure max open files server can open. This can
// commonly be done through "ulimit -n 10000" shell command.
func BenchmarkExpand(b *testing.B) {
	b.StopTimer()
	shortReq, _ := json.Marshal(shortReq{LongURL: "http://www.google.com"})
	req, err := http.NewRequest(
		"POST",
		"http://127.0.0.1:3030/short",
		bytes.NewBuffer(shortReq))
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		b.Fatal(err)
	}
	if resp.StatusCode != http.StatusOK {
		b.Fatalf("http response status: %v", resp.StatusCode)
	}

	body, _ := ioutil.ReadAll(resp.Body)
	var shortResp shortResp
	json.Unmarshal(body, &shortResp)
	shortURL := shortResp.ShortURL
	b.StartTimer()

	for i := 0; i < b.N; i++ {
		req, err := http.NewRequest(
			"GET",
			fmt.Sprintf("%v", shortURL),
			nil,
		)
		if err != nil {
			b.Fatal(err)
		}

		transport := http.Transport{}
		resp, err := transport.RoundTrip(req)

		if err != nil {
			b.Fatal(err)
		}

		if resp.StatusCode != http.StatusTemporaryRedirect {
			b.Log(shortURL)
			b.Log(resp.Request.URL)
			b.Fatalf("http response status: %v", resp.StatusCode)
		}
	}
}
Exemplo n.º 13
0
func (h *RequestHandler) HandleHttpRequest(transport *http.Transport, endpoint *route.Endpoint) (*http.Response, error) {
	h.transport = transport

	h.setupRequest(endpoint)
	h.setupConnection()

	endpointResponse, err := transport.RoundTrip(h.request)
	if err != nil {
		return endpointResponse, err
	}

	h.forwardResponseHeaders(endpointResponse)

	h.setupStickySession(endpointResponse, endpoint)

	return endpointResponse, err
}
Exemplo n.º 14
0
func TestUnauthRequest(t *testing.T) {
	mux := http.NewServeMux()
	mux.HandleFunc(serverConfig.ProtectPath, genericRequestHandler)
	mux.HandleFunc(serverConfig.CallbackPath, oauthCallbackHandler)
	server = httptest.NewServer(mux)

	req, _ := http.NewRequest("GET", server.URL, nil)
	client := new(http.Transport)
	response, err := client.RoundTrip(req)
	if err != nil {
		t.Fatalf("Get: %v", err)
	}
	location := response.Header.Get("Location")
	if !strings.HasPrefix(location, "https://accounts.google.com/o/oauth2") {
		t.Errorf("Expected Location header incorrect: %q", location)
	}
}
Exemplo n.º 15
0
// Do an HTTP roundtrip using the payload data in buf and the request metadata
// in info.
func roundTripWithHTTP(buf []byte, info *RequestInfo) (*http.Response, error) {
	tr := new(http.Transport)
	if info.ProxyURL != nil {
		if info.ProxyURL.Scheme != "http" {
			panic(fmt.Sprintf("don't know how to use proxy %s", info.ProxyURL.String()))
		}
		tr.Proxy = http.ProxyURL(info.ProxyURL)
	}
	req, err := http.NewRequest("POST", info.URL.String(), bytes.NewReader(buf))
	if err != nil {
		return nil, err
	}
	if info.Host != "" {
		req.Host = info.Host
	}
	req.Header.Set("X-Session-Id", info.SessionID)
	return tr.RoundTrip(req)
}
Exemplo n.º 16
0
func proxy(target string, w http.ResponseWriter, r *http.Request) {

	stripped := r.RequestURI[strings.Index(r.RequestURI[1:], "/")+1:]
	uri := target + stripped

	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Printf("ERROR: %s", err)
		return
	}

	rr, err := http.NewRequest(r.Method, uri, bytes.NewBuffer(body))
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Printf("ERROR: %s", err)
		return
	}
	copyHeader(r.Header, &rr.Header)

	// Create a client and query the target
	var transport http.Transport
	resp, err := transport.RoundTrip(rr)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Printf("ERROR: %s", err)
		return
	}

	defer resp.Body.Close()
	body, err = ioutil.ReadAll(resp.Body)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Printf("ERROR: %s", err)
		return
	}

	dH := w.Header()
	copyHeader(resp.Header, &dH)

	w.Write(body)
}
Exemplo n.º 17
0
func CheckRedirect(reqUrl string) (bool, string, int) {
	client := http.Transport{}
	req, _ := http.NewRequest("HEAD", reqUrl, nil)
	r, err := client.RoundTrip(req)
	if err != nil {
		return false, "", 502
	}
	lv := &url.URL{}
	lv, err = r.Location()
	if err == nil {
		reqUrl = lv.String()
	}

	if r.StatusCode < 300 {
		return false, reqUrl, 200
	} else if r.StatusCode >= 300 && r.StatusCode < 400 {
		return true, reqUrl, r.StatusCode
	} else {
		return false, "", 502
	}
}
Exemplo n.º 18
0
func loginAttack(options *Options) {
	target := fmt.Sprintf("http://%s:%d", options.Host, options.Port)
	endpoint := fmt.Sprintf("%s%s", target, options.Uri)
	fmt.Println("Starting login attack on", endpoint)

	file, err := os.Open("dictionary.txt")
	if err != nil {
		fmt.Println(err)
	}
	defer file.Close()

	var lines []string
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		lines = append(lines, scanner.Text())
	}

	for _, password := range lines {
		data := url.Values{}
		data.Set("inputEmail", "*****@*****.**")
		data.Set("inputPassword", password)

		request, _ := http.NewRequest("POST", endpoint, strings.NewReader(data.Encode()))
		request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
		if options.From != "" {
			request.Header.Add("X-Forwarded-For", options.From)
		}

		transport := http.Transport{}
		response, _ := transport.RoundTrip(request)
		defer response.Body.Close()

		if response.StatusCode == 302 {
			fmt.Println("The password is:", password)
			os.Exit(0)
		}
	}
}
Exemplo n.º 19
0
func StartClient(url_, heads, requestBody string, meth string, dka bool, responseChan chan *Response, waitGroup *sync.WaitGroup, tc int) {
	defer waitGroup.Done()

	var tr *http.Transport

	u, err := url.Parse(url_)

	if err == nil && u.Scheme == "https" {
		var tlsConfig *tls.Config
		if *insecure {
			tlsConfig = &tls.Config{
				InsecureSkipVerify: true,
			}
		} else {
			// Load client cert
			cert, err := tls.LoadX509KeyPair(*certFile, *keyFile)
			if err != nil {
				log.Fatal(err)
			}

			// Load CA cert
			caCert, err := ioutil.ReadFile(*caFile)
			if err != nil {
				log.Fatal(err)
			}
			caCertPool := x509.NewCertPool()
			caCertPool.AppendCertsFromPEM(caCert)

			// Setup HTTPS client
			tlsConfig = &tls.Config{
				Certificates: []tls.Certificate{cert},
				RootCAs:      caCertPool,
			}
			tlsConfig.BuildNameToCertificate()
		}

		tr = &http.Transport{TLSClientConfig: tlsConfig, DisableKeepAlives: dka}
	} else {
		tr = &http.Transport{DisableKeepAlives: dka}
	}

	requestBodyReader := strings.NewReader(requestBody)

	req, _ := http.NewRequest(meth, url_, requestBodyReader)
	sets := strings.Split(heads, "\n")

	//Split incoming header string by \n and build header pairs
	for i := range sets {
		split := strings.SplitN(sets[i], ":", 2)
		if len(split) == 2 {
			req.Header.Set(split[0], split[1])
		}
	}

	timer := NewTimer()
	for {
		timer.Reset()

		resp, err := tr.RoundTrip(req)

		respObj := &Response{}

		if err != nil {
			respObj.Error = true
		} else {
			if resp.ContentLength < 0 { // -1 if the length is unknown
				data, err := ioutil.ReadAll(resp.Body)
				if err == nil {
					respObj.Size = int64(len(data))
				}
			} else {
				respObj.Size = resp.ContentLength
			}
			respObj.StatusCode = resp.StatusCode
			resp.Body.Close()
		}

		respObj.Duration = timer.Duration()

		if len(responseChan) >= tc {
			break
		}
		responseChan <- respObj
	}
}
Exemplo n.º 20
0
// ServeHTTP catches a client request and proxies it to the destination server,
// then waits for the server's answer and sends it back to the client.
//
// (this method should not be called directly).
func (p *Proxy) ServeHTTP(wri http.ResponseWriter, req *http.Request) {

	var err error
	var transport *http.Transport

	pr := p.newProxiedRequest(wri, req)

	out := new(http.Request)
	*out = *req

	if req.TLS == nil {
		transport = &http.Transport{}
		out.URL.Scheme = "http"
	} else {
		transport = &http.Transport{
			TLSClientConfig: &tls.Config{
				InsecureSkipVerify: false,
			},
		}
		out.URL.Scheme = "https"
	}

	// Making sure the Host header is present.
	out.URL.Host = out.Host
	out.Header.Add("Host", out.Host)

	out.Proto = "HTTP/1.1"
	out.ProtoMajor = 1
	out.ProtoMinor = 1
	out.Close = false

	// Walking over directors.
	for i := range p.directors {
		if err := p.directors[i].Direct(out); err != nil {
			log.Printf("Director: %q", err)
		}
	}

	// Intercepting request body.
	body := bytes.NewBuffer(nil)
	bodyCopy := bytes.NewBuffer(nil)
	io.Copy(io.MultiWriter(body, bodyCopy), out.Body)

	out.Body = ioutil.NopCloser(body)

	// Proxying client request to destination server.
	if pr.Response, err = transport.RoundTrip(out); err != nil {
		log.Printf("RoundTrip: %q", err)
		wri.WriteHeader(http.StatusInternalServerError)
		return
	}

	// (Response received).

	// Resetting body (so it can be read later)
	out.Body = ioutil.NopCloser(bodyCopy)

	// Walking over interceptos.
	for i := range p.interceptors {
		if err := p.interceptors[i].Intercept(pr.Response); err != nil {
			log.Printf("Interceptor: %q", err)
		}
	}

	// Copying response headers to the writer we are going to send to the client.
	copyHeader(pr.ResponseWriter.Header(), pr.Response.Header)

	// Copying response status.
	pr.ResponseWriter.WriteHeader(pr.Response.StatusCode)

	// Running writers.
	ws := make([]io.WriteCloser, 0, len(p.writers))

	for i := range p.writers {
		var w io.WriteCloser
		var err error
		if w, err = p.writers[i].NewWriteCloser(pr.Response); err != nil {
			log.Printf("WriteCloser: %q", err)
			continue
		}
		ws = append(ws, w)
	}

	defer pr.Response.Body.Close()

	// Writing response.
	writers := make([]io.Writer, 0, len(ws)+1)
	writers = append(writers, pr.ResponseWriter)

	for i := range ws {
		writers = append(writers, ws[i])
	}

	if _, err := io.Copy(io.MultiWriter(writers...), pr.Response.Body); err != nil {
		log.Printf("io.Copy: %q", err)
	}

	// Closing write closers.
	for i := range ws {
		if err := ws[i].Close(); err != nil {
			log.Printf("WriteCloser.Close: %q", err)
		}
	}

	// Walking over loggers.
	for i := range p.loggers {
		if err := p.loggers[i].Log(pr); err != nil {
			log.Printf("Log: %q", err)
		}
	}
}
Exemplo n.º 21
0
func (e *periodicExporter) updateSlaves() {
	log.Debug("discovering slaves...")

	// This will redirect us to the elected mesos master
	redirectURL := fmt.Sprintf("%s/master/redirect", e.opts.masterURL)
	rReq, err := http.NewRequest("GET", redirectURL, nil)
	if err != nil {
		panic(err)
	}

	tr := http.Transport{
		DisableKeepAlives: true,
	}
	rresp, err := tr.RoundTrip(rReq)
	if err != nil {
		log.Warn(err)
		return
	}
	defer rresp.Body.Close()

	// This will/should return http://master.ip:5050
	masterLoc := rresp.Header.Get("Location")
	if masterLoc == "" {
		log.Warnf("%d response missing Location header", rresp.StatusCode)
		return
	}

	log.Debugf("current elected master at: %s", masterLoc)

	// Find all active slaves
	stateURL := fmt.Sprintf("%s/master/state.json", masterLoc)
	resp, err := http.Get(stateURL)
	if err != nil {
		log.Warn(err)
		return
	}
	defer resp.Body.Close()

	type slave struct {
		Active   bool   `json:"active"`
		Hostname string `json:"hostname"`
		Pid      string `json:"pid"`
	}

	var req struct {
		Slaves []*slave `json:"slaves"`
	}

	if err := json.NewDecoder(resp.Body).Decode(&req); err != nil {
		log.Warnf("failed to deserialize request: %s", err)
		return
	}

	var slaveURLs []string
	for _, slave := range req.Slaves {
		if slave.Active {
			// Extract slave port from pid
			_, port, err := net.SplitHostPort(slave.Pid)
			if err != nil {
				port = "5051"
			}
			url := fmt.Sprintf("http://%s:%s", slave.Hostname, port)

			slaveURLs = append(slaveURLs, url)
		}
	}

	log.Debugf("%d slaves discovered", len(slaveURLs))

	e.slaves.Lock()
	e.slaves.urls = slaveURLs
	e.slaves.Unlock()
}
Exemplo n.º 22
0
// send is sending a http.Request without following redirects
func (s *FormsAuthSuite) send(r *http.Request) (*http.Response, error) {
	t := http.Transport{}
	return t.RoundTrip(r)
}
Exemplo n.º 23
0
func report(w http.ResponseWriter, r *http.Request) {
	uri := target + r.RequestURI

	if useCache && r.Method == "GET" {
		element, error := cacheGet(uri)
		if error == nil {
			dH := w.Header()
			copyHeader(element.resp.Header, &dH)
			dH.Add("From-Cache", "true")
			dH.Set("Content-Length", strconv.Itoa(len(element.body)))
			w.WriteHeader(element.resp.StatusCode)
			w.Write(element.body)
			return
		}
	}

	if showUri {
		fmt.Println("URI (" + r.Method + "): " + r.Host + r.RequestURI)
	}

	if showTargetUri {
		fmt.Println("Modified URI (" + r.Method + "): " + uri)
	}

	requestBody, err := ioutil.ReadAll(r.Body)
	r.Body.Close()
	fatal(err)

	if showRequestHeaders {
		fmt.Printf("Request Headers: %v\n", r.Header)
	}

	if showRequestBody && string(requestBody) != "" {
		fmt.Printf("Request Body: %s\n", string(requestBody))
	}

	/*  We can make changes to the request body (requestBody) here */

	r2, err := http.NewRequest(r.Method, uri, bytes.NewBuffer(requestBody))
	fatal(err)
	copyHeader(r.Header, &r2.Header)
	r2.Header.Set("Content-Length", strconv.Itoa(len(requestBody)))

	/* We can mess with the request headers here */
	// r2.Header.Add("Something", "Some Value")
	/* */

	if showTargetRequestHeaders {
		fmt.Printf("Modified Request Headers: %v\n", r2.Header)
	}

	if showTargetRequestBody && string(requestBody) != "" {
		fmt.Printf("Modified Request Body: %s\n", string(requestBody))
	}

	var transport http.Transport
	resp, err := transport.RoundTrip(r2)
	if err != nil {
		log.Print(err)
		return
	}

	if showResponseHeaders {
		fmt.Printf("Response Headers: %v\n", resp.Header)
	}

	responseBody, err := getBodyBuffer(resp)

	if showResponse {
		fmt.Printf("Response Body: %s\n", responseBody)
	}

	/* We can mess with the final response body (responseBody) here */
	//responseBody = swap(responseBody, "north", "south")
	//responseBody = swap(responseBody, "down", "up")
	//responseBody = replace(responseBody, "nice", "nasty")
	//responseBody = replace(responseBody, "cool", "hideous")
	/* */

	dH := w.Header()
	copyHeader(resp.Header, &dH)

	/* We can mess with the final response headers here */
	// fmt.Printf("Resp-Status: %v\n",resp.Status)
	dH.Add("Requested-Host", r2.Host)
	/* */

	body, _ := compressBody(responseBody, resp)
	dH.Set("Content-Length", strconv.Itoa(len(body)))

	if showFinalResponseHeaders {
		fmt.Printf("Modified Response Headers: %v\n", resp.Header)
	}

	if showFinalResponse {
		fmt.Printf("Modified Response Body: %s\n", responseBody)
	}

	w.WriteHeader(resp.StatusCode)
	w.Write(body)

	if useCache && r.Method == "GET" {
		cacheSet(uri, cacheElement{resp: resp, body: body})
	}
}
Exemplo n.º 24
0
func (ctx *ProxyCtx) wrapTransport(tr *http.Transport) RoundTripper {
	return RoundTripperFunc(func(req *http.Request, ctx *ProxyCtx) (*http.Response, error) {
		return tr.RoundTrip(req)
	})
}
Exemplo n.º 25
0
		server = httptest.NewServer(handler)

		transport = &http.Transport{}

		var err error
		request, err = http.NewRequest("GET", server.URL+"/some-path", nil)
		Expect(err).ToNot(HaveOccurred())
	})

	AfterEach(func() {
		server.Close()
	})

	JustBeforeEach(func() {
		response, requestErr = transport.RoundTrip(request)
	})

	Context("when the ErrHandler returns nil", func() {
		BeforeEach(func() {
			fakeErrHandler.ServeHTTPReturns(nil)
		})

		It("does nothing with the response writer", func() {
			Expect(response.StatusCode).To(Equal(http.StatusOK))
		})
	})

	Context("when the ErrHandler returns concourse.ErrUnauthorized", func() {
		BeforeEach(func() {
			fakeErrHandler.ServeHTTPReturns(concourse.ErrUnauthorized)
Exemplo n.º 26
0
					})

					Context("when forceHTTPS is true", func() {
						BeforeEach(func() {
							args = append(args, "-forceHTTPS=true")
						})

						It("redirects HTTP to HTTPS", func() {
							session = startMainWithArgs(args...)
							Eventually(session).Should(gbytes.Say("garagepi started"))

							req, err := http.NewRequest("GET", fmt.Sprintf("http://localhost:%d/", httpPort), nil)
							Expect(err).NotTo(HaveOccurred())

							transport := http.Transport{}
							resp, err := transport.RoundTrip(req)

							Expect(resp.StatusCode).To(Equal(http.StatusFound))

							expectedLocation := fmt.Sprintf("localhost:%d", httpsPort)

							location, err := resp.Location()
							Expect(err).NotTo(HaveOccurred())
							Expect(location.Scheme).To(Equal("https"))
							Expect(location.Host).To(Equal(expectedLocation))
						})
					})
				})
			})
		})
	})
Exemplo n.º 27
0
func (e *periodicExporter) updateSlaves() {
	log.Debug("discovering slaves...")

	// This will redirect us to the elected mesos master
	redirectURL := fmt.Sprintf("%s://%s/master/redirect", e.queryURL.Scheme, e.queryURL.Host)
	rReq, err := http.NewRequest("GET", redirectURL, nil)
	if err != nil {
		panic(err)
	}

	tr := http.Transport{
		DisableKeepAlives: true,
	}
	rresp, err := tr.RoundTrip(rReq)
	if err != nil {
		log.Warn(err)
		return
	}
	defer rresp.Body.Close()

	// This will/should return http://master.ip:5050
	masterLoc := rresp.Header.Get("Location")
	if masterLoc == "" {
		log.Warnf("%d response missing Location header", rresp.StatusCode)
		return
	}

	log.Debugf("current elected master at: %s", masterLoc)

	// Starting from 0.23.0, a Mesos Master does not set the scheme in the "Location" header.
	// Use the scheme from the master URL in this case.
	var stateURL string
	if strings.HasPrefix(masterLoc, "http") {
		stateURL = fmt.Sprintf("%s/master/state.json", masterLoc)
	} else {
		stateURL = fmt.Sprintf("%s:%s/master/state.json", e.queryURL.Scheme, masterLoc)
	}

	var state masterState

	// Find all active slaves
	err = getJSON(&state, stateURL)
	if err != nil {
		log.Warn(err)
		return
	}

	var slaveURLs []string
	for _, slave := range state.Slaves {
		if slave.Active {
			// Extract slave port from pid
			_, port, err := net.SplitHostPort(slave.PID)
			if err != nil {
				port = "5051"
			}
			url := fmt.Sprintf("http://%s:%s", slave.Hostname, port)

			slaveURLs = append(slaveURLs, url)
		}
	}

	log.Debugf("%d slaves discovered", len(slaveURLs))

	e.slaves.Lock()
	e.slaves.urls = slaveURLs
	e.slaves.Unlock()
}
Exemplo n.º 28
0
func (ci *ConnectionInfo) forwardHandler(respWriter http.ResponseWriter, req *http.Request) error {
	//Get local host/port if not already determined
	if ci.LocalHost == "" {
		ci.LocalHost = strings.Split(req.Host, ":")[0]
	}

	//Update the request object
	req.Host = ci.swapHost(req.Host, false)
	req.URL.Host = req.Host
	req.URL.Scheme = ci.RemoteProtocol
	req.RequestURI = "" //go requires that this be empty
	req.RemoteAddr = "" //go likes filling this one in itself

	//Save the origin
	var origOrigin string
	hasOrigOrigin := false
	if tempVal, tempOK := req.Header["Origin"]; tempOK && len(tempVal) > 0 {
		origOrigin = tempVal[0]
		hasOrigOrigin = true
	}

	//---Update the headers---
	//Swap hosts in the request headers
	for k, v := range req.Header {
		req.Header[k] = ci.swapHostArr(v, false)
		//TODO: Do cookies need to be treated separately hear?
	}
	//Update the allowed encodings
	if req.Header["Accept-Encoding"] != nil && len(req.Header["Accept-Encoding"]) > 0 {
		possibleEncodings := strings.Split(req.Header["Accept-Encoding"][0], ",")
		finalEncodings := make([]string, 0, len(possibleEncodings))
		for _, v := range possibleEncodings {
			v = strings.TrimSpace(v)
			if strings.EqualFold(v, "gzip") || strings.EqualFold(v, "deflate") {
				finalEncodings = append(finalEncodings, v)
			}
		}
		req.Header["Accept-Encoding"][0] = strings.Join(finalEncodings, ", ")
	}
	ModifyForwarderRequest(ci, req) //Custom callback

	//TODO: Should the request itself be host-swapped?

	//Send the request
	transport := http.Transport{} //Had to use a transport instead of http.Client so that Location header requests would come through instead of being followed
	resp, err := transport.RoundTrip(req)
	if err != nil {
		return err
	}

	//Save the access control origin
	var origAccessControlOrigin string
	hasOrigAccessControlOrigin := false
	if tempVal, tempOK := resp.Header["Access-Control-Allow-Origin"]; tempOK && len(tempVal) > 0 {
		origAccessControlOrigin = tempVal[0]
		hasOrigAccessControlOrigin = true
	}

	//Copy the host-swapped updated return headers
	//TODO: I am not sure if this is safe right now. Some headers might need to be ignored.
	headers := respWriter.Header()
	for k, v := range resp.Header {
		if k != "Set-Cookie" { //Handle cookies separately, since they are encoded
			headers[k] = ci.swapHostArr(v, true)
		}
	}

	//Set the access control allow origin
	newOriginFound := true
	newAccessControlOrigin := func() string {
		//Test all the origin types until one succeeds
		for _, originType := range ci.AccessOrigin {
			switch originType {
			case originTypes.Original:
				if hasOrigAccessControlOrigin {
					return origAccessControlOrigin
				}
			case originTypes.OriginalSwapped:
				if hasOrigAccessControlOrigin {
					return headers["Access-Control-Allow-Origin"][0]
				}
			case originTypes.LocalHost:
				return ci.swapHost(ci.RemoteHost, true)
			case originTypes.RemoteHost:
				return ci.swapHost(ci.LocalHost, false)
			case originTypes.RequestOrigin:
				if hasOrigOrigin {
					return origOrigin
				}
			case originTypes.AcceptAll:
				return "*"
			case originTypes.Custom:
				return ci.CustomAccessOrigin
			default:
				panic("Should not get here")
			}
		}

		//If no origin was found
		newOriginFound = false
		return ""
	}()
	if !newOriginFound && hasOrigAccessControlOrigin {
		delete(headers, "Access-Control-Allow-Origin")
	} else if newOriginFound {
		headers["Access-Control-Allow-Origin"] = []string{newAccessControlOrigin}
	}

	//Copy the host-swapped returned cookies
	for _, c := range resp.Cookies() {
		unescaped, err := url.QueryUnescape(c.Value)
		if err == nil {
			c.Value = url.QueryEscape(ci.swapHost(unescaped, true))
			//TODO: More might need to be swapped here, like the Cookie.Domain
		}
		http.SetCookie(respWriter, c)
	}

	//Get the response content
	retContent, _ := ioutil.ReadAll(resp.Body)
	resp.Body.Close()

	//Host-swap the response (only for text types)
	recompressType := ""
	if FirstStringStartsWith(resp.Header["Content-Type"], "text/", true) {
		//If compressed, decompress
		var err error
		if FirstStringStartsWith(resp.Header["Content-Encoding"], "gzip", false) {
			retContent, recompressType, err = decompress(retContent, "gzip")
		} else if FirstStringStartsWith(resp.Header["Content-Encoding"], "deflate", false) {
			retContent, recompressType, err = decompress(retContent, "deflate")
		}
		if err != nil {
			return err
		}

		//Do the swap
		retContent = []byte(ci.swapHost(string(retContent), true))
	}
	retContent = ModifyForwarderReply(ci, respWriter, retContent, req) //Custom callback

	//Recompress if required
	if recompressType != "" {
		var b bytes.Buffer
		var writer io.WriteCloser
		if recompressType == "gzip" {
			writer = gzip.NewWriter(&b)
		} else {
			writer = zlib.NewWriter(&b)
		}
		writer.Write(retContent)
		writer.Close()
		retContent = b.Bytes()
	}

	//Update the content length and write the updated headers
	headers["Content-Length"] = []string{strconv.Itoa(len(retContent))}
	respWriter.WriteHeader(resp.StatusCode) //Write the status code

	//Write the content back out
	respWriter.Write(retContent)
	return nil
}