fix(windows): start a responsive tray immediately after installation

This commit is contained in:
cabbage committed 2026-10-27 07:43:37 +00:00
1 parent 14cb3570c1
commit d59b2d5463
13 files changed
+850 -106

No files matched your search

@@ -0,0 +1,242 @@
//go:build windows
package windowstray
import (
"context"
"errors"
"fmt"
"io"
"runtime"
"strings"
"testing"
"time"
"unsafe"
winapi "golang.org/x/sys/windows"
)
func trayTestName() string {
return fmt.Sprintf(`\\.\pipe\rvbox-tray-test-%d-%d`, winapi.GetCurrentProcessId(), time.Now().UnixNano())
}
func trayTestServer(t *testing.T, handler func(context.Context, winapi.Handle)) string {
t.Helper()
name := trayTestName()
pipe, err := newTrayPipe(name)
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
done := make(chan struct{})
go func() {
defer close(done)
defer winapi.CloseHandle(pipe)
if connectTrayPipe(ctx, pipe) == nil {
handler(ctx, pipe)
}
}()
t.Cleanup(func() {
cancel()
select {
case <-done:
case <-time.After(2 * time.Second):
t.Error("pipe server did not shut down")
}
})
return name
}
func TestNativeTrayRequestRoundTrip_HP_WINTRAY_02(t *testing.T) {
var session uint32
if err := winapi.ProcessIdToSessionId(winapi.GetCurrentProcessId(), &session); err != nil {
t.Fatal(err)
}
seen := make(chan Peer, 1)
name := trayTestServer(t, func(ctx context.Context, pipe winapi.Handle) {
// serveTrayPipe owns its handle; the test server owns the original.
var duplicate winapi.Handle
process := winapi.CurrentProcess()
if err := winapi.DuplicateHandle(process, pipe, process, &duplicate, 0, false, winapi.DUPLICATE_SAME_ACCESS); err != nil {
t.Error(err)
return
}
serveTrayPipe(ctx, duplicate, func(_ context.Context, peer Peer, _ Frame) (Frame, error) {
seen <- peer
return Frame{Action: ActionStatus, Payload: []byte("native status OK")}, nil
})
})
response, err := requestNamedTrayPipe(context.Background(), name, Frame{Action: ActionStatus})
if err != nil {
t.Fatal(err)
}
if session == 0 {
if !strings.Contains(string(response.Payload), "not interactive") {
t.Fatalf("Session 0 rejection = %q", response.Payload)
}
return
}
if string(response.Payload) != "native status OK" {
t.Fatalf("response = %q", response.Payload)
}
peer := <-seen
if !peer.TokenVerified || !peer.Interactive || peer.SessionID != session || peer.PID != winapi.GetCurrentProcessId() {
t.Fatalf("peer = %#v", peer)
}
var token winapi.Token
if err := winapi.OpenProcessToken(winapi.CurrentProcess(), winapi.TOKEN_QUERY, &token); err != nil {
t.Fatal(err)
}
defer token.Close()
if peer.Administrator != token.IsElevated() {
t.Fatalf("enabled administrator membership=%t, elevated=%t", peer.Administrator, token.IsElevated())
}
}
func TestNativeTrayStalledServerDeadline_BH_WINTRAY_02(t *testing.T) {
name := trayTestServer(t, func(ctx context.Context, _ winapi.Handle) { <-ctx.Done() })
ctx, cancel := context.WithTimeout(context.Background(), 150*time.Millisecond)
defer cancel()
start := time.Now()
_, err := requestNamedTrayPipe(ctx, name, Frame{Action: ActionStatus})
if !errors.Is(err, context.DeadlineExceeded) || time.Since(start) > 2*time.Second {
t.Fatalf("stalled request = %v after %s", err, time.Since(start))
}
}
func TestNativeTrayMalformedResponse_BH_WINTRAY_03(t *testing.T) {
name := trayTestServer(t, func(ctx context.Context, pipe winapi.Handle) {
if _, err := readTrayFrame(ctx, pipe); err != nil {
t.Error(err)
return
}
_, _ = transferTrayPipe(ctx, pipe, []byte("invalid frame"), true)
_, _ = transferTrayPipe(ctx, pipe, make([]byte, 1), false)
})
_, err := requestNamedTrayPipe(context.Background(), name, Frame{Action: ActionStatus})
if !errors.Is(err, ErrInvalidFrame) {
t.Fatalf("malformed response = %v", err)
}
}
func TestNativeTrayRejectionBeforeRead_BH_WINTRAY_05(t *testing.T) {
name := trayTestServer(t, func(ctx context.Context, pipe winapi.Handle) {
// Reproduce an identity rejection before reading the request. A client
// FlushFileBuffers here would wait forever for a server read, while the
// server's flush waits for a client response read.
writeTrayResponse(ctx, pipe, ErrInvalidPeer)
buffer := make([]byte, maxFrameBytes)
for {
if _, err := transferTrayPipe(ctx, pipe, buffer, false); err != nil {
return
}
}
})
response, err := requestNamedTrayPipe(context.Background(), name, Frame{Action: ActionStatus})
if err != nil || !strings.Contains(string(response.Payload), ErrInvalidPeer.Error()) {
t.Fatalf("pre-read rejection = %q, %v", response.Payload, err)
}
}
func TestNativeTrayIdlePeersBoundedShutdown_BH_WINTRAY_04(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
name := trayTestName()
done := make(chan error, 1)
go func() {
done <- serveNamedTrayPipe(ctx, name, func(context.Context, Peer, Frame) (Frame, error) { return Frame{Action: ActionStatus}, nil })
}()
var clients []winapi.Handle
t.Cleanup(func() {
cancel()
for _, handle := range clients {
_ = winapi.CloseHandle(handle)
}
})
path, _ := winapi.UTF16PtrFromString(name)
for i := 0; i < pipeInstances; i++ {
deadline := time.Now().Add(2 * time.Second)
for {
handle, err := winapi.CreateFile(path, winapi.GENERIC_READ|winapi.GENERIC_WRITE, 0, nil, winapi.OPEN_EXISTING, winapi.FILE_FLAG_OVERLAPPED, 0)
if err == nil {
clients = append(clients, handle)
break
}
if time.Now().After(deadline) {
t.Fatal(err)
}
time.Sleep(5 * time.Millisecond)
}
}
requestCtx, requestCancel := context.WithTimeout(ctx, 150*time.Millisecond)
_, err := requestNamedTrayPipe(requestCtx, name, Frame{Action: ActionStatus})
requestCancel()
if !errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("ninth stalled peer = %v", err)
}
cancel()
select {
case err := <-done:
if err != nil {
t.Fatal(err)
}
case <-time.After(2 * time.Second):
t.Fatal("service did not cancel its accept and idle reads")
}
}
func TestNativeTrayIconLayout_HP_WINTRAY_03(t *testing.T) {
if runtime.GOARCH != "amd64" {
t.Skip("v1 Windows executable is amd64")
}
var icon trayIconData
if unsafe.Sizeof(icon) != 976 || unsafe.Offsetof(icon.InfoData) != 304 || unsafe.Offsetof(icon.TimeoutOrVersion) != 816 || unsafe.Offsetof(icon.InfoTitle) != 820 || unsafe.Offsetof(icon.InfoFlags) != 948 || unsafe.Offsetof(icon.Guid) != 952 {
t.Fatalf("NOTIFYICONDATAW layout mismatch: size=%d info=%d title=%d flags=%d", unsafe.Sizeof(icon), unsafe.Offsetof(icon.InfoData), unsafe.Offsetof(icon.InfoTitle), unsafe.Offsetof(icon.InfoFlags))
}
}
func TestNativeTrayWindowLifecycle_HP_WINTRAY_04(t *testing.T) {
var session uint32
if err := winapi.ProcessIdToSessionId(winapi.GetCurrentProcessId(), &session); err != nil {
t.Fatal(err)
}
if session == 0 {
t.Skip("requires the real interactive Windows fixture desktop")
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
ready := make(chan *trayWindow, 1)
done := make(chan error, 1)
go runTrayMessageLoop(ctx, io.Discard, "RVBox native tray test", ready, done)
var window *trayWindow
select {
case window = <-ready:
case err := <-done:
t.Fatalf("tray startup failed: %v", err)
case <-time.After(5 * time.Second):
t.Fatal("tray startup blocked before creating its icon")
}
defer procPostMessage.Call(window.hwnd, wmClose, 0, 0)
readyCtx, readyCancel := context.WithTimeout(ctx, time.Second)
defer readyCancel()
if err := WaitReady(readyCtx); err != nil {
t.Fatalf("Shell did not confirm its registered icon: %v", err)
}
send := user32Tray.NewProc("SendMessageTimeoutW")
for i := 0; i < 10; i++ {
runtime.GC()
var result uintptr
ok, _, err := send.Call(window.hwnd, 0, 0, 0, 2, 1000, uintptr(unsafe.Pointer(&result)))
if ok == 0 {
t.Fatalf("window message loop stopped responding after GC: %v", err)
}
}
_, _, _ = procPostMessage.Call(window.hwnd, wmClose, 0, 0)
select {
case err := <-done:
if err != nil {
t.Fatal(err)
}
case <-time.After(2 * time.Second):
t.Fatal("tray did not process close on its owning thread")
}
}
@@ -0,0 +1,66 @@
//go:build windows
package windowstray
import (
"context"
"errors"
"runtime"
winapi "golang.org/x/sys/windows"
)
// Each operation owns its OVERLAPPED/event until cancellation has actually
// completed. Closing a synchronous pipe from another goroutine does not provide
// the bounded shutdown/deadline contract needed by a desktop frontend.
func trayOverlapped(ctx context.Context, handle winapi.Handle, start func(*winapi.Overlapped, *uint32) error) (uint32, error) {
if err := ctx.Err(); err != nil {
return 0, err
}
event, err := winapi.CreateEvent(nil, 1, 0, nil)
if err != nil {
return 0, err
}
defer winapi.CloseHandle(event)
overlapped := winapi.Overlapped{HEvent: event}
var transferred uint32
err = start(&overlapped, &transferred)
if !errors.Is(err, winapi.ERROR_IO_PENDING) {
return transferred, err
}
cancelled := make(chan struct{})
stop := context.AfterFunc(ctx, func() {
_ = winapi.CancelIoEx(handle, &overlapped)
close(cancelled)
})
err = winapi.GetOverlappedResult(handle, &overlapped, &transferred, true)
if !stop() {
<-cancelled
}
if err != nil && ctx.Err() != nil {
return transferred, ctx.Err()
}
return transferred, err
}
func connectTrayPipe(ctx context.Context, handle winapi.Handle) error {
_, err := trayOverlapped(ctx, handle, func(overlapped *winapi.Overlapped, _ *uint32) error {
err := winapi.ConnectNamedPipe(handle, overlapped)
if errors.Is(err, winapi.ERROR_PIPE_CONNECTED) {
return nil
}
return err
})
return err
}
func transferTrayPipe(ctx context.Context, handle winapi.Handle, buffer []byte, write bool) (uint32, error) {
n, err := trayOverlapped(ctx, handle, func(overlapped *winapi.Overlapped, transferred *uint32) error {
if write {
return winapi.WriteFile(handle, buffer, transferred, overlapped)
}
return winapi.ReadFile(handle, buffer, transferred, overlapped)
})
runtime.KeepAlive(buffer)
return n, err
}
@@ -18,3 +18,7 @@ func Serve(context.Context, Handler) error { return ErrUnsupported }
func Request(context.Context, Frame) (Frame, error) { return Frame{}, ErrUnsupported }
func Run(context.Context, io.Writer) error { return ErrUnsupported }
func WaitReady(context.Context) error { return ErrUnsupported }
func CloseCurrent(context.Context) error { return ErrUnsupported }
+95 -61
View File
@@ -13,7 +13,7 @@ import (
"errors"
"fmt"
"io"
"os"
"sync"
"time"
"unsafe"
@@ -23,6 +23,8 @@ import (
const (
pipeBufferBytes = 64 << 10
pipeInstances = 8
requestTimeout = 3 * time.Second
peerTimeout = 5 * time.Second
)
var (
@@ -34,41 +36,53 @@ var (
// run before any interactive user logs in; in that state no client can pass
// the interactive-peer authorization check.
func Serve(ctx context.Context, handler Handler) error {
return serveNamedTrayPipe(ctx, PipeName, handler)
}
func serveNamedTrayPipe(ctx context.Context, name string, handler Handler) error {
if handler == nil {
return errors.New("tray handler is required")
}
ctx, cancel := context.WithCancel(ctx)
var workers sync.WaitGroup
defer func() { cancel(); workers.Wait() }()
active := make(chan struct{}, pipeInstances)
for {
pipe, err := newTrayPipe()
if err != nil {
return fmt.Errorf("create tray pipe: %w", err)
}
connected := make(chan error, 1)
go func() { connected <- winapi.ConnectNamedPipe(winapi.Handle(pipe.Fd()), nil) }()
select {
case <-ctx.Done():
_ = pipe.Close()
return nil
case err := <-connected:
if err != nil && !errors.Is(err, winapi.ERROR_PIPE_CONNECTED) {
_ = pipe.Close()
if ctx.Err() != nil {
return nil
}
continue
}
go serveTrayPipe(ctx, pipe, handler)
case active <- struct{}{}:
}
pipe, err := newTrayPipe(name)
if err != nil {
<-active
return fmt.Errorf("create tray pipe: %w", err)
}
if err := connectTrayPipe(ctx, pipe); err != nil {
_ = winapi.CloseHandle(pipe)
<-active
if ctx.Err() != nil {
return nil
}
continue
}
workers.Add(1)
go func() {
defer workers.Done()
defer func() { <-active }()
serveTrayPipe(ctx, pipe, handler)
}()
}
}
func newTrayPipe() (*os.File, error) {
name, err := winapi.UTF16PtrFromString(PipeName)
func newTrayPipe(pipeName string) (winapi.Handle, error) {
name, err := winapi.UTF16PtrFromString(pipeName)
if err != nil {
return nil, err
return 0, err
}
descriptor, err := winapi.SecurityDescriptorFromString(pipeSDDL)
if err != nil {
return nil, err
return 0, err
}
attributes := &winapi.SecurityAttributes{
Length: uint32(unsafe.Sizeof(winapi.SecurityAttributes{})),
@@ -78,47 +92,49 @@ func newTrayPipe() (*os.File, error) {
// client rejection belongs to the latter; placing it in open mode produces
// ERROR_INVALID_PARAMETER on Windows. We inspect the client token directly
// and never impersonate it, so no SQOS/impersonation flag is needed here.
openMode := uint32(winapi.PIPE_ACCESS_DUPLEX)
openMode := uint32(winapi.PIPE_ACCESS_DUPLEX | winapi.FILE_FLAG_OVERLAPPED)
pipeMode := uint32(winapi.PIPE_TYPE_MESSAGE | winapi.PIPE_READMODE_MESSAGE | winapi.PIPE_WAIT | winapi.PIPE_REJECT_REMOTE_CLIENTS)
handle, err := winapi.CreateNamedPipe(name, openMode, pipeMode, pipeInstances, pipeBufferBytes, pipeBufferBytes, 0, attributes)
if err != nil {
return nil, err
return 0, err
}
return os.NewFile(uintptr(handle), "rvbox-tray-pipe"), nil
return handle, nil
}
func serveTrayPipe(ctx context.Context, pipe *os.File, handler Handler) {
if pipe == nil {
return
}
defer pipe.Close()
// A blocked Read must be interrupted when service shutdown cancels ctx.
readDone := make(chan struct{})
go func() {
select {
case <-ctx.Done():
_ = pipe.Close()
case <-readDone:
func serveTrayPipe(ctx context.Context, pipe winapi.Handle, handler Handler) {
defer winapi.CloseHandle(pipe)
ctx, cancel := context.WithTimeout(ctx, peerTimeout)
defer cancel()
respond := func(value any) {
writeTrayResponse(ctx, pipe, value)
// Keep buffered response bytes alive until the one-shot client closes.
// Unlike FlushFileBuffers this read is cancellable and deadline-bounded;
// no additional acknowledgement frame is required on the wire.
buffer := make([]byte, maxFrameBytes)
for ctx.Err() == nil {
n, err := transferTrayPipe(ctx, pipe, buffer, false)
if err != nil && !errors.Is(err, winapi.ERROR_MORE_DATA) || n == 0 {
break
}
}
}()
defer close(readDone)
peer, err := peerFromPipe(winapi.Handle(pipe.Fd()))
}
peer, err := peerFromPipe(pipe)
if err != nil {
writeTrayResponse(pipe, err)
respond(err)
return
}
request, err := readTrayFrame(pipe)
request, err := readTrayFrame(ctx, pipe)
if err != nil {
writeTrayResponse(pipe, err)
respond(err)
return
}
if err := Authorize(peer, request.Action); err != nil {
writeTrayResponse(pipe, err)
respond(err)
return
}
response, err := handler(ctx, peer, request)
if err != nil {
writeTrayResponse(pipe, err)
respond(err)
return
}
if response.Action == 0 {
@@ -127,22 +143,25 @@ func serveTrayPipe(ctx context.Context, pipe *os.File, handler Handler) {
if response.Action != ActionStatus {
response = Frame{Action: ActionStatus}
}
writeTrayResponse(pipe, response)
respond(response)
}
func readTrayFrame(reader io.Reader) (Frame, error) {
func readTrayFrame(ctx context.Context, pipe winapi.Handle) (Frame, error) {
buffer := make([]byte, maxFrameBytes)
count, err := reader.Read(buffer)
count, err := transferTrayPipe(ctx, pipe, buffer, false)
if errors.Is(err, winapi.ERROR_MORE_DATA) {
return Frame{}, ErrFrameTooLarge
}
if err != nil {
return Frame{}, err
}
if count == len(buffer) {
if int(count) == len(buffer) {
return Frame{}, ErrFrameTooLarge
}
return Decode(buffer[:count])
}
func writeTrayResponse(writer *os.File, value any) {
func writeTrayResponse(ctx context.Context, pipe winapi.Handle, value any) {
frame := Frame{Action: ActionStatus}
switch response := value.(type) {
case Frame:
@@ -158,8 +177,7 @@ func writeTrayResponse(writer *os.File, value any) {
if err != nil {
return
}
_, _ = writer.Write(encoded)
_ = winapi.FlushFileBuffers(winapi.Handle(writer.Fd()))
_, _ = transferTrayPipe(ctx, pipe, encoded, true)
}
func peerFromPipe(pipe winapi.Handle) (Peer, error) {
@@ -193,10 +211,19 @@ func peerFromPipe(pipe winapi.Handle) (Peer, error) {
if err != nil {
return Peer{}, ErrInvalidPeer
}
admin, err := token.IsMember(adminSID)
groups, err := token.GetTokenGroups()
if err != nil {
return Peer{}, ErrInvalidPeer
}
// OpenProcessToken returns a primary token; CheckTokenMembership requires
// an impersonation token. Inspect enabled groups directly, excluding the
// deny-only Administrators SID in a normal split-token user's token.
admin := false
for _, group := range groups.AllGroups() {
if group.Sid != nil && group.Sid.Equals(adminSID) && group.Attributes&winapi.SE_GROUP_ENABLED != 0 && group.Attributes&winapi.SE_GROUP_USE_FOR_DENY_ONLY == 0 {
admin = true
}
}
sid := user.User.Sid.String()
return Peer{PID: pid, SessionID: sessionID, SID: sid, TokenVerified: true, Interactive: sessionID != 0, Administrator: admin, System: sid == "S-1-5-18"}, nil
}
@@ -205,22 +232,28 @@ func peerFromPipe(pipe winapi.Handle) (Peer, error) {
// It retries only the transient ERROR_PIPE_BUSY state and never falls back to
// an arbitrary filesystem/socket path.
func Request(ctx context.Context, request Frame) (Frame, error) {
return requestNamedTrayPipe(ctx, PipeName, request)
}
func requestNamedTrayPipe(ctx context.Context, pipeName string, request Frame) (Frame, error) {
ctx, cancel := context.WithTimeout(ctx, requestTimeout)
defer cancel()
encoded, err := Encode(request)
if err != nil {
return Frame{}, err
}
var pipe *os.File
var pipe winapi.Handle
for {
if ctx.Err() != nil {
return Frame{}, ctx.Err()
}
name, nameErr := winapi.UTF16PtrFromString(PipeName)
name, nameErr := winapi.UTF16PtrFromString(pipeName)
if nameErr != nil {
return Frame{}, nameErr
}
handle, openErr := winapi.CreateFile(name, winapi.GENERIC_READ|winapi.GENERIC_WRITE, 0, nil, winapi.OPEN_EXISTING, 0, 0)
handle, openErr := winapi.CreateFile(name, winapi.GENERIC_READ|winapi.GENERIC_WRITE, 0, nil, winapi.OPEN_EXISTING, winapi.FILE_FLAG_OVERLAPPED, 0)
if openErr == nil {
pipe = os.NewFile(uintptr(handle), "rvbox-tray-client")
pipe = handle
break
}
if !errors.Is(openErr, winapi.ERROR_PIPE_BUSY) {
@@ -234,14 +267,15 @@ func Request(ctx context.Context, request Frame) (Frame, error) {
case <-timer.C:
}
}
defer pipe.Close()
defer winapi.CloseHandle(pipe)
state := uint32(winapi.PIPE_READMODE_MESSAGE)
_ = winapi.SetNamedPipeHandleState(winapi.Handle(pipe.Fd()), &state, nil, nil)
if _, err := pipe.Write(encoded); err != nil {
if err := winapi.SetNamedPipeHandleState(pipe, &state, nil, nil); err != nil {
return Frame{}, err
}
if err := winapi.FlushFileBuffers(winapi.Handle(pipe.Fd())); err != nil {
if n, err := transferTrayPipe(ctx, pipe, encoded, true); err != nil {
return Frame{}, err
} else if int(n) != len(encoded) {
return Frame{}, io.ErrShortWrite
}
return readTrayFrame(pipe)
return readTrayFrame(ctx, pipe)
}
+141 -22
View File
@@ -15,9 +15,11 @@ import (
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"sync"
"syscall"
"time"
"unicode/utf8"
"unsafe"
@@ -32,6 +34,7 @@ const (
wmLButtonDblClick = 0x0203
wmApp = 0x8000
trayMessage = wmApp + 1
trayResponse = wmApp + 2
trayIconID = 1
trayNIMAdd = 0
trayNIMModify = 1
@@ -50,6 +53,7 @@ const (
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")
@@ -69,9 +73,11 @@ var (
procDestroyMenu = user32Tray.NewProc("DestroyMenu")
procGetCursorPos = user32Tray.NewProc("GetCursorPos")
procSetForeground = user32Tray.NewProc("SetForegroundWindow")
procGetModuleHandle = user32Tray.NewProc("GetModuleHandleW")
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
@@ -113,9 +119,10 @@ type trayIconData struct {
Tip [128]uint16
State uint32
StateMask uint32
InfoFlags uint32
InfoTitle [64]uint16
InfoData [256]uint16
TimeoutOrVersion uint32
InfoTitle [64]uint16
InfoFlags uint32
Guid [16]byte
BalloonIcon uintptr
}
@@ -127,6 +134,15 @@ type trayWindow struct {
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
@@ -138,24 +154,27 @@ func Run(ctx context.Context, output io.Writer) error {
return err
}
defer winapi.CloseHandle(mutex)
response, err := Request(ctx, Frame{Action: ActionStatus})
tooltip := "RVBox service unavailable"
if err == nil {
tooltip = string(response.Payload)
}
if tooltip == "" {
tooltip = "RVBox service"
}
ctx, cancel := context.WithCancel(ctx)
defer cancel()
ready := make(chan *trayWindow, 1)
done := make(chan error, 1)
go runTrayMessageLoop(output, tooltip, ready, done)
// 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():
return nil
// 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():
@@ -177,7 +196,7 @@ func acquireTrayMutex() (winapi.Handle, error) {
if err != nil {
return 0, err
}
mutex, err := winapi.CreateMutex(nil, true, name)
mutex, err := winapi.CreateMutex(nil, false, name)
if errors.Is(err, winapi.ERROR_ALREADY_EXISTS) {
if mutex != 0 {
_ = winapi.CloseHandle(mutex)
@@ -190,14 +209,25 @@ func acquireTrayMutex() (winapi.Handle, error) {
return mutex, nil
}
func runTrayMessageLoop(output io.Writer, tooltip string, ready chan<- *trayWindow, done chan<- error) {
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)
icon, _, _ := procLoadIcon.Call(0, uintptr(trayIDIApplication))
// 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) {
@@ -210,9 +240,9 @@ func runTrayMessageLoop(output io.Writer, tooltip string, ready chan<- *trayWind
done <- callErr
return
}
window := &trayWindow{hwnd: hwnd, class: className, tooltip: tooltip, output: output}
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[:], winapi.StringToUTF16(tooltip))
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)))
@@ -225,6 +255,7 @@ func runTrayMessageLoop(output io.Writer, tooltip string, ready chan<- *trayWind
}
_, _, _ = procShowWindow.Call(hwnd, traySWHide)
ready <- window
window.action(ActionStatus)
for {
var message trayMessageRecord
result, _, getErr := procGetMessage.Call(uintptr(unsafe.Pointer(&message)), 0, 0, 0)
@@ -262,6 +293,11 @@ func trayWindowProc(hwnd uintptr, message uint32, wParam, lParam uintptr) uintpt
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()
@@ -283,7 +319,7 @@ 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 = syscall.GetLastError()
err = errors.New("Shell_NotifyIconW did not accept the notification icon")
}
return err
}
@@ -329,8 +365,38 @@ func (window *trayWindow) action(action Action) {
_, _, _ = procDestroyWindow.Call(window.hwnd)
return
}
response, err := Request(context.Background(), Frame{Action: action})
if err != nil {
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
}
@@ -351,6 +417,59 @@ func (window *trayWindow) action(action Action) {
}
}
// 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
}
@@ -418,7 +537,7 @@ func (window *trayWindow) setTooltip(value string) {
for index := range window.icon.Tip {
window.icon.Tip[index] = 0
}
copy(window.icon.Tip[:], winapi.StringToUTF16(value))
copy(window.icon.Tip[:len(window.icon.Tip)-1], winapi.StringToUTF16(value))
_, _, _ = procShellNotify.Call(uintptr(trayNIMModify), uintptr(unsafe.Pointer(&window.icon)))
}