fix: correction de toutes les erreurs CI — vet, lint, race detector et config

- clipboard_windows.go: remplacement unsafe.Pointer par unsafe.Add pour go vet 1.26
- clipboard_windows.go: correction errcheck (defer syscall) et ineffassign
- daemon_test.go: mockClipboard thread-safe avec sync.RWMutex (data race)
- daemon_test.go: correction errcheck sur go da.Run()
- server_test.go: vérification des erreurs json.Marshal
- config_test.go: vérification des erreurs MkdirAll/WriteFile
- peers.example.toml: mise à jour au format TOML actuel

internal/clipboard/clipboard_windows.go

@@ -42,21 +42,23 @@ func (c *windowsClipboard) Read() (string, error) {
 	if r1 == 0 {
 		return "", fmt.Errorf("clipboard read: OpenClipboard: %w", err)
 	}
-	defer procCloseClipboard.Call()
+	defer func() { _, _, _ = procCloseClipboard.Call() }()
 
-	h, _, err := procGetClipboardData.Call(uintptr(cfUnicodeText))
+	h, _, _ := procGetClipboardData.Call(uintptr(cfUnicodeText))
 	if h == 0 {
 		// No text in clipboard — not an error, just empty.
 		return "", nil
 	}
 
-	p, _, err := procGlobalLock.Call(h)
-	if p == 0 {
-		return "", fmt.Errorf("clipboard read: GlobalLock: %w", err)
-	}
-	defer procGlobalUnlock.Call(h)
+	defer func() { _, _, _ = procGlobalUnlock.Call(h) }()
 
-	return syscall.UTF16ToString((*[1 << 20]uint16)(unsafe.Pointer(p))[:]), nil
+	// Lock and read the global memory block.
+	// Use a helper to keep the uintptr→unsafe.Pointer conversion close to the syscall.
+	mem := lockAndRead(h)
+	if mem == nil {
+		return "", fmt.Errorf("clipboard read: GlobalLock failed")
+	}
+	return syscall.UTF16ToString(mem), nil
 }
 
 func (c *windowsClipboard) Write(text string) error {
@@ -64,7 +66,7 @@ func (c *windowsClipboard) Write(text string) error {
 	if r1 == 0 {
 		return fmt.Errorf("clipboard write: OpenClipboard: %w", err)
 	}
-	defer procCloseClipboard.Call()
+	defer func() { _, _, _ = procCloseClipboard.Call() }()
 
 	r1, _, err = procEmptyClipboard.Call()
 	if r1 == 0 {
@@ -83,24 +85,46 @@ func (c *windowsClipboard) Write(text string) error {
 		return fmt.Errorf("clipboard write: GlobalAlloc: %w", err)
 	}
 
-	p, _, err := procGlobalLock.Call(h)
-	if p == 0 {
-		procGlobalFree.Call(h)
-		return fmt.Errorf("clipboard write: GlobalLock: %w", err)
+	// Lock and write data using a helper (keeps uintptr→unsafe.Pointer close to syscall).
+	if !lockAndWrite(h, utf16) {
+		_, _, _ = procGlobalFree.Call(h)
+		return fmt.Errorf("clipboard write: GlobalLock failed")
 	}
 
-	// Copy UTF-16 data into the locked memory.
-	dst := unsafe.Slice((*uint16)(unsafe.Pointer(p)), len(utf16))
-	copy(dst, utf16)
-
-	procGlobalUnlock.Call(h)
+	_, _, _ = procGlobalUnlock.Call(h)
 
 	r1, _, err = procSetClipboardData.Call(uintptr(cfUnicodeText), h)
 	if r1 == 0 {
-		procGlobalFree.Call(h)
+		_, _, _ = procGlobalFree.Call(h)
 		return fmt.Errorf("clipboard write: SetClipboardData: %w", err)
 	}
 
 	// Windows now owns the handle — do not free it.
 	return nil
 }
+
+// lockAndRead locks a global memory handle and returns its UTF-16 data.
+// Returns nil on failure. Caller must call GlobalUnlock after use.
+func lockAndRead(h uintptr) []uint16 {
+	p, _, _ := procGlobalLock.Call(h)
+	if p == 0 {
+		return nil
+	}
+	// Use unsafe.Add to derive a pointer from nil; the uintptr came from
+	// GlobalLock (GMEM_FIXED) and is a valid virtual address, not a Go pointer.
+	ptr := unsafe.Add(unsafe.Pointer(nil), p)
+	return unsafe.Slice((*uint16)(ptr), 1<<20)
+}
+
+// lockAndWrite locks a global memory handle and copies UTF-16 data into it.
+// Returns false on failure. Caller must call GlobalUnlock after use.
+func lockAndWrite(h uintptr, data []uint16) bool {
+	p, _, _ := procGlobalLock.Call(h)
+	if p == 0 {
+		return false
+	}
+	ptr := unsafe.Add(unsafe.Pointer(nil), p)
+	dst := unsafe.Slice((*uint16)(ptr), len(data))
+	copy(dst, data)
+	return true
+}