feat: Unixfs1.5 mode and modification time support (#150)

Apply unix mode and modification time to files.

Uses kubo and boxo with for Unixfs 1.5 to provide support for mode and modification time. If a retrieved file has mode and/or mod time, these values are applied to the saved file.

This demonstrates that kubo/client/rpc is working.

- Additional tests show that kubo/client/rpc works over a unix domain socket.
- Fix path parsing with new `path` package
- Add tests for directory contents with mod time and mode
- Use latest kubo and boxo
- Depend on go1.22

http.go

@@ -3,8 +3,8 @@ package main
 import (
 	"context"
 
-	iface "github.com/ipfs/boxo/coreiface"
 	ipfshttp "github.com/ipfs/kubo/client/rpc"
+	iface "github.com/ipfs/kubo/core/coreiface"
 )
 
 func http(ctx context.Context) (iface.CoreAPI, error) {

main.go

@@ -9,14 +9,15 @@ import (
 	"os/signal"
 	gopath "path"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"sync"
 	"syscall"
 
 	"github.com/cheggaaa/pb/v3"
-	iface "github.com/ipfs/boxo/coreiface"
-	ipath "github.com/ipfs/boxo/coreiface/path"
 	files "github.com/ipfs/boxo/files"
+	ipath "github.com/ipfs/boxo/path"
+	iface "github.com/ipfs/kubo/core/coreiface"
 	cli "github.com/urfave/cli/v2"
 )
 
@@ -166,25 +167,28 @@ func movePostfixOptions(args []string) []string {
 }
 
 func parsePath(path string) (ipath.Path, error) {
-	ipfsPath := ipath.New(path)
-	if ipfsPath.IsValid() == nil {
+	ipfsPath, err := ipath.NewPath(path)
+	if err == nil {
+		return ipfsPath, nil
+	}
+	origErr := err
+
+	ipfsPath, err = ipath.NewPath("/ipfs/" + path)
+	if err == nil {
 		return ipfsPath, nil
 	}
 
 	u, err := url.Parse(path)
 	if err != nil {
-		return nil, fmt.Errorf("%q could not be parsed: %s", path, err)
+		return nil, origErr
 	}
-
-	switch proto := u.Scheme; proto {
+	switch u.Scheme {
 	case "ipfs", "ipld", "ipns":
-		ipfsPath = ipath.New(gopath.Join("/", proto, u.Host, u.Path))
+		return ipath.NewPath(gopath.Join("/", u.Scheme, u.Host, u.Path))
 	case "http", "https":
-		ipfsPath = ipath.New(u.Path)
-	default:
-		return nil, fmt.Errorf("%q is not recognized as an IPFS path", path)
+		return ipath.NewPath(u.Path)
 	}
-	return ipfsPath, ipfsPath.IsValid()
+	return nil, fmt.Errorf("%q is not recognized as an IPFS path", path)
 }
 
 // WriteTo writes the given node to the local filesystem at fpath.
@@ -205,7 +209,16 @@ func WriteTo(nd files.Node, fpath string, progress bool) error {
 func writeToRec(nd files.Node, fpath string, bar *pb.ProgressBar) error {
 	switch nd := nd.(type) {
 	case *files.Symlink:
-		return os.Symlink(nd.Target, fpath)
+		err := os.Symlink(nd.Target, fpath)
+		if err != nil {
+			return err
+		}
+		switch runtime.GOOS {
+		case "linux", "freebsd", "netbsd", "openbsd", "dragonfly":
+			return files.UpdateModTime(fpath, nd.ModTime())
+		default:
+			return nil
+		}
 	case files.File:
 		f, err := os.Create(fpath)
 		defer f.Close()
@@ -221,20 +234,24 @@ func writeToRec(nd files.Node, fpath string, bar *pb.ProgressBar) error {
 		if err != nil {
 			return err
 		}
-		return nil
+		return files.UpdateMeta(fpath, nd.Mode(), nd.ModTime())
 	case files.Directory:
 		err := os.Mkdir(fpath, 0777)
 		if err != nil {
 			return err
 		}
-
 		entries := nd.Entries()
 		for entries.Next() {
 			child := filepath.Join(fpath, entries.Name())
 			if err := writeToRec(entries.Node(), child, bar); err != nil {
 				return err
 			}
 		}
+
+		if err = files.UpdateMeta(fpath, nd.Mode(), nd.ModTime()); err != nil {
+			return err
+		}
+
 		return entries.Err()
 	default:
 		return fmt.Errorf("file type %T at %q is not supported", nd, fpath)

node.go

@@ -7,11 +7,11 @@ import (
 	"os"
 	"path/filepath"
 
-	iface "github.com/ipfs/boxo/coreiface"
-	"github.com/ipfs/boxo/coreiface/options"
 	config "github.com/ipfs/kubo/config"
 	"github.com/ipfs/kubo/core"
 	"github.com/ipfs/kubo/core/coreapi"
+	iface "github.com/ipfs/kubo/core/coreiface"
+	"github.com/ipfs/kubo/core/coreiface/options"
 	"github.com/ipfs/kubo/core/node/libp2p"
 	"github.com/ipfs/kubo/plugin/loader"
 	"github.com/ipfs/kubo/repo/fsrepo"