linux.go 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521
  1. //go:build linux
  2. package main
  3. import (
  4. "context"
  5. "encoding/json"
  6. "errors"
  7. "os"
  8. "runtime"
  9. "sync/atomic"
  10. "time"
  11. "unsafe"
  12. "clusterflow.dev/cfbrowser/api"
  13. "clusterflow.dev/cfbrowser/internal/capture"
  14. "clusterflow.dev/cfbrowser/protocol"
  15. "github.com/ebitengine/purego"
  16. )
  17. type nativePage struct {
  18. window, view uintptr
  19. loading bool
  20. failed bool
  21. }
  22. type allocation struct{ X, Y, Width, Height int32 }
  23. type nativeCapture struct {
  24. result chan evalResult
  25. page uint64
  26. data []byte
  27. }
  28. type nativeHost struct {
  29. snapshots map[uintptr]*nativeCapture
  30. snapshot func(uintptr, int32, uint32, uintptr, uintptr, uintptr)
  31. snapshotFinish func(uintptr, uintptr, *uintptr) uintptr
  32. surfaceDestroy func(uintptr)
  33. surfaceWidth, surfaceHeight, surfaceType func(uintptr) int32
  34. surfacePNG func(uintptr, uintptr, uintptr) int32
  35. sizeAllocate func(uintptr, *allocation)
  36. snapshotCallback, pngCallback uintptr
  37. queue chan func()
  38. pages map[uint64]*nativePage
  39. next uint64
  40. options api.EngineOptions
  41. configured bool
  42. webContext uintptr
  43. callbacks map[uintptr]chan evalResult
  44. evalSeq uintptr
  45. gtkInit func(uintptr, uintptr) int32
  46. windowNew func(int32) uintptr
  47. windowSize func(uintptr, int32, int32)
  48. containerAdd func(uintptr, uintptr)
  49. show, realize, destroy func(uintptr)
  50. pending func() int32
  51. iteration func(int32) int32
  52. contextNew func() uintptr
  53. viewNew func(uintptr) uintptr
  54. contentManager func(uintptr) uintptr
  55. scriptNew func(string, int32, int32, string, uintptr, uintptr) uintptr
  56. addScript func(uintptr, uintptr)
  57. scriptUnref func(uintptr)
  58. load func(uintptr, string)
  59. uri func(uintptr) *byte
  60. back, forward, reload func(uintptr)
  61. eval func(uintptr, string, int64, string, string, uintptr, uintptr, uintptr)
  62. finish func(uintptr, uintptr, *uintptr) uintptr
  63. toJSON func(uintptr, uint32) *byte
  64. free, unref, errorFree func(uintptr)
  65. signal func(uintptr, string, uintptr, uintptr, uintptr, uint32) uint64
  66. evalCallback, loadCallback, failedCallback uintptr
  67. }
  68. type evalResult struct {
  69. raw json.RawMessage
  70. err error
  71. }
  72. func openLibrary(name string) (uintptr, error) {
  73. return purego.Dlopen(name, purego.RTLD_NOW|purego.RTLD_GLOBAL)
  74. }
  75. func newHost() (*nativeHost, error) {
  76. gtk, err := openLibrary("libgtk-3.so.0")
  77. if err != nil {
  78. return nil, err
  79. }
  80. wk, err := openLibrary("libwebkit2gtk-4.1.so.0")
  81. if err != nil {
  82. return nil, err
  83. }
  84. jsc, err := openLibrary("libjavascriptcoregtk-4.1.so.0")
  85. if err != nil {
  86. return nil, err
  87. }
  88. glib, err := openLibrary("libglib-2.0.so.0")
  89. if err != nil {
  90. return nil, err
  91. }
  92. object, err := openLibrary("libgobject-2.0.so.0")
  93. if err != nil {
  94. return nil, err
  95. }
  96. cairo, err := openLibrary("libcairo.so.2")
  97. if err != nil {
  98. return nil, err
  99. }
  100. h := &nativeHost{snapshots: map[uintptr]*nativeCapture{}, queue: make(chan func(), 32), pages: map[uint64]*nativePage{}, callbacks: map[uintptr]chan evalResult{}}
  101. purego.RegisterLibFunc(&h.snapshot, wk, "webkit_web_view_get_snapshot")
  102. purego.RegisterLibFunc(&h.snapshotFinish, wk, "webkit_web_view_get_snapshot_finish")
  103. purego.RegisterLibFunc(&h.surfaceDestroy, cairo, "cairo_surface_destroy")
  104. purego.RegisterLibFunc(&h.surfaceWidth, cairo, "cairo_image_surface_get_width")
  105. purego.RegisterLibFunc(&h.surfaceHeight, cairo, "cairo_image_surface_get_height")
  106. purego.RegisterLibFunc(&h.surfaceType, cairo, "cairo_surface_get_type")
  107. purego.RegisterLibFunc(&h.surfacePNG, cairo, "cairo_surface_write_to_png_stream")
  108. purego.RegisterLibFunc(&h.sizeAllocate, gtk, "gtk_widget_size_allocate")
  109. purego.RegisterLibFunc(&h.gtkInit, gtk, "gtk_init_check")
  110. purego.RegisterLibFunc(&h.windowNew, gtk, "gtk_window_new")
  111. purego.RegisterLibFunc(&h.windowSize, gtk, "gtk_window_set_default_size")
  112. purego.RegisterLibFunc(&h.containerAdd, gtk, "gtk_container_add")
  113. purego.RegisterLibFunc(&h.show, gtk, "gtk_widget_show_all")
  114. purego.RegisterLibFunc(&h.realize, gtk, "gtk_widget_realize")
  115. purego.RegisterLibFunc(&h.destroy, gtk, "gtk_widget_destroy")
  116. purego.RegisterLibFunc(&h.pending, gtk, "gtk_events_pending")
  117. purego.RegisterLibFunc(&h.iteration, gtk, "gtk_main_iteration_do")
  118. purego.RegisterLibFunc(&h.contextNew, wk, "webkit_web_context_new_ephemeral")
  119. purego.RegisterLibFunc(&h.viewNew, wk, "webkit_web_view_new_with_context")
  120. purego.RegisterLibFunc(&h.contentManager, wk, "webkit_web_view_get_user_content_manager")
  121. purego.RegisterLibFunc(&h.scriptNew, wk, "webkit_user_script_new_for_world")
  122. purego.RegisterLibFunc(&h.addScript, wk, "webkit_user_content_manager_add_script")
  123. purego.RegisterLibFunc(&h.scriptUnref, wk, "webkit_user_script_unref")
  124. purego.RegisterLibFunc(&h.load, wk, "webkit_web_view_load_uri")
  125. purego.RegisterLibFunc(&h.uri, wk, "webkit_web_view_get_uri")
  126. purego.RegisterLibFunc(&h.back, wk, "webkit_web_view_go_back")
  127. purego.RegisterLibFunc(&h.forward, wk, "webkit_web_view_go_forward")
  128. purego.RegisterLibFunc(&h.reload, wk, "webkit_web_view_reload")
  129. purego.RegisterLibFunc(&h.eval, wk, "webkit_web_view_evaluate_javascript")
  130. purego.RegisterLibFunc(&h.finish, wk, "webkit_web_view_evaluate_javascript_finish")
  131. purego.RegisterLibFunc(&h.toJSON, jsc, "jsc_value_to_json")
  132. purego.RegisterLibFunc(&h.free, glib, "g_free")
  133. purego.RegisterLibFunc(&h.errorFree, glib, "g_error_free")
  134. purego.RegisterLibFunc(&h.unref, object, "g_object_unref")
  135. purego.RegisterLibFunc(&h.signal, object, "g_signal_connect_data")
  136. if h.gtkInit(0, 0) == 0 {
  137. return nil, api.Err("BROWSER_RUNTIME_UNAVAILABLE", "GTK display unavailable; run in a desktop session or under Xvfb")
  138. }
  139. h.webContext = h.contextNew()
  140. h.evalCallback = purego.NewCallback(func(view, result, id uintptr) {
  141. ch := h.callbacks[id]
  142. delete(h.callbacks, id)
  143. var nativeError uintptr
  144. value := h.finish(view, result, &nativeError)
  145. if nativeError != 0 {
  146. h.errorFree(nativeError)
  147. if ch != nil {
  148. ch <- evalResult{err: errors.New("WebKit evaluation failed")}
  149. }
  150. return
  151. }
  152. if value == 0 {
  153. if ch != nil {
  154. ch <- evalResult{err: errors.New("WebKit returned no value")}
  155. }
  156. return
  157. }
  158. ptr := h.toJSON(value, 0)
  159. s, e := cString(ptr, protocol.MaxMessage)
  160. if ptr != nil {
  161. h.free(uintptr(unsafe.Pointer(ptr)))
  162. }
  163. h.unref(value)
  164. if ch != nil {
  165. ch <- evalResult{raw: json.RawMessage(s), err: e}
  166. }
  167. })
  168. h.pngCallback = purego.NewCallback(func(key uintptr, ptr *byte, n uint32) int32 {
  169. job := h.snapshots[key]
  170. if job == nil || int(n) > capture.MaxBytes-len(job.data) {
  171. return 11
  172. } // CAIRO_STATUS_WRITE_ERROR
  173. job.data = append(job.data, unsafe.Slice(ptr, int(n))...)
  174. return 0
  175. })
  176. h.snapshotCallback = purego.NewCallback(func(view, result, key uintptr) {
  177. var nativeError uintptr
  178. surface := h.snapshotFinish(view, result, &nativeError)
  179. job := h.snapshots[key]
  180. if surface != 0 {
  181. defer h.surfaceDestroy(surface)
  182. }
  183. if nativeError != 0 {
  184. h.errorFree(nativeError)
  185. }
  186. if job == nil {
  187. return
  188. }
  189. defer delete(h.snapshots, key)
  190. if surface == 0 || nativeError != 0 {
  191. job.result <- evalResult{err: api.Err("BROWSER_CAPTURE_FAILED", "WebKit snapshot failed")}
  192. return
  193. }
  194. if h.surfaceType(surface) != 0 || h.surfaceWidth(surface) < 1 || h.surfaceHeight(surface) < 1 || h.surfaceWidth(surface) > capture.MaxDimension || h.surfaceHeight(surface) > capture.MaxDimension {
  195. job.result <- evalResult{err: api.Err("BROWSER_RESULT_LIMIT", "invalid capture surface dimensions")}
  196. return
  197. }
  198. status := h.surfacePNG(surface, h.pngCallback, key)
  199. if status != 0 {
  200. job.result <- evalResult{err: api.Err("BROWSER_RESULT_LIMIT", "PNG encoding failed or exceeds 4 MiB")}
  201. return
  202. }
  203. job.result <- evalResult{raw: job.data}
  204. })
  205. h.loadCallback = purego.NewCallback(func(view uintptr, event int32, data uintptr) {
  206. for _, p := range h.pages {
  207. if p.view == view {
  208. if event == 0 {
  209. p.loading = true
  210. }
  211. if event == 3 {
  212. p.loading = false
  213. }
  214. }
  215. }
  216. })
  217. h.failedCallback = purego.NewCallback(func(view uintptr, event int32, uri, nativeError, data uintptr) int32 {
  218. for _, p := range h.pages {
  219. if p.view == view {
  220. p.loading = false
  221. p.failed = true
  222. }
  223. }
  224. return 1
  225. })
  226. return h, nil
  227. }
  228. func cString(ptr *byte, max int) (string, error) {
  229. if ptr == nil {
  230. return "", nil
  231. }
  232. b := make([]byte, 0, 256)
  233. for i := 0; i <= max; i++ {
  234. v := *(*byte)(unsafe.Add(unsafe.Pointer(ptr), i))
  235. if v == 0 {
  236. return string(b), nil
  237. }
  238. if i == max {
  239. return "", api.Err("BROWSER_RESULT_LIMIT", "native string exceeds limit")
  240. }
  241. b = append(b, v)
  242. }
  243. return "", errors.New("invalid native string")
  244. }
  245. func (h *nativeHost) dispatch(ctx context.Context, f func()) error {
  246. select {
  247. case h.queue <- f:
  248. return nil
  249. case <-ctx.Done():
  250. return ctx.Err()
  251. }
  252. }
  253. func (h *nativeHost) call(ctx context.Context, f func() (any, error)) (any, error) {
  254. result := make(chan struct {
  255. value any
  256. err error
  257. }, 1)
  258. err := h.dispatch(ctx, func() {
  259. if ctx.Err() != nil {
  260. result <- struct {
  261. value any
  262. err error
  263. }{nil, ctx.Err()}
  264. return
  265. }
  266. v, e := f()
  267. result <- struct {
  268. value any
  269. err error
  270. }{v, e}
  271. })
  272. if err != nil {
  273. return nil, err
  274. }
  275. select {
  276. case r := <-result:
  277. return r.value, r.err
  278. case <-ctx.Done():
  279. return nil, ctx.Err()
  280. }
  281. }
  282. func (h *nativeHost) handle(ctx context.Context, method string, raw json.RawMessage) (any, error) {
  283. var a struct {
  284. Page uint64 `json:"page"`
  285. URL string `json:"url"`
  286. Op string `json:"op"`
  287. Script string `json:"script"`
  288. FullPage bool `json:"fullPage"`
  289. }
  290. if method != "configure" && method != "session.features" {
  291. if err := json.Unmarshal(raw, &a); err != nil && string(raw) != "null" {
  292. return nil, err
  293. }
  294. }
  295. if method == "page.capture" {
  296. ch := make(chan evalResult, 1)
  297. var id atomic.Uint64
  298. _, err := h.call(ctx, func() (any, error) {
  299. p := h.pages[a.Page]
  300. if p == nil {
  301. return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found")
  302. }
  303. if a.FullPage {
  304. return nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "WebKitGTK full-page capture is not implemented")
  305. }
  306. if len(h.snapshots) >= 16 {
  307. return nil, api.Err("BROWSER_LIMIT", "too many pending snapshots")
  308. }
  309. h.evalSeq++
  310. key := h.evalSeq
  311. id.Store(uint64(key))
  312. h.snapshots[key] = &nativeCapture{result: ch, page: a.Page}
  313. h.snapshot(p.view, 0, 0, 0, h.snapshotCallback, key)
  314. return nil, nil
  315. })
  316. if err != nil {
  317. return nil, err
  318. }
  319. select {
  320. case r := <-ch:
  321. if r.err != nil {
  322. return nil, r.err
  323. }
  324. if ctx.Err() != nil {
  325. return nil, ctx.Err()
  326. }
  327. return capture.Save(h.options.DownloadDir, r.raw)
  328. case <-ctx.Done():
  329. _ = h.dispatch(context.Background(), func() { delete(h.snapshots, uintptr(id.Load())) })
  330. return nil, ctx.Err()
  331. }
  332. }
  333. if method == "page.evaluate" {
  334. ch := make(chan evalResult, 1)
  335. var id atomic.Uint64
  336. _, err := h.call(ctx, func() (any, error) {
  337. p := h.pages[a.Page]
  338. if p == nil {
  339. return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found")
  340. }
  341. h.evalSeq++
  342. key := h.evalSeq
  343. id.Store(uint64(key))
  344. h.callbacks[key] = ch
  345. h.eval(p.view, a.Script, int64(len(a.Script)), "cfbrowser-isolated", "", 0, h.evalCallback, key)
  346. return nil, nil
  347. })
  348. if err != nil {
  349. return nil, err
  350. }
  351. select {
  352. case result := <-ch:
  353. return result.raw, result.err
  354. case <-ctx.Done():
  355. _ = h.dispatch(context.Background(), func() { delete(h.callbacks, uintptr(id.Load())) })
  356. return nil, ctx.Err()
  357. }
  358. }
  359. if method == "page.navigate" {
  360. _, err := h.call(ctx, func() (any, error) {
  361. p := h.pages[a.Page]
  362. if p == nil {
  363. return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found")
  364. }
  365. p.failed = false
  366. p.loading = true
  367. switch a.Op {
  368. case "goto":
  369. h.load(p.view, a.URL)
  370. case "reload":
  371. h.reload(p.view)
  372. case "back":
  373. h.back(p.view)
  374. case "forward":
  375. h.forward(p.view)
  376. default:
  377. p.loading = false
  378. return nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation")
  379. }
  380. return nil, nil
  381. })
  382. if err != nil {
  383. return nil, err
  384. }
  385. ticker := time.NewTicker(10 * time.Millisecond)
  386. defer ticker.Stop()
  387. for {
  388. v, err := h.call(ctx, func() (any, error) {
  389. p := h.pages[a.Page]
  390. if p == nil {
  391. return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page closed")
  392. }
  393. if p.failed {
  394. return nil, api.Err("BROWSER_NAVIGATION_FAILED", "WebKit load failed")
  395. }
  396. if p.loading {
  397. return nil, nil
  398. }
  399. return cString(h.uri(p.view), 8192)
  400. })
  401. if err != nil {
  402. return nil, err
  403. }
  404. if v != nil {
  405. return v, nil
  406. }
  407. select {
  408. case <-ctx.Done():
  409. return nil, ctx.Err()
  410. case <-ticker.C:
  411. }
  412. }
  413. }
  414. return h.call(ctx, func() (any, error) {
  415. switch method {
  416. case "session.features":
  417. if !h.configured {
  418. return nil, api.Err("BROWSER_INVALID_CONFIG", "configure worker first")
  419. }
  420. return map[string]int{"featureVersion": protocol.FeatureVersion}, nil
  421. case "configure":
  422. if h.configured {
  423. return nil, api.Err("BROWSER_INVALID_CONFIG", "worker is already configured")
  424. }
  425. if err := json.Unmarshal(raw, &h.options); err != nil {
  426. return nil, err
  427. }
  428. if h.options.ViewportWidth == 0 {
  429. h.options.ViewportWidth = 1280
  430. }
  431. if h.options.ViewportHeight == 0 {
  432. h.options.ViewportHeight = 800
  433. }
  434. if h.options.ViewportWidth < 1 || h.options.ViewportWidth > 4096 || h.options.ViewportHeight < 1 || h.options.ViewportHeight > 4096 {
  435. return nil, api.Err("BROWSER_INVALID_CONFIG", "invalid viewport dimensions")
  436. }
  437. h.configured = true
  438. return true, nil
  439. case "page.new":
  440. if !h.configured {
  441. return nil, api.Err("BROWSER_INVALID_CONFIG", "configure worker first")
  442. }
  443. if len(h.pages) >= 16 {
  444. return nil, api.Err("BROWSER_LIMIT", "native page quota reached")
  445. }
  446. window := h.windowNew(0)
  447. view := h.viewNew(h.webContext)
  448. h.windowSize(window, int32(h.options.ViewportWidth), int32(h.options.ViewportHeight))
  449. h.containerAdd(window, view)
  450. // Retain the named script world across separate evaluation calls.
  451. script := h.scriptNew("void 0;", 1, 0, "cfbrowser-isolated", 0, 0)
  452. h.addScript(h.contentManager(view), script)
  453. h.scriptUnref(script)
  454. // Realize the native surface without mapping a top-level desktop window.
  455. h.show(view)
  456. h.realize(window)
  457. h.sizeAllocate(view, &allocation{Width: int32(h.options.ViewportWidth), Height: int32(h.options.ViewportHeight)})
  458. if !h.options.Headless {
  459. h.show(window)
  460. }
  461. h.next++
  462. h.pages[h.next] = &nativePage{window: window, view: view}
  463. h.signal(view, "load-changed", h.loadCallback, 0, 0, 0)
  464. h.signal(view, "load-failed", h.failedCallback, 0, 0, 0)
  465. return h.next, nil
  466. case "page.close":
  467. for key, job := range h.snapshots {
  468. if job.page == a.Page {
  469. job.result <- evalResult{err: api.Err("BROWSER_CLOSED", "page closed during capture")}
  470. delete(h.snapshots, key)
  471. }
  472. }
  473. if p := h.pages[a.Page]; p != nil {
  474. h.destroy(p.window)
  475. delete(h.pages, a.Page)
  476. }
  477. return true, nil
  478. default:
  479. return nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "unknown native worker method")
  480. }
  481. })
  482. }
  483. func run() error {
  484. runtime.LockOSThread()
  485. defer runtime.UnlockOSThread()
  486. h, err := newHost()
  487. if err != nil {
  488. return err
  489. }
  490. done := make(chan error, 1)
  491. go func() { done <- protocol.Serve(context.Background(), os.Stdin, os.Stdout, h.handle) }()
  492. defer func() {
  493. for _, p := range h.pages {
  494. h.destroy(p.window)
  495. }
  496. h.unref(h.webContext)
  497. }()
  498. for {
  499. select {
  500. case err := <-done:
  501. return err
  502. case task := <-h.queue:
  503. task()
  504. default:
  505. }
  506. for i := 0; i < 100 && h.pending() != 0; i++ {
  507. h.iteration(0)
  508. }
  509. time.Sleep(time.Millisecond)
  510. }
  511. }