| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240 |
- package cfbrowser
- import (
- "bytes"
- "clusterflow.dev/cfbrowser/internal/capture"
- "context"
- "crypto/sha256"
- "encoding/hex"
- "errors"
- "io"
- "mime"
- "os"
- "path/filepath"
- "sort"
- "strings"
- "clusterflow.dev/cfbrowser/api"
- )
- type storedFile struct {
- info api.FileInfo
- name string
- }
- func (m *Manager) store(s *session, name, mimeType string, r io.Reader, max int64) (api.FileInfo, error) {
- s.mu.Lock()
- defer s.mu.Unlock()
- if s.closed {
- return api.FileInfo{}, api.Err("BROWSER_CLOSED", "session is closed")
- }
- if len(s.files) >= 64 {
- return api.FileInfo{}, api.Err("BROWSER_LIMIT", "file quota reached")
- }
- root, err := os.OpenRoot(s.downloadDir)
- if err != nil {
- return api.FileInfo{}, err
- }
- defer root.Close()
- id := newID("file-")
- f, err := root.OpenFile(id, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
- if err != nil {
- return api.FileInfo{}, err
- }
- hash := sha256.New()
- n, err := io.Copy(io.MultiWriter(f, hash), io.LimitReader(r, max+1))
- err = errors.Join(err, f.Close())
- if err != nil || n > max {
- _ = root.Remove(id)
- if err != nil {
- return api.FileInfo{}, err
- }
- return api.FileInfo{}, api.Err("BROWSER_DOWNLOAD_LIMIT", "file exceeds configured limit")
- }
- info := api.FileInfo{ID: id, Name: safeName(name), MIME: mimeType, Size: n, SHA256: hex.EncodeToString(hash.Sum(nil))}
- s.files[id] = storedFile{info: info, name: id}
- return info, nil
- }
- func safeName(s string) string {
- s = filepath.Base(strings.ReplaceAll(s, "\\", "/"))
- s = strings.Map(func(r rune) rune {
- if r < 32 || r == 127 {
- return -1
- }
- return r
- }, s)
- if s == "" || s == "." || s == ".." {
- return "download.bin"
- }
- return truncate(s, 200)
- }
- func (m *Manager) Capture(ctx context.Context, o api.Owner, sid, pid string) (api.FileInfo, error) {
- return m.CapturePage(ctx, o, sid, pid, false)
- }
- // CapturePage captures a viewport or a bounded full document without scrolling.
- func (m *Manager) CapturePage(ctx context.Context, o api.Owner, sid, pid string, fullPage bool) (api.FileInfo, error) {
- ctx, cancel := m.operation(ctx)
- defer cancel()
- p, unlock, err := m.lockedPage(ctx, o, sid, pid)
- if err != nil {
- return api.FileInfo{}, err
- }
- defer unlock()
- var data []byte
- if fullPage {
- engine, ok := p.engine.(api.FullPageCapturer)
- if !ok {
- return api.FileInfo{}, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "full-page capture is unavailable")
- }
- data, err = engine.CaptureFullPage(ctx)
- } else {
- data, err = p.engine.Capture(ctx)
- }
- if err != nil {
- return api.FileInfo{}, err
- }
- if err = capture.Validate(data); err != nil {
- return api.FileInfo{}, err
- }
- s, err := m.owned(o, sid)
- if err != nil {
- return api.FileInfo{}, err
- }
- return m.store(s, "screenshot.png", "clusterflow.dev/cfbrowser/internal/capture", bytes.NewReader(data), 4*1024*1024)
- }
- // Files imports completed engine downloads and returns metadata without disk paths.
- func (m *Manager) Files(ctx context.Context, o api.Owner, sid string) ([]api.FileInfo, error) {
- s, err := m.owned(o, sid)
- if err != nil {
- return nil, err
- }
- for _, d := range s.engine.Downloads() {
- if err = ctx.Err(); err != nil {
- return nil, err
- }
- if d.State != "completed" {
- continue
- }
- s.mu.Lock()
- already := s.imported[d.ID]
- if !already {
- s.imported[d.ID] = true
- }
- s.mu.Unlock()
- if already {
- continue
- }
- root, e := os.OpenRoot(s.downloadDir)
- if e != nil {
- return nil, e
- }
- f, e := root.Open(filepath.Base(d.Path))
- if e != nil {
- root.Close()
- s.mu.Lock()
- delete(s.imported, d.ID)
- s.mu.Unlock()
- return nil, e
- }
- _, e = m.store(s, d.Name, mime.TypeByExtension(filepath.Ext(d.Name)), f, m.cfg.MaxDownloadBytes)
- f.Close()
- root.Close()
- if e != nil {
- s.mu.Lock()
- delete(s.imported, d.ID)
- s.mu.Unlock()
- return nil, e
- }
- }
- s.mu.Lock()
- defer s.mu.Unlock()
- out := make([]api.FileInfo, 0, len(s.files))
- for _, f := range s.files {
- out = append(out, f.info)
- }
- sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
- return out, nil
- }
- // Export requires a host-authorized destination root and never overwrites files.
- func (m *Manager) Export(ctx context.Context, o api.Owner, sid, fileID, destinationRoot, relative string) (api.FileInfo, error) {
- if !filepath.IsLocal(relative) || strings.Contains(relative, "\\") || strings.ContainsRune(relative, 0) {
- return api.FileInfo{}, api.Err("BROWSER_PATH_BLOCKED", "destination must be a local relative path")
- }
- for _, part := range strings.Split(filepath.ToSlash(relative), "/") {
- if part == ".." || part == "." || part == "" {
- return api.FileInfo{}, api.Err("BROWSER_PATH_BLOCKED", "invalid destination component")
- }
- }
- s, err := m.owned(o, sid)
- if err != nil {
- return api.FileInfo{}, err
- }
- s.mu.Lock()
- f, ok := s.files[fileID]
- closed := s.closed
- s.mu.Unlock()
- if !ok || closed {
- return api.FileInfo{}, api.Err("BROWSER_FILE_NOT_FOUND", "file is unavailable")
- }
- if err = ctx.Err(); err != nil {
- return api.FileInfo{}, err
- }
- srcRoot, err := os.OpenRoot(s.downloadDir)
- if err != nil {
- return api.FileInfo{}, err
- }
- defer srcRoot.Close()
- src, err := srcRoot.Open(f.name)
- if err != nil {
- return api.FileInfo{}, err
- }
- defer src.Close()
- dstRoot, err := os.OpenRoot(destinationRoot)
- if err != nil {
- return api.FileInfo{}, err
- }
- defer dstRoot.Close()
- dst, err := dstRoot.OpenFile(relative, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
- if err != nil {
- return api.FileInfo{}, err
- }
- _, err = copyContext(ctx, dst, src)
- err = errors.Join(err, dst.Close())
- if err != nil {
- _ = dstRoot.Remove(relative)
- return api.FileInfo{}, err
- }
- return f.info, nil
- }
- func copyContext(ctx context.Context, w io.Writer, r io.Reader) (int64, error) {
- buf := make([]byte, 32*1024)
- var total int64
- for {
- if err := ctx.Err(); err != nil {
- return total, err
- }
- n, err := r.Read(buf)
- if n > 0 {
- written, e := w.Write(buf[:n])
- total += int64(written)
- if e != nil {
- return total, e
- }
- if written != n {
- return total, io.ErrShortWrite
- }
- }
- if err == io.EOF {
- return total, nil
- }
- if err != nil {
- return total, err
- }
- }
- }
|