gateway: initial hostname-based routing

Replace IPNSHostname based routing with general-purpose hostname-based routing
that also supports handling requests to "known gateways".

TODO: I'll break KnownGateways out into a config option in a later commit.

License: MIT
Signed-off-by: Steven Allen <[email protected]>

Author: Stebalien

cmd/ipfs/daemon.go

@@ -637,7 +637,7 @@ func serveHTTPGateway(req *cmds.Request, cctx *oldcmds.Context) (<-chan error, e
 	var opts = []corehttp.ServeOption{
 		corehttp.ProxyOption(), // Proxies all CONNECT requests to self. Always put this first.
 		corehttp.MetricsCollectionOption("gateway"),
-		corehttp.IPNSHostnameOption(),
+		corehttp.HostnameOption(),
 		corehttp.GatewayOption(writable, "/ipfs", "/ipns"),
 		corehttp.VersionOption(),
 		corehttp.CheckVersionOption(),

core/corehttp/gateway_handler.go

@@ -31,6 +31,28 @@ const (
 	ipnsPathPrefix = "/ipns/"
 )
 
+type GatewaySpec struct {
+	// PathPrefixes list the set of path prefixes that should be handled by
+	// the gateway logic.
+	PathPrefixes []string
+
+	// SupportsSubdomains indicates whether or not this gateway supports
+	// requests of the form http://CID.ipfs.GATEWAY/...
+	SupportsSubdomains bool
+}
+
+var DefaultGatewaySpec = GatewaySpec{
+	PathPrefixes:       []string{ipfsPathPrefix, ipnsPathPrefix, "/api/"},
+	SupportsSubdomains: true,
+}
+
+// TODO(steb): Configurable
+var KnownGateways = map[string]GatewaySpec{
+	"ipfs.io":         DefaultGatewaySpec,
+	"gateway.ipfs.io": DefaultGatewaySpec,
+	"localhost:8080":  DefaultGatewaySpec,
+}
+
 // gatewayHandler is a HTTP handler that serves IPFS objects (accessible by default at /ipfs/<path>)
 // (it serves requests like GET /ipfs/QmVRzPKPzNtSrEzBFm2UZfxmPAgnaLke4DMcerbsGGSaFe/link)
 type gatewayHandler struct {
@@ -142,7 +164,7 @@ func (i *gatewayHandler) getOrHeadHandler(w http.ResponseWriter, r *http.Request
 		}
 	}
 
-	// IPNSHostnameOption might have constructed an IPNS path using the Host header.
+	// HostnameOption might have constructed an IPNS/IPFS path using the Host header.
 	// In this case, we need the original path for constructing redirects
 	// and links that match the requested URL.
 	// For example, http://example.net would become /ipns/example.net, and

core/corehttp/gateway_test.go

@@ -138,7 +138,7 @@ func newTestServerAndNode(t *testing.T, ns mockNamesys) (*httptest.Server, iface
 
 	dh.Handler, err = makeHandler(n,
 		ts.Listener,
-		IPNSHostnameOption(),
+		HostnameOption(),
 		GatewayOption(false, "/ipfs", "/ipns"),
 		VersionOption(),
 	)

core/corehttp/hostname.go

@@ -0,0 +1,78 @@
+package corehttp
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"strings"
+
+	core "github.com/ipfs/go-ipfs/core"
+	namesys "github.com/ipfs/go-ipfs/namesys"
+
+	nsopts "github.com/ipfs/interface-go-ipfs-core/options/namesys"
+	isd "github.com/jbenet/go-is-domain"
+)
+
+// HostnameOption rewrites an incoming request based on the Host header.
+func HostnameOption() ServeOption {
+	return func(n *core.IpfsNode, _ net.Listener, mux *http.ServeMux) (*http.ServeMux, error) {
+		childMux := http.NewServeMux()
+		mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+			ctx, cancel := context.WithCancel(n.Context())
+			defer cancel()
+
+			// Is this one of our "known gateways"?
+			if gw, ok := KnownGateways[r.Host]; ok {
+				if hasPrefix(r.URL.Path, gw.PathPrefixes...) {
+					childMux.ServeHTTP(w, r)
+					return
+				}
+			} else if host, pathPrefix, ok := parseSubdomains(r.Host); ok {
+				if gw, ok := KnownGateways[host]; ok && gw.SupportsSubdomains {
+					// Always handle this with the gateway.
+					// We don't care if it's one of the
+					// valid path-prefixes.
+
+					r.URL.Path = pathPrefix + r.URL.Path
+					childMux.ServeHTTP(w, r)
+					return
+				}
+			}
+
+			host := strings.SplitN(r.Host, ":", 2)[0]
+			if len(host) == 0 || !isd.IsDomain(host) {
+				childMux.ServeHTTP(w, r)
+				return
+			}
+
+			name := "/ipns/" + host
+			_, err := n.Namesys.Resolve(ctx, name, nsopts.Depth(1))
+			if err == nil || err == namesys.ErrResolveRecursion {
+				r.URL.Path = name + r.URL.Path
+			}
+			childMux.ServeHTTP(w, r)
+		})
+		return childMux, nil
+	}
+}
+
+func parseSubdomains(host string) (newHost, pathPrefix string, ok bool) {
+	parts := strings.SplitN(host, ".", 3)
+	if len(parts) < 3 {
+		return "", "", false
+	}
+	switch parts[1] {
+	case "ipfs", "ipns", "p2p":
+		return parts[2], "/" + parts[1] + "/" + parts[0], true
+	}
+	return "", "", false
+}
+
+func hasPrefix(s string, prefixes ...string) bool {
+	for _, prefix := range prefixes {
+		if strings.HasPrefix(s, prefix) {
+			return true
+		}
+	}
+	return false
+}