func (h *handler) ServeHTTP(wOrig http.ResponseWriter, r *http.Request) {
var statusCode = 0
var statusText string
remoteAddr := r.RemoteAddr
if xff := r.Header.Get("X-Forwarded-For"); xff != "" {
remoteAddr = xff + "," + remoteAddr
}
w := httpserver.WrapResponseWriter(wOrig)
defer func() {
if statusCode == 0 {
statusCode = w.WroteStatus()
} else if w.WroteStatus() == 0 {
w.WriteHeader(statusCode)
} else if w.WroteStatus() != statusCode {
httpserver.Log(r.RemoteAddr, "WARNING",
fmt.Sprintf("Our status changed from %d to %d after we sent headers", w.WroteStatus(), statusCode))
}
if statusText == "" {
statusText = http.StatusText(statusCode)
}
httpserver.Log(remoteAddr, statusCode, statusText, w.WroteBodyBytes(), r.Method, r.Host, r.URL.Path, r.URL.RawQuery)
}()
if r.Method != "GET" && r.Method != "POST" {
statusCode, statusText = http.StatusMethodNotAllowed, r.Method
return
}
if r.Header.Get("Origin") != "" {
// Allow simple cross-origin requests without user
// credentials ("user credentials" as defined by CORS,
// i.e., cookies, HTTP authentication, and client-side
// SSL certificates. See
// http://www.w3.org/TR/cors/#user-credentials).
w.Header().Set("Access-Control-Allow-Origin", "*")
}
arv := clientPool.Get()
if arv == nil {
statusCode, statusText = http.StatusInternalServerError, "Pool failed: "+clientPool.Err().Error()
return
}
defer clientPool.Put(arv)
pathParts := strings.Split(r.URL.Path[1:], "/")
var targetID string
var targetPath []string
var tokens []string
var reqTokens []string
var pathToken bool
var attachment bool
credentialsOK := trustAllContent
if r.Host != "" && r.Host == attachmentOnlyHost {
credentialsOK = true
attachment = true
} else if r.FormValue("disposition") == "attachment" {
attachment = true
}
if targetID = parseCollectionIDFromDNSName(r.Host); targetID != "" {
// http://ID.collections.example/PATH...
credentialsOK = true
targetPath = pathParts
} else if len(pathParts) >= 2 && strings.HasPrefix(pathParts[0], "c=") {
// /c=ID/PATH...
targetID = parseCollectionIDFromURL(pathParts[0][2:])
targetPath = pathParts[1:]
} else if len(pathParts) >= 3 && pathParts[0] == "collections" {
if len(pathParts) >= 5 && pathParts[1] == "download" {
// /collections/download/ID/TOKEN/PATH...
targetID = pathParts[2]
tokens = []string{pathParts[3]}
targetPath = pathParts[4:]
pathToken = true
} else {
// /collections/ID/PATH...
targetID = pathParts[1]
tokens = anonymousTokens
targetPath = pathParts[2:]
}
} else {
statusCode = http.StatusNotFound
return
}
formToken := r.FormValue("api_token")
if formToken != "" && r.Header.Get("Origin") != "" && attachment && r.URL.Query().Get("api_token") == "" {
// The client provided an explicit token in the POST
// body. The Origin header indicates this *might* be
// an AJAX request, in which case redirect-with-cookie
// won't work: we should just serve the content in the
// POST response. This is safe because:
//
// * We're supplying an attachment, not inline
// content, so we don't need to convert the POST to
// a GET and avoid the "really resubmit form?"
// problem.
//
// * The token isn't embedded in the URL, so we don't
// need to worry about bookmarks and copy/paste.
tokens = append(tokens, formToken)
} else if formToken != "" {
// The client provided an explicit token in the query
// string, or a form in POST body. We must put the
// token in an HttpOnly cookie, and redirect to the
// same URL with the query param redacted and method =
// GET.
if !credentialsOK {
// It is not safe to copy the provided token
// into a cookie unless the current vhost
// (origin) serves only a single collection or
// we are in trustAllContent mode.
statusCode = http.StatusBadRequest
return
}
// The HttpOnly flag is necessary to prevent
// JavaScript code (included in, or loaded by, a page
// in the collection being served) from employing the
// user's token beyond reading other files in the same
// domain, i.e., same collection.
//
// The 303 redirect is necessary in the case of a GET
// request to avoid exposing the token in the Location
// bar, and in the case of a POST request to avoid
// raising warnings when the user refreshes the
// resulting page.
http.SetCookie(w, &http.Cookie{
Name: "arvados_api_token",
Value: auth.EncodeTokenCookie([]byte(formToken)),
Path: "/",
HttpOnly: true,
})
// Propagate query parameters (except api_token) from
// the original request.
redirQuery := r.URL.Query()
redirQuery.Del("api_token")
redir := (&url.URL{
Host: r.Host,
Path: r.URL.Path,
RawQuery: redirQuery.Encode(),
}).String()
w.Header().Add("Location", redir)
statusCode, statusText = http.StatusSeeOther, redir
w.WriteHeader(statusCode)
io.WriteString(w, `<A href="`)
io.WriteString(w, html.EscapeString(redir))
io.WriteString(w, `">Continue</A>`)
return
}
if tokens == nil && strings.HasPrefix(targetPath[0], "t=") {
// http://ID.example/t=TOKEN/PATH...
// /c=ID/t=TOKEN/PATH...
//
// This form must only be used to pass scoped tokens
// that give permission for a single collection. See
// FormValue case above.
tokens = []string{targetPath[0][2:]}
pathToken = true
targetPath = targetPath[1:]
}
if tokens == nil {
if credentialsOK {
reqTokens = auth.NewCredentialsFromHTTPRequest(r).Tokens
}
tokens = append(reqTokens, anonymousTokens...)
}
if len(targetPath) > 0 && targetPath[0] == "_" {
// If a collection has a directory called "t=foo" or
// "_", it can be served at
// //collections.example/_/t=foo/ or
// //collections.example/_/_/ respectively:
// //collections.example/t=foo/ won't work because
// t=foo will be interpreted as a token "foo".
targetPath = targetPath[1:]
}
tokenResult := make(map[string]int)
collection := make(map[string]interface{})
found := false
for _, arv.ApiToken = range tokens {
err := arv.Get("collections", targetID, nil, &collection)
if err == nil {
// Success
found = true
break
}
if srvErr, ok := err.(arvadosclient.APIServerError); ok {
switch srvErr.HttpStatusCode {
case 404, 401:
// Token broken or insufficient to
// retrieve collection
tokenResult[arv.ApiToken] = srvErr.HttpStatusCode
continue
}
}
// Something more serious is wrong
statusCode, statusText = http.StatusInternalServerError, err.Error()
return
}
if !found {
if pathToken || !credentialsOK {
// Either the URL is a "secret sharing link"
// that didn't work out (and asking the client
// for additional credentials would just be
// confusing), or we don't even accept
// credentials at this path.
statusCode = http.StatusNotFound
return
}
for _, t := range reqTokens {
if tokenResult[t] == 404 {
// The client provided valid token(s), but the
// collection was not found.
statusCode = http.StatusNotFound
return
}
}
// The client's token was invalid (e.g., expired), or
// the client didn't even provide one. Propagate the
// 401 to encourage the client to use a [different]
// token.
//
// TODO(TC): This response would be confusing to
// someone trying (anonymously) to download public
// data that has been deleted. Allow a referrer to
// provide this context somehow?
w.Header().Add("WWW-Authenticate", "Basic realm=\"collections\"")
statusCode = http.StatusUnauthorized
return
}
filename := strings.Join(targetPath, "/")
kc, err := keepclient.MakeKeepClient(arv)
if err != nil {
statusCode, statusText = http.StatusInternalServerError, err.Error()
return
}
if kc.Client != nil && kc.Client.Transport != nil {
// Workaround for https://dev.arvados.org/issues/9005
if t, ok := kc.Client.Transport.(*http.Transport); ok {
defer t.CloseIdleConnections()
}
}
rdr, err := kc.CollectionFileReader(collection, filename)
if os.IsNotExist(err) {
statusCode = http.StatusNotFound
return
} else if err != nil {
statusCode, statusText = http.StatusBadGateway, err.Error()
return
}
defer rdr.Close()
basenamePos := strings.LastIndex(filename, "/")
if basenamePos < 0 {
basenamePos = 0
}
extPos := strings.LastIndex(filename, ".")
if extPos > basenamePos {
// Now extPos is safely >= 0.
if t := mime.TypeByExtension(filename[extPos:]); t != "" {
w.Header().Set("Content-Type", t)
}
}
if rdr, ok := rdr.(keepclient.ReadCloserWithLen); ok {
w.Header().Set("Content-Length", fmt.Sprintf("%d", rdr.Len()))
}
applyContentDispositionHdr(w, r, filename[basenamePos:], attachment)
rangeRdr, statusCode := applyRangeHdr(w, r, rdr)
w.WriteHeader(statusCode)
_, err = io.Copy(w, rangeRdr)
if err != nil {
statusCode, statusText = http.StatusBadGateway, err.Error()
}
}
func (h *authHandler) ServeHTTP(wOrig http.ResponseWriter, r *http.Request) {
var statusCode int
var statusText string
var apiToken string
var repoName string
var validApiToken bool
w := httpserver.WrapResponseWriter(wOrig)
defer func() {
if w.WroteStatus() == 0 {
// Nobody has called WriteHeader yet: that
// must be our job.
w.WriteHeader(statusCode)
w.Write([]byte(statusText))
}
// If the given password is a valid token, log the first 10 characters of the token.
// Otherwise: log the string <invalid> if a password is given, else an empty string.
passwordToLog := ""
if !validApiToken {
if len(apiToken) > 0 {
passwordToLog = "<invalid>"
}
} else {
passwordToLog = apiToken[0:10]
}
httpserver.Log(r.RemoteAddr, passwordToLog, w.WroteStatus(), statusText, repoName, r.Method, r.URL.Path)
}()
creds := auth.NewCredentialsFromHTTPRequest(r)
if len(creds.Tokens) == 0 {
statusCode, statusText = http.StatusUnauthorized, "no credentials provided"
w.Header().Add("WWW-Authenticate", "Basic realm=\"git\"")
return
}
apiToken = creds.Tokens[0]
// Access to paths "/foo/bar.git/*" and "/foo/bar/.git/*" are
// protected by the permissions on the repository named
// "foo/bar".
pathParts := strings.SplitN(r.URL.Path[1:], ".git/", 2)
if len(pathParts) != 2 {
statusCode, statusText = http.StatusBadRequest, "bad request"
return
}
repoName = pathParts[0]
repoName = strings.TrimRight(repoName, "/")
arv := clientPool.Get()
if arv == nil {
statusCode, statusText = http.StatusInternalServerError, "connection pool failed: "+clientPool.Err().Error()
return
}
defer clientPool.Put(arv)
// Ask API server whether the repository is readable using
// this token (by trying to read it!)
arv.ApiToken = apiToken
reposFound := arvadosclient.Dict{}
if err := arv.List("repositories", arvadosclient.Dict{
"filters": [][]string{{"name", "=", repoName}},
}, &reposFound); err != nil {
statusCode, statusText = http.StatusInternalServerError, err.Error()
return
}
validApiToken = true
if avail, ok := reposFound["items_available"].(float64); !ok {
statusCode, statusText = http.StatusInternalServerError, "bad list response from API"
return
} else if avail < 1 {
statusCode, statusText = http.StatusNotFound, "not found"
return
} else if avail > 1 {
statusCode, statusText = http.StatusInternalServerError, "name collision"
return
}
repoUUID := reposFound["items"].([]interface{})[0].(map[string]interface{})["uuid"].(string)
isWrite := strings.HasSuffix(r.URL.Path, "/git-receive-pack")
if !isWrite {
statusText = "read"
} else {
err := arv.Update("repositories", repoUUID, arvadosclient.Dict{
"repository": arvadosclient.Dict{
"modified_at": time.Now().String(),
},
}, &arvadosclient.Dict{})
if err != nil {
statusCode, statusText = http.StatusForbidden, err.Error()
return
}
statusText = "write"
}
// Regardless of whether the client asked for "/foo.git" or
// "/foo/.git", we choose whichever variant exists in our repo
// root, and we try {uuid}.git and {uuid}/.git first. If none
// of these exist, we 404 even though the API told us the repo
// _should_ exist (presumably this means the repo was just
// created, and gitolite sync hasn't run yet).
rewrittenPath := ""
tryDirs := []string{
"/" + repoUUID + ".git",
"/" + repoUUID + "/.git",
"/" + repoName + ".git",
"/" + repoName + "/.git",
}
for _, dir := range tryDirs {
if fileInfo, err := os.Stat(theConfig.Root + dir); err != nil {
if !os.IsNotExist(err) {
statusCode, statusText = http.StatusInternalServerError, err.Error()
return
}
} else if fileInfo.IsDir() {
rewrittenPath = dir + "/" + pathParts[1]
break
}
}
if rewrittenPath == "" {
log.Println("WARNING:", repoUUID,
"git directory not found in", theConfig.Root, tryDirs)
// We say "content not found" to disambiguate from the
// earlier "API says that repo does not exist" error.
statusCode, statusText = http.StatusNotFound, "content not found"
return
}
r.URL.Path = rewrittenPath
handlerCopy := *h.handler
handlerCopy.Env = append(handlerCopy.Env, "REMOTE_USER="+r.RemoteAddr) // Should be username
handlerCopy.ServeHTTP(&w, r)
}