eed3806efb
Server: list_directory returns a directory_listing (path, home, parent, entries with is_dir/is_git_repo/hidden, truncated) confined to the server user's home subtree after cleaning and resolving symlinks, refusing pseudo filesystems and capping entries at 2000. Documented in docs/cli.md. App: "Choose folder…" in the create dialog opens a picker (full-screen page on phones, large dialog on wide windows, Material and Cupertino) with breadcrumbs, filter, Show hidden, git badges, dimmed files, recent folders, inline errors and "Start chat here". The probe app gains a folder fixture for captures.
201 lines
6.8 KiB
Go
201 lines
6.8 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// directoryListingScanLimit bounds how many names one list_directory reads
|
|
// before sorting, so a huge directory cannot make the server read without end.
|
|
// The reply itself is capped at protocol.DirectoryListingMaxEntries.
|
|
const directoryListingScanLimit = 5 * protocol.DirectoryListingMaxEntries
|
|
|
|
// handleDirectoryListing answers list_directory. It returns true when the
|
|
// request was a list_directory and has been answered.
|
|
func handleDirectoryListing(request protocol.Message, write func(protocol.Message) error) bool {
|
|
if request.Type != protocol.ListDirectory {
|
|
return false
|
|
}
|
|
path := ""
|
|
if request.ListDirectory != nil {
|
|
path = request.ListDirectory.Path
|
|
}
|
|
home, err := OperatorHomeDirectory()
|
|
if err == nil {
|
|
var listing protocol.DirectoryListingResult
|
|
listing, err = listHomeDirectory(home, path, protocol.DirectoryListingMaxEntries)
|
|
if err == nil {
|
|
_ = write(protocol.Message{Type: protocol.DirectoryListing, ID: request.ID, DirectoryListing: &listing})
|
|
return true
|
|
}
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
|
return true
|
|
}
|
|
|
|
// listHomeDirectory lists one directory inside home. The requested path is
|
|
// cleaned and its symlinks resolved before the containment check, so neither
|
|
// ".." nor a symlink can escape home. The listed path is reported under home
|
|
// (as the operator sees it) even when home itself is reached through a link.
|
|
func listHomeDirectory(home, requested string, maxEntries int) (protocol.DirectoryListingResult, error) {
|
|
home = filepath.Clean(home)
|
|
realHome, err := filepath.EvalSymlinks(home)
|
|
if err != nil {
|
|
return protocol.DirectoryListingResult{}, errors.New("resolve home directory: " + err.Error())
|
|
}
|
|
target, err := expandHomePath(home, requested)
|
|
if err != nil {
|
|
return protocol.DirectoryListingResult{}, err
|
|
}
|
|
rel, realTarget, err := resolveInsideHome(realHome, target)
|
|
if err != nil {
|
|
return protocol.DirectoryListingResult{}, err
|
|
}
|
|
shown := filepath.Join(home, rel)
|
|
info, err := os.Stat(realTarget)
|
|
if err != nil {
|
|
return protocol.DirectoryListingResult{}, describePathError(shown, err)
|
|
}
|
|
if !info.IsDir() {
|
|
return protocol.DirectoryListingResult{}, errors.New(shown + " is not a directory")
|
|
}
|
|
if specialFilesystem(realTarget) {
|
|
return protocol.DirectoryListingResult{}, errors.New(shown + " is on a special filesystem and cannot be listed")
|
|
}
|
|
entries, truncated, err := readDirectoryEntries(realHome, realTarget, shown, maxEntries)
|
|
if err != nil {
|
|
return protocol.DirectoryListingResult{}, err
|
|
}
|
|
result := protocol.DirectoryListingResult{Path: shown, Home: home, Entries: entries, Truncated: truncated}
|
|
if rel != "." {
|
|
parent := filepath.Dir(shown)
|
|
result.Parent = &parent
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
// expandHomePath turns "", "~" and "~/sub" into paths under home and requires
|
|
// anything else to be absolute. "~user" forms are refused.
|
|
func expandHomePath(home, requested string) (string, error) {
|
|
requested = strings.TrimSpace(requested)
|
|
switch {
|
|
case requested == "" || requested == "~":
|
|
return home, nil
|
|
case strings.HasPrefix(requested, "~/"):
|
|
return filepath.Join(home, requested[2:]), nil
|
|
case strings.HasPrefix(requested, "~"):
|
|
return "", errors.New("path " + requested + " must be absolute or start with ~/")
|
|
case !filepath.IsAbs(requested):
|
|
return "", errors.New("path " + requested + " must be absolute or start with ~")
|
|
}
|
|
return filepath.Clean(requested), nil
|
|
}
|
|
|
|
// resolveInsideHome resolves every symlink in target and returns its path
|
|
// relative to realHome, refusing anything outside the home subtree.
|
|
func resolveInsideHome(realHome, target string) (string, string, error) {
|
|
realTarget, err := filepath.EvalSymlinks(target)
|
|
if err != nil {
|
|
return "", "", describePathError(target, err)
|
|
}
|
|
rel, ok := relInside(realHome, realTarget)
|
|
if !ok {
|
|
return "", "", errors.New("path " + target + " is outside the home directory " + realHome + "; only folders inside home can be listed")
|
|
}
|
|
return rel, realTarget, nil
|
|
}
|
|
|
|
func relInside(root, path string) (string, bool) {
|
|
rel, err := filepath.Rel(root, path)
|
|
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
|
|
return "", false
|
|
}
|
|
return rel, true
|
|
}
|
|
|
|
func describePathError(path string, err error) error {
|
|
switch {
|
|
case errors.Is(err, fs.ErrPermission):
|
|
return errors.New("permission denied: " + path)
|
|
case errors.Is(err, fs.ErrNotExist):
|
|
return errors.New(path + " does not exist")
|
|
}
|
|
return errors.New(path + " is not available: " + err.Error())
|
|
}
|
|
|
|
// readDirectoryEntries reads at most directoryListingScanLimit names, sorts
|
|
// directories first then case-insensitively, and caps the result. Only names
|
|
// and kinds are read; no file is opened.
|
|
func readDirectoryEntries(realHome, realDir, shown string, maxEntries int) ([]protocol.DirectoryEntry, bool, error) {
|
|
dir, err := os.Open(realDir)
|
|
if err != nil {
|
|
return nil, false, describePathError(shown, err)
|
|
}
|
|
defer dir.Close()
|
|
items, err := dir.ReadDir(directoryListingScanLimit + 1)
|
|
if err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, false, describePathError(shown, err)
|
|
}
|
|
truncated := len(items) > directoryListingScanLimit
|
|
if truncated {
|
|
items = items[:directoryListingScanLimit]
|
|
}
|
|
entries := make([]protocol.DirectoryEntry, 0, len(items))
|
|
for _, item := range items {
|
|
entries = append(entries, describeEntry(realHome, realDir, shown, item))
|
|
}
|
|
sort.SliceStable(entries, func(i, j int) bool {
|
|
a, b := entries[i], entries[j]
|
|
if a.IsDir != b.IsDir {
|
|
return a.IsDir
|
|
}
|
|
la, lb := strings.ToLower(a.Name), strings.ToLower(b.Name)
|
|
if la != lb {
|
|
return la < lb
|
|
}
|
|
return a.Name < b.Name
|
|
})
|
|
if len(entries) > maxEntries {
|
|
entries = entries[:maxEntries]
|
|
truncated = true
|
|
}
|
|
return entries, truncated, nil
|
|
}
|
|
|
|
// describeEntry classifies one name. A symlink counts as a directory only when
|
|
// it resolves to a directory still inside home; one that escapes is shown as a
|
|
// plain, non-selectable name. Devices, sockets and pipes are plain names too.
|
|
func describeEntry(realHome, realDir, shown string, item fs.DirEntry) protocol.DirectoryEntry {
|
|
name := item.Name()
|
|
entry := protocol.DirectoryEntry{Name: name, Path: filepath.Join(shown, name), Hidden: strings.HasPrefix(name, ".")}
|
|
full := filepath.Join(realDir, name)
|
|
switch {
|
|
case item.IsDir():
|
|
entry.IsDir = true
|
|
case item.Type()&fs.ModeSymlink != 0:
|
|
resolved, err := filepath.EvalSymlinks(full)
|
|
if err != nil {
|
|
break
|
|
}
|
|
if _, ok := relInside(realHome, resolved); !ok {
|
|
break
|
|
}
|
|
if info, err := os.Stat(resolved); err == nil && info.IsDir() {
|
|
entry.IsDir = true
|
|
}
|
|
}
|
|
if entry.IsDir {
|
|
if _, err := os.Lstat(filepath.Join(full, ".git")); err == nil {
|
|
entry.IsGitRepo = true
|
|
}
|
|
}
|
|
return entry
|
|
}
|