예제 #1
1
func (conn *streamConn) connect() (*http.Response, os.Error) {
	if conn.stale {
		return nil, os.NewError("Stale connection")
	}
	tcpConn, err := net.Dial("tcp", "", conn.url.Host+":80")
	if err != nil {
		return nil, err
	}
	conn.clientConn = http.NewClientConn(tcpConn, nil)

	var req http.Request
	req.URL = conn.url
	req.Method = "GET"
	req.Header = map[string]string{}
	req.Header["Authorization"] = "Basic " + conn.authData

	if conn.postData != "" {
		req.Method = "POST"
		req.Body = nopCloser{bytes.NewBufferString(conn.postData)}
		req.ContentLength = int64(len(conn.postData))
		req.Header["Content-Type"] = "application/x-www-form-urlencoded"
	}

	err = conn.clientConn.Write(&req)
	if err != nil {
		return nil, err
	}

	resp, err := conn.clientConn.Read()
	if err != nil {
		return nil, err
	}

	return resp, nil
}
예제 #2
0
func dial(host string) (conn *http.ClientConn) {
	var tcp net.Conn
	var err os.Error
	fmt.Fprintf(os.Stderr, "http-gonsole: establishing a TCP connection ...\n")
	proxy := os.Getenv("HTTP_PROXY")
	if len(proxy) > 0 {
		proxy_url, _ := http.ParseURL(proxy)
		tcp, err = net.Dial("tcp", proxy_url.Host)
	} else {
		tcp, err = net.Dial("tcp", host)
	}
	if err != nil {
		fmt.Fprintln(os.Stderr, "http-gonsole:", err)
		os.Exit(1)
	}
	if *useSSL {
		cf := &tls.Config{Rand: rand.Reader, Time: time.Nanoseconds}
		ssl := tls.Client(tcp, cf)
		conn = http.NewClientConn(ssl, nil)
		if len(proxy) > 0 {
			tcp.Write([]byte("CONNECT " + host + " HTTP/1.0\r\n\r\n"))
			b := make([]byte, 1024)
			tcp.Read(b)
		}
	} else {
		conn = http.NewClientConn(tcp, nil)
	}
	return
}
예제 #3
0
파일: conn.go 프로젝트: tkawachi/GoAWS
// Returns a new HTTP connection;  As with NewConn, netname is not
// checked, and the behaviour of an HTTP client over a non stream
// protocol is undefined - but probably interesting to watch.
func (self *Endpoint) NewHTTPClientConn(netname, local string, r *bufio.Reader) (hc *http.ClientConn, err os.Error) {
	rawc, err := self.NewConn(netname, local)
	if err == nil {
		hc = http.NewClientConn(rawc, r)
	}
	return
}
예제 #4
0
파일: main.go 프로젝트: davecheney/poxy
func ProxyServer(w http.ResponseWriter, req *http.Request) {
	log.Printf("%#v", req)
	addr, err := net.ResolveIPAddr(req.URL.Host)
	if err != nil {
		io.WriteString(w, err.String())
		return
	}
	conn, err := net.DialTCP("tcp4", nil, &net.TCPAddr{IP: addr.IP, Port: 80})
	if err != nil {
		io.WriteString(w, err.String())
		return
	}
	defer conn.Close()
	client := http.NewClientConn(conn, nil)
	err = client.Write(req)
	if err != nil {
		io.WriteString(w, err.String())
		return
	}
	resp, err := client.Read()
	if err != nil {
		io.WriteString(w, err.String())
		return
	}
	for k, v := range resp.Header {
		w.SetHeader(k, v)
	}
	io.Copy(w, resp.Body)
	w.Flush()
}
예제 #5
0
파일: client.go 프로젝트: abneptis/riak
func dialHTTP(hoststring string, scheme string) (cc *http.ClientConn, err os.Error) {
	host, port, err := net.SplitHostPort(hoststring)
	if err != nil {
		return
	}
	if port == "" {
		switch scheme {
		case "http":
			port = "80"
		case "https":
			port = "80"
		case "riak":
			port = "8098"
		default:
			err = os.NewError("Unknown scheme")
		}
	}
	if err != nil {
		return
	}
	var c net.Conn
	switch scheme {
	case "https":
		c, err = tls.Dial("tcp", host+":"+port, nil)
	default:
		c, err = net.Dial("tcp", host+":"+port)
	}
	if err == nil {
		cc = http.NewClientConn(c, nil)
	}
	return
}
예제 #6
0
파일: cmd-google.go 프로젝트: raylu/rbot
// make a GET request with a fake user agent
// this is definitely not for those undocumented Google APIs
func getUserAgent(urlstr string) ([]byte, os.Error) {
	urlobj, err := url.Parse(urlstr)
	if err != nil {
		return nil, err
	}

	conn, err := net.Dial("tcp", urlobj.Host+":http")
	if err != nil {
		return nil, err
	}

	req, err := http.NewRequest("GET", urlstr, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("User-Agent", "Mozilla/5.0")

	httpconn := http.NewClientConn(conn, nil)
	response, err := httpconn.Do(req)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	b, err := ioutil.ReadAll(response.Body)
	return b, err
}
예제 #7
0
func newConn(url *url.URL) (*http.ClientConn, os.Error) {
	addr := url.Host
	//just set the default scheme to http
	if url.Scheme == "" {
		url.Scheme = "http"
	}
	if !hasPort(addr) {
		addr += ":" + url.Scheme
	}
	var conn net.Conn
	var err os.Error
	if url.Scheme == "http" {
		conn, err = net.Dial("tcp", addr)
		if err != nil {
			return nil, err
		}
	} else { // https
		conn, err = tls.Dial("tcp", addr, nil)
		if err != nil {
			return nil, err
		}
		h := url.Host
		if hasPort(h) {
			h = h[0:strings.LastIndex(h, ":")]
		}
		if err := conn.(*tls.Conn).VerifyHostname(h); err != nil {
			return nil, err
		}
	}

	return http.NewClientConn(conn, nil), nil
}
예제 #8
0
파일: riak.go 프로젝트: c141charlie/riak.go
func ProcessRequest(req *http.Request, address string, port string) (map[string]string, int, os.Error) {
	// Request is all set. Let's Make connection.
	results := map[string]string{"X-Riak-Vclock": "", "Body": ""}
	conn, err := net.Dial("tcp", "", fmt.Sprintf("%s:%s", address, port))
	if err != nil {
		return results, 500, err
	}

	http_conn := http.NewClientConn(conn, nil)
	defer http_conn.Close()

	if err := http_conn.Write(req); err != nil {
		return results, 500, err
	}

	//Request sent. Time to get the response.
	resp, err := http_conn.Read()
	if err != nil {
		return results, 500, err
	}

	bytes, _ := ioutil.ReadAll(resp.Body)
	resp.Body.Close()

	results["X-Riak-Vclock"] = resp.Header["X-Riak-Vclock"]
	results["Body"] = string(bytes)

	return results, resp.StatusCode, nil
}
예제 #9
0
func (self *Conn) dial() (err os.Error) {
	if self.c == nil {
		// Get the underlying connection (or redial)
		err = self.uc.Dial()
		if err == nil {
			self.c = http.NewClientConn(self.uc, nil)
		}
	}
	return
}
예제 #10
0
파일: conn.go 프로젝트: kr/httpc.go
func dial(addr string) (*http.ClientConn, os.Error) {
	if !hasPort(addr) {
		addr += ":http"
	}
	sock, err := net.Dial("tcp", "", addr)
	if err != nil {
		return nil, err
	}
	return http.NewClientConn(sock, nil), nil
}
예제 #11
0
func oauthGet(accessToken string, urlString string) (*http.Response, os.Error) {
	url, _ := http.ParseURL(urlString)
	conn, _ := net.Dial("tcp", url.Host+":80")

	clientConn := http.NewClientConn(conn, nil)
	header := map[string][]string{"Authorization": {"OAuth " + accessToken}}
	request := http.Request{Method: "GET", URL: url, Header: header}
	clientConn.Write(&request)
	return clientConn.Read(&request)
}
예제 #12
0
파일: twitter.go 프로젝트: Nazgand/go-gtk
func HttpGet(url string) (*http.Response, os.Error) {
	var r *http.Response
	var err os.Error
	if proxy := os.Getenv("HTTP_PROXY"); len(proxy) > 0 {
		proxy_url, _ := http.ParseURL(proxy)
		tcp, _ := net.Dial("tcp", "", proxy_url.Host)
		conn := http.NewClientConn(tcp, nil)
		var req http.Request
		req.URL, _ = http.ParseURL(url)
		req.Method = "GET"
		err = conn.Write(&req)
		r, err = conn.Read()
	} else {
		r, _, err = http.Get(url)
	}
	return r, err
}
예제 #13
0
// This function is launched async as a go routine. It tries to send a message
// to a remote server and sends a bool to nextChannel to indicate whether this
// has succeeded or not. It is not allowed to run this function multiple times in parallel
// for the same FederationGateway.
func (self *FederationGateway) sendFromQueue(req *WaveletUpdateRequest) {
	// No HTTP connection open yet?
	if self.connection == nil {
		con, err := net.Dial("tcp", "", fmt.Sprintf("%v:%v", self.manifest.HostName, self.manifest.Port))
		if err != nil {
			// TODO: Good error handling
			log.Println("Failed connecting to ", self.manifest, err)
			self.nextChannel <- false
			return
		}
		self.connection = http.NewClientConn(con, nil)
	}

	// Build the HTTP request
	var hreq http.Request
	hreq.Host = self.manifest.Domain
	hreq.Header = make(map[string]string)
	hreq.RawURL = fmt.Sprintf("http://%v:%v/fed%v", self.manifest.HostName, self.manifest.Port, req.uri)
	hreq.Method = "PUT"
	hreq.Body = NewRequestBody(req.Data)
	hreq.ContentLength = int64(len(req.Data))
	hreq.Header["Content-Type"] = req.MimeType
	log.Println("Sending WaveletUpdate to remote server ", hreq.RawURL)

	// Send the HTTP request
	self.connection.Write(&hreq)
	// Read the HTTP response
	hres, err := self.connection.Read()
	if err != nil {
		log.Println("Error reading HTTP response from ", self.manifest, err)
		// TODO: Better error handling
		self.connection.Close()
		self.connection = nil
		self.nextChannel <- false
		return
	}

	log.Println("After sending WaveletUpdate, status code is ", hres.StatusCode)
	// Success in sending the wavelet update?
	if hres.StatusCode == 200 {
		self.nextChannel <- true
		return
	}
	// Sending the wavelet update failed
	self.nextChannel <- false
}
예제 #14
0
파일: client.go 프로젝트: chinmayc/rest.go
// Creates a client for the specified resource.
//
// The resource is the url to the base of the resource (i.e.,
// http://127.0.0.1:3000/snips/)
func NewClient(resource string) (*Client, os.Error) {
	var client = new(Client)
	var err os.Error

	// setup host
	if client.resource, err = http.ParseURL(resource); err != nil {
		return nil, err
	}

	// Setup conn
	var tcpConn net.Conn
	if tcpConn, err = net.Dial("tcp", client.resource.Host); err != nil {
		return nil, err
	}
	client.conn = http.NewClientConn(tcpConn, nil)

	return client, nil
}
예제 #15
0
func (conn *streamConn) connect() (*http.Response, os.Error) {
	if conn.stale {
		return nil, os.NewError("Stale connection")
	}
	var tcpConn net.Conn
	var err os.Error
	if proxy := os.Getenv("HTTP_PROXY"); len(proxy) > 0 {
		proxy_url, _ := url.Parse(proxy)
		tcpConn, err = net.Dial("tcp", proxy_url.Host)
	} else {
		tcpConn, err = net.Dial("tcp", conn.url.Host+":443")
	}
	if err != nil {
		return nil, err
	}
	cf := &tls.Config{Rand: rand.Reader, Time: time.Nanoseconds}
	ssl := tls.Client(tcpConn, cf)

	conn.clientConn = http.NewClientConn(ssl, nil)

	var req http.Request
	req.URL = conn.url
	req.Method = "GET"
	req.Header = http.Header{}
	req.Header.Set("Authorization", "Basic "+conn.authData)

	if conn.postData != "" {
		req.Method = "POST"
		req.Body = nopCloser{bytes.NewBufferString(conn.postData)}
		req.ContentLength = int64(len(conn.postData))
		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	}

	resp, err := conn.clientConn.Do(&req)
	if err != nil {
		return nil, err
	}

	return resp, nil
}
예제 #16
0
func GetManifest(host string, port uint16) *ServerManifest {
	log.Println("Discovery at ", host, port)
	// Make a TCP connection
	con, err := net.Dial("tcp", "", fmt.Sprintf("%v:%v", host, port))
	if err != nil {
		log.Println("Failed connecting to ", host, port, err)
		return nil
	}
	// Make a HTTP connection
	hcon := http.NewClientConn(con, nil)
	// Build the HTTP request
	var hreq http.Request
	hreq.Host = host
	hreq.Method = "GET"
	hreq.RawURL = fmt.Sprintf("http://%v:%v/_manifest", host, port)
	log.Println("Sending request")
	// Send the HTTP request
	if err = hcon.Write(&hreq); err != nil {
		log.Println("Error sending GET request")
		hcon.Close()
		return nil
	}
	// Read the HTTP response
	_, err = hcon.Read()
	if err != nil {
		log.Println("Error reading HTTP response from ", host, err)
		hcon.Close()
		return nil
	}

	m := &ServerManifest{}
	// TODO: Parse the manifest
	// HACK START
	m.HostName = host
	m.Port = port
	// HACK END
	return m
}
예제 #17
0
파일: httpGet2.go 프로젝트: border/learning
func main() {

	url, err := http.ParseURL("http://bbs.golang-china.org/")

	if err != nil {
		log.Exit(err)
	}

	tcpConn, err := net.Dial("tcp", "", url.Host+":80")

	if err != nil {
		log.Exit(err)
	}

	clientConn := http.NewClientConn(tcpConn, nil)

	var req http.Request
	req.URL = url
	req.Method = "GET"
	req.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/534.11 (KHTML, like Gecko) Chrome/9.0.570.0 Safari/534.11"
	req.Header = map[string]string{}
	req.Header["Connection"] = "keep-alive"

	err = clientConn.Write(&req)
	if err != nil {
		log.Exit(err)
	}
	resp, err := clientConn.Read()
	if err != nil {
		log.Exit(err)
	}
	defer resp.Body.Close()

	log.Println("Http Response: " + resp.Status)
	body, _ := ioutil.ReadAll(resp.Body)

	log.Println(string(body))
}
예제 #18
0
파일: fetch.go 프로젝트: GunioRobot/heroshi
func (client *Client) Connect(addr string) (err os.Error) {
	if !hasPort(addr) {
		addr += ":http"
	}

	var tcp_addr *net.TCPAddr
	tcp_addr, err = net.ResolveTCPAddr(addr)
	if err != nil {
		return err
	}

	client.NetConn, err = net.DialTCP("tcp", nil, tcp_addr)
	if err != nil {
		return err
	}
	client.NetConn.SetKeepAlive(true)
	client.NetConn.SetLinger(0)
	// NoDelay is true by default, that's what we need
	client.NetConn.SetTimeout(int64(client.IOTimeout))

	client.HttpConn = http.NewClientConn(client.NetConn, nil)
	return nil
}
예제 #19
0
파일: server.go 프로젝트: Jonersan/goproxy
func WriteResponse(c *http.Conn, req *http.Request) {

	PrintRequest(req)
	req = DeleteHopByHopHeader(req)
	PrintRequest(req)
	host := req.URL.Host
	if match, _ := regexp.MatchString(":[0-9]+$", host); !match {
		if req.URL.Scheme == "http" {
			host = host + ":80"
		} else if req.URL.Scheme == "https" {
			host = host + ":443"
		}
	}
	proxy := os.Getenv("HTTP_PROXY")
	if len(proxy) > 0 {
		proxy_url, _ := http.ParseURL(proxy)
		host = proxy_url.Host
	}
	log.Stdoutf("host:%s\n", host)

	tcp, err := net.Dial("tcp", "", host)
	if err != nil {
		log.Stdout(err)
		return
	}
	defer tcp.Close()

	conn := http.NewClientConn(tcp, nil)
	defer conn.Close()

	err = conn.Write(req)
	if err != nil {
		log.Stdout(err)
		return
	}
	response, err := conn.Read()
	if err != nil {
		log.Stdout(err)
		return
	}

	PrintResponse(response)
	/***
	size := response.ContentLength
	if size > 0 {
		buf := make([]byte, size)
		io.ReadFull(response.Body, buf)
		c.Write(buf)
	} else if response.RequestMethod == "HEAD" {
		buf, _ := ioutil.ReadAll(response.Body)
		c.Write(buf)
	}
	***/
	err = response.Write(c)
	if err != nil {
		log.Stdout("ERROR:")
		log.Stdout(err)
		return
	}
	err = response.Body.Close()
	if err != nil {
		log.Stdout("ERROR:")
		log.Stdout(err)
	}
}
예제 #20
0
func (self *FederationProxy) sendFromQueue() {
	if len(self.queue) == 0 {
		return
	}

	log.Println("Sending message from queue")

	// No HTTP connection open yet?
	if self.connection == nil {
		con, err := net.Dial("tcp", "", fmt.Sprintf("%v:%v", self.manifest.HostName, self.manifest.Port))
		if err != nil {
			// TODO: Good error handling
			log.Println("Failed connecting to ", self.manifest, err)
			return
		}
		self.connection = http.NewClientConn(con, nil)
	}

	// Dequeue a message
	req := self.queue.At(0).(FederationRequest)
	// Build the HTTP request
	var hreq http.Request
	hreq.Host = self.manifest.Domain
	hreq.Header = make(map[string]string)
	switch req.(type) {
	case *PostRequest:
		preq := req.(*PostRequest)
		hreq.RawURL = fmt.Sprintf("http://%v:%v/fed/%v", self.manifest.HostName, self.manifest.Port, preq.URI.String())
		hreq.Method = "POST"
		hreq.Body = NewRequestBody(preq.Data)
		hreq.ContentLength = int64(len(preq.Data))
		hreq.Header["Content-Type"] = preq.MimeType
	case *GetRequest:
		greq := req.(*GetRequest)
		hreq.Method = "GET"
		hreq.RawURL = fmt.Sprintf("http://%v:%v/fed/%v", self.manifest.HostName, self.manifest.Port, greq.URI.String())
	default:
		log.Println(req)
		panic("Unsupported kind of message forwarded internally to the federation proxy")
	}
	log.Println("Sending request to ", hreq.RawURL)

	// Send the HTTP request
	self.connection.Write(&hreq)
	// Read the HTTP response
	hres, err := self.connection.Read()
	if err != nil {
		log.Println("Error reading HTTP response from ", self.manifest, err)
		// TODO: Better error handling
		self.connection.Close()
		self.connection = nil
		return
	}

	// Success. Remove the request from the queue
	self.queue.Delete(0)

	// Send the result back to the client
	_, err = io.Copy(req.GetResponseWriter(), hres.Body)
	hres.Body.Close()
	if err != nil {
		log.Println("Error sending result of federated message back to the client")
		req.SendFinishSignal(false)
	}
	req.SendFinishSignal(true)
}