diff --git a/.github/workflows/docker-image.yml b/.github/workflows/docker-image.yml
index 9c2f6d4eaa6..e52e522eac3 100644
--- a/.github/workflows/docker-image.yml
+++ b/.github/workflows/docker-image.yml
@@ -72,7 +72,7 @@ jobs:
# builds, only one platform is being loaded into the cache. This would
# prevent us from testing the other platforms.
- name: Build Docker image (linux/amd64)
- uses: docker/build-push-action@v5
+ uses: docker/build-push-action@v6
with:
platforms: linux/amd64
context: .
@@ -84,7 +84,7 @@ jobs:
cache-to: type=local,dest=/tmp/.buildx-cache-new
- name: Build Docker image (linux/arm/v7)
- uses: docker/build-push-action@v5
+ uses: docker/build-push-action@v6
with:
platforms: linux/arm/v7
context: .
@@ -96,7 +96,7 @@ jobs:
cache-to: type=local,dest=/tmp/.buildx-cache-new
- name: Build Docker image (linux/arm64/v8)
- uses: docker/build-push-action@v5
+ uses: docker/build-push-action@v6
with:
platforms: linux/arm64/v8
context: .
@@ -116,7 +116,7 @@ jobs:
# This will only push the previously built images.
- if: github.event_name != 'workflow_dispatch' || github.event.inputs.push == 'true'
name: Publish to Docker Hub
- uses: docker/build-push-action@v5
+ uses: docker/build-push-action@v6
with:
platforms: linux/amd64,linux/arm/v7,linux/arm64/v8
context: .
diff --git a/.github/workflows/gateway-conformance.yml b/.github/workflows/gateway-conformance.yml
index 0f369864162..b1791868c41 100644
--- a/.github/workflows/gateway-conformance.yml
+++ b/.github/workflows/gateway-conformance.yml
@@ -41,7 +41,7 @@ jobs:
steps:
# 1. Download the gateway-conformance fixtures
- name: Download gateway-conformance fixtures
- uses: ipfs/gateway-conformance/.github/actions/extract-fixtures@v0.5
+ uses: ipfs/gateway-conformance/.github/actions/extract-fixtures@v0.6
with:
output: fixtures
@@ -84,9 +84,7 @@ jobs:
# Import dnslink records
# the IPFS_NS_MAP env will be used by the daemon
- export IPFS_NS_MAP=$(cat "./fixtures/dnslinks.json" | jq -r '.subdomains | to_entries | map("\(.key).example.com:\(.value)") | join(",")')
- export IPFS_NS_MAP="$(cat "./fixtures/dnslinks.json" | jq -r '.domains | to_entries | map("\(.key):\(.value)") | join(",")'),${IPFS_NS_MAP}"
- echo "IPFS_NS_MAP=${IPFS_NS_MAP}" >> $GITHUB_ENV
+ echo "IPFS_NS_MAP=$(cat ./fixtures/dnslinks.IPFS_NS_MAP)" >> $GITHUB_ENV
# 5. Start the kubo-gateway
- name: Start kubo-gateway
@@ -96,14 +94,15 @@ jobs:
# 6. Run the gateway-conformance tests
- name: Run gateway-conformance tests
- uses: ipfs/gateway-conformance/.github/actions/test@v0.5
+ uses: ipfs/gateway-conformance/.github/actions/test@v0.6
with:
gateway-url: http://127.0.0.1:8080
+ subdomain-url: http://localhost:8080
+ args: -skip 'TestGatewayCar/GET_response_for_application/vnd.ipld.car/Header_Content-Length'
json: output.json
xml: output.xml
html: output.html
markdown: output.md
- args: -skip 'TestGatewayCar/GET_response_for_application/vnd.ipld.car/Header_Content-Length'
# 7. Upload the results
- name: Upload MD summary
@@ -129,7 +128,7 @@ jobs:
steps:
# 1. Download the gateway-conformance fixtures
- name: Download gateway-conformance fixtures
- uses: ipfs/gateway-conformance/.github/actions/extract-fixtures@v0.5
+ uses: ipfs/gateway-conformance/.github/actions/extract-fixtures@v0.6
with:
output: fixtures
@@ -202,14 +201,14 @@ jobs:
# 9. Run the gateway-conformance tests over libp2p
- name: Run gateway-conformance tests over libp2p
- uses: ipfs/gateway-conformance/.github/actions/test@v0.5
+ uses: ipfs/gateway-conformance/.github/actions/test@v0.6
with:
gateway-url: http://127.0.0.1:8092
+ args: --specs "trustless-gateway,-trustless-ipns-gateway" -skip 'TestGatewayCar/GET_response_for_application/vnd.ipld.car/Header_Content-Length'
json: output.json
xml: output.xml
html: output.html
markdown: output.md
- args: --specs "trustless-gateway,-trustless-ipns-gateway" -skip 'TestGatewayCar/GET_response_for_application/vnd.ipld.car/Header_Content-Length'
# 10. Upload the results
- name: Upload MD summary
diff --git a/.github/workflows/build.yml b/.github/workflows/interop.yml
similarity index 84%
rename from .github/workflows/build.yml
rename to .github/workflows/interop.yml
index 2967c999721..73ee255557b 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/interop.yml
@@ -70,9 +70,27 @@ jobs:
restore-keys: ${{ runner.os }}-${{ github.job }}-helia-
- run: sudo apt update
- run: sudo apt install -y libxkbcommon0 libxdamage1 libgbm1 libpango-1.0-0 libcairo2 # dependencies for playwright
- - run: npx --package @helia/interop helia-interop
+
+ # TODO: for now run against version from https://github.com/ipfs/helia/pull/584
+ - name: Checkout helia-interop with provisional fix
+ uses: actions/checkout@v4
+ with:
+ repository: ipfs/helia
+ ref: ab6b385787075ad9932f24362293b3bb82ff1d96
+ path: helia
+ - name: Run provisional build of helia
+ run: npm i && npm run build
+ working-directory: helia
+ - name: Run provisional build of helia-interop
+ run: npm i && npm run build && npx .
+ working-directory: helia/packages/interop
env:
KUBO_BINARY: ${{ github.workspace }}/cmd/ipfs/ipfs
+
+ # TODO: switch back to release once https://github.com/ipfs/helia/pull/584 ships
+ #- run: npx --package @helia/interop helia-interop
+ # env:
+ # KUBO_BINARY: ${{ github.workspace }}/cmd/ipfs/ipfs
ipfs-webui:
needs: [interop-prep]
runs-on: ${{ fromJSON(github.repository == 'ipfs/kubo' && '["self-hosted", "linux", "x64", "2xlarge"]' || '"ubuntu-latest"') }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5b68d6152f4..93901ba1efb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,6 @@
# Kubo Changelogs
+- [v0.30](docs/changelogs/v0.30.md)
- [v0.29](docs/changelogs/v0.29.md)
- [v0.28](docs/changelogs/v0.28.md)
- [v0.27](docs/changelogs/v0.27.md)
diff --git a/README.md b/README.md
index d2ff46a9310..30a884e9680 100644
--- a/README.md
+++ b/README.md
@@ -73,11 +73,13 @@ Before opening an issue, consider using one of the following locations to ensure
- [Downloading builds using IPFS](#downloading-builds-using-ipfs)
- [Unofficial Linux packages](#unofficial-linux-packages)
- [ArchLinux](#arch-linux)
+ - [Gentoo Linux](#gentoo-linux)
- [Nix](#nix)
- [Solus](#solus)
- [openSUSE](#opensuse)
- [Guix](#guix)
- [Snap](#snap)
+ - [Ubuntu PPA](#ubuntu-ppa)
- [Unofficial Windows packages](#unofficial-windows-packages)
- [Chocolatey](#chocolatey)
- [Scoop](#scoop)
@@ -198,11 +200,13 @@ $ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_windows-amd64.zip
- [ArchLinux](#arch-linux)
+- [Gentoo Linux](#gentoo-linux)
- [Nix](#nix-linux)
- [Solus](#solus)
- [openSUSE](#opensuse)
- [Guix](#guix)
- [Snap](#snap)
+- [Ubuntu PPA](#ubuntu-ppa)
#### Arch Linux
@@ -214,6 +218,16 @@ $ ipfs get /ipns/dist.ipfs.tech/kubo/$VERSION/kubo_$VERSION_windows-amd64.zip
[](https://aur.archlinux.org/packages/kubo/)
+#### Gentoo Linux
+
+https://wiki.gentoo.org/wiki/Kubo
+
+```bash
+# emerge -a net-p2p/kubo
+```
+
+https://packages.gentoo.org/packages/net-p2p/kubo
+
#### Nix
With the purely functional package manager [Nix](https://nixos.org/nix/) you can install kubo (go-ipfs) like this:
@@ -246,6 +260,31 @@ You can also install it through the Solus software center.
No longer supported, see rationale in [kubo#8688](https://github.com/ipfs/kubo/issues/8688).
+#### Ubuntu PPA
+
+[PPA homepage](https://launchpad.net/~twdragon/+archive/ubuntu/ipfs) on Launchpad.
+
+##### Latest Ubuntu (>= 20.04 LTS)
+```sh
+sudo add-apt-repository ppa:twdragon/ipfs
+sudo apt update
+sudo apt install ipfs-kubo
+```
+
+##### Any Ubuntu version
+
+```sh
+sudo su
+echo 'deb https://ppa.launchpadcontent.net/twdragon/ipfs/ubuntu <> main' >> /etc/apt/sources.list.d/ipfs
+echo 'deb-src https://ppa.launchpadcontent.net/twdragon/ipfs/ubuntu <> main' >> /etc/apt/sources.list.d/ipfs
+exit
+sudo apt update
+sudo apt install ipfs-kubo
+```
+where `<>` is the codename of your Ubuntu distribution (for example, `jammy` for 22.04 LTS). During the first installation the package maintenance script may automatically ask you about which networking profile, CPU accounting model, and/or existing node configuration file you want to use.
+
+**NOTE**: this method also may work with any compatible Debian-based distro which has `libc6` inside, and APT as a package manager.
+
### Unofficial Windows packages
- [Chocolatey](#chocolatey)
@@ -432,9 +471,11 @@ If you make changes to the protocol buffers, you will need to install the [proto
Find more documentation for developers on [docs](./docs)
## Maintainer Info
-* [Project Board for active and upcoming work](https://pl-strflt.notion.site/Kubo-GitHub-Project-Board-c68f9192e48e4e9eba185fa697bf0570)
-* [Release Process](https://pl-strflt.notion.site/Kubo-Release-Process-5a5d066264704009a28a79cff93062c4)
-* [Additional PL EngRes Kubo maintainer info](https://pl-strflt.notion.site/Kubo-go-ipfs-4a484aeeaa974dcf918027c300426c05)
+
+Kubo is maintained by [Shipyard](https://ipshipyard.com/).
+
+* This repository is part of [Shipyard's GO Triage triage](https://ipshipyard.notion.site/IPFS-Go-Triage-Boxo-Kubo-Rainbow-0ddee6b7f28d412da7dabe4f9107c29a).
+* [Release Process](https://ipshipyard.notion.site/Kubo-Release-Process-6dba4f5755c9458ab5685eeb28173778)
## Contributing
diff --git a/Rules.mk b/Rules.mk
index c3e662aa0e0..ef88bee0f74 100644
--- a/Rules.mk
+++ b/Rules.mk
@@ -123,7 +123,7 @@ help:
@echo ' build - Build binary at ./cmd/ipfs/ipfs'
@echo ' nofuse - Build binary with no fuse support'
@echo ' install - Build binary and install into $$GOBIN'
- @echo ' mod_tidy - Remove unused dependencis from go.mod files'
+ @echo ' mod_tidy - Remove unused dependencies from go.mod files'
# @echo ' dist_install - TODO: c.f. ./cmd/ipfs/dist/README.md'
@echo ''
@echo 'CLEANING TARGETS:'
diff --git a/client/rpc/api.go b/client/rpc/api.go
index 79d42124a7b..80a309b9190 100644
--- a/client/rpc/api.go
+++ b/client/rpc/api.go
@@ -5,6 +5,7 @@ import (
"encoding/json"
"errors"
"fmt"
+ "net"
"net/http"
"os"
"path/filepath"
@@ -98,11 +99,29 @@ func ApiAddr(ipfspath string) (ma.Multiaddr, error) {
// NewApi constructs HttpApi with specified endpoint.
func NewApi(a ma.Multiaddr) (*HttpApi, error) {
+ transport := &http.Transport{
+ Proxy: http.ProxyFromEnvironment,
+ DisableKeepAlives: true,
+ }
+
+ network, address, err := manet.DialArgs(a)
+ if err != nil {
+ return nil, err
+ }
+ if network == "unix" {
+ transport.DialContext = func(_ context.Context, _, _ string) (net.Conn, error) {
+ return net.Dial("unix", address)
+ }
+ c := &http.Client{
+ Transport: transport,
+ }
+ // This will create an API client which
+ // makes requests to `http://unix`.
+ return NewURLApiWithClient(network, c)
+ }
+
c := &http.Client{
- Transport: &http.Transport{
- Proxy: http.ProxyFromEnvironment,
- DisableKeepAlives: true,
- },
+ Transport: transport,
}
return NewApiWithClient(a, c)
diff --git a/client/rpc/apifile.go b/client/rpc/apifile.go
index 7a54995b181..57d82c5f712 100644
--- a/client/rpc/apifile.go
+++ b/client/rpc/apifile.go
@@ -1,10 +1,14 @@
package rpc
import (
+ "bytes"
"context"
"encoding/json"
"fmt"
"io"
+ "os"
+ "strconv"
+ "time"
"github.com/ipfs/boxo/files"
unixfs "github.com/ipfs/boxo/ipld/unixfs"
@@ -24,20 +28,35 @@ func (api *UnixfsAPI) Get(ctx context.Context, p path.Path) (files.Node, error)
}
var stat struct {
- Hash string
- Type string
- Size int64 // unixfs size
+ Hash string
+ Type string
+ Size int64 // unixfs size
+ Mode string
+ Mtime int64
+ MtimeNsecs int
}
err := api.core().Request("files/stat", p.String()).Exec(ctx, &stat)
if err != nil {
return nil, err
}
+ mode, err := stringToFileMode(stat.Mode)
+ if err != nil {
+ return nil, err
+ }
+
+ var modTime time.Time
+ if stat.Mtime != 0 {
+ modTime = time.Unix(stat.Mtime, int64(stat.MtimeNsecs)).UTC()
+ }
+
switch stat.Type {
case "file":
- return api.getFile(ctx, p, stat.Size)
+ return api.getFile(ctx, p, stat.Size, mode, modTime)
case "directory":
- return api.getDir(ctx, p, stat.Size)
+ return api.getDir(ctx, p, stat.Size, mode, modTime)
+ case "symlink":
+ return api.getSymlink(ctx, p, modTime)
default:
return nil, fmt.Errorf("unsupported file type '%s'", stat.Type)
}
@@ -49,6 +68,9 @@ type apiFile struct {
size int64
path path.Path
+ mode os.FileMode
+ mtime time.Time
+
r *Response
at int64
}
@@ -128,16 +150,37 @@ func (f *apiFile) Close() error {
return nil
}
+func (f *apiFile) Mode() os.FileMode {
+ return f.mode
+}
+
+func (f *apiFile) ModTime() time.Time {
+ return f.mtime
+}
+
func (f *apiFile) Size() (int64, error) {
return f.size, nil
}
-func (api *UnixfsAPI) getFile(ctx context.Context, p path.Path, size int64) (files.Node, error) {
+func stringToFileMode(mode string) (os.FileMode, error) {
+ if mode == "" {
+ return 0, nil
+ }
+ mode64, err := strconv.ParseUint(mode, 8, 32)
+ if err != nil {
+ return 0, fmt.Errorf("cannot parse mode %s: %s", mode, err)
+ }
+ return os.FileMode(uint32(mode64)), nil
+}
+
+func (api *UnixfsAPI) getFile(ctx context.Context, p path.Path, size int64, mode os.FileMode, mtime time.Time) (files.Node, error) {
f := &apiFile{
- ctx: ctx,
- core: api.core(),
- size: size,
- path: p,
+ ctx: ctx,
+ core: api.core(),
+ size: size,
+ path: p,
+ mode: mode,
+ mtime: mtime,
}
return f, f.reset()
@@ -195,13 +238,19 @@ func (it *apiIter) Next() bool {
switch it.cur.Type {
case unixfs.THAMTShard, unixfs.TMetadata, unixfs.TDirectory:
- it.curFile, err = it.core.getDir(it.ctx, path.FromCid(c), int64(it.cur.Size))
+ it.curFile, err = it.core.getDir(it.ctx, path.FromCid(c), int64(it.cur.Size), it.cur.Mode, it.cur.ModTime)
if err != nil {
it.err = err
return false
}
case unixfs.TFile:
- it.curFile, err = it.core.getFile(it.ctx, path.FromCid(c), int64(it.cur.Size))
+ it.curFile, err = it.core.getFile(it.ctx, path.FromCid(c), int64(it.cur.Size), it.cur.Mode, it.cur.ModTime)
+ if err != nil {
+ it.err = err
+ return false
+ }
+ case unixfs.TSymlink:
+ it.curFile, err = it.core.getSymlink(it.ctx, path.FromCid(c), it.cur.ModTime)
if err != nil {
it.err = err
return false
@@ -223,6 +272,9 @@ type apiDir struct {
size int64
path path.Path
+ mode os.FileMode
+ mtime time.Time
+
dec *json.Decoder
}
@@ -230,6 +282,14 @@ func (d *apiDir) Close() error {
return nil
}
+func (d *apiDir) Mode() os.FileMode {
+ return d.mode
+}
+
+func (d *apiDir) ModTime() time.Time {
+ return d.mtime
+}
+
func (d *apiDir) Size() (int64, error) {
return d.size, nil
}
@@ -242,7 +302,7 @@ func (d *apiDir) Entries() files.DirIterator {
}
}
-func (api *UnixfsAPI) getDir(ctx context.Context, p path.Path, size int64) (files.Node, error) {
+func (api *UnixfsAPI) getDir(ctx context.Context, p path.Path, size int64, mode os.FileMode, modTime time.Time) (files.Node, error) {
resp, err := api.core().Request("ls", p.String()).
Option("resolve-size", true).
Option("stream", true).Send(ctx)
@@ -253,18 +313,43 @@ func (api *UnixfsAPI) getDir(ctx context.Context, p path.Path, size int64) (file
return nil, resp.Error
}
- d := &apiDir{
- ctx: ctx,
- core: api,
- size: size,
- path: p,
+ data, _ := io.ReadAll(resp.Output)
+ rdr := bytes.NewReader(data)
- dec: json.NewDecoder(resp.Output),
+ d := &apiDir{
+ ctx: ctx,
+ core: api,
+ size: size,
+ path: p,
+ mode: mode,
+ mtime: modTime,
+
+ //dec: json.NewDecoder(resp.Output),
+ dec: json.NewDecoder(rdr),
}
return d, nil
}
+func (api *UnixfsAPI) getSymlink(ctx context.Context, p path.Path, modTime time.Time) (files.Node, error) {
+ resp, err := api.core().Request("cat", p.String()).
+ Option("resolve-size", true).
+ Option("stream", true).Send(ctx)
+ if err != nil {
+ return nil, err
+ }
+ if resp.Error != nil {
+ return nil, resp.Error
+ }
+
+ target, err := io.ReadAll(resp.Output)
+ if err != nil {
+ return nil, err
+ }
+
+ return files.NewSymlinkFile(string(target), modTime), nil
+}
+
var (
_ files.File = &apiFile{}
_ files.Directory = &apiDir{}
diff --git a/client/rpc/errors.go b/client/rpc/errors.go
index 6c136ebefeb..29f5487d442 100644
--- a/client/rpc/errors.go
+++ b/client/rpc/errors.go
@@ -68,11 +68,11 @@ func parseErrNotFound(msg string) (error, bool) {
// Assume CIDs break on:
// - Whitespaces: " \t\n\r\v\f"
// - Semicolon: ";" this is to parse ipld.ErrNotFound wrapped in multierr
-// - Double Quotes: "\"" this is for parsing %q and %#v formating.
+// - Double Quotes: "\"" this is for parsing %q and %#v formatting.
const cidBreakSet = " \t\n\r\v\f;\""
func parseIPLDErrNotFound(msg string) (error, bool) {
- // The patern we search for is:
+ // The pattern we search for is:
const ipldErrNotFoundKey = "ipld: could not find " /*CID*/
// We try to parse the CID, if it's invalid we give up and return a simple text error.
// We also accept "node" in place of the CID because that means it's an Undefined CID.
diff --git a/client/rpc/unixfs.go b/client/rpc/unixfs.go
index 501e8d02511..3ba2c1c15f0 100644
--- a/client/rpc/unixfs.go
+++ b/client/rpc/unixfs.go
@@ -6,6 +6,8 @@ import (
"errors"
"fmt"
"io"
+ "os"
+ "time"
"github.com/ipfs/boxo/files"
unixfs "github.com/ipfs/boxo/ipld/unixfs"
@@ -80,14 +82,13 @@ func (api *UnixfsAPI) Add(ctx context.Context, f files.Node, opts ...caopts.Unix
}
defer resp.Output.Close()
dec := json.NewDecoder(resp.Output)
-loop:
+
for {
var evt addEvent
- switch err := dec.Decode(&evt); err {
- case nil:
- case io.EOF:
- break loop
- default:
+ if err := dec.Decode(&evt); err != nil {
+ if errors.Is(err, io.EOF) {
+ break
+ }
return path.ImmutablePath{}, err
}
out = evt
@@ -129,6 +130,9 @@ type lsLink struct {
Size uint64
Type unixfs_pb.Data_DataType
Target string
+
+ Mode os.FileMode
+ ModTime time.Time
}
type lsObject struct {
@@ -222,6 +226,9 @@ func (api *UnixfsAPI) Ls(ctx context.Context, p path.Path, opts ...caopts.Unixfs
Size: l0.Size,
Type: ftype,
Target: l0.Target,
+
+ Mode: l0.Mode,
+ ModTime: l0.ModTime,
}:
case <-ctx.Done():
}
diff --git a/cmd/ipfs/kubo/daemon.go b/cmd/ipfs/kubo/daemon.go
index ab034b20a14..eb9fff8e448 100644
--- a/cmd/ipfs/kubo/daemon.go
+++ b/cmd/ipfs/kubo/daemon.go
@@ -1,15 +1,19 @@
package kubo
import (
+ "context"
"errors"
_ "expvar"
"fmt"
+ "math"
"net"
"net/http"
_ "net/http/pprof"
"os"
+ "regexp"
"runtime"
"sort"
+ "strings"
"sync"
"time"
@@ -87,7 +91,7 @@ running, calls to 'ipfs' commands will be sent over the network to
the daemon.
`,
LongDescription: `
-The daemon will start listening on ports on the network, which are
+The Kubo daemon will start listening on ports on the network, which are
documented in (and can be modified through) 'ipfs config Addresses'.
For example, to change the 'Gateway' port:
@@ -107,11 +111,16 @@ other computers in the network, use 0.0.0.0 as the ip address:
Be careful if you expose the RPC API. It is a security risk, as anyone could
control your node remotely. If you need to control the node remotely,
make sure to protect the port as you would other services or database
-(firewall, authenticated proxy, etc).
+(firewall, authenticated proxy, etc), or at least set API.Authorizations.
+
+If you do not want to open any ports for RPC, and only want to use
+kubo CLI client, it is possible to expose the RPC over Unix socket:
+
+ ipfs config Addresses.API /unix/var/run/kubo.socket
HTTP Headers
-ipfs supports passing arbitrary headers to the RPC API and Gateway. You can
+Kubo supports passing arbitrary headers to the RPC API and Gateway. You can
do this by setting headers on the API.HTTPHeaders and Gateway.HTTPHeaders
keys:
@@ -122,7 +131,7 @@ Note that the value of the keys is an _array_ of strings. This is because
headers can have more than one value, and it is convenient to pass through
to other libraries.
-CORS Headers (for API)
+CORS Headers (for RPC API)
You can setup CORS headers the same way:
@@ -139,7 +148,7 @@ second signal.
IPFS_PATH environment variable
-ipfs uses a repository in the local file system. By default, the repo is
+Kubo uses a repository in the local file system. By default, the repo is
located at ~/.ipfs. To change the repo location, set the $IPFS_PATH
environment variable:
@@ -147,7 +156,7 @@ environment variable:
DEPRECATION NOTICE
-Previously, ipfs used an environment variable as seen below:
+Previously, Kubo used an environment variable as seen below:
export API_ORIGIN="http://localhost:8888/"
@@ -158,14 +167,14 @@ Headers.
},
Options: []cmds.Option{
- cmds.BoolOption(initOptionKwd, "Initialize ipfs with default settings if not already initialized"),
+ cmds.BoolOption(initOptionKwd, "Initialize Kubo with default settings if not already initialized"),
cmds.StringOption(initConfigOptionKwd, "Path to existing configuration file to be loaded during --init"),
cmds.StringOption(initProfileOptionKwd, "Configuration profiles to apply for --init. See ipfs init --help for more"),
cmds.StringOption(routingOptionKwd, "Overrides the routing option").WithDefault(routingOptionDefaultKwd),
cmds.BoolOption(mountKwd, "Mounts IPFS to the filesystem using FUSE (experimental)"),
cmds.StringOption(ipfsMountKwd, "Path to the mountpoint for IPFS (if using --mount). Defaults to config setting."),
cmds.StringOption(ipnsMountKwd, "Path to the mountpoint for IPNS (if using --mount). Defaults to config setting."),
- cmds.BoolOption(unrestrictedAPIAccessKwd, "Allow API access to unlisted hashes"),
+ cmds.BoolOption(unrestrictedAPIAccessKwd, "Allow RPC API access to unlisted hashes"),
cmds.BoolOption(unencryptTransportKwd, "Disable transport encryption (for debugging protocols)"),
cmds.BoolOption(enableGCKwd, "Enable automatic periodic repo garbage collection"),
cmds.BoolOption(adjustFDLimitKwd, "Check and raise file descriptor limits if needed").WithDefault(true),
@@ -371,6 +380,8 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
return err
}
+ fmt.Printf("PeerID: %s\n", cfg.Identity.PeerID)
+
if !psSet {
pubsub = cfg.Pubsub.Enabled.WithDefault(false)
}
@@ -438,9 +449,11 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
return fmt.Errorf("unrecognized routing option: %s", routingOption)
}
- agentVersionSuffixString, _ := req.Options[agentVersionSuffix].(string)
- if agentVersionSuffixString != "" {
- version.SetUserAgentSuffix(agentVersionSuffixString)
+ // Set optional agent version suffix
+ versionSuffixFromCli, _ := req.Options[agentVersionSuffix].(string)
+ versionSuffix := cfg.Version.AgentSuffix.WithDefault(versionSuffixFromCli)
+ if versionSuffix != "" {
+ version.SetUserAgentSuffix(versionSuffix)
}
node, err := core.NewNode(req.Context, ncfg)
@@ -459,7 +472,7 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment
log.Fatal("Private network does not work with Routing.Type=auto. Update your config to Routing.Type=dht (or none, and do manual peering)")
}
- printSwarmAddrs(node)
+ printLibp2pPorts(node)
if node.PrivateKey.Type() == p2pcrypto.RSA {
fmt.Print(`
@@ -559,7 +572,7 @@ take effect.
// Add ipfs version info to prometheus metrics
ipfsInfoMetric := promauto.NewGaugeVec(prometheus.GaugeOpts{
Name: "ipfs_info",
- Help: "IPFS version information.",
+ Help: "Kubo IPFS version information.",
}, []string{"version", "commit"})
// Setting to 1 lets us multiply it with other stats to add the version labels
@@ -593,6 +606,7 @@ take effect.
cfg, err := cctx.GetConfig()
if err != nil {
log.Errorf("failed to access config: %s", err)
+ return
}
if len(cfg.Bootstrap) == 0 && len(cfg.Peering.Peers) == 0 {
// Skip peer check if Bootstrap and Peering lists are empty
@@ -603,13 +617,24 @@ take effect.
ipfs, err := coreapi.NewCoreAPI(node)
if err != nil {
log.Errorf("failed to access CoreAPI: %v", err)
+ return
}
peers, err := ipfs.Swarm().Peers(cctx.Context())
if err != nil {
log.Errorf("failed to read swarm peers: %v", err)
+ return
}
if len(peers) == 0 {
log.Error("failed to bootstrap (no peers found): consider updating Bootstrap or Peering section of your config")
+ } else {
+ // After 1 minute we should have enough peers
+ // to run informed version check
+ startVersionChecker(
+ cctx.Context(),
+ node,
+ cfg.Version.SwarmCheckEnabled.WithDefault(true),
+ cfg.Version.SwarmCheckPercentThreshold.WithDefault(config.DefaultSwarmCheckPercentThreshold),
+ )
}
})
}
@@ -763,8 +788,8 @@ func rewriteMaddrToUseLocalhostIfItsAny(maddr ma.Multiaddr) ma.Multiaddr {
}
}
-// printSwarmAddrs prints the addresses of the host.
-func printSwarmAddrs(node *core.IpfsNode) {
+// printLibp2pPorts prints which ports are opened to facilitate swarm connectivity.
+func printLibp2pPorts(node *core.IpfsNode) {
if !node.IsOnline {
fmt.Println("Swarm not listening, running in offline mode.")
return
@@ -774,24 +799,49 @@ func printSwarmAddrs(node *core.IpfsNode) {
if err != nil {
log.Errorf("failed to read listening addresses: %s", err)
}
- lisAddrs := make([]string, len(ifaceAddrs))
- for i, addr := range ifaceAddrs {
- lisAddrs[i] = addr.String()
- }
- sort.Strings(lisAddrs)
- for _, addr := range lisAddrs {
- fmt.Printf("Swarm listening on %s\n", addr)
+
+ // Multiple libp2p transports can use same port.
+ // Deduplicate all listeners and collect unique IP:port (udp|tcp) combinations
+ // which is useful information for operator deploying Kubo in TCP/IP infra.
+ addrMap := make(map[string]map[string]struct{})
+ re := regexp.MustCompile(`^/(?:ip[46]|dns(?:[46])?)/([^/]+)/(tcp|udp)/(\d+)(/.*)?$`)
+ for _, addr := range ifaceAddrs {
+ matches := re.FindStringSubmatch(addr.String())
+ if matches != nil {
+ hostname := matches[1]
+ protocol := strings.ToUpper(matches[2])
+ port := matches[3]
+ var host string
+ if matches[0][:4] == "/ip6" {
+ host = fmt.Sprintf("[%s]:%s", hostname, port)
+ } else {
+ host = fmt.Sprintf("%s:%s", hostname, port)
+ }
+ if _, ok := addrMap[host]; !ok {
+ addrMap[host] = make(map[string]struct{})
+ }
+ addrMap[host][protocol] = struct{}{}
+ }
}
- nodePhostAddrs := node.PeerHost.Addrs()
- addrs := make([]string, len(nodePhostAddrs))
- for i, addr := range nodePhostAddrs {
- addrs[i] = addr.String()
+ // Produce a sorted host:port list
+ hosts := make([]string, 0, len(addrMap))
+ for host := range addrMap {
+ hosts = append(hosts, host)
}
- sort.Strings(addrs)
- for _, addr := range addrs {
- fmt.Printf("Swarm announcing %s\n", addr)
+ sort.Strings(hosts)
+
+ // Print listeners
+ for _, host := range hosts {
+ protocolsSet := addrMap[host]
+ protocols := make([]string, 0, len(protocolsSet))
+ for protocol := range protocolsSet {
+ protocols = append(protocols, protocol)
+ }
+ sort.Strings(protocols)
+ fmt.Printf("Swarm listening on %s (%s)\n", host, strings.Join(protocols, "+"))
}
+ fmt.Printf("Run 'ipfs id' to inspect announced and discovered multiaddrs of this node.\n")
}
// serveHTTPGateway collects options, creates listener, prints status message and starts serving requests.
@@ -1027,7 +1077,11 @@ func YesNoPrompt(prompt string) bool {
var s string
for i := 0; i < 3; i++ {
fmt.Printf("%s ", prompt)
- fmt.Scanf("%s", &s)
+ _, err := fmt.Scanf("%s", &s)
+ if err != nil {
+ fmt.Printf("Invalid input: %v. Please try again.\n", err)
+ continue
+ }
switch s {
case "y", "Y":
return true
@@ -1052,3 +1106,41 @@ func printVersion() {
fmt.Printf("System version: %s\n", runtime.GOARCH+"/"+runtime.GOOS)
fmt.Printf("Golang version: %s\n", runtime.Version())
}
+
+func startVersionChecker(ctx context.Context, nd *core.IpfsNode, enabled bool, percentThreshold int64) {
+ if !enabled {
+ return
+ }
+ ticker := time.NewTicker(time.Hour)
+ defer ticker.Stop()
+ go func() {
+ for {
+ o, err := commands.DetectNewKuboVersion(nd, percentThreshold)
+ if err != nil {
+ // The version check is best-effort, and may fail in custom
+ // configurations that do not run standard WAN DHT. If it
+ // errors here, no point in spamming logs: og once and exit.
+ log.Errorw("initial version check failed, will not be run again", "error", err)
+ return
+ }
+ if o.UpdateAvailable {
+ newerPercent := fmt.Sprintf("%.0f%%", math.Round(float64(o.WithGreaterVersion)/float64(o.PeersSampled)*100))
+ log.Errorf(`
+⚠️ A NEW VERSION OF KUBO DETECTED
+
+This Kubo node is running an outdated version (%s).
+%s of the sampled Kubo peers are running a higher version.
+Visit https://github.com/ipfs/kubo/releases or https://dist.ipfs.tech/#kubo and update to version %s or later.`,
+ o.RunningVersion, newerPercent, o.GreatestVersion)
+ }
+ select {
+ case <-ctx.Done():
+ return
+ case <-nd.Process.Closing():
+ return
+ case <-ticker.C:
+ continue
+ }
+ }
+ }()
+}
diff --git a/cmd/ipfs/kubo/start.go b/cmd/ipfs/kubo/start.go
index cae1e2c1b70..474045e7102 100644
--- a/cmd/ipfs/kubo/start.go
+++ b/cmd/ipfs/kubo/start.go
@@ -303,7 +303,10 @@ func makeExecutor(req *cmds.Request, env interface{}) (cmds.Executor, error) {
}
// Resolve the API addr.
- apiAddr, err = resolveAddr(req.Context, apiAddr)
+ //
+ // Do not replace apiAddr with the resolved addr so that the requested
+ // hostname is kept for use in the request's HTTP header.
+ _, err = resolveAddr(req.Context, apiAddr)
if err != nil {
return nil, err
}
diff --git a/config/autonat.go b/config/autonat.go
index eb87b48e6f4..e8940d14eeb 100644
--- a/config/autonat.go
+++ b/config/autonat.go
@@ -20,6 +20,9 @@ const (
// AutoNATServiceDisabled indicates that the user has disabled the
// AutoNATService.
AutoNATServiceDisabled
+ // AutoNATServiceEnabledV1Only forces use of V1 and disables V2
+ // (used for testing)
+ AutoNATServiceEnabledV1Only
)
func (m *AutoNATServiceMode) UnmarshalText(text []byte) error {
@@ -30,6 +33,8 @@ func (m *AutoNATServiceMode) UnmarshalText(text []byte) error {
*m = AutoNATServiceEnabled
case "disabled":
*m = AutoNATServiceDisabled
+ case "legacy-v1":
+ *m = AutoNATServiceEnabledV1Only
default:
return fmt.Errorf("unknown autonat mode: %s", string(text))
}
@@ -44,6 +49,8 @@ func (m AutoNATServiceMode) MarshalText() ([]byte, error) {
return []byte("enabled"), nil
case AutoNATServiceDisabled:
return []byte("disabled"), nil
+ case AutoNATServiceEnabledV1Only:
+ return []byte("legacy-v1"), nil
default:
return nil, fmt.Errorf("unknown autonat mode: %d", m)
}
diff --git a/config/config.go b/config/config.go
index 046c930be93..71365eb0b5e 100644
--- a/config/config.go
+++ b/config/config.go
@@ -37,6 +37,7 @@ type Config struct {
Plugins Plugins
Pinning Pinning
Import Import
+ Version Version
Internal Internal // experimental/unstable options
}
diff --git a/config/init.go b/config/init.go
index e3d0af30d9e..4a86aa5183e 100644
--- a/config/init.go
+++ b/config/init.go
@@ -112,8 +112,10 @@ func addressesConfig() Addresses {
Swarm: []string{
"/ip4/0.0.0.0/tcp/4001",
"/ip6/::/tcp/4001",
+ "/ip4/0.0.0.0/udp/4001/webrtc-direct",
"/ip4/0.0.0.0/udp/4001/quic-v1",
"/ip4/0.0.0.0/udp/4001/quic-v1/webtransport",
+ "/ip6/::/udp/4001/webrtc-direct",
"/ip6/::/udp/4001/quic-v1",
"/ip6/::/udp/4001/quic-v1/webtransport",
},
diff --git a/config/version.go b/config/version.go
new file mode 100644
index 00000000000..8096107bb26
--- /dev/null
+++ b/config/version.go
@@ -0,0 +1,14 @@
+package config
+
+const DefaultSwarmCheckPercentThreshold = 5
+
+// Version allows controling things like custom user agent and update checks.
+type Version struct {
+ // Optional suffix to the AgentVersion presented by `ipfs id` and exposed
+ // via libp2p identify protocol.
+ AgentSuffix *OptionalString `json:",omitempty"`
+
+ // Detect when to warn about new version when observed via libp2p identify
+ SwarmCheckEnabled Flag `json:",omitempty"`
+ SwarmCheckPercentThreshold *OptionalInteger `json:",omitempty"`
+}
diff --git a/core/commands/add.go b/core/commands/add.go
index 94a5a0f51f5..90861302551 100644
--- a/core/commands/add.go
+++ b/core/commands/add.go
@@ -6,7 +6,9 @@ import (
"io"
"os"
gopath "path"
+ "strconv"
"strings"
+ "time"
"github.com/ipfs/kubo/config"
"github.com/ipfs/kubo/core/commands/cmdenv"
@@ -25,11 +27,31 @@ import (
// ErrDepthLimitExceeded indicates that the max depth has been exceeded.
var ErrDepthLimitExceeded = fmt.Errorf("depth limit exceeded")
+type TimeParts struct {
+ t *time.Time
+}
+
+func (t TimeParts) MarshalJSON() ([]byte, error) {
+ return t.t.MarshalJSON()
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface.
+// The time is expected to be a quoted string in RFC 3339 format.
+func (t *TimeParts) UnmarshalJSON(data []byte) (err error) {
+ // Fractional seconds are handled implicitly by Parse.
+ tt, err := time.Parse("\"2006-01-02T15:04:05Z\"", string(data))
+ *t = TimeParts{&tt}
+ return
+}
+
type AddEvent struct {
- Name string
- Hash string `json:",omitempty"`
- Bytes int64 `json:",omitempty"`
- Size string `json:",omitempty"`
+ Name string
+ Hash string `json:",omitempty"`
+ Bytes int64 `json:",omitempty"`
+ Size string `json:",omitempty"`
+ Mode string `json:",omitempty"`
+ Mtime int64 `json:",omitempty"`
+ MtimeNsecs int `json:",omitempty"`
}
const (
@@ -50,6 +72,12 @@ const (
inlineOptionName = "inline"
inlineLimitOptionName = "inline-limit"
toFilesOptionName = "to-files"
+
+ preserveModeOptionName = "preserve-mode"
+ preserveMtimeOptionName = "preserve-mtime"
+ modeOptionName = "mode"
+ mtimeOptionName = "mtime"
+ mtimeNsecsOptionName = "mtime-nsecs"
)
const adderOutChanSize = 8
@@ -166,22 +194,24 @@ See 'dag export' and 'dag import' for more information.
cmds.IntOption(inlineLimitOptionName, "Maximum block size to inline. (experimental)").WithDefault(32),
cmds.BoolOption(pinOptionName, "Pin locally to protect added files from garbage collection.").WithDefault(true),
cmds.StringOption(toFilesOptionName, "Add reference to Files API (MFS) at the provided path."),
+ cmds.BoolOption(preserveModeOptionName, "Apply existing POSIX permissions to created UnixFS entries. Disables raw-leaves. (experimental)"),
+ cmds.BoolOption(preserveMtimeOptionName, "Apply existing POSIX modification time to created UnixFS entries. Disables raw-leaves. (experimental)"),
+ cmds.UintOption(modeOptionName, "Custom POSIX file mode to store in created UnixFS entries. Disables raw-leaves. (experimental)"),
+ cmds.Int64Option(mtimeOptionName, "Custom POSIX modification time to store in created UnixFS entries (seconds before or after the Unix Epoch). Disables raw-leaves. (experimental)"),
+ cmds.UintOption(mtimeNsecsOptionName, "Custom POSIX modification time (optional time fraction in nanoseconds)"),
},
PreRun: func(req *cmds.Request, env cmds.Environment) error {
quiet, _ := req.Options[quietOptionName].(bool)
quieter, _ := req.Options[quieterOptionName].(bool)
quiet = quiet || quieter
-
silent, _ := req.Options[silentOptionName].(bool)
- if quiet || silent {
- return nil
- }
-
- // ipfs cli progress bar defaults to true unless quiet or silent is used
- _, found := req.Options[progressOptionName].(bool)
- if !found {
- req.Options[progressOptionName] = true
+ if !quiet && !silent {
+ // ipfs cli progress bar defaults to true unless quiet or silent is used
+ _, found := req.Options[progressOptionName].(bool)
+ if !found {
+ req.Options[progressOptionName] = true
+ }
}
return nil
@@ -217,6 +247,11 @@ See 'dag export' and 'dag import' for more information.
inline, _ := req.Options[inlineOptionName].(bool)
inlineLimit, _ := req.Options[inlineLimitOptionName].(int)
toFilesStr, toFilesSet := req.Options[toFilesOptionName].(string)
+ preserveMode, _ := req.Options[preserveModeOptionName].(bool)
+ preserveMtime, _ := req.Options[preserveMtimeOptionName].(bool)
+ mode, _ := req.Options[modeOptionName].(uint)
+ mtime, _ := req.Options[mtimeOptionName].(int64)
+ mtimeNsecs, _ := req.Options[mtimeNsecsOptionName].(uint)
if chunker == "" {
chunker = cfg.Import.UnixFSChunker.WithDefault(config.DefaultUnixFSChunker)
@@ -236,6 +271,19 @@ See 'dag export' and 'dag import' for more information.
rawblks = cfg.Import.UnixFSRawLeaves.WithDefault(config.DefaultUnixFSRawLeaves)
}
+ // Storing optional mode or mtime (UnixFS 1.5) requires root block
+ // to always be 'dag-pb' and not 'raw'. Below adjusts raw-leaves setting, if possible.
+ if preserveMode || preserveMtime || mode != 0 || mtime != 0 {
+ // Error if --raw-leaves flag was explicitly passed by the user.
+ // (let user make a decision to manually disable it and retry)
+ if rbset && rawblks {
+ return fmt.Errorf("%s can't be used with UnixFS metadata like mode or modification time", rawLeavesOptionName)
+ }
+ // No explicit preference from user, disable raw-leaves and continue
+ rbset = true
+ rawblks = false
+ }
+
if onlyHash && toFilesSet {
return fmt.Errorf("%s and %s options are not compatible", onlyHashOptionName, toFilesOptionName)
}
@@ -272,6 +320,19 @@ See 'dag export' and 'dag import' for more information.
options.Unixfs.Progress(progress),
options.Unixfs.Silent(silent),
+
+ options.Unixfs.PreserveMode(preserveMode),
+ options.Unixfs.PreserveMtime(preserveMtime),
+ }
+
+ if mode != 0 {
+ opts = append(opts, options.Unixfs.Mode(os.FileMode(mode)))
+ }
+
+ if mtime != 0 {
+ opts = append(opts, options.Unixfs.Mtime(mtime, uint32(mtimeNsecs)))
+ } else if mtimeNsecs != 0 {
+ return fmt.Errorf("option %q requires %q to be provided as well", mtimeNsecsOptionName, mtimeOptionName)
}
if cidVerSet {
@@ -383,12 +444,33 @@ See 'dag export' and 'dag import' for more information.
output.Name = gopath.Join(addit.Name(), output.Name)
}
- if err := res.Emit(&AddEvent{
- Name: output.Name,
- Hash: h,
- Bytes: output.Bytes,
- Size: output.Size,
- }); err != nil {
+ output.Mode = addit.Node().Mode()
+ if ts := addit.Node().ModTime(); !ts.IsZero() {
+ output.Mtime = addit.Node().ModTime().Unix()
+ output.MtimeNsecs = addit.Node().ModTime().Nanosecond()
+ }
+
+ addEvent := AddEvent{
+ Name: output.Name,
+ Hash: h,
+ Bytes: output.Bytes,
+ Size: output.Size,
+ Mtime: output.Mtime,
+ MtimeNsecs: output.MtimeNsecs,
+ }
+
+ if output.Mode != 0 {
+ addEvent.Mode = "0" + strconv.FormatUint(uint64(output.Mode), 8)
+ }
+
+ if output.Mtime > 0 {
+ addEvent.Mtime = output.Mtime
+ if output.MtimeNsecs > 0 {
+ addEvent.MtimeNsecs = output.MtimeNsecs
+ }
+ }
+
+ if err := res.Emit(&addEvent); err != nil {
return err
}
}
diff --git a/core/commands/bitswap.go b/core/commands/bitswap.go
index 6502876d197..07f91fb0f52 100644
--- a/core/commands/bitswap.go
+++ b/core/commands/bitswap.go
@@ -109,7 +109,7 @@ var bitswapStatCmd = &cmds.Command{
}
if !nd.IsOnline {
- return cmds.Errorf(cmds.ErrClient, ErrNotOnline.Error())
+ return cmds.Errorf(cmds.ErrClient, "unable to run offline: %s", ErrNotOnline)
}
bs, ok := nd.Exchange.(*bitswap.Bitswap)
diff --git a/core/commands/commands_test.go b/core/commands/commands_test.go
index 38172fd66d9..b04a5459b50 100644
--- a/core/commands/commands_test.go
+++ b/core/commands/commands_test.go
@@ -89,6 +89,8 @@ func TestCommands(t *testing.T) {
"/files/rm",
"/files/stat",
"/files/write",
+ "/files/chmod",
+ "/files/touch",
"/filestore",
"/filestore/dups",
"/filestore/ls",
@@ -199,6 +201,7 @@ func TestCommands(t *testing.T) {
"/swarm/resources",
"/update",
"/version",
+ "/version/check",
"/version/deps",
}
diff --git a/core/commands/files.go b/core/commands/files.go
index 12891a7301d..d1a52cbfbbb 100644
--- a/core/commands/files.go
+++ b/core/commands/files.go
@@ -2,13 +2,16 @@ package commands
import (
"context"
+ "encoding/json"
"errors"
"fmt"
"io"
"os"
gopath "path"
"sort"
+ "strconv"
"strings"
+ "time"
humanize "github.com/dustin/go-humanize"
"github.com/ipfs/kubo/config"
@@ -81,6 +84,8 @@ operations.
"rm": filesRmCmd,
"flush": filesFlushCmd,
"chcid": filesChcidCmd,
+ "chmod": filesChmodCmd,
+ "touch": filesTouchCmd,
},
}
@@ -105,6 +110,43 @@ type statOutput struct {
WithLocality bool `json:",omitempty"`
Local bool `json:",omitempty"`
SizeLocal uint64 `json:",omitempty"`
+ Mode uint32 `json:",omitempty"`
+ Mtime int64 `json:",omitempty"`
+ MtimeNsecs int `json:",omitempty"`
+}
+
+func (s *statOutput) MarshalJSON() ([]byte, error) {
+ type so statOutput
+ out := &struct {
+ *so
+ Mode string `json:",omitempty"`
+ }{so: (*so)(s)}
+
+ if s.Mode != 0 {
+ out.Mode = fmt.Sprintf("%04o", s.Mode)
+ }
+ return json.Marshal(out)
+}
+
+func (s *statOutput) UnmarshalJSON(data []byte) error {
+ var err error
+ type so statOutput
+ tmp := &struct {
+ *so
+ Mode string `json:",omitempty"`
+ }{so: (*so)(s)}
+
+ if err := json.Unmarshal(data, &tmp); err != nil {
+ return err
+ }
+
+ if tmp.Mode != "" {
+ mode, err := strconv.ParseUint(tmp.Mode, 8, 32)
+ if err == nil {
+ s.Mode = uint32(mode)
+ }
+ }
+ return err
}
const (
@@ -112,10 +154,13 @@ const (
Size:
CumulativeSize:
ChildBlocks:
-Type: `
+Type:
+Mode: ()
+Mtime: `
filesFormatOptionName = "format"
filesSizeOptionName = "size"
filesWithLocalOptionName = "with-local"
+ filesStatUnspecified = "not set"
)
var filesStatCmd = &cmds.Command{
@@ -128,7 +173,8 @@ var filesStatCmd = &cmds.Command{
},
Options: []cmds.Option{
cmds.StringOption(filesFormatOptionName, "Print statistics in given format. Allowed tokens: "+
- " . Conflicts with other format options.").WithDefault(defaultStatFormat),
+ " and optional ."+
+ "Conflicts with other format options.").WithDefault(defaultStatFormat),
cmds.BoolOption(filesHashOptionName, "Print only hash. Implies '--format='. Conflicts with other format options."),
cmds.BoolOption(filesSizeOptionName, "Print only size. Implies '--format='. Conflicts with other format options."),
cmds.BoolOption(filesWithLocalOptionName, "Compute the amount of the dag that is local, and if possible the total size"),
@@ -136,7 +182,7 @@ var filesStatCmd = &cmds.Command{
Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
_, err := statGetFormatOptions(req)
if err != nil {
- return cmds.Errorf(cmds.ErrClient, err.Error())
+ return cmds.Errorf(cmds.ErrClient, "invalid parameters: %s", err)
}
node, err := cmdenv.GetNode(env)
@@ -199,12 +245,29 @@ var filesStatCmd = &cmds.Command{
},
Encoders: cmds.EncoderMap{
cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *statOutput) error {
+ mode, modeo := filesStatUnspecified, filesStatUnspecified
+ if out.Mode != 0 {
+ mode = strings.ToLower(os.FileMode(out.Mode).String())
+ modeo = "0" + strconv.FormatInt(int64(out.Mode&0x1FF), 8)
+ }
+ mtime, mtimes, mtimens := filesStatUnspecified, filesStatUnspecified, filesStatUnspecified
+ if out.Mtime > 0 {
+ mtime = time.Unix(out.Mtime, int64(out.MtimeNsecs)).UTC().Format("2 Jan 2006, 15:04:05 MST")
+ mtimes = strconv.FormatInt(out.Mtime, 10)
+ mtimens = strconv.Itoa(out.MtimeNsecs)
+ }
+
s, _ := statGetFormatOptions(req)
s = strings.Replace(s, "", out.Hash, -1)
s = strings.Replace(s, "", fmt.Sprintf("%d", out.Size), -1)
s = strings.Replace(s, "", fmt.Sprintf("%d", out.CumulativeSize), -1)
s = strings.Replace(s, "", fmt.Sprintf("%d", out.Blocks), -1)
s = strings.Replace(s, "", out.Type, -1)
+ s = strings.Replace(s, "", mode, -1)
+ s = strings.Replace(s, "", modeo, -1)
+ s = strings.Replace(s, "", mtime, -1)
+ s = strings.Replace(s, "", mtimes, -1)
+ s = strings.Replace(s, "", mtimens, -1)
fmt.Fprintln(w, s)
@@ -254,28 +317,7 @@ func statNode(nd ipld.Node, enc cidenc.Encoder) (*statOutput, error) {
switch n := nd.(type) {
case *dag.ProtoNode:
- d, err := ft.FSNodeFromBytes(n.Data())
- if err != nil {
- return nil, err
- }
-
- var ndtype string
- switch d.Type() {
- case ft.TDirectory, ft.THAMTShard:
- ndtype = "directory"
- case ft.TFile, ft.TMetadata, ft.TRaw:
- ndtype = "file"
- default:
- return nil, fmt.Errorf("unrecognized node type: %s", d.Type())
- }
-
- return &statOutput{
- Hash: enc.Encode(c),
- Blocks: len(nd.Links()),
- Size: d.FileSize(),
- CumulativeSize: cumulsize,
- Type: ndtype,
- }, nil
+ return statProtoNode(n, enc, c, cumulsize)
case *dag.RawNode:
return &statOutput{
Hash: enc.Encode(c),
@@ -289,6 +331,44 @@ func statNode(nd ipld.Node, enc cidenc.Encoder) (*statOutput, error) {
}
}
+func statProtoNode(n *dag.ProtoNode, enc cidenc.Encoder, cid cid.Cid, cumulsize uint64) (*statOutput, error) {
+ d, err := ft.FSNodeFromBytes(n.Data())
+ if err != nil {
+ return nil, err
+ }
+
+ stat := statOutput{
+ Hash: enc.Encode(cid),
+ Blocks: len(n.Links()),
+ Size: d.FileSize(),
+ CumulativeSize: cumulsize,
+ }
+
+ switch d.Type() {
+ case ft.TDirectory, ft.THAMTShard:
+ stat.Type = "directory"
+ case ft.TFile, ft.TSymlink, ft.TMetadata, ft.TRaw:
+ stat.Type = "file"
+ default:
+ return nil, fmt.Errorf("unrecognized node type: %s", d.Type())
+ }
+
+ if mode := d.Mode(); mode != 0 {
+ stat.Mode = uint32(mode)
+ } else if d.Type() == ft.TSymlink {
+ stat.Mode = uint32(os.ModeSymlink | 0x1FF)
+ }
+
+ if mt := d.ModTime(); !mt.IsZero() {
+ stat.Mtime = mt.Unix()
+ if ns := mt.Nanosecond(); ns > 0 {
+ stat.MtimeNsecs = ns
+ }
+ }
+
+ return &stat, nil
+}
+
func walkBlock(ctx context.Context, dagserv ipld.DAGService, nd ipld.Node) (bool, uint64, error) {
// Start with the block data size
sizeLocal := uint64(len(nd.RawData()))
@@ -341,7 +421,7 @@ $ ipfs add --quieter --pin=false
$ ipfs files cp /ipfs/ /your/desired/mfs/path
If you wish to fully copy content from a different IPFS peer into MFS, do not
-forget to force IPFS to fetch to full DAG after doing the "cp" operation. i.e:
+forget to force IPFS to fetch the full DAG after doing a "cp" operation. i.e:
$ ipfs files cp /ipfs/ /your/desired/mfs/path
$ ipfs pin add
@@ -1313,3 +1393,86 @@ func getParentDir(root *mfs.Root, dir string) (*mfs.Directory, error) {
}
return pdir, nil
}
+
+var filesChmodCmd = &cmds.Command{
+ Status: cmds.Experimental,
+ Helptext: cmds.HelpText{
+ Tagline: "Change optional POSIX mode permissions",
+ ShortDescription: `
+The mode argument must be specified in Unix numeric notation.
+
+ $ ipfs files chmod 0644 /foo
+ $ ipfs files stat /foo
+ ...
+ Type: file
+ Mode: -rw-r--r-- (0644)
+ ...
+`,
+ },
+ Arguments: []cmds.Argument{
+ cmds.StringArg("mode", true, false, "Mode to apply to node (numeric notation)"),
+ cmds.StringArg("path", true, false, "Path to apply mode"),
+ },
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+ nd, err := cmdenv.GetNode(env)
+ if err != nil {
+ return err
+ }
+
+ path, err := checkPath(req.Arguments[1])
+ if err != nil {
+ return err
+ }
+
+ mode, err := strconv.ParseInt(req.Arguments[0], 8, 32)
+ if err != nil {
+ return err
+ }
+
+ return mfs.Chmod(nd.FilesRoot, path, os.FileMode(mode))
+ },
+}
+
+var filesTouchCmd = &cmds.Command{
+ Status: cmds.Experimental,
+ Helptext: cmds.HelpText{
+ Tagline: "Set or change optional POSIX modification times.",
+ ShortDescription: `
+Examples:
+ # set modification time to now.
+ $ ipfs files touch /foo
+ # set a custom modification time.
+ $ ipfs files touch --mtime=1630937926 /foo
+`,
+ },
+ Arguments: []cmds.Argument{
+ cmds.StringArg("path", true, false, "Path of target to update."),
+ },
+ Options: []cmds.Option{
+ cmds.Int64Option(mtimeOptionName, "Modification time in seconds before or since the Unix Epoch to apply to created UnixFS entries."),
+ cmds.UintOption(mtimeNsecsOptionName, "Modification time fraction in nanoseconds"),
+ },
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+ nd, err := cmdenv.GetNode(env)
+ if err != nil {
+ return err
+ }
+
+ path, err := checkPath(req.Arguments[0])
+ if err != nil {
+ return err
+ }
+
+ mtime, _ := req.Options[mtimeOptionName].(int64)
+ nsecs, _ := req.Options[mtimeNsecsOptionName].(uint)
+
+ var ts time.Time
+ if mtime != 0 {
+ ts = time.Unix(mtime, int64(nsecs)).UTC()
+ } else {
+ ts = time.Now().UTC()
+ }
+
+ return mfs.Touch(nd.FilesRoot, path, ts)
+ },
+}
diff --git a/core/commands/get.go b/core/commands/get.go
index 5b64c281bbd..12a3ea8ca26 100644
--- a/core/commands/get.go
+++ b/core/commands/get.go
@@ -1,6 +1,7 @@
package commands
import (
+ gotar "archive/tar"
"bufio"
"compress/gzip"
"errors"
@@ -331,7 +332,8 @@ func fileArchive(f files.Node, name string, archive bool, compression int) (io.R
closeGzwAndPipe() // everything seems to be ok
}()
} else {
- // the case for 1. archive, and 2. not archived and not compressed, in which tar is used anyway as a transport format
+ // the case for 1. archive, and 2. not archived and not compressed, in
+ // which tar is used anyway as a transport format
// construct the tar writer
w, err := files.NewTarWriter(maybeGzw)
@@ -339,6 +341,11 @@ func fileArchive(f files.Node, name string, archive bool, compression int) (io.R
return nil, err
}
+ // if not creating an archive set the format to PAX in order to preserve nanoseconds
+ if !archive {
+ w.SetFormat(gotar.FormatPAX)
+ }
+
go func() {
// write all the nodes recursively
if err := w.WriteFile(f, filename); checkErrAndClosePipe(err) {
diff --git a/core/commands/ls.go b/core/commands/ls.go
index 6fd53528271..ab914bb0e15 100644
--- a/core/commands/ls.go
+++ b/core/commands/ls.go
@@ -6,6 +6,7 @@ import (
"os"
"sort"
"text/tabwriter"
+ "time"
cmdenv "github.com/ipfs/kubo/core/commands/cmdenv"
"github.com/ipfs/kubo/core/commands/cmdutils"
@@ -23,6 +24,8 @@ type LsLink struct {
Size uint64
Type unixfs_pb.Data_DataType
Target string
+ Mode os.FileMode
+ ModTime time.Time
}
// LsObject is an element of LsOutput
@@ -163,6 +166,9 @@ The JSON output contains type information.
Size: link.Size,
Type: ftype,
Target: link.Target,
+
+ Mode: link.Mode,
+ ModTime: link.ModTime,
}
if err := processLink(paths[i], lsLink); err != nil {
return err
@@ -256,6 +262,7 @@ func tabularOutput(req *cmds.Request, w io.Writer, out *LsOutput, lastObjectHash
}
}
+ // TODO: Print link.Mode and link.ModTime?
fmt.Fprintf(tw, s, link.Hash, link.Size, cmdenv.EscNonPrint(link.Name))
}
}
diff --git a/core/commands/name/ipnsps.go b/core/commands/name/ipnsps.go
index f57173eeaca..e465549e07c 100644
--- a/core/commands/name/ipnsps.go
+++ b/core/commands/name/ipnsps.go
@@ -135,7 +135,7 @@ var ipnspsCancelCmd = &cmds.Command{
name = strings.TrimPrefix(name, "/ipns/")
pid, err := peer.Decode(name)
if err != nil {
- return cmds.Errorf(cmds.ErrClient, err.Error())
+ return cmds.Errorf(cmds.ErrClient, "not a valid IPNS name: %s", err)
}
ok, err := n.PSRouter.Cancel("/ipns/" + string(pid))
diff --git a/core/commands/name/name.go b/core/commands/name/name.go
index 9445fc362f0..912629d6883 100644
--- a/core/commands/name/name.go
+++ b/core/commands/name/name.go
@@ -260,8 +260,7 @@ Passing --verify will verify signature against provided public key.
if out.HexDump != "" {
tw.Flush()
- fmt.Fprintf(w, "\nHex Dump:\n")
- fmt.Fprintf(w, out.HexDump)
+ fmt.Fprintf(w, "\nHex Dump:\n%s", out.HexDump)
}
return nil
diff --git a/core/commands/refs.go b/core/commands/refs.go
index cefd8af9071..53c92c3df04 100644
--- a/core/commands/refs.go
+++ b/core/commands/refs.go
@@ -21,7 +21,7 @@ import (
var refsEncoderMap = cmds.EncoderMap{
cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *RefWrapper) error {
if out.Err != "" {
- return fmt.Errorf(out.Err)
+ return errors.New(out.Err)
}
fmt.Fprintln(w, out.Ref)
diff --git a/core/commands/stat.go b/core/commands/stat.go
index a09c70ea1c1..4ceb95f13d0 100644
--- a/core/commands/stat.go
+++ b/core/commands/stat.go
@@ -96,7 +96,7 @@ Example:
// Must be online!
if !nd.IsOnline {
- return cmds.Errorf(cmds.ErrClient, ErrNotOnline.Error())
+ return cmds.Errorf(cmds.ErrClient, "unable to run offline: %s", ErrNotOnline)
}
if nd.Reporter == nil {
diff --git a/core/commands/swarm.go b/core/commands/swarm.go
index 4fe535ffc21..252c48d334e 100644
--- a/core/commands/swarm.go
+++ b/core/commands/swarm.go
@@ -557,7 +557,7 @@ var swarmAddrsCmd = &cmds.Command{
paddrs := am.Addrs[p]
fmt.Fprintf(w, "%s (%d)\n", p, len(paddrs))
for _, addr := range paddrs {
- fmt.Fprintf(w, "\t"+addr+"\n")
+ fmt.Fprintf(w, "\t%s\n", addr)
}
}
diff --git a/core/commands/version.go b/core/commands/version.go
index e404074fe75..22172688146 100644
--- a/core/commands/version.go
+++ b/core/commands/version.go
@@ -5,17 +5,25 @@ import (
"fmt"
"io"
"runtime/debug"
+ "strings"
- version "github.com/ipfs/kubo"
-
+ versioncmp "github.com/hashicorp/go-version"
cmds "github.com/ipfs/go-ipfs-cmds"
+ version "github.com/ipfs/kubo"
+ "github.com/ipfs/kubo/config"
+ "github.com/ipfs/kubo/core"
+ "github.com/ipfs/kubo/core/commands/cmdenv"
+ "github.com/libp2p/go-libp2p-kad-dht/fullrt"
+ peer "github.com/libp2p/go-libp2p/core/peer"
+ pstore "github.com/libp2p/go-libp2p/core/peerstore"
)
const (
- versionNumberOptionName = "number"
- versionCommitOptionName = "commit"
- versionRepoOptionName = "repo"
- versionAllOptionName = "all"
+ versionNumberOptionName = "number"
+ versionCommitOptionName = "commit"
+ versionRepoOptionName = "repo"
+ versionAllOptionName = "all"
+ versionCheckThresholdOptionName = "min-percent"
)
var VersionCmd = &cmds.Command{
@@ -24,7 +32,8 @@ var VersionCmd = &cmds.Command{
ShortDescription: "Returns the current version of IPFS and exits.",
},
Subcommands: map[string]*cmds.Command{
- "deps": depsVersionCommand,
+ "deps": depsVersionCommand,
+ "check": checkVersionCommand,
},
Options: []cmds.Option{
@@ -130,3 +139,161 @@ Print out all dependencies and their versions.`,
}),
},
}
+
+const DefaultMinimalVersionFraction = 0.05 // 5%
+
+type VersionCheckOutput struct {
+ UpdateAvailable bool
+ RunningVersion string
+ GreatestVersion string
+ PeersSampled int
+ WithGreaterVersion int
+}
+
+var checkVersionCommand = &cmds.Command{
+ Helptext: cmds.HelpText{
+ Tagline: "Checks Kubo version against connected peers.",
+ ShortDescription: `
+This command uses the libp2p identify protocol to check the 'AgentVersion'
+of connected peers and see if the Kubo version we're running is outdated.
+
+Peers with an AgentVersion that doesn't start with 'kubo/' are ignored.
+'UpdateAvailable' is set to true only if the 'min-fraction' criteria are met.
+
+The 'ipfs daemon' does the same check regularly and logs when a new version
+is available. You can stop these regular checks by setting
+Version.SwarmCheckEnabled:false in the config.
+`,
+ },
+ Options: []cmds.Option{
+ cmds.IntOption(versionCheckThresholdOptionName, "t", "Percentage (1-100) of sampled peers with the new Kubo version needed to trigger an update warning.").WithDefault(config.DefaultSwarmCheckPercentThreshold),
+ },
+ Type: VersionCheckOutput{},
+
+ Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
+ nd, err := cmdenv.GetNode(env)
+ if err != nil {
+ return err
+ }
+
+ if !nd.IsOnline {
+ return ErrNotOnline
+ }
+
+ minPercent, _ := req.Options[versionCheckThresholdOptionName].(int64)
+ output, err := DetectNewKuboVersion(nd, minPercent)
+ if err != nil {
+ return err
+ }
+
+ if err := cmds.EmitOnce(res, output); err != nil {
+ return err
+ }
+ return nil
+ },
+}
+
+// DetectNewKuboVersion observers kubo version reported by other peers via
+// libp2p identify protocol and notifies when threshold fraction of seen swarm
+// is running updated Kubo. It is used by RPC and CLI at 'ipfs version check'
+// and also periodically when 'ipfs daemon' is running.
+func DetectNewKuboVersion(nd *core.IpfsNode, minPercent int64) (VersionCheckOutput, error) {
+ ourVersion, err := versioncmp.NewVersion(version.CurrentVersionNumber)
+ if err != nil {
+ return VersionCheckOutput{}, fmt.Errorf("could not parse our own version %q: %w",
+ version.CurrentVersionNumber, err)
+ }
+ // MAJOR.MINOR.PATCH without any suffix
+ ourVersion = ourVersion.Core()
+
+ greatestVersionSeen := ourVersion
+ totalPeersSampled := 1 // Us (and to avoid division-by-zero edge case)
+ withGreaterVersion := 0
+
+ recordPeerVersion := func(agentVersion string) {
+ // We process the version as is it assembled in GetUserAgentVersion
+ segments := strings.Split(agentVersion, "/")
+ if len(segments) < 2 {
+ return
+ }
+ if segments[0] != "kubo" {
+ return
+ }
+ versionNumber := segments[1] // As in our CurrentVersionNumber
+
+ peerVersion, err := versioncmp.NewVersion(versionNumber)
+ if err != nil {
+ // Do not error on invalid remote versions, just ignore
+ return
+ }
+
+ // Ignore prerelases and development releases (-dev, -rcX)
+ if peerVersion.Metadata() != "" || peerVersion.Prerelease() != "" {
+ return
+ }
+
+ // MAJOR.MINOR.PATCH without any suffix
+ peerVersion = peerVersion.Core()
+
+ // Valid peer version number
+ totalPeersSampled += 1
+ if ourVersion.LessThan(peerVersion) {
+ withGreaterVersion += 1
+ }
+ if peerVersion.GreaterThan(greatestVersionSeen) {
+ greatestVersionSeen = peerVersion
+ }
+ }
+
+ processPeerstoreEntry := func(id peer.ID) {
+ if v, err := nd.Peerstore.Get(id, "AgentVersion"); err == nil {
+ recordPeerVersion(v.(string))
+ } else if errors.Is(err, pstore.ErrNotFound) { // ignore noop
+ } else { // a bug, usually.
+ log.Errorw("failed to get agent version from peerstore", "error", err)
+ }
+ }
+
+ // Amino DHT client keeps information about previously seen peers
+ if nd.DHTClient != nd.DHT && nd.DHTClient != nil {
+ client, ok := nd.DHTClient.(*fullrt.FullRT)
+ if !ok {
+ return VersionCheckOutput{}, errors.New("could not perform version check due to missing or incompatible DHT configuration")
+ }
+ for _, p := range client.Stat() {
+ processPeerstoreEntry(p)
+ }
+ } else if nd.DHT != nil && nd.DHT.WAN != nil {
+ for _, pi := range nd.DHT.WAN.RoutingTable().GetPeerInfos() {
+ processPeerstoreEntry(pi.Id)
+ }
+ } else if nd.DHT != nil && nd.DHT.LAN != nil {
+ for _, pi := range nd.DHT.LAN.RoutingTable().GetPeerInfos() {
+ processPeerstoreEntry(pi.Id)
+ }
+ } else {
+ return VersionCheckOutput{}, errors.New("could not perform version check due to missing or incompatible DHT configuration")
+ }
+
+ if minPercent < 1 || minPercent > 100 {
+ if minPercent == 0 {
+ minPercent = config.DefaultSwarmCheckPercentThreshold
+ } else {
+ return VersionCheckOutput{}, errors.New("Version.SwarmCheckPercentThreshold must be between 1 and 100")
+ }
+ }
+
+ minFraction := float64(minPercent) / 100.0
+
+ // UpdateAvailable flag is set only if minFraction was reached
+ greaterFraction := float64(withGreaterVersion) / float64(totalPeersSampled)
+
+ // Gathered metric are returned every time
+ return VersionCheckOutput{
+ UpdateAvailable: (greaterFraction >= minFraction),
+ RunningVersion: ourVersion.String(),
+ GreatestVersion: greatestVersionSeen.String(),
+ PeersSampled: totalPeersSampled,
+ WithGreaterVersion: withGreaterVersion,
+ }, nil
+}
diff --git a/core/coreapi/unixfs.go b/core/coreapi/unixfs.go
index 860574945d7..e175488f37f 100644
--- a/core/coreapi/unixfs.go
+++ b/core/coreapi/unixfs.go
@@ -130,6 +130,10 @@ func (api *UnixfsAPI) Add(ctx context.Context, files files.Node, opts ...options
fileAdder.RawLeaves = settings.RawLeaves
fileAdder.NoCopy = settings.NoCopy
fileAdder.CidBuilder = prefix
+ fileAdder.PreserveMode = settings.PreserveMode
+ fileAdder.PreserveMtime = settings.PreserveMtime
+ fileAdder.FileMode = settings.Mode
+ fileAdder.FileMtime = settings.Mtime
switch settings.Layout {
case options.BalancedLayout:
@@ -270,6 +274,8 @@ func (api *UnixfsAPI) processLink(ctx context.Context, linkres ft.LinkResult, se
if !settings.UseCumulativeSize {
lnk.Size = d.FileSize()
}
+ lnk.Mode = d.Mode()
+ lnk.ModTime = d.ModTime()
}
}
diff --git a/core/corehttp/webui.go b/core/corehttp/webui.go
index 2e31b22144f..82520e30da2 100644
--- a/core/corehttp/webui.go
+++ b/core/corehttp/webui.go
@@ -1,11 +1,12 @@
package corehttp
// WebUI version confirmed to work with this Kubo version
-const WebUIPath = "/ipfs/bafybeigggyffcf6yfhx5irtwzx3cgnk6n3dwylkvcpckzhqqrigsxowjwe" // v4.2.1
+const WebUIPath = "/ipfs/bafybeihatzsgposbr3hrngo42yckdyqcc56yean2rynnwpzxstvdlphxf4" // v4.3.0
// WebUIPaths is a list of all past webUI paths.
var WebUIPaths = []string{
WebUIPath,
+ "/ipfs/bafybeigggyffcf6yfhx5irtwzx3cgnk6n3dwylkvcpckzhqqrigsxowjwe",
"/ipfs/bafybeidf7cpkwsjkq6xs3r6fbbxghbugilx3jtezbza7gua3k5wjixpmba",
"/ipfs/bafybeiamycmd52xvg6k3nzr6z3n33de6a2teyhquhj4kspdtnvetnkrfim",
"/ipfs/bafybeieqdeoqkf7xf4aozd524qncgiloh33qgr25lyzrkusbcre4c3fxay",
diff --git a/core/coreiface/options/unixfs.go b/core/coreiface/options/unixfs.go
index f00fffb87b0..c837ec1b2db 100644
--- a/core/coreiface/options/unixfs.go
+++ b/core/coreiface/options/unixfs.go
@@ -3,6 +3,8 @@ package options
import (
"errors"
"fmt"
+ "os"
+ "time"
dag "github.com/ipfs/boxo/ipld/merkledag"
cid "github.com/ipfs/go-cid"
@@ -36,6 +38,11 @@ type UnixfsAddSettings struct {
Events chan<- interface{}
Silent bool
Progress bool
+
+ PreserveMode bool
+ PreserveMtime bool
+ Mode os.FileMode
+ Mtime time.Time
}
type UnixfsLsSettings struct {
@@ -69,6 +76,11 @@ func UnixfsAddOptions(opts ...UnixfsAddOption) (*UnixfsAddSettings, cid.Prefix,
Events: nil,
Silent: false,
Progress: false,
+
+ PreserveMode: false,
+ PreserveMtime: false,
+ Mode: 0,
+ Mtime: time.Time{},
}
for _, opt := range opts {
@@ -106,6 +118,14 @@ func UnixfsAddOptions(opts ...UnixfsAddOption) (*UnixfsAddSettings, cid.Prefix,
}
}
+ if !options.Mtime.IsZero() && options.PreserveMtime {
+ options.PreserveMtime = false
+ }
+
+ if options.Mode != 0 && options.PreserveMode {
+ options.PreserveMode = false
+ }
+
// cidV1 -> raw blocks (by default)
if options.CidVersion > 0 && !options.RawLeavesSet {
options.RawLeaves = true
@@ -293,3 +313,38 @@ func (unixfsOpts) UseCumulativeSize(use bool) UnixfsLsOption {
return nil
}
}
+
+// PreserveMode tells the adder to store the file permissions
+func (unixfsOpts) PreserveMode(enable bool) UnixfsAddOption {
+ return func(settings *UnixfsAddSettings) error {
+ settings.PreserveMode = enable
+ return nil
+ }
+}
+
+// PreserveMtime tells the adder to store the file modification time
+func (unixfsOpts) PreserveMtime(enable bool) UnixfsAddOption {
+ return func(settings *UnixfsAddSettings) error {
+ settings.PreserveMtime = enable
+ return nil
+ }
+}
+
+// Mode represents a unix file mode
+func (unixfsOpts) Mode(mode os.FileMode) UnixfsAddOption {
+ return func(settings *UnixfsAddSettings) error {
+ settings.Mode = mode
+ return nil
+ }
+}
+
+// Mtime represents a unix file mtime
+func (unixfsOpts) Mtime(seconds int64, nsecs uint32) UnixfsAddOption {
+ return func(settings *UnixfsAddSettings) error {
+ if nsecs > 999999999 {
+ return errors.New("mtime nanoseconds must be in range [1, 999999999]")
+ }
+ settings.Mtime = time.Unix(seconds, int64(nsecs))
+ return nil
+ }
+}
diff --git a/core/coreiface/unixfs.go b/core/coreiface/unixfs.go
index d0dc4d8ce09..c0150bd12c6 100644
--- a/core/coreiface/unixfs.go
+++ b/core/coreiface/unixfs.go
@@ -2,6 +2,8 @@ package iface
import (
"context"
+ "os"
+ "time"
"github.com/ipfs/boxo/files"
"github.com/ipfs/boxo/path"
@@ -10,10 +12,13 @@ import (
)
type AddEvent struct {
- Name string
- Path path.ImmutablePath `json:",omitempty"`
- Bytes int64 `json:",omitempty"`
- Size string `json:",omitempty"`
+ Name string
+ Path path.ImmutablePath `json:",omitempty"`
+ Bytes int64 `json:",omitempty"`
+ Size string `json:",omitempty"`
+ Mode os.FileMode `json:",omitempty"`
+ Mtime int64 `json:",omitempty"`
+ MtimeNsecs int `json:",omitempty"`
}
// FileType is an enum of possible UnixFS file types.
@@ -56,6 +61,9 @@ type DirEntry struct {
Type FileType // The type of the file.
Target string // The symlink target (if a symlink).
+ Mode os.FileMode
+ ModTime time.Time
+
Err error
}
diff --git a/core/coreunix/add.go b/core/coreunix/add.go
index a8d7e5982f0..5f7cbb61065 100644
--- a/core/coreunix/add.go
+++ b/core/coreunix/add.go
@@ -5,8 +5,10 @@ import (
"errors"
"fmt"
"io"
+ "os"
gopath "path"
"strconv"
+ "time"
bstore "github.com/ipfs/boxo/blockstore"
chunker "github.com/ipfs/boxo/chunker"
@@ -81,6 +83,11 @@ type Adder struct {
tempRoot cid.Cid
CidBuilder cid.Builder
liveNodes uint64
+
+ PreserveMode bool
+ PreserveMtime bool
+ FileMode os.FileMode
+ FileMtime time.Time
}
func (adder *Adder) mfsRoot() (*mfs.Root, error) {
@@ -113,11 +120,13 @@ func (adder *Adder) add(reader io.Reader) (ipld.Node, error) {
}
params := ihelper.DagBuilderParams{
- Dagserv: adder.bufferedDS,
- RawLeaves: adder.RawLeaves,
- Maxlinks: ihelper.DefaultLinksPerBlock,
- NoCopy: adder.NoCopy,
- CidBuilder: adder.CidBuilder,
+ Dagserv: adder.bufferedDS,
+ RawLeaves: adder.RawLeaves,
+ Maxlinks: ihelper.DefaultLinksPerBlock,
+ NoCopy: adder.NoCopy,
+ CidBuilder: adder.CidBuilder,
+ FileMode: adder.FileMode,
+ FileModTime: adder.FileMtime,
}
db, err := params.New(chnk)
@@ -359,6 +368,14 @@ func (adder *Adder) addFileNode(ctx context.Context, path string, file files.Nod
return err
}
+ if adder.PreserveMtime {
+ adder.FileMtime = file.ModTime()
+ }
+
+ if adder.PreserveMode {
+ adder.FileMode = file.Mode()
+ }
+
if adder.liveNodes >= liveCacheSize {
// TODO: A smarter cache that uses some sort of lru cache with an eviction handler
mr, err := adder.mfsRoot()
@@ -391,6 +408,18 @@ func (adder *Adder) addSymlink(path string, l *files.Symlink) error {
return err
}
+ if !adder.FileMtime.IsZero() {
+ fsn, err := unixfs.FSNodeFromBytes(sdata)
+ if err != nil {
+ return err
+ }
+
+ fsn.SetModTime(adder.FileMtime)
+ if sdata, err = fsn.GetBytes(); err != nil {
+ return err
+ }
+ }
+
dagnode := dag.NodeWithData(sdata)
err = dagnode.SetCidBuilder(adder.CidBuilder)
if err != nil {
@@ -429,6 +458,20 @@ func (adder *Adder) addFile(path string, file files.File) error {
func (adder *Adder) addDir(ctx context.Context, path string, dir files.Directory, toplevel bool) error {
log.Infof("adding directory: %s", path)
+ // if we need to store mode or modification time then create a new root which includes that data
+ if toplevel && (adder.FileMode != 0 || !adder.FileMtime.IsZero()) {
+ nd := unixfs.EmptyDirNodeWithStat(adder.FileMode, adder.FileMtime)
+ err := nd.SetCidBuilder(adder.CidBuilder)
+ if err != nil {
+ return err
+ }
+ mr, err := mfs.NewRoot(ctx, adder.dagService, nd, nil)
+ if err != nil {
+ return err
+ }
+ adder.SetMfsRoot(mr)
+ }
+
if !(toplevel && path == "") {
mr, err := adder.mfsRoot()
if err != nil {
@@ -438,6 +481,8 @@ func (adder *Adder) addDir(ctx context.Context, path string, dir files.Directory
Mkparents: true,
Flush: false,
CidBuilder: adder.CidBuilder,
+ Mode: adder.FileMode,
+ ModTime: adder.FileMtime,
})
if err != nil {
return err
diff --git a/core/coreunix/metadata_test.go b/core/coreunix/metadata_test.go
index b40f010db48..c7d1b94db38 100644
--- a/core/coreunix/metadata_test.go
+++ b/core/coreunix/metadata_test.go
@@ -16,11 +16,11 @@ import (
bstore "github.com/ipfs/boxo/blockstore"
chunker "github.com/ipfs/boxo/chunker"
offline "github.com/ipfs/boxo/exchange/offline"
- u "github.com/ipfs/boxo/util"
cid "github.com/ipfs/go-cid"
ds "github.com/ipfs/go-datastore"
dssync "github.com/ipfs/go-datastore/sync"
ipld "github.com/ipfs/go-ipld-format"
+ "github.com/ipfs/go-test/random"
)
func getDagserv(t *testing.T) ipld.DAGService {
@@ -35,7 +35,7 @@ func TestMetadata(t *testing.T) {
// Make some random node
ds := getDagserv(t)
data := make([]byte, 1000)
- _, err := io.ReadFull(u.NewTimeSeededRand(), data)
+ _, err := io.ReadFull(random.NewRand(), data)
if err != nil {
t.Fatal(err)
}
diff --git a/core/node/groups.go b/core/node/groups.go
index 3df945fd2cc..a12cc7b7f1d 100644
--- a/core/node/groups.go
+++ b/core/node/groups.go
@@ -105,7 +105,9 @@ func LibP2P(bcfg *BuildCfg, cfg *config.Config, userResourceOverrides rcmgr.Part
// to dhtclient.
fallthrough
case config.AutoNATServiceEnabled:
- autonat = fx.Provide(libp2p.AutoNATService(cfg.AutoNAT.Throttle))
+ autonat = fx.Provide(libp2p.AutoNATService(cfg.AutoNAT.Throttle, false))
+ case config.AutoNATServiceEnabledV1Only:
+ autonat = fx.Provide(libp2p.AutoNATService(cfg.AutoNAT.Throttle, true))
}
enableRelayTransport := cfg.Swarm.Transports.Network.Relay.WithDefault(true) // nolint
diff --git a/core/node/libp2p/nat.go b/core/node/libp2p/nat.go
index fc72d7fb3c0..6d3cd09c38e 100644
--- a/core/node/libp2p/nat.go
+++ b/core/node/libp2p/nat.go
@@ -9,7 +9,7 @@ import (
var NatPortMap = simpleOpt(libp2p.NATPortMap())
-func AutoNATService(throttle *config.AutoNATThrottleConfig) func() Libp2pOpts {
+func AutoNATService(throttle *config.AutoNATThrottleConfig, v1only bool) func() Libp2pOpts {
return func() (opts Libp2pOpts) {
opts.Opts = append(opts.Opts, libp2p.EnableNATService())
if throttle != nil {
@@ -21,6 +21,13 @@ func AutoNATService(throttle *config.AutoNATThrottleConfig) func() Libp2pOpts {
),
)
}
+
+ // While V1 still exists and V2 rollout is in progress
+ // (https://github.com/ipfs/kubo/issues/10091) we check a flag that
+ // allows users to disable V2 and run V1-only mode
+ if !v1only {
+ opts.Opts = append(opts.Opts, libp2p.EnableAutoNATv2())
+ }
return opts
}
}
diff --git a/core/node/libp2p/rcmgr.go b/core/node/libp2p/rcmgr.go
index ab6e7294018..8b6d55a2cfc 100644
--- a/core/node/libp2p/rcmgr.go
+++ b/core/node/libp2p/rcmgr.go
@@ -77,21 +77,16 @@ filled in with autocomputed defaults.`)
ropts := []rcmgr.Option{
rcmgr.WithMetrics(createRcmgrMetrics()),
rcmgr.WithTraceReporter(str),
- rcmgr.WithLimitPeersPerCIDR(
- []rcmgr.ConnLimitPerCIDR{
+ rcmgr.WithLimitPerSubnet(
+ nil,
+ []rcmgr.ConnLimitPerSubnet{
{
- ConnCount: 16,
- BitMask: 32,
+ ConnCount: 16,
+ PrefixLength: 56,
},
- },
- []rcmgr.ConnLimitPerCIDR{
{
- ConnCount: 16,
- BitMask: 56,
- },
- {
- ConnCount: 8 * 16,
- BitMask: 48,
+ ConnCount: 8 * 16,
+ PrefixLength: 48,
},
}),
}
diff --git a/core/node/libp2p/sec.go b/core/node/libp2p/sec.go
index 0dc6940d8f9..5a3e95e3150 100644
--- a/core/node/libp2p/sec.go
+++ b/core/node/libp2p/sec.go
@@ -22,11 +22,11 @@ func Security(enabled bool, tptConfig config.Transports) interface{} {
return func() (opts Libp2pOpts) {
opts.Opts = append(opts.Opts, prioritizeOptions([]priorityOption{{
priority: tptConfig.Security.TLS,
- defaultPriority: 200,
+ defaultPriority: 100,
opt: libp2p.Security(tls.ID, tls.New),
}, {
priority: tptConfig.Security.Noise,
- defaultPriority: 100,
+ defaultPriority: 200,
opt: libp2p.Security(noise.ID, noise.New),
}}))
return opts
diff --git a/core/node/libp2p/transport.go b/core/node/libp2p/transport.go
index 797917b72cb..6628adc3268 100644
--- a/core/node/libp2p/transport.go
+++ b/core/node/libp2p/transport.go
@@ -50,7 +50,7 @@ func Transports(tptConfig config.Transports) interface{} {
opts.Opts = append(opts.Opts, libp2p.Transport(webtransport.New))
}
- if tptConfig.Network.WebRTCDirect.WithDefault(false) {
+ if tptConfig.Network.WebRTCDirect.WithDefault(!privateNetworkEnabled) {
if privateNetworkEnabled {
return opts, fmt.Errorf(
"WebRTC Direct transport does not support private networks, please disable Swarm.Transports.Network.WebRTCDirect",
diff --git a/core/node/storage.go b/core/node/storage.go
index a303ddc23a3..aedf0ee6a1d 100644
--- a/core/node/storage.go
+++ b/core/node/storage.go
@@ -56,7 +56,7 @@ func GcBlockstoreCtor(bb BaseBlocks) (gclocker blockstore.GCLocker, gcbs blockst
return
}
-// GcBlockstoreCtor wraps GcBlockstore and adds Filestore support
+// FilestoreBlockstoreCtor wraps GcBlockstore and adds Filestore support
func FilestoreBlockstoreCtor(repo repo.Repo, bb BaseBlocks) (gclocker blockstore.GCLocker, gcbs blockstore.GCBlockstore, bs blockstore.Blockstore, fstore *filestore.Filestore) {
gclocker = blockstore.NewGCLocker()
diff --git a/docs/RELEASE_CHECKLIST.md b/docs/RELEASE_CHECKLIST.md
index 727700eebbd..655329e1a7f 100644
--- a/docs/RELEASE_CHECKLIST.md
+++ b/docs/RELEASE_CHECKLIST.md
@@ -173,8 +173,7 @@ This section covers tasks to be done during each release.
- [ ]   Create a dependency update PR
- [ ]   check out [ipfs/kubo](https://github.com/ipfs/kubo)
- [ ]   run `go get -u` in root directory
- - [ ]   run `go mod tidy` in root directory
- - [ ]   run `go mod tidy` in `docs/examples/kubo-as-a-library` directory
+ - [ ]   run `make mod_tidy`
- [ ]   create a PR which updates `go.mod` and `go.sum`
- [ ]   add the PR to the next release milestone
- [ ]  Close the release issue
diff --git a/docs/changelogs/v0.30.md b/docs/changelogs/v0.30.md
new file mode 100644
index 00000000000..5fcfb693cf5
--- /dev/null
+++ b/docs/changelogs/v0.30.md
@@ -0,0 +1,337 @@
+# Kubo changelog v0.30
+
+- [v0.30.0](#v0300)
+
+## v0.30.0
+
+- [Overview](#overview)
+- [🔦 Highlights](#-highlights)
+ - [Improved P2P connectivity](#improved-p2p-connectivity)
+ - [Refactored Bitswap and dag-pb chunker](#refactored-bitswap-and-dag-pb-chunker)
+ - [WebRTC-Direct Transport enabled by default](#webrtc-direct-transport-enabled-by-default)
+ - [UnixFS 1.5: Mode and Modification Time Support](#unixfs-15-mode-and-modification-time-support)
+ - [AutoNAT V2 Service Introduced Alongside V1](#autonat-v2-service-introduced-alongside-v1)
+ - [Automated `ipfs version check`](#automated-ipfs-version-check)
+ - [Version Suffix Configuration](#version-suffix-configuration)
+ - [`/unix/` socket support in `Addresses.API`](#unix-socket-support-in-addressesapi)
+ - [Cleaned Up `ipfs daemon` Startup Log](#cleaned-up-ipfs-daemon-startup-log)
+ - [Commands Preserve Specified Hostname](#commands-preserve-specified-hostname)
+- [📝 Changelog](#-changelog)
+- [👨👩👧👦 Contributors](#-contributors)
+
+### Overview
+
+### 🔦 Highlights
+
+This release took longer and is more packed with fixes and features than usual.
+
+> [!IMPORTANT]
+> TLDR: update, it contains many, many fixes.
+
+#### Improved P2P connectivity
+
+This release comes with significant go-libp2p update from v0.34.1 to v0.36.3 ([release notes](https://github.com/libp2p/go-libp2p/releases/)).
+
+It includes multiple fixes to key protocols: [QUIC](https://github.com/libp2p/specs/tree/master/quic)/[Webtransport](https://github.com/libp2p/specs/tree/master/webtransport)/[WebRTC](https://github.com/libp2p/specs/tree/master/webrtc), Connection Upgrades through Relay ([DCUtR](https://github.com/libp2p/specs/blob/master/relay/DCUtR.md)), and [Secure WebSockets](https://github.com/libp2p/specs/pull/624).
+
+Also, peers that are behind certain types of NAT will now be more reachable. For this alone, Kubo users are highly encouraged to upgrade.
+
+#### Refactored Bitswap and dag-pb chunker
+
+Some workloads may experience improved memory profile thanks to optimizations from Boxo SDK [v0.23.0](https://github.com/ipfs/boxo/releases/tag/v0.23.0).
+
+> [!IMPORTANT]
+> Storage providers should upgrade to take advantage of the Bitswap server fix, which resolves the issue of greedy peers depleting available wantlist slots for their PeerID, resulting in stalled downloads.
+
+#### WebRTC-Direct Transport enabled by default
+
+Kubo now ships with [WebRTC Direct](https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md) listener enabled by default: `/udp/4001/webrtc-direct`.
+
+WebRTC Direct complements existing `/wss` (Secure WebSockets) and `/webtransport` transports. Unlike `/wss`, which requires a domain name and a CA-issued TLS certificate, WebRTC Direct works with IPs and can be enabled by default on all Kubo nodes.
+
+Learn more: [`Swarm.Transports.Network.WebRTCDirect`](https://github.com/ipfs/kubo/blob/master/docs/config.md#swarmtransportsnetworkwebrtcdirect)
+
+> [!NOTE]
+> Kubo 0.30 includes a migration for existing users that adds `/webrtc-direct` listener on the same UDP port as `/udp/{port}/quic-v1`. This supports the WebRTC-Direct rollout by reusing preexisting UDP firewall settings and port mappings created for QUIC.
+
+#### UnixFS 1.5: Mode and Modification Time Support
+
+Kubo now allows users to opt-in to store mode and modification time for files, directories, and symbolic links.
+By default, if you do not opt-in, the old behavior remains unchanged, and the same CIDs will be generated as before.
+
+The `ipfs add` CLI options `--preserve-mode` and `--preserve-mtime` can be used to store the original mode and last modified time of the file being added, and `ipfs files stat /ipfs/CID` can be used for inspecting these optional attributes:
+
+```console
+$ touch ./file
+$ chmod 654 ./file
+$ ipfs add --preserve-mode --preserve-mtime -Q ./file
+QmczQr4XS1rRnWVopyg5Chr9EQ7JKpbhgnrjpb5kTQ1DKQ
+
+$ ipfs files stat /ipfs/QmczQr4XS1rRnWVopyg5Chr9EQ7JKpbhgnrjpb5kTQ1DKQ
+QmczQr4XS1rRnWVopyg5Chr9EQ7JKpbhgnrjpb5kTQ1DKQ
+Size: 0
+CumulativeSize: 22
+ChildBlocks: 0
+Type: file
+Mode: -rw-r-xr-- (0654)
+Mtime: 13 Aug 2024, 21:15:31 UTC
+```
+
+The CLI and HTTP RPC options `--mode`, `--mtime` and `--mtime-nsecs` can be used to set them to arbitrary values.
+
+Opt-in support for `mode` and `mtime` was also added to MFS (`ipfs files --help`). For more information see `--help` text of `ipfs files touch|stat|chmod` commands.
+
+Modification time support was also added to the Gateway. If present, value from file's dag-pb is returned in `Last-Modified` HTTP header and requests made with `If-Modified-Since` can produce HTTP 304 not modified response.
+
+> [!NOTE]
+> Storing `mode` and `mtime` requires root block to be `dag-pb` and disabled `raw-leaves` setting to create envelope for storing the metadata.
+
+#### AutoNAT V2 Service Introduced Alongside V1
+
+The AutoNAT service enables nodes to determine their public reachability on the internet. [AutoNAT V2](https://github.com/libp2p/specs/pull/538) enhances this protocol with improved features. In this release, Kubo will offer both V1 and V2 services to other peers, although it will continue to use only V1 when acting as a client. Future releases will phase out V1, transitioning clients to utilize V2 exclusively.
+
+For more details, see the [Deployment Plan for AutoNAT V2](https://github.com/ipfs/kubo/issues/10091) and [`AutoNAT`](https://github.com/ipfs/kubo/blob/master/docs/config.md#autonat) configuration options.
+
+#### Automated `ipfs version check`
+
+Kubo now performs privacy-preserving version checks using the [libp2p identify protocol](https://github.com/libp2p/specs/blob/master/identify/README.md) on peers detected by the Amino DHT client.
+If more than 5% of Kubo peers seen by your node are running a newer version, you will receive a log message notification.
+
+- For manual checks, refer to `ipfs version check --help` for details.
+- To disable automated checks, set [`Version.SwarmCheckEnabled`](https://github.com/ipfs/kubo/blob/master/docs/config.md#versionswarmcheckenabled) to `false`.
+
+#### Version Suffix Configuration
+
+Defining the optional agent version suffix is now simpler. The [`Version.AgentSuffix`](https://github.com/ipfs/kubo/blob/master/docs/config.md#agentsuffix) value from the Kubo config takes precedence over any value provided via `ipfs daemon --agent-version-suffix` (which is still supported).
+
+> [!NOTE]
+> Setting a custom version suffix helps with ecosystem analysis, such as Amino DHT reports published at https://stats.ipfs.network
+
+#### `/unix/` socket support in `Addresses.API`
+
+This release fixes a bug which blocked users from using Unix domain sockets for [Kubo's RPC](https://docs.ipfs.tech/reference/kubo/rpc/) (instead of a local HTTP port).
+
+```console
+$ ipfs config Addresses.API "/unix/tmp/kubo.socket"
+$ ipfs daemon # start with rpc socket
+...
+RPC API server listening on /unix/tmp/kubo.socket
+
+$ # cli client, in different terminal can find socket via /api file
+$ cat $IPFS_PATH/api
+/unix/tmp/kubo.socket
+
+$ # or have it pased via --api
+$ ipfs --api=/unix/tmp/kubo.socket id
+```
+
+#### Cleaned Up `ipfs daemon` Startup Log
+
+The `ipfs daemon` startup output has been streamlined to enhance clarity and usability:
+
+```console
+$ ipfs daemon
+Initializing daemon...
+Kubo version: 0.30.0
+Repo version: 16
+System version: amd64/linux
+Golang version: go1.22.5
+PeerID: 12D3KooWQ73s1CQsm4jWwQvdCAtc5w8LatyQt7QLQARk5xdhK9CE
+Swarm listening on 127.0.0.1:4001 (TCP+UDP)
+Swarm listening on 192.0.2.10:4001 (TCP+UDP)
+Swarm listening on [::1]:4001 (TCP+UDP)
+Swarm listening on [2001:0db8::10]:4001 (TCP+UDP)
+Run 'ipfs id' to inspect announced and discovered multiaddrs of this node.
+RPC API server listening on /ip4/127.0.0.1/tcp/5001
+WebUI: http://127.0.0.1:5001/webui
+Gateway server listening on /ip4/127.0.0.1/tcp/8080
+Daemon is ready
+```
+
+The previous lengthy listing of all listener and announced multiaddrs has been removed due to its complexity, especially with modern libp2p nodes sharing multiple transports and long lists of `/webtransport` and `/webrtc-direct` certhashes.
+The output now features a simplified list of swarm listeners, displayed in the format `host:port (TCP+UDP)`, which provides essential information for debugging connectivity issues, particularly related to port forwarding.
+Announced libp2p addresses are no longer printed on startup, because libp2p may change or augument them based on AutoNAT, relay, and UPnP state. Instead, users are prompted to run `ipfs id` to obtain up-to-date list of listeners and announced multiaddrs in libp2p format.
+
+#### Commands Preserve Specified Hostname
+
+When executing a [CLI command](https://docs.ipfs.tech/reference/kubo/cli/) over [Kubo RPC API](https://docs.ipfs.tech/reference/kubo/rpc/), if a hostname is specified by `--api=/dns4//` the resulting HTTP request now contains the hostname, instead of the the IP address that the hostname resolved to, as was the previous behavior. This makes it easier for those trying to run Kubo behind a reverse proxy using hostname-based rules.
+
+### 📝 Changelog
+
+Full Changelog
+
+- github.com/ipfs/kubo:
+ - chore: set version to 0.30.0
+ - chore: bump CurrentVersionNumber
+ - chore: boxo v0.23.0 and go-libp2p v0.36.3 (#10507) ([ipfs/kubo#10507](https://github.com/ipfs/kubo/pull/10507))
+ - fix: switch back to go 1.22 (#10502) ([ipfs/kubo#10502](https://github.com/ipfs/kubo/pull/10502))
+ - chore: update go-unixfsnode, cmds, and boxo (#10494) ([ipfs/kubo#10494](https://github.com/ipfs/kubo/pull/10494))
+ - fix(cli): preserve hostname specified with --api in http request headers (#10497) ([ipfs/kubo#10497](https://github.com/ipfs/kubo/pull/10497))
+ - chore: upgrade to go 1.23 (#10486) ([ipfs/kubo#10486](https://github.com/ipfs/kubo/pull/10486))
+ - fix: error during config when running benchmarks (#10495) ([ipfs/kubo#10495](https://github.com/ipfs/kubo/pull/10495))
+ - chore: update version to rc-2
+ - chore: update version
+ - chore: fix function name (#10481) ([ipfs/kubo#10481](https://github.com/ipfs/kubo/pull/10481))
+ - feat: Support storing UnixFS 1.5 Mode and ModTime (#10478) ([ipfs/kubo#10478](https://github.com/ipfs/kubo/pull/10478))
+ - fix(rpc): cross-platform support for /unix/ socket maddrs in Addresses.API ([ipfs/kubo#10019](https://github.com/ipfs/kubo/pull/10019))
+ - chore(daemon): sort listeners (#10480) ([ipfs/kubo#10480](https://github.com/ipfs/kubo/pull/10480))
+ - feat(daemon): improve stdout on startup (#10472) ([ipfs/kubo#10472](https://github.com/ipfs/kubo/pull/10472))
+ - fix(daemon): panic in kubo/daemon.go:595 (#10473) ([ipfs/kubo#10473](https://github.com/ipfs/kubo/pull/10473))
+ - feat: webui v4.3.0 (#10477) ([ipfs/kubo#10477](https://github.com/ipfs/kubo/pull/10477))
+ - docs(readme): add Gentoo Linux (#10474) ([ipfs/kubo#10474](https://github.com/ipfs/kubo/pull/10474))
+ - libp2p: default to prefering TLS ([ipfs/kubo#10227](https://github.com/ipfs/kubo/pull/10227))
+ - docs: document unofficial Ubuntu PPA ([ipfs/kubo#10467](https://github.com/ipfs/kubo/pull/10467))
+ - feat: run AutoNAT V2 service in addition to V1 (#10468) ([ipfs/kubo#10468](https://github.com/ipfs/kubo/pull/10468))
+ - feat: go-libp2p 0.36 and /webrtc-direct listener (#10463) ([ipfs/kubo#10463](https://github.com/ipfs/kubo/pull/10463))
+ - chore: update dependencies (#10462)(#10466) ([ipfs/kubo#10466](https://github.com/ipfs/kubo/pull/10466))
+ - feat: periodic version check and json config (#10438) ([ipfs/kubo#10438](https://github.com/ipfs/kubo/pull/10438))
+ - docs: clarify pnet limitations
+ - docs: "error mounting: could not resolve name" (#10449) ([ipfs/kubo#10449](https://github.com/ipfs/kubo/pull/10449))
+ - docs: update ipfs-swarm-key-gen example (#10453) ([ipfs/kubo#10453](https://github.com/ipfs/kubo/pull/10453))
+ - chore: update deps incl. boxo v0.21.0 (#10444) ([ipfs/kubo#10444](https://github.com/ipfs/kubo/pull/10444))
+ - chore: go-libp2p 0.35.1 (#10430) ([ipfs/kubo#10430](https://github.com/ipfs/kubo/pull/10430))
+ - docsa: update RELEASE_CHECKLIST.md
+ - chore: create next changelog (#10443) ([ipfs/kubo#10443](https://github.com/ipfs/kubo/pull/10443))
+ - Merge Release: v0.29.0 [skip changelog] ([ipfs/kubo#10442](https://github.com/ipfs/kubo/pull/10442))
+ - fix(cli): unify --name param in ls and add (#10439) ([ipfs/kubo#10439](https://github.com/ipfs/kubo/pull/10439))
+ - fix(libp2p): streams config validation in resource manager (#10435) ([ipfs/kubo#10435](https://github.com/ipfs/kubo/pull/10435))
+ - chore: fix some typos (#10396) ([ipfs/kubo#10396](https://github.com/ipfs/kubo/pull/10396))
+ - chore: update version
+- github.com/ipfs/boxo (v0.20.0 -> v0.23.0):
+ - Release v0.23.0 ([ipfs/boxo#669](https://github.com/ipfs/boxo/pull/669))
+ - docs(changelog): move entry to correct release
+ - Release v0.22.0 ([ipfs/boxo#654](https://github.com/ipfs/boxo/pull/654))
+ - Release v0.21.0 ([ipfs/boxo#622](https://github.com/ipfs/boxo/pull/622))
+- github.com/ipfs/go-ipfs-cmds (v0.11.0 -> v0.13.0):
+ - chore: release v0.13.0 (#261) ([ipfs/go-ipfs-cmds#261](https://github.com/ipfs/go-ipfs-cmds/pull/261))
+ - chore: release v0.12.0 (#259) ([ipfs/go-ipfs-cmds#259](https://github.com/ipfs/go-ipfs-cmds/pull/259))
+- github.com/ipfs/go-unixfsnode (v1.9.0 -> v1.9.1):
+ - Update release version ([ipfs/go-unixfsnode#76](https://github.com/ipfs/go-unixfsnode/pull/76))
+ - chore: update dependencies ([ipfs/go-unixfsnode#75](https://github.com/ipfs/go-unixfsnode/pull/75))
+- github.com/libp2p/go-libp2p (v0.34.1 -> v0.36.3):
+ - Release v0.36.3
+ - Fix: WebSocket: Clone TLS config before creating a new listener
+ - fix: enable dctur when interface address is public (#2931) ([libp2p/go-libp2p#2931](https://github.com/libp2p/go-libp2p/pull/2931))
+ - fix: QUIC/Webtransport Transports now will prefer their owned listeners for dialing out (#2936) ([libp2p/go-libp2p#2936](https://github.com/libp2p/go-libp2p/pull/2936))
+ - ci: uci/update-go (#2937) ([libp2p/go-libp2p#2937](https://github.com/libp2p/go-libp2p/pull/2937))
+ - fix: slice append value (#2938) ([libp2p/go-libp2p#2938](https://github.com/libp2p/go-libp2p/pull/2938))
+ - webrtc: wait for listener context before dropping connection (#2932) ([libp2p/go-libp2p#2932](https://github.com/libp2p/go-libp2p/pull/2932))
+ - ci: use go1.23, drop go1.21 (#2933) ([libp2p/go-libp2p#2933](https://github.com/libp2p/go-libp2p/pull/2933))
+ - Fail on any test timeout (#2929) ([libp2p/go-libp2p#2929](https://github.com/libp2p/go-libp2p/pull/2929))
+ - test: Try to fix test timeout (#2930) ([libp2p/go-libp2p#2930](https://github.com/libp2p/go-libp2p/pull/2930))
+ - ci: Out of the tarpit (#2923) ([libp2p/go-libp2p#2923](https://github.com/libp2p/go-libp2p/pull/2923))
+ - Fix proto import paths (#2920) ([libp2p/go-libp2p#2920](https://github.com/libp2p/go-libp2p/pull/2920))
+ - Release v0.36.2
+ - webrtc: reduce loglevel for pion logs (#2915) ([libp2p/go-libp2p#2915](https://github.com/libp2p/go-libp2p/pull/2915))
+ - webrtc: close connection when remote closes (#2914) ([libp2p/go-libp2p#2914](https://github.com/libp2p/go-libp2p/pull/2914))
+ - basic_host: close swarm on Close (#2916) ([libp2p/go-libp2p#2916](https://github.com/libp2p/go-libp2p/pull/2916))
+ - Revert "Create funding.json" (#2919) ([libp2p/go-libp2p#2919](https://github.com/libp2p/go-libp2p/pull/2919))
+ - Create funding.json
+ - Release v0.36.1
+ - Release v0.36.0 (#2905) ([libp2p/go-libp2p#2905](https://github.com/libp2p/go-libp2p/pull/2905))
+ - swarm: add a default timeout to conn.NewStream (#2907) ([libp2p/go-libp2p#2907](https://github.com/libp2p/go-libp2p/pull/2907))
+ - udpmux: Don't log an error if canceled because of shutdown (#2903) ([libp2p/go-libp2p#2903](https://github.com/libp2p/go-libp2p/pull/2903))
+ - ObsAddrManager: Infer external addresses for transports that share the same listening address. (#2892) ([libp2p/go-libp2p#2892](https://github.com/libp2p/go-libp2p/pull/2892))
+ - feat: WebRTC reuse QUIC conn (#2889) ([libp2p/go-libp2p#2889](https://github.com/libp2p/go-libp2p/pull/2889))
+ - examples/chat-with-mdns: default to a random port (#2896) ([libp2p/go-libp2p#2896](https://github.com/libp2p/go-libp2p/pull/2896))
+ - allow findpeers limit to be 0 (#2894) ([libp2p/go-libp2p#2894](https://github.com/libp2p/go-libp2p/pull/2894))
+ - quic: add support for quic-go metrics (#2823) ([libp2p/go-libp2p#2823](https://github.com/libp2p/go-libp2p/pull/2823))
+ - webrtc: remove experimental tag, enable by default (#2887) ([libp2p/go-libp2p#2887](https://github.com/libp2p/go-libp2p/pull/2887))
+ - config: fix AddrFactory for AutoNAT (#2868) ([libp2p/go-libp2p#2868](https://github.com/libp2p/go-libp2p/pull/2868))
+ - chore: /quic → /quic-v1 (#2888) ([libp2p/go-libp2p#2888](https://github.com/libp2p/go-libp2p/pull/2888))
+ - basichost: reset stream if SetProtocol fails (#2875) ([libp2p/go-libp2p#2875](https://github.com/libp2p/go-libp2p/pull/2875))
+ - feat: libp2phttp `/http-path` (#2850) ([libp2p/go-libp2p#2850](https://github.com/libp2p/go-libp2p/pull/2850))
+ - readme: update per latest multiversx rename (#2874) ([libp2p/go-libp2p#2874](https://github.com/libp2p/go-libp2p/pull/2874))
+ - websocket: don't return transport.ErrListenerClosed on closing listener (#2867) ([libp2p/go-libp2p#2867](https://github.com/libp2p/go-libp2p/pull/2867))
+ - Added tau to README.md (#2870) ([libp2p/go-libp2p#2870](https://github.com/libp2p/go-libp2p/pull/2870))
+ - basichost: reset new stream if rcmgr blocks (#2869) ([libp2p/go-libp2p#2869](https://github.com/libp2p/go-libp2p/pull/2869))
+ - transport integration tests: test conn attempt is dropped when the rcmgr blocks for WebRTC (#2856) ([libp2p/go-libp2p#2856](https://github.com/libp2p/go-libp2p/pull/2856))
+ - webtransport: close underlying h3 connection (#2862) ([libp2p/go-libp2p#2862](https://github.com/libp2p/go-libp2p/pull/2862))
+ - peerstore: don't intern protocols (#2860) ([libp2p/go-libp2p#2860](https://github.com/libp2p/go-libp2p/pull/2860))
+ - autonatv2: add server metrics for dial requests (#2848) ([libp2p/go-libp2p#2848](https://github.com/libp2p/go-libp2p/pull/2848))
+ - PR Comments
+ - Add a transport level test to ensure we close conns after rejecting them by the rcmgr
+ - Close quic conns when wrapping conn fails
+ - libp2p: use rcmgr for autonat dials (#2842) ([libp2p/go-libp2p#2842](https://github.com/libp2p/go-libp2p/pull/2842))
+ - metricshelper: improve checks for ip and transport (#2849) ([libp2p/go-libp2p#2849](https://github.com/libp2p/go-libp2p/pull/2849))
+ - Don't reuse the URL, make a new one
+ - Use default transport to make using the Host cheaper
+ - cleanup
+ - Add future test
+ - HTTP Host implements RoundTripper
+ - swarm: improve dial worker performance for common case
+ - pstoremanager: fix connectedness check
+ - autonatv2: implement autonatv2 spec (#2469) ([libp2p/go-libp2p#2469](https://github.com/libp2p/go-libp2p/pull/2469))
+ - webrtc: add a test for establishing many connections (#2801) ([libp2p/go-libp2p#2801](https://github.com/libp2p/go-libp2p/pull/2801))
+ - webrtc: fix ufrag prefix for dialing (#2832) ([libp2p/go-libp2p#2832](https://github.com/libp2p/go-libp2p/pull/2832))
+ - circuitv2: improve voucher validation (#2826) ([libp2p/go-libp2p#2826](https://github.com/libp2p/go-libp2p/pull/2826))
+ - libp2phttp: workaround for ResponseWriter's CloseNotifier (#2821) ([libp2p/go-libp2p#2821](https://github.com/libp2p/go-libp2p/pull/2821))
+ - Update README.md (#2830) ([libp2p/go-libp2p#2830](https://github.com/libp2p/go-libp2p/pull/2830))
+ - identify: add test for observed address handling (#2828) ([libp2p/go-libp2p#2828](https://github.com/libp2p/go-libp2p/pull/2828))
+ - identify: fix bug in observed address handling (#2825) ([libp2p/go-libp2p#2825](https://github.com/libp2p/go-libp2p/pull/2825))
+ - identify: Don't filter addr if remote is neither public nor private (#2820) ([libp2p/go-libp2p#2820](https://github.com/libp2p/go-libp2p/pull/2820))
+ - limit ping duration to 30s (#1358) ([libp2p/go-libp2p#1358](https://github.com/libp2p/go-libp2p/pull/1358))
+ - Remove out-dated code in example readme (#2818) ([libp2p/go-libp2p#2818](https://github.com/libp2p/go-libp2p/pull/2818))
+ - v0.35.0 (#2812) ([libp2p/go-libp2p#2812](https://github.com/libp2p/go-libp2p/pull/2812))
+ - rcmgr: Support specific network prefix in conn limiter (#2807) ([libp2p/go-libp2p#2807](https://github.com/libp2p/go-libp2p/pull/2807))
+- github.com/libp2p/go-libp2p-kad-dht (v0.25.2 -> v0.26.1):
+ - Release v0.26.1 ([libp2p/go-libp2p-kad-dht#983](https://github.com/libp2p/go-libp2p-kad-dht/pull/983))
+ - fix: Unexport hasValidConnectedness to make a patch release ([libp2p/go-libp2p-kad-dht#982](https://github.com/libp2p/go-libp2p-kad-dht/pull/982))
+ - correctly merging fix from https://github.com/libp2p/go-libp2p-kad-dht/pull/976 ([libp2p/go-libp2p-kad-dht#980](https://github.com/libp2p/go-libp2p-kad-dht/pull/980))
+ - Release v0.26.0 ([libp2p/go-libp2p-kad-dht#979](https://github.com/libp2p/go-libp2p-kad-dht/pull/979))
+ - chore: update deps ([libp2p/go-libp2p-kad-dht#974](https://github.com/libp2p/go-libp2p-kad-dht/pull/974))
+ - Upgrade to go-log v2.5.1 ([libp2p/go-libp2p-kad-dht#971](https://github.com/libp2p/go-libp2p-kad-dht/pull/971))
+ - Fix: don't perform lookupCheck if not enough peers in routing table ([libp2p/go-libp2p-kad-dht#970](https://github.com/libp2p/go-libp2p-kad-dht/pull/970))
+ - findnode(self) should return multiple peers ([libp2p/go-libp2p-kad-dht#968](https://github.com/libp2p/go-libp2p-kad-dht/pull/968))
+- github.com/libp2p/go-libp2p-routing-helpers (v0.7.3 -> v0.7.4):
+ - chore: release v0.7.4 (#85) ([libp2p/go-libp2p-routing-helpers#85](https://github.com/libp2p/go-libp2p-routing-helpers/pull/85))
+ - fix: composable parallel router tracing by index (#84) ([libp2p/go-libp2p-routing-helpers#84](https://github.com/libp2p/go-libp2p-routing-helpers/pull/84))
+- github.com/multiformats/go-multiaddr (v0.12.4 -> v0.13.0):
+ - Release v0.13.0 ([multiformats/go-multiaddr#248](https://github.com/multiformats/go-multiaddr/pull/248))
+ - Add support for http-path ([multiformats/go-multiaddr#246](https://github.com/multiformats/go-multiaddr/pull/246))
+- github.com/whyrusleeping/cbor-gen (v0.1.1 -> v0.1.2):
+ - properly extend strings (#95) ([whyrusleeping/cbor-gen#95](https://github.com/whyrusleeping/cbor-gen/pull/95))
+ - ioutil to io (#98) ([whyrusleeping/cbor-gen#98](https://github.com/whyrusleeping/cbor-gen/pull/98))
+
+