Files
rvbox/internal/client/windowstray/tray_windows.go
T

562 lines
17 KiB
Go

//go:build windows
package windowstray
// A deliberately small Win32 notification-area host. The tray has no
// durable state and no command execution path; it only renders a tooltip,
// sends enum actions over the authenticated service pipe, and opens paths
// returned by the service with the exact Windows Explorer executable.
import (
"context"
"errors"
"fmt"
"io"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"sync"
"syscall"
"time"
"unicode/utf8"
"unsafe"
winapi "golang.org/x/sys/windows"
)
const (
wmDestroy = 0x0002
wmClose = 0x0010
wmCommand = 0x0111
wmRButtonUp = 0x0205
wmLButtonDblClick = 0x0203
wmApp = 0x8000
trayMessage = wmApp + 1
trayResponse = wmApp + 2
trayIconID = 1
trayNIMAdd = 0
trayNIMModify = 1
trayNIMDelete = 2
trayNIFMessage = 0x00000001
trayNIFIcon = 0x00000002
trayNIFTip = 0x00000004
trayTPMRightBtn = 0x0002
trayMFString = 0x00000000
trayMFSeparator = 0x00000800
traySWHide = 0
trayIDIApplication = 32512
trayIDCArrow = 32512
)
var (
ErrTrayAlreadyRunning = errors.New("RVBox tray is already running in this session")
user32Tray = syscall.NewLazyDLL("user32.dll")
kernel32Tray = syscall.NewLazyDLL("kernel32.dll")
shell32Tray = syscall.NewLazyDLL("shell32.dll")
procRegisterClassEx = user32Tray.NewProc("RegisterClassExW")
procCreateWindowEx = user32Tray.NewProc("CreateWindowExW")
procDefWindowProc = user32Tray.NewProc("DefWindowProcW")
procGetMessage = user32Tray.NewProc("GetMessageW")
procTranslate = user32Tray.NewProc("TranslateMessage")
procDispatch = user32Tray.NewProc("DispatchMessageW")
procPostMessage = user32Tray.NewProc("PostMessageW")
procDestroyWindow = user32Tray.NewProc("DestroyWindow")
procShowWindow = user32Tray.NewProc("ShowWindow")
procPostQuitMessage = user32Tray.NewProc("PostQuitMessage")
procLoadIcon = user32Tray.NewProc("LoadIconW")
procLoadCursor = user32Tray.NewProc("LoadCursorW")
procCreatePopup = user32Tray.NewProc("CreatePopupMenu")
procAppendMenu = user32Tray.NewProc("AppendMenuW")
procTrackPopup = user32Tray.NewProc("TrackPopupMenu")
procDestroyMenu = user32Tray.NewProc("DestroyMenu")
procGetCursorPos = user32Tray.NewProc("GetCursorPos")
procSetForeground = user32Tray.NewProc("SetForegroundWindow")
procGetModuleHandle = kernel32Tray.NewProc("GetModuleHandleW")
procRegisterMessage = user32Tray.NewProc("RegisterWindowMessageW")
procShellNotify = shell32Tray.NewProc("Shell_NotifyIconW")
procShellIconRect = shell32Tray.NewProc("Shell_NotifyIconGetRect")
procFindWindow = user32Tray.NewProc("FindWindowW")
trayCallback = syscall.NewCallback(trayWindowProc)
trayWindows sync.Map // hwnd -> *trayWindow
taskbarCreatedMessage uint32
)
type trayPoint struct{ X, Y int32 }
type trayMessageRecord struct {
HWnd uintptr
Message uint32
WParam uintptr
LParam uintptr
Time uint32
Point trayPoint
}
type trayClass struct {
CbSize uint32
Style uint32
WndProc uintptr
CbClsExtra int32
CbWndExtra int32
HInstance uintptr
HIcon uintptr
HCursor uintptr
HbrBackground uintptr
MenuName *uint16
ClassName *uint16
HIconSm uintptr
}
type trayIconData struct {
CbSize uint32
HWnd uintptr
UID uint32
UFlags uint32
UCallbackMessage uint32
HIcon uintptr
Tip [128]uint16
State uint32
StateMask uint32
InfoData [256]uint16
TimeoutOrVersion uint32
InfoTitle [64]uint16
InfoFlags uint32
Guid [16]byte
BalloonIcon uintptr
}
type trayWindow struct {
hwnd uintptr
icon trayIconData
class *uint16
tooltip string
output io.Writer
closeOnce sync.Once
ctx context.Context
responses chan trayActionResult
pending bool // UI-thread owned; at most one bounded request at a time.
}
type trayActionResult struct {
action Action
response Frame
err error
}
// Run starts one notification icon for the current logged-in session. It
// returns when the icon is closed, the service becomes unavailable, or ctx is
// cancelled; none of those outcomes affect the machine-wide service.
func Run(ctx context.Context, output io.Writer) error {
mutex, err := acquireTrayMutex()
if err != nil {
return err
}
defer winapi.CloseHandle(mutex)
ctx, cancel := context.WithCancel(ctx)
defer cancel()
ready := make(chan *trayWindow, 1)
done := make(chan error, 1)
// Icon creation never waits for the daemon or the network. Status refresh
// is asynchronous after the icon exists, including when the service is down.
go runTrayMessageLoop(ctx, output, "RVBox service", ready, done)
var window *trayWindow
select {
case window = <-ready:
case err := <-done:
return err
case <-ctx.Done():
// Do not abandon an in-progress startup and leave an orphan icon.
select {
case window = <-ready:
_, _, _ = procPostMessage.Call(window.hwnd, wmClose, 0, 0)
return <-done
case err := <-done:
return err
}
}
select {
case <-ctx.Done():
if window != nil {
_, _, _ = procPostMessage.Call(window.hwnd, wmClose, 0, 0)
}
return <-done
case err := <-done:
return err
}
}
func acquireTrayMutex() (winapi.Handle, error) {
var sessionID uint32
if err := winapi.ProcessIdToSessionId(winapi.GetCurrentProcessId(), &sessionID); err != nil {
return 0, err
}
name, err := winapi.UTF16PtrFromString(fmt.Sprintf("Local\\RVBoxTrayV1-%d", sessionID))
if err != nil {
return 0, err
}
mutex, err := winapi.CreateMutex(nil, false, name)
if errors.Is(err, winapi.ERROR_ALREADY_EXISTS) {
if mutex != 0 {
_ = winapi.CloseHandle(mutex)
}
return 0, ErrTrayAlreadyRunning
}
if err != nil {
return 0, err
}
return mutex, nil
}
func runTrayMessageLoop(ctx context.Context, output io.Writer, tooltip string, ready chan<- *trayWindow, done chan<- error) {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if ctx.Err() != nil {
done <- nil
return
}
className, err := winapi.UTF16PtrFromString("RVBoxTrayWindowV1")
if err != nil {
done <- err
return
}
instance, _, _ := procGetModuleHandle.Call(0)
// Release builds embed the application's icon as resource 1. Unit-test
// binaries have no resource, so retain the standard icon as a fallback.
icon, _, _ := procLoadIcon.Call(instance, 1)
if icon == 0 {
icon, _, _ = procLoadIcon.Call(0, uintptr(trayIDIApplication))
}
cursor, _, _ := procLoadCursor.Call(0, uintptr(trayIDCArrow))
class := trayClass{CbSize: uint32(unsafe.Sizeof(trayClass{})), WndProc: trayCallback, HInstance: instance, HIcon: icon, HCursor: cursor, ClassName: className, HIconSm: icon}
if result, _, callErr := procRegisterClassEx.Call(uintptr(unsafe.Pointer(&class))); result == 0 && !errors.Is(callErr, winapi.ERROR_CLASS_ALREADY_EXISTS) {
done <- callErr
return
}
title, _ := winapi.UTF16PtrFromString("RVBox")
hwnd, _, callErr := procCreateWindowEx.Call(0, uintptr(unsafe.Pointer(className)), uintptr(unsafe.Pointer(title)), 0, 0, 0, 0, 0, 0, 0, instance, 0)
if hwnd == 0 {
done <- callErr
return
}
window := &trayWindow{hwnd: hwnd, class: className, tooltip: tooltip, output: output, ctx: ctx, responses: make(chan trayActionResult, 1)}
window.icon = trayIconData{CbSize: uint32(unsafe.Sizeof(trayIconData{})), HWnd: hwnd, UID: trayIconID, UFlags: trayNIFMessage | trayNIFIcon | trayNIFTip, UCallbackMessage: trayMessage, HIcon: icon}
copy(window.icon.Tip[:len(window.icon.Tip)-1], winapi.StringToUTF16(tooltip))
trayWindows.Store(hwnd, window)
messageName, _ := winapi.UTF16PtrFromString("TaskbarCreated")
registeredMessage, _, _ := procRegisterMessage.Call(uintptr(unsafe.Pointer(messageName)))
taskbarCreatedMessage = uint32(registeredMessage)
if err := window.addIcon(); err != nil {
trayWindows.Delete(hwnd)
_, _, _ = procDestroyWindow.Call(hwnd)
done <- err
return
}
_, _, _ = procShowWindow.Call(hwnd, traySWHide)
ready <- window
window.action(ActionStatus)
for {
var message trayMessageRecord
result, _, getErr := procGetMessage.Call(uintptr(unsafe.Pointer(&message)), 0, 0, 0)
if int32(result) == -1 {
window.removeIcon()
done <- getErr
return
}
if result == 0 {
window.removeIcon()
done <- nil
return
}
_, _, _ = procTranslate.Call(uintptr(unsafe.Pointer(&message)))
_, _, _ = procDispatch.Call(uintptr(unsafe.Pointer(&message)))
}
}
func trayWindowProc(hwnd uintptr, message uint32, wParam, lParam uintptr) uintptr {
value, _ := trayWindows.Load(hwnd)
window, _ := value.(*trayWindow)
switch message {
case wmClose:
_, _, _ = procDestroyWindow.Call(hwnd)
return 0
case wmDestroy:
if window != nil {
window.removeIcon()
}
trayWindows.Delete(hwnd)
procPostQuitMessage.Call(0)
return 0
case wmCommand:
if window != nil {
window.action(Action(uint16(wParam)))
}
return 0
case trayResponse:
if window != nil {
window.applyResponse()
}
return 0
case trayMessage:
if window != nil && (uint32(lParam) == wmRButtonUp || uint32(lParam) == wmLButtonDblClick) {
window.showMenu()
}
return 0
}
if window != nil && taskbarCreatedMessage != 0 && message == taskbarCreatedMessage {
// Explorer may restart without destroying the tray window. Re-add the
// icon with the current bounded tooltip so the frontend recovers without
// restarting the service or tray process.
_ = window.addIcon()
return 0
}
result, _, _ := procDefWindowProc.Call(hwnd, uintptr(message), wParam, lParam)
return result
}
func (window *trayWindow) addIcon() error {
window.icon.UFlags = trayNIFMessage | trayNIFIcon | trayNIFTip
if result, _, err := procShellNotify.Call(uintptr(trayNIMAdd), uintptr(unsafe.Pointer(&window.icon))); result == 0 {
if err == syscall.Errno(0) {
err = errors.New("Shell_NotifyIconW did not accept the notification icon")
}
return err
}
return nil
}
func (window *trayWindow) removeIcon() {
window.closeOnce.Do(func() {
window.icon.UFlags = 0
_, _, _ = procShellNotify.Call(uintptr(trayNIMDelete), uintptr(unsafe.Pointer(&window.icon)))
})
}
func (window *trayWindow) showMenu() {
menu, _, _ := procCreatePopup.Call()
if menu == 0 {
return
}
defer procDestroyMenu.Call(menu)
add := func(action Action, label string) {
text, _ := winapi.UTF16PtrFromString(label)
procAppendMenu.Call(menu, trayMFString, uintptr(action), uintptr(unsafe.Pointer(text)))
}
add(ActionStatus, "Status")
add(ActionOpenConfig, "Open config")
add(ActionOpenLog, "Open log")
procAppendMenu.Call(menu, trayMFSeparator, 0, 0)
add(ActionStartService, "Start service")
add(ActionStopService, "Stop service")
add(ActionRestartService, "Restart service")
add(ActionSetAutomatic, "Start automatically")
add(ActionSetManual, "Start manually")
procAppendMenu.Call(menu, trayMFSeparator, 0, 0)
add(ActionExitTray, "Exit")
var point trayPoint
procGetCursorPos.Call(uintptr(unsafe.Pointer(&point)))
procSetForeground.Call(window.hwnd)
procTrackPopup.Call(menu, trayTPMRightBtn, uintptr(point.X), uintptr(point.Y), 0, window.hwnd, 0)
}
func (window *trayWindow) action(action Action) {
if action == ActionExitTray {
_, _, _ = procDestroyWindow.Call(window.hwnd)
return
}
if window.pending {
return
}
window.pending = true
go func() {
response, err := Request(window.ctx, Frame{Action: action})
select {
case window.responses <- trayActionResult{action: action, response: response, err: err}:
_, _, _ = procPostMessage.Call(window.hwnd, trayResponse, 0, 0)
case <-window.ctx.Done():
}
}()
}
func (window *trayWindow) applyResponse() {
var result trayActionResult
select {
case result = <-window.responses:
default:
return
}
window.pending = false
action, response := result.action, result.response
if result.err != nil {
if isServiceMutation(action) {
// A stopped service has no pipe to answer Start. The same narrow
// UAC helper is valid both for absent IPC and denied authorization.
if err := runElevatedServiceAction(action); err == nil {
window.setTooltip("RVBox elevation requested")
return
}
}
window.setTooltip("RVBox service unavailable")
return
}
if isServiceMutation(action) && strings.HasPrefix(string(response.Payload), "error:") {
if err := runElevatedServiceAction(action); err == nil {
window.setTooltip("RVBox elevation requested")
return
}
}
if action == ActionOpenConfig || action == ActionOpenLog {
if err := openExactPath(string(response.Payload)); err != nil {
window.setTooltip("RVBox open failed")
}
return
}
if len(response.Payload) > 0 {
window.setTooltip(string(response.Payload))
}
}
// WaitReady is used only by the interactive installer in the same desktop
// session. It confirms Shell has accepted an actual icon, not merely that a
// child process was spawned. It never opens daemon config or state.
func WaitReady(ctx context.Context) error {
class, _ := winapi.UTF16PtrFromString("RVBoxTrayWindowV1")
type identifier struct {
Size uint32
HWnd uintptr
UID uint32
GUID [16]byte
}
type rectangle struct{ Left, Top, Right, Bottom int32 }
timer := time.NewTicker(50 * time.Millisecond)
defer timer.Stop()
for {
hwnd, _, _ := procFindWindow.Call(uintptr(unsafe.Pointer(class)), 0)
if hwnd != 0 {
id := identifier{Size: uint32(unsafe.Sizeof(identifier{})), HWnd: hwnd, UID: trayIconID}
var rect rectangle
result, _, _ := procShellIconRect.Call(uintptr(unsafe.Pointer(&id)), uintptr(unsafe.Pointer(&rect)))
if int32(result) == 0 {
return nil
}
}
select {
case <-ctx.Done():
return ctx.Err()
case <-timer.C:
}
}
}
// CloseCurrent lets an elevated installer update the canonical executable
// without leaving this desktop's old frontend holding the image open. It is
// deliberately a same-session window message, not service session injection.
func CloseCurrent(ctx context.Context) error {
class, _ := winapi.UTF16PtrFromString("RVBoxTrayWindowV1")
timer := time.NewTicker(50 * time.Millisecond)
defer timer.Stop()
for {
hwnd, _, _ := procFindWindow.Call(uintptr(unsafe.Pointer(class)), 0)
if hwnd == 0 {
return nil
}
_, _, _ = procPostMessage.Call(hwnd, wmClose, 0, 0)
select {
case <-ctx.Done():
return ctx.Err()
case <-timer.C:
}
}
}
func isServiceMutation(action Action) bool {
return action == ActionStartService || action == ActionStopService || action == ActionRestartService || action == ActionSetAutomatic || action == ActionSetManual
}
// runElevatedServiceAction is the tray's narrow UAC fallback. The service
// remains the authorization boundary; this helper only replays the enum as a
// canonical rvbox mode under an administrator token when the tray's filtered
// token cannot mutate SCM state directly.
func runElevatedServiceAction(action Action) error {
mode := ""
switch action {
case ActionStartService:
mode = "--start-service"
case ActionStopService:
mode = "--stop-service"
case ActionRestartService:
mode = "--restart-service"
case ActionSetAutomatic:
mode = "--configure-service --startup automatic"
case ActionSetManual:
mode = "--configure-service --startup manual"
default:
return errors.New("unsupported elevated tray action")
}
executable, err := os.Executable()
if err != nil {
return err
}
configPath := ""
for index := 0; index+1 < len(os.Args); index++ {
if os.Args[index] == "--config" {
configPath = os.Args[index+1]
break
}
}
if configPath == "" {
return errors.New("tray config path is unavailable")
}
args, err := winapi.UTF16PtrFromString(mode + " --config " + syscall.EscapeArg(configPath))
if err != nil {
return err
}
file, err := winapi.UTF16PtrFromString(executable)
if err != nil {
return err
}
if err := winapi.ShellExecute(0, mustUTF16("runas"), file, args, nil, winapi.SW_SHOWNORMAL); err != nil {
return err
}
return nil
}
func mustUTF16(value string) *uint16 {
encoded, _ := winapi.UTF16PtrFromString(value)
return encoded
}
func (window *trayWindow) setTooltip(value string) {
value = strings.TrimSpace(value)
if value == "" {
value = "RVBox service"
}
window.tooltip = value
window.icon.UFlags = trayNIFTip
for index := range window.icon.Tip {
window.icon.Tip[index] = 0
}
copy(window.icon.Tip[:len(window.icon.Tip)-1], winapi.StringToUTF16(value))
_, _, _ = procShellNotify.Call(uintptr(trayNIMModify), uintptr(unsafe.Pointer(&window.icon)))
}
func openExactPath(path string) error {
if path == "" || strings.TrimSpace(path) != path || !utf8.ValidString(path) || !filepath.IsAbs(path) {
return errors.New("invalid path returned by service")
}
info, err := os.Lstat(path)
if err != nil || !info.Mode().IsRegular() {
return errors.New("service path is not a regular file")
}
windowsDir, err := winapi.GetWindowsDirectory()
if err != nil {
return err
}
explorer := filepath.Join(windowsDir, "explorer.exe")
if info, err := os.Lstat(explorer); err != nil || !info.Mode().IsRegular() {
return errors.New("Windows Explorer is unavailable")
}
return exec.Command(explorer, path).Start()
}