//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" "github.com/rvbox/rvbox/internal/client/windowsservice" winapi "golang.org/x/sys/windows" ) const ( wmDestroy = 0x0002 wmClose = 0x0010 wmCommand = 0x0111 wmTimer = 0x0113 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 trayMFDisabled = 0x00000001 trayMFChecked = 0x00000008 trayMFByPosition = 0x00000400 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") procModifyMenu = user32Tray.NewProc("ModifyMenuW") 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") procSetTimer = user32Tray.NewProc("SetTimer") procKillTimer = user32Tray.NewProc("KillTimer") 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 background status request. logPending bool configPath string status MenuStatus menu uintptr } type trayActionResult struct { action Action response Frame err error status *MenuStatus } // 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, configPath string, 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, "Status: checking", ready, done, configPath) 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, configPath string) { 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, 2), status: MenuStatus{Label: "Status: checking"}, configPath: configPath} 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) _, _, _ = procSetTimer.Call(hwnd, 1, 2000, 0) defer procKillTimer.Call(hwnd, 1) 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 { action := Action(uint16(wParam)) if action == ActionSetAutomatic { action = automaticAction(window.status.AutoStart) } window.action(action) } return 0 case wmTimer: if window != nil { window.action(ActionStatus) } 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) window.menu = menu defer func() { window.menu = 0 }() for _, item := range trayMenu(window.status) { flags, text := menuItemFlags(item) procAppendMenu.Call(menu, flags, uintptr(item.Action), uintptr(unsafe.Pointer(text))) } window.action(ActionStatus) 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 menuItemFlags(item menuItem) (uintptr, *uint16) { if item.Separator { return trayMFSeparator, nil } flags := uintptr(trayMFString) if item.Disabled { flags |= trayMFDisabled } if item.Checked { flags |= trayMFChecked } text, _ := winapi.UTF16PtrFromString(item.Label) return flags, text } func (window *trayWindow) refreshMenu() { if window.menu == 0 { return } for index, item := range trayMenu(window.status) { flags, text := menuItemFlags(item) procModifyMenu.Call(window.menu, uintptr(index), flags|trayMFByPosition, uintptr(item.Action), uintptr(unsafe.Pointer(text))) } } func (window *trayWindow) action(action Action) { if action == ActionExitTray { _, _, _ = procDestroyWindow.Call(window.hwnd) return } if action == ActionOpenConfig { if err := openExactPath(window.configPath); err != nil { window.setTooltip("RVBox: could not open config") } return } if isServiceMutation(action) { // Service control remains a narrow UAC helper. It does not depend on // a live pipe, and a background status poll cannot swallow this click. if err := runElevatedServiceAction(action, window.configPath); err != nil && !errors.Is(err, winapi.ERROR_CANCELLED) { window.setTooltip("RVBox: service action could not start") } window.action(ActionStatus) return } if action == ActionStatus { if window.pending { return } window.pending = true } else if action == ActionOpenLog { if window.logPending { return } window.logPending = true } else { return } go func() { result := trayActionResult{action: action} if action == ActionStatus { service, err := windowsservice.Query() connection := "" if err == nil && service.State == windowsservice.StateRunning { response, requestErr := Request(window.ctx, Frame{Action: ActionStatus}) if requestErr == nil { connection = string(response.Payload) } } status := menuStatus(service, err, connection) result.status = &status } else { result.response, result.err = Request(window.ctx, Frame{Action: action}) } select { case window.responses <- result: _, _, _ = 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 } action, response := result.action, result.response if action == ActionStatus && result.status != nil { window.pending = false window.status = *result.status window.setTooltip("RVBox — " + window.status.Label) window.refreshMenu() return } window.logPending = false if result.err != nil { window.setTooltip("RVBox service unavailable") return } if 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 { timer := time.NewTicker(50 * time.Millisecond) defer timer.Stop() for { if IsReady() { return nil } select { case <-ctx.Done(): return ctx.Err() case <-timer.C: } } } // IsReady probes this desktop once; it neither contacts SCM nor starts a tray. func IsReady() bool { class, _ := winapi.UTF16PtrFromString("RVBoxTrayWindowV1") type identifier struct { Size uint32 HWnd uintptr UID uint32 GUID [16]byte } type rectangle struct{ Left, Top, Right, Bottom int32 } 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 iconQuerySucceeded(result) { return true } } return false } // CloseCurrent lets an elevated installer update the canonical executable // without leaving this desktop's old frontend holding the image open. It is // a same-session window message followed by waiting for process exit. func CloseCurrent(ctx context.Context) error { class, _ := winapi.UTF16PtrFromString("RVBoxTrayWindowV1") for { if err := ctx.Err(); err != nil { return err } hwnd, _, _ := procFindWindow.Call(uintptr(unsafe.Pointer(class)), 0) if hwnd == 0 { return nil } var pid uint32 _, _, _ = user32Tray.NewProc("GetWindowThreadProcessId").Call(hwnd, uintptr(unsafe.Pointer(&pid))) process, err := winapi.OpenProcess(winapi.SYNCHRONIZE, false, pid) if err != nil { if errors.Is(err, winapi.ERROR_INVALID_PARAMETER) { continue } return fmt.Errorf("wait for old tray process: %w", err) } _, _, _ = procPostMessage.Call(hwnd, wmClose, 0, 0) for { result, waitErr := winapi.WaitForSingleObject(process, 50) if waitErr != nil || result == winapi.WAIT_OBJECT_0 { _ = winapi.CloseHandle(process) if waitErr != nil { return waitErr } break } if ctx.Err() != nil { _ = winapi.CloseHandle(process) return ctx.Err() } } } } 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, configPath string) 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 } 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() }