Debian Codegraph @

windows/xattr_test.go

raw
1 // Copyright 2026 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 //go:build windows
6
7 package windows_test
8
9 import (
10 "bytes"
11 "encoding/binary"
12 "fmt"
13 "io"
14 "os"
15 "path/filepath"
16 "strings"
17 "testing"
18 "unsafe"
19
20 "golang.org/x/sys/windows"
21 )
22
23 func TestFdXattr(t *testing.T) {
24 fp := filepath.Join(t.TempDir(), "test_fd_xattr.txt")
25 wantContent := "I am an xattr testing file. I will get some xattrs attached."
26 wantXa := map[string]string{
27 "xattr-key-1": "Value for xattr-key-1",
28 "xattr-key-2": "Also value, but for xattr-key-2",
29 "xattr-key-3": "xattr-key-3 needs a value too",
30 "xattr-key-4": "xattr-key-4 never wanted any value but got one anyway",
31 }
32
33 xattrSet(t, fp, wantContent, wantXa)
34
35 fr, err := os.Open(fp)
36 if err != nil {
37 t.Fatalf("Open for read error: %v", err)
38 }
39 defer fr.Close()
40
41 haveContent, err := io.ReadAll(fr)
42
43 if err != nil {
44 t.Fatalf("Read error: %v", err)
45 }
46 if string(haveContent) != wantContent {
47 t.Fatalf("File content mismatch: want %q, have %q", wantContent, string(haveContent))
48 }
49
50 haveXa, err := winGetEa(fr)
51 if err != nil {
52 t.Fatalf("Windows get EA error: %v", err)
53 }
54
55 for k, v := range wantXa {
56 if haveXa[k] != v {
57 t.Fatalf("XAttr mismatch for key %q: want %q, have %q", k, v, haveXa[k])
58 }
59 }
60 }
61
62 func xattrSet(t *testing.T, fp string, content string, xa map[string]string) {
63 fw, err := os.OpenFile(fp, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0o600)
64 if err != nil {
65 t.Fatalf("Open for write error: %v", err)
66 }
67 defer fw.Close()
68
69 _, err = fw.WriteString(content)
70 if err != nil {
71 t.Fatalf("Write error: %v", err)
72 }
73
74 err = winSetEa(fw, xa)
75 if err != nil {
76 if err == windows.STATUS_EAS_NOT_SUPPORTED {
77 t.Skip("filesystem does not support extended attributes, skipping test")
78 }
79 t.Fatalf("Windows set EA error: %v", err)
80 }
81 }
82
83 // ExtendedAttribute represents a single Windows EA.
84 type extendedAttribute struct {
85 Name string
86 Value []byte
87 Flags uint8
88 }
89
90 type fileFullEaInformation struct {
91 NextEntryOffset uint32
92 Flags uint8
93 NameLength uint8
94 ValueLength uint16
95 }
96
97 var fileFullEaInformationSize = binary.Size(&fileFullEaInformation{})
98
99 // Windows just cannot keep its hands off letter case
100 func keyToAttrName(k string) string {
101 return strings.ToUpper(k)
102 }
103
104 func attrNameToKey(k string) string {
105 return strings.ToLower(k)
106 }
107
108 func winSetEa(f *os.File, xattrs map[string]string) error {
109 eas := make([]extendedAttribute, 0, len(xattrs))
110
111 for k, v := range xattrs {
112 eas = append(eas, extendedAttribute{
113 Name: keyToAttrName(k),
114 Value: []byte(v),
115 })
116 }
117
118 eaBuf, err := encodeExtendedAttributes(eas)
119 if err != nil {
120 return err
121 }
122
123 var iosb windows.IO_STATUS_BLOCK
124 err = windows.NtSetEaFile(
125 windows.Handle(f.Fd()), &iosb, &eaBuf[0], uint32(len(eaBuf)),
126 )
127
128 if err != nil {
129 return err
130 }
131
132 return nil
133 }
134
135 func winGetEa(f *os.File) (map[string]string, error) {
136 sz, err := getEaBlockSize(f)
137 if err != nil || sz == 0 {
138 return nil, err
139 }
140
141 var iosb windows.IO_STATUS_BLOCK
142 eaBuf := make([]byte, int(sz))
143
144 err = windows.NtQueryEaFile(
145 windows.Handle(f.Fd()),
146 &iosb,
147 &eaBuf[0],
148 uint32(len(eaBuf)),
149 false,
150 nil,
151 0,
152 nil,
153 true,
154 )
155
156 if err != nil {
157 return nil, err
158 }
159
160 eas, err := decodeExtendedAttributes(eaBuf)
161 if err != nil || len(eas) == 0 {
162 return nil, err
163 }
164
165 m := make(map[string]string, len(eas))
166 for _, ea := range eas {
167 m[attrNameToKey(ea.Name)] = string(ea.Value)
168 }
169
170 return m, nil
171 }
172
173 func getEaBlockSize(f *os.File) (uint, error) {
174 var iosb windows.IO_STATUS_BLOCK
175 var rv uint32
176
177 err := windows.NtQueryInformationFile(
178 windows.Handle(f.Fd()),
179 &iosb,
180 (*byte)(unsafe.Pointer(&rv)),
181 uint32(unsafe.Sizeof(rv)),
182 windows.FileEaInformation,
183 )
184
185 if err != nil {
186 return 0, err
187 }
188
189 return uint(rv), nil
190 }
191
192 func encodeExtendedAttributes(eas []extendedAttribute) ([]byte, error) {
193 var buf bytes.Buffer
194 for i := range eas {
195 last := false
196 if i == len(eas)-1 {
197 last = true
198 }
199
200 err := writeExtendedAttributes(&buf, &eas[i], last)
201 if err != nil {
202 return nil, err
203 }
204 }
205 return buf.Bytes(), nil
206 }
207
208 func decodeExtendedAttributes(b []byte) (eas []extendedAttribute, err error) {
209 for len(b) != 0 {
210 ea, nb, err := parseExtendedAttributes(b)
211 if err != nil {
212 return nil, err
213 }
214
215 eas = append(eas, ea)
216 b = nb
217 }
218 return
219 }
220
221 func writeExtendedAttributes(buf *bytes.Buffer, ea *extendedAttribute, last bool) error {
222 if int(uint8(len(ea.Name))) != len(ea.Name) {
223 return fmt.Errorf(
224 "Extended attribute name is too long (limited to 255 bytes): name %q, value %q",
225 ea.Name, string(ea.Value),
226 )
227 }
228
229 if int(uint16(len(ea.Value))) != len(ea.Value) {
230 return fmt.Errorf(
231 "Extended attribute value is too long (limited to 65535 bytes): name %q, value %q",
232 ea.Name, string(ea.Value),
233 )
234 }
235
236 entrySize := uint32(fileFullEaInformationSize + len(ea.Name) + 1 + len(ea.Value))
237 withPadding := (entrySize + 3) &^ 3
238 nextOffset := uint32(0)
239 if !last {
240 nextOffset = withPadding
241 }
242 info := fileFullEaInformation{
243 NextEntryOffset: nextOffset,
244 Flags: ea.Flags,
245 NameLength: uint8(len(ea.Name)),
246 ValueLength: uint16(len(ea.Value)),
247 }
248
249 err := binary.Write(buf, binary.LittleEndian, &info)
250 if err != nil {
251 return err
252 }
253
254 _, err = buf.Write([]byte(ea.Name))
255 if err != nil {
256 return err
257 }
258
259 err = buf.WriteByte(0)
260 if err != nil {
261 return err
262 }
263
264 _, err = buf.Write(ea.Value)
265 if err != nil {
266 return err
267 }
268
269 _, err = buf.Write([]byte{0, 0, 0}[0 : withPadding-entrySize])
270 if err != nil {
271 return err
272 }
273
274 return nil
275 }
276
277 func parseExtendedAttributes(b []byte) (ea extendedAttribute, nb []byte, err error) {
278 var info fileFullEaInformation
279 err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &info)
280 if err != nil {
281 return
282 }
283
284 nameOffset := fileFullEaInformationSize
285 nameLen := int(info.NameLength)
286 valueOffset := nameOffset + int(info.NameLength) + 1
287 valueLen := int(info.ValueLength)
288 nextOffset := int(info.NextEntryOffset)
289 if valueLen+valueOffset > len(b) || nextOffset < 0 || nextOffset > len(b) {
290 err = fmt.Errorf("Invalid extended attribute buffer offset")
291 return
292 }
293
294 ea.Name = string(b[nameOffset : nameOffset+nameLen])
295 ea.Value = b[valueOffset : valueOffset+valueLen]
296 ea.Flags = info.Flags
297 if info.NextEntryOffset != 0 {
298 nb = b[info.NextEntryOffset:]
299 }
300 return
301 }