ipfs/ipfs-cluster

package ipfsproxy

import (
    "fmt"
    "net/http"
    "time"

    "github.com/ipfs-cluster/ipfs-cluster/version"
)

// This file has the collection of header-related functions

// We will extract all these from a pre-flight OPTIONs request to IPFS to
// use in the respose of a hijacked request (usually POST).
var corsHeaders = []string{
    // These two must be returned as IPFS would return them
    // for a request with the same origin.
    "Access-Control-Allow-Origin",
    "Vary", // seems more correctly set in OPTIONS than other requests.

    // This is returned by OPTIONS so we can take it, even if ipfs sets
    // it for nothing by default.
    "Access-Control-Allow-Credentials",

    // Unfortunately this one should not come with OPTIONS by default,
    // but only with the real request itself.
    // We use extractHeadersDefault for it, even though I think
    // IPFS puts it in OPTIONS responses too. In any case, ipfs
    // puts it on all requests as of 0.4.18, so it should be OK.
    // "Access-Control-Expose-Headers",

    // Only for preflight responses, we do not need
    // these since we will simply proxy OPTIONS requests and not
    // handle them.
    //
    // They are here for reference about other CORS related headers.
    // "Access-Control-Max-Age",
    // "Access-Control-Allow-Methods",
    // "Access-Control-Allow-Headers",
}

// This can be used to hardcode header extraction from the proxy if we ever
// need to. It is appended to config.ExtractHeaderExtra.
// Maybe "X-Ipfs-Gateway" is a good candidate.
var extractHeadersDefault = []string{
    "Access-Control-Expose-Headers",
}

const ipfsHeadersTimestampKey = "proxyHeadersTS"

// ipfsHeaders returns all the headers we want to extract-once from IPFS: a
// concatenation of extractHeadersDefault and config.ExtractHeadersExtra.
func (proxy *Server) ipfsHeaders() []string {
    return append(extractHeadersDefault, proxy.config.ExtractHeadersExtra...)
}

// rememberIPFSHeaders extracts headers and stores them for re-use with
// setIPFSHeaders.
func (proxy *Server) rememberIPFSHeaders(hdrs http.Header) {
    for _, h := range proxy.ipfsHeaders() {
        proxy.ipfsHeadersStore.Store(h, hdrs[h])
    }
    // use the sync map to store the ts
    proxy.ipfsHeadersStore.Store(ipfsHeadersTimestampKey, time.Now())
}

// returns whether we can consider that whatever headers we are
// storing have a valid TTL still.
func (proxy *Server) headersWithinTTL() bool {
    ttl := proxy.config.ExtractHeadersTTL
    if ttl == 0 {
        return true
    }

    tsRaw, ok := proxy.ipfsHeadersStore.Load(ipfsHeadersTimestampKey)
    if !ok {
        return false
    }

    ts, ok := tsRaw.(time.Time)
    if !ok {
        return false
    }

    lifespan := time.Since(ts)
    return lifespan < ttl
}

// setIPFSHeaders adds the known IPFS Headers to the destination
// and returns true if we could set all the headers in the list and
// the TTL has not expired.
// False is used to determine if we need to make a request to try
// to extract these headers.
func (proxy *Server) setIPFSHeaders(dest http.Header) bool {
    r := true

    if !proxy.headersWithinTTL() {
        r = false
        // still set those headers we can set in the destination.
        // We do our best there, since maybe the ipfs daemon
        // is down and what we have now is all we can use.
    }

    for _, h := range proxy.ipfsHeaders() {
        v, ok := proxy.ipfsHeadersStore.Load(h)
        if !ok {
            r = false
            continue
        }
        dest[h] = v.([]string)
    }
    return r
}

// copyHeadersFromIPFSWithRequest makes a request to IPFS as used by the proxy
// and copies the given list of hdrs from the response to the dest http.Header
// object.
func (proxy *Server) copyHeadersFromIPFSWithRequest(
    hdrs []string,
    dest http.Header, req *http.Request,
) error {
    res, err := proxy.reverseProxy.Transport.RoundTrip(req)
    if err != nil {
        logger.Error("error making request for header extraction to ipfs: ", err)
        return err
    }

    for _, h := range hdrs {
        dest[h] = res.Header[h]
    }
    return nil
}

// setHeaders sets some headers for all hijacked endpoints:
//   - First, we fix CORs headers by making an OPTIONS request to IPFS with the
//     same Origin. Our objective is to get headers for non-preflight requests
//     only (the ones we hijack).
//   - Second, we add any of the one-time-extracted headers that we deem necessary
//     or the user needs from IPFS (in case of custom headers).
//     This may trigger a single POST request to ExtractHeaderPath if they
//     were not extracted before or TTL has expired.
//   - Third, we set our own headers.
func (proxy *Server) setHeaders(dest http.Header, srcRequest *http.Request) {
    proxy.setCORSHeaders(dest, srcRequest)
    proxy.setAdditionalIpfsHeaders(dest, srcRequest)
    proxy.setClusterProxyHeaders(dest, srcRequest)
}

// see setHeaders
func (proxy *Server) setCORSHeaders(dest http.Header, srcRequest *http.Request) {
    // Fix CORS headers by making an OPTIONS request

    // The request URL only has a valid Path(). See http.Request docs.
    srcURL := fmt.Sprintf("%s%s", proxy.nodeAddr, srcRequest.URL.Path)
    req, err := http.NewRequest(http.MethodOptions, srcURL, nil)
    if err != nil { // this should really not happen.
        logger.Error(err)
        return
    }

    req.Header["Origin"] = srcRequest.Header["Origin"]
    req.Header.Set("Access-Control-Request-Method", srcRequest.Method)
    // error is logged. We proceed if request failed.
    proxy.copyHeadersFromIPFSWithRequest(corsHeaders, dest, req)
}

// see setHeaders
func (proxy *Server) setAdditionalIpfsHeaders(dest http.Header, srcRequest *http.Request) {
    // Avoid re-requesting these if we have them
    if ok := proxy.setIPFSHeaders(dest); ok {
        return
    }

    srcURL := fmt.Sprintf("%s%s", proxy.nodeAddr, proxy.config.ExtractHeadersPath)
    req, err := http.NewRequest(http.MethodPost, srcURL, nil)
    if err != nil {
        logger.Error("error extracting additional headers from ipfs", err)
        return
    }
    // error is logged. We proceed if request failed.
    proxy.copyHeadersFromIPFSWithRequest(
        proxy.ipfsHeaders(),
        dest,
        req,
    )
    proxy.rememberIPFSHeaders(dest)
}

// see setHeaders
func (proxy *Server) setClusterProxyHeaders(dest http.Header, srcRequest *http.Request) {
    dest.Set("Content-Type", "application/json")
    dest.Set("Server", fmt.Sprintf("ipfs-cluster/ipfsproxy/%s", version.Version))
}