func increaseTime(writer http.ResponseWriter, req *http.Request) {
//This function allows a user, if it owns the allocation, to free an allocation
//number and all associated nodes. It resets the resource map and current
//requests map.
var end time.Time
heckleDaemon.DaemonLog.DebugHttp(req)
heckleDaemon.DaemonLog.LogDebug("Increasing allocation time on an allocation number.")
req.ProtoMinor = 0
err := heckleDaemon.AuthN.HTTPAuthenticate(req, false)
if err != nil {
heckleDaemon.DaemonLog.LogError("Permission Denied", err)
writer.WriteHeader(http.StatusUnauthorized)
}
heckleDaemon.UpdateActivity()
username, _, _ := heckleDaemon.AuthN.GetHTTPAuthenticateInfo(req)
jsonType := heckleDaemon.ProcessJson(req, new(int64))
timeIncrease := jsonType.(int64)
resourcesLock.Lock()
for _, value := range resources {
if value.Owner == username {
value.AllocationEndTime = value.AllocationEndTime.Add(time.Duration(timeIncrease))
end = value.AllocationEndTime
}
}
resourcesLock.Unlock()
heckleDaemon.DaemonLog.Log(fmt.Sprintf("Increased timeout by %d for %s. Allocation will end at %d", timeIncrease, username, end.Unix()))
updateDatabase(false)
}
func (l *HttpLocation) copyRequest(req *http.Request, body netutils.MultiReader, endpoint endpoint.Endpoint) *http.Request {
outReq := new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
// Set the body to the enhanced body that can be re-read multiple times and buffered to disk
outReq.Body = body
endpointURL := endpoint.GetUrl()
outReq.URL.Scheme = endpointURL.Scheme
outReq.URL.Host = endpointURL.Host
outReq.URL.Opaque = req.RequestURI
// raw query is already included in RequestURI, so ignore it to avoid dupes
outReq.URL.RawQuery = ""
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
// Overwrite close flag so we can keep persistent connection for the backend servers
outReq.Close = false
outReq.Header = make(http.Header)
netutils.CopyHeaders(outReq.Header, req.Header)
return outReq
}
func post(url_ string, oauthHeaders map[string]string) (r *http.Response, err error) {
var req http.Request
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = true
req.Header = map[string][]string{
"Authorization": {"OAuth "},
}
req.TransferEncoding = []string{"chunked"}
first := true
for k, v := range oauthHeaders {
if first {
first = false
} else {
req.Header["Authorization"][0] += ",\n "
}
req.Header["Authorization"][0] += k + "=\"" + v + "\""
}
req.URL, err = url.Parse(url_)
if err != nil {
return nil, err
}
return send(&req)
}
func (f *Forwarder) copyRequest(req *http.Request, u *url.URL) *http.Request {
outReq := new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
outReq.URL = utils.CopyURL(req.URL)
outReq.URL.Scheme = u.Scheme
outReq.URL.Host = u.Host
outReq.URL.Opaque = req.RequestURI
// raw query is already included in RequestURI, so ignore it to avoid dupes
outReq.URL.RawQuery = ""
// Go doesn't implicitly pass the host header unless you set Host on the request
outReq.Host = u.Host
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
// Overwrite close flag so we can keep persistent connection for the backend servers
outReq.Close = false
outReq.Header = make(http.Header)
utils.CopyHeaders(outReq.Header, req.Header)
if f.rewriter != nil {
f.rewriter.Rewrite(outReq)
}
return outReq
}
// NewFastHTTPHandler wraps net/http handler to fasthttp request handler,
// so it can be passed to fasthttp server.
//
// While this function may be used for easy switching from net/http to fasthttp,
// it has the following drawbacks comparing to using manually written fasthttp
// request handler:
//
// * A lot of useful functionality provided by fasthttp is missing
// from net/http handler.
// * net/http -> fasthttp handler conversion has some overhead,
// so the returned handler will be always slower than manually written
// fasthttp handler.
//
// So it is advisable using this function only for quick net/http -> fasthttp
// switching. Then manually convert net/http handlers to fasthttp handlers
// according to https://github.com/valyala/fasthttp#switching-from-nethttp-to-fasthttp .
func NewFastHTTPHandler(h http.Handler) fasthttp.RequestHandler {
return func(ctx *fasthttp.RequestCtx) {
var r http.Request
body := ctx.PostBody()
r.Method = string(ctx.Method())
r.Proto = "HTTP/1.1"
r.ProtoMajor = 1
r.ProtoMinor = 1
r.RequestURI = string(ctx.RequestURI())
r.ContentLength = int64(len(body))
r.Host = string(ctx.Host())
r.RemoteAddr = ctx.RemoteAddr().String()
hdr := make(http.Header)
ctx.Request.Header.VisitAll(func(k, v []byte) {
hdr.Set(string(k), string(v))
})
r.Header = hdr
r.Body = &netHTTPBody{body}
var w netHTTPResponseWriter
h.ServeHTTP(&w, &r)
ctx.SetStatusCode(w.StatusCode())
for k, vv := range w.Header() {
for _, v := range vv {
ctx.Response.Header.Set(k, v)
}
}
ctx.Write(w.body)
}
}
// copyRequest creates a new proxy request with some modifications from an original request.
func copyRequest(originalRequest *http.Request) *http.Request {
pr := new(http.Request)
*pr = *originalRequest
pr.Proto = "HTTP/1.1"
pr.ProtoMajor = 1
pr.ProtoMinor = 1
pr.Close = false
pr.Header = make(http.Header)
pr.URL.Scheme = "http"
pr.URL.Path = originalRequest.URL.Path
// Copy all header fields.
for key, values := range originalRequest.Header {
for _, value := range values {
pr.Header.Add(key, value)
}
}
// Remove ignored header fields.
for _, header := range ignoredHeaderNames {
pr.Header.Del(header)
}
// Append this machine's host name into X-Forwarded-For.
if requestHost, _, err := net.SplitHostPort(originalRequest.RemoteAddr); err == nil {
if originalValues, ok := pr.Header["X-Forwarded-For"]; ok {
requestHost = strings.Join(originalValues, ", ") + ", " + requestHost
}
pr.Header.Set("X-Forwarded-For", requestHost)
}
return pr
}
func (proxy *Proxy) copyRequest(r *http.Request) *http.Request {
proxyRequest := new(http.Request)
*proxyRequest = *r
proxyRequest.Proto = "HTTP/1.1"
proxyRequest.ProtoMajor = 1
proxyRequest.ProtoMinor = 1
proxyRequest.Close = false
proxyRequest.Header = make(http.Header)
proxyRequest.URL.Scheme = "http"
proxyRequest.URL.Path = r.URL.Path
for key, values := range r.Header {
for _, value := range values {
proxyRequest.Header.Add(key, value)
}
}
for _, headerName := range ignoredHeaderNames {
proxyRequest.Header.Del(headerName)
}
if requestHost, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
if values, ok := proxyRequest.Header["X-Forwarded-For"]; ok {
requestHost = strings.Join(values, ", ") + ", " + requestHost
}
proxyRequest.Header.Set("X-Forwarded-For", requestHost)
}
return proxyRequest
}
func nodeStatus(writer http.ResponseWriter, req *http.Request) {
heckleDaemon.DaemonLog.LogDebug("Sending back node status.")
response := ""
req.ProtoMinor = 0
heckleDaemon.DaemonLog.DebugHttp(req)
err := heckleDaemon.AuthN.HTTPAuthenticate(req, false)
if err != nil {
heckleDaemon.DaemonLog.LogError("Permission Denied", err)
writer.WriteHeader(http.StatusUnauthorized)
}
heckleDaemon.UpdateActivity()
resourcesLock.Lock()
//This need to go away as well. Why are we writing out the response...?
for key, value := range resources {
if value.Allocated {
response = response + "NODE: " + key + "\tALLOCATED: yes\tALLOCATION: " + strconv.FormatUint(value.AllocationNumber, 10) + "\tOWNER: " + value.Owner + "\tIMAGE: " + value.Image + "\tALLOCATION START: " + value.TimeAllocated.Format(time.UnixDate) + "\tALLOCATION END: " + value.AllocationEndTime.Format(time.UnixDate) + "\tCOMMENTS: " + value.Comments + "\n\n"
}
}
resourcesLock.Unlock()
_, error := writer.Write([]byte(response))
heckleDaemon.DaemonLog.LogError("Unable to write node status response in heckle.", error)
}
func (f *Forwarder) copyRequest(req *http.Request, u *url.URL) *http.Request {
outReq := new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
outReq.URL = utils.CopyURL(req.URL)
outReq.URL.Scheme = u.Scheme
outReq.URL.Host = u.Host
// workaround for https://github.com/golang/go/issues/10433
outReq.URL.Opaque = mergeStartingSlashes(req.RequestURI)
// raw query is already included in RequestURI, so ignore it to avoid dupes
outReq.URL.RawQuery = ""
// Do not pass client Host header unless optsetter PassHostHeader is set.
if f.passHost != true {
outReq.Host = u.Host
}
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
// Overwrite close flag so we can keep persistent connection for the backend servers
outReq.Close = false
outReq.Header = make(http.Header)
utils.CopyHeaders(outReq.Header, req.Header)
if f.rewriter != nil {
f.rewriter.Rewrite(outReq)
}
return outReq
}
// This function alters the original request - adds/removes headers, removes hop headers,
// changes the request path.
func rewriteRequest(req *http.Request, cmd *command.Forward, upstream *command.Upstream) *http.Request {
outReq := new(http.Request)
*outReq = *req // includes shallow copies of maps, but we handle this below
outReq.URL.Scheme = upstream.Scheme
outReq.URL.Host = fmt.Sprintf("%s:%d", upstream.Host, upstream.Port)
if len(cmd.RewritePath) != 0 {
outReq.URL.Path = cmd.RewritePath
}
outReq.URL.RawQuery = req.URL.RawQuery
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
outReq.Close = false
glog.Infof("Proxying request to: %v", outReq)
outReq.Header = make(http.Header)
netutils.CopyHeaders(outReq.Header, req.Header)
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
// TODO(pquerna): configure this? Not all backends properly parse the header..
if TRUST_FORWARD_HEADER {
if prior, ok := outReq.Header["X-Forwarded-For"]; ok {
clientIP = strings.Join(prior, ", ") + ", " + clientIP
}
}
outReq.Header.Set("X-Forwarded-For", clientIP)
}
if req.TLS != nil {
outReq.Header.Set("X-Forwarded-Proto", "https")
} else {
outReq.Header.Set("X-Forwarded-Proto", "http")
}
if req.Host != "" {
outReq.Header.Set("X-Forwarded-Host", req.Host)
}
outReq.Header.Set("X-Forwarded-Server", vulcanHostname)
if len(cmd.RemoveHeaders) != 0 {
netutils.RemoveHeaders(cmd.RemoveHeaders, outReq.Header)
}
// Add generic instructions headers to the request
if len(cmd.AddHeaders) != 0 {
glog.Info("Proxying instructions headers:", cmd.AddHeaders)
netutils.CopyHeaders(outReq.Header, cmd.AddHeaders)
}
// Remove hop-by-hop headers to the backend. Especially
// important is "Connection" because we want a persistent
// connection, regardless of what the client sent to us.
netutils.RemoveHeaders(hopHeaders, outReq.Header)
return outReq
}
func freeAllocation(writer http.ResponseWriter, req *http.Request) {
//This function allows a user, if it owns the allocation, to free an allocation
//number and all associated nodes. It resets the resource map and current
//requests map.
heckleDaemon.DaemonLog.DebugHttp(req)
req.ProtoMinor = 0
err := heckleDaemon.AuthN.HTTPAuthenticate(req, false)
if err != nil {
heckleDaemon.DaemonLog.LogError("Permission Denied", err)
writer.WriteHeader(http.StatusUnauthorized)
}
heckleDaemon.UpdateActivity()
username, _, admin := heckleDaemon.AuthN.GetHTTPAuthenticateInfo(req)
jsonType := heckleDaemon.ProcessJson(req, new(uint64))
allocationNumber := jsonType.(*uint64)
if *allocationNumber <= 0 {
heckleDaemon.DaemonLog.LogError(fmt.Sprintf("Allocation #%d does not exsist", *allocationNumber), errors.New("0 used"))
writer.WriteHeader(http.StatusBadRequest)
return
}
powerDown := []string{}
currentRequestsLock.Lock()
resourcesLock.Lock()
found := false
for key, value := range resources {
if *allocationNumber == value.AllocationNumber {
if username == value.Owner || admin {
value.Reset()
powerDown = append(powerDown, key)
delete(currentRequests, key)
found = true
} else {
heckleDaemon.DaemonLog.LogError("Cannot free allocations that do not belong to you.", errors.New("Access Denied"))
currentRequestsLock.Unlock()
resourcesLock.Unlock()
return
}
}
}
currentRequestsLock.Unlock()
resourcesLock.Unlock()
if !found {
heckleDaemon.DaemonLog.LogError(fmt.Sprintf("Allocation #%d does not exist.", allocationNumber), errors.New("Wrong Number"))
writer.WriteHeader(http.StatusBadRequest)
return
}
pollingCancelChan <- powerDown //Needed because polling will continue to poll if allocation is freed during allocation.
_, err = ps.PostServer("/command/off", powerDown)
heckleDaemon.DaemonLog.LogError("Failed to post for reboot of nodes in free allocation number.", err)
heckleDaemon.DaemonLog.Log(fmt.Sprintf("Allocation #%d nodes %s have been freed.", *allocationNumber, powerDown))
updateDatabase(false)
}
func (p *ReverseProxy) ServeHTTP(req *http.Request) (*http.Response, error) {
transport := p.Transport
if transport == nil {
transport = http.DefaultTransport
}
outreq := new(http.Request)
*outreq = *req // includes shallow copies of maps, but okay
p.Director(outreq)
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove hop-by-hop headers to the backend. Especially
// important is "Connection" because we want a persistent
// connection, regardless of what the client sent to us. This
// is modifying the same underlying map from req (shallow
// copied above) so we only copy it if necessary.
copiedHeaders := false
for _, h := range hopHeaders {
if outreq.Header.Get(h) != "" {
if !copiedHeaders {
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
copiedHeaders = true
}
outreq.Header.Del(h)
}
}
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
// If we aren't the first proxy retain prior
// X-Forwarded-For information as a comma+space
// separated list and fold multiple headers into one.
if prior, ok := outreq.Header["X-Forwarded-For"]; ok {
clientIP = strings.Join(prior, ", ") + ", " + clientIP
}
outreq.Header.Set("X-Forwarded-For", clientIP)
}
res, err := transport.RoundTrip(outreq)
if err != nil {
return res, err
}
for _, p := range *p.Plugins {
p.Outbound(res)
}
for _, h := range hopHeaders {
res.Header.Del(h)
}
return res, nil
}
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, outreq *http.Request, respUpdateFn respUpdateFn) error {
transport := p.Transport
if transport == nil {
transport = http.DefaultTransport
}
p.Director(outreq)
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
res, err := transport.RoundTrip(outreq)
if err != nil {
return err
} else if respUpdateFn != nil {
respUpdateFn(res)
}
if res.StatusCode == http.StatusSwitchingProtocols && strings.ToLower(res.Header.Get("Upgrade")) == "websocket" {
res.Body.Close()
hj, ok := rw.(http.Hijacker)
if !ok {
return nil
}
conn, _, err := hj.Hijack()
if err != nil {
return err
}
defer conn.Close()
backendConn, err := net.Dial("tcp", outreq.URL.Host)
if err != nil {
return err
}
defer backendConn.Close()
outreq.Write(backendConn)
go func() {
io.Copy(backendConn, conn) // write tcp stream to backend.
}()
io.Copy(conn, backendConn) // read tcp stream from backend.
} else {
defer res.Body.Close()
for _, h := range hopHeaders {
res.Header.Del(h)
}
copyHeader(rw.Header(), res.Header)
rw.WriteHeader(res.StatusCode)
p.copyResponse(rw, res.Body)
}
return nil
}
func prepareRequest(req *http.Request) *http.Request {
outreq := new(http.Request)
*outreq = *req // includes shallow copies of maps, but okay
// Pass the Request-URI verbatim without any modifications.
//
// NOTE: An exception must be made if the Request-URI is a path
// beginning with "//" (e.g. "//foo/bar") because then
// req.URL.RequestURI() would interpret req.URL.Opaque as being a URI
// with the scheme stripped and so generate a URI like scheme:opaque
// (e.g. "http://foo/bar") which would be incorrect, see:
// https://github.com/golang/go/blob/f75aafd/src/net/url/url.go#L913-L931
//
// It is ok to make this exception because the fallback to
// req.URL.EscapedPath will generate the correct Request-URI.
if !strings.HasPrefix(req.RequestURI, "//") {
outreq.URL.Opaque = strings.Split(strings.TrimPrefix(req.RequestURI, req.URL.Scheme+":"), "?")[0]
}
outreq.URL.Scheme = "http"
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove hop-by-hop headers to the backend.
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
for _, h := range hopHeaders {
outreq.Header.Del(h)
}
// remove the Upgrade header and headers referenced in the Connection
// header if HTTP < 1.1 or if Connection header didn't contain "upgrade":
// https://tools.ietf.org/html/rfc7230#section-6.7
if !req.ProtoAtLeast(1, 1) || !isConnectionUpgrade(req.Header) {
outreq.Header.Del("Upgrade")
// Especially important is "Connection" because we want a persistent
// connection, regardless of what the client sent to us.
outreq.Header.Del("Connection")
// A proxy or gateway MUST parse a received Connection header field before a
// message is forwarded and, for each connection-option in this field, remove
// any header field(s) from the message with the same name as the
// connection-option, and then remove the Connection header field itself (or
// replace it with the intermediary's own connection options for the
// forwarded message): https://tools.ietf.org/html/rfc7230#section-6.1
tokens := strings.Split(req.Header.Get("Connection"), ",")
for _, hdr := range tokens {
outreq.Header.Del(hdr)
}
}
return outreq
}
func (cms ControllerMuxServer) wrapControl(w http.ResponseWriter, req *http.Request) {
powerDaemon.DaemonLog.DebugHttp(req)
req.ProtoMinor = 0
err := powerDaemon.AuthN.HTTPAuthenticate(req, true)
if err != nil {
powerDaemon.DaemonLog.LogError("Access not permitted.", err)
w.WriteHeader(http.StatusUnauthorized)
return
}
cmd := strings.Split(req.RequestURI, "/")[2]
switch cmd {
case "on", "off", "reboot":
break
default:
powerDaemon.DaemonLog.LogError(fmt.Sprintf("%s command not supported", cmd),
errors.New("dummy"))
w.WriteHeader(http.StatusNotFound)
return
break
}
body, err := ioutil.ReadAll(req.Body)
err = req.Body.Close()
if err != nil {
fmt.Println(err.Error())
}
var nodes []string
err = json.Unmarshal(body, &nodes)
if err != nil {
fmt.Println(err.Error())
}
powerDaemon.DaemonLog.Log(fmt.Sprintf("%s: %s", cmd, nodes))
switch cmd {
case "on":
err = cms.cm.On(nodes)
case "off":
err = cms.cm.Off(nodes)
case "reboot":
err = cms.cm.Reboot(nodes)
}
if err != nil {
powerDaemon.DaemonLog.LogError(err.Error(), err)
w.WriteHeader(http.StatusInternalServerError)
}
return
}
func reverseProxy(w http.ResponseWriter, req *http.Request) {
logRequest(req)
if rSensitivePath.MatchString(req.URL.Path) {
w.WriteHeader(http.StatusForbidden)
return
}
outReq := new(http.Request)
outReq.Method = req.Method
outReq.URL = &url.URL{
Scheme: "http",
Host: host,
Path: req.URL.Path,
RawQuery: req.URL.RawQuery,
}
outReq.Proto = "HTTP/1.1"
outReq.ProtoMajor = 1
outReq.ProtoMinor = 1
outReq.Header = make(http.Header)
outReq.Body = req.Body
outReq.ContentLength = req.ContentLength
outReq.Host = host
for _, h := range removeHeaders {
req.Header.Del(h)
}
copyHeader(outReq.Header, req.Header)
outReq.Header.Set("Host", host)
outReq.Header.Set("Referer", baseURL)
outReq.Header.Set("Origin", baseURL)
resp, err := send(outReq)
if err != nil {
log.Printf("proxy error: %v", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
defer resp.Body.Close()
for _, h := range removeHeaders {
resp.Header.Del(h)
}
if loc := resp.Header.Get("Location"); loc != "" {
if u, err := url.Parse(loc); err == nil && u.Host == host {
u.Scheme = "http"
u.Host = req.Host
resp.Header.Set("Location", u.String())
}
}
copyHeader(w.Header(), resp.Header)
w.WriteHeader(resp.StatusCode)
io.Copy(w, resp.Body)
}
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request, location string) {
transport := p.Transport
if transport == nil {
transport = http.DefaultTransport
}
outreq := new(http.Request)
p.Director(outreq)
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove hop-by-hop headers to the backend. Especially
// important is "Connection" because we want a persistent
// connection, regardless of what the client sent to us. This
// is modifying the same underlying map from req (shallow
// copied above) so we only copy it if necessary.
copiedHeaders := false
for _, h := range hopHeaders {
if outreq.Header.Get(h) != "" {
if !copiedHeaders {
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
copiedHeaders = true
}
outreq.Header.Del(h)
}
}
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
// If we aren't the first proxy retain prior
// X-Forwarded-For information as a comma+space
// separated list and fold multiple headers into one.
if prior, ok := outreq.Header["X-Forwarded-For"]; ok {
clientIP = strings.Join(prior, ", ") + ", " + clientIP
}
outreq.Header.Set("X-Forwarded-For", clientIP)
}
res, err := transport.RoundTrip(outreq)
if err != nil {
log.Printf("http: proxy error: %v", err)
rw.WriteHeader(http.StatusInternalServerError)
return
}
defer res.Body.Close()
copyHeader(rw.Header(), res.Header)
rw.WriteHeader(res.StatusCode)
p.copyResponse(rw, res.Body)
}
func (client *RPCClient) RPCCall(methodName string,
args ...interface{}) (interface{}, *rpc.Fault, *rpc.Error) {
buf := bytes.NewBufferString("")
berr := Marshal(buf, methodName, args)
if berr != nil {
return nil, nil, berr
}
var req http.Request
req.URL = client.url
req.Method = "POST"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = false
req.Body = nopCloser{buf}
req.Header = map[string][]string{
"Content-Type": {"text/xml"},
}
req.RawURL = "/RPC"
req.ContentLength = int64(buf.Len())
if client.conn == nil {
var cerr *rpc.Error
if client.conn, cerr = rpc.Open(client.url); cerr != nil {
return nil, nil, cerr
}
}
if werr := req.Write(client.conn); werr != nil {
client.conn.Close()
return nil, nil, &rpc.Error{Msg: werr.String()}
}
reader := bufio.NewReader(client.conn)
resp, rerr := http.ReadResponse(reader, &req)
if rerr != nil {
client.conn.Close()
return nil, nil, &rpc.Error{Msg: rerr.String()}
} else if resp == nil {
rrerr := fmt.Sprintf("ReadResponse for %s returned nil response\n",
methodName)
return nil, nil, &rpc.Error{Msg: rrerr}
}
_, pval, perr, pfault := Unmarshal(resp.Body)
if resp.Close {
resp.Body.Close()
client.conn = nil
}
return pval, pfault, perr
}
func httpProxy(writer http.ResponseWriter, request *http.Request) {
proxyRequest := new(http.Request)
*proxyRequest = *request
log.Printf("request = %s %s", request.Method, request.URL.Host)
if strings.ToUpper(proxyRequest.Method) == "CONNECT" {
hostPort := request.URL.Host
pandora, err := dialer.Dial("tcp", hostPort) // tuner.pandora.com:443
if err != nil {
log.Printf("pianobarproxy: error: %v", err)
writer.WriteHeader(http.StatusInternalServerError)
return
}
client, writer, err := writer.(http.Hijacker).Hijack()
writer.WriteString("HTTP/1.0 200 Connection Established\r\n\r\n")
writer.Flush()
go pipe(client, pandora)
go pipe(pandora, client)
return
}
proxyRequest.Proto = "HTTP/1.1"
proxyRequest.ProtoMajor = 1
proxyRequest.ProtoMinor = 1
proxyRequest.Close = false
// Remove the connection header to the backend. We want a
// persistent connection, regardless of what the client sent
// to us.
if proxyRequest.Header.Get("Connection") != "" {
proxyRequest.Header = make(http.Header)
copyHeader(proxyRequest.Header, request.Header)
proxyRequest.Header.Del("Connection")
}
response, err := transport.RoundTrip(proxyRequest)
if err != nil {
log.Printf("pianobarproxy: error: %v", err)
writer.WriteHeader(http.StatusInternalServerError)
return
}
copyHeader(writer.Header(), response.Header)
writer.WriteHeader(response.StatusCode)
if response.Body != nil {
io.Copy(io.Writer(writer), response.Body)
}
}
func CopyRequest(req *http.Request) *http.Request {
outreq := new(http.Request)
*outreq = *req // includes shallow copies of maps, but okay
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove hop-by-hop headers to the backend. Especially
// important is "Connection" because we want a persistent
// connection, regardless of what the client sent to us. This
// is modifying the same underlying map from req (shallow
// copied above) so we only copy it if necessary.
copiedHeaders := false
for _, h := range hopHeaders {
if outreq.Header.Get(h) != "" {
if !copiedHeaders {
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
copiedHeaders = true
}
outreq.Header.Del(h)
}
}
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
// If we aren't the first proxy retain prior
// X-Forwarded-For information as a comma+space
// separated list and fold multiple headers into one.
if prior, ok := outreq.Header["X-Forwarded-For"]; ok {
clientIP = strings.Join(prior, ", ") + ", " + clientIP
}
outreq.Header.Set("X-Forwarded-For", clientIP)
}
// If the request body is not chunked, tee it into the
// proxy request's body & and replace it with a buffered
// copy of the request body (it will be fully read by
// the proxy request).
if !isChunked(req) {
bodyBuffer := bytes.NewBuffer(make([]byte, 0, req.ContentLength))
bodyReader := io.TeeReader(req.Body, bodyBuffer)
outreq.Body = ioutil.NopCloser(bodyReader)
req.Body = ioutil.NopCloser(bodyBuffer)
} else {
outreq.Body = ioutil.NopCloser(bytes.NewReader([]byte{}))
}
return outreq
}
func InstallCall(w http.ResponseWriter, req *http.Request) {
fmDaemon.DaemonLog.DebugHttp(req)
req.ProtoMinor = 0
add := req.RemoteAddr
addTmp := strings.Split(add, ":")
address := addTmp[0]
cmd := strings.Split(req.RequestURI, "/")
//Flunky auth needed
fmDaemon.UpdateActivity()
tmp := fm.RenderImage(strings.TrimSpace(cmd[1]), address)
status := strings.TrimSpace(string(tmp))
w.Write([]byte(status))
}
func (h *HTTPSender) buildBaseRequest(contextPath string, method string, headers map[string][]string, bodyReader *bytes.Reader) *http.Request {
var req http.Request
req.Method = h.method
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = false
req.Header = h.headers
req.URL = h.parsedContextPath
req.URL.Host = h.hosts[h.currentHost]
req.Body = ioutil.NopCloser(bodyReader)
req.ContentLength = int64(bodyReader.Len())
return &req
}
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
transport := p.Transport
if transport == nil {
transport = http.DefaultTransport
}
outreq := new(http.Request)
*outreq = *req // includes shallow copies of maps, but okay
p.Director(outreq)
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove the connection header to the backend. We want a
// persistent connection, regardless of what the client sent
// to us. This is modifying the same underlying map from req
// (shallow copied above) so we only copy it if necessary.
if outreq.Header.Get("Connection") != "" {
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
outreq.Header.Del("Connection")
}
if clientIp, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
outreq.Header.Set("X-Forwarded-For", clientIp)
}
res, err := transport.RoundTrip(outreq)
if err != nil {
log.Printf("http: proxy error: %v", err)
rw.WriteHeader(http.StatusInternalServerError)
return
}
copyHeader(rw.Header(), res.Header)
rw.WriteHeader(res.StatusCode)
if res.Body != nil {
var dst io.Writer = rw
if p.FlushInterval != 0 {
if wf, ok := rw.(writeFlusher); ok {
dst = &maxLatencyWriter{dst: wf, latency: p.FlushInterval}
}
}
io.Copy(dst, res.Body)
}
}
func DynamicCall(w http.ResponseWriter, req *http.Request) {
fmDaemon.DaemonLog.DebugHttp(req)
req.ProtoMinor = 0
add := req.RemoteAddr
addTmp := strings.Split(add, ":")
address := addTmp[0]
cmd := strings.Split(req.RequestURI, "/")
//Flunky Auth needed
fmDaemon.UpdateActivity()
tmp := fm.RenderGetDynamic(req.RequestURI, address)
status := strings.TrimSpace(string(tmp))
w.Write([]byte(status))
fmDaemon.DaemonLog.Log(fmt.Sprintf("%s Rendered %s", cmd[1:], address))
}
func TestTransportConnectionCloseOnRequest(t *testing.T) {
ts := httptest.NewServer(hostPortHandler)
defer ts.Close()
connSet, testDial := makeTestDial(t)
for _, connectionClose := range []bool{false, true} {
tr := &Transport{
Dial: testDial,
}
c := &http.Client{Transport: tr}
fetch := func(n int) string {
req := new(http.Request)
var err error
req.URL, err = url.Parse(ts.URL)
if err != nil {
t.Fatalf("URL parse error: %v", err)
}
req.Method = "GET"
req.Proto = "HTTP/1.1"
req.ProtoMajor = 1
req.ProtoMinor = 1
req.Close = connectionClose
res, err := c.Do(req)
if err != nil {
t.Fatalf("error in connectionClose=%v, req #%d, Do: %v", connectionClose, n, err)
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("error in connectionClose=%v, req #%d, ReadAll: %v", connectionClose, n, err)
}
return string(body)
}
body1 := fetch(1)
body2 := fetch(2)
bodiesDiffer := body1 != body2
if bodiesDiffer != connectionClose {
t.Errorf("error in connectionClose=%v. unexpected bodiesDiffer=%v; body1=%q; body2=%q",
connectionClose, bodiesDiffer, body1, body2)
}
tr.CloseIdleConnections()
}
connSet.check(t)
}
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
transport := p.Transport
if transport == nil {
transport = http.DefaultTransport
}
outreq := new(http.Request)
*outreq = *req // includes shallow copies of maps, but okay
p.Director(outreq)
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove the connection header to the backend. We want a
// persistent connection, regardless of what the client sent
// to us. This is modifying the same underlying map from req
// (shallow copied above) so we only copy it if necessary.
if outreq.Header.Get("Connection") != "" {
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
outreq.Header.Del("Connection")
}
if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
// If we aren't the first proxy retain prior
// X-Forwarded-For information as a comma+space
// separated list and fold multiple headers into one.
if prior, ok := outreq.Header["X-Forwarded-For"]; ok {
clientIP = strings.Join(prior, ", ") + ", " + clientIP
}
outreq.Header.Set("X-Forwarded-For", clientIP)
}
res, err := transport.RoundTrip(outreq)
if err != nil {
log.Printf("http: proxy error: %v", err)
rw.WriteHeader(http.StatusInternalServerError)
return
}
defer res.Body.Close()
copyHeader(rw.Header(), res.Header)
rw.WriteHeader(res.StatusCode)
p.copyResponse(rw, res.Body)
}
func relay(w http.ResponseWriter, req *http.Request) {
defer func() {
if err := recover(); err != nil {
http.Error(w, fmt.Sprint(err), 200)
}
}()
c, proxy, err := buildProxy()
if err != nil {
panic(err)
}
defer c.Close()
_ = proxy
outreq := new(http.Request)
*outreq = *req // includes shallow copies of maps, but okay
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
// Remove the connection header to the backend. We want a
// persistent connection, regardless of what the client sent
// to us. This is modifying the same underlying map from req
// (shallow copied above) so we only copy it if necessary.
if outreq.Header.Get("Connection") != "" {
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
outreq.Header.Del("Connection")
}
outreq.Write(c)
br := bufio.NewReader(c)
resp, err := http.ReadResponse(br, outreq)
if err != nil {
panic(err)
}
copyHeader(w.Header(), resp.Header)
w.WriteHeader(resp.StatusCode)
if resp.Body != nil {
io.Copy(w, resp.Body)
}
}
// Issue a request to an internal handler. This duplicates some logic found in
// net.http.serve http://golang.org/src/net/http/server.go?#L1124 and
// net.http.readRequest http://golang.org/src/net/http/server.go?#L
func (t *WSTunnelClient) finishInternalRequest(id int16, req *http.Request) {
log := t.Log.New("id", id, "verb", req.Method, "uri", req.RequestURI)
log.Info("HTTP issuing internal request")
// Remove hop-by-hop headers
for _, h := range hopHeaders {
req.Header.Del(h)
}
// Add fake protocol version
req.Proto = "HTTP/1.0"
req.ProtoMajor = 1
req.ProtoMinor = 0
// Dump the request into a buffer in case we want to log it
dump, _ := httputil.DumpRequest(req, false)
log.Debug("dump", "req", strings.Replace(string(dump), "\r\n", " || ", -1))
// Make sure we don't die if a panic occurs in the handler
defer func() {
if err := recover(); err != nil {
const size = 64 << 10
buf := make([]byte, size)
buf = buf[:runtime.Stack(buf, false)]
log.Error("HTTP panic in handler", "err", err, "stack", string(buf))
}
}()
// Concoct Response
rw := newResponseWriter(req)
// Issue the request to the HTTP server
t.InternalServer.ServeHTTP(rw, req)
err := rw.finishResponse()
if err != nil {
//dump2, _ := httputil.DumpResponse(resp, true)
//log15.Info("handleWsRequests: request error", "err", err.Error(),
// "req", string(dump), "resp", string(dump2))
log.Info("HTTP request error", "err", err.Error())
writeResponseMessage(t, id, concoctResponse(req, err.Error(), 502))
return
}
log.Info("HTTP responded", "status", rw.resp.Status)
writeResponseMessage(t, id, rw.resp)
}
// NewFastHTTPHandler wraps net/http handler to fasthttp request handler,
// so it can be passed to fasthttp server.
//
// While this function may be used for easy switching from net/http to fasthttp,
// it has the following drawbacks comparing to using manually written fasthttp
// request handler:
//
// * A lot of useful functionality provided by fasthttp is missing
// from net/http handler.
// * net/http -> fasthttp handler conversion has some overhead,
// so the returned handler will be always slower than manually written
// fasthttp handler.
//
// So it is advisable using this function only for quick net/http -> fasthttp
// switching. Then manually convert net/http handlers to fasthttp handlers
// according to https://github.com/valyala/fasthttp#switching-from-nethttp-to-fasthttp .
func NewFastHTTPHandler(h http.Handler) fasthttp.RequestHandler {
return func(ctx *fasthttp.RequestCtx) {
var r http.Request
body := ctx.PostBody()
r.Method = string(ctx.Method())
r.Proto = "HTTP/1.1"
r.ProtoMajor = 1
r.ProtoMinor = 1
r.RequestURI = string(ctx.RequestURI())
r.ContentLength = int64(len(body))
r.Host = string(ctx.Host())
r.RemoteAddr = ctx.RemoteAddr().String()
hdr := make(http.Header)
ctx.Request.Header.VisitAll(func(k, v []byte) {
sk := string(k)
sv := string(v)
switch sk {
case "Transfer-Encoding":
r.TransferEncoding = append(r.TransferEncoding, sv)
default:
hdr.Set(sk, sv)
}
})
r.Header = hdr
r.Body = &netHTTPBody{body}
rURL, err := url.ParseRequestURI(r.RequestURI)
if err != nil {
ctx.Logger().Printf("cannot parse requestURI %q: %s", r.RequestURI, err)
ctx.Error("Internal Server Error", fasthttp.StatusInternalServerError)
return
}
r.URL = rURL
var w netHTTPResponseWriter
h.ServeHTTP(&w, &r)
ctx.SetStatusCode(w.StatusCode())
for k, vv := range w.Header() {
for _, v := range vv {
ctx.Response.Header.Set(k, v)
}
}
ctx.Write(w.body)
}
}
func (p *Proxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
node := p.lookup(req)
if node == nil {
rw.WriteHeader(http.StatusNotFound)
return
}
p.increaseConn(node)
defer p.decreaseConn(node)
outreq := new(http.Request)
*outreq = *req
outreq.URL.Scheme = "http"
outreq.URL.Host = node.Host
outreq.Proto = "HTTP/1.1"
outreq.ProtoMajor = 1
outreq.ProtoMinor = 1
outreq.Close = false
if outreq.Header.Get("Connection") != "" {
outreq.Header = make(http.Header)
copyHeader(outreq.Header, req.Header)
outreq.Header.Del("Connection")
}
if clientIp, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
outreq.Header.Set("X-Forwarded-For", clientIp)
}
res, err := http.DefaultTransport.RoundTrip(outreq)
if err != nil {
log.Printf("proxy round trip error: %v", err)
rw.WriteHeader(http.StatusInternalServerError)
return
}
copyHeader(rw.Header(), res.Header)
rw.WriteHeader(res.StatusCode)
if res.Body != nil {
var dst io.Writer = rw
io.Copy(dst, res.Body)
}
}