package storage import ( "archive/zip" "fmt" "io" "io/fs" "os" "path" "path/filepath" "strings" ) // Téléchargement d'un dossier ou d'une sélection en archive ZIP, générée en // flux (aucun fichier temporaire, mémoire constante). // ZipItem est un fichier ou un dossier à archiver : Abs est son chemin sur le // disque, Name son nom dans l'archive. type ZipItem struct { Abs string Name string } // compressed : extensions déjà compressées, stockées sans recompression. var compressed = map[string]bool{ ".zip": true, ".gz": true, ".tgz": true, ".bz2": true, ".xz": true, ".7z": true, ".rar": true, ".zst": true, ".jpg": true, ".jpeg": true, ".png": true, ".gif": true, ".webp": true, ".avif": true, ".heic": true, ".mp3": true, ".aac": true, ".ogg": true, ".opus": true, ".flac": true, ".m4a": true, ".mp4": true, ".mkv": true, ".webm": true, ".mov": true, ".avi": true, ".m4v": true, ".pdf": true, ".docx": true, ".xlsx": true, ".pptx": true, ".odt": true, ".ods": true, ".jar": true, } // ZipItems traduit des chemins virtuels en éléments à archiver ; les doublons // de noms (même nom dans deux dossiers) reçoivent un suffixe « (2) ». Renvoie // aussi un nom d'archive : celui de l'élément unique, sinon « fichiers ». func (u *Space) ZipItems(paths []string) ([]ZipItem, string, error) { if len(paths) == 0 { return nil, "", ErrInvalidPath } var items []ZipItem used := map[string]bool{} for _, p := range paths { st, rel, err := u.route(p) if err != nil { return nil, "", err } c, abs, err := st.resolve(rel) if err != nil { return nil, "", err } name := path.Base(c) if c == "" { name = "fichiers" // racine de l'espace personnel } fi, err := os.Lstat(abs) if err != nil { return nil, "", mapErr(err) } if !fi.IsDir() && !fi.Mode().IsRegular() { return nil, "", ErrNotFound } items = append(items, ZipItem{Abs: abs, Name: uniqueZipName(name, used)}) } archive := "fichiers" if len(items) == 1 { archive = items[0].Name } return items, archive, nil } func uniqueZipName(name string, used map[string]bool) string { n := name for i := 2; used[strings.ToLower(n)]; i++ { ext := path.Ext(name) n = fmt.Sprintf("%s (%d)%s", strings.TrimSuffix(name, ext), i, ext) } used[strings.ToLower(n)] = true return n } // SharedZipItem renvoie l'élément d'un lien de partage (ou d'un de ses // sous-dossiers) à archiver. func (s *Store) SharedZipItem(rel string) (ZipItem, error) { c, abs, err := s.resolve(rel) if err != nil { return ZipItem{}, err } if _, err := os.Lstat(abs); err != nil { return ZipItem{}, mapErr(err) } return ZipItem{Abs: abs, Name: path.Base(c)}, nil } // WriteZip écrit les éléments dans w au format ZIP. Les liens symboliques, les // fichiers spéciaux et les fichiers internes (noms cachés) sont ignorés ; un // fichier illisible est sauté sans interrompre l'archive. func WriteZip(w io.Writer, items []ZipItem) error { zw := zip.NewWriter(w) for _, it := range items { fi, err := os.Lstat(it.Abs) if err != nil { continue } if !fi.IsDir() { if err := addZipFile(zw, it.Abs, it.Name, fi); err != nil { return err } continue } err = filepath.WalkDir(it.Abs, func(p string, d fs.DirEntry, err error) error { if err != nil { return nil } if p != it.Abs && !visible(d.Name()) { if d.IsDir() { return filepath.SkipDir } return nil } rel, _ := filepath.Rel(it.Abs, p) name := it.Name if rel != "." { name = path.Join(it.Name, filepath.ToSlash(rel)) } switch { case d.IsDir(): h := &zip.FileHeader{Name: name + "/", Method: zip.Store} if info, err := d.Info(); err == nil { h.Modified = info.ModTime() } _, err := zw.CreateHeader(h) return err case d.Type().IsRegular(): info, err := d.Info() if err != nil { return nil } return addZipFile(zw, p, name, info) } return nil }) if err != nil { return err } } return zw.Close() } func addZipFile(zw *zip.Writer, abs, name string, fi fs.FileInfo) error { f, err := os.Open(abs) if err != nil { return nil // fichier illisible : sauté } defer f.Close() h := &zip.FileHeader{Name: name, Method: zip.Deflate, Modified: fi.ModTime()} if compressed[strings.ToLower(path.Ext(name))] { h.Method = zip.Store } h.UncompressedSize64 = uint64(fi.Size()) out, err := zw.CreateHeader(h) if err != nil { return err } _, err = io.Copy(out, f) return err }