files.go 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  1. package cfbrowser
  2. import (
  3. "bytes"
  4. "clusterflow.dev/cfbrowser/internal/capture"
  5. "context"
  6. "crypto/sha256"
  7. "encoding/hex"
  8. "errors"
  9. "io"
  10. "mime"
  11. "os"
  12. "path/filepath"
  13. "sort"
  14. "strings"
  15. "clusterflow.dev/cfbrowser/api"
  16. )
  17. type storedFile struct {
  18. info api.FileInfo
  19. name string
  20. }
  21. func (m *Manager) store(s *session, name, mimeType string, r io.Reader, max int64) (api.FileInfo, error) {
  22. s.mu.Lock()
  23. defer s.mu.Unlock()
  24. if s.closed {
  25. return api.FileInfo{}, api.Err("BROWSER_CLOSED", "session is closed")
  26. }
  27. if len(s.files) >= 64 {
  28. return api.FileInfo{}, api.Err("BROWSER_LIMIT", "file quota reached")
  29. }
  30. root, err := os.OpenRoot(s.downloadDir)
  31. if err != nil {
  32. return api.FileInfo{}, err
  33. }
  34. defer root.Close()
  35. id := newID("file-")
  36. f, err := root.OpenFile(id, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
  37. if err != nil {
  38. return api.FileInfo{}, err
  39. }
  40. hash := sha256.New()
  41. n, err := io.Copy(io.MultiWriter(f, hash), io.LimitReader(r, max+1))
  42. err = errors.Join(err, f.Close())
  43. if err != nil || n > max {
  44. _ = root.Remove(id)
  45. if err != nil {
  46. return api.FileInfo{}, err
  47. }
  48. return api.FileInfo{}, api.Err("BROWSER_DOWNLOAD_LIMIT", "file exceeds configured limit")
  49. }
  50. info := api.FileInfo{ID: id, Name: safeName(name), MIME: mimeType, Size: n, SHA256: hex.EncodeToString(hash.Sum(nil))}
  51. s.files[id] = storedFile{info: info, name: id}
  52. return info, nil
  53. }
  54. func safeName(s string) string {
  55. s = filepath.Base(strings.ReplaceAll(s, "\\", "/"))
  56. s = strings.Map(func(r rune) rune {
  57. if r < 32 || r == 127 {
  58. return -1
  59. }
  60. return r
  61. }, s)
  62. if s == "" || s == "." || s == ".." {
  63. return "download.bin"
  64. }
  65. return truncate(s, 200)
  66. }
  67. func (m *Manager) Capture(ctx context.Context, o api.Owner, sid, pid string) (api.FileInfo, error) {
  68. return m.CapturePage(ctx, o, sid, pid, false)
  69. }
  70. // CapturePage captures a viewport or a bounded full document without scrolling.
  71. func (m *Manager) CapturePage(ctx context.Context, o api.Owner, sid, pid string, fullPage bool) (api.FileInfo, error) {
  72. ctx, cancel := m.operation(ctx)
  73. defer cancel()
  74. p, unlock, err := m.lockedPage(ctx, o, sid, pid)
  75. if err != nil {
  76. return api.FileInfo{}, err
  77. }
  78. defer unlock()
  79. var data []byte
  80. if fullPage {
  81. engine, ok := p.engine.(api.FullPageCapturer)
  82. if !ok {
  83. return api.FileInfo{}, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "full-page capture is unavailable")
  84. }
  85. data, err = engine.CaptureFullPage(ctx)
  86. } else {
  87. data, err = p.engine.Capture(ctx)
  88. }
  89. if err != nil {
  90. return api.FileInfo{}, err
  91. }
  92. if err = capture.Validate(data); err != nil {
  93. return api.FileInfo{}, err
  94. }
  95. s, err := m.owned(o, sid)
  96. if err != nil {
  97. return api.FileInfo{}, err
  98. }
  99. return m.store(s, "screenshot.png", "clusterflow.dev/cfbrowser/internal/capture", bytes.NewReader(data), 4*1024*1024)
  100. }
  101. // Files imports completed engine downloads and returns metadata without disk paths.
  102. func (m *Manager) Files(ctx context.Context, o api.Owner, sid string) ([]api.FileInfo, error) {
  103. s, err := m.owned(o, sid)
  104. if err != nil {
  105. return nil, err
  106. }
  107. for _, d := range s.engine.Downloads() {
  108. if err = ctx.Err(); err != nil {
  109. return nil, err
  110. }
  111. if d.State != "completed" {
  112. continue
  113. }
  114. s.mu.Lock()
  115. already := s.imported[d.ID]
  116. if !already {
  117. s.imported[d.ID] = true
  118. }
  119. s.mu.Unlock()
  120. if already {
  121. continue
  122. }
  123. root, e := os.OpenRoot(s.downloadDir)
  124. if e != nil {
  125. return nil, e
  126. }
  127. f, e := root.Open(filepath.Base(d.Path))
  128. if e != nil {
  129. root.Close()
  130. s.mu.Lock()
  131. delete(s.imported, d.ID)
  132. s.mu.Unlock()
  133. return nil, e
  134. }
  135. _, e = m.store(s, d.Name, mime.TypeByExtension(filepath.Ext(d.Name)), f, m.cfg.MaxDownloadBytes)
  136. f.Close()
  137. root.Close()
  138. if e != nil {
  139. s.mu.Lock()
  140. delete(s.imported, d.ID)
  141. s.mu.Unlock()
  142. return nil, e
  143. }
  144. }
  145. s.mu.Lock()
  146. defer s.mu.Unlock()
  147. out := make([]api.FileInfo, 0, len(s.files))
  148. for _, f := range s.files {
  149. out = append(out, f.info)
  150. }
  151. sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
  152. return out, nil
  153. }
  154. // Export requires a host-authorized destination root and never overwrites files.
  155. func (m *Manager) Export(ctx context.Context, o api.Owner, sid, fileID, destinationRoot, relative string) (api.FileInfo, error) {
  156. if !filepath.IsLocal(relative) || strings.Contains(relative, "\\") || strings.ContainsRune(relative, 0) {
  157. return api.FileInfo{}, api.Err("BROWSER_PATH_BLOCKED", "destination must be a local relative path")
  158. }
  159. for _, part := range strings.Split(filepath.ToSlash(relative), "/") {
  160. if part == ".." || part == "." || part == "" {
  161. return api.FileInfo{}, api.Err("BROWSER_PATH_BLOCKED", "invalid destination component")
  162. }
  163. }
  164. s, err := m.owned(o, sid)
  165. if err != nil {
  166. return api.FileInfo{}, err
  167. }
  168. s.mu.Lock()
  169. f, ok := s.files[fileID]
  170. closed := s.closed
  171. s.mu.Unlock()
  172. if !ok || closed {
  173. return api.FileInfo{}, api.Err("BROWSER_FILE_NOT_FOUND", "file is unavailable")
  174. }
  175. if err = ctx.Err(); err != nil {
  176. return api.FileInfo{}, err
  177. }
  178. srcRoot, err := os.OpenRoot(s.downloadDir)
  179. if err != nil {
  180. return api.FileInfo{}, err
  181. }
  182. defer srcRoot.Close()
  183. src, err := srcRoot.Open(f.name)
  184. if err != nil {
  185. return api.FileInfo{}, err
  186. }
  187. defer src.Close()
  188. dstRoot, err := os.OpenRoot(destinationRoot)
  189. if err != nil {
  190. return api.FileInfo{}, err
  191. }
  192. defer dstRoot.Close()
  193. dst, err := dstRoot.OpenFile(relative, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
  194. if err != nil {
  195. return api.FileInfo{}, err
  196. }
  197. _, err = copyContext(ctx, dst, src)
  198. err = errors.Join(err, dst.Close())
  199. if err != nil {
  200. _ = dstRoot.Remove(relative)
  201. return api.FileInfo{}, err
  202. }
  203. return f.info, nil
  204. }
  205. func copyContext(ctx context.Context, w io.Writer, r io.Reader) (int64, error) {
  206. buf := make([]byte, 32*1024)
  207. var total int64
  208. for {
  209. if err := ctx.Err(); err != nil {
  210. return total, err
  211. }
  212. n, err := r.Read(buf)
  213. if n > 0 {
  214. written, e := w.Write(buf[:n])
  215. total += int64(written)
  216. if e != nil {
  217. return total, e
  218. }
  219. if written != n {
  220. return total, io.ErrShortWrite
  221. }
  222. }
  223. if err == io.EOF {
  224. return total, nil
  225. }
  226. if err != nil {
  227. return total, err
  228. }
  229. }
  230. }