Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

feat: gateway subdomains + http proxy mode #6096

Merged
merged 6 commits into from
Mar 18, 2020
Merged

Conversation

Stebalien
Copy link
Member

@Stebalien Stebalien commented Mar 18, 2019

Depends on ipfs/go-ipfs-config#30

  • TODO: Needs base32 peer IDs. The IPNS and p2p proxy stuff doesn't currently work due to this.
  • Think through the "known gateway" concept.

What does this do?

  1. Any HTTP CONNECT (proxy) requests will be looped backed to the gateway. This means a browser can, e.g., proxy http://ipfs.io/ipfs/... to the local gateway without redirecting (or touching the URL bar).
  2. IPFS can handle CIDs in subdomains. That is, http://CID.ipfs.localhost:8080.

fixes #5982
fixes #6498
cc ipfs/in-web-browsers#89, ipfs/ipfs-companion#667

@ghost ghost assigned Stebalien Mar 18, 2019
@ghost ghost added the status/in-progress In progress label Mar 18, 2019
@Stebalien Stebalien force-pushed the feat/gateway-subdomains branch 2 times, most recently from bb44c3c to 5abd144 Compare March 25, 2019 12:14
@lidel
Copy link
Member

lidel commented Jul 16, 2019

I'm trying to look at this by the lens of what potential user wants.
AFAIK simplified Gateway use cases are:

  • (A) run go-ipfs on local machine with default settings
  • (B) run Path Gateway on some hostname
  • (C) run DNSLink Gateway for some|single domain with proper DNS TXT record
  • (D) set up Subdomain Gateway on some hostname

I think (A) should be "batteries included" and not require any configuration, (D) requires more advanced setup in DNS anyway, so it is ok for it to be an opt-in, and there is some vagueness about resolution rules when (B) and (C) happen to use the same hostname, which suggests there should be a way to make both configurable or simply do not allow that scenario on a single hostname.

Having that as a starting point, some notes below (apologies, I failed to make this shorter).

Simplify configuration of Gateway features

I like the idea of having explicit list of hostnames that impacts the way requests are handled, but we should not hardcode any known PublicGateways: we want people to run their own. Let's keep the list empty and dogfood entire configuration process on our gateways.

Would it be more versatile and easier to reason about if we tweak ipfs/go-ipfs-config#30 and add three clear options to control gateway behavior?

Something like (names are just placeholders):

  • Gateway.DNSLink – optional boolean to control DNSLink support (default: true)
  • Gateway.SubdomainHosts – optional array of hostnames whitelisted for use in subdomains and proxy mode (+ implicit localhost)
  • Gateway.PathHosts - optional array of hostnames that are known to be path-based Gateways where content paths should take priority over DNSLink (+ implicit 127.0.0.1 and ::1)

Caveats:

  • These config options replace UseSubdomains and PublicGateways
  • Every hostname on Gateway.SubdomainHosts needs to redirect non-subdomain paths (dweb.link/ipfs/<cid>/foo) to subdomain ones (<cid>.ipfs.dweb.link/foo)
  • There needs to be some validation that ensures SubdomainHosts and PathHosts have no overlap or ignore hostnames that are on both
  • If we don't allow DNSLink+Path Gateway on the same hostname (and handle ipfs.io via Nginx) the Gateway Heuristic below get MUCH easier, and I think we no longer need PathHosts

Gateway Heuristic

Localhost

IIUC there is a golden path for localhost:

  • Support <cid>.<ns>.localhost out of the box
    (localhost as a permanent, implicit entry on Gateway.SubdomainHosts)
  • requests to localhost hostname (without subdomain) need to be redirected to 127.0.0.1 (same path, but on raw IP). This will ensure the Origin(s) of Path and Subdomain gateways on a local machine are separate (and users can have both!)

Public Gateways

I feel I am missing some context on gateway symlinks mentioned here – what are use cases for that?

So far I was under impression that mixing namespaces such as DNSLink website with Path Gateway is something we want to move away from. It makes security model unnecessarily hard to reason about and I did not see any use in production apart from ipfs.io (which we want to move to dweb.link anyway).

That being said:

If we allow Paths & DNSLink on the same hostname

We use Gateway.PathHosts to control which hostnames prioritize Path Gateway over DNSLink.
Default use case is hosting websites with DNSLink. DNSLink takes a priority unless gateway hostname is listed in Gateway.PathHosts:

  • IF Host is matching <cid>.<ns>.example.com and example.com is listed in Gateway.SubdomainHosts
    THEN process request as Subdomain Gateway
  • ELSE
    • IF path is /ipfs/, /ipns/ or /api/
      • IF example.com is listed in Gateway.PathHosts
        THEN process request as Path Gateway
      • ELSE
        • IF Host is not IP and DNSLink is present
          THEN process request as DNSLink
        • ELSE process request as Path Gateway
    • ELSE process request as DNSLink or return 404

If DNSLink always takes a priority

We don't need Gateway.PathHosts and it gets much easier:

  • IF Host is matching <cid>.<ns>.example.com and example.com is listed in Gateway.SubdomainHosts
    THEN process request as Subdomain Gateway
  • ELSE
    • IF Host is not IP and DNSLink is present
      THEN process request as DNSLink
    • ELSE process request as Path Gateway

Personally I'd like to keep it simple and avoid mixing DNSLink with Path Gateway if possible,
but let me know if I missed any nuance.

Configuration Examples

DNSLink

Gateway.DNSLink = true
Gateway.SubdomainHosts = []
Gateway.PathHosts = []
  • example.com/foo will load via DNSLink (if present)
  • example.com/ipfs/foo will load via DNSLink (if present)
  • <cid>.ipfs.example.com/foo will return 404 Not Found

Path Gateway

Gateway.DNSLink = true
Gateway.SubdomainHosts = []
Gateway.PathHosts = ['example.com']
  • example.com/foo will load via DNSLink (if we allow mixing with DNSLink)
  • example.com/ipfs/<cid> will load via Path Gateway
  • <cid>.ipfs.example.com/foo will return a 301 redirect to example.com/ipfs/<cid>/foo

Subdomain Gateway

Gateway.DNSLink = true
Gateway.SubdomainHosts = ['example.com']
Gateway.PathHosts = []
  • example.com/foo will load via DNSLink (if we allow mixing with DNSLink)
  • example.com/ipfs/<cid>/foo will return a 301 redirect to <cid>.ipfs.example.com/foo
  • <cid>.ipfs.example.com/ will load via Subdomain Gateway

Thoughts?

@lidel lidel mentioned this pull request Jul 16, 2019
@lanzafame lanzafame added the topic/gateway Topic gateway label Jul 17, 2019
@lidel

This comment has been minimized.

@Stebalien
Copy link
Member Author

Unless I'm mistaken, I believe our proposals are mostly isomorphic. PublicGateways isn't the list of all public gateways that exist, it's the list of public gateways that the go-ipfs proxy will handle.

We might want a better name.

Given:

{
  SubdomainHosts: ["x"],
  PathHosts: ["y"],
}

This would be expressed in the current patch as:

{
  PublicGateways: {
    "x": {
      "UseSubdomains": true,,
      "PathPrefixes": ["/ipfs", "/ipns"],
    },
    "y": {
      "UseSubdomains": false,
      "PathPrefixes": ["/ipfs", "/ipns"],
    },
  }
}

The benefits of doing it this way are:

  • No chance of conflicting rules.
  • We can add flags as we add optional features to gateways. (not a strong motivation)

There needs to be some validation that ensures SubdomainHosts and PathHosts have no overlap or ignore hostnames that are on both

That's why I had a single list.

If we don't allow DNSLink+Path Gateway on the same hostname (and handle ipfs.io via Nginx) the Gateway Heuristic below get MUCH easier, and I think we no longer need PathHosts

There's still an issue of hosting a DNSLink website and a subdomain gateway on the same hostname. In the original proposal, we'd redirect paths listed in PathPrefixes to the subdomain gateway.

I feel I am missing some context on gateway symlinks mentioned here – what are use cases for that?

With symlink support, any DNSLink website could become a "gateway" by creating a symlink to /ipfs. The go-ipfs gateway would.

  1. Lookup the dnslink record for the website.
  2. Resolve the website's IPFS directory.
  3. Lookup /ipns/my.domain/ipfs/...
  4. See that /ipns/my.domain/ipfs is actually a symlink to /ipfs.
  5. Serve /ipfs/...

So far I was under impression that mixing namespaces such as DNSLink website with Path Gateway is something we want to move away from. It makes security model unnecessarily hard to reason about and I did not see any use in production apart from ipfs.io (which we want to move to dweb.link anyway).

In general, we do. However, users may still want to have path-based gateways (possibly with javascript disabled via CSP) with a nice homepage.

@Stebalien
Copy link
Member Author

Gateway.DNSLink – optional boolean to control DNSLink support (default: true)

This should definitely be an option.

@Stebalien
Copy link
Member Author

What if we replace the boolean DNSLink with a third, optional list (catch-all if list is empty or missing)?

Good point.

@Stebalien
Copy link
Member Author

Thinking about it a bit, I like the way you've split the gateway lists (path/subdomain). I'm just not entirely sure how to handle subdomain gateways + dnslink + redirects.

@lidel
Copy link
Member

lidel commented Dec 30, 2019

dweb.link: all-in-one gateway edge case

I'm just not entirely sure how to handle subdomain gateways + dnslink + redirects.

Our dweb.link makes a good test case for this, so let's look at it as an example.

I believe the setup we want is:

  • subdomain gateway at {cid}.ipfs.dweb.link
  • path gateway at dweb.link/ipfs/{cid} that redirects to {cid}.ipfs.dweb.link
  • DNSLink website at dweb.link with info about what IPFS gateway is etc
  • convention over configuration, where possible

If we agree on the above, then we see there is only one way to handle the "fallback order":

  • enabling subdomain gateway implicitly enables redirects from dweb.link/ipfs/{cid} to {cid}.ipfs.dweb.link
    • this gives us backward-compatibility with existing tools that accept a URL of "IPFS gateway" without the need for differentiating between subdomain and path based ones
      (examples: IPFS Companion, MetaMask, {a browser vendor})
    • this means "subdomain > path > dnslink"
      • subdomain takes priority over path
      • path-based gateway at dweb.link/ipfs/{cid} takes priority over DNSLink for dweb.link

Different take on the config

I like how your version enables us to add more configuration options per hostname.
It is not a strong motivation today, but makes things much more flexible and could save us a lot of headache in the future. Worth considering.

@Stebalien How does the below convention look like?

"Gateway": {
  "Hostnames": {
    "dweb.link": {
      "ResolveSubdomains": true
    },
    "ipfs.io": {
      "ResolvePaths": true,
    },
    "en.wikipedia-on-ipfs.org": {
      "ResolveDNSLink": true
    }
  }
}

The same as above, but with explicit default values:

"Gateway": {
  "ResolveDNSLink": true, /*implicit*/
  "Hostnames": {
    "127.0.0.1": { /*implicit*/
      "ResolveSubdomains": false,
      "ResolvePaths": true,
      "ResolveDNSLink": false
    },
    "::1": { /*implicit*/
      "ResolveSubdomains": false,
      "ResolvePaths": true,
      "ResolveDNSLink": false
    },
    "localhost": { /*implicit*/
      "ResolveSubdomains": true,
      "ResolvePaths": false,
      "ResolveDNSLink": false
    },
    "dweb.link": {
      "ResolveSubdomains": true,
      "ResolvePaths": false, /*implicit*/
      "ResolveDNSLink": true
    },
    "ipfs.io": {
      "ResolveSubdomains": false, /*implicit*/
      "ResolvePaths": true,
      "ResolveDNSLink": true
    },
    "en.wikipedia-on-ipfs.org": {
      "ResolveSubdomains": false, /*implicit*/
      "ResolvePaths": false, /*implicit*/
      "ResolveDNSLink": true
    }
  }
}

Note:

  • localhost gateways are implicit and enabled by default
    • IP ones are path-based
    • localhost domain is used for subdomains
    • we need both types to work: IPFS Companion will detect OS support for localhost subdomains and enable it as the default
  • ResolveSubdomains takes priority over ResolvePaths if both are true. Path redirect to Subdomain is always present (even if ResolvePaths: false)

@Stebalien
Copy link
Member Author

@lidel LGTM! Go for it.

@alanshaw
Copy link
Member

alanshaw commented Jan 7, 2020

My only issue with this format is that for most people the default config will be correct and so the host config for each host will just be an empty object.

Maybe we could drop the word "Resolve" from "ResolvePaths", "ResolveDNSLink" etc.?

Otherwise this LGTM!

@lidel
Copy link
Member

lidel commented Jan 23, 2020

gateway: localhost subdomains with cid conversion

- "known gateways" can be now defined with or without port.
  if port is missing, a version defined without it will be used
  as a fallback
- subdomain gateway at *.ipfs.localhost is supported out of the box
- subdomain gateway redirects path-gateway requests to subdomain version
  with automatic conversion to CIDv1 in Base32
  (try http://localhost:8080/ipfs/QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR)

Initial success with *.ipfs.localhost working out of the box (regular gateway, not proxied).

Next steps:

  • fix proxy mode for hostnames without port
  • understand the behavior of localhost in proxy mode
    • *.ipfs.localhost:8080 works fine in all contexts
    • *.ipfs.localhost (without port) may not work in some user agents
  • config for toggling dnslink (NoDNSLink)
  • config for toggling public gateway
    (loading arbitrary content-addressed paths)
  • ensuring above toggles can be defined globally + overriden per hostname
  • figure out if PathPrefixes should be split into two separate options
    • note: yes, confirmed with Steven that PathPrefixes in subdomain context should be something else
  • fix directory listing when in subdomain mode
  • fix go tests
  • write sharness tests
  • docs with examples (this PR)
    • document new config keys
    • rebase on top of doc(config): cleanup #6855
    • explain paths defined in PathPrefixes are mounted on top of DNSLink. if PathPrefixes=["/ipfs"] and DNSLink exists for example.com then "example.com/ipfs/*" will be routed to the regular gateway
    • recipe on how to restore old behavior on localhost
  • other docs (docs-beta.ipfs.io?)
    • document dnslink support on localhost
    • document dnslink support on FQDNS (describe issue with double wildcard certs)
    • document http proxy mode is supported
      • how to for curl, chromium, firefox
      • document how to set up wildcard *.localhost - http proxy, and what needs to be set up without proxy mode + verify if it works out of the box on windows 10 and latest Mac

Some fun screenshots

Note: Crossed padlock is Firefox-specific waiting for upstream fix, as noted in https://bugzilla.mozilla.org/show_bug.cgi?id=1220810#c23

IPFS CIDv1:
2020-01-23--15-29-07

DNSLink websites:
vincent-2020-01-23--15-59-37
2020-01-23--15-51-26

Even ENS looks cool:
eth-2020-01-23--15-57-32

@lidel lidel force-pushed the feat/gateway-subdomains branch 2 times, most recently from 8af259f to ba96bba Compare January 27, 2020 14:56
Copy link
Member Author

@Stebalien Stebalien left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Looking nice.

docs/config.md Outdated Show resolved Hide resolved
docs/config.md Outdated Show resolved Hide resolved
docs/config.md Outdated Show resolved Hide resolved
@lidel
Copy link
Member

lidel commented Jan 30, 2020

Updated Gateway config and Gateway.PublicGateways examples:
https://github.com/ipfs/go-ipfs/blob/feat/gateway-subdomains/docs/config.md#gatewaypublicgateways

The time for 🚲🏚️ is NOW ;-)

Copy link
Member Author

@Stebalien Stebalien left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Review of the config documentation only. From what I can tell, the design looks good. I assume most of my comments are just bugs.

docs/config.md Outdated Show resolved Hide resolved
docs/config.md Outdated Show resolved Hide resolved
docs/config.md Outdated Show resolved Hide resolved
docs/config.md Outdated Show resolved Hide resolved
docs/config.md Outdated Show resolved Hide resolved
docs/config.md Outdated Show resolved Hide resolved
@lidel
Copy link
Member

lidel commented Feb 11, 2020

(rebased and updated docs/config to match new style from #6855)

Next: finish writing tests (proxy+dnslink)

test/sharness/lib/test-lib.sh Outdated Show resolved Hide resolved
namesys/routing.go Outdated Show resolved Hide resolved
namesys/namesys.go Outdated Show resolved Hide resolved
lidel added a commit that referenced this pull request Mar 3, 2020
This switches to peer.Decode as suggested in
#6096 (comment)
and adds tests for missing PeerID types.

License: MIT
Signed-off-by: Marcin Rataj <lidel@lidel.org>
close(out)
cancel()
return out
}
Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

?

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We should probably have a test for this case as well.

Copy link
Member

@lidel lidel Mar 18, 2020

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I don't remember removing this on purpose, we should restore this.

Digression: I'd do it myself but I need to fix my go dev env, go-ipfs requires go 1.14 now, and on my OS that requires kernel > 5.2 due to a known bug (golang/go#37436), so need to upgrade a few things 🙃
(commenting so we don't forget)

core/corehttp/hostname.go Show resolved Hide resolved
// Example: given "dist.ipfs.io.ipns.dweb.link":
// 1. Lookup "link" TLD in knownGateways: negative
// 2. Lookup "dweb.link" in knownGateways: positive
for i := range labels {
Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

for i := len(labels) - 1; i >= 2; i-- {
...
}

I've pushed a patch for this.

if err == nil {
return host
}
// noop: this should never happen
Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

How so? There may not be a port.

Stebalien and others added 3 commits March 17, 2020 19:34
(we're implementing an _actual_ proxy)

License: MIT
Signed-off-by: Steven Allen <steven@stebalien.com>
Instead of adding a new fake header (that could be spoofed by the client...),
just read the original request URI from the request object.

This also removes support for suborigins. They have never been implemented in
browsers and it looks like efforts have stalled. We can add support back if we
need it but, well, maintaining support was going to be more trouble than it was
worth.

License: MIT
Signed-off-by: Steven Allen <steven@stebalien.com>
Allows static DNSLink mappings with IPFS_NS_MAP.

License: MIT
Signed-off-by: Marcin Rataj <lidel@lidel.org>
@Stebalien
Copy link
Member Author

I've squashed this into reasonable commits.

@Stebalien
Copy link
Member Author

And I've updated go-ipfs-config to the release version.

core/corehttp/hostname.go Outdated Show resolved Hide resolved
close(out)
cancel()
return out
}
Copy link
Member

@lidel lidel Mar 18, 2020

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I don't remember removing this on purpose, we should restore this.

Digression: I'd do it myself but I need to fix my go dev env, go-ipfs requires go 1.14 now, and on my OS that requires kernel > 5.2 due to a known bug (golang/go#37436), so need to upgrade a few things 🙃
(commenting so we don't forget)

lidel and others added 3 commits March 18, 2020 08:50
License: MIT
Signed-off-by: Marcin Rataj <lidel@lidel.org>
When request is sent to http://localhost:8080/ipfs/$cid response has
HTTP 301 status code and "Location" header with redirect destination at
$cid.ipfs.localhost:8080

Redirect is followed by browsersi, but not by commandline tools.
Status 301 is ignored by curl in default mode: it will print response
and won't follow redirect, user needs to add -L for that.

To fix curl, we return correct payload in body of HTTP 301 response,
but set Clear-Site-Data header to ensure Origin sandbox can't be abused.

This requires a surgical workaround:
If Location header is present in ResponseWriter's Header map,
we ensure http.ServeContent() returns HTTP 301

Context: #6982

License: MIT
Signed-off-by: Marcin Rataj <lidel@lidel.org>
Copy link
Member

@lidel lidel left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approving because @Stebalien can't approve PR he initially created 🙃

@Stebalien Stebalien merged commit 0114869 into master Mar 18, 2020
@Stebalien Stebalien deleted the feat/gateway-subdomains branch March 18, 2020 16:05
@Stebalien
Copy link
Member Author

@ilyaigpetrov
Copy link

ilyaigpetrov commented Mar 18, 2020

I can't wrap my mind around this currently, so I just kindly ask you not to forget the idea of @Stebalien about permanent links if it's appropriate here:

In that light, we may want something like https://<ipns-hash>.ipns-archive.cf-ipfs.com/<signed-ipns-record>/.... Or maybe the query string? https://<ipns-hash>.ipns.cf-ipfs.com/thing/other-thing?backup=<signed-ipns-record>?

Source: ipld/specs#19 (comment)

If it's not appropriate, just ignore me.

@Stebalien
Copy link
Member Author

This change won't conflict with that feature.

@ilyaigpetrov
Copy link

ilyaigpetrov commented Mar 19, 2020

This change won't conflict with that feature.

In the screenshots above I see *.ipns.localhost:8030 so if we request <ipns-hash>.ipns.localhost:8030/<signed-ipns-record>/baz/file then there would be a conflict with files served from FS and <signed-ipns-record>.

Could you, please, elaborate why won't there be a conflict: will be this service launched on special port (e.g. 8030) different from permanent mutable links?

@Stebalien
Copy link
Member Author

We'd use one of the proposals in the comment you linked: either (a) use a different subdomain <ipns-hash>.ipns-archive.localhost:8080 or (b) <ipns-hash>.ipns.localhost:8080/some/path?backup=<signed-ipns-record>. Both of those solutions work with with this new feature.

lidel added a commit to ipfs-shipyard/is-ipfs that referenced this pull request Mar 22, 2020
This change adds support for DNSLink subdomains on localhost gateway
(ipfs/kubo#6096)

Example: en.wikipedia-on-ipfs.org.ipfs.localhost:8080

BREAKING CHANGE: `isIPFS.subdomain` now returns true for <domain.tld>.ipns.localhost
BREAKING CHANGE: `isIPFS.subdomainPattern` changed

License: MIT
Signed-off-by: Marcin Rataj <lidel@lidel.org>
lidel added a commit to ipfs-shipyard/is-ipfs that referenced this pull request Apr 5, 2020
* feat: support DNSLink subdomains

This change adds support for DNSLink subdomains on localhost gateway
(ipfs/kubo#6096)

Example: en.wikipedia-on-ipfs.org.ipfs.localhost:8080

BREAKING CHANGE: `isIPFS.subdomain` now returns true for <domain.tld>.ipns.localhost
BREAKING CHANGE: `isIPFS.subdomainPattern` changed

* test: support peer multiaddr with /p2p/

Context: libp2p/libp2p#79

* fix: explicitly ignore URL param and hash

.url and .path now return true when validating:
https://ipfs.io/ipfs/<CID>?filename=name.png#foo

* refactor: simplify dnslinkSubdomain

License: MIT
Signed-off-by: Marcin Rataj <lidel@lidel.org>

* fix: url() check should include subdomain()

When .url was created we only had path gateways.  When .subdomain was
added, we did not update .url to test for subdomain gateways, which in
the long run will confuse people and feels like a bug.

Let's fix this: .url() will now check for both subdomain and path gateways

#32 (comment)

BREAKING CHANGE: .url(url) now returns true if .subdomain(url) is true

* refactor: merge DNSLink check into ipnsSubdomain()

This makes subdomain checks follow what path gateway checks do, removing
confusion.

In both cases (IPNS and DNSLink) user needs to perform online record
check, so this is just a handy way of detecting potential matches.

* docs: update examples
* refactor: switch to iso-url
* refactor: lint-package-json
* chore: update deps

License: MIT
Signed-off-by: Marcin Rataj <lidel@lidel.org>
@bmwiedemann
Copy link
Contributor

Seems to break on Linux => #7290

hacdias pushed a commit to ipfs/boxo that referenced this pull request Jan 27, 2023
feat: gateway subdomains + http proxy mode

This commit was moved from ipfs/kubo@0114869
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
status/in-progress In progress topic/gateway Topic gateway
Projects
None yet
Development

Successfully merging this pull request may close these issues.

Subdomain Gateway Act as HTTP PROXY for http://<cidv1b32>.ipfs.localhost
6 participants