syscall.go 3.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143
  1. //go:build windows
  2. package webviewloader
  3. import (
  4. "fmt"
  5. "syscall"
  6. "unicode/utf16"
  7. "unsafe"
  8. "golang.org/x/sys/windows"
  9. )
  10. var (
  11. modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
  12. procGlobalAlloc = modkernel32.NewProc("GlobalAlloc")
  13. procGlobalFree = modkernel32.NewProc("GlobalFree")
  14. modversion = windows.NewLazySystemDLL("version.dll")
  15. procGetFileVersionInfoSize = modversion.NewProc("GetFileVersionInfoSizeW")
  16. procGetFileVersionInfo = modversion.NewProc("GetFileVersionInfoW")
  17. procVerQueryValue = modversion.NewProc("VerQueryValueW")
  18. modole32 = windows.NewLazySystemDLL("ole32.dll")
  19. procCoTaskMemAlloc = modole32.NewProc("CoTaskMemAlloc")
  20. )
  21. func getFileVersionInfo(path string) ([]byte, error) {
  22. lptstrFilename, err := syscall.UTF16PtrFromString(path)
  23. if err != nil {
  24. return nil, err
  25. }
  26. size, _, err := procGetFileVersionInfoSize.Call(
  27. uintptr(unsafe.Pointer(lptstrFilename)),
  28. 0,
  29. )
  30. err = maskErrorSuccess(err)
  31. if size == 0 && err == nil {
  32. err = fmt.Errorf("GetFileVersionInfoSize failed")
  33. }
  34. if err != nil {
  35. return nil, err
  36. }
  37. data := make([]byte, size)
  38. ret, _, err := procGetFileVersionInfo.Call(
  39. uintptr(unsafe.Pointer(lptstrFilename)),
  40. 0,
  41. uintptr(size),
  42. uintptr(unsafe.Pointer(&data[0])),
  43. )
  44. err = maskErrorSuccess(err)
  45. if ret == 0 && err == nil {
  46. err = fmt.Errorf("GetFileVersionInfo failed")
  47. }
  48. if err != nil {
  49. return nil, err
  50. }
  51. return data, nil
  52. }
  53. func verQueryValueString(block []byte, subBlock string) (string, error) {
  54. // Allocate memory from native side to make sure the block doesn't get moved
  55. // because we get a pointer into that memory block from the native verQueryValue
  56. // call back.
  57. pBlock := globalAlloc(0, uint32(len(block)))
  58. defer globalFree(unsafe.Pointer(pBlock))
  59. // Copy the memory region into native side memory
  60. copy(unsafe.Slice((*byte)(pBlock), len(block)), block)
  61. lpSubBlock, err := syscall.UTF16PtrFromString(subBlock)
  62. if err != nil {
  63. return "", err
  64. }
  65. var lplpBuffer unsafe.Pointer
  66. var puLen uint
  67. ret, _, err := procVerQueryValue.Call(
  68. uintptr(pBlock),
  69. uintptr(unsafe.Pointer(lpSubBlock)),
  70. uintptr(unsafe.Pointer(&lplpBuffer)),
  71. uintptr(unsafe.Pointer(&puLen)),
  72. )
  73. err = maskErrorSuccess(err)
  74. if ret == 0 && err == nil {
  75. err = fmt.Errorf("VerQueryValue failed")
  76. }
  77. if err != nil {
  78. return "", err
  79. }
  80. if puLen <= 1 {
  81. return "", nil
  82. }
  83. puLen -= 1 // Remove Null-Terminator
  84. wchar := unsafe.Slice((*uint16)(lplpBuffer), puLen)
  85. return string(utf16.Decode(wchar)), nil
  86. }
  87. func globalAlloc(uFlags uint, dwBytes uint32) unsafe.Pointer {
  88. ret, _, _ := procGlobalAlloc.Call(
  89. uintptr(uFlags),
  90. uintptr(dwBytes))
  91. if ret == 0 {
  92. panic("globalAlloc failed")
  93. }
  94. return unsafe.Pointer(ret)
  95. }
  96. func globalFree(data unsafe.Pointer) {
  97. ret, _, _ := procGlobalFree.Call(uintptr(data))
  98. if ret != 0 {
  99. panic("globalFree failed")
  100. }
  101. }
  102. func maskErrorSuccess(err error) error {
  103. if err == windows.ERROR_SUCCESS {
  104. return nil
  105. }
  106. return err
  107. }
  108. func coTaskMemAlloc(size int) unsafe.Pointer {
  109. ret, _, _ := procCoTaskMemAlloc.Call(
  110. uintptr(size))
  111. if ret == 0 {
  112. panic("coTaskMemAlloc failed")
  113. }
  114. return unsafe.Pointer(ret)
  115. }