Files
upandown/internal/api/preview.go
claude BotandClaude Opus 5.5 68885f7e6b Lot 0 : interface Root et lecture en flux, préalable à la racine S3
- storage.File (Read/Seek/Close) remplace *os.File dans Open, OpenVersion
  et l'API (téléchargement, aperçu, liens publics) : un objet S3 lu par
  plages pourra être servi tel quel par http.ServeContent.
- Interface storage.Root (List, Stat, Open, Put, Mkdir, Move, Copy,
  Delete, Remove, Walk), implémentée par Store ; ajout de Store.Walk et
  Store.Remove (suppression définitive).
- Archives ZIP construites via Root (Walk + Open) au lieu de chemins disque.
- transfer : copie en flux entre deux racines quelconques, base des
  déplacements disque <-> S3.
- Aucun changement de comportement ; tests ajoutés (root_test.go).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:09:52 +01:00

304 lines
9.4 KiB
Go

package api
import (
"bytes"
"io"
"io/fs"
"net/http"
"path"
"strconv"
"strings"
"unicode/utf8"
"github.com/vblogio/upandown/internal/storage"
)
// Aperçu en lecture seule, rendu côté client.
//
// GET /api/preview?path=x (même authentification que /api/file)
// GET /api/public/{jeton}/preview?sub=x (même contrôle que /api/public/{jeton}/file)
//
// Seules les extensions de la liste blanche sont servies, toujours en
// Content-Disposition: inline, avec nosniff et une CSP stricte. Le contenu
// texte n'est jamais servi avec un type actif (HTML, XML, JavaScript) : un
// fichier .html part en text/plain et s'affiche comme du code. Le texte est
// plafonné (2 Mo par défaut, réglable) ; au-delà, seul le début est envoyé.
//
// Hors liste blanche, le contenu est reniflé (sniffText) : un fichier lisible
// en texte (.pem, .csr, .crt, fichier sans extension...) est servi en
// text/plain avec les mêmes protections, genre "text" et X-Preview-Detected: 1.
// Les formats exclus (excludedExts) ne sont jamais reniflés.
//
// Réglages de l'administrateur (storage.PreviewSettings) : reniflage actif ou
// non, plafond du texte, extensions toujours en texte, extensions exclues,
// aperçu dans les liens de partage.
//
// En-têtes de réponse : X-Preview-Kind (text, csv, markdown, code, pdf),
// X-Preview-Size (taille réelle du fichier), X-Preview-Truncated (1 si coupé),
// X-Preview-Detected (1 si le genre vient du reniflage du contenu).
// Genres d'aperçu.
const (
PreviewText = "text"
PreviewCSV = "csv"
PreviewMarkdown = "markdown"
PreviewCode = "code"
PreviewPDF = "pdf"
)
// previewExts : liste blanche des extensions prévisualisables.
var previewExts = map[string]string{
".txt": PreviewText, ".log": PreviewText, ".rst": PreviewText, ".srt": PreviewText, ".sub": PreviewText,
".tex": PreviewText, ".bib": PreviewText, ".nfo": PreviewText,
".csv": PreviewCSV, ".tsv": PreviewCSV,
".md": PreviewMarkdown, ".markdown": PreviewMarkdown,
".pdf": PreviewPDF,
}
// previewNames : fichiers sans extension reconnus par leur nom (en minuscules).
var previewNames = map[string]string{
"dockerfile": PreviewCode, "containerfile": PreviewCode, "makefile": PreviewCode,
"jenkinsfile": PreviewCode, "vagrantfile": PreviewCode,
"readme": PreviewText, "license": PreviewText, "changelog": PreviewText,
}
func init() {
for _, e := range strings.Fields(`
.json .jsonc .js .mjs .cjs .jsx .ts .tsx .yaml .yml .toml .ini .conf .cfg .env .properties
.go .py .sh .bash .zsh .ps1 .xml .html .htm .css .scss .less .sql .rs .java .kt .c .h .cpp .hpp
.cs .php .rb .lua .tf .hcl .service .gitignore .dockerignore .diff .patch .vue .svelte`) {
previewExts[e] = PreviewCode
}
}
// excludedExts : formats texte ou binaires exclus de l'aperçu, même reniflés
// (RTF/DOC/DOCX hors périmètre ; SVG servi par /api/file).
var excludedExts = map[string]bool{".rtf": true, ".doc": true, ".docx": true, ".svg": true}
// PreviewKind renvoie le genre d'aperçu d'un fichier d'après son nom ("" :
// hors liste blanche, à renifler sauf extension exclue).
func PreviewKind(name string) string {
base := strings.ToLower(path.Base(name))
if k, ok := previewNames[base]; ok {
return k
}
// Dockerfile.dev, Containerfile.prod...
if strings.HasPrefix(base, "dockerfile.") || strings.HasPrefix(base, "containerfile.") {
return PreviewCode
}
return previewExts[strings.ToLower(path.Ext(base))]
}
// previewType : type MIME servi pour chaque genre. Jamais de type actif.
var previewType = map[string]string{
PreviewText: "text/plain; charset=utf-8",
PreviewCode: "text/plain; charset=utf-8",
PreviewCSV: "text/csv; charset=utf-8",
PreviewMarkdown: "text/markdown; charset=utf-8",
PreviewPDF: "application/pdf",
}
const (
// Texte : récupéré par fetch, jamais affiché en navigation directe comme
// un document actif ; sandbox et aucune sous-ressource.
cspPreviewText = "sandbox; default-src 'none'; frame-ancestors 'none'"
// PDF : affiché par la visionneuse du navigateur dans une iframe de
// l'application. Pas de sandbox (Chrome refuse alors d'afficher le PDF).
cspPreviewPDF = "default-src 'none'; object-src 'self'; frame-ancestors 'self'"
)
func (h *Handler) preview(w http.ResponseWriter, r *http.Request) {
u, ok := h.space(w, r)
if !ok {
return
}
cfg, ok := h.previewSettings(w)
if !ok {
return
}
p := r.URL.Query().Get("path")
if cfg.excluded(p) {
writeErr(w, http.StatusUnsupportedMediaType, "pas d'aperçu pour ce type de fichier")
return
}
f, fi, err := u.Open(p)
if err != nil {
fail(w, err)
return
}
defer f.Close()
h.servePreview(w, r, f, fi, cfg)
}
func (h *Handler) publicPreview(w http.ResponseWriter, r *http.Request) {
_, st, full, _, ok := h.sharedItem(w, r)
if !ok {
return
}
cfg, ok := h.previewSettings(w)
if !ok {
return
}
if !cfg.Shares {
writeErr(w, http.StatusForbidden, "aperçu désactivé pour les liens de partage")
return
}
f, fi, err := st.Open(full)
if err != nil {
fail(w, err)
return
}
defer f.Close()
h.servePreview(w, r, f, fi, cfg)
}
// previewConfig : réglages de l'aperçu (paramètres de l'administrateur).
type previewConfig struct {
storage.PreviewSettings
text, excl map[string]bool // extensions avec le point, en minuscules
}
func (h *Handler) previewSettings(w http.ResponseWriter) (previewConfig, bool) {
st, err := h.Store.ReadSettings()
if err != nil {
fail(w, err)
return previewConfig{}, false
}
c := previewConfig{PreviewSettings: st.Preview, text: map[string]bool{}, excl: map[string]bool{}}
for _, e := range st.Preview.TextExts {
c.text["."+e] = true
}
for _, e := range st.Preview.ExcludedExts {
c.excl["."+e] = true
}
return c, true
}
// excluded : extension exclue d'office (RTF, DOC...) ou par l'administrateur.
func (c previewConfig) excluded(name string) bool {
e := strings.ToLower(path.Ext(name))
return excludedExts[e] || c.excl[e]
}
// kind : genre d'après le nom (liste blanche, puis extensions texte de l'administrateur).
func (c previewConfig) kind(name string) string {
if k := PreviewKind(name); k != "" {
return k
}
if c.text[strings.ToLower(path.Ext(name))] {
return PreviewText
}
return ""
}
func (c previewConfig) maxText() int64 {
if c.MaxTextMB < 1 {
return int64(storage.DefaultPreview.MaxTextMB) << 20
}
return int64(c.MaxTextMB) << 20
}
func (h *Handler) servePreview(w http.ResponseWriter, r *http.Request, f storage.File, fi fs.FileInfo, cfg previewConfig) {
name := fi.Name()
kind := cfg.kind(name)
if fi.IsDir() || cfg.excluded(name) || (kind == "" && !cfg.Sniff) {
writeErr(w, http.StatusUnsupportedMediaType, "pas d'aperçu pour ce type de fichier")
return
}
detected := false
if kind == "" {
head := make([]byte, sniffLen)
n, _ := io.ReadFull(f, head)
if !sniffText(head[:n], int64(n) < fi.Size()) {
writeErr(w, http.StatusUnsupportedMediaType, "pas d'aperçu pour ce type de fichier")
return
}
if _, err := f.Seek(0, io.SeekStart); err != nil {
fail(w, err)
return
}
kind, detected = PreviewText, true
}
hd := w.Header()
hd.Set("Content-Type", previewType[kind])
hd.Set("Content-Disposition", contentDisposition(true, name))
hd.Set("X-Content-Type-Options", "nosniff")
hd.Set("Cache-Control", "private, no-cache")
hd.Set("ETag", storage.ETag(fi))
hd.Set("X-Preview-Kind", kind)
hd.Set("X-Preview-Size", strconv.FormatInt(fi.Size(), 10))
hd.Set("X-Preview-Detected", map[bool]string{true: "1", false: "0"}[detected])
if kind == PreviewPDF {
hd.Set("Content-Security-Policy", cspPreviewPDF)
hd.Set("X-Preview-Truncated", "0")
http.ServeContent(w, r, name, fi.ModTime(), f)
return
}
hd.Set("Content-Security-Policy", cspPreviewText)
max := cfg.maxText()
if h.PreviewMaxText > 0 { // tests
max = h.PreviewMaxText
}
b, err := io.ReadAll(io.LimitReader(f, max))
if err != nil {
fail(w, err)
return
}
truncated := fi.Size() > int64(len(b))
if truncated {
b = trimPartialRune(b)
}
if bytes.IndexByte(b[:min(len(b), 8192)], 0) >= 0 {
hd.Del("Content-Disposition")
writeErr(w, http.StatusUnsupportedMediaType, "contenu binaire : pas d'aperçu")
return
}
hd.Set("X-Preview-Truncated", map[bool]string{true: "1", false: "0"}[truncated])
// L'ETag désigne le fichier : il reste valable pour l'extrait tant que le
// plafond ne change pas. Pas de Range sur un extrait.
r.Header.Del("Range")
http.ServeContent(w, r, name, fi.ModTime(), bytes.NewReader(b))
}
// sniffLen : octets examinés pour reconnaître un fichier texte.
const sniffLen = 8192
// sniffText indique si un début de fichier est du texte lisible : UTF-8 valide
// (un caractère coupé en fin d'échantillon est toléré si partial), aucun octet
// NUL, et au plus 1 % de caractères de contrôle hors \t \n \r \f et ESC.
// Un fichier vide est du texte.
func sniffText(b []byte, partial bool) bool {
if partial {
b = trimPartialRune(b)
}
if !utf8.Valid(b) || bytes.IndexByte(b, 0) >= 0 {
return false
}
ctrl := 0
for _, c := range b {
if (c < 0x20 && c != '\t' && c != '\n' && c != '\r' && c != '\f' && c != 0x1b) || c == 0x7f {
ctrl++
}
}
return ctrl*100 <= len(b)
}
// trimPartialRune retire un caractère UTF-8 coupé en fin d'extrait.
func trimPartialRune(b []byte) []byte {
for i := 1; i <= utf8.UTFMax && i <= len(b); i++ {
c := b[len(b)-i]
if c < 0x80 { // ASCII : rien de coupé
return b
}
if utf8.RuneStart(c) {
if r, _ := utf8.DecodeRune(b[len(b)-i:]); r == utf8.RuneError {
return b[:len(b)-i]
}
return b
}
}
return b
}