native_module.go 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173
  1. //go:build windows && native_webview2loader
  2. package webviewloader
  3. import (
  4. "errors"
  5. "fmt"
  6. "os"
  7. "sync"
  8. "unsafe"
  9. "github.com/jchv/go-winloader"
  10. "golang.org/x/sys/windows"
  11. )
  12. func init() {
  13. preventEnvAndRegistryOverrides(nil, nil, "")
  14. }
  15. var (
  16. memOnce sync.Once
  17. memModule winloader.Module
  18. memCreate winloader.Proc
  19. memCompareBrowserVersions winloader.Proc
  20. memGetAvailableCoreWebView2BrowserVersionString winloader.Proc
  21. memErr error
  22. )
  23. const (
  24. // https://referencesource.microsoft.com/#system.web/Util/hresults.cs,20
  25. E_FILENOTFOUND = 0x80070002
  26. )
  27. // CompareBrowserVersions will compare the 2 given versions and return:
  28. //
  29. // Less than zero: v1 < v2
  30. // zero: v1 == v2
  31. // Greater than zero: v1 > v2
  32. func CompareBrowserVersions(v1 string, v2 string) (int, error) {
  33. _v1, err := windows.UTF16PtrFromString(v1)
  34. if err != nil {
  35. return 0, err
  36. }
  37. _v2, err := windows.UTF16PtrFromString(v2)
  38. if err != nil {
  39. return 0, err
  40. }
  41. err = loadFromMemory()
  42. if err != nil {
  43. return 0, err
  44. }
  45. var result int32
  46. _, _, err = memCompareBrowserVersions.Call(
  47. uint64(uintptr(unsafe.Pointer(_v1))),
  48. uint64(uintptr(unsafe.Pointer(_v2))),
  49. uint64(uintptr(unsafe.Pointer(&result))))
  50. if err != windows.ERROR_SUCCESS {
  51. return 0, err
  52. }
  53. return int(result), nil
  54. }
  55. // GetAvailableCoreWebView2BrowserVersionString returns version of the webview2 runtime.
  56. // If path is empty, it will try to find installed webview2 is the system.
  57. // If there is no version installed, a blank string is returned.
  58. func GetAvailableCoreWebView2BrowserVersionString(path string) (string, error) {
  59. if path != "" {
  60. // The default implementation fails if CGO and a fixed browser path is used. It's caused by the go-winloader
  61. // which loads the native DLL from memory.
  62. // Use the new GoWebView2Loader in this case, in the future we will make GoWebView2Loader
  63. // feature-complete and remove the use of the native DLL and go-winloader.
  64. version, err := goGetAvailableCoreWebView2BrowserVersionString(path)
  65. if errors.Is(err, errNoClientDLLFound) {
  66. // WebView2 is not found
  67. return "", nil
  68. } else if err != nil {
  69. return "", err
  70. }
  71. return version, nil
  72. }
  73. err := loadFromMemory()
  74. if err != nil {
  75. return "", err
  76. }
  77. var browserPath *uint16 = nil
  78. if path != "" {
  79. browserPath, err = windows.UTF16PtrFromString(path)
  80. if err != nil {
  81. return "", fmt.Errorf("error calling UTF16PtrFromString for %s: %v", path, err)
  82. }
  83. }
  84. preventEnvAndRegistryOverrides(browserPath, nil, "")
  85. var result *uint16
  86. res, _, err := memGetAvailableCoreWebView2BrowserVersionString.Call(
  87. uint64(uintptr(unsafe.Pointer(browserPath))),
  88. uint64(uintptr(unsafe.Pointer(&result))))
  89. if res != 0 {
  90. if res == E_FILENOTFOUND {
  91. // WebView2 is not installed
  92. return "", nil
  93. }
  94. return "", fmt.Errorf("Unable to call GetAvailableCoreWebView2BrowserVersionString (%x): %w", res, err)
  95. }
  96. version := windows.UTF16PtrToString(result)
  97. windows.CoTaskMemFree(unsafe.Pointer(result))
  98. return version, nil
  99. }
  100. // CreateCoreWebView2EnvironmentWithOptions tries to load WebviewLoader2 and
  101. // call the CreateCoreWebView2EnvironmentWithOptions routine.
  102. func CreateCoreWebView2EnvironmentWithOptions(browserExecutableFolder, userDataFolder *uint16, environmentCompletedHandle uintptr, additionalBrowserArgs string) (uintptr, error) {
  103. err := loadFromMemory()
  104. if err != nil {
  105. return 0, err
  106. }
  107. preventEnvAndRegistryOverrides(browserExecutableFolder, userDataFolder, additionalBrowserArgs)
  108. res, _, _ := memCreate.Call(
  109. uint64(uintptr(unsafe.Pointer(browserExecutableFolder))),
  110. uint64(uintptr(unsafe.Pointer(userDataFolder))),
  111. 0,
  112. uint64(environmentCompletedHandle),
  113. )
  114. return uintptr(res), nil
  115. }
  116. func loadFromMemory() error {
  117. var err error
  118. // DLL is not available natively. Try loading embedded copy.
  119. memOnce.Do(func() {
  120. memModule, memErr = winloader.LoadFromMemory(WebView2Loader)
  121. if memErr != nil {
  122. err = fmt.Errorf("Unable to load WebView2Loader.dll from memory: %w", memErr)
  123. return
  124. }
  125. memCreate = memModule.Proc("CreateCoreWebView2EnvironmentWithOptions")
  126. memCompareBrowserVersions = memModule.Proc("CompareBrowserVersions")
  127. memGetAvailableCoreWebView2BrowserVersionString = memModule.Proc("GetAvailableCoreWebView2BrowserVersionString")
  128. })
  129. return err
  130. }
  131. func preventEnvAndRegistryOverrides(browserFolder, userDataFolder *uint16, additionalBrowserArgs string) {
  132. // Setting these env variables to empty string also prevents registry overrides because webview2loader
  133. // checks for existence and not for empty value
  134. os.Setenv("WEBVIEW2_PIPE_FOR_SCRIPT_DEBUGGER", "")
  135. // Set these overrides to the values or empty to prevent registry and external env overrides
  136. os.Setenv("WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS", additionalBrowserArgs)
  137. os.Setenv("WEBVIEW2_RELEASE_CHANNEL_PREFERENCE", "0")
  138. os.Setenv("WEBVIEW2_BROWSER_EXECUTABLE_FOLDER", windows.UTF16PtrToString(browserFolder))
  139. os.Setenv("WEBVIEW2_USER_DATA_FOLDER", windows.UTF16PtrToString(userDataFolder))
  140. }
  141. func goGetAvailableCoreWebView2BrowserVersionString(browserExecutableFolder string) (string, error) {
  142. clientPath, err := findEmbeddedClientDll(browserExecutableFolder)
  143. if err != nil {
  144. return "", err
  145. }
  146. return findEmbeddedBrowserVersion(clientPath)
  147. }