| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521 |
- //go:build linux
- package main
- import (
- "context"
- "encoding/json"
- "errors"
- "os"
- "runtime"
- "sync/atomic"
- "time"
- "unsafe"
- "clusterflow.dev/cfbrowser/api"
- "clusterflow.dev/cfbrowser/internal/capture"
- "clusterflow.dev/cfbrowser/protocol"
- "github.com/ebitengine/purego"
- )
- type nativePage struct {
- window, view uintptr
- loading bool
- failed bool
- }
- type allocation struct{ X, Y, Width, Height int32 }
- type nativeCapture struct {
- result chan evalResult
- page uint64
- data []byte
- }
- type nativeHost struct {
- snapshots map[uintptr]*nativeCapture
- snapshot func(uintptr, int32, uint32, uintptr, uintptr, uintptr)
- snapshotFinish func(uintptr, uintptr, *uintptr) uintptr
- surfaceDestroy func(uintptr)
- surfaceWidth, surfaceHeight, surfaceType func(uintptr) int32
- surfacePNG func(uintptr, uintptr, uintptr) int32
- sizeAllocate func(uintptr, *allocation)
- snapshotCallback, pngCallback uintptr
- queue chan func()
- pages map[uint64]*nativePage
- next uint64
- options api.EngineOptions
- configured bool
- webContext uintptr
- callbacks map[uintptr]chan evalResult
- evalSeq uintptr
- gtkInit func(uintptr, uintptr) int32
- windowNew func(int32) uintptr
- windowSize func(uintptr, int32, int32)
- containerAdd func(uintptr, uintptr)
- show, realize, destroy func(uintptr)
- pending func() int32
- iteration func(int32) int32
- contextNew func() uintptr
- viewNew func(uintptr) uintptr
- contentManager func(uintptr) uintptr
- scriptNew func(string, int32, int32, string, uintptr, uintptr) uintptr
- addScript func(uintptr, uintptr)
- scriptUnref func(uintptr)
- load func(uintptr, string)
- uri func(uintptr) *byte
- back, forward, reload func(uintptr)
- eval func(uintptr, string, int64, string, string, uintptr, uintptr, uintptr)
- finish func(uintptr, uintptr, *uintptr) uintptr
- toJSON func(uintptr, uint32) *byte
- free, unref, errorFree func(uintptr)
- signal func(uintptr, string, uintptr, uintptr, uintptr, uint32) uint64
- evalCallback, loadCallback, failedCallback uintptr
- }
- type evalResult struct {
- raw json.RawMessage
- err error
- }
- func openLibrary(name string) (uintptr, error) {
- return purego.Dlopen(name, purego.RTLD_NOW|purego.RTLD_GLOBAL)
- }
- func newHost() (*nativeHost, error) {
- gtk, err := openLibrary("libgtk-3.so.0")
- if err != nil {
- return nil, err
- }
- wk, err := openLibrary("libwebkit2gtk-4.1.so.0")
- if err != nil {
- return nil, err
- }
- jsc, err := openLibrary("libjavascriptcoregtk-4.1.so.0")
- if err != nil {
- return nil, err
- }
- glib, err := openLibrary("libglib-2.0.so.0")
- if err != nil {
- return nil, err
- }
- object, err := openLibrary("libgobject-2.0.so.0")
- if err != nil {
- return nil, err
- }
- cairo, err := openLibrary("libcairo.so.2")
- if err != nil {
- return nil, err
- }
- h := &nativeHost{snapshots: map[uintptr]*nativeCapture{}, queue: make(chan func(), 32), pages: map[uint64]*nativePage{}, callbacks: map[uintptr]chan evalResult{}}
- purego.RegisterLibFunc(&h.snapshot, wk, "webkit_web_view_get_snapshot")
- purego.RegisterLibFunc(&h.snapshotFinish, wk, "webkit_web_view_get_snapshot_finish")
- purego.RegisterLibFunc(&h.surfaceDestroy, cairo, "cairo_surface_destroy")
- purego.RegisterLibFunc(&h.surfaceWidth, cairo, "cairo_image_surface_get_width")
- purego.RegisterLibFunc(&h.surfaceHeight, cairo, "cairo_image_surface_get_height")
- purego.RegisterLibFunc(&h.surfaceType, cairo, "cairo_surface_get_type")
- purego.RegisterLibFunc(&h.surfacePNG, cairo, "cairo_surface_write_to_png_stream")
- purego.RegisterLibFunc(&h.sizeAllocate, gtk, "gtk_widget_size_allocate")
- purego.RegisterLibFunc(&h.gtkInit, gtk, "gtk_init_check")
- purego.RegisterLibFunc(&h.windowNew, gtk, "gtk_window_new")
- purego.RegisterLibFunc(&h.windowSize, gtk, "gtk_window_set_default_size")
- purego.RegisterLibFunc(&h.containerAdd, gtk, "gtk_container_add")
- purego.RegisterLibFunc(&h.show, gtk, "gtk_widget_show_all")
- purego.RegisterLibFunc(&h.realize, gtk, "gtk_widget_realize")
- purego.RegisterLibFunc(&h.destroy, gtk, "gtk_widget_destroy")
- purego.RegisterLibFunc(&h.pending, gtk, "gtk_events_pending")
- purego.RegisterLibFunc(&h.iteration, gtk, "gtk_main_iteration_do")
- purego.RegisterLibFunc(&h.contextNew, wk, "webkit_web_context_new_ephemeral")
- purego.RegisterLibFunc(&h.viewNew, wk, "webkit_web_view_new_with_context")
- purego.RegisterLibFunc(&h.contentManager, wk, "webkit_web_view_get_user_content_manager")
- purego.RegisterLibFunc(&h.scriptNew, wk, "webkit_user_script_new_for_world")
- purego.RegisterLibFunc(&h.addScript, wk, "webkit_user_content_manager_add_script")
- purego.RegisterLibFunc(&h.scriptUnref, wk, "webkit_user_script_unref")
- purego.RegisterLibFunc(&h.load, wk, "webkit_web_view_load_uri")
- purego.RegisterLibFunc(&h.uri, wk, "webkit_web_view_get_uri")
- purego.RegisterLibFunc(&h.back, wk, "webkit_web_view_go_back")
- purego.RegisterLibFunc(&h.forward, wk, "webkit_web_view_go_forward")
- purego.RegisterLibFunc(&h.reload, wk, "webkit_web_view_reload")
- purego.RegisterLibFunc(&h.eval, wk, "webkit_web_view_evaluate_javascript")
- purego.RegisterLibFunc(&h.finish, wk, "webkit_web_view_evaluate_javascript_finish")
- purego.RegisterLibFunc(&h.toJSON, jsc, "jsc_value_to_json")
- purego.RegisterLibFunc(&h.free, glib, "g_free")
- purego.RegisterLibFunc(&h.errorFree, glib, "g_error_free")
- purego.RegisterLibFunc(&h.unref, object, "g_object_unref")
- purego.RegisterLibFunc(&h.signal, object, "g_signal_connect_data")
- if h.gtkInit(0, 0) == 0 {
- return nil, api.Err("BROWSER_RUNTIME_UNAVAILABLE", "GTK display unavailable; run in a desktop session or under Xvfb")
- }
- h.webContext = h.contextNew()
- h.evalCallback = purego.NewCallback(func(view, result, id uintptr) {
- ch := h.callbacks[id]
- delete(h.callbacks, id)
- var nativeError uintptr
- value := h.finish(view, result, &nativeError)
- if nativeError != 0 {
- h.errorFree(nativeError)
- if ch != nil {
- ch <- evalResult{err: errors.New("WebKit evaluation failed")}
- }
- return
- }
- if value == 0 {
- if ch != nil {
- ch <- evalResult{err: errors.New("WebKit returned no value")}
- }
- return
- }
- ptr := h.toJSON(value, 0)
- s, e := cString(ptr, protocol.MaxMessage)
- if ptr != nil {
- h.free(uintptr(unsafe.Pointer(ptr)))
- }
- h.unref(value)
- if ch != nil {
- ch <- evalResult{raw: json.RawMessage(s), err: e}
- }
- })
- h.pngCallback = purego.NewCallback(func(key uintptr, ptr *byte, n uint32) int32 {
- job := h.snapshots[key]
- if job == nil || int(n) > capture.MaxBytes-len(job.data) {
- return 11
- } // CAIRO_STATUS_WRITE_ERROR
- job.data = append(job.data, unsafe.Slice(ptr, int(n))...)
- return 0
- })
- h.snapshotCallback = purego.NewCallback(func(view, result, key uintptr) {
- var nativeError uintptr
- surface := h.snapshotFinish(view, result, &nativeError)
- job := h.snapshots[key]
- if surface != 0 {
- defer h.surfaceDestroy(surface)
- }
- if nativeError != 0 {
- h.errorFree(nativeError)
- }
- if job == nil {
- return
- }
- defer delete(h.snapshots, key)
- if surface == 0 || nativeError != 0 {
- job.result <- evalResult{err: api.Err("BROWSER_CAPTURE_FAILED", "WebKit snapshot failed")}
- return
- }
- if h.surfaceType(surface) != 0 || h.surfaceWidth(surface) < 1 || h.surfaceHeight(surface) < 1 || h.surfaceWidth(surface) > capture.MaxDimension || h.surfaceHeight(surface) > capture.MaxDimension {
- job.result <- evalResult{err: api.Err("BROWSER_RESULT_LIMIT", "invalid capture surface dimensions")}
- return
- }
- status := h.surfacePNG(surface, h.pngCallback, key)
- if status != 0 {
- job.result <- evalResult{err: api.Err("BROWSER_RESULT_LIMIT", "PNG encoding failed or exceeds 4 MiB")}
- return
- }
- job.result <- evalResult{raw: job.data}
- })
- h.loadCallback = purego.NewCallback(func(view uintptr, event int32, data uintptr) {
- for _, p := range h.pages {
- if p.view == view {
- if event == 0 {
- p.loading = true
- }
- if event == 3 {
- p.loading = false
- }
- }
- }
- })
- h.failedCallback = purego.NewCallback(func(view uintptr, event int32, uri, nativeError, data uintptr) int32 {
- for _, p := range h.pages {
- if p.view == view {
- p.loading = false
- p.failed = true
- }
- }
- return 1
- })
- return h, nil
- }
- func cString(ptr *byte, max int) (string, error) {
- if ptr == nil {
- return "", nil
- }
- b := make([]byte, 0, 256)
- for i := 0; i <= max; i++ {
- v := *(*byte)(unsafe.Add(unsafe.Pointer(ptr), i))
- if v == 0 {
- return string(b), nil
- }
- if i == max {
- return "", api.Err("BROWSER_RESULT_LIMIT", "native string exceeds limit")
- }
- b = append(b, v)
- }
- return "", errors.New("invalid native string")
- }
- func (h *nativeHost) dispatch(ctx context.Context, f func()) error {
- select {
- case h.queue <- f:
- return nil
- case <-ctx.Done():
- return ctx.Err()
- }
- }
- func (h *nativeHost) call(ctx context.Context, f func() (any, error)) (any, error) {
- result := make(chan struct {
- value any
- err error
- }, 1)
- err := h.dispatch(ctx, func() {
- if ctx.Err() != nil {
- result <- struct {
- value any
- err error
- }{nil, ctx.Err()}
- return
- }
- v, e := f()
- result <- struct {
- value any
- err error
- }{v, e}
- })
- if err != nil {
- return nil, err
- }
- select {
- case r := <-result:
- return r.value, r.err
- case <-ctx.Done():
- return nil, ctx.Err()
- }
- }
- func (h *nativeHost) handle(ctx context.Context, method string, raw json.RawMessage) (any, error) {
- var a struct {
- Page uint64 `json:"page"`
- URL string `json:"url"`
- Op string `json:"op"`
- Script string `json:"script"`
- FullPage bool `json:"fullPage"`
- }
- if method != "configure" && method != "session.features" {
- if err := json.Unmarshal(raw, &a); err != nil && string(raw) != "null" {
- return nil, err
- }
- }
- if method == "page.capture" {
- ch := make(chan evalResult, 1)
- var id atomic.Uint64
- _, err := h.call(ctx, func() (any, error) {
- p := h.pages[a.Page]
- if p == nil {
- return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found")
- }
- if a.FullPage {
- return nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "WebKitGTK full-page capture is not implemented")
- }
- if len(h.snapshots) >= 16 {
- return nil, api.Err("BROWSER_LIMIT", "too many pending snapshots")
- }
- h.evalSeq++
- key := h.evalSeq
- id.Store(uint64(key))
- h.snapshots[key] = &nativeCapture{result: ch, page: a.Page}
- h.snapshot(p.view, 0, 0, 0, h.snapshotCallback, key)
- return nil, nil
- })
- if err != nil {
- return nil, err
- }
- select {
- case r := <-ch:
- if r.err != nil {
- return nil, r.err
- }
- if ctx.Err() != nil {
- return nil, ctx.Err()
- }
- return capture.Save(h.options.DownloadDir, r.raw)
- case <-ctx.Done():
- _ = h.dispatch(context.Background(), func() { delete(h.snapshots, uintptr(id.Load())) })
- return nil, ctx.Err()
- }
- }
- if method == "page.evaluate" {
- ch := make(chan evalResult, 1)
- var id atomic.Uint64
- _, err := h.call(ctx, func() (any, error) {
- p := h.pages[a.Page]
- if p == nil {
- return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found")
- }
- h.evalSeq++
- key := h.evalSeq
- id.Store(uint64(key))
- h.callbacks[key] = ch
- h.eval(p.view, a.Script, int64(len(a.Script)), "cfbrowser-isolated", "", 0, h.evalCallback, key)
- return nil, nil
- })
- if err != nil {
- return nil, err
- }
- select {
- case result := <-ch:
- return result.raw, result.err
- case <-ctx.Done():
- _ = h.dispatch(context.Background(), func() { delete(h.callbacks, uintptr(id.Load())) })
- return nil, ctx.Err()
- }
- }
- if method == "page.navigate" {
- _, err := h.call(ctx, func() (any, error) {
- p := h.pages[a.Page]
- if p == nil {
- return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found")
- }
- p.failed = false
- p.loading = true
- switch a.Op {
- case "goto":
- h.load(p.view, a.URL)
- case "reload":
- h.reload(p.view)
- case "back":
- h.back(p.view)
- case "forward":
- h.forward(p.view)
- default:
- p.loading = false
- return nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation")
- }
- return nil, nil
- })
- if err != nil {
- return nil, err
- }
- ticker := time.NewTicker(10 * time.Millisecond)
- defer ticker.Stop()
- for {
- v, err := h.call(ctx, func() (any, error) {
- p := h.pages[a.Page]
- if p == nil {
- return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page closed")
- }
- if p.failed {
- return nil, api.Err("BROWSER_NAVIGATION_FAILED", "WebKit load failed")
- }
- if p.loading {
- return nil, nil
- }
- return cString(h.uri(p.view), 8192)
- })
- if err != nil {
- return nil, err
- }
- if v != nil {
- return v, nil
- }
- select {
- case <-ctx.Done():
- return nil, ctx.Err()
- case <-ticker.C:
- }
- }
- }
- return h.call(ctx, func() (any, error) {
- switch method {
- case "session.features":
- if !h.configured {
- return nil, api.Err("BROWSER_INVALID_CONFIG", "configure worker first")
- }
- return map[string]int{"featureVersion": protocol.FeatureVersion}, nil
- case "configure":
- if h.configured {
- return nil, api.Err("BROWSER_INVALID_CONFIG", "worker is already configured")
- }
- if err := json.Unmarshal(raw, &h.options); err != nil {
- return nil, err
- }
- if h.options.ViewportWidth == 0 {
- h.options.ViewportWidth = 1280
- }
- if h.options.ViewportHeight == 0 {
- h.options.ViewportHeight = 800
- }
- if h.options.ViewportWidth < 1 || h.options.ViewportWidth > 4096 || h.options.ViewportHeight < 1 || h.options.ViewportHeight > 4096 {
- return nil, api.Err("BROWSER_INVALID_CONFIG", "invalid viewport dimensions")
- }
- h.configured = true
- return true, nil
- case "page.new":
- if !h.configured {
- return nil, api.Err("BROWSER_INVALID_CONFIG", "configure worker first")
- }
- if len(h.pages) >= 16 {
- return nil, api.Err("BROWSER_LIMIT", "native page quota reached")
- }
- window := h.windowNew(0)
- view := h.viewNew(h.webContext)
- h.windowSize(window, int32(h.options.ViewportWidth), int32(h.options.ViewportHeight))
- h.containerAdd(window, view)
- // Retain the named script world across separate evaluation calls.
- script := h.scriptNew("void 0;", 1, 0, "cfbrowser-isolated", 0, 0)
- h.addScript(h.contentManager(view), script)
- h.scriptUnref(script)
- // Realize the native surface without mapping a top-level desktop window.
- h.show(view)
- h.realize(window)
- h.sizeAllocate(view, &allocation{Width: int32(h.options.ViewportWidth), Height: int32(h.options.ViewportHeight)})
- if !h.options.Headless {
- h.show(window)
- }
- h.next++
- h.pages[h.next] = &nativePage{window: window, view: view}
- h.signal(view, "load-changed", h.loadCallback, 0, 0, 0)
- h.signal(view, "load-failed", h.failedCallback, 0, 0, 0)
- return h.next, nil
- case "page.close":
- for key, job := range h.snapshots {
- if job.page == a.Page {
- job.result <- evalResult{err: api.Err("BROWSER_CLOSED", "page closed during capture")}
- delete(h.snapshots, key)
- }
- }
- if p := h.pages[a.Page]; p != nil {
- h.destroy(p.window)
- delete(h.pages, a.Page)
- }
- return true, nil
- default:
- return nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "unknown native worker method")
- }
- })
- }
- func run() error {
- runtime.LockOSThread()
- defer runtime.UnlockOSThread()
- h, err := newHost()
- if err != nil {
- return err
- }
- done := make(chan error, 1)
- go func() { done <- protocol.Serve(context.Background(), os.Stdin, os.Stdout, h.handle) }()
- defer func() {
- for _, p := range h.pages {
- h.destroy(p.window)
- }
- h.unref(h.webContext)
- }()
- for {
- select {
- case err := <-done:
- return err
- case task := <-h.queue:
- task()
- default:
- }
- for i := 0; i < 100 && h.pending() != 0; i++ {
- h.iteration(0)
- }
- time.Sleep(time.Millisecond)
- }
- }
|