// Package storage gère l'arborescence de fichiers sur disque. // // Tous les chemins manipulés par l'API sont relatifs à la racine (DATA_DIR), // au format "slash" (a/b/rapport.pdf). Le package garantit qu'aucun chemin ne // sort de la racine, y compris via un lien symbolique, et que les fichiers // internes (noms commençant par un point : .trash, .history, .meta.json...) // ne sont jamais exposés. package storage import ( "crypto/sha256" "encoding/hex" "errors" "fmt" "io" "io/fs" "os" "path" "path/filepath" "strconv" "strings" "sync" "time" "unicode/utf8" ) const ( trashDir = ".trash" thumbsDir = ".thumbs" // MaxNameLen borne la longueur d'un nom de fichier ou de dossier (octets). MaxNameLen = 255 ) var ( ErrNotFound = errors.New("introuvable") ErrExists = errors.New("existe déjà") ErrInvalidPath = errors.New("chemin invalide") ErrConflict = errors.New("le fichier a été modifié entre-temps") ErrNotEmpty = errors.New("dossier non vide") ErrForbidden = errors.New("action non autorisée") ErrQuota = errors.New("quota de stockage dépassé") ErrTooLarge = errors.New("fichier trop volumineux") ) // Entry décrit un élément de l'arborescence. type Entry struct { Name string `json:"name"` Path string `json:"path"` IsDir bool `json:"isDir"` Size int64 `json:"size"` ModTime time.Time `json:"modTime"` Tags []string `json:"tags,omitempty"` Favorite bool `json:"favorite,omitempty"` Icon string `json:"icon,omitempty"` // dossier : icône choisie (meta.go) EditedBy string `json:"editedBy,omitempty"` // fichier : dernier utilisateur à l'avoir déposé // Détails (details.go), seulement sur demande (/api/list?details=1). Details *Details `json:"details,omitempty"` // Dossiers virtuels et favoris (spaces.go). Special string `json:"special,omitempty"` // "favoris", "perso" ou "poubelle" : entrée de la racine Link string `json:"link,omitempty"` // nom du lien dans le dossier Favoris Broken bool `json:"broken,omitempty"` // favori dont l'élément d'origine a disparu // Poubelle (trash.go, spaces.go). Count int `json:"count,omitempty"` // entrée « poubelle » de la racine : nombre d'éléments Origin string `json:"origin,omitempty"` // élément de la poubelle : chemin d'origine By string `json:"by,omitempty"` // élément de la poubelle : supprimé par } // Store est un dépôt de fichiers enraciné dans un répertoire. type Store struct { root string // History règle l'historique des versions (DefaultHistory par défaut). History HistoryPolicy // Defaults : valeurs des paramètres tant que l'administrateur ne les a pas // modifiés (variables d'environnement, voir settings.go). Defaults SettingsDefaults settingsMu sync.Mutex // sérialise les lectures-modifications de .settings.json index textIndex // texte des fichiers pour la recherche (search.go) thumbSem chan struct{} metaMu sync.Mutex // tags, favoris, auteurs (meta.go) meta map[string]itemMeta // nil : pas encore chargé sharesMu sync.Mutex // liens de partage (share.go) shareKey []byte // clé HMAC ; nil : pas encore chargée fixedKey bool // clé imposée par SHARE_SECRET keyFrom *Store // espace personnel : clé de signature du Store principal usageMu sync.Mutex usageAt time.Time usageSize int64 } // New crée le répertoire racine si besoin et renvoie un Store. func New(root string) (*Store, error) { abs, err := filepath.Abs(root) if err != nil { return nil, err } if err := os.MkdirAll(abs, 0o755); err != nil { return nil, err } // Résout un éventuel lien symbolique sur la racine elle-même pour que // les comparaisons de préfixe soient fiables. if abs, err = filepath.EvalSymlinks(abs); err != nil { return nil, err } return &Store{root: abs, History: DefaultHistory, Defaults: DefaultSettings, thumbSem: make(chan struct{}, 2)}, nil } // Clean normalise un chemin relatif : "/a/../b/" -> "b", "" -> "". // Les composants cachés (".trash", ".git"...), les caractères de contrôle et // les noms trop longs sont refusés. func Clean(rel string) (string, error) { if strings.ContainsRune(rel, 0) || strings.Contains(rel, `\`) || !utf8.ValidString(rel) { return "", ErrInvalidPath } c := strings.TrimPrefix(path.Clean("/"+rel), "/") if c == "" { return "", nil } for _, part := range strings.Split(c, "/") { if strings.HasPrefix(part, ".") || len(part) > MaxNameLen || strings.TrimSpace(part) != part { return "", ErrInvalidPath } for _, r := range part { if r < 0x20 || r == 0x7f { return "", ErrInvalidPath } } } return c, nil } // resolve convertit un chemin relatif en chemin absolu sous la racine et // vérifie que l'ancêtre existant le plus proche ne s'échappe pas via symlink // et ne mène pas à un répertoire interne. func (s *Store) resolve(rel string) (string, string, error) { c, err := Clean(rel) if err != nil { return "", "", err } abs := filepath.Join(s.root, filepath.FromSlash(c)) probe := abs for { real, err := filepath.EvalSymlinks(probe) if err == nil { if real != s.root && !strings.HasPrefix(real, s.root+string(os.PathSeparator)) { return "", "", ErrInvalidPath } if real != s.root { inner, _ := filepath.Rel(s.root, real) for _, part := range strings.Split(filepath.ToSlash(inner), "/") { if strings.HasPrefix(part, ".") { return "", "", ErrInvalidPath } } } break } if !errors.Is(err, fs.ErrNotExist) { return "", "", err } parent := filepath.Dir(probe) if parent == probe { return "", "", ErrInvalidPath } probe = parent } return c, abs, nil } func mapErr(err error) error { switch { case err == nil: return nil case errors.Is(err, fs.ErrNotExist): return ErrNotFound case errors.Is(err, fs.ErrExist): return ErrExists } return err } func toEntry(rel string, fi fs.FileInfo) Entry { e := Entry{ Name: fi.Name(), Path: rel, IsDir: fi.IsDir(), Size: fi.Size(), ModTime: fi.ModTime().UTC(), } if e.IsDir { e.Size = 0 } return e } func visible(name string) bool { return !strings.HasPrefix(name, ".") } // List renvoie le contenu d'un dossier : dossiers d'abord, puis fichiers, // triés par nom (insensible à la casse). func (s *Store) List(rel string) ([]Entry, error) { c, abs, err := s.resolve(rel) if err != nil { return nil, err } des, err := os.ReadDir(abs) if err != nil { if errors.Is(err, fs.ErrNotExist) || strings.Contains(err.Error(), "not a directory") { return nil, ErrNotFound } return nil, mapErr(err) } out := make([]Entry, 0, len(des)) meta := s.metaSnapshot() for _, de := range des { if !visible(de.Name()) || de.Type()&fs.ModeSymlink != 0 { continue } fi, err := de.Info() if err != nil { continue } if !fi.IsDir() && !fi.Mode().IsRegular() { continue } e := toEntry(path.Join(c, de.Name()), fi) decorate(&e, meta) out = append(out, e) } sortEntries(out) return out, nil } // Stat décrit un fichier ou un dossier. func (s *Store) Stat(rel string) (Entry, error) { c, abs, err := s.resolve(rel) if err != nil { return Entry{}, err } fi, err := os.Lstat(abs) if err != nil { return Entry{}, mapErr(err) } if fi.Mode()&fs.ModeSymlink != 0 { return Entry{}, ErrNotFound } e := toEntry(c, fi) decorate(&e, s.metaSnapshot()) return e, nil } // ETag calcule l'empreinte faible d'un fichier (taille et date de modification). func ETag(fi fs.FileInfo) string { return `W/"` + strconv.FormatInt(fi.Size(), 36) + "-" + strconv.FormatInt(fi.ModTime().UnixNano(), 36) + `"` } // Open ouvre un fichier en lecture. Les liens symboliques sont refusés. func (s *Store) Open(rel string) (File, fs.FileInfo, error) { c, abs, err := s.resolve(rel) if err != nil { return nil, nil, err } if c == "" { return nil, nil, ErrInvalidPath } fi, err := os.Lstat(abs) if err != nil { return nil, nil, mapErr(err) } if !fi.Mode().IsRegular() { return nil, nil, ErrNotFound } f, err := os.Open(abs) if err != nil { return nil, nil, mapErr(err) } if fi, err = f.Stat(); err != nil { f.Close() return nil, nil, err } return f, fi, nil } // PutOptions règle l'écriture d'un fichier (Put). type PutOptions struct { // Conflict : conduite si le fichier existe. "" ou "fail" : ErrExists ; // "overwrite" : remplacement (la version précédente part dans l'historique) ; // "rename" : le nouveau fichier prend un nom libre « nom (2).ext ». Conflict string // IfMatch : ETag attendu du fichier remplacé (ErrConflict sinon) ; vide : pas de contrôle. IfMatch string // Limit : nombre maximal d'octets acceptés (0 : illimité) ; LimitErr est // renvoyée s'il est dépassé (ErrTooLarge ou ErrQuota). Limit int64 LimitErr error // ModTime : date de modification à donner au fichier (zéro : maintenant). ModTime time.Time // By : utilisateur qui dépose le fichier (auteur et dernier auteur). By string } // Put écrit un fichier de façon atomique et en flux (fichier temporaire dans // le dossier cible, fsync, rename) : un envoi interrompu ne laisse rien. Les // dossiers parents sont créés. Renvoie l'entrée écrite (son chemin peut // différer de rel avec Conflict = "rename"). func (s *Store) Put(rel string, r io.Reader, o PutOptions) (Entry, error) { c, abs, err := s.resolve(rel) if err != nil { return Entry{}, err } if c == "" { return Entry{}, ErrInvalidPath } fi, err := os.Lstat(abs) exists := err == nil if err != nil && !errors.Is(err, fs.ErrNotExist) { return Entry{}, mapErr(err) } if exists { if fi.IsDir() { return Entry{}, fmt.Errorf("%w : un dossier porte déjà ce nom", ErrExists) } switch o.Conflict { case "overwrite": if o.IfMatch != "" && o.IfMatch != "*" && o.IfMatch != ETag(fi) { return Entry{}, ErrConflict } case "rename": c = s.freeName(c, false, " (%d)") if _, abs, err = s.resolve(c); err != nil { return Entry{}, err } exists = false default: return Entry{}, ErrExists } } else if o.IfMatch != "" && o.IfMatch != "*" { return Entry{}, ErrConflict } // Un composant du chemin ne doit pas être un fichier. if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil { if errors.Is(err, fs.ErrExist) || strings.Contains(err.Error(), "not a directory") { return Entry{}, fmt.Errorf("%w : un fichier porte le nom d'un dossier du chemin", ErrExists) } return Entry{}, err } tmp, err := os.CreateTemp(filepath.Dir(abs), ".tmp-*") if err != nil { return Entry{}, err } defer os.Remove(tmp.Name()) // no-op après un rename réussi src := r if o.Limit > 0 { src = io.LimitReader(r, o.Limit+1) } n, err := io.Copy(tmp, src) if err != nil { tmp.Close() return Entry{}, err } if o.Limit > 0 && n > o.Limit { tmp.Close() if o.LimitErr != nil { return Entry{}, o.LimitErr } return Entry{}, ErrTooLarge } if err := tmp.Sync(); err != nil { tmp.Close() return Entry{}, err } if err := tmp.Close(); err != nil { return Entry{}, err } if err := os.Chmod(tmp.Name(), 0o644); err != nil { return Entry{}, err } if m := o.ModTime; !m.IsZero() && m.After(time.Date(1980, 1, 1, 0, 0, 0, 0, time.UTC)) && m.Before(time.Now().Add(24*time.Hour)) { _ = os.Chtimes(tmp.Name(), m, m) } if exists { s.autoSnapshot(c, abs, fi) } if err := os.Rename(tmp.Name(), abs); err != nil { return Entry{}, err } s.usageDirty() s.removeThumb(c) s.noteEdit(c, o.By, !exists) nfi, err := os.Stat(abs) if err != nil { return Entry{}, err } e := toEntry(c, nfi) e.EditedBy = o.By return e, nil } // Mkdir crée un dossier (et ses parents). func (s *Store) Mkdir(rel string) (Entry, error) { c, abs, err := s.resolve(rel) if err != nil { return Entry{}, err } if c == "" { return Entry{}, ErrInvalidPath } if _, err := os.Lstat(abs); err == nil { return Entry{}, ErrExists } if err := os.MkdirAll(abs, 0o755); err != nil { if strings.Contains(err.Error(), "not a directory") { return Entry{}, fmt.Errorf("%w : un fichier porte le nom d'un dossier du chemin", ErrExists) } return Entry{}, mapErr(err) } fi, err := os.Stat(abs) if err != nil { return Entry{}, err } return toEntry(c, fi), nil } // Move renomme ou déplace un fichier ou un dossier. La destination ne doit // pas exister ; un dossier ne peut pas être déplacé dans lui-même. func (s *Store) Move(from, to string) (Entry, error) { cf, af, err := s.resolve(from) if err != nil { return Entry{}, err } ct, at, err := s.resolve(to) if err != nil { return Entry{}, err } if cf == "" || ct == "" { return Entry{}, ErrInvalidPath } fi, err := os.Lstat(af) if err != nil { return Entry{}, mapErr(err) } if fi.IsDir() && (ct == cf || strings.HasPrefix(ct, cf+"/")) { return Entry{}, fmt.Errorf("%w : déplacement d'un dossier dans lui-même", ErrInvalidPath) } if _, err := os.Lstat(at); err == nil { // Renommage qui ne change que la casse (volume insensible à la casse). if !strings.EqualFold(cf, ct) || cf == ct { return Entry{}, ErrExists } } if err := os.MkdirAll(filepath.Dir(at), 0o755); err != nil { return Entry{}, err } if err := os.Rename(af, at); err != nil { return Entry{}, mapErr(err) } s.moveThumb(cf, ct, fi.IsDir()) s.moveHistory(cf, ct) s.moveMeta(cf, ct) s.moveShares(cf, ct) fi, err = os.Stat(at) if err != nil { return Entry{}, err } e := toEntry(ct, fi) decorate(&e, s.metaSnapshot()) return e, nil } // MoveResult est le résultat d'un déplacement unitaire dans MoveMany. type MoveResult struct { From string `json:"from"` To string `json:"to,omitempty"` Error string `json:"error,omitempty"` err error } // Err renvoie l'erreur du déplacement (nil si réussi). func (r MoveResult) Err() error { return r.err } // Copy duplique un fichier, ou un dossier avec tout son contenu (fichiers // réguliers seulement). Les tags sont copiés, pas les favoris ni les partages. func (s *Store) Copy(from, to string) (Entry, error) { cf, af, err := s.resolve(from) if err != nil { return Entry{}, err } ct, at, err := s.resolve(to) if err != nil { return Entry{}, err } if cf == "" || ct == "" { return Entry{}, ErrInvalidPath } fi, err := os.Lstat(af) if err != nil { return Entry{}, mapErr(err) } if _, err := os.Lstat(at); err == nil { return Entry{}, ErrExists } if fi.IsDir() { if ct == cf || strings.HasPrefix(ct, cf+"/") { return Entry{}, fmt.Errorf("%w : copie d'un dossier dans lui-même", ErrInvalidPath) } err = copyTree(af, at) } else if fi.Mode().IsRegular() { err = copyFile(af, at) } else { return Entry{}, ErrNotFound } if err != nil { _ = os.RemoveAll(at) return Entry{}, err } s.usageDirty() s.copyMeta(cf, ct) nfi, err := os.Stat(at) if err != nil { return Entry{}, err } return toEntry(ct, nfi), nil } func copyFile(src, dst string) error { in, err := os.Open(src) if err != nil { return err } defer in.Close() fi, err := in.Stat() if err != nil { return err } if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil { return err } tmp, err := os.CreateTemp(filepath.Dir(dst), ".tmp-*") if err != nil { return err } defer os.Remove(tmp.Name()) if _, err := io.Copy(tmp, in); err != nil { tmp.Close() return err } if err := tmp.Sync(); err != nil { tmp.Close() return err } if err := tmp.Close(); err != nil { return err } _ = os.Chmod(tmp.Name(), 0o644) _ = os.Chtimes(tmp.Name(), fi.ModTime(), fi.ModTime()) return os.Rename(tmp.Name(), dst) } func copyTree(src, dst string) error { return filepath.WalkDir(src, func(p string, d fs.DirEntry, err error) error { if err != nil { return err } rel, _ := filepath.Rel(src, p) target := filepath.Join(dst, rel) switch { case d.IsDir(): return os.MkdirAll(target, 0o755) case d.Type().IsRegular() && visible(d.Name()): return copyFile(p, target) } return nil // liens, fichiers spéciaux et fichiers internes ignorés }) } // Delete déplace un fichier ou un dossier dans la corbeille (.trash/, voir // trash.go), sans suppression physique. Un dossier non vide n'est supprimé que // si recursive. func (s *Store) Delete(rel string, recursive bool) error { return s.deleteAs(rel, recursive, "") } // deleteAs est Delete en notant l'auteur de la suppression (by). func (s *Store) deleteAs(rel string, recursive bool, by string) error { c, abs, err := s.resolve(rel) if err != nil { return err } if c == "" { return ErrInvalidPath } fi, err := os.Lstat(abs) if err != nil { return mapErr(err) } if fi.IsDir() && !recursive { des, err := os.ReadDir(abs) if err != nil { return err } if len(des) > 0 { return ErrNotEmpty } } if err := s.trash(c, abs, by); err != nil { return err } s.removeThumb(c) s.removeShares(c) return nil } // freeName renvoie c s'il est libre, sinon « nom (2).ext », « nom (3).ext »... // (format : suffixe avec %d) ; les dossiers n'ont pas d'extension. func (s *Store) freeName(c string, isDir bool, format string) string { if _, err := os.Lstat(absOf(s, c)); errors.Is(err, fs.ErrNotExist) { return c } dir, base, ext := path.Dir(c), path.Base(c), "" if !isDir { ext = path.Ext(base) base = strings.TrimSuffix(base, ext) } for i := 2; ; i++ { n := base + fmt.Sprintf(format, i) + ext if dir != "." { n = dir + "/" + n } if _, err := os.Lstat(absOf(s, n)); errors.Is(err, fs.ErrNotExist) { return n } } } // --- Occupation disque ------------------------------------------------------------- func (s *Store) usageDirty() { s.usageMu.Lock() s.usageAt = time.Time{} s.usageMu.Unlock() } // Usage renvoie le nombre d'octets occupés (fichiers, corbeille et historique // compris ; miniatures exclues). Le résultat est gardé 15 s, ou jusqu'à la // prochaine écriture. func (s *Store) Usage() int64 { s.usageMu.Lock() defer s.usageMu.Unlock() if time.Since(s.usageAt) < 15*time.Second { return s.usageSize } var total int64 _ = filepath.WalkDir(s.root, func(p string, d fs.DirEntry, err error) error { if err != nil { return nil } if d.IsDir() && p != s.root && d.Name() == thumbsDir { return filepath.SkipDir } if d.Type().IsRegular() { if fi, err := d.Info(); err == nil { total += fi.Size() } } return nil }) s.usageSize, s.usageAt = total, time.Now() return total } // fileID : empreinte courte d'une chaîne (noms de fichiers dérivés). func fileID(s string) string { h := sha256.Sum256([]byte(s)) return hex.EncodeToString(h[:8]) } // atomicWrite écrit data dans abs de façon atomique (fichier temporaire + rename). func atomicWrite(abs string, data []byte) error { tmp, err := os.CreateTemp(filepath.Dir(abs), ".tmp-*") if err != nil { return err } defer os.Remove(tmp.Name()) // no-op après un rename réussi if _, err := tmp.Write(data); err != nil { tmp.Close() return err } if err := tmp.Sync(); err != nil { tmp.Close() return err } if err := tmp.Close(); err != nil { return err } if err := os.Chmod(tmp.Name(), 0o644); err != nil { return err } return os.Rename(tmp.Name(), abs) }