?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:torture: Do not free full_name before we printed it
[Samba.git] / source4 / torture / vfs / fruit.c
blob45c7aaac7a352760d169a94362cdec7e23edba88
1 /*
2 Unix SMB/CIFS implementation.
3
4 vfs_fruit tests
5
6 Copyright (C) Ralph Boehme 2014
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "system/filesys.h"
24 #include "libcli/libcli.h"
25 #include "libcli/smb2/smb2.h"
26 #include "libcli/smb2/smb2_calls.h"
27 #include "libcli/smb/smb2_create_ctx.h"
28 #include "lib/cmdline/popt_common.h"
29 #include "param/param.h"
30 #include "libcli/resolve/resolve.h"
31 #include "MacExtensions.h"
32 #include "lib/util/tsort.h"
33
34 #include "torture/torture.h"
35 #include "torture/util.h"
36 #include "torture/smb2/proto.h"
37 #include "torture/vfs/proto.h"
38 #include "librpc/gen_ndr/ndr_ioctl.h"
39 #include "libcli/security/dom_sid.h"
40 #include "../librpc/gen_ndr/ndr_security.h"
41 #include "libcli/security/secace.h"
42 #include "libcli/security/security_descriptor.h"
43
44 #define BASEDIR "vfs_fruit_dir"
45 #define FNAME_CC_SRC "testfsctl.dat"
46 #define FNAME_CC_DST "testfsctl2.dat"
47
48 #define CHECK_STATUS(status, correct) do { \
49 if (!NT_STATUS_EQUAL(status, correct)) { \
50 torture_result(tctx, TORTURE_FAIL, \
51 "(%s) Incorrect status %s - should be %s\n", \
52 __location__, nt_errstr(status), nt_errstr(correct)); \
53 ret = false; \
54 goto done; \
55 }} while (0)
56
57 #define CHECK_VALUE(v, correct) do { \
58 if ((v) != (correct)) { \
59 torture_result(tctx, TORTURE_FAIL, \
60 "(%s) Incorrect value %s=%u - should be %u\n", \
61 __location__, #v, (unsigned)v, (unsigned)correct); \
62 ret = false; \
63 goto done; \
64 }} while (0)
65
66 static bool check_stream_list(struct smb2_tree *tree,
67 struct torture_context *tctx,
68 const char *fname,
69 int num_exp,
70 const char **exp,
71 bool is_dir);
72
73 static int qsort_string(char * const *s1, char * const *s2)
74 {
75 return strcmp(*s1, *s2);
76 }
77
78 static int qsort_stream(const struct stream_struct * s1, const struct stream_struct *s2)
79 {
80 return strcmp(s1->stream_name.s, s2->stream_name.s);
81 }
82
83 /*
84 * REVIEW:
85 * This is hokey, but what else can we do?
86 */
87 #if defined(HAVE_ATTROPEN) || defined(FREEBSD)
88 #define AFPINFO_EA_NETATALK "org.netatalk.Metadata"
89 #define AFPRESOURCE_EA_NETATALK "org.netatalk.ResourceFork"
90 #else
91 #define AFPINFO_EA_NETATALK "user.org.netatalk.Metadata"
92 #define AFPRESOURCE_EA_NETATALK "user.org.netatalk.ResourceFork"
93 #endif
94
95 /*
96 The metadata xattr char buf below contains the following attributes:
97
98 -------------------------------------------------------------------------------
99 Entry ID : 00000008 : File Dates Info
100 Offset : 00000162 : 354
101 Length : 00000010 : 16
102
103 -DATE------: : (GMT) : (Local)
104 create : 1B442169 : Mon Jun 30 13:23:53 2014 : Mon Jun 30 15:23:53 2014
105 modify : 1B442169 : Mon Jun 30 13:23:53 2014 : Mon Jun 30 15:23:53 2014
106 backup : 80000000 : Unknown or Initial
107 access : 1B442169 : Mon Jun 30 13:23:53 2014 : Mon Jun 30 15:23:53 2014
108
109 -RAW DUMP--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
110 00000000 : 1B 44 21 69 1B 44 21 69 80 00 00 00 1B 44 21 69 : .D!i.D!i.....D!i
111
112 -------------------------------------------------------------------------------
113 Entry ID : 00000009 : Finder Info
114 Offset : 0000007A : 122
115 Length : 00000020 : 32
116
117 -FInfo-----:
118 Type : 42415252 : BARR
119 Creator : 464F4F4F : FOOO
120 isAlias : 0
121 Invisible : 1
122 hasBundle : 0
123 nameLocked : 0
124 Stationery : 0
125 CustomIcon : 0
126 Reserved : 0
127 Inited : 0
128 NoINITS : 0
129 Shared : 0
130 SwitchLaunc: 0
131 Hidden Ext : 0
132 color : 000 : none
133 isOnDesk : 0
134 Location v : 0000 : 0
135 Location h : 0000 : 0
136 Fldr : 0000 : ..
137
138 -FXInfo----:
139 Rsvd|IconID: 0000 : 0
140 Rsvd : 0000 : ..
141 Rsvd : 0000 : ..
142 Rsvd : 0000 : ..
143 AreInvalid : 0
144 unknown bit: 0
145 unknown bit: 0
146 unknown bit: 0
147 unknown bit: 0
148 unknown bit: 0
149 unknown bit: 0
150 CustomBadge: 0
151 ObjctIsBusy: 0
152 unknown bit: 0
153 unknown bit: 0
154 unknown bit: 0
155 unknown bit: 0
156 RoutingInfo: 0
157 unknown bit: 0
158 unknown bit: 0
159 Rsvd|commnt: 0000 : 0
160 PutAway : 00000000 : 0
161
162 -RAW DUMP--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
163 00000000 : 42 41 52 52 46 4F 4F 4F 40 00 00 00 00 00 00 00 : BARRFOOO@.......
164 00000010 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
165
166 -------------------------------------------------------------------------------
167 Entry ID : 0000000E : AFP File Info
168 Offset : 00000172 : 370
169 Length : 00000004 : 4
170
171 -RAW DUMP--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
172 00000000 : 00 00 01 A1 : ....
173 */
174
175 char metadata_xattr[] = {
176 0x00, 0x05, 0x16, 0x07, 0x00, 0x02, 0x00, 0x00,
177 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
178 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
179 0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
180 0x00, 0x9a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
181 0x00, 0x08, 0x00, 0x00, 0x01, 0x62, 0x00, 0x00,
182 0x00, 0x10, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
183 0x00, 0x7a, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
184 0x00, 0x0e, 0x00, 0x00, 0x01, 0x72, 0x00, 0x00,
185 0x00, 0x04, 0x80, 0x44, 0x45, 0x56, 0x00, 0x00,
186 0x01, 0x76, 0x00, 0x00, 0x00, 0x08, 0x80, 0x49,
187 0x4e, 0x4f, 0x00, 0x00, 0x01, 0x7e, 0x00, 0x00,
188 0x00, 0x08, 0x80, 0x53, 0x59, 0x4e, 0x00, 0x00,
189 0x01, 0x86, 0x00, 0x00, 0x00, 0x08, 0x80, 0x53,
190 0x56, 0x7e, 0x00, 0x00, 0x01, 0x8e, 0x00, 0x00,
191 0x00, 0x04, 0x42, 0x41, 0x52, 0x52, 0x46, 0x4f,
192 0x4f, 0x4f, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
193 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
194 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
195 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
196 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
197 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
198 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
199 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
200 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
201 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
202 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
203 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
204 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
205 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
206 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
207 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
208 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
209 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
210 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
211 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
212 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
213 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
214 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
215 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
216 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
217 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
218 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
219 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
220 0x00, 0x00, 0x1b, 0x44, 0x21, 0x69, 0x1b, 0x44,
221 0x21, 0x69, 0x80, 0x00, 0x00, 0x00, 0x1b, 0x44,
222 0x21, 0x69, 0x00, 0x00, 0x01, 0xa1, 0x00, 0xfd,
223 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x20,
224 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf1, 0xe3,
225 0x86, 0x53, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x01,
226 0x00, 0x00
227 };
228
229 /*
230 The buf below contains the following AppleDouble encoded data:
231
232 -------------------------------------------------------------------------------
233 MagicNumber: 00051607 : AppleDouble
234 Version : 00020000 : Version 2
235 Filler : 4D 61 63 20 4F 53 20 58 20 20 20 20 20 20 20 20 : Mac OS X
236 Num. of ent: 0002 : 2
237
238 -------------------------------------------------------------------------------
239 Entry ID : 00000009 : Finder Info
240 Offset : 00000032 : 50
241 Length : 00000EB0 : 3760
242
243 -FInfo-----:
244 Type : 54455354 : TEST
245 Creator : 534C4F57 : SLOW
246 isAlias : 0
247 Invisible : 0
248 hasBundle : 0
249 nameLocked : 0
250 Stationery : 0
251 CustomIcon : 0
252 Reserved : 0
253 Inited : 0
254 NoINITS : 0
255 Shared : 0
256 SwitchLaunc: 0
257 Hidden Ext : 0
258 color : 100 : blue
259 isOnDesk : 0
260 Location v : 0000 : 0
261 Location h : 0000 : 0
262 Fldr : 0000 : ..
263
264 -FXInfo----:
265 Rsvd|IconID: 0000 : 0
266 Rsvd : 0000 : ..
267 Rsvd : 0000 : ..
268 Rsvd : 0000 : ..
269 AreInvalid : 0
270 unknown bit: 0
271 unknown bit: 0
272 unknown bit: 0
273 unknown bit: 0
274 unknown bit: 0
275 unknown bit: 0
276 CustomBadge: 0
277 ObjctIsBusy: 0
278 unknown bit: 0
279 unknown bit: 0
280 unknown bit: 0
281 unknown bit: 0
282 RoutingInfo: 0
283 unknown bit: 0
284 unknown bit: 0
285 Rsvd|commnt: 0000 : 0
286 PutAway : 00000000 : 0
287
288 -EA--------:
289 pad : 0000 : ..
290 magic : 41545452 : ATTR
291 debug_tag : 53D4580C : 1406425100
292 total_size : 00000EE2 : 3810
293 data_start : 000000BC : 188
294 data_length: 0000005E : 94
295 reserved[0]: 00000000 : ....
296 reserved[1]: 00000000 : ....
297 reserved[2]: 00000000 : ....
298 flags : 0000 : ..
299 num_attrs : 0002 : 2
300 -EA ENTRY--:
301 offset : 000000BC : 188
302 length : 0000005B : 91
303 flags : 0000 : ..
304 namelen : 24 : 36
305 -EA NAME---: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
306 00000000 : 63 6F 6D 2E 61 70 70 6C 65 2E 6D 65 74 61 64 61 : com.apple.metada
307 00000010 : 74 61 3A 5F 6B 4D 44 49 74 65 6D 55 73 65 72 54 : ta:_kMDItemUserT
308 00000020 : 61 67 73 00 : ags.
309 -EA VALUE--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
310 00000000 : 62 70 6C 69 73 74 30 30 A5 01 02 03 04 05 54 74 : bplist00......Tt
311 00000010 : 65 73 74 66 00 47 00 72 00 FC 00 6E 00 0A 00 32 : estf.G.r...n...2
312 00000020 : 56 4C 69 6C 61 0A 33 56 47 65 6C 62 0A 35 56 42 : VLila.3VGelb.5VB
313 00000030 : 6C 61 75 0A 34 08 0E 13 20 27 2E 00 00 00 00 00 : lau.4... '......
314 00000040 : 00 01 01 00 00 00 00 00 00 00 06 00 00 00 00 00 : ................
315 00000050 : 00 00 00 00 00 00 00 00 00 00 35 : ..........5
316 -EA ENTRY--:
317 offset : 00000117 : 279
318 length : 00000003 : 3
319 flags : 0000 : ..
320 namelen : 08 : 8
321 -EA NAME---: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
322 00000000 : 66 6F 6F 3A 62 61 72 00 : foo:bar.
323 -EA VALUE--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
324 00000000 : 62 61 7A : baz
325
326 -RAW DUMP--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
327 00000000 : 54 45 53 54 53 4C 4F 57 00 08 00 00 00 00 00 00 : TESTSLOW........
328 00000010 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
329 00000020 : 00 00 41 54 54 52 53 D4 58 0C 00 00 0E E2 00 00 : ..ATTRS.X.......
330 00000030 : 00 BC 00 00 00 5E 00 00 00 00 00 00 00 00 00 00 : .....^..........
331 00000040 : 00 00 00 00 00 02 00 00 00 BC 00 00 00 5B 00 00 : .............[..
332 00000050 : 24 63 6F 6D 2E 61 70 70 6C 65 2E 6D 65 74 61 64 : $com.apple.metad
333 00000060 : 61 74 61 3A 5F 6B 4D 44 49 74 65 6D 55 73 65 72 : ata:_kMDItemUser
334 00000070 : 54 61 67 73 00 00 00 00 01 17 00 00 00 03 00 00 : Tags............
335 00000080 : 08 66 6F 6F 3A 62 61 72 00 66 62 70 6C 69 73 74 : .foo:bar.fbplist
336 00000090 : 30 30 A5 01 02 03 04 05 54 74 65 73 74 66 00 47 : 00......Ttestf.G
337 000000A0 : 00 72 00 FC 00 6E 00 0A 00 32 56 4C 69 6C 61 0A : .r...n...2VLila.
338 000000B0 : 33 56 47 65 6C 62 0A 35 56 42 6C 61 75 0A 34 08 : 3VGelb.5VBlau.4.
339 000000C0 : 0E 13 20 27 2E 00 00 00 00 00 00 01 01 00 00 00 : .. '............
340 000000D0 : 00 00 00 00 06 00 00 00 00 00 00 00 00 00 00 00 : ................
341 000000E0 : 00 00 00 00 35 62 61 7A 00 00 00 00 00 00 00 00 : ....5baz........
342 000000F0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
343 ... all zeroes ...
344 00000EA0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
345
346 -------------------------------------------------------------------------------
347 Entry ID : 00000002 : Resource Fork
348 Offset : 00000EE2 : 3810
349 Length : 0000011E : 286
350
351 -RAW DUMP--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
352 00000000 : 00 00 01 00 00 00 01 00 00 00 00 00 00 00 00 1E : ................
353 00000010 : 54 68 69 73 20 72 65 73 6F 75 72 63 65 20 66 6F : This resource fo
354 00000020 : 72 6B 20 69 6E 74 65 6E 74 69 6F 6E 61 6C 6C 79 : rk intentionally
355 00000030 : 20 6C 65 66 74 20 62 6C 61 6E 6B 20 20 20 00 00 : left blank ..
356 00000040 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
357 00000050 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
358 00000060 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
359 00000070 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
360 00000080 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
361 00000090 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
362 000000A0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
363 000000B0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
364 000000C0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
365 000000D0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
366 000000E0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
367 000000F0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
368 00000100 : 00 00 01 00 00 00 01 00 00 00 00 00 00 00 00 1E : ................
369 00000110 : 00 00 00 00 00 00 00 00 00 1C 00 1E FF FF : ..............
370
371 It was created with:
372 $ hexdump -ve '"\t" 7/1 "0x%02x, " 1/1 " 0x%02x," "\n"'
373 */
374 static char osx_adouble_w_xattr[] = {
375 0x00, 0x05, 0x16, 0x07, 0x00, 0x02, 0x00, 0x00,
376 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58,
377 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
378 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
379 0x00, 0x32, 0x00, 0x00, 0x0e, 0xb0, 0x00, 0x00,
380 0x00, 0x02, 0x00, 0x00, 0x0e, 0xe2, 0x00, 0x00,
381 0x01, 0x1e, 0x54, 0x45, 0x53, 0x54, 0x53, 0x4c,
382 0x4f, 0x57, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
383 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
384 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
385 0x00, 0x00, 0x00, 0x00, 0x41, 0x54, 0x54, 0x52,
386 0x53, 0xd4, 0x58, 0x0c, 0x00, 0x00, 0x0e, 0xe2,
387 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0x5e,
388 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
389 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
390 0x00, 0x00, 0x00, 0xbc, 0x00, 0x00, 0x00, 0x5b,
391 0x00, 0x00, 0x24, 0x63, 0x6f, 0x6d, 0x2e, 0x61,
392 0x70, 0x70, 0x6c, 0x65, 0x2e, 0x6d, 0x65, 0x74,
393 0x61, 0x64, 0x61, 0x74, 0x61, 0x3a, 0x5f, 0x6b,
394 0x4d, 0x44, 0x49, 0x74, 0x65, 0x6d, 0x55, 0x73,
395 0x65, 0x72, 0x54, 0x61, 0x67, 0x73, 0x00, 0x00,
396 0x00, 0x00, 0x01, 0x17, 0x00, 0x00, 0x00, 0x03,
397 0x00, 0x00, 0x08, 0x66, 0x6f, 0x6f, 0x3a, 0x62,
398 0x61, 0x72, 0x00, 0x66, 0x62, 0x70, 0x6c, 0x69,
399 0x73, 0x74, 0x30, 0x30, 0xa5, 0x01, 0x02, 0x03,
400 0x04, 0x05, 0x54, 0x74, 0x65, 0x73, 0x74, 0x66,
401 0x00, 0x47, 0x00, 0x72, 0x00, 0xfc, 0x00, 0x6e,
402 0x00, 0x0a, 0x00, 0x32, 0x56, 0x4c, 0x69, 0x6c,
403 0x61, 0x0a, 0x33, 0x56, 0x47, 0x65, 0x6c, 0x62,
404 0x0a, 0x35, 0x56, 0x42, 0x6c, 0x61, 0x75, 0x0a,
405 0x34, 0x08, 0x0e, 0x13, 0x20, 0x27, 0x2e, 0x00,
406 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00,
407 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
408 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
409 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x62,
410 0x61, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
411 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
412 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
413 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
414 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
415 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
416 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
417 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
418 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
419 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
420 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
421 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
422 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
423 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
424 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
425 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
426 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
427 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
428 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
429 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
430 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
431 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
432 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
433 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
434 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
435 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
436 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
437 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
438 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
439 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
440 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
441 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
442 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
443 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
444 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
445 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
446 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
447 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
448 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
449 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
450 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
451 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
452 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
453 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
454 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
455 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
456 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
457 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
458 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
459 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
460 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
461 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
462 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
463 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
464 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
465 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
466 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
467 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
468 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
469 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
470 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
471 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
472 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
473 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
474 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
475 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
476 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
477 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
478 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
479 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
480 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
481 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
482 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
483 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
484 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
485 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
486 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
487 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
488 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
489 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
490 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
491 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
492 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
493 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
494 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
495 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
496 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
497 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
498 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
499 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
500 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
501 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
502 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
503 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
504 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
505 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
506 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
507 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
508 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
509 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
510 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
511 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
512 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
513 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
514 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
515 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
516 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
517 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
518 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
519 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
520 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
521 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
522 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
523 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
524 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
525 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
526 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
527 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
528 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
529 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
530 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
531 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
532 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
533 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
534 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
535 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
536 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
537 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
538 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
539 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
540 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
541 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
542 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
543 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
544 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
545 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
546 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
547 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
548 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
549 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
550 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
551 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
552 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
553 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
554 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
555 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
556 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
557 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
558 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
559 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
560 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
561 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
562 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
563 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
564 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
565 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
566 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
567 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
568 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
569 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
570 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
571 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
572 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
573 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
574 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
575 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
576 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
577 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
578 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
579 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
580 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
581 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
582 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
583 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
584 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
585 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
586 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
587 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
588 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
589 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
590 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
591 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
592 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
593 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
594 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
595 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
596 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
597 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
598 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
599 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
600 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
601 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
602 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
603 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
604 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
605 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
606 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
607 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
608 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
609 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
610 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
611 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
612 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
613 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
614 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
615 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
616 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
617 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
618 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
619 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
620 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
621 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
622 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
623 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
624 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
625 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
626 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
627 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
628 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
629 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
630 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
631 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
632 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
633 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
634 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
635 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
636 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
637 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
638 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
639 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
640 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
641 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
642 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
643 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
644 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
645 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
646 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
647 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
648 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
649 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
650 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
651 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
652 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
653 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
654 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
655 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
656 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
657 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
658 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
659 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
660 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
661 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
662 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
663 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
664 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
665 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
666 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
667 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
668 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
669 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
670 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
671 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
672 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
673 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
674 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
675 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
676 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
677 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
678 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
679 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
680 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
681 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
682 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
683 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
684 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
685 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
686 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
687 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
688 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
689 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
690 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
691 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
692 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
693 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
694 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
695 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
696 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
697 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
698 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
699 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
700 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
701 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
702 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
703 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
704 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
705 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
706 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
707 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
708 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
709 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
710 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
711 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
712 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
713 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
714 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
715 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
716 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
717 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
718 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
719 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
720 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
721 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
722 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
723 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
724 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
725 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
726 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
727 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
728 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
729 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
730 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
731 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
732 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
733 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
734 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
735 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
736 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
737 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
738 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
739 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
740 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
741 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
742 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
743 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
744 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
745 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
746 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
747 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
748 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
749 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
750 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
751 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
752 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
753 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
754 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
755 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
756 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
757 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
758 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
759 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
760 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
761 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
762 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
763 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
764 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
765 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
766 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
767 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
768 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
769 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
770 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
771 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
772 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
773 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
774 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
775 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
776 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
777 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
778 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
779 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
780 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
781 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
782 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
783 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
784 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
785 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
786 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
787 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
788 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
789 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
790 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
791 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
792 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
793 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
794 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
795 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
796 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
797 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
798 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
799 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
800 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
801 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
802 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
803 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
804 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
805 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
806 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
807 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
808 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
809 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
810 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
811 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
812 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
813 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
814 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
815 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
816 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
817 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
818 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
819 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
820 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
821 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
822 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
823 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
824 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
825 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
826 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
827 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
828 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
829 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
830 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
831 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
832 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
833 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
834 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
835 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
836 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
837 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
838 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
839 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
840 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
841 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
842 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
843 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
844 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
845 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
846 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
847 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
848 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
849 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
850 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
851 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
852 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
853 0x00, 0x1e, 0x54, 0x68, 0x69, 0x73, 0x20, 0x72,
854 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20,
855 0x66, 0x6f, 0x72, 0x6b, 0x20, 0x69, 0x6e, 0x74,
856 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
857 0x6c, 0x79, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x20,
858 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x20, 0x20, 0x20,
859 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
860 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
861 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
862 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
863 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
864 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
865 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
866 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
867 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
868 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
869 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
870 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
871 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
872 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
873 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
874 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
875 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
876 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
877 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
878 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
879 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
880 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
881 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
882 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
883 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
884 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
885 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
886 0x00, 0x00, 0x00, 0x1c, 0x00, 0x1e, 0xff, 0xff
887 };
888
889 /*
890 * The buf below contains the following AppleDouble encoded data:
891 *
892 * -------------------------------------------------------------------------------
893 * MagicNumber: 00051607 : AppleDouble
894 * Version : 00020000 : Version 2
895 * Filler : 4D 61 63 20 4F 53 20 58 20 20 20 20 20 20 20 20 : Mac OS X
896 * Num. of ent: 0002 : 2
897 *
898 * -------------------------------------------------------------------------------
899 * Entry ID : 00000002 : Resource Fork
900 * Offset : 00000052 : 82
901 * Length : 0000011E : 286
902 *
903 * -RAW DUMP--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
904 * 00000000 : 00 00 01 00 00 00 01 00 00 00 00 00 00 00 00 1E : ................
905 * 00000010 : 54 68 69 73 20 72 65 73 6F 75 72 63 65 20 66 6F : This resource fo
906 * 00000020 : 72 6B 20 69 6E 74 65 6E 74 69 6F 6E 61 6C 6C 79 : rk intentionally
907 * 00000030 : 20 6C 65 66 74 20 62 6C 61 6E 6B 20 20 20 00 00 : left blank ..
908 * 00000040 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
909 * 00000050 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
910 * 00000060 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
911 * 00000070 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
912 * 00000080 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
913 * 00000090 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
914 * 000000A0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
915 * 000000B0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
916 * 000000C0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
917 * 000000D0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
918 * 000000E0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
919 * 000000F0 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
920 * 00000100 : 00 00 01 00 00 00 01 00 00 00 00 00 00 00 00 1E : ................
921 * 00000110 : 00 00 00 00 00 00 00 00 00 1C 00 1E FF FF : ..............
922 *
923 * Entry ID : 00000009 : Finder Info
924 * Offset : 00000032 : 50
925 * Length : 00000020 : 32
926 *
927 * -NOTE------: cannot detect whether FInfo or DInfo. assume FInfo.
928 *
929 * -FInfo-----:
930 * Type : 57415645 : WAVE
931 * Creator : 5054756C : PTul
932 * isAlias : 0
933 * Invisible : 0
934 * hasBundle : 0
935 * nameLocked : 0
936 * Stationery : 0
937 * CustomIcon : 0
938 * Reserved : 0
939 * Inited : 0
940 * NoINITS : 0
941 * Shared : 0
942 * SwitchLaunc: 0
943 * Hidden Ext : 0
944 * color : 000 : none
945 * isOnDesk : 0
946 * Location v : 0000 : 0
947 * Location h : 0000 : 0
948 * Fldr : 0000 : ..
949 *
950 * -FXInfo----:
951 * Rsvd|IconID: 0000 : 0
952 * Rsvd : 0000 : ..
953 * Rsvd : 0000 : ..
954 * Rsvd : 0000 : ..
955 * AreInvalid : 0
956 * unknown bit: 0
957 * unknown bit: 0
958 * unknown bit: 0
959 * unknown bit: 0
960 * unknown bit: 0
961 * unknown bit: 0
962 * CustomBadge: 0
963 * ObjctIsBusy: 0
964 * unknown bit: 0
965 * unknown bit: 0
966 * unknown bit: 0
967 * unknown bit: 0
968 * RoutingInfo: 0
969 * unknown bit: 0
970 * unknown bit: 0
971 * Rsvd|commnt: 0000 : 0
972 * PutAway : 00000000 : 0
973 *
974 * -RAW DUMP--: 0 1 2 3 4 5 6 7 8 9 A B C D E F : (ASCII)
975 * 00000000 : 57 41 56 45 50 54 75 6C 00 00 00 00 00 00 00 00 : WAVEPTul........
976 * 00000010 : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 : ................
977 * *
978 * It was created with:
979 * $ hexdump -ve '"\t" 7/1 "0x%02x, " 1/1 " 0x%02x," "\n"'
980 */
981 static char osx_adouble_without_xattr[] = {
982 0x00, 0x05, 0x16, 0x07, 0x00, 0x02, 0x00, 0x00,
983 0x4d, 0x61, 0x63, 0x20, 0x4f, 0x53, 0x20, 0x58,
984 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
985 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,
986 0x00, 0x52, 0x00, 0x00, 0x01, 0x1e, 0x00, 0x00,
987 0x00, 0x09, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00,
988 0x00, 0x20, 0x57, 0x41, 0x56, 0x45, 0x50, 0x54,
989 0x75, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
990 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
991 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
992 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
993 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
994 0x00, 0x1e, 0x54, 0x68, 0x69, 0x73, 0x20, 0x72,
995 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x20,
996 0x66, 0x6f, 0x72, 0x6b, 0x20, 0x69, 0x6e, 0x74,
997 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
998 0x6c, 0x79, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x20,
999 0x62, 0x6c, 0x61, 0x6e, 0x6b, 0x20, 0x20, 0x20,
1000 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1001 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1002 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1003 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1004 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1005 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1006 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1007 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1008 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1009 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1010 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1011 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1012 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1013 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1014 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1015 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1016 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1017 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1018 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1019 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1020 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1021 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1022 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1023 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1024 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
1025 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1026 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1027 0x00, 0x00, 0x00, 0x1c, 0x00, 0x1e, 0xff, 0xff
1028 };
1029
1030 /**
1031 * talloc and intialize an AfpInfo
1032 **/
1033 static AfpInfo *torture_afpinfo_new(TALLOC_CTX *mem_ctx)
1034 {
1035 AfpInfo *info;
1036
1037 info = talloc_zero(mem_ctx, AfpInfo);
1038 if (info == NULL) {
1039 return NULL;
1040 }
1041
1042 info->afpi_Signature = AFP_Signature;
1043 info->afpi_Version = AFP_Version;
1044 info->afpi_BackupTime = AFP_BackupTime;
1045
1046 return info;
1047 }
1048
1049 /**
1050 * Pack AfpInfo into a talloced buffer
1051 **/
1052 static char *torture_afpinfo_pack(TALLOC_CTX *mem_ctx,
1053 AfpInfo *info)
1054 {
1055 char *buf;
1056
1057 buf = talloc_zero_array(mem_ctx, char, AFP_INFO_SIZE);
1058 if (buf == NULL) {
1059 return NULL;
1060 }
1061
1062 RSIVAL(buf, 0, info->afpi_Signature);
1063 RSIVAL(buf, 4, info->afpi_Version);
1064 RSIVAL(buf, 12, info->afpi_BackupTime);
1065 memcpy(buf + 16, info->afpi_FinderInfo, sizeof(info->afpi_FinderInfo));
1066
1067 return buf;
1068 }
1069
1070 /**
1071 * Unpack AfpInfo
1072 **/
1073 #if 0
1074 static void torture_afpinfo_unpack(AfpInfo *info, char *data)
1075 {
1076 info->afpi_Signature = RIVAL(data, 0);
1077 info->afpi_Version = RIVAL(data, 4);
1078 info->afpi_BackupTime = RIVAL(data, 12);
1079 memcpy(info->afpi_FinderInfo, (const char *)data + 16,
1080 sizeof(info->afpi_FinderInfo));
1081 }
1082 #endif
1083
1084 static bool torture_write_afpinfo(struct smb2_tree *tree,
1085 struct torture_context *tctx,
1086 TALLOC_CTX *mem_ctx,
1087 const char *fname,
1088 AfpInfo *info)
1089 {
1090 struct smb2_handle handle;
1091 struct smb2_create io;
1092 NTSTATUS status;
1093 const char *full_name;
1094 char *infobuf;
1095 bool ret = true;
1096
1097 full_name = talloc_asprintf(mem_ctx, "%s%s", fname, AFPINFO_STREAM_NAME);
1098 if (full_name == NULL) {
1099 torture_comment(tctx, "talloc_asprintf error\n");
1100 return false;
1101 }
1102 ZERO_STRUCT(io);
1103 io.in.desired_access = SEC_FILE_WRITE_DATA;
1104 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1105 io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1106 io.in.create_options = 0;
1107 io.in.fname = full_name;
1108
1109 status = smb2_create(tree, mem_ctx, &io);
1110 CHECK_STATUS(status, NT_STATUS_OK);
1111
1112 handle = io.out.file.handle;
1113
1114 infobuf = torture_afpinfo_pack(mem_ctx, info);
1115 if (infobuf == NULL) {
1116 return false;
1117 }
1118
1119 status = smb2_util_write(tree, handle, infobuf, 0, AFP_INFO_SIZE);
1120 CHECK_STATUS(status, NT_STATUS_OK);
1121
1122 smb2_util_close(tree, handle);
1123
1124 done:
1125 return ret;
1126 }
1127
1128 /**
1129 * Read 'count' bytes at 'offset' from stream 'fname:sname' and
1130 * compare against buffer 'value'
1131 **/
1132 static bool check_stream(struct smb2_tree *tree,
1133 const char *location,
1134 struct torture_context *tctx,
1135 TALLOC_CTX *mem_ctx,
1136 const char *fname,
1137 const char *sname,
1138 off_t read_offset,
1139 size_t read_count,
1140 off_t comp_offset,
1141 size_t comp_count,
1142 const char *value)
1143 {
1144 struct smb2_handle handle;
1145 struct smb2_create create;
1146 struct smb2_read r;
1147 NTSTATUS status;
1148 char *full_name;
1149 bool ret = true;
1150
1151 full_name = talloc_asprintf(mem_ctx, "%s%s", fname, sname);
1152 if (full_name == NULL) {
1153 torture_comment(tctx, "talloc_asprintf error\n");
1154 return false;
1155 }
1156 ZERO_STRUCT(create);
1157 create.in.desired_access = SEC_FILE_READ_DATA;
1158 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1159 create.in.create_disposition = NTCREATEX_DISP_OPEN;
1160 create.in.fname = full_name;
1161
1162 torture_comment(tctx, "Open stream %s\n", full_name);
1163
1164 status = smb2_create(tree, mem_ctx, &create);
1165 if (!NT_STATUS_IS_OK(status)) {
1166 if (value == NULL) {
1167 return true;
1168 }
1169 torture_comment(tctx, "Unable to open stream %s\n", full_name);
1170 TALLOC_FREE(full_name);
1171 return false;
1172 }
1173
1174 handle = create.out.file.handle;
1175 if (value == NULL) {
1176 TALLOC_FREE(full_name);
1177 smb2_util_close(tree, handle);
1178 return true;
1179 }
1180
1181 ZERO_STRUCT(r);
1182 r.in.file.handle = handle;
1183 r.in.length = read_count;
1184 r.in.offset = read_offset;
1185
1186 status = smb2_read(tree, tree, &r);
1187
1188 torture_assert_ntstatus_ok_goto(
1189 tctx, status, ret, done,
1190 talloc_asprintf(tctx, "(%s) Failed to read %lu bytes from stream '%s'\n",
1191 location, (long)strlen(value), full_name));
1192
1193 torture_assert_goto(tctx, r.out.data.length == read_count, ret, done,
1194 talloc_asprintf(tctx, "smb2_read returned %jd bytes, expected %jd\n",
1195 (intmax_t)r.out.data.length, (intmax_t)read_count));
1196
1197 torture_assert_goto(
1198 tctx, memcmp(r.out.data.data + comp_offset, value, comp_count) == 0,
1199 ret, done,
1200 talloc_asprintf(tctx, "(%s) Bad data in stream\n", location));
1201
1202 done:
1203 TALLOC_FREE(full_name);
1204 smb2_util_close(tree, handle);
1205 return ret;
1206 }
1207
1208 /**
1209 * Read 'count' bytes at 'offset' from stream 'fname:sname' and
1210 * compare against buffer 'value'
1211 **/
1212 static ssize_t read_stream(struct smb2_tree *tree,
1213 const char *location,
1214 struct torture_context *tctx,
1215 TALLOC_CTX *mem_ctx,
1216 const char *fname,
1217 const char *sname,
1218 off_t read_offset,
1219 size_t read_count)
1220 {
1221 struct smb2_handle handle;
1222 struct smb2_create create;
1223 struct smb2_read r;
1224 NTSTATUS status;
1225 const char *full_name;
1226 bool ret = true;
1227
1228 full_name = talloc_asprintf(mem_ctx, "%s%s", fname, sname);
1229 if (full_name == NULL) {
1230 torture_comment(tctx, "talloc_asprintf error\n");
1231 return -1;
1232 }
1233 ZERO_STRUCT(create);
1234 create.in.desired_access = SEC_FILE_READ_DATA;
1235 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1236 create.in.create_disposition = NTCREATEX_DISP_OPEN;
1237 create.in.fname = full_name;
1238
1239 torture_comment(tctx, "Open stream %s\n", full_name);
1240
1241 status = smb2_create(tree, mem_ctx, &create);
1242 if (!NT_STATUS_IS_OK(status)) {
1243 torture_comment(tctx, "Unable to open stream %s\n",
1244 full_name);
1245 return -1;
1246 }
1247
1248 handle = create.out.file.handle;
1249
1250 ZERO_STRUCT(r);
1251 r.in.file.handle = handle;
1252 r.in.length = read_count;
1253 r.in.offset = read_offset;
1254
1255 status = smb2_read(tree, tree, &r);
1256 if (!NT_STATUS_IS_OK(status)) {
1257 CHECK_STATUS(status, NT_STATUS_END_OF_FILE);
1258 }
1259
1260 smb2_util_close(tree, handle);
1261
1262 done:
1263 if (ret == false) {
1264 return -1;
1265 }
1266 return r.out.data.length;
1267 }
1268
1269 /**
1270 * Read 'count' bytes at 'offset' from stream 'fname:sname' and
1271 * compare against buffer 'value'
1272 **/
1273 static bool write_stream(struct smb2_tree *tree,
1274 const char *location,
1275 struct torture_context *tctx,
1276 TALLOC_CTX *mem_ctx,
1277 const char *fname,
1278 const char *sname,
1279 off_t offset,
1280 size_t size,
1281 const char *value)
1282 {
1283 struct smb2_handle handle;
1284 struct smb2_create create;
1285 NTSTATUS status;
1286 const char *full_name;
1287
1288 full_name = talloc_asprintf(mem_ctx, "%s%s", fname, sname ? sname : "");
1289 if (full_name == NULL) {
1290 torture_comment(tctx, "talloc_asprintf error\n");
1291 return false;
1292 }
1293 ZERO_STRUCT(create);
1294 create.in.desired_access = SEC_FILE_WRITE_DATA;
1295 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1296 create.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1297 create.in.fname = full_name;
1298
1299 status = smb2_create(tree, mem_ctx, &create);
1300 if (!NT_STATUS_IS_OK(status)) {
1301 if (value == NULL) {
1302 return true;
1303 } else {
1304 torture_comment(tctx, "Unable to open stream %s\n",
1305 full_name);
1306 sleep(10000000);
1307 return false;
1308 }
1309 }
1310
1311 handle = create.out.file.handle;
1312 if (value == NULL) {
1313 return true;
1314 }
1315
1316 status = smb2_util_write(tree, handle, value, offset, size);
1317
1318 if (!NT_STATUS_IS_OK(status)) {
1319 torture_comment(tctx, "(%s) Failed to write %lu bytes to "
1320 "stream '%s'\n", location, (long)size, full_name);
1321 return false;
1322 }
1323
1324 smb2_util_close(tree, handle);
1325 return true;
1326 }
1327
1328 static bool torture_setup_local_xattr(struct torture_context *tctx,
1329 const char *path_option,
1330 const char *name,
1331 const char *xattr,
1332 const char *metadata,
1333 size_t size)
1334 {
1335 int ret = true;
1336 int result;
1337 const char *spath;
1338 char *path;
1339
1340 spath = torture_setting_string(tctx, path_option, NULL);
1341 if (spath == NULL) {
1342 printf("No sharepath for option %s\n", path_option);
1343 return false;
1344 }
1345
1346 path = talloc_asprintf(tctx, "%s/%s", spath, name);
1347
1348 result = setxattr(path, xattr, metadata, size, 0);
1349 if (result != 0) {
1350 ret = false;
1351 }
1352
1353 TALLOC_FREE(path);
1354
1355 return ret;
1356 }
1357
1358 /**
1359 * Create a file or directory
1360 **/
1361 static bool torture_setup_file(TALLOC_CTX *mem_ctx, struct smb2_tree *tree,
1362 const char *name, bool dir)
1363 {
1364 struct smb2_create io;
1365 NTSTATUS status;
1366
1367 smb2_util_unlink(tree, name);
1368 ZERO_STRUCT(io);
1369 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
1370 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1371 io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1372 io.in.share_access =
1373 NTCREATEX_SHARE_ACCESS_DELETE|
1374 NTCREATEX_SHARE_ACCESS_READ|
1375 NTCREATEX_SHARE_ACCESS_WRITE;
1376 io.in.create_options = 0;
1377 io.in.fname = name;
1378 if (dir) {
1379 io.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1380 io.in.share_access &= ~NTCREATEX_SHARE_ACCESS_DELETE;
1381 io.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
1382 io.in.create_disposition = NTCREATEX_DISP_CREATE;
1383 }
1384
1385 status = smb2_create(tree, mem_ctx, &io);
1386 if (!NT_STATUS_IS_OK(status)) {
1387 return false;
1388 }
1389
1390 status = smb2_util_close(tree, io.out.file.handle);
1391 if (!NT_STATUS_IS_OK(status)) {
1392 return false;
1393 }
1394
1395 return true;
1396 }
1397
1398 static bool enable_aapl(struct torture_context *tctx,
1399 struct smb2_tree *tree)
1400 {
1401 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1402 NTSTATUS status;
1403 bool ret = true;
1404 struct smb2_create io;
1405 DATA_BLOB data;
1406 struct smb2_create_blob *aapl = NULL;
1407 uint32_t aapl_server_caps;
1408 uint32_t expected_scaps = (SMB2_CRTCTX_AAPL_UNIX_BASED |
1409 SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR |
1410 SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE |
1411 SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE);
1412 bool is_osx_server = torture_setting_bool(tctx, "osx", false);
1413
1414 ZERO_STRUCT(io);
1415 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
1416 io.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
1417 io.in.create_disposition = NTCREATEX_DISP_OPEN;
1418 io.in.share_access = (NTCREATEX_SHARE_ACCESS_DELETE |
1419 NTCREATEX_SHARE_ACCESS_READ |
1420 NTCREATEX_SHARE_ACCESS_WRITE);
1421 io.in.fname = "";
1422
1423 /*
1424 * Issuing an SMB2/CREATE with a suitably formed AAPL context,
1425 * controls behaviour of Apple's SMB2 extensions for the whole
1426 * session!
1427 */
1428
1429 data = data_blob_talloc(mem_ctx, NULL, 3 * sizeof(uint64_t));
1430 SBVAL(data.data, 0, SMB2_CRTCTX_AAPL_SERVER_QUERY);
1431 SBVAL(data.data, 8, (SMB2_CRTCTX_AAPL_SERVER_CAPS |
1432 SMB2_CRTCTX_AAPL_VOLUME_CAPS |
1433 SMB2_CRTCTX_AAPL_MODEL_INFO));
1434 SBVAL(data.data, 16, (SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR |
1435 SMB2_CRTCTX_AAPL_UNIX_BASED |
1436 SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE));
1437
1438 status = smb2_create_blob_add(tctx, &io.in.blobs, "AAPL", data);
1439 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create_blob_add");
1440
1441 status = smb2_create(tree, tctx, &io);
1442 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create");
1443
1444 status = smb2_util_close(tree, io.out.file.handle);
1445 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_util_close");
1446
1447 /*
1448 * Now check returned AAPL context
1449 */
1450 torture_comment(tctx, "Comparing returned AAPL capabilities\n");
1451
1452 aapl = smb2_create_blob_find(&io.out.blobs,
1453 SMB2_CREATE_TAG_AAPL);
1454 torture_assert_goto(tctx, aapl != NULL, ret, done, "missing AAPL context");
1455
1456 if (!is_osx_server) {
1457 size_t expected_aapl_ctx_size;
1458
1459 expected_aapl_ctx_size = strlen("MacSamba") * 2 + 40;
1460
1461 torture_assert_goto(
1462 tctx, aapl->data.length == expected_aapl_ctx_size,
1463 ret, done, "bad AAPL size");
1464 }
1465
1466 aapl_server_caps = BVAL(aapl->data.data, 16);
1467 torture_assert_goto(tctx, aapl_server_caps == expected_scaps,
1468 ret, done, "bad AAPL caps");
1469
1470 done:
1471 talloc_free(mem_ctx);
1472 return ret;
1473 }
1474
1475 static bool test_read_netatalk_metadata(struct torture_context *tctx,
1476 struct smb2_tree *tree)
1477 {
1478 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1479 const char *fname = BASEDIR "\\torture_read_metadata";
1480 NTSTATUS status;
1481 struct smb2_handle testdirh;
1482 bool ret = true;
1483 ssize_t len;
1484 const char *localdir = NULL;
1485
1486 torture_comment(tctx, "Checking metadata access\n");
1487
1488 localdir = torture_setting_string(tctx, "localdir", NULL);
1489 if (localdir == NULL) {
1490 torture_skip(tctx, "Need localdir for test");
1491 }
1492
1493 smb2_util_unlink(tree, fname);
1494
1495 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
1496 CHECK_STATUS(status, NT_STATUS_OK);
1497 smb2_util_close(tree, testdirh);
1498
1499 ret = torture_setup_file(mem_ctx, tree, fname, false);
1500 if (ret == false) {
1501 goto done;
1502 }
1503
1504 ret = torture_setup_local_xattr(tctx, "localdir",
1505 BASEDIR "/torture_read_metadata",
1506 AFPINFO_EA_NETATALK,
1507 metadata_xattr, sizeof(metadata_xattr));
1508 if (ret == false) {
1509 goto done;
1510 }
1511
1512 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1513 0, 60, 0, 4, "AFP");
1514 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
1515
1516 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1517 0, 60, 16, 8, "BARRFOOO");
1518 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
1519
1520 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1521 16, 8, 0, 3, "AFP");
1522 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
1523
1524 /* Check reading offset and read size > sizeof(AFPINFO_STREAM) */
1525
1526 len = read_stream(tree, __location__, tctx, mem_ctx, fname,
1527 AFPINFO_STREAM, 0, 61);
1528 CHECK_VALUE(len, 60);
1529
1530 len = read_stream(tree, __location__, tctx, mem_ctx, fname,
1531 AFPINFO_STREAM, 59, 2);
1532 CHECK_VALUE(len, 2);
1533
1534 len = read_stream(tree, __location__, tctx, mem_ctx, fname,
1535 AFPINFO_STREAM, 60, 1);
1536 CHECK_VALUE(len, 1);
1537
1538 len = read_stream(tree, __location__, tctx, mem_ctx, fname,
1539 AFPINFO_STREAM, 61, 1);
1540 CHECK_VALUE(len, 0);
1541
1542 done:
1543 smb2_deltree(tree, BASEDIR);
1544 talloc_free(mem_ctx);
1545 return ret;
1546 }
1547
1548 static bool test_read_afpinfo(struct torture_context *tctx,
1549 struct smb2_tree *tree)
1550 {
1551 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1552 const char *fname = BASEDIR "\\torture_read_metadata";
1553 NTSTATUS status;
1554 struct smb2_handle testdirh;
1555 bool ret = true;
1556 ssize_t len;
1557 AfpInfo *info;
1558 const char *type_creator = "SMB,OLE!";
1559
1560 torture_comment(tctx, "Checking metadata access\n");
1561
1562 smb2_util_unlink(tree, fname);
1563
1564 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
1565 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir failed");
1566 smb2_util_close(tree, testdirh);
1567
1568 ret = torture_setup_file(mem_ctx, tree, fname, false);
1569 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file failed");
1570
1571 info = torture_afpinfo_new(mem_ctx);
1572 torture_assert_goto(tctx, info != NULL, ret, done, "torture_afpinfo_new failed");
1573
1574 memcpy(info->afpi_FinderInfo, type_creator, 8);
1575 ret = torture_write_afpinfo(tree, tctx, mem_ctx, fname, info);
1576 torture_assert_goto(tctx, ret == true, ret, done, "torture_write_afpinfo failed");
1577
1578 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1579 0, 60, 0, 4, "AFP");
1580 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
1581
1582 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1583 0, 60, 16, 8, type_creator);
1584 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
1585
1586 /*
1587 * OS X ignores offset <= 60 and treats the as
1588 * offset=0. Reading from offsets > 60 returns EOF=0.
1589 */
1590
1591 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1592 16, 8, 0, 8, "AFP\0\0\0\001\0");
1593 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
1594
1595 len = read_stream(tree, __location__, tctx, mem_ctx, fname,
1596 AFPINFO_STREAM, 0, 61);
1597 torture_assert_goto(tctx, len == 60, ret, done, "read_stream failed");
1598
1599 len = read_stream(tree, __location__, tctx, mem_ctx, fname,
1600 AFPINFO_STREAM, 59, 2);
1601 torture_assert_goto(tctx, len == 2, ret, done, "read_stream failed");
1602
1603 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1604 59, 2, 0, 2, "AF");
1605 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
1606
1607 len = read_stream(tree, __location__, tctx, mem_ctx, fname,
1608 AFPINFO_STREAM, 60, 1);
1609 torture_assert_goto(tctx, len == 1, ret, done, "read_stream failed");
1610
1611 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1612 60, 1, 0, 1, "A");
1613 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
1614
1615 len = read_stream(tree, __location__, tctx, mem_ctx, fname,
1616 AFPINFO_STREAM, 61, 1);
1617 torture_assert_goto(tctx, len == 0, ret, done, "read_stream failed");
1618
1619 done:
1620 smb2_util_unlink(tree, fname);
1621 smb2_deltree(tree, BASEDIR);
1622 talloc_free(mem_ctx);
1623 return ret;
1624 }
1625
1626 static bool test_write_atalk_metadata(struct torture_context *tctx,
1627 struct smb2_tree *tree)
1628 {
1629 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1630 const char *fname = BASEDIR "\\torture_write_metadata";
1631 const char *type_creator = "SMB,OLE!";
1632 NTSTATUS status;
1633 struct smb2_handle testdirh;
1634 bool ret = true;
1635 AfpInfo *info;
1636
1637 smb2_deltree(tree, BASEDIR);
1638 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
1639 CHECK_STATUS(status, NT_STATUS_OK);
1640 smb2_util_close(tree, testdirh);
1641
1642 ret = torture_setup_file(mem_ctx, tree, fname, false);
1643 if (ret == false) {
1644 goto done;
1645 }
1646
1647 info = torture_afpinfo_new(mem_ctx);
1648 if (info == NULL) {
1649 goto done;
1650 }
1651
1652 memcpy(info->afpi_FinderInfo, type_creator, 8);
1653 ret = torture_write_afpinfo(tree, tctx, mem_ctx, fname, info);
1654 ret &= check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
1655 0, 60, 16, 8, type_creator);
1656
1657 done:
1658 smb2_util_unlink(tree, fname);
1659 smb2_deltree(tree, BASEDIR);
1660 talloc_free(mem_ctx);
1661 return ret;
1662 }
1663
1664 static bool test_write_atalk_rfork_io(struct torture_context *tctx,
1665 struct smb2_tree *tree)
1666 {
1667 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1668 const char *fname = BASEDIR "\\torture_write_rfork_io";
1669 const char *rfork = BASEDIR "\\torture_write_rfork_io" AFPRESOURCE_STREAM_NAME;
1670 const char *rfork_content = "1234567890";
1671 NTSTATUS status;
1672 struct smb2_handle testdirh;
1673 bool ret = true;
1674
1675 union smb_open io;
1676 struct smb2_handle filehandle;
1677 union smb_fileinfo finfo;
1678 union smb_setfileinfo sinfo;
1679
1680 smb2_util_unlink(tree, fname);
1681
1682 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
1683 CHECK_STATUS(status, NT_STATUS_OK);
1684 smb2_util_close(tree, testdirh);
1685
1686 ret = torture_setup_file(mem_ctx, tree, fname, false);
1687 if (ret == false) {
1688 goto done;
1689 }
1690
1691 torture_comment(tctx, "(%s) writing to resource fork\n",
1692 __location__);
1693
1694 ret &= write_stream(tree, __location__, tctx, mem_ctx,
1695 fname, AFPRESOURCE_STREAM_NAME,
1696 10, 10, rfork_content);
1697
1698 ret &= check_stream(tree, __location__, tctx, mem_ctx,
1699 fname, AFPRESOURCE_STREAM_NAME,
1700 0, 20, 10, 10, rfork_content);
1701
1702 /* Check size after write */
1703
1704 ZERO_STRUCT(io);
1705 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1706 io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
1707 SEC_FILE_WRITE_ATTRIBUTE;
1708 io.smb2.in.fname = rfork;
1709 status = smb2_create(tree, mem_ctx, &(io.smb2));
1710 CHECK_STATUS(status, NT_STATUS_OK);
1711 filehandle = io.smb2.out.file.handle;
1712
1713 torture_comment(tctx, "(%s) check resource fork size after write\n",
1714 __location__);
1715
1716 ZERO_STRUCT(finfo);
1717 finfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
1718 finfo.generic.in.file.handle = filehandle;
1719 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
1720 CHECK_STATUS(status, NT_STATUS_OK);
1721 if (finfo.all_info.out.size != 20) {
1722 torture_result(tctx, TORTURE_FAIL,
1723 "(%s) Incorrect resource fork size\n",
1724 __location__);
1725 ret = false;
1726 smb2_util_close(tree, filehandle);
1727 goto done;
1728 }
1729 smb2_util_close(tree, filehandle);
1730
1731 /* Write at large offset */
1732
1733 torture_comment(tctx, "(%s) writing to resource fork at large offset\n",
1734 __location__);
1735
1736 ret &= write_stream(tree, __location__, tctx, mem_ctx,
1737 fname, AFPRESOURCE_STREAM_NAME,
1738 (off_t)64*1024*1024, 10, rfork_content);
1739
1740 ret &= check_stream(tree, __location__, tctx, mem_ctx,
1741 fname, AFPRESOURCE_STREAM_NAME,
1742 (off_t)64*1024*1024, 10, 0, 10, rfork_content);
1743
1744 /* Truncate back to size of 1 byte */
1745
1746 torture_comment(tctx, "(%s) truncate resource fork and check size\n",
1747 __location__);
1748
1749 ZERO_STRUCT(io);
1750 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1751 io.smb2.in.desired_access = SEC_FILE_ALL;
1752 io.smb2.in.fname = rfork;
1753 status = smb2_create(tree, mem_ctx, &(io.smb2));
1754 CHECK_STATUS(status, NT_STATUS_OK);
1755 filehandle = io.smb2.out.file.handle;
1756
1757 ZERO_STRUCT(sinfo);
1758 sinfo.end_of_file_info.level =
1759 RAW_SFILEINFO_END_OF_FILE_INFORMATION;
1760 sinfo.end_of_file_info.in.file.handle = filehandle;
1761 sinfo.end_of_file_info.in.size = 1;
1762 status = smb2_setinfo_file(tree, &sinfo);
1763 CHECK_STATUS(status, NT_STATUS_OK);
1764
1765 smb2_util_close(tree, filehandle);
1766
1767 /* Now check size */
1768 ZERO_STRUCT(io);
1769 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1770 io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
1771 SEC_FILE_WRITE_ATTRIBUTE;
1772 io.smb2.in.fname = rfork;
1773 status = smb2_create(tree, mem_ctx, &(io.smb2));
1774 CHECK_STATUS(status, NT_STATUS_OK);
1775 filehandle = io.smb2.out.file.handle;
1776
1777 ZERO_STRUCT(finfo);
1778 finfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
1779 finfo.generic.in.file.handle = filehandle;
1780 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
1781 CHECK_STATUS(status, NT_STATUS_OK);
1782 if (finfo.all_info.out.size != 1) {
1783 torture_result(tctx, TORTURE_FAIL,
1784 "(%s) Incorrect resource fork size\n",
1785 __location__);
1786 ret = false;
1787 smb2_util_close(tree, filehandle);
1788 goto done;
1789 }
1790 smb2_util_close(tree, filehandle);
1791
1792 done:
1793 smb2_util_unlink(tree, fname);
1794 smb2_deltree(tree, BASEDIR);
1795 talloc_free(mem_ctx);
1796 return ret;
1797 }
1798
1799 static bool test_rfork_truncate(struct torture_context *tctx,
1800 struct smb2_tree *tree)
1801 {
1802 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1803 const char *fname = BASEDIR "\\torture_rfork_truncate";
1804 const char *rfork = BASEDIR "\\torture_rfork_truncate" AFPRESOURCE_STREAM;
1805 const char *rfork_content = "1234567890";
1806 NTSTATUS status;
1807 struct smb2_handle testdirh;
1808 bool ret = true;
1809 struct smb2_create create;
1810 struct smb2_handle fh1, fh2, fh3;
1811 union smb_setfileinfo sinfo;
1812
1813 ret = enable_aapl(tctx, tree);
1814 torture_assert_goto(tctx, ret == true, ret, done, "enable_aapl failed");
1815
1816 smb2_util_unlink(tree, fname);
1817
1818 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
1819 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
1820 smb2_util_close(tree, testdirh);
1821
1822 ret = torture_setup_file(mem_ctx, tree, fname, false);
1823 if (ret == false) {
1824 goto done;
1825 }
1826
1827 ret &= write_stream(tree, __location__, tctx, mem_ctx,
1828 fname, AFPRESOURCE_STREAM,
1829 10, 10, rfork_content);
1830
1831 /* Truncate back to size 0, further access MUST return ENOENT */
1832
1833 torture_comment(tctx, "(%s) truncate resource fork to size 0\n",
1834 __location__);
1835
1836 ZERO_STRUCT(create);
1837 create.in.create_disposition = NTCREATEX_DISP_OPEN;
1838 create.in.desired_access = SEC_STD_READ_CONTROL | SEC_FILE_ALL;
1839 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1840 create.in.fname = fname;
1841 create.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
1842 NTCREATEX_SHARE_ACCESS_READ |
1843 NTCREATEX_SHARE_ACCESS_WRITE;
1844 status = smb2_create(tree, mem_ctx, &create);
1845 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create");
1846 fh1 = create.out.file.handle;
1847
1848 ZERO_STRUCT(create);
1849 create.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1850 create.in.desired_access = SEC_STD_READ_CONTROL | SEC_FILE_ALL;
1851 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1852 create.in.fname = rfork;
1853 create.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
1854 NTCREATEX_SHARE_ACCESS_READ |
1855 NTCREATEX_SHARE_ACCESS_WRITE;
1856 status = smb2_create(tree, mem_ctx, &create);
1857 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create");
1858 fh2 = create.out.file.handle;
1859
1860 ZERO_STRUCT(sinfo);
1861 sinfo.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
1862 sinfo.end_of_file_info.in.file.handle = fh2;
1863 sinfo.end_of_file_info.in.size = 0;
1864 status = smb2_setinfo_file(tree, &sinfo);
1865 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_setinfo_file");
1866
1867 /*
1868 * Now check size, we should get OBJECT_NAME_NOT_FOUND (!)
1869 */
1870 ZERO_STRUCT(create);
1871 create.in.create_disposition = NTCREATEX_DISP_OPEN;
1872 create.in.desired_access = SEC_FILE_ALL;
1873 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1874 create.in.fname = rfork;
1875 create.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
1876 NTCREATEX_SHARE_ACCESS_READ |
1877 NTCREATEX_SHARE_ACCESS_WRITE;
1878 status = smb2_create(tree, mem_ctx, &create);
1879 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND, ret, done, "smb2_create");
1880
1881 /*
1882 * Do another open on the rfork and write to the new handle. A
1883 * naive server might unlink the AppleDouble resource fork
1884 * file when its truncated to 0 bytes above, so in case both
1885 * open handles share the same underlying fd, the unlink would
1886 * cause the below write to be lost.
1887 */
1888 ZERO_STRUCT(create);
1889 create.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1890 create.in.desired_access = SEC_STD_READ_CONTROL | SEC_FILE_ALL;
1891 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1892 create.in.fname = rfork;
1893 create.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
1894 NTCREATEX_SHARE_ACCESS_READ |
1895 NTCREATEX_SHARE_ACCESS_WRITE;
1896 status = smb2_create(tree, mem_ctx, &create);
1897 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create");
1898 fh3 = create.out.file.handle;
1899
1900 status = smb2_util_write(tree, fh3, "foo", 0, 3);
1901 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_util_write");
1902
1903 smb2_util_close(tree, fh3);
1904 smb2_util_close(tree, fh2);
1905 smb2_util_close(tree, fh1);
1906
1907 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPRESOURCE_STREAM,
1908 0, 3, 0, 3, "foo");
1909 torture_assert_goto(tctx, ret == true, ret, done, "check_stream");
1910
1911 done:
1912 smb2_util_unlink(tree, fname);
1913 smb2_deltree(tree, BASEDIR);
1914 talloc_free(mem_ctx);
1915 return ret;
1916 }
1917
1918 static bool test_rfork_create(struct torture_context *tctx,
1919 struct smb2_tree *tree)
1920 {
1921 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1922 const char *fname = BASEDIR "\\torture_rfork_create";
1923 const char *rfork = BASEDIR "\\torture_rfork_create" AFPRESOURCE_STREAM;
1924 NTSTATUS status;
1925 struct smb2_handle testdirh;
1926 bool ret = true;
1927 struct smb2_create create;
1928 struct smb2_handle fh1;
1929 const char *streams[] = {
1930 "::$DATA"
1931 };
1932 union smb_fileinfo finfo;
1933
1934 ret = enable_aapl(tctx, tree);
1935 torture_assert_goto(tctx, ret == true, ret, done, "enable_aapl failed");
1936
1937 smb2_util_unlink(tree, fname);
1938
1939 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
1940 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
1941 smb2_util_close(tree, testdirh);
1942
1943 ret = torture_setup_file(mem_ctx, tree, fname, false);
1944 if (ret == false) {
1945 goto done;
1946 }
1947
1948 torture_comment(tctx, "(%s) open rfork, should return ENOENT\n",
1949 __location__);
1950
1951 ZERO_STRUCT(create);
1952 create.in.create_disposition = NTCREATEX_DISP_OPEN;
1953 create.in.desired_access = SEC_STD_READ_CONTROL | SEC_FILE_ALL;
1954 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1955 create.in.fname = rfork;
1956 create.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
1957 NTCREATEX_SHARE_ACCESS_READ |
1958 NTCREATEX_SHARE_ACCESS_WRITE;
1959 status = smb2_create(tree, mem_ctx, &create);
1960 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND, ret, done, "smb2_create");
1961
1962 torture_comment(tctx, "(%s) create resource fork\n", __location__);
1963
1964 ZERO_STRUCT(create);
1965 create.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1966 create.in.desired_access = SEC_STD_READ_CONTROL | SEC_FILE_ALL;
1967 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1968 create.in.fname = rfork;
1969 create.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
1970 NTCREATEX_SHARE_ACCESS_READ |
1971 NTCREATEX_SHARE_ACCESS_WRITE;
1972 status = smb2_create(tree, mem_ctx, &create);
1973 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create");
1974 fh1 = create.out.file.handle;
1975
1976 torture_comment(tctx, "(%s) getinfo on create handle\n",
1977 __location__);
1978
1979 ZERO_STRUCT(finfo);
1980 finfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
1981 finfo.generic.in.file.handle = fh1;
1982 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
1983 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_getinfo_file");
1984 if (finfo.all_info.out.size != 0) {
1985 torture_result(tctx, TORTURE_FAIL,
1986 "(%s) Incorrect resource fork size\n",
1987 __location__);
1988 ret = false;
1989 smb2_util_close(tree, fh1);
1990 goto done;
1991 }
1992
1993 torture_comment(tctx, "(%s) open rfork, should still return ENOENT\n",
1994 __location__);
1995
1996 ZERO_STRUCT(create);
1997 create.in.create_disposition = NTCREATEX_DISP_OPEN;
1998 create.in.desired_access = SEC_STD_READ_CONTROL | SEC_FILE_ALL;
1999 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2000 create.in.fname = rfork;
2001 create.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
2002 NTCREATEX_SHARE_ACCESS_READ |
2003 NTCREATEX_SHARE_ACCESS_WRITE;
2004 status = smb2_create(tree, mem_ctx, &create);
2005 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND, ret, done, "smb2_create");
2006
2007 ret = check_stream_list(tree, tctx, fname, 1, streams, false);
2008 torture_assert_goto(tctx, ret == true, ret, done, "check_stream_list");
2009
2010 torture_comment(tctx, "(%s) close empty created rfork, open should return ENOENT\n",
2011 __location__);
2012
2013 ZERO_STRUCT(create);
2014 create.in.create_disposition = NTCREATEX_DISP_OPEN;
2015 create.in.desired_access = SEC_STD_READ_CONTROL | SEC_FILE_ALL;
2016 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2017 create.in.fname = rfork;
2018 create.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
2019 NTCREATEX_SHARE_ACCESS_READ |
2020 NTCREATEX_SHARE_ACCESS_WRITE;
2021 status = smb2_create(tree, mem_ctx, &create);
2022 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND, ret, done, "smb2_create");
2023
2024 done:
2025 smb2_util_unlink(tree, fname);
2026 smb2_deltree(tree, BASEDIR);
2027 talloc_free(mem_ctx);
2028 return ret;
2029 }
2030
2031 static bool test_rfork_create_ro(struct torture_context *tctx,
2032 struct smb2_tree *tree)
2033 {
2034 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2035 const char *fname = BASEDIR "\\torture_rfork_create";
2036 const char *rfork = BASEDIR "\\torture_rfork_create" AFPRESOURCE_STREAM;
2037 NTSTATUS status;
2038 struct smb2_handle testdirh;
2039 bool ret = true;
2040 struct smb2_create create;
2041
2042 smb2_util_unlink(tree, fname);
2043 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
2044 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
2045 "torture_smb2_testdir\n");
2046 smb2_util_close(tree, testdirh);
2047
2048 ret = torture_setup_file(mem_ctx, tree, fname, false);
2049 if (ret == false) {
2050 goto done;
2051 }
2052
2053 torture_comment(tctx, "(%s) Try opening read-only with "
2054 "open_if create disposition, should work\n",
2055 __location__);
2056
2057 ZERO_STRUCT(create);
2058 create.in.fname = rfork;
2059 create.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2060 create.in.desired_access = SEC_FILE_READ_DATA | SEC_STD_READ_CONTROL;
2061 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2062 create.in.share_access = FILE_SHARE_READ | FILE_SHARE_DELETE;
2063 status = smb2_create(tree, mem_ctx, &(create));
2064 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
2065 "smb2_create failed\n");
2066
2067 smb2_util_close(tree, create.out.file.handle);
2068
2069 done:
2070 smb2_util_unlink(tree, fname);
2071 smb2_deltree(tree, BASEDIR);
2072 talloc_free(mem_ctx);
2073 return ret;
2074 }
2075
2076 static bool test_adouble_conversion(struct torture_context *tctx,
2077 struct smb2_tree *tree)
2078 {
2079 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2080 const char *fname = BASEDIR "\\test_adouble_conversion";
2081 const char *adname = BASEDIR "/._test_adouble_conversion";
2082 NTSTATUS status;
2083 struct smb2_handle testdirh;
2084 bool ret = true;
2085 const char *data = "This resource fork intentionally left blank";
2086 size_t datalen = strlen(data);
2087 const char *streams[] = {
2088 "::$DATA",
2089 AFPINFO_STREAM,
2090 AFPRESOURCE_STREAM,
2091 ":com.apple.metadata" "\xef\x80\xa2" "_kMDItemUserTags:$DATA",
2092 ":foo" "\xef\x80\xa2" "bar:$DATA", /* "foo:bar:$DATA" */
2093 };
2094 bool is_osx = torture_setting_bool(tctx, "osx", false);
2095
2096 if (is_osx) {
2097 torture_skip(tctx, "Test only works with Samba\n");
2098 }
2099
2100 smb2_deltree(tree, BASEDIR);
2101
2102 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
2103 CHECK_STATUS(status, NT_STATUS_OK);
2104 smb2_util_close(tree, testdirh);
2105
2106 ret = torture_setup_file(tctx, tree, fname, false);
2107 torture_assert_goto(tctx, ret == true, ret, done,
2108 "torture_setup_file failed\n");
2109
2110 ret = torture_setup_file(tctx, tree, adname, false);
2111 torture_assert_goto(tctx, ret == true, ret, done,
2112 "torture_setup_file failed\n");
2113
2114 ret = write_stream(tree, __location__, tctx, mem_ctx,
2115 adname, NULL,
2116 0, sizeof(osx_adouble_w_xattr), osx_adouble_w_xattr);
2117 torture_assert_goto(tctx, ret == true, ret, done,
2118 "write_stream failed\n");
2119
2120 torture_comment(tctx, "(%s) test OS X AppleDouble conversion\n",
2121 __location__);
2122
2123 ret = check_stream(tree, __location__, tctx, mem_ctx,
2124 fname, AFPRESOURCE_STREAM,
2125 16, datalen, 0, datalen, data);
2126 torture_assert_goto(tctx, ret == true, ret, done,
2127 "check AFPRESOURCE_STREAM failed\n");
2128
2129 ret = check_stream(tree, __location__, tctx, mem_ctx,
2130 fname, AFPINFO_STREAM,
2131 0, 60, 16, 8, "TESTSLOW");
2132 torture_assert_goto(tctx, ret == true, ret, done,
2133 "check AFPINFO_STREAM failed\n");
2134
2135 ret = check_stream(tree, __location__, tctx, mem_ctx, fname,
2136 ":foo" "\xef\x80\xa2" "bar:$DATA", /* "foo:bar:$DATA" */
2137 0, 3, 0, 3, "baz");
2138 torture_assert_goto(tctx, ret == true, ret, done,
2139 "check foo:bar stream failed\n");
2140
2141 ret = check_stream_list(tree, tctx, fname, 5, streams, false);
2142 torture_assert_goto(tctx, ret == true, ret, done, "check_stream_list");
2143
2144 done:
2145 smb2_deltree(tree, BASEDIR);
2146 talloc_free(mem_ctx);
2147 return ret;
2148 }
2149
2150 /*
2151 * Test conversion of AppleDouble file without embedded xattr data
2152 */
2153 static bool test_adouble_conversion_wo_xattr(struct torture_context *tctx,
2154 struct smb2_tree *tree)
2155 {
2156 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2157 const char *fname = BASEDIR "\\test_adouble_conversion";
2158 const char *adname = BASEDIR "/._test_adouble_conversion";
2159 NTSTATUS status;
2160 struct smb2_handle testdirh;
2161 bool ret = true;
2162 const char *streams[] = {
2163 "::$DATA",
2164 AFPINFO_STREAM,
2165 AFPRESOURCE_STREAM
2166 };
2167 struct smb2_create create;
2168 struct smb2_find find;
2169 unsigned int count;
2170 union smb_search_data *d;
2171 const char *data = "This resource fork intentionally left blank";
2172 size_t datalen = strlen(data);
2173 bool is_osx = torture_setting_bool(tctx, "osx", false);
2174
2175 if (is_osx) {
2176 torture_skip(tctx, "Test only works with Samba\n");
2177 }
2178
2179 smb2_deltree(tree, BASEDIR);
2180
2181 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
2182 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
2183 "torture_smb2_testdir failed\n");
2184 smb2_util_close(tree, testdirh);
2185
2186 ret = torture_setup_file(tctx, tree, fname, false);
2187 torture_assert_goto(tctx, ret == true, ret, done,
2188 "torture_setup_file failed\n");
2189
2190 ret = torture_setup_file(tctx, tree, adname, false);
2191 torture_assert_goto(tctx, ret == true, ret, done,
2192 "torture_setup_file failed\n");
2193
2194 ret = write_stream(tree, __location__, tctx, mem_ctx,
2195 adname, NULL, 0,
2196 sizeof(osx_adouble_without_xattr),
2197 osx_adouble_without_xattr);
2198 torture_assert_goto(tctx, ret == true, ret, done,
2199 "write_stream failed\n");
2200
2201 ret = enable_aapl(tctx, tree);
2202 torture_assert_goto(tctx, ret == true, ret, done, "enable_aapl failed");
2203
2204 /*
2205 * Issue a smb2_find(), this triggers the server-side conversion
2206 */
2207
2208 create = (struct smb2_create) {
2209 .in.desired_access = SEC_RIGHTS_DIR_READ,
2210 .in.create_options = NTCREATEX_OPTIONS_DIRECTORY,
2211 .in.file_attributes = FILE_ATTRIBUTE_DIRECTORY,
2212 .in.share_access = NTCREATEX_SHARE_ACCESS_READ,
2213 .in.create_disposition = NTCREATEX_DISP_OPEN,
2214 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
2215 .in.fname = BASEDIR,
2216 };
2217
2218 status = smb2_create(tree, tctx, &create);
2219 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
2220 "smb2_create failed\n");
2221
2222 find = (struct smb2_find) {
2223 .in.file.handle = create.out.file.handle,
2224 .in.pattern = "*",
2225 .in.max_response_size = 0x1000,
2226 .in.level = SMB2_FIND_ID_BOTH_DIRECTORY_INFO,
2227 };
2228
2229 status = smb2_find_level(tree, tree, &find, &count, &d);
2230 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
2231 "smb2_find_level failed\n");
2232
2233 status = smb2_util_close(tree, create.out.file.handle);
2234 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
2235 "smb2_util_close failed");
2236
2237 /*
2238 * Check number of streams
2239 */
2240
2241 ret = check_stream_list(tree, tctx, fname, 3, streams, false);
2242 torture_assert_goto(tctx, ret == true, ret, done, "check_stream_list");
2243
2244
2245 /*
2246 * Check Resourcefork data can be read.
2247 */
2248
2249 ret = check_stream(tree, __location__, tctx, mem_ctx,
2250 fname, AFPRESOURCE_STREAM,
2251 16, datalen, 0, datalen, data);
2252 torture_assert_goto(tctx, ret == true, ret, done,
2253 "check AFPRESOURCE_STREAM failed\n");
2254
2255 /*
2256 * Check FinderInfo data has been migrated to stream.
2257 */
2258
2259 ret = check_stream(tree, __location__, tctx, mem_ctx,
2260 fname, AFPINFO_STREAM,
2261 0, 60, 16, 8, "WAVEPTul");
2262 torture_assert_goto(tctx, ret == true, ret, done,
2263 "check AFPINFO_STREAM failed\n");
2264
2265 done:
2266 smb2_deltree(tree, BASEDIR);
2267 talloc_free(mem_ctx);
2268 return ret;
2269 }
2270
2271 static bool test_aapl(struct torture_context *tctx,
2272 struct smb2_tree *tree)
2273 {
2274 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2275 const char *fname = BASEDIR "\\test_aapl";
2276 NTSTATUS status;
2277 struct smb2_handle testdirh;
2278 bool ret = true;
2279 struct smb2_create io;
2280 DATA_BLOB data;
2281 struct smb2_create_blob *aapl = NULL;
2282 AfpInfo *info;
2283 const char *type_creator = "SMB,OLE!";
2284 char type_creator_buf[9];
2285 uint32_t aapl_cmd;
2286 uint32_t aapl_reply_bitmap;
2287 uint32_t aapl_server_caps;
2288 uint32_t aapl_vol_caps;
2289 uint32_t expected_vol_caps = 0;
2290 char *model;
2291 struct smb2_find f;
2292 unsigned int count;
2293 union smb_search_data *d;
2294 uint64_t rfork_len;
2295 bool is_osx_server = torture_setting_bool(tctx, "osx", false);
2296
2297 smb2_deltree(tree, BASEDIR);
2298
2299 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
2300 CHECK_STATUS(status, NT_STATUS_OK);
2301 smb2_util_close(tree, testdirh);
2302
2303 ZERO_STRUCT(io);
2304 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
2305 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2306 io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
2307 io.in.share_access = (NTCREATEX_SHARE_ACCESS_DELETE |
2308 NTCREATEX_SHARE_ACCESS_READ |
2309 NTCREATEX_SHARE_ACCESS_WRITE);
2310 io.in.fname = fname;
2311
2312 /*
2313 * Issuing an SMB2/CREATE with a suitably formed AAPL context,
2314 * controls behaviour of Apple's SMB2 extensions for the whole
2315 * session!
2316 */
2317
2318 data = data_blob_talloc(mem_ctx, NULL, 3 * sizeof(uint64_t));
2319 SBVAL(data.data, 0, SMB2_CRTCTX_AAPL_SERVER_QUERY);
2320 SBVAL(data.data, 8, (SMB2_CRTCTX_AAPL_SERVER_CAPS |
2321 SMB2_CRTCTX_AAPL_VOLUME_CAPS |
2322 SMB2_CRTCTX_AAPL_MODEL_INFO));
2323 SBVAL(data.data, 16, (SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR |
2324 SMB2_CRTCTX_AAPL_UNIX_BASED |
2325 SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE));
2326
2327 torture_comment(tctx, "Testing SMB2 create context AAPL\n");
2328 status = smb2_create_blob_add(tctx, &io.in.blobs, "AAPL", data);
2329 CHECK_STATUS(status, NT_STATUS_OK);
2330
2331 status = smb2_create(tree, tctx, &io);
2332 CHECK_STATUS(status, NT_STATUS_OK);
2333 status = smb2_util_close(tree, io.out.file.handle);
2334 CHECK_STATUS(status, NT_STATUS_OK);
2335
2336 /*
2337 * Now check returned AAPL context
2338 */
2339 torture_comment(tctx, "Comparing returned AAPL capabilities\n");
2340
2341 aapl = smb2_create_blob_find(&io.out.blobs,
2342 SMB2_CREATE_TAG_AAPL);
2343
2344 if (aapl == NULL) {
2345 torture_result(tctx, TORTURE_FAIL,
2346 "(%s) unexpectedly no AAPL capabilities were returned.",
2347 __location__);
2348 ret = false;
2349 goto done;
2350 }
2351
2352 if (!is_osx_server) {
2353 size_t expected_aapl_ctx_size;
2354 bool size_ok;
2355
2356 /*
2357 * uint32_t CommandCode = kAAPL_SERVER_QUERY
2358 * uint32_t Reserved = 0;
2359 * uint64_t ReplyBitmap = kAAPL_SERVER_CAPS |
2360 * kAAPL_VOLUME_CAPS |
2361 * kAAPL_MODEL_INFO;
2362 * uint64_t ServerCaps = kAAPL_SUPPORTS_READDIR_ATTR |
2363 * kAAPL_SUPPORTS_OSX_COPYFILE;
2364 * uint64_t VolumeCaps = kAAPL_SUPPORT_RESOLVE_ID |
2365 * kAAPL_CASE_SENSITIVE;
2366 * uint32_t Pad2 = 0;
2367 * uint32_t ModelStringLen = 10;
2368 * ucs2_t ModelString[5] = "MacSamba";
2369 */
2370 expected_aapl_ctx_size = strlen("MacSamba") * 2 + 40;
2371
2372 size_ok = aapl->data.length == expected_aapl_ctx_size;
2373 torture_assert_goto(tctx, size_ok, ret, done, "bad AAPL size");
2374 }
2375
2376 aapl_cmd = IVAL(aapl->data.data, 0);
2377 if (aapl_cmd != SMB2_CRTCTX_AAPL_SERVER_QUERY) {
2378 torture_result(tctx, TORTURE_FAIL,
2379 "(%s) unexpected cmd: %d",
2380 __location__, (int)aapl_cmd);
2381 ret = false;
2382 goto done;
2383 }
2384
2385 aapl_reply_bitmap = BVAL(aapl->data.data, 8);
2386 if (aapl_reply_bitmap != (SMB2_CRTCTX_AAPL_SERVER_CAPS |
2387 SMB2_CRTCTX_AAPL_VOLUME_CAPS |
2388 SMB2_CRTCTX_AAPL_MODEL_INFO)) {
2389 torture_result(tctx, TORTURE_FAIL,
2390 "(%s) unexpected reply_bitmap: %d",
2391 __location__, (int)aapl_reply_bitmap);
2392 ret = false;
2393 goto done;
2394 }
2395
2396 aapl_server_caps = BVAL(aapl->data.data, 16);
2397 if (aapl_server_caps != (SMB2_CRTCTX_AAPL_UNIX_BASED |
2398 SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR |
2399 SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE |
2400 SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE)) {
2401 torture_result(tctx, TORTURE_FAIL,
2402 "(%s) unexpected server_caps: %d",
2403 __location__, (int)aapl_server_caps);
2404 ret = false;
2405 goto done;
2406 }
2407
2408 if (is_osx_server) {
2409 expected_vol_caps = 5;
2410 }
2411 aapl_vol_caps = BVAL(aapl->data.data, 24);
2412 if (aapl_vol_caps != expected_vol_caps) {
2413 /* this will fail on a case insensitive fs ... */
2414 torture_result(tctx, TORTURE_FAIL,
2415 "(%s) unexpected vol_caps: %d",
2416 __location__, (int)aapl_vol_caps);
2417 }
2418
2419 ret = convert_string_talloc(mem_ctx,
2420 CH_UTF16LE, CH_UNIX,
2421 aapl->data.data + 40, 10,
2422 &model, NULL);
2423 if (ret == false) {
2424 torture_result(tctx, TORTURE_FAIL,
2425 "(%s) convert_string_talloc() failed",
2426 __location__);
2427 goto done;
2428 }
2429 torture_comment(tctx, "Got server model: \"%s\"\n", model);
2430
2431 /*
2432 * Now that Requested AAPL extensions are enabled, setup some
2433 * Mac files with metadata and resource fork
2434 */
2435 ret = torture_setup_file(mem_ctx, tree, fname, false);
2436 if (ret == false) {
2437 torture_result(tctx, TORTURE_FAIL,
2438 "(%s) torture_setup_file() failed",
2439 __location__);
2440 goto done;
2441 }
2442
2443 info = torture_afpinfo_new(mem_ctx);
2444 if (info == NULL) {
2445 torture_result(tctx, TORTURE_FAIL,
2446 "(%s) torture_afpinfo_new() failed",
2447 __location__);
2448 ret = false;
2449 goto done;
2450 }
2451
2452 memcpy(info->afpi_FinderInfo, type_creator, 8);
2453 ret = torture_write_afpinfo(tree, tctx, mem_ctx, fname, info);
2454 if (ret == false) {
2455 torture_result(tctx, TORTURE_FAIL,
2456 "(%s) torture_write_afpinfo() failed",
2457 __location__);
2458 goto done;
2459 }
2460
2461 ret = write_stream(tree, __location__, tctx, mem_ctx,
2462 fname, AFPRESOURCE_STREAM_NAME,
2463 0, 3, "foo");
2464 if (ret == false) {
2465 torture_result(tctx, TORTURE_FAIL,
2466 "(%s) write_stream() failed",
2467 __location__);
2468 goto done;
2469 }
2470
2471 /*
2472 * Ok, file is prepared, now call smb2/find
2473 */
2474
2475 ZERO_STRUCT(io);
2476 io.in.desired_access = SEC_RIGHTS_DIR_READ;
2477 io.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
2478 io.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
2479 io.in.share_access = (NTCREATEX_SHARE_ACCESS_READ |
2480 NTCREATEX_SHARE_ACCESS_WRITE |
2481 NTCREATEX_SHARE_ACCESS_DELETE);
2482 io.in.create_disposition = NTCREATEX_DISP_OPEN;
2483 io.in.fname = BASEDIR;
2484 status = smb2_create(tree, tctx, &io);
2485 CHECK_STATUS(status, NT_STATUS_OK);
2486
2487 ZERO_STRUCT(f);
2488 f.in.file.handle = io.out.file.handle;
2489 f.in.pattern = "test_aapl";
2490 f.in.continue_flags = SMB2_CONTINUE_FLAG_SINGLE;
2491 f.in.max_response_size = 0x1000;
2492 f.in.level = SMB2_FIND_ID_BOTH_DIRECTORY_INFO;
2493
2494 status = smb2_find_level(tree, tree, &f, &count, &d);
2495 CHECK_STATUS(status, NT_STATUS_OK);
2496
2497 status = smb2_util_close(tree, io.out.file.handle);
2498 CHECK_STATUS(status, NT_STATUS_OK);
2499
2500 if (strcmp(d[0].id_both_directory_info.name.s, "test_aapl") != 0) {
2501 torture_result(tctx, TORTURE_FAIL,
2502 "(%s) write_stream() failed",
2503 __location__);
2504 ret = false;
2505 goto done;
2506 }
2507
2508 if (d[0].id_both_directory_info.short_name.private_length != 24) {
2509 torture_result(tctx, TORTURE_FAIL,
2510 "(%s) bad short_name length %" PRIu32 ", expected 24",
2511 __location__, d[0].id_both_directory_info.short_name.private_length);
2512 ret = false;
2513 goto done;
2514 }
2515
2516 torture_comment(tctx, "short_name buffer:\n");
2517 dump_data(0, d[0].id_both_directory_info.short_name_buf, 24);
2518
2519 /*
2520 * Extract data as specified by the AAPL extension:
2521 * - ea_size contains max_access
2522 * - short_name contains resource fork length + FinderInfo
2523 * - reserved2 contains the unix mode
2524 */
2525 torture_comment(tctx, "mac_access: %" PRIx32 "\n",
2526 d[0].id_both_directory_info.ea_size);
2527
2528 rfork_len = BVAL(d[0].id_both_directory_info.short_name_buf, 0);
2529 if (rfork_len != 3) {
2530 torture_result(tctx, TORTURE_FAIL,
2531 "(%s) expected resource fork length 3, got: %" PRIu64,
2532 __location__, rfork_len);
2533 ret = false;
2534 goto done;
2535 }
2536
2537 memcpy(type_creator_buf, d[0].id_both_directory_info.short_name_buf + 8, 8);
2538 type_creator_buf[8] = 0;
2539 if (strcmp(type_creator, type_creator_buf) != 0) {
2540 torture_result(tctx, TORTURE_FAIL,
2541 "(%s) expected type/creator \"%s\" , got: %s",
2542 __location__, type_creator, type_creator_buf);
2543 ret = false;
2544 goto done;
2545 }
2546
2547 done:
2548 smb2_util_unlink(tree, fname);
2549 smb2_deltree(tree, BASEDIR);
2550 talloc_free(mem_ctx);
2551 return ret;
2552 }
2553
2554 static uint64_t patt_hash(uint64_t off)
2555 {
2556 return off;
2557 }
2558
2559 static bool write_pattern(struct torture_context *torture,
2560 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
2561 struct smb2_handle h, uint64_t off, uint64_t len,
2562 uint64_t patt_off)
2563 {
2564 NTSTATUS status;
2565 uint64_t i;
2566 uint8_t *buf;
2567 uint64_t io_sz = MIN(1024 * 64, len);
2568
2569 if (len == 0) {
2570 return true;
2571 }
2572
2573 torture_assert(torture, (len % 8) == 0, "invalid write len");
2574
2575 buf = talloc_zero_size(mem_ctx, io_sz);
2576 torture_assert(torture, (buf != NULL), "no memory for file data buf");
2577
2578 while (len > 0) {
2579 for (i = 0; i <= io_sz - 8; i += 8) {
2580 SBVAL(buf, i, patt_hash(patt_off));
2581 patt_off += 8;
2582 }
2583
2584 status = smb2_util_write(tree, h,
2585 buf, off, io_sz);
2586 torture_assert_ntstatus_ok(torture, status, "file write");
2587
2588 len -= io_sz;
2589 off += io_sz;
2590 }
2591
2592 talloc_free(buf);
2593
2594 return true;
2595 }
2596
2597 static bool check_pattern(struct torture_context *torture,
2598 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
2599 struct smb2_handle h, uint64_t off, uint64_t len,
2600 uint64_t patt_off)
2601 {
2602 if (len == 0) {
2603 return true;
2604 }
2605
2606 torture_assert(torture, (len % 8) == 0, "invalid read len");
2607
2608 while (len > 0) {
2609 uint64_t i;
2610 struct smb2_read r;
2611 NTSTATUS status;
2612 uint64_t io_sz = MIN(1024 * 64, len);
2613
2614 ZERO_STRUCT(r);
2615 r.in.file.handle = h;
2616 r.in.length = io_sz;
2617 r.in.offset = off;
2618 status = smb2_read(tree, mem_ctx, &r);
2619 torture_assert_ntstatus_ok(torture, status, "read");
2620
2621 torture_assert_u64_equal(torture, r.out.data.length, io_sz,
2622 "read data len mismatch");
2623
2624 for (i = 0; i <= io_sz - 8; i += 8, patt_off += 8) {
2625 uint64_t data = BVAL(r.out.data.data, i);
2626 torture_assert_u64_equal(torture, data, patt_hash(patt_off),
2627 talloc_asprintf(torture, "read data "
2628 "pattern bad at %llu\n",
2629 (unsigned long long)off + i));
2630 }
2631 talloc_free(r.out.data.data);
2632 len -= io_sz;
2633 off += io_sz;
2634 }
2635
2636 return true;
2637 }
2638
2639 static bool test_setup_open(struct torture_context *torture,
2640 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
2641 const char *fname,
2642 struct smb2_handle *fh,
2643 uint32_t desired_access,
2644 uint32_t file_attributes)
2645 {
2646 struct smb2_create io;
2647 NTSTATUS status;
2648
2649 ZERO_STRUCT(io);
2650 io.in.desired_access = desired_access;
2651 io.in.file_attributes = file_attributes;
2652 io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2653 io.in.share_access =
2654 NTCREATEX_SHARE_ACCESS_DELETE|
2655 NTCREATEX_SHARE_ACCESS_READ|
2656 NTCREATEX_SHARE_ACCESS_WRITE;
2657 if (file_attributes & FILE_ATTRIBUTE_DIRECTORY) {
2658 io.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
2659 }
2660 io.in.fname = fname;
2661
2662 status = smb2_create(tree, mem_ctx, &io);
2663 torture_assert_ntstatus_ok(torture, status, "file create");
2664
2665 *fh = io.out.file.handle;
2666
2667 return true;
2668 }
2669
2670 static bool test_setup_create_fill(struct torture_context *torture,
2671 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
2672 const char *fname,
2673 struct smb2_handle *fh,
2674 uint64_t size,
2675 uint32_t desired_access,
2676 uint32_t file_attributes)
2677 {
2678 bool ok;
2679
2680 ok = test_setup_open(torture, tree, mem_ctx,
2681 fname,
2682 fh,
2683 desired_access,
2684 file_attributes);
2685 torture_assert(torture, ok, "file open");
2686
2687 if (size > 0) {
2688 ok = write_pattern(torture, tree, mem_ctx, *fh, 0, size, 0);
2689 torture_assert(torture, ok, "write pattern");
2690 }
2691 return true;
2692 }
2693
2694 static bool test_setup_copy_chunk(struct torture_context *torture,
2695 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
2696 uint32_t nchunks,
2697 const char *src_name,
2698 struct smb2_handle *src_h,
2699 uint64_t src_size,
2700 uint32_t src_desired_access,
2701 const char *dst_name,
2702 struct smb2_handle *dest_h,
2703 uint64_t dest_size,
2704 uint32_t dest_desired_access,
2705 struct srv_copychunk_copy *cc_copy,
2706 union smb_ioctl *io)
2707 {
2708 struct req_resume_key_rsp res_key;
2709 bool ok;
2710 NTSTATUS status;
2711 enum ndr_err_code ndr_ret;
2712
2713 ok = test_setup_create_fill(torture, tree, mem_ctx, src_name,
2714 src_h, src_size, src_desired_access,
2715 FILE_ATTRIBUTE_NORMAL);
2716 torture_assert(torture, ok, "src file create fill");
2717
2718 ok = test_setup_create_fill(torture, tree, mem_ctx, dst_name,
2719 dest_h, dest_size, dest_desired_access,
2720 FILE_ATTRIBUTE_NORMAL);
2721 torture_assert(torture, ok, "dest file create fill");
2722
2723 ZERO_STRUCTPN(io);
2724 io->smb2.level = RAW_IOCTL_SMB2;
2725 io->smb2.in.file.handle = *src_h;
2726 io->smb2.in.function = FSCTL_SRV_REQUEST_RESUME_KEY;
2727 /* Allow for Key + ContextLength + Context */
2728 io->smb2.in.max_output_response = 32;
2729 io->smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
2730
2731 status = smb2_ioctl(tree, mem_ctx, &io->smb2);
2732 torture_assert_ntstatus_ok(torture, status,
2733 "FSCTL_SRV_REQUEST_RESUME_KEY");
2734
2735 ndr_ret = ndr_pull_struct_blob(&io->smb2.out.out, mem_ctx, &res_key,
2736 (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
2737
2738 torture_assert_ndr_success(torture, ndr_ret,
2739 "ndr_pull_req_resume_key_rsp");
2740
2741 ZERO_STRUCTPN(io);
2742 io->smb2.level = RAW_IOCTL_SMB2;
2743 io->smb2.in.file.handle = *dest_h;
2744 io->smb2.in.function = FSCTL_SRV_COPYCHUNK;
2745 io->smb2.in.max_output_response = sizeof(struct srv_copychunk_rsp);
2746 io->smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
2747
2748 ZERO_STRUCTPN(cc_copy);
2749 memcpy(cc_copy->source_key, res_key.resume_key, ARRAY_SIZE(cc_copy->source_key));
2750 cc_copy->chunk_count = nchunks;
2751 cc_copy->chunks = talloc_zero_array(mem_ctx, struct srv_copychunk, nchunks);
2752 torture_assert(torture, (cc_copy->chunks != NULL), "no memory for chunks");
2753
2754 return true;
2755 }
2756
2757
2758 static bool check_copy_chunk_rsp(struct torture_context *torture,
2759 struct srv_copychunk_rsp *cc_rsp,
2760 uint32_t ex_chunks_written,
2761 uint32_t ex_chunk_bytes_written,
2762 uint32_t ex_total_bytes_written)
2763 {
2764 torture_assert_int_equal(torture, cc_rsp->chunks_written,
2765 ex_chunks_written, "num chunks");
2766 torture_assert_int_equal(torture, cc_rsp->chunk_bytes_written,
2767 ex_chunk_bytes_written, "chunk bytes written");
2768 torture_assert_int_equal(torture, cc_rsp->total_bytes_written,
2769 ex_total_bytes_written, "chunk total bytes");
2770 return true;
2771 }
2772
2773 static bool neg_aapl_copyfile(struct torture_context *tctx,
2774 struct smb2_tree *tree,
2775 uint64_t flags)
2776 {
2777 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2778 const char *fname = "aapl";
2779 NTSTATUS status;
2780 struct smb2_create io;
2781 DATA_BLOB data;
2782 struct smb2_create_blob *aapl = NULL;
2783 uint32_t aapl_cmd;
2784 uint32_t aapl_reply_bitmap;
2785 uint32_t aapl_server_caps;
2786 bool ret = true;
2787
2788 ZERO_STRUCT(io);
2789 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
2790 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2791 io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
2792 io.in.share_access = (NTCREATEX_SHARE_ACCESS_DELETE |
2793 NTCREATEX_SHARE_ACCESS_READ |
2794 NTCREATEX_SHARE_ACCESS_WRITE);
2795 io.in.fname = fname;
2796
2797 data = data_blob_talloc(mem_ctx, NULL, 3 * sizeof(uint64_t));
2798 SBVAL(data.data, 0, SMB2_CRTCTX_AAPL_SERVER_QUERY);
2799 SBVAL(data.data, 8, (SMB2_CRTCTX_AAPL_SERVER_CAPS));
2800 SBVAL(data.data, 16, flags);
2801
2802 status = smb2_create_blob_add(tctx, &io.in.blobs, "AAPL", data);
2803 CHECK_STATUS(status, NT_STATUS_OK);
2804
2805 status = smb2_create(tree, tctx, &io);
2806 CHECK_STATUS(status, NT_STATUS_OK);
2807
2808 aapl = smb2_create_blob_find(&io.out.blobs,
2809 SMB2_CREATE_TAG_AAPL);
2810 if (aapl == NULL) {
2811 ret = false;
2812 goto done;
2813
2814 }
2815 if (aapl->data.length < 24) {
2816 ret = false;
2817 goto done;
2818 }
2819
2820 aapl_cmd = IVAL(aapl->data.data, 0);
2821 if (aapl_cmd != SMB2_CRTCTX_AAPL_SERVER_QUERY) {
2822 torture_result(tctx, TORTURE_FAIL,
2823 "(%s) unexpected cmd: %d",
2824 __location__, (int)aapl_cmd);
2825 ret = false;
2826 goto done;
2827 }
2828
2829 aapl_reply_bitmap = BVAL(aapl->data.data, 8);
2830 if (!(aapl_reply_bitmap & SMB2_CRTCTX_AAPL_SERVER_CAPS)) {
2831 torture_result(tctx, TORTURE_FAIL,
2832 "(%s) unexpected reply_bitmap: %d",
2833 __location__, (int)aapl_reply_bitmap);
2834 ret = false;
2835 goto done;
2836 }
2837
2838 aapl_server_caps = BVAL(aapl->data.data, 16);
2839 if (!(aapl_server_caps & flags)) {
2840 torture_result(tctx, TORTURE_FAIL,
2841 "(%s) unexpected server_caps: %d",
2842 __location__, (int)aapl_server_caps);
2843 ret = false;
2844 goto done;
2845 }
2846
2847 done:
2848 status = smb2_util_close(tree, io.out.file.handle);
2849 CHECK_STATUS(status, NT_STATUS_OK);
2850
2851 smb2_util_unlink(tree, "aapl");
2852 talloc_free(mem_ctx);
2853 return ret;
2854 }
2855
2856 static bool test_copyfile(struct torture_context *torture,
2857 struct smb2_tree *tree)
2858 {
2859 struct smb2_handle src_h;
2860 struct smb2_handle dest_h;
2861 NTSTATUS status;
2862 union smb_ioctl io;
2863 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2864 struct srv_copychunk_copy cc_copy;
2865 struct srv_copychunk_rsp cc_rsp;
2866 enum ndr_err_code ndr_ret;
2867 bool ok;
2868 const char *sname = ":foo" "\xef\x80\xa2" "bar:$DATA";
2869
2870 /*
2871 * First test a copy_chunk with a 0 chunk count without having
2872 * enabled this via AAPL. The request must not fail and the
2873 * copied length in the response must be 0. This is verified
2874 * against Windows 2008r2.
2875 */
2876
2877 ok = test_setup_copy_chunk(torture, tree, tmp_ctx,
2878 0, /* 0 chunks, copyfile semantics */
2879 FNAME_CC_SRC,
2880 &src_h, 4096, /* fill 4096 byte src file */
2881 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
2882 FNAME_CC_DST,
2883 &dest_h, 0, /* 0 byte dest file */
2884 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
2885 &cc_copy,
2886 &io);
2887 if (!ok) {
2888 torture_fail_goto(torture, done, "setup copy chunk error");
2889 }
2890
2891 ndr_ret = ndr_push_struct_blob(&io.smb2.in.out, tmp_ctx,
2892 &cc_copy,
2893 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
2894 torture_assert_ndr_success(torture, ndr_ret,
2895 "ndr_push_srv_copychunk_copy");
2896
2897 status = smb2_ioctl(tree, tmp_ctx, &io.smb2);
2898 torture_assert_ntstatus_ok_goto(torture, status, ok, done, "FSCTL_SRV_COPYCHUNK");
2899
2900 ndr_ret = ndr_pull_struct_blob(&io.smb2.out.out, tmp_ctx,
2901 &cc_rsp,
2902 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
2903 torture_assert_ndr_success(torture, ndr_ret,
2904 "ndr_pull_srv_copychunk_rsp");
2905
2906 ok = check_copy_chunk_rsp(torture, &cc_rsp,
2907 0, /* chunks written */
2908 0, /* chunk bytes unsuccessfully written */
2909 0); /* total bytes written */
2910 if (!ok) {
2911 torture_fail_goto(torture, done, "bad copy chunk response data");
2912 }
2913
2914 /*
2915 * Now enable AAPL copyfile and test again, the file and the
2916 * stream must be copied by the server.
2917 */
2918 ok = neg_aapl_copyfile(torture, tree,
2919 SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE);
2920 if (!ok) {
2921 torture_skip_goto(torture, done, "missing AAPL copyfile");
2922 goto done;
2923 }
2924
2925 smb2_util_close(tree, src_h);
2926 smb2_util_close(tree, dest_h);
2927 smb2_util_unlink(tree, FNAME_CC_SRC);
2928 smb2_util_unlink(tree, FNAME_CC_DST);
2929
2930 ok = torture_setup_file(tmp_ctx, tree, FNAME_CC_SRC, false);
2931 if (!ok) {
2932 torture_fail(torture, "setup file error");
2933 }
2934 ok = write_stream(tree, __location__, torture, tmp_ctx,
2935 FNAME_CC_SRC, AFPRESOURCE_STREAM,
2936 10, 10, "1234567890");
2937 if (!ok) {
2938 torture_fail(torture, "setup stream error");
2939 }
2940
2941 ok = write_stream(tree, __location__, torture, tmp_ctx,
2942 FNAME_CC_SRC, sname,
2943 10, 10, "abcdefghij");
2944 torture_assert_goto(torture, ok == true, ok, done, "write_stream failed\n");
2945
2946 ok = test_setup_copy_chunk(torture, tree, tmp_ctx,
2947 0, /* 0 chunks, copyfile semantics */
2948 FNAME_CC_SRC,
2949 &src_h, 4096, /* fill 4096 byte src file */
2950 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
2951 FNAME_CC_DST,
2952 &dest_h, 0, /* 0 byte dest file */
2953 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
2954 &cc_copy,
2955 &io);
2956 if (!ok) {
2957 torture_fail_goto(torture, done, "setup copy chunk error");
2958 }
2959
2960 ndr_ret = ndr_push_struct_blob(&io.smb2.in.out, tmp_ctx,
2961 &cc_copy,
2962 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
2963 torture_assert_ndr_success(torture, ndr_ret,
2964 "ndr_push_srv_copychunk_copy");
2965
2966 status = smb2_ioctl(tree, tmp_ctx, &io.smb2);
2967 torture_assert_ntstatus_ok_goto(torture, status, ok, done, "FSCTL_SRV_COPYCHUNK");
2968
2969 ndr_ret = ndr_pull_struct_blob(&io.smb2.out.out, tmp_ctx,
2970 &cc_rsp,
2971 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
2972 torture_assert_ndr_success(torture, ndr_ret,
2973 "ndr_pull_srv_copychunk_rsp");
2974
2975 ok = check_copy_chunk_rsp(torture, &cc_rsp,
2976 0, /* chunks written */
2977 0, /* chunk bytes unsuccessfully written */
2978 4096); /* total bytes written */
2979 if (!ok) {
2980 torture_fail_goto(torture, done, "bad copy chunk response data");
2981 }
2982
2983 ok = test_setup_open(torture, tree, tmp_ctx, FNAME_CC_DST, &dest_h,
2984 SEC_FILE_READ_DATA, FILE_ATTRIBUTE_NORMAL);
2985 if (!ok) {
2986 torture_fail_goto(torture, done,"open failed");
2987 }
2988 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 4096, 0);
2989 if (!ok) {
2990 torture_fail_goto(torture, done, "inconsistent file data");
2991 }
2992
2993 ok = check_stream(tree, __location__, torture, tmp_ctx,
2994 FNAME_CC_DST, AFPRESOURCE_STREAM,
2995 0, 20, 10, 10, "1234567890");
2996 if (!ok) {
2997 torture_fail_goto(torture, done, "inconsistent stream data");
2998 }
2999
3000 ok = check_stream(tree, __location__, torture, tmp_ctx,
3001 FNAME_CC_DST, sname,
3002 0, 20, 10, 10, "abcdefghij");
3003 torture_assert_goto(torture, ok == true, ok, done, "check_stream failed\n");
3004
3005 done:
3006 smb2_util_close(tree, src_h);
3007 smb2_util_close(tree, dest_h);
3008 smb2_util_unlink(tree, FNAME_CC_SRC);
3009 smb2_util_unlink(tree, FNAME_CC_DST);
3010 talloc_free(tmp_ctx);
3011 return true;
3012 }
3013
3014 static bool check_stream_list(struct smb2_tree *tree,
3015 struct torture_context *tctx,
3016 const char *fname,
3017 int num_exp,
3018 const char **exp,
3019 bool is_dir)
3020 {
3021 bool ret = true;
3022 union smb_fileinfo finfo;
3023 NTSTATUS status;
3024 int i;
3025 TALLOC_CTX *tmp_ctx = talloc_new(tctx);
3026 char **exp_sort;
3027 struct stream_struct *stream_sort;
3028 struct smb2_create create;
3029 struct smb2_handle h;
3030
3031 ZERO_STRUCT(h);
3032 torture_assert_goto(tctx, tmp_ctx != NULL, ret, done, "talloc_new failed");
3033
3034 ZERO_STRUCT(create);
3035 create.in.fname = fname;
3036 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3037 create.in.desired_access = SEC_FILE_ALL;
3038 create.in.create_options = is_dir ? NTCREATEX_OPTIONS_DIRECTORY : 0;
3039 create.in.file_attributes = is_dir ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL;
3040 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
3041 status = smb2_create(tree, tmp_ctx, &create);
3042 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create");
3043 h = create.out.file.handle;
3044
3045 finfo.generic.level = RAW_FILEINFO_STREAM_INFORMATION;
3046 finfo.generic.in.file.handle = h;
3047
3048 status = smb2_getinfo_file(tree, tctx, &finfo);
3049 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "get stream info");
3050
3051 smb2_util_close(tree, h);
3052
3053 torture_assert_int_equal_goto(tctx, finfo.stream_info.out.num_streams, num_exp,
3054 ret, done, "stream count");
3055
3056 if (num_exp == 0) {
3057 TALLOC_FREE(tmp_ctx);
3058 goto done;
3059 }
3060
3061 exp_sort = talloc_memdup(tmp_ctx, exp, num_exp * sizeof(*exp));
3062 torture_assert_goto(tctx, exp_sort != NULL, ret, done, __location__);
3063
3064 TYPESAFE_QSORT(exp_sort, num_exp, qsort_string);
3065
3066 stream_sort = talloc_memdup(tmp_ctx, finfo.stream_info.out.streams,
3067 finfo.stream_info.out.num_streams *
3068 sizeof(*stream_sort));
3069 torture_assert_goto(tctx, stream_sort != NULL, ret, done, __location__);
3070
3071 TYPESAFE_QSORT(stream_sort, finfo.stream_info.out.num_streams, qsort_stream);
3072
3073 for (i=0; i<num_exp; i++) {
3074 torture_comment(tctx, "i[%d] exp[%s] got[%s]\n",
3075 i, exp_sort[i], stream_sort[i].stream_name.s);
3076 torture_assert_str_equal_goto(tctx, stream_sort[i].stream_name.s, exp_sort[i],
3077 ret, done, "stream name");
3078 }
3079
3080 done:
3081 TALLOC_FREE(tmp_ctx);
3082 return ret;
3083 }
3084
3085 static bool check_stream_list_handle(struct smb2_tree *tree,
3086 struct torture_context *tctx,
3087 struct smb2_handle h,
3088 int num_exp,
3089 const char **exp,
3090 bool is_dir)
3091 {
3092 bool ret = true;
3093 union smb_fileinfo finfo;
3094 NTSTATUS status;
3095 int i;
3096 TALLOC_CTX *tmp_ctx = talloc_new(tctx);
3097 char **exp_sort;
3098 struct stream_struct *stream_sort;
3099
3100 torture_assert_goto(tctx, tmp_ctx != NULL, ret, done,
3101 "talloc_new failed\n");
3102
3103 finfo = (union smb_fileinfo) {
3104 .stream_info.level = RAW_FILEINFO_STREAM_INFORMATION,
3105 .stream_info.in.file.handle = h,
3106 };
3107
3108 status = smb2_getinfo_file(tree, tctx, &finfo);
3109 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
3110 "get stream info\n");
3111
3112 torture_assert_int_equal_goto(tctx, finfo.stream_info.out.num_streams,
3113 num_exp, ret, done, "stream count\n");
3114
3115 if (num_exp == 0) {
3116 TALLOC_FREE(tmp_ctx);
3117 goto done;
3118 }
3119
3120 exp_sort = talloc_memdup(tmp_ctx, exp, num_exp * sizeof(*exp));
3121 torture_assert_goto(tctx, exp_sort != NULL, ret, done, __location__);
3122
3123 TYPESAFE_QSORT(exp_sort, num_exp, qsort_string);
3124
3125 stream_sort = talloc_memdup(tmp_ctx, finfo.stream_info.out.streams,
3126 finfo.stream_info.out.num_streams *
3127 sizeof(*stream_sort));
3128 torture_assert_goto(tctx, stream_sort != NULL, ret, done, __location__);
3129
3130 TYPESAFE_QSORT(stream_sort, finfo.stream_info.out.num_streams, qsort_stream);
3131
3132 for (i=0; i<num_exp; i++) {
3133 torture_comment(tctx, "i[%d] exp[%s] got[%s]\n",
3134 i, exp_sort[i], stream_sort[i].stream_name.s);
3135 torture_assert_str_equal_goto(tctx, stream_sort[i].stream_name.s,
3136 exp_sort[i], ret, done,
3137 "stream name\n");
3138 }
3139
3140 done:
3141 TALLOC_FREE(tmp_ctx);
3142 return ret;
3143 }
3144
3145 /*
3146 test stream names
3147 */
3148 static bool test_stream_names(struct torture_context *tctx,
3149 struct smb2_tree *tree)
3150 {
3151 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3152 NTSTATUS status;
3153 struct smb2_create create;
3154 struct smb2_handle h;
3155 const char *fname = BASEDIR "\\stream_names.txt";
3156 const char *sname1;
3157 bool ret;
3158 /* UTF8 private use are starts at 0xef 0x80 0x80 (0xf000) */
3159 const char *streams[] = {
3160 ":foo" "\xef\x80\xa2" "bar:$DATA", /* "foo:bar:$DATA" */
3161 "::$DATA"
3162 };
3163
3164 sname1 = talloc_asprintf(mem_ctx, "%s%s", fname, streams[0]);
3165
3166 /* clean slate ...*/
3167 smb2_util_unlink(tree, fname);
3168 smb2_deltree(tree, fname);
3169 smb2_deltree(tree, BASEDIR);
3170
3171 status = torture_smb2_testdir(tree, BASEDIR, &h);
3172 CHECK_STATUS(status, NT_STATUS_OK);
3173 smb2_util_close(tree, h);
3174
3175 ret = torture_setup_file(mem_ctx, tree, fname, false);
3176 torture_assert_goto(tctx, ret, ret, done, "torture_setup_file");
3177
3178 torture_comment(tctx, "(%s) testing stream names\n", __location__);
3179 ZERO_STRUCT(create);
3180 create.in.desired_access = SEC_FILE_WRITE_DATA;
3181 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3182 create.in.share_access =
3183 NTCREATEX_SHARE_ACCESS_DELETE|
3184 NTCREATEX_SHARE_ACCESS_READ|
3185 NTCREATEX_SHARE_ACCESS_WRITE;
3186 create.in.create_disposition = NTCREATEX_DISP_CREATE;
3187 create.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3188 create.in.fname = sname1;
3189
3190 status = smb2_create(tree, mem_ctx, &create);
3191 CHECK_STATUS(status, NT_STATUS_OK);
3192
3193 status = smb2_util_write(tree, create.out.file.handle, "foo", 0, 3);
3194 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
3195 "smb2_util_write failed\n");
3196
3197 smb2_util_close(tree, create.out.file.handle);
3198
3199 ret = check_stream_list(tree, tctx, fname, 2, streams, false);
3200 CHECK_VALUE(ret, true);
3201
3202 done:
3203 status = smb2_util_unlink(tree, fname);
3204 smb2_deltree(tree, BASEDIR);
3205 talloc_free(mem_ctx);
3206
3207 return ret;
3208 }
3209
3210 /* Renaming a directory with open file, should work for OS X AAPL clients */
3211 static bool test_rename_dir_openfile(struct torture_context *torture,
3212 struct smb2_tree *tree)
3213 {
3214 bool ret = true;
3215 NTSTATUS status;
3216 union smb_open io;
3217 union smb_close cl;
3218 union smb_setfileinfo sinfo;
3219 struct smb2_handle d1, h1;
3220 const char *renamedir = BASEDIR "-new";
3221 bool server_is_osx = torture_setting_bool(torture, "osx", false);
3222
3223 smb2_deltree(tree, BASEDIR);
3224 smb2_util_rmdir(tree, BASEDIR);
3225 smb2_deltree(tree, renamedir);
3226
3227 ZERO_STRUCT(io.smb2);
3228 io.generic.level = RAW_OPEN_SMB2;
3229 io.smb2.in.create_flags = 0;
3230 io.smb2.in.desired_access = 0x0017019f;
3231 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
3232 io.smb2.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
3233 io.smb2.in.share_access = 0;
3234 io.smb2.in.alloc_size = 0;
3235 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
3236 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3237 io.smb2.in.security_flags = 0;
3238 io.smb2.in.fname = BASEDIR;
3239
3240 status = smb2_create(tree, torture, &(io.smb2));
3241 torture_assert_ntstatus_ok(torture, status, "smb2_create dir");
3242 d1 = io.smb2.out.file.handle;
3243
3244 ZERO_STRUCT(io.smb2);
3245 io.generic.level = RAW_OPEN_SMB2;
3246 io.smb2.in.create_flags = 0;
3247 io.smb2.in.desired_access = 0x0017019f;
3248 io.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
3249 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3250 io.smb2.in.share_access = 0;
3251 io.smb2.in.alloc_size = 0;
3252 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
3253 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3254 io.smb2.in.security_flags = 0;
3255 io.smb2.in.fname = BASEDIR "\\file.txt";
3256
3257 status = smb2_create(tree, torture, &(io.smb2));
3258 torture_assert_ntstatus_ok(torture, status, "smb2_create file");
3259 h1 = io.smb2.out.file.handle;
3260
3261 if (!server_is_osx) {
3262 torture_comment(torture, "Renaming directory without AAPL, must fail\n");
3263
3264 ZERO_STRUCT(sinfo);
3265 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
3266 sinfo.rename_information.in.file.handle = d1;
3267 sinfo.rename_information.in.overwrite = 0;
3268 sinfo.rename_information.in.root_fid = 0;
3269 sinfo.rename_information.in.new_name = renamedir;
3270 status = smb2_setinfo_file(tree, &sinfo);
3271
3272 torture_assert_ntstatus_equal(torture, status,
3273 NT_STATUS_ACCESS_DENIED,
3274 "smb2_setinfo_file");
3275 }
3276
3277 status = smb2_util_close(tree, d1);
3278 torture_assert_ntstatus_ok(torture, status, "smb2_util_close\n");
3279 ZERO_STRUCT(d1);
3280
3281 torture_comment(torture, "Enabling AAPL\n");
3282
3283 ret = enable_aapl(torture, tree);
3284 torture_assert(torture, ret == true, "enable_aapl failed");
3285
3286 torture_comment(torture, "Renaming directory with AAPL\n");
3287
3288 ZERO_STRUCT(io.smb2);
3289 io.generic.level = RAW_OPEN_SMB2;
3290 io.smb2.in.desired_access = 0x0017019f;
3291 io.smb2.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
3292 io.smb2.in.share_access = 0;
3293 io.smb2.in.alloc_size = 0;
3294 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
3295 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3296 io.smb2.in.security_flags = 0;
3297 io.smb2.in.fname = BASEDIR;
3298
3299 status = smb2_create(tree, torture, &(io.smb2));
3300 torture_assert_ntstatus_ok(torture, status, "smb2_create dir");
3301 d1 = io.smb2.out.file.handle;
3302
3303 ZERO_STRUCT(sinfo);
3304 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
3305 sinfo.rename_information.in.file.handle = d1;
3306 sinfo.rename_information.in.overwrite = 0;
3307 sinfo.rename_information.in.root_fid = 0;
3308 sinfo.rename_information.in.new_name = renamedir;
3309
3310 status = smb2_setinfo_file(tree, &sinfo);
3311 torture_assert_ntstatus_ok(torture, status, "smb2_setinfo_file");
3312
3313 ZERO_STRUCT(cl.smb2);
3314 cl.smb2.level = RAW_CLOSE_SMB2;
3315 cl.smb2.in.file.handle = d1;
3316 status = smb2_close(tree, &(cl.smb2));
3317 torture_assert_ntstatus_ok(torture, status, "smb2_close");
3318 ZERO_STRUCT(d1);
3319
3320 cl.smb2.in.file.handle = h1;
3321 status = smb2_close(tree, &(cl.smb2));
3322 torture_assert_ntstatus_ok(torture, status, "smb2_close");
3323 ZERO_STRUCT(h1);
3324
3325 torture_comment(torture, "Cleaning up\n");
3326
3327 if (h1.data[0] || h1.data[1]) {
3328 ZERO_STRUCT(cl.smb2);
3329 cl.smb2.level = RAW_CLOSE_SMB2;
3330 cl.smb2.in.file.handle = h1;
3331 status = smb2_close(tree, &(cl.smb2));
3332 }
3333
3334 smb2_util_unlink(tree, BASEDIR "\\file.txt");
3335 smb2_util_unlink(tree, BASEDIR "-new\\file.txt");
3336 smb2_deltree(tree, renamedir);
3337 smb2_deltree(tree, BASEDIR);
3338 return ret;
3339 }
3340
3341 static bool test_afpinfo_enoent(struct torture_context *tctx,
3342 struct smb2_tree *tree)
3343 {
3344 bool ret = true;
3345 NTSTATUS status;
3346 struct smb2_create create;
3347 struct smb2_handle h1;
3348 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3349 const char *fname = BASEDIR "\\file";
3350 const char *sname = BASEDIR "\\file" AFPINFO_STREAM_NAME;
3351
3352 torture_comment(tctx, "Opening file without AFP_AfpInfo\n");
3353
3354 smb2_deltree(tree, BASEDIR);
3355 status = torture_smb2_testdir(tree, BASEDIR, &h1);
3356 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
3357 smb2_util_close(tree, h1);
3358 ret = torture_setup_file(mem_ctx, tree, fname, false);
3359 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
3360
3361 torture_comment(tctx, "Opening not existing AFP_AfpInfo\n");
3362
3363 ZERO_STRUCT(create);
3364 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3365 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE; /* stat open */
3366 create.in.fname = sname;
3367
3368 status = smb2_create(tree, mem_ctx, &create);
3369 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
3370 ret, done, "Got unexpected AFP_AfpInfo stream");
3371
3372 done:
3373 smb2_util_unlink(tree, fname);
3374 smb2_util_rmdir(tree, BASEDIR);
3375 return ret;
3376 }
3377
3378 static bool test_create_delete_on_close(struct torture_context *tctx,
3379 struct smb2_tree *tree)
3380 {
3381 bool ret = true;
3382 NTSTATUS status;
3383 struct smb2_create create;
3384 struct smb2_handle h1;
3385 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3386 const char *fname = BASEDIR "\\file";
3387 const char *sname = BASEDIR "\\file" AFPINFO_STREAM_NAME;
3388 const char *type_creator = "SMB,OLE!";
3389 AfpInfo *info = NULL;
3390 const char *streams_basic[] = {
3391 "::$DATA"
3392 };
3393 const char *streams_afpinfo[] = {
3394 "::$DATA",
3395 AFPINFO_STREAM
3396 };
3397
3398 torture_assert_goto(tctx, mem_ctx != NULL, ret, done, "talloc_new");
3399
3400 torture_comment(tctx, "Checking whether create with delete-on-close work with AFP_AfpInfo\n");
3401
3402 smb2_deltree(tree, BASEDIR);
3403 status = torture_smb2_testdir(tree, BASEDIR, &h1);
3404 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
3405 smb2_util_close(tree, h1);
3406 ret = torture_setup_file(mem_ctx, tree, fname, false);
3407 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
3408
3409 torture_comment(tctx, "Opening not existing AFP_AfpInfo\n");
3410
3411 ZERO_STRUCT(create);
3412 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3413 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE; /* stat open */
3414 create.in.fname = sname;
3415
3416 status = smb2_create(tree, mem_ctx, &create);
3417 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
3418 ret, done, "Got unexpected AFP_AfpInfo stream");
3419
3420 ZERO_STRUCT(create);
3421 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3422 create.in.desired_access = SEC_FILE_ALL;
3423 create.in.fname = sname;
3424
3425 status = smb2_create(tree, mem_ctx, &create);
3426 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
3427 ret, done, "Got unexpected AFP_AfpInfo stream");
3428
3429 ret = check_stream_list(tree, tctx, fname, 1, streams_basic, false);
3430 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3431
3432 torture_comment(tctx, "Deleting AFP_AfpInfo via create with delete-on-close\n");
3433
3434 info = torture_afpinfo_new(mem_ctx);
3435 torture_assert_goto(tctx, info != NULL, ret, done, "torture_afpinfo_new failed");
3436
3437 memcpy(info->afpi_FinderInfo, type_creator, 8);
3438 ret = torture_write_afpinfo(tree, tctx, mem_ctx, fname, info);
3439 torture_assert_goto(tctx, ret == true, ret, done, "torture_write_afpinfo failed");
3440
3441 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
3442 0, 60, 16, 8, type_creator);
3443 torture_assert_goto(tctx, ret == true, ret, done, "Bad type/creator in AFP_AfpInfo");
3444
3445 ret = check_stream_list(tree, tctx, fname, 2, streams_afpinfo, false);
3446 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3447
3448 ZERO_STRUCT(create);
3449 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3450 create.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
3451 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE | SEC_STD_SYNCHRONIZE | SEC_STD_DELETE;
3452 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3453 create.in.fname = sname;
3454 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3455
3456 status = smb2_create(tree, mem_ctx, &create);
3457 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
3458
3459 h1 = create.out.file.handle;
3460 smb2_util_close(tree, h1);
3461
3462 ZERO_STRUCT(create);
3463 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3464 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE;
3465 create.in.fname = sname;
3466 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3467 status = smb2_create(tree, mem_ctx, &create);
3468 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
3469 ret, done, "Got unexpected AFP_AfpInfo stream");
3470
3471 ret = check_stream_list(tree, tctx, fname, 1, streams_basic, false);
3472 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3473
3474 done:
3475 smb2_util_unlink(tree, fname);
3476 smb2_util_rmdir(tree, BASEDIR);
3477 return ret;
3478 }
3479
3480 static bool test_setinfo_delete_on_close(struct torture_context *tctx,
3481 struct smb2_tree *tree)
3482 {
3483 bool ret = true;
3484 NTSTATUS status;
3485 struct smb2_create create;
3486 union smb_setfileinfo sfinfo;
3487 struct smb2_handle h1;
3488 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3489 const char *fname = BASEDIR "\\file";
3490 const char *sname = BASEDIR "\\file" AFPINFO_STREAM_NAME;
3491 const char *type_creator = "SMB,OLE!";
3492 AfpInfo *info = NULL;
3493 const char *streams[] = {
3494 AFPINFO_STREAM,
3495 "::$DATA"
3496 };
3497 const char *streams_basic[] = {
3498 "::$DATA"
3499 };
3500
3501 torture_assert_goto(tctx, mem_ctx != NULL, ret, done, "talloc_new");
3502
3503 torture_comment(tctx, "Deleting AFP_AfpInfo via setinfo with delete-on-close\n");
3504
3505 smb2_deltree(tree, BASEDIR);
3506 status = torture_smb2_testdir(tree, BASEDIR, &h1);
3507 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
3508 smb2_util_close(tree, h1);
3509 ret = torture_setup_file(mem_ctx, tree, fname, false);
3510 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
3511
3512 info = torture_afpinfo_new(mem_ctx);
3513 torture_assert_goto(tctx, info != NULL, ret, done, "torture_afpinfo_new failed");
3514 memcpy(info->afpi_FinderInfo, type_creator, 8);
3515 ret = torture_write_afpinfo(tree, tctx, mem_ctx, fname, info);
3516 torture_assert_goto(tctx, ret == true, ret, done, "torture_write_afpinfo failed");
3517
3518 ZERO_STRUCT(create);
3519 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3520 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE | SEC_STD_SYNCHRONIZE | SEC_STD_DELETE;
3521 create.in.fname = sname;
3522 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3523 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3524
3525 status = smb2_create(tree, mem_ctx, &create);
3526 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
3527
3528 h1 = create.out.file.handle;
3529
3530 /* Delete stream via setinfo delete-on-close */
3531 ZERO_STRUCT(sfinfo);
3532 sfinfo.disposition_info.in.delete_on_close = 1;
3533 sfinfo.generic.level = RAW_SFILEINFO_DISPOSITION_INFORMATION;
3534 sfinfo.generic.in.file.handle = h1;
3535 status = smb2_setinfo_file(tree, &sfinfo);
3536 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "set delete-on-close failed");
3537
3538 ret = check_stream_list(tree, tctx, fname, 2, streams, false);
3539 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3540
3541 ZERO_STRUCT(create);
3542 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3543 create.in.desired_access = SEC_FILE_ALL;
3544 create.in.fname = sname;
3545 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3546 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3547 status = smb2_create(tree, mem_ctx, &create);
3548 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_DELETE_PENDING,
3549 ret, done, "Got unexpected AFP_AfpInfo stream");
3550
3551 smb2_util_close(tree, h1);
3552
3553 ret = check_stream_list(tree, tctx, fname, 1, streams_basic, false);
3554 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3555
3556 ZERO_STRUCT(create);
3557 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3558 create.in.desired_access = SEC_FILE_ALL;
3559 create.in.fname = sname;
3560 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3561 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3562 status = smb2_create(tree, mem_ctx, &create);
3563 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
3564 ret, done, "Got unexpected AFP_AfpInfo stream");
3565
3566 done:
3567 smb2_util_unlink(tree, fname);
3568 smb2_util_rmdir(tree, BASEDIR);
3569 return ret;
3570 }
3571
3572 static bool test_setinfo_eof(struct torture_context *tctx,
3573 struct smb2_tree *tree)
3574 {
3575 bool ret = true;
3576 NTSTATUS status;
3577 struct smb2_create create;
3578 union smb_setfileinfo sfinfo;
3579 struct smb2_handle h1;
3580 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3581 const char *fname = BASEDIR "\\file";
3582 const char *sname = BASEDIR "\\file" AFPINFO_STREAM_NAME;
3583 const char *type_creator = "SMB,OLE!";
3584 AfpInfo *info = NULL;
3585 const char *streams_afpinfo[] = {
3586 "::$DATA",
3587 AFPINFO_STREAM
3588 };
3589
3590 torture_assert_goto(tctx, mem_ctx != NULL, ret, done, "talloc_new");
3591
3592 torture_comment(tctx, "Set AFP_AfpInfo EOF to 61, 1 and 0\n");
3593
3594 smb2_deltree(tree, BASEDIR);
3595 status = torture_smb2_testdir(tree, BASEDIR, &h1);
3596 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
3597 smb2_util_close(tree, h1);
3598 ret = torture_setup_file(mem_ctx, tree, fname, false);
3599 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
3600
3601 info = torture_afpinfo_new(mem_ctx);
3602 torture_assert_goto(tctx, info != NULL, ret, done, "torture_afpinfo_new failed");
3603 memcpy(info->afpi_FinderInfo, type_creator, 8);
3604 ret = torture_write_afpinfo(tree, tctx, mem_ctx, fname, info);
3605 torture_assert_goto(tctx, ret == true, ret, done, "torture_write_afpinfo failed");
3606
3607 ZERO_STRUCT(create);
3608 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3609 create.in.desired_access = SEC_FILE_ALL;
3610 create.in.fname = sname;
3611 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3612 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3613
3614 status = smb2_create(tree, mem_ctx, &create);
3615 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
3616
3617 h1 = create.out.file.handle;
3618
3619 torture_comment(tctx, "Set AFP_AfpInfo EOF to 61\n");
3620
3621 /* Test setinfo end-of-file info */
3622 ZERO_STRUCT(sfinfo);
3623 sfinfo.generic.in.file.handle = h1;
3624 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
3625 sfinfo.position_information.in.position = 61;
3626 status = smb2_setinfo_file(tree, &sfinfo);
3627 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_ALLOTTED_SPACE_EXCEEDED,
3628 ret, done, "set eof 61 failed");
3629
3630 torture_comment(tctx, "Set AFP_AfpInfo EOF to 1\n");
3631
3632 /* Truncation returns success, but has no effect */
3633 ZERO_STRUCT(sfinfo);
3634 sfinfo.generic.in.file.handle = h1;
3635 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
3636 sfinfo.position_information.in.position = 1;
3637 status = smb2_setinfo_file(tree, &sfinfo);
3638 torture_assert_ntstatus_ok_goto(tctx, status,
3639 ret, done, "set eof 1 failed");
3640 smb2_util_close(tree, h1);
3641
3642 ret = check_stream_list(tree, tctx, fname, 2, streams_afpinfo, false);
3643 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3644
3645 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
3646 0, 60, 16, 8, type_creator);
3647 torture_assert_goto(tctx, ret == true, ret, done, "FinderInfo changed");
3648
3649 ZERO_STRUCT(create);
3650 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3651 create.in.desired_access = SEC_FILE_ALL;
3652 create.in.fname = sname;
3653 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3654 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3655
3656 status = smb2_create(tree, mem_ctx, &create);
3657 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
3658
3659 h1 = create.out.file.handle;
3660
3661 /*
3662 * Delete stream via setinfo end-of-file info to 0, should
3663 * return success but stream MUST NOT deleted
3664 */
3665 ZERO_STRUCT(sfinfo);
3666 sfinfo.generic.in.file.handle = h1;
3667 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
3668 sfinfo.position_information.in.position = 0;
3669 status = smb2_setinfo_file(tree, &sfinfo);
3670 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "set eof 0 failed");
3671
3672 smb2_util_close(tree, h1);
3673
3674 ret = check_stream_list(tree, tctx, fname, 2, streams_afpinfo, false);
3675 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3676
3677 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
3678 0, 60, 16, 8, type_creator);
3679 torture_assert_goto(tctx, ret == true, ret, done, "FinderInfo changed");
3680
3681 done:
3682 smb2_util_unlink(tree, fname);
3683 smb2_util_rmdir(tree, BASEDIR);
3684 return ret;
3685 }
3686
3687 static bool test_afpinfo_all0(struct torture_context *tctx,
3688 struct smb2_tree *tree)
3689 {
3690 bool ret = true;
3691 NTSTATUS status;
3692 struct smb2_create create;
3693 struct smb2_handle h1 = {{0}};
3694 struct smb2_handle baseh = {{0}};
3695 union smb_setfileinfo setfinfo;
3696 union smb_fileinfo getfinfo;
3697 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3698 const char *fname = BASEDIR "\\file";
3699 const char *sname = BASEDIR "\\file" AFPINFO_STREAM;
3700 const char *type_creator = "SMB,OLE!";
3701 AfpInfo *info = NULL;
3702 char *infobuf = NULL;
3703 const char *streams_basic[] = {
3704 "::$DATA"
3705 };
3706 const char *streams_afpinfo[] = {
3707 "::$DATA",
3708 AFPINFO_STREAM
3709 };
3710
3711 torture_assert_goto(tctx, mem_ctx != NULL, ret, done, "talloc_new");
3712
3713 torture_comment(tctx, "Write all 0 to AFP_AfpInfo and see what happens\n");
3714
3715 smb2_deltree(tree, BASEDIR);
3716 status = torture_smb2_testdir(tree, BASEDIR, &h1);
3717 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
3718 smb2_util_close(tree, h1);
3719 ret = torture_setup_file(mem_ctx, tree, fname, false);
3720 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
3721
3722 info = torture_afpinfo_new(mem_ctx);
3723 torture_assert_goto(tctx, info != NULL, ret, done, "torture_afpinfo_new failed");
3724 memcpy(info->afpi_FinderInfo, type_creator, 8);
3725 ret = torture_write_afpinfo(tree, tctx, mem_ctx, fname, info);
3726 torture_assert_goto(tctx, ret == true, ret, done, "torture_write_afpinfo failed");
3727
3728 ret = check_stream_list(tree, tctx, fname, 2, streams_afpinfo, false);
3729 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3730
3731 /* Write all 0 to AFP_AfpInfo */
3732 memset(info->afpi_FinderInfo, 0, AFP_FinderSize);
3733 infobuf = torture_afpinfo_pack(mem_ctx, info);
3734 torture_assert_not_null_goto(tctx, infobuf, ret, done,
3735 "torture_afpinfo_pack failed\n");
3736
3737 ZERO_STRUCT(create);
3738 create.in.desired_access = SEC_FILE_ALL;
3739 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3740 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3741 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
3742 create.in.fname = fname;
3743
3744 status = smb2_create(tree, mem_ctx, &create);
3745 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
3746 "smb2_create failed\n");
3747 baseh = create.out.file.handle;
3748
3749 ZERO_STRUCT(create);
3750 create.in.desired_access = SEC_FILE_ALL;
3751 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3752 create.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
3753 create.in.fname = sname;
3754
3755 status = smb2_create(tree, mem_ctx, &create);
3756 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
3757 "smb2_create failed\n");
3758 h1 = create.out.file.handle;
3759
3760 status = smb2_util_write(tree, h1, infobuf, 0, AFP_INFO_SIZE);
3761 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
3762 "smb2_util_write failed\n");
3763
3764 /*
3765 * Get stream information on open handle, must return only default
3766 * stream, the AFP_AfpInfo stream must not be returned.
3767 */
3768
3769 ZERO_STRUCT(getfinfo);
3770 getfinfo.generic.level = RAW_FILEINFO_STREAM_INFORMATION;
3771 getfinfo.generic.in.file.handle = baseh;
3772
3773 status = smb2_getinfo_file(tree, tctx, &getfinfo);
3774 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
3775 "get stream info\n");
3776
3777 torture_assert_int_equal_goto(tctx, getfinfo.stream_info.out.num_streams,
3778 1, ret, done, "stream count");
3779
3780 smb2_util_close(tree, baseh);
3781 ZERO_STRUCT(baseh);
3782
3783 /*
3784 * Try to set some file-basic-info (time) on the stream. This catches
3785 * naive implementation mistakes that simply deleted the backing store
3786 * from the filesystem in the zero-out step.
3787 */
3788
3789 ZERO_STRUCT(setfinfo);
3790 unix_to_nt_time(&setfinfo.basic_info.in.write_time, time(NULL));
3791 setfinfo.basic_info.in.attrib = 0x20;
3792 setfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
3793 setfinfo.generic.in.file.handle = h1;
3794
3795 status = smb2_setinfo_file(tree, &setfinfo);
3796 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
3797 "smb2_getinfo_file failed\n");
3798
3799 ret = check_stream_list(tree, tctx, fname, 1, streams_basic, false);
3800 torture_assert_goto(tctx, ret == true, ret, done, "check_stream_list");
3801
3802 smb2_util_close(tree, h1);
3803 ZERO_STRUCT(h1);
3804
3805 ret = check_stream_list(tree, tctx, fname, 1, streams_basic, false);
3806 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3807
3808 done:
3809 if (!smb2_util_handle_empty(h1)) {
3810 smb2_util_close(tree, h1);
3811 }
3812 if (!smb2_util_handle_empty(baseh)) {
3813 smb2_util_close(tree, baseh);
3814 }
3815 smb2_util_unlink(tree, fname);
3816 smb2_util_rmdir(tree, BASEDIR);
3817 return ret;
3818 }
3819
3820 static bool test_create_delete_on_close_resource(struct torture_context *tctx,
3821 struct smb2_tree *tree)
3822 {
3823 bool ret = true;
3824 NTSTATUS status;
3825 struct smb2_create create;
3826 struct smb2_handle h1;
3827 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3828 const char *fname = BASEDIR "\\file";
3829 const char *sname = BASEDIR "\\file" AFPRESOURCE_STREAM_NAME;
3830 const char *streams_basic[] = {
3831 "::$DATA"
3832 };
3833 const char *streams_afpresource[] = {
3834 "::$DATA",
3835 AFPRESOURCE_STREAM
3836 };
3837
3838 torture_assert_goto(tctx, mem_ctx != NULL, ret, done, "talloc_new");
3839
3840 torture_comment(tctx, "Checking whether create with delete-on-close is ignored for AFP_AfpResource\n");
3841
3842 smb2_deltree(tree, BASEDIR);
3843 status = torture_smb2_testdir(tree, BASEDIR, &h1);
3844 torture_assert_ntstatus_ok(tctx, status, "torture_smb2_testdir");
3845 smb2_util_close(tree, h1);
3846 ret = torture_setup_file(mem_ctx, tree, fname, false);
3847 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
3848
3849 torture_comment(tctx, "Opening not existing AFP_AfpResource\n");
3850
3851 ZERO_STRUCT(create);
3852 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3853 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE; /* stat open */
3854 create.in.fname = sname;
3855
3856 status = smb2_create(tree, mem_ctx, &create);
3857 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
3858 ret, done, "Got unexpected AFP_AfpResource stream");
3859
3860 ZERO_STRUCT(create);
3861 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3862 create.in.desired_access = SEC_FILE_ALL;
3863 create.in.fname = sname;
3864
3865 status = smb2_create(tree, mem_ctx, &create);
3866 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
3867 ret, done, "Got unexpected AFP_AfpResource stream");
3868
3869 ret = check_stream_list(tree, tctx, fname, 1, streams_basic, false);
3870 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3871
3872 torture_comment(tctx, "Trying to delete AFP_AfpResource via create with delete-on-close\n");
3873
3874 ret = write_stream(tree, __location__, tctx, mem_ctx,
3875 fname, AFPRESOURCE_STREAM_NAME,
3876 0, 10, "1234567890");
3877 torture_assert_goto(tctx, ret == true, ret, done, "Writing to AFP_AfpResource failed");
3878
3879 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPRESOURCE_STREAM_NAME,
3880 0, 10, 0, 10, "1234567890");
3881 torture_assert_goto(tctx, ret == true, ret, done, "Bad content from AFP_AfpResource");
3882
3883 ret = check_stream_list(tree, tctx, fname, 2, streams_afpresource, false);
3884 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3885
3886 ZERO_STRUCT(create);
3887 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3888 create.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
3889 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE | SEC_STD_SYNCHRONIZE | SEC_STD_DELETE;
3890 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3891 create.in.fname = sname;
3892 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3893
3894 status = smb2_create(tree, mem_ctx, &create);
3895 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
3896
3897 h1 = create.out.file.handle;
3898 smb2_util_close(tree, h1);
3899
3900 ret = check_stream_list(tree, tctx, fname, 2, streams_afpresource, false);
3901 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3902
3903 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPRESOURCE_STREAM_NAME,
3904 0, 10, 0, 10, "1234567890");
3905 torture_assert_goto(tctx, ret == true, ret, done, "Bad content from AFP_AfpResource");
3906
3907 done:
3908 smb2_util_unlink(tree, fname);
3909 smb2_util_rmdir(tree, BASEDIR);
3910 return ret;
3911 }
3912
3913 static bool test_setinfo_delete_on_close_resource(struct torture_context *tctx,
3914 struct smb2_tree *tree)
3915 {
3916 bool ret = true;
3917 NTSTATUS status;
3918 struct smb2_create create;
3919 union smb_setfileinfo sfinfo;
3920 struct smb2_handle h1;
3921 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3922 const char *fname = BASEDIR "\\file";
3923 const char *sname = BASEDIR "\\file" AFPRESOURCE_STREAM_NAME;
3924 const char *streams_afpresource[] = {
3925 "::$DATA",
3926 AFPRESOURCE_STREAM
3927 };
3928
3929 torture_assert_goto(tctx, mem_ctx != NULL, ret, done, "talloc_new");
3930
3931 torture_comment(tctx, "Trying to delete AFP_AfpResource via setinfo with delete-on-close\n");
3932
3933 smb2_deltree(tree, BASEDIR);
3934 status = torture_smb2_testdir(tree, BASEDIR, &h1);
3935 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
3936 smb2_util_close(tree, h1);
3937 ret = torture_setup_file(mem_ctx, tree, fname, false);
3938 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
3939
3940 ret = write_stream(tree, __location__, tctx, mem_ctx,
3941 fname, AFPRESOURCE_STREAM_NAME,
3942 10, 10, "1234567890");
3943 torture_assert_goto(tctx, ret == true, ret, done, "Writing to AFP_AfpResource failed");
3944
3945 ZERO_STRUCT(create);
3946 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3947 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE | SEC_STD_SYNCHRONIZE | SEC_STD_DELETE;
3948 create.in.fname = sname;
3949 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3950 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3951
3952 status = smb2_create(tree, mem_ctx, &create);
3953 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
3954
3955 h1 = create.out.file.handle;
3956
3957 /* Try to delete stream via setinfo delete-on-close */
3958 ZERO_STRUCT(sfinfo);
3959 sfinfo.disposition_info.in.delete_on_close = 1;
3960 sfinfo.generic.level = RAW_SFILEINFO_DISPOSITION_INFORMATION;
3961 sfinfo.generic.in.file.handle = h1;
3962 status = smb2_setinfo_file(tree, &sfinfo);
3963 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "set delete-on-close failed");
3964
3965 smb2_util_close(tree, h1);
3966
3967 ret = check_stream_list(tree, tctx, fname, 2, streams_afpresource, false);
3968 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
3969
3970 ZERO_STRUCT(create);
3971 create.in.create_disposition = NTCREATEX_DISP_OPEN;
3972 create.in.desired_access = SEC_FILE_ALL;
3973 create.in.fname = sname;
3974 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3975 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
3976 status = smb2_create(tree, mem_ctx, &create);
3977 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
3978 "Got unexpected AFP_AfpResource stream");
3979
3980 done:
3981 smb2_util_unlink(tree, fname);
3982 smb2_util_rmdir(tree, BASEDIR);
3983 return ret;
3984 }
3985
3986 static bool test_setinfo_eof_resource(struct torture_context *tctx,
3987 struct smb2_tree *tree)
3988 {
3989 bool ret = true;
3990 NTSTATUS status;
3991 struct smb2_create create;
3992 union smb_setfileinfo sfinfo;
3993 union smb_fileinfo finfo;
3994 struct smb2_handle h1;
3995 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3996 const char *fname = BASEDIR "\\file";
3997 const char *sname = BASEDIR "\\file" AFPRESOURCE_STREAM_NAME;
3998 const char *streams_basic[] = {
3999 "::$DATA"
4000 };
4001
4002 torture_assert_goto(tctx, mem_ctx != NULL, ret, done, "talloc_new");
4003
4004 ret = enable_aapl(tctx, tree);
4005 torture_assert_goto(tctx, ret == true, ret, done, "enable_aapl failed");
4006
4007 torture_comment(tctx, "Set AFP_AfpResource EOF to 1 and 0\n");
4008
4009 smb2_deltree(tree, BASEDIR);
4010 status = torture_smb2_testdir(tree, BASEDIR, &h1);
4011 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir");
4012 smb2_util_close(tree, h1);
4013 ret = torture_setup_file(mem_ctx, tree, fname, false);
4014 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
4015
4016 ret = write_stream(tree, __location__, tctx, mem_ctx,
4017 fname, AFPRESOURCE_STREAM_NAME,
4018 10, 10, "1234567890");
4019 torture_assert_goto(tctx, ret == true, ret, done, "Writing to AFP_AfpResource failed");
4020
4021 ZERO_STRUCT(create);
4022 create.in.create_disposition = NTCREATEX_DISP_OPEN;
4023 create.in.desired_access = SEC_FILE_ALL;
4024 create.in.fname = sname;
4025 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4026 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
4027
4028 status = smb2_create(tree, mem_ctx, &create);
4029 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
4030
4031 h1 = create.out.file.handle;
4032
4033 torture_comment(tctx, "Set AFP_AfpResource EOF to 1\n");
4034
4035 /* Test setinfo end-of-file info */
4036 ZERO_STRUCT(sfinfo);
4037 sfinfo.generic.in.file.handle = h1;
4038 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
4039 sfinfo.position_information.in.position = 1;
4040 status = smb2_setinfo_file(tree, &sfinfo);
4041 torture_assert_ntstatus_ok_goto(tctx, status,
4042 ret, done, "set eof 1 failed");
4043
4044 smb2_util_close(tree, h1);
4045
4046 /* Check size == 1 */
4047 ZERO_STRUCT(create);
4048 create.in.fname = sname;
4049 create.in.create_disposition = NTCREATEX_DISP_OPEN;
4050 create.in.desired_access = SEC_FILE_ALL;
4051 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4052 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
4053 status = smb2_create(tree, mem_ctx, &create);
4054 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
4055
4056 h1 = create.out.file.handle;
4057
4058 ZERO_STRUCT(finfo);
4059 finfo.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
4060 finfo.generic.in.file.handle = h1;
4061 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
4062 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_getinfo_file failed");
4063
4064 smb2_util_close(tree, h1);
4065
4066 torture_assert_goto(tctx, finfo.all_info.out.size == 1, ret, done, "size != 1");
4067
4068 ZERO_STRUCT(create);
4069 create.in.create_disposition = NTCREATEX_DISP_OPEN;
4070 create.in.desired_access = SEC_FILE_ALL;
4071 create.in.fname = sname;
4072 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4073 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
4074
4075 status = smb2_create(tree, mem_ctx, &create);
4076 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
4077
4078 h1 = create.out.file.handle;
4079
4080 /*
4081 * Delete stream via setinfo end-of-file info to 0, this
4082 * should delete the stream.
4083 */
4084 ZERO_STRUCT(sfinfo);
4085 sfinfo.generic.in.file.handle = h1;
4086 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
4087 sfinfo.position_information.in.position = 0;
4088 status = smb2_setinfo_file(tree, &sfinfo);
4089 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "set eof 0 failed");
4090
4091 smb2_util_close(tree, h1);
4092
4093 ret = check_stream_list(tree, tctx, fname, 1, streams_basic, false);
4094 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
4095
4096 ZERO_STRUCT(create);
4097 create.in.create_disposition = NTCREATEX_DISP_OPEN;
4098 create.in.desired_access = SEC_FILE_ALL;
4099 create.in.fname = sname;
4100 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4101 create.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
4102
4103 status = smb2_create(tree, mem_ctx, &create);
4104 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
4105 ret, done, "smb2_create failed");
4106
4107 done:
4108 smb2_util_unlink(tree, fname);
4109 smb2_util_rmdir(tree, BASEDIR);
4110 return ret;
4111 }
4112
4113 /*
4114 * This tests that right after creating the AFP_AfpInfo stream,
4115 * reading from the stream returns an empty, default metadata blob of
4116 * 60 bytes.
4117 *
4118 * NOTE: against OS X SMB server this only works if the read request
4119 * is compounded with the create that created the stream, is fails
4120 * otherwise. We don't care...
4121 */
4122 static bool test_null_afpinfo(struct torture_context *tctx,
4123 struct smb2_tree *tree)
4124 {
4125 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4126 const char *fname = "test_null_afpinfo";
4127 const char *sname = "test_null_afpinfo" AFPINFO_STREAM_NAME;
4128 NTSTATUS status;
4129 bool ret = true;
4130 struct smb2_request *req[3];
4131 struct smb2_handle handle;
4132 struct smb2_create create;
4133 struct smb2_read read;
4134 AfpInfo *afpinfo = NULL;
4135 char *afpinfo_buf = NULL;
4136 const char *type_creator = "SMB,OLE!";
4137 struct smb2_handle handle2;
4138 struct smb2_read r;
4139
4140 torture_comment(tctx, "Checking create of AfpInfo stream\n");
4141
4142 smb2_util_unlink(tree, fname);
4143
4144 ret = torture_setup_file(mem_ctx, tree, fname, false);
4145 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file failed");
4146
4147 ZERO_STRUCT(create);
4148 create.in.desired_access = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA;
4149 create.in.share_access = FILE_SHARE_READ | FILE_SHARE_DELETE;
4150 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4151 create.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
4152 create.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
4153 create.in.fname = sname;
4154
4155 smb2_transport_compound_start(tree->session->transport, 2);
4156
4157 req[0] = smb2_create_send(tree, &create);
4158
4159 handle.data[0] = UINT64_MAX;
4160 handle.data[1] = UINT64_MAX;
4161
4162 smb2_transport_compound_set_related(tree->session->transport, true);
4163
4164 ZERO_STRUCT(read);
4165 read.in.file.handle = handle;
4166 read.in.length = AFP_INFO_SIZE;
4167 req[1] = smb2_read_send(tree, &read);
4168
4169 status = smb2_create_recv(req[0], tree, &create);
4170 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create_recv failed");
4171
4172 handle = create.out.file.handle;
4173
4174 status = smb2_read_recv(req[1], tree, &read);
4175 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_read_recv failed");
4176
4177 status = torture_smb2_testfile_access(tree, sname, &handle2,
4178 SEC_FILE_READ_DATA);
4179 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
4180 "torture_smb2_testfile failed\n");
4181 r = (struct smb2_read) {
4182 .in.file.handle = handle2,
4183 .in.length = AFP_INFO_SIZE,
4184 };
4185
4186 status = smb2_read(tree, tree, &r);
4187 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
4188 "torture_smb2_testfile failed\n");
4189 smb2_util_close(tree, handle2);
4190
4191 afpinfo = torture_afpinfo_new(mem_ctx);
4192 torture_assert_goto(tctx, afpinfo != NULL, ret, done, "torture_afpinfo_new failed");
4193
4194 memcpy(afpinfo->afpi_FinderInfo, type_creator, 8);
4195
4196 afpinfo_buf = torture_afpinfo_pack(tctx, afpinfo);
4197 torture_assert_goto(tctx, afpinfo_buf != NULL, ret, done, "torture_afpinfo_new failed");
4198
4199 status = smb2_util_write(tree, handle, afpinfo_buf, 0, AFP_INFO_SIZE);
4200 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_util_write failed");
4201
4202 smb2_util_close(tree, handle);
4203
4204 ret = check_stream(tree, __location__, tctx, mem_ctx, fname, AFPINFO_STREAM,
4205 0, 60, 16, 8, type_creator);
4206 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed");
4207
4208 done:
4209 smb2_util_unlink(tree, fname);
4210 talloc_free(mem_ctx);
4211 return ret;
4212 }
4213
4214 static bool test_delete_file_with_rfork(struct torture_context *tctx,
4215 struct smb2_tree *tree)
4216 {
4217 const char *fname = "torture_write_rfork_io";
4218 const char *rfork_content = "1234567890";
4219 NTSTATUS status;
4220 bool ret = true;
4221
4222 smb2_util_unlink(tree, fname);
4223
4224 torture_comment(tctx, "Test deleting file with resource fork\n");
4225
4226 ret = torture_setup_file(tctx, tree, fname, false);
4227 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file failed\n");
4228
4229 ret = write_stream(tree, __location__, tctx, tctx,
4230 fname, AFPRESOURCE_STREAM_NAME,
4231 10, 10, rfork_content);
4232 torture_assert_goto(tctx, ret == true, ret, done, "write_stream failed\n");
4233
4234 ret = check_stream(tree, __location__, tctx, tctx,
4235 fname, AFPRESOURCE_STREAM_NAME,
4236 0, 20, 10, 10, rfork_content);
4237 torture_assert_goto(tctx, ret == true, ret, done, "check_stream failed\n");
4238
4239 status = smb2_util_unlink(tree, fname);
4240 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "check_stream failed\n");
4241
4242 done:
4243 return ret;
4244 }
4245
4246 static bool test_rename_and_read_rsrc(struct torture_context *tctx,
4247 struct smb2_tree *tree)
4248 {
4249 bool ret = true;
4250 NTSTATUS status;
4251 struct smb2_create create, create2;
4252 struct smb2_handle h1, h2;
4253 const char *fname = "test_rename_openfile";
4254 const char *sname = "test_rename_openfile" AFPRESOURCE_STREAM_NAME;
4255 const char *fname_renamed = "test_rename_openfile_renamed";
4256 const char *data = "1234567890";
4257 union smb_setfileinfo sinfo;
4258 bool server_is_macos = torture_setting_bool(tctx, "osx", false);
4259 NTSTATUS expected_status;
4260
4261 ret = enable_aapl(tctx, tree);
4262 torture_assert_goto(tctx, ret == true, ret, done, "enable_aapl failed");
4263
4264 torture_comment(tctx, "Create file with resource fork\n");
4265
4266 ret = torture_setup_file(tctx, tree, fname, false);
4267 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
4268
4269 ret = write_stream(tree, __location__, tctx, tctx,
4270 fname, AFPRESOURCE_STREAM_NAME, 0, 10, data);
4271 torture_assert_goto(tctx, ret == true, ret, done, "write_stream failed");
4272
4273 torture_comment(tctx, "Open resource fork\n");
4274
4275 ZERO_STRUCT(create);
4276 create.in.desired_access = SEC_FILE_ALL;
4277 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
4278 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4279 create.in.create_disposition = NTCREATEX_DISP_OPEN;
4280 create.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
4281 create.in.fname = sname;
4282
4283 status = smb2_create(tree, tctx, &create);
4284 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
4285
4286 h1 = create.out.file.handle;
4287
4288 torture_comment(tctx, "Rename base file\n");
4289
4290 ZERO_STRUCT(create2);
4291 create2.in.desired_access = SEC_FILE_ALL;
4292 create2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4293 create2.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
4294 create2.in.create_disposition = NTCREATEX_DISP_OPEN;
4295 create2.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
4296 create2.in.fname = fname;
4297
4298 status = smb2_create(tree, tctx, &create2);
4299 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
4300
4301 h2 = create2.out.file.handle;
4302
4303 ZERO_STRUCT(sinfo);
4304 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
4305 sinfo.rename_information.in.file.handle = h2;
4306 sinfo.rename_information.in.overwrite = 0;
4307 sinfo.rename_information.in.root_fid = 0;
4308 sinfo.rename_information.in.new_name = fname_renamed;
4309
4310 if (server_is_macos) {
4311 expected_status = NT_STATUS_SHARING_VIOLATION;
4312 } else {
4313 expected_status = NT_STATUS_ACCESS_DENIED;
4314 }
4315
4316 status = smb2_setinfo_file(tree, &sinfo);
4317 torture_assert_ntstatus_equal_goto(
4318 tctx, status, expected_status, ret, done,
4319 "smb2_setinfo_file failed");
4320
4321 smb2_util_close(tree, h2);
4322
4323 status = smb2_util_write(tree, h1, "foo", 0, 3);
4324 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
4325 "write failed\n");
4326
4327 smb2_util_close(tree, h1);
4328
4329 done:
4330 smb2_util_unlink(tree, fname);
4331 smb2_util_unlink(tree, fname_renamed);
4332
4333 return ret;
4334 }
4335
4336 static bool test_readdir_attr_illegal_ntfs(struct torture_context *tctx,
4337 struct smb2_tree *tree)
4338 {
4339 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4340 const char *name = "test" "\xef\x80\xa2" "aapl"; /* "test:aapl" */
4341 const char *fname = BASEDIR "\\test" "\xef\x80\xa2" "aapl"; /* "test:aapl" */
4342 NTSTATUS status;
4343 struct smb2_handle testdirh;
4344 bool ret = true;
4345 struct smb2_create io;
4346 AfpInfo *info;
4347 const char *type_creator = "SMB,OLE!";
4348 struct smb2_find f;
4349 unsigned int count;
4350 union smb_search_data *d;
4351 uint64_t rfork_len;
4352 int i;
4353
4354 smb2_deltree(tree, BASEDIR);
4355
4356 status = torture_smb2_testdir(tree, BASEDIR, &testdirh);
4357 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir failed");
4358 smb2_util_close(tree, testdirh);
4359
4360 torture_comment(tctx, "Enabling AAPL\n");
4361
4362 ret = enable_aapl(tctx, tree);
4363 torture_assert_goto(tctx, ret == true, ret, done, "enable_aapl failed");
4364
4365 /*
4366 * Now that Requested AAPL extensions are enabled, setup some
4367 * Mac files with metadata and resource fork
4368 */
4369
4370 torture_comment(tctx, "Preparing file\n");
4371
4372 ret = torture_setup_file(mem_ctx, tree, fname, false);
4373 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file failed");
4374
4375 info = torture_afpinfo_new(mem_ctx);
4376 torture_assert_not_null_goto(tctx, info, ret, done, "torture_afpinfo_new failed");
4377
4378 memcpy(info->afpi_FinderInfo, type_creator, 8);
4379 ret = torture_write_afpinfo(tree, tctx, mem_ctx, fname, info);
4380 torture_assert_goto(tctx, ret == true, ret, done, "torture_write_afpinfo failed");
4381
4382 ret = write_stream(tree, __location__, tctx, mem_ctx,
4383 fname, AFPRESOURCE_STREAM_NAME,
4384 0, 3, "foo");
4385 torture_assert_goto(tctx, ret == true, ret, done, "write_stream failed");
4386
4387 /*
4388 * Ok, file is prepared, now call smb2/find
4389 */
4390
4391 torture_comment(tctx, "Issue find\n");
4392
4393 ZERO_STRUCT(io);
4394 io.in.desired_access = SEC_RIGHTS_DIR_READ;
4395 io.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
4396 io.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
4397 io.in.share_access = (NTCREATEX_SHARE_ACCESS_READ |
4398 NTCREATEX_SHARE_ACCESS_WRITE |
4399 NTCREATEX_SHARE_ACCESS_DELETE);
4400 io.in.create_disposition = NTCREATEX_DISP_OPEN;
4401 io.in.fname = BASEDIR;
4402 status = smb2_create(tree, tctx, &io);
4403 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_create failed");
4404
4405 ZERO_STRUCT(f);
4406 f.in.file.handle = io.out.file.handle;
4407 f.in.pattern = "*";
4408 f.in.max_response_size = 0x1000;
4409 f.in.level = SMB2_FIND_ID_BOTH_DIRECTORY_INFO;
4410
4411 status = smb2_find_level(tree, tree, &f, &count, &d);
4412 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_find_level failed");
4413
4414 status = smb2_util_close(tree, io.out.file.handle);
4415 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "smb2_util_close failed");
4416
4417 torture_comment(tctx, "Checking find response with enriched macOS metadata\n");
4418
4419 for (i = 0; i < count; i++) {
4420 const char *found = d[i].id_both_directory_info.name.s;
4421
4422 if (!strcmp(found, ".") || !strcmp(found, ".."))
4423 continue;
4424 if (strncmp(found, "._", 2) == 0) {
4425 continue;
4426 }
4427 break;
4428 }
4429
4430 torture_assert_str_equal_goto(tctx,
4431 d[i].id_both_directory_info.name.s, name,
4432 ret, done, "bad name");
4433
4434 rfork_len = BVAL(d[i].id_both_directory_info.short_name_buf, 0);
4435 torture_assert_int_equal_goto(tctx, rfork_len, 3, ret, done, "bad resource fork length");
4436
4437 torture_assert_mem_equal_goto(tctx, type_creator,
4438 d[i].id_both_directory_info.short_name_buf + 8,
4439 8, ret, done, "Bad FinderInfo");
4440 done:
4441 smb2_util_unlink(tree, fname);
4442 smb2_deltree(tree, BASEDIR);
4443 talloc_free(mem_ctx);
4444 return ret;
4445 }
4446
4447 static bool test_invalid_afpinfo(struct torture_context *tctx,
4448 struct smb2_tree *tree1,
4449 struct smb2_tree *tree2)
4450 {
4451 const char *fname = "filtest_invalid_afpinfo";
4452 const char *sname = "filtest_invalid_afpinfo" AFPINFO_STREAM_NAME;
4453 struct smb2_create create;
4454 const char *streams_basic[] = {
4455 "::$DATA"
4456 };
4457 const char *streams_afpinfo[] = {
4458 "::$DATA",
4459 AFPINFO_STREAM
4460 };
4461 NTSTATUS status;
4462 bool ret = true;
4463
4464 if (tree2 == NULL) {
4465 torture_skip_goto(tctx, done, "need second share without fruit\n");
4466 }
4467
4468 torture_comment(tctx, "Testing invalid AFP_AfpInfo stream\n");
4469
4470 ret = torture_setup_file(tctx, tree2, fname, false);
4471 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
4472
4473 ret = write_stream(tree2, __location__, tctx, tctx,
4474 fname, AFPINFO_STREAM_NAME,
4475 0, 3, "foo");
4476 torture_assert_goto(tctx, ret == true, ret, done, "write_stream failed");
4477
4478 ret = check_stream_list(tree2, tctx, fname, 2, streams_afpinfo, false);
4479 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
4480
4481 torture_comment(tctx, "Listing streams, bad AFPINFO stream must not be present\n");
4482
4483 ret = check_stream_list(tree1, tctx, fname, 1, streams_basic, false);
4484 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
4485
4486 torture_comment(tctx, "Try to open AFPINFO stream, must fail\n");
4487
4488 ZERO_STRUCT(create);
4489 create.in.desired_access = SEC_FILE_ALL;
4490 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
4491 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4492 create.in.create_disposition = NTCREATEX_DISP_OPEN;
4493 create.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
4494 create.in.fname = sname;
4495
4496 status = smb2_create(tree1, tctx, &create);
4497 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
4498 ret, done, "Stream still around?");
4499
4500 done:
4501 smb2_util_unlink(tree1, fname);
4502 return ret;
4503 }
4504
4505 static bool test_writing_afpinfo(struct torture_context *tctx,
4506 struct smb2_tree *tree)
4507 {
4508 const char *fname = "filtest_invalid_afpinfo";
4509 const char *sname = "filtest_invalid_afpinfo" AFPINFO_STREAM;
4510 const char *streams_afpinfo[] = {
4511 "::$DATA",
4512 AFPINFO_STREAM
4513 };
4514 bool ret = true;
4515 static AfpInfo *afpi = NULL;
4516 char *buf = NULL;
4517 char *afpi_buf = NULL;
4518 char *zero_buf = NULL;
4519 bool broken_osx = torture_setting_bool(tctx, "broken_osx_45759458", false);
4520 off_t min_offset_for_2streams = 16;
4521 int i;
4522 NTSTATUS status;
4523 struct test_sizes {
4524 off_t offset;
4525 size_t size;
4526 bool expected_result;
4527 } test_sizes[] = {
4528 { 0, 1, false},
4529 { 0, 2, false},
4530 { 0, 3, true},
4531 { 0, 4, true},
4532 { 0, 14, true},
4533 { 0, 15, true},
4534 { 0, 16, true},
4535 { 0, 24, true},
4536 { 0, 34, true},
4537 { 0, 44, true},
4538 { 0, 54, true},
4539 { 0, 55, true},
4540 { 0, 56, true},
4541 { 0, 57, true},
4542 { 0, 58, true},
4543 { 0, 59, true},
4544 { 0, 60, true},
4545 { 0, 61, true},
4546 { 0, 64, true},
4547 { 0, 1024, true},
4548 { 0, 10064, true},
4549
4550 { 1, 1, false},
4551 { 1, 2, false},
4552 { 1, 3, false},
4553 { 1, 4, false},
4554 { 1, 14, false},
4555 { 1, 15, false},
4556 { 1, 16, false},
4557 { 1, 24, false},
4558 { 1, 34, false},
4559 { 1, 44, false},
4560 { 1, 54, false},
4561 { 1, 55, false},
4562 { 1, 56, false},
4563 { 1, 57, false},
4564 { 1, 58, false},
4565 { 1, 59, false},
4566 { 1, 60, true},
4567 { 1, 61, true},
4568 { 1, 1024, true},
4569 { 1, 10064, true},
4570
4571 { 30, 1, false},
4572 { 30, 2, false},
4573 { 30, 3, false},
4574 { 30, 4, false},
4575 { 30, 14, false},
4576 { 30, 15, false},
4577 { 30, 16, false},
4578 { 30, 24, false},
4579 { 30, 34, false},
4580 { 30, 44, false},
4581 { 30, 54, false},
4582 { 30, 55, false},
4583 { 30, 56, false},
4584 { 30, 57, false},
4585 { 30, 58, false},
4586 { 30, 59, false},
4587 { 30, 60, true},
4588 { 30, 61, true},
4589 { 30, 1024, true},
4590 { 30, 10064, true},
4591
4592 { 58, 1, false},
4593 { 58, 2, false},
4594 { 58, 3, false},
4595 { 58, 4, false},
4596 { 58, 14, false},
4597 { 58, 15, false},
4598 { 58, 16, false},
4599 { 58, 24, false},
4600 { 58, 34, false},
4601 { 58, 44, false},
4602 { 58, 54, false},
4603 { 58, 55, false},
4604 { 58, 56, false},
4605 { 58, 57, false},
4606 { 58, 58, false},
4607 { 58, 59, false},
4608 { 58, 60, true},
4609 { 58, 61, true},
4610 { 58, 1024, true},
4611 { 58, 10064, true},
4612
4613 { 59, 1, false},
4614 { 59, 2, false},
4615 { 59, 3, false},
4616 { 59, 4, false},
4617 { 59, 14, false},
4618 { 59, 15, false},
4619 { 59, 16, false},
4620 { 59, 24, false},
4621 { 59, 34, false},
4622 { 59, 44, false},
4623 { 59, 54, false},
4624 { 59, 55, false},
4625 { 59, 56, false},
4626 { 59, 57, false},
4627 { 59, 58, false},
4628 { 59, 59, false},
4629 { 59, 60, true},
4630 { 59, 61, true},
4631 { 59, 1024, true},
4632 { 59, 10064, true},
4633
4634 { 60, 1, false},
4635 { 60, 2, false},
4636 { 60, 3, false},
4637 { 60, 4, false},
4638 { 60, 14, false},
4639 { 60, 15, false},
4640 { 60, 16, false},
4641 { 60, 24, false},
4642 { 60, 34, false},
4643 { 60, 44, false},
4644 { 60, 54, false},
4645 { 60, 55, false},
4646 { 60, 56, false},
4647 { 60, 57, false},
4648 { 60, 58, false},
4649 { 60, 59, false},
4650 { 60, 60, true},
4651 { 60, 61, true},
4652 { 60, 1024, true},
4653 { 60, 10064, true},
4654
4655 { 61, 1, false},
4656 { 61, 2, false},
4657 { 61, 3, false},
4658 { 61, 4, false},
4659 { 61, 14, false},
4660 { 61, 15, false},
4661 { 61, 16, false},
4662 { 61, 24, false},
4663 { 61, 34, false},
4664 { 61, 44, false},
4665 { 61, 54, false},
4666 { 61, 55, false},
4667 { 61, 56, false},
4668 { 61, 57, false},
4669 { 61, 58, false},
4670 { 61, 59, false},
4671 { 61, 60, true},
4672 { 61, 61, true},
4673 { 61, 1024, true},
4674 { 61, 10064, true},
4675
4676 { 10000, 1, false},
4677 { 10000, 2, false},
4678 { 10000, 3, false},
4679 { 10000, 4, false},
4680 { 10000, 14, false},
4681 { 10000, 15, false},
4682 { 10000, 16, false},
4683 { 10000, 24, false},
4684 { 10000, 34, false},
4685 { 10000, 44, false},
4686 { 10000, 54, false},
4687 { 10000, 55, false},
4688 { 10000, 56, false},
4689 { 10000, 57, false},
4690 { 10000, 58, false},
4691 { 10000, 59, false},
4692 { 10000, 60, true},
4693 { 10000, 61, true},
4694 { 10000, 1024, true},
4695 { 10000, 10064, true},
4696
4697 { -1, 0, false},
4698 };
4699
4700 afpi = torture_afpinfo_new(tctx);
4701 torture_assert_not_null_goto(tctx, afpi, ret, done,
4702 "torture_afpinfo_new failed\n");
4703
4704 memcpy(afpi->afpi_FinderInfo, "FOO BAR ", 8);
4705
4706 buf = torture_afpinfo_pack(afpi, afpi);
4707 torture_assert_not_null_goto(tctx, buf, ret, done,
4708 "torture_afpinfo_pack failed\n");
4709
4710 afpi_buf = talloc_zero_array(tctx, char, 10064);
4711 torture_assert_not_null_goto(tctx, afpi_buf, ret, done,
4712 "talloc_zero_array failed\n");
4713 memcpy(afpi_buf, buf, 60);
4714
4715 zero_buf = talloc_zero_array(tctx, char, 10064);
4716 torture_assert_not_null_goto(tctx, zero_buf, ret, done,
4717 "talloc_zero_array failed\n");
4718
4719 ret = torture_setup_file(tctx, tree, fname, false);
4720 torture_assert_goto(tctx, ret == true, ret, done,
4721 "torture_setup_file\n");
4722
4723 for (i = 0; test_sizes[i].offset != -1; i++) {
4724 struct smb2_handle h;
4725 struct smb2_create c;
4726 int expected_num_streams;
4727 size_t fi_check_size;
4728
4729 torture_comment(tctx,
4730 "Test %d: offset=%jd size=%zu result=%s\n",
4731 i,
4732 (intmax_t)test_sizes[i].offset,
4733 test_sizes[i].size,
4734 test_sizes[i].expected_result ? "true":"false");
4735
4736
4737 c = (struct smb2_create) {
4738 .in.desired_access = SEC_FILE_WRITE_DATA,
4739 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
4740 .in.create_disposition = NTCREATEX_DISP_OPEN_IF,
4741 .in.fname = sname,
4742 };
4743
4744 status = smb2_create(tree, tree, &c);
4745 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
4746 "smb2_create\n");
4747 h = c.out.file.handle;
4748
4749 status = smb2_util_write(tree,
4750 h,
4751 zero_buf,
4752 test_sizes[i].offset,
4753 test_sizes[i].size);
4754 torture_assert_ntstatus_equal_goto(
4755 tctx, status, NT_STATUS_INVALID_PARAMETER,
4756 ret, done, "smb2_util_write\n");
4757
4758 status = smb2_util_write(tree,
4759 h,
4760 afpi_buf,
4761 test_sizes[i].offset,
4762 test_sizes[i].size);
4763 smb2_util_close(tree, h);
4764 if (test_sizes[i].expected_result == true) {
4765 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
4766 "smb2_util_write\n");
4767 } else {
4768 torture_assert_ntstatus_equal_goto(
4769 tctx, status, NT_STATUS_INVALID_PARAMETER,
4770 ret, done, "smb2_util_write\n");
4771 }
4772
4773 if (broken_osx) {
4774 /*
4775 * Currently macOS has a bug (Radar #45759458) where it
4776 * writes more bytes then requested from uninitialized
4777 * memory to the filesystem. That means it will likely
4778 * write data to FinderInfo so the stream is not empty
4779 * and thus listed when the number of streams is
4780 * queried.
4781 */
4782 min_offset_for_2streams = 2;
4783 }
4784
4785 if ((test_sizes[i].expected_result == true) &&
4786 (test_sizes[i].size > min_offset_for_2streams))
4787 {
4788 expected_num_streams = 2;
4789 } else {
4790 expected_num_streams = 1;
4791 }
4792
4793 ret = check_stream_list(tree, tctx, fname,
4794 expected_num_streams,
4795 streams_afpinfo, false);
4796 torture_assert_goto(tctx, ret == true, ret, done,
4797 "Bad streams\n");
4798
4799 if (test_sizes[i].expected_result == false) {
4800 continue;
4801 }
4802
4803 if (test_sizes[i].size <= 16) {
4804 /*
4805 * FinderInfo with the "FOO BAR " string we wrote above
4806 * would start at offset 16. Check whether this test
4807 * wrote 1 byte or more.
4808 */
4809 goto next;
4810 }
4811
4812 fi_check_size = test_sizes[i].size - 16;
4813 fi_check_size = MIN(fi_check_size, 8);
4814
4815 ret = check_stream(tree, __location__,
4816 tctx, tctx,
4817 fname, AFPINFO_STREAM,
4818 0, 60, 16, fi_check_size, "FOO BAR ");
4819 torture_assert_goto(tctx, ret == true, ret, done,
4820 "Bad streams\n");
4821
4822 next:
4823 status = smb2_util_unlink(tree, sname);
4824 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
4825 bool missing_ok;
4826
4827 missing_ok = test_sizes[i].expected_result == false;
4828 missing_ok |= test_sizes[i].size <= 16;
4829
4830 torture_assert_goto(tctx, missing_ok,
4831 ret, done, "smb2_util_unlink\n");
4832 }
4833 }
4834
4835 done:
4836 smb2_util_unlink(tree, fname);
4837 return ret;
4838 }
4839
4840 static bool test_zero_file_id(struct torture_context *tctx,
4841 struct smb2_tree *tree)
4842 {
4843 const char *fname = "filtest_file_id";
4844 struct smb2_create create = {0};
4845 NTSTATUS status;
4846 bool ret = true;
4847 uint8_t zero_file_id[8] = {0};
4848
4849 torture_comment(tctx, "Testing zero file id\n");
4850
4851 ret = torture_setup_file(tctx, tree, fname, false);
4852 torture_assert_goto(tctx, ret == true, ret, done, "torture_setup_file");
4853
4854 ZERO_STRUCT(create);
4855 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE;
4856 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
4857 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4858 create.in.create_disposition = NTCREATEX_DISP_OPEN;
4859 create.in.fname = fname;
4860 create.in.query_on_disk_id = true;
4861
4862 status = smb2_create(tree, tctx, &create);
4863 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OK, ret,
4864 done,
4865 "test file could not be opened");
4866 torture_assert_mem_not_equal_goto(tctx, create.out.on_disk_id,
4867 zero_file_id, 8, ret, done,
4868 "unexpected zero file id");
4869
4870 smb2_util_close(tree, create.out.file.handle);
4871
4872 ret = enable_aapl(tctx, tree);
4873 torture_assert(tctx, ret == true, "enable_aapl failed");
4874
4875 ZERO_STRUCT(create);
4876 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE;
4877 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
4878 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
4879 create.in.create_disposition = NTCREATEX_DISP_OPEN;
4880 create.in.fname = fname;
4881 create.in.query_on_disk_id = true;
4882
4883 status = smb2_create(tree, tctx, &create);
4884 torture_assert_ntstatus_equal_goto(
4885 tctx, status, NT_STATUS_OK, ret, done,
4886 "test file could not be opened with AAPL");
4887 torture_assert_mem_equal_goto(tctx, create.out.on_disk_id, zero_file_id,
4888 8, ret, done, "non-zero file id");
4889
4890 smb2_util_close(tree, create.out.file.handle);
4891
4892 done:
4893 smb2_util_unlink(tree, fname);
4894 return ret;
4895 }
4896
4897 static bool copy_one_stream(struct torture_context *torture,
4898 struct smb2_tree *tree,
4899 TALLOC_CTX *tmp_ctx,
4900 const char *src_sname,
4901 const char *dst_sname)
4902 {
4903 struct smb2_handle src_h = {{0}};
4904 struct smb2_handle dest_h = {{0}};
4905 NTSTATUS status;
4906 union smb_ioctl io;
4907 struct srv_copychunk_copy cc_copy;
4908 struct srv_copychunk_rsp cc_rsp;
4909 enum ndr_err_code ndr_ret;
4910 bool ok = false;
4911
4912 ok = test_setup_copy_chunk(torture, tree, tmp_ctx,
4913 1, /* 1 chunk */
4914 src_sname,
4915 &src_h, 256, /* fill 256 byte src file */
4916 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
4917 dst_sname,
4918 &dest_h, 0, /* 0 byte dest file */
4919 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
4920 &cc_copy,
4921 &io);
4922 torture_assert_goto(torture, ok == true, ok, done,
4923 "setup copy chunk error\n");
4924
4925 /* copy all src file data (via a single chunk desc) */
4926 cc_copy.chunks[0].source_off = 0;
4927 cc_copy.chunks[0].target_off = 0;
4928 cc_copy.chunks[0].length = 256;
4929
4930 ndr_ret = ndr_push_struct_blob(
4931 &io.smb2.in.out, tmp_ctx, &cc_copy,
4932 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
4933
4934 torture_assert_ndr_success_goto(torture, ndr_ret, ok, done,
4935 "ndr_push_srv_copychunk_copy\n");
4936
4937 status = smb2_ioctl(tree, tmp_ctx, &io.smb2);
4938 torture_assert_ntstatus_ok_goto(torture, status, ok, done,
4939 "FSCTL_SRV_COPYCHUNK\n");
4940
4941 ndr_ret = ndr_pull_struct_blob(
4942 &io.smb2.out.out, tmp_ctx, &cc_rsp,
4943 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
4944
4945 torture_assert_ndr_success_goto(torture, ndr_ret, ok, done,
4946 "ndr_pull_srv_copychunk_rsp\n");
4947
4948 ok = check_copy_chunk_rsp(torture, &cc_rsp,
4949 1, /* chunks written */
4950 0, /* chunk bytes unsuccessfully written */
4951 256); /* total bytes written */
4952 torture_assert_goto(torture, ok == true, ok, done,
4953 "bad copy chunk response data\n");
4954
4955 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 256, 0);
4956 if (!ok) {
4957 torture_fail(torture, "inconsistent file data\n");
4958 }
4959
4960 done:
4961 if (!smb2_util_handle_empty(src_h)) {
4962 smb2_util_close(tree, src_h);
4963 }
4964 if (!smb2_util_handle_empty(dest_h)) {
4965 smb2_util_close(tree, dest_h);
4966 }
4967
4968 return ok;
4969 }
4970
4971 static bool copy_finderinfo_stream(struct torture_context *torture,
4972 struct smb2_tree *tree,
4973 TALLOC_CTX *tmp_ctx,
4974 const char *src_name,
4975 const char *dst_name)
4976 {
4977 struct smb2_handle src_h = {{0}};
4978 struct smb2_handle dest_h = {{0}};
4979 NTSTATUS status;
4980 union smb_ioctl io;
4981 struct srv_copychunk_copy cc_copy;
4982 struct srv_copychunk_rsp cc_rsp;
4983 enum ndr_err_code ndr_ret;
4984 const char *type_creator = "SMB,OLE!";
4985 AfpInfo *info = NULL;
4986 const char *src_name_afpinfo = NULL;
4987 const char *dst_name_afpinfo = NULL;
4988 bool ok = false;
4989
4990 src_name_afpinfo = talloc_asprintf(tmp_ctx, "%s%s", src_name,
4991 AFPINFO_STREAM);
4992 torture_assert_not_null_goto(torture, src_name_afpinfo, ok, done,
4993 "talloc_asprintf failed\n");
4994
4995 dst_name_afpinfo = talloc_asprintf(tmp_ctx, "%s%s", dst_name,
4996 AFPINFO_STREAM);
4997 torture_assert_not_null_goto(torture, dst_name_afpinfo, ok, done,
4998 "talloc_asprintf failed\n");
4999
5000 info = torture_afpinfo_new(tmp_ctx);
5001 torture_assert_not_null_goto(torture, info, ok, done,
5002 "torture_afpinfo_new failed\n");
5003
5004 memcpy(info->afpi_FinderInfo, type_creator, 8);
5005 ok = torture_write_afpinfo(tree, torture, tmp_ctx, src_name, info);
5006 torture_assert_goto(torture, ok == true, ok, done,
5007 "torture_write_afpinfo failed\n");
5008
5009 ok = test_setup_copy_chunk(torture, tree, tmp_ctx,
5010 1, /* 1 chunk */
5011 src_name_afpinfo,
5012 &src_h, 0,
5013 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
5014 dst_name_afpinfo,
5015 &dest_h, 0,
5016 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
5017 &cc_copy,
5018 &io);
5019 torture_assert_goto(torture, ok == true, ok, done,
5020 "setup copy chunk error\n");
5021
5022 /* copy all src file data (via a single chunk desc) */
5023 cc_copy.chunks[0].source_off = 0;
5024 cc_copy.chunks[0].target_off = 0;
5025 cc_copy.chunks[0].length = 60;
5026
5027 ndr_ret = ndr_push_struct_blob(
5028 &io.smb2.in.out, tmp_ctx, &cc_copy,
5029 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
5030
5031 torture_assert_ndr_success_goto(torture, ndr_ret, ok, done,
5032 "ndr_push_srv_copychunk_copy\n");
5033
5034 status = smb2_ioctl(tree, tmp_ctx, &io.smb2);
5035 torture_assert_ntstatus_ok_goto(torture, status, ok, done,
5036 "FSCTL_SRV_COPYCHUNK\n");
5037
5038 ndr_ret = ndr_pull_struct_blob(
5039 &io.smb2.out.out, tmp_ctx, &cc_rsp,
5040 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
5041
5042 torture_assert_ndr_success_goto(torture, ndr_ret, ok, done,
5043 "ndr_pull_srv_copychunk_rsp\n");
5044
5045 smb2_util_close(tree, src_h);
5046 ZERO_STRUCT(src_h);
5047 smb2_util_close(tree, dest_h);
5048 ZERO_STRUCT(dest_h);
5049
5050 ok = check_copy_chunk_rsp(torture, &cc_rsp,
5051 1, /* chunks written */
5052 0, /* chunk bytes unsuccessfully written */
5053 60); /* total bytes written */
5054 torture_assert_goto(torture, ok == true, ok, done,
5055 "bad copy chunk response data\n");
5056
5057 ok = check_stream(tree, __location__, torture, tmp_ctx,
5058 dst_name, AFPINFO_STREAM,
5059 0, 60, 16, 8, type_creator);
5060 torture_assert_goto(torture, ok == true, ok, done, "check_stream failed\n");
5061
5062 done:
5063 if (!smb2_util_handle_empty(src_h)) {
5064 smb2_util_close(tree, src_h);
5065 }
5066 if (!smb2_util_handle_empty(dest_h)) {
5067 smb2_util_close(tree, dest_h);
5068 }
5069
5070 return ok;
5071 }
5072
5073 static bool test_copy_chunk_streams(struct torture_context *torture,
5074 struct smb2_tree *tree)
5075 {
5076 const char *src_name = "src";
5077 const char *dst_name = "dst";
5078 struct names {
5079 const char *src_sname;
5080 const char *dst_sname;
5081 } names[] = {
5082 { "src:foo", "dst:foo" },
5083 { "src" AFPRESOURCE_STREAM, "dst" AFPRESOURCE_STREAM }
5084 };
5085 int i;
5086 TALLOC_CTX *tmp_ctx = NULL;
5087 bool ok = false;
5088
5089 tmp_ctx = talloc_new(tree);
5090 torture_assert_not_null_goto(torture, tmp_ctx, ok, done,
5091 "torture_setup_file\n");
5092
5093 smb2_util_unlink(tree, src_name);
5094 smb2_util_unlink(tree, dst_name);
5095
5096 ok = torture_setup_file(torture, tree, src_name, false);
5097 torture_assert_goto(torture, ok == true, ok, done, "torture_setup_file\n");
5098 ok = torture_setup_file(torture, tree, dst_name, false);
5099 torture_assert_goto(torture, ok == true, ok, done, "torture_setup_file\n");
5100
5101 for (i = 0; i < ARRAY_SIZE(names); i++) {
5102 ok = copy_one_stream(torture, tree, tmp_ctx,
5103 names[i].src_sname,
5104 names[i].dst_sname);
5105 torture_assert_goto(torture, ok == true, ok, done,
5106 "copy_one_stream failed\n");
5107 }
5108
5109 ok = copy_finderinfo_stream(torture, tree, tmp_ctx,
5110 src_name, dst_name);
5111 torture_assert_goto(torture, ok == true, ok, done,
5112 "copy_finderinfo_stream failed\n");
5113
5114 done:
5115 smb2_util_unlink(tree, src_name);
5116 smb2_util_unlink(tree, dst_name);
5117 talloc_free(tmp_ctx);
5118 return ok;
5119 }
5120
5121 /*
5122 * Ensure this security descriptor has exactly one mode, uid
5123 * and gid.
5124 */
5125
5126 static NTSTATUS check_nfs_sd(const struct security_descriptor *psd)
5127 {
5128 uint32_t i;
5129 bool got_one_mode = false;
5130 bool got_one_uid = false;
5131 bool got_one_gid = false;
5132
5133 if (psd->dacl == NULL) {
5134 return NT_STATUS_INVALID_SECURITY_DESCR;
5135 }
5136
5137 for (i = 0; i < psd->dacl->num_aces; i++) {
5138 if (dom_sid_compare_domain(&global_sid_Unix_NFS_Mode,
5139 &psd->dacl->aces[i].trustee) == 0) {
5140 if (got_one_mode == true) {
5141 /* Can't have more than one. */
5142 return NT_STATUS_INVALID_SECURITY_DESCR;
5143 }
5144 got_one_mode = true;
5145 }
5146 }
5147 for (i = 0; i < psd->dacl->num_aces; i++) {
5148 if (dom_sid_compare_domain(&global_sid_Unix_NFS_Users,
5149 &psd->dacl->aces[i].trustee) == 0) {
5150 if (got_one_uid == true) {
5151 /* Can't have more than one. */
5152 return NT_STATUS_INVALID_SECURITY_DESCR;
5153 }
5154 got_one_uid = true;
5155 }
5156 }
5157 for (i = 0; i < psd->dacl->num_aces; i++) {
5158 if (dom_sid_compare_domain(&global_sid_Unix_NFS_Groups,
5159 &psd->dacl->aces[i].trustee) == 0) {
5160 if (got_one_gid == true) {
5161 /* Can't have more than one. */
5162 return NT_STATUS_INVALID_SECURITY_DESCR;
5163 }
5164 got_one_gid = true;
5165 }
5166 }
5167 /* Must have at least one of each. */
5168 if (got_one_mode == false ||
5169 got_one_uid == false ||
5170 got_one_gid == false) {
5171 return NT_STATUS_INVALID_SECURITY_DESCR;
5172 }
5173 return NT_STATUS_OK;
5174 }
5175
5176 static bool test_nfs_aces(struct torture_context *tctx,
5177 struct smb2_tree *tree)
5178 {
5179 TALLOC_CTX *mem_ctx = talloc_new(tctx);
5180 struct security_ace ace;
5181 struct dom_sid sid;
5182 const char *fname = BASEDIR "\\nfs_aces.txt";
5183 struct smb2_handle h = {{0}};
5184 union smb_fileinfo finfo2;
5185 union smb_setfileinfo set;
5186 struct security_descriptor *psd = NULL;
5187 NTSTATUS status;
5188 bool ret = true;
5189 bool is_osx = torture_setting_bool(tctx, "osx", false);
5190
5191 if (is_osx) {
5192 torture_skip(tctx, "Test only works with Samba\n");
5193 }
5194
5195 ret = enable_aapl(tctx, tree);
5196 torture_assert(tctx, ret == true, "enable_aapl failed");
5197
5198 /* clean slate ...*/
5199 smb2_util_unlink(tree, fname);
5200 smb2_deltree(tree, fname);
5201 smb2_deltree(tree, BASEDIR);
5202
5203 status = torture_smb2_testdir(tree, BASEDIR, &h);
5204 CHECK_STATUS(status, NT_STATUS_OK);
5205 smb2_util_close(tree, h);
5206
5207 /* Create a test file. */
5208 status = torture_smb2_testfile_access(tree,
5209 fname,
5210 &h,
5211 SEC_STD_READ_CONTROL |
5212 SEC_STD_WRITE_DAC |
5213 SEC_RIGHTS_FILE_ALL);
5214 CHECK_STATUS(status, NT_STATUS_OK);
5215
5216 /* Get the ACL. */
5217 finfo2.query_secdesc.in.secinfo_flags =
5218 SECINFO_OWNER |
5219 SECINFO_GROUP |
5220 SECINFO_DACL;
5221 finfo2.generic.level = RAW_FILEINFO_SEC_DESC;
5222 finfo2.generic.in.file.handle = h;
5223 status = smb2_getinfo_file(tree, tctx, &finfo2);
5224 CHECK_STATUS(status, NT_STATUS_OK);
5225
5226 psd = finfo2.query_secdesc.out.sd;
5227
5228 /* Ensure we have only single mode/uid/gid NFS entries. */
5229 status = check_nfs_sd(psd);
5230 if (!NT_STATUS_IS_OK(status)) {
5231 NDR_PRINT_DEBUG(
5232 security_descriptor,
5233 discard_const_p(struct security_descriptor, psd));
5234 }
5235 CHECK_STATUS(status, NT_STATUS_OK);
5236
5237 /* Add a couple of extra NFS uids and gids. */
5238 sid_compose(&sid, &global_sid_Unix_NFS_Users, 27);
5239 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
5240 status = security_descriptor_dacl_add(psd, &ace);
5241 CHECK_STATUS(status, NT_STATUS_OK);
5242 status = security_descriptor_dacl_add(psd, &ace);
5243 CHECK_STATUS(status, NT_STATUS_OK);
5244
5245 sid_compose(&sid, &global_sid_Unix_NFS_Groups, 300);
5246 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
5247 status = security_descriptor_dacl_add(psd, &ace);
5248 CHECK_STATUS(status, NT_STATUS_OK);
5249 status = security_descriptor_dacl_add(psd, &ace);
5250 CHECK_STATUS(status, NT_STATUS_OK);
5251
5252 /* Now set on the file handle. */
5253 set.set_secdesc.level = RAW_SFILEINFO_SEC_DESC;
5254 set.set_secdesc.in.file.handle = h;
5255 set.set_secdesc.in.secinfo_flags = SECINFO_DACL;
5256 set.set_secdesc.in.sd = psd;
5257 status = smb2_setinfo_file(tree, &set);
5258 CHECK_STATUS(status, NT_STATUS_OK);
5259
5260 /* Get the ACL again. */
5261 finfo2.query_secdesc.in.secinfo_flags =
5262 SECINFO_OWNER |
5263 SECINFO_GROUP |
5264 SECINFO_DACL;
5265 finfo2.generic.level = RAW_FILEINFO_SEC_DESC;
5266 finfo2.generic.in.file.handle = h;
5267 status = smb2_getinfo_file(tree, tctx, &finfo2);
5268 CHECK_STATUS(status, NT_STATUS_OK);
5269
5270 psd = finfo2.query_secdesc.out.sd;
5271
5272 /* Ensure we have only single mode/uid/gid NFS entries. */
5273 status = check_nfs_sd(psd);
5274 if (!NT_STATUS_IS_OK(status)) {
5275 NDR_PRINT_DEBUG(
5276 security_descriptor,
5277 discard_const_p(struct security_descriptor, psd));
5278 }
5279 CHECK_STATUS(status, NT_STATUS_OK);
5280
5281 done:
5282 if (!smb2_util_handle_empty(h)) {
5283 smb2_util_close(tree, h);
5284 }
5285 smb2_util_unlink(tree, fname);
5286 smb2_deltree(tree, fname);
5287 smb2_deltree(tree, BASEDIR);
5288 talloc_free(mem_ctx);
5289 return ret;
5290 }
5291
5292 static bool test_setinfo_stream_eof(struct torture_context *tctx,
5293 struct smb2_tree *tree)
5294 {
5295 bool ret = true;
5296 NTSTATUS status;
5297 struct smb2_create create;
5298 union smb_setfileinfo sfinfo;
5299 union smb_fileinfo finfo;
5300 struct smb2_handle h1;
5301 TALLOC_CTX *mem_ctx = talloc_new(tctx);
5302 const char *fname = BASEDIR "\\file";
5303 const char *sname = BASEDIR "\\file:foo";
5304
5305 torture_assert_goto(tctx, mem_ctx != NULL, ret, done,
5306 "talloc_new failed\n");
5307
5308 ret = enable_aapl(tctx, tree);
5309 torture_assert(tctx, ret == true, "enable_aapl failed");
5310
5311 torture_comment(tctx, "Test setting EOF on a stream\n");
5312
5313 smb2_deltree(tree, BASEDIR);
5314 status = torture_smb2_testdir(tree, BASEDIR, &h1);
5315 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5316 "torture_smb2_testdir\n");
5317 smb2_util_close(tree, h1);
5318
5319 status = torture_smb2_testfile(tree, fname, &h1);
5320 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5321 "torture_smb2_testfile failed\n");
5322 smb2_util_close(tree, h1);
5323
5324 status = torture_smb2_testfile_access(tree, sname, &h1,
5325 SEC_FILE_WRITE_DATA);
5326 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5327 "torture_smb2_testfile failed\n");
5328
5329 status = smb2_util_write(tree, h1, "1234567890", 0, 10);
5330 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5331 "smb2_util_write failed\n");
5332 smb2_util_close(tree, h1);
5333
5334 /*
5335 * Test setting EOF to 21
5336 */
5337
5338 torture_comment(tctx, "Setting stream EOF to 21\n");
5339
5340 status = torture_smb2_testfile_access(tree, sname, &h1,
5341 SEC_FILE_WRITE_DATA);
5342 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5343 "torture_smb2_testfile failed\n");
5344
5345 ZERO_STRUCT(sfinfo);
5346 sfinfo.generic.in.file.handle = h1;
5347 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5348 sfinfo.position_information.in.position = 21;
5349 status = smb2_setinfo_file(tree, &sfinfo);
5350 torture_assert_ntstatus_ok_goto(tctx, status,
5351 ret, done, "set EOF 21 failed\n");
5352
5353 smb2_util_close(tree, h1);
5354
5355 status = torture_smb2_testfile_access(tree, sname, &h1,
5356 SEC_FILE_WRITE_DATA);
5357 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5358 "torture_smb2_testfile failed\n");
5359
5360 ZERO_STRUCT(finfo);
5361 finfo.generic.level = RAW_FILEINFO_STANDARD_INFORMATION;
5362 finfo.generic.in.file.handle = h1;
5363 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
5364 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5365 "smb2_getinfo_file failed");
5366
5367 smb2_util_close(tree, h1);
5368
5369 torture_assert_goto(tctx, finfo.standard_info.out.size == 21,
5370 ret, done, "size != 21\n");
5371
5372 /*
5373 * Test setting EOF to 0
5374 */
5375
5376 torture_comment(tctx, "Setting stream EOF to 0\n");
5377
5378 status = torture_smb2_testfile_access(tree, sname, &h1,
5379 SEC_FILE_WRITE_DATA);
5380 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5381 "torture_smb2_testfile failed\n");
5382
5383 ZERO_STRUCT(sfinfo);
5384 sfinfo.generic.in.file.handle = h1;
5385 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5386 sfinfo.position_information.in.position = 0;
5387 status = smb2_setinfo_file(tree, &sfinfo);
5388 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5389 "set eof 0 failed\n");
5390
5391 ZERO_STRUCT(create);
5392 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE;
5393 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
5394 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
5395 create.in.create_disposition = NTCREATEX_DISP_OPEN;
5396 create.in.fname = sname;
5397
5398 status = smb2_create(tree, tctx, &create);
5399 torture_assert_ntstatus_equal_goto(
5400 tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND, ret, done,
5401 "Unexpected status\n");
5402
5403 smb2_util_close(tree, h1);
5404
5405 ZERO_STRUCT(create);
5406 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE;
5407 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
5408 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
5409 create.in.create_disposition = NTCREATEX_DISP_OPEN;
5410 create.in.fname = sname;
5411
5412 status = smb2_create(tree, tctx, &create);
5413 torture_assert_ntstatus_equal_goto(
5414 tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND, ret, done,
5415 "Unexpected status\n");
5416
5417 status = torture_smb2_testfile_access(tree, sname, &h1,
5418 SEC_FILE_WRITE_DATA);
5419 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5420 "torture_smb2_testfile failed\n");
5421
5422 ZERO_STRUCT(finfo);
5423 finfo.generic.level = RAW_FILEINFO_STANDARD_INFORMATION;
5424 finfo.generic.in.file.handle = h1;
5425 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
5426 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5427 "smb2_getinfo_file failed\n");
5428
5429 smb2_util_close(tree, h1);
5430
5431 torture_assert_goto(tctx, finfo.standard_info.out.size == 0,
5432 ret, done, "size != 0\n");
5433
5434 /*
5435 * Test setinfo end-of-file info to 1
5436 */
5437
5438 torture_comment(tctx, "Setting stream EOF to 1\n");
5439
5440 status = torture_smb2_testfile_access(tree, sname, &h1,
5441 SEC_FILE_WRITE_DATA);
5442 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5443 "torture_smb2_testfile failed\n");
5444
5445 ZERO_STRUCT(sfinfo);
5446 sfinfo.generic.in.file.handle = h1;
5447 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5448 sfinfo.position_information.in.position = 1;
5449 status = smb2_setinfo_file(tree, &sfinfo);
5450 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5451 "set EOF 1 failed\n");
5452
5453 smb2_util_close(tree, h1);
5454
5455 status = torture_smb2_testfile_access(tree, sname, &h1,
5456 SEC_FILE_WRITE_DATA);
5457 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5458 "torture_smb2_testfile failed\n");
5459
5460 ZERO_STRUCT(finfo);
5461 finfo.generic.level = RAW_FILEINFO_STANDARD_INFORMATION;
5462 finfo.generic.in.file.handle = h1;
5463 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
5464 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5465 "smb2_getinfo_file failed\n");
5466
5467 smb2_util_close(tree, h1);
5468
5469 torture_assert_goto(tctx, finfo.standard_info.out.size == 1,
5470 ret, done, "size != 1\n");
5471
5472 /*
5473 * Test setting EOF to 0 with AAPL enabled, should delete stream
5474 */
5475
5476 torture_comment(tctx, "Enabling AAPL extensions\n");
5477
5478 ret = enable_aapl(tctx, tree);
5479 torture_assert(tctx, ret == true, "enable_aapl failed\n");
5480
5481 torture_comment(tctx, "Setting stream EOF to 0\n");
5482 status = torture_smb2_testfile_access(tree, sname, &h1,
5483 SEC_FILE_WRITE_DATA);
5484 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5485 "torture_smb2_testfile failed\n");
5486
5487 ZERO_STRUCT(sfinfo);
5488 sfinfo.generic.in.file.handle = h1;
5489 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5490 sfinfo.position_information.in.position = 0;
5491 status = smb2_setinfo_file(tree, &sfinfo);
5492 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5493 "set eof 0 failed\n");
5494
5495 ZERO_STRUCT(create);
5496 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE;
5497 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
5498 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
5499 create.in.create_disposition = NTCREATEX_DISP_OPEN;
5500 create.in.fname = sname;
5501
5502 status = smb2_create(tree, tctx, &create);
5503 torture_assert_ntstatus_equal_goto(
5504 tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND, ret, done,
5505 "Unexpected status\n");
5506
5507 smb2_util_close(tree, h1);
5508
5509 ZERO_STRUCT(create);
5510 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE;
5511 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
5512 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
5513 create.in.create_disposition = NTCREATEX_DISP_OPEN;
5514 create.in.fname = sname;
5515
5516 status = smb2_create(tree, tctx, &create);
5517 torture_assert_ntstatus_equal_goto(
5518 tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND, ret, done,
5519 "Unexpected status\n");
5520
5521 torture_comment(
5522 tctx, "Setting main file EOF to 1 to force 0-truncate\n");
5523
5524 status = torture_smb2_testfile_access(
5525 tree,
5526 fname,
5527 &h1,
5528 SEC_FILE_WRITE_DATA);
5529 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5530 "torture_smb2_testfile failed\n");
5531
5532 ZERO_STRUCT(sfinfo);
5533 sfinfo.generic.in.file.handle = h1;
5534 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5535 sfinfo.position_information.in.position = 1;
5536 status = smb2_setinfo_file(tree, &sfinfo);
5537 torture_assert_ntstatus_ok_goto(
5538 tctx,
5539 status,
5540 ret,
5541 done,
5542 "set eof 1 failed\n");
5543
5544 sfinfo.position_information.in.position = 0;
5545 status = smb2_setinfo_file(tree, &sfinfo);
5546 torture_assert_ntstatus_ok_goto(
5547 tctx,
5548 status,
5549 ret,
5550 done,
5551 "set eof 0 failed\n");
5552
5553 smb2_util_close(tree, h1);
5554
5555 ZERO_STRUCT(create);
5556 create.in.desired_access = SEC_FILE_READ_ATTRIBUTE;
5557 create.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
5558 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
5559 create.in.create_disposition = NTCREATEX_DISP_OPEN;
5560 create.in.fname = fname;
5561
5562 status = smb2_create(tree, tctx, &create);
5563 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5564 "torture_smb2_testfile failed\n");
5565 smb2_util_close(tree, h1);
5566
5567 torture_comment(tctx, "Writing to stream after setting EOF to 0\n");
5568 status = torture_smb2_testfile_access(tree, sname, &h1,
5569 SEC_FILE_WRITE_DATA);
5570 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5571 "torture_smb2_testfile failed\n");
5572
5573 status = smb2_util_write(tree, h1, "1234567890", 0, 10);
5574 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5575 "smb2_util_write failed\n");
5576
5577 ZERO_STRUCT(sfinfo);
5578 sfinfo.generic.in.file.handle = h1;
5579 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5580 sfinfo.position_information.in.position = 0;
5581 status = smb2_setinfo_file(tree, &sfinfo);
5582 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5583 "set eof 0 failed\n");
5584
5585 status = smb2_util_write(tree, h1, "1234567890", 0, 10);
5586 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5587 "smb2_util_write failed\n");
5588
5589 smb2_util_close(tree, h1);
5590
5591 done:
5592 smb2_util_unlink(tree, fname);
5593 smb2_util_rmdir(tree, BASEDIR);
5594 return ret;
5595 }
5596
5597 #define MAX_STREAMS 16
5598
5599 struct tcase {
5600 const char *name;
5601 uint32_t access;
5602 const char *write_data;
5603 size_t write_size;
5604 struct tcase_results {
5605 size_t size;
5606 NTSTATUS initial_status;
5607 NTSTATUS final_status;
5608 int num_streams_open_handle;
5609 const char *streams_open_handle[MAX_STREAMS];
5610 int num_streams_closed_handle;
5611 const char *streams_closed_handle[MAX_STREAMS];
5612 } create, write, overwrite, eof, doc;
5613 };
5614
5615 typedef enum {T_CREATE, T_WRITE, T_OVERWRITE, T_EOF, T_DOC} subtcase_t;
5616
5617 static bool test_empty_stream_do_checks(
5618 struct torture_context *tctx,
5619 struct smb2_tree *tree,
5620 struct smb2_tree *tree2,
5621 struct tcase *tcase,
5622 TALLOC_CTX *mem_ctx,
5623 struct smb2_handle baseh,
5624 struct smb2_handle streamh,
5625 subtcase_t subcase)
5626 {
5627 bool ret = false;
5628 NTSTATUS status;
5629 struct smb2_handle h1;
5630 union smb_fileinfo finfo;
5631 struct tcase_results *tcase_results = NULL;
5632
5633 switch (subcase) {
5634 case T_CREATE:
5635 tcase_results = &tcase->create;
5636 break;
5637 case T_OVERWRITE:
5638 tcase_results = &tcase->overwrite;
5639 break;
5640 case T_WRITE:
5641 tcase_results = &tcase->write;
5642 break;
5643 case T_EOF:
5644 tcase_results = &tcase->eof;
5645 break;
5646 case T_DOC:
5647 tcase_results = &tcase->doc;
5648 break;
5649 }
5650
5651 finfo = (union smb_fileinfo) {
5652 .generic.level = RAW_FILEINFO_STANDARD_INFORMATION,
5653 .generic.in.file.handle = streamh,
5654 };
5655
5656 /*
5657 * Test: check size, same client
5658 */
5659
5660 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
5661 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5662 "torture_smb2_testfile failed\n");
5663
5664 torture_assert_int_equal_goto(tctx, finfo.standard_info.out.size,
5665 tcase_results->size,
5666 ret, done, "Wrong size\n");
5667
5668 /*
5669 * Test: open, same client
5670 */
5671
5672 status = torture_smb2_open(tree, tcase->name,
5673 SEC_FILE_READ_ATTRIBUTE, &h1);
5674 torture_assert_ntstatus_equal_goto(tctx, status,
5675 tcase_results->initial_status,
5676 ret, done,
5677 "smb2_create failed\n");
5678 if (NT_STATUS_IS_OK(status)) {
5679 status = smb2_util_close(tree, h1);
5680 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5681 "smb2_util_close failed\n");
5682 }
5683
5684 /*
5685 * Test: check streams, same client
5686 */
5687
5688 ret = check_stream_list_handle(tree, tctx, baseh,
5689 tcase_results->num_streams_open_handle,
5690 tcase_results->streams_open_handle,
5691 false);
5692 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
5693
5694 /*
5695 * Test: open, different client
5696 */
5697
5698 status = torture_smb2_open(tree2, tcase->name,
5699 SEC_FILE_READ_ATTRIBUTE, &h1);
5700 torture_assert_ntstatus_equal_goto(tctx, status,
5701 tcase_results->initial_status,
5702 ret, done,
5703 "smb2_create failed\n");
5704 if (NT_STATUS_IS_OK(status)) {
5705 finfo = (union smb_fileinfo) {
5706 .generic.level = RAW_FILEINFO_STANDARD_INFORMATION,
5707 .generic.in.file.handle = h1,
5708 };
5709
5710 /*
5711 * Test: check size, different client
5712 */
5713
5714 status = smb2_getinfo_file(tree2, mem_ctx, &finfo);
5715 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5716 "smb2_getinfo_file failed\n");
5717
5718 torture_assert_int_equal_goto(tctx, finfo.standard_info.out.size,
5719 tcase_results->size,
5720 ret, done, "Wrong size\n");
5721
5722 /*
5723 * Test: check streams, different client
5724 */
5725
5726 ret = check_stream_list(tree2, tctx, BASEDIR "\\file",
5727 tcase_results->num_streams_open_handle,
5728 tcase_results->streams_open_handle,
5729 false);
5730 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
5731
5732 status = smb2_util_close(tree2, h1);
5733 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5734 "smb2_util_close failed\n");
5735 }
5736
5737 status = smb2_util_close(tree, streamh);
5738 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5739 "smb2_util_close failed\n");
5740
5741 /*
5742 * Test: open after close, same client
5743 */
5744
5745 status = torture_smb2_open(tree, tcase->name,
5746 SEC_FILE_READ_DATA, &h1);
5747 torture_assert_ntstatus_equal_goto(tctx, status,
5748 tcase_results->final_status,
5749 ret, done,
5750 "smb2_create failed\n");
5751 if (NT_STATUS_IS_OK(status)) {
5752 status = smb2_util_close(tree, h1);
5753 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5754 "smb2_util_close failed\n");
5755 }
5756
5757 /*
5758 * Test: open after close, different client
5759 */
5760
5761 status = torture_smb2_open(tree2, tcase->name,
5762 SEC_FILE_READ_DATA, &h1);
5763 torture_assert_ntstatus_equal_goto(tctx, status,
5764 tcase_results->final_status,
5765 ret, done,
5766 "smb2_create failed\n");
5767 if (NT_STATUS_IS_OK(status)) {
5768 status = smb2_util_close(tree2, h1);
5769 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5770 "smb2_util_close failed\n");
5771 }
5772
5773 /*
5774 * Test: check streams after close, same client
5775 */
5776
5777 ret = check_stream_list_handle(tree, tctx, baseh,
5778 tcase_results->num_streams_closed_handle,
5779 tcase_results->streams_closed_handle,
5780 false);
5781 torture_assert_goto(tctx, ret == true, ret, done, "Bad streams");
5782
5783 ret = true;
5784
5785 done:
5786 smb2_util_close(tree, streamh);
5787 smb2_util_close(tree, baseh);
5788 return ret;
5789 }
5790
5791 static bool test_empty_stream_do_one(
5792 struct torture_context *tctx,
5793 struct smb2_tree *tree,
5794 struct smb2_tree *tree2,
5795 struct tcase *tcase)
5796 {
5797 bool ret = false;
5798 NTSTATUS status;
5799 struct smb2_handle baseh = {{0}};
5800 struct smb2_handle streamh;
5801 struct smb2_create create;
5802 union smb_setfileinfo sfinfo;
5803 TALLOC_CTX *mem_ctx = talloc_new(tctx);
5804
5805 torture_comment(tctx, "Testing stream [%s]\n", tcase->name);
5806
5807 torture_assert_goto(tctx, mem_ctx != NULL, ret, done, "talloc_new\n");
5808
5809 /*
5810 * Subtest: create
5811 */
5812 torture_comment(tctx, "Subtest: T_CREATE\n");
5813
5814 status = smb2_util_unlink(tree, BASEDIR "\\file");
5815 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5816 "smb2_util_unlink failed\n");
5817
5818 status = torture_smb2_testfile_access(tree, BASEDIR "\\file",
5819 &baseh, SEC_FILE_ALL);
5820 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5821 "torture_smb2_testfile_access failed\n");
5822
5823 status = torture_smb2_testfile_access(tree, tcase->name, &streamh,
5824 tcase->access);
5825 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5826 "torture_smb2_testfile_access failed\n");
5827
5828 ret = test_empty_stream_do_checks(tctx, tree, tree2, tcase,
5829 mem_ctx, baseh, streamh, T_CREATE);
5830 torture_assert_goto(tctx, ret, ret, done, "test failed\n");
5831
5832 if (!(tcase->access & SEC_FILE_WRITE_DATA)) {
5833 /*
5834 * All subsequent tests require write access
5835 */
5836 ret = true;
5837 goto done;
5838 }
5839
5840 /*
5841 * Subtest: create and write
5842 */
5843 torture_comment(tctx, "Subtest: T_WRITE\n");
5844
5845 status = smb2_util_unlink(tree, BASEDIR "\\file");
5846 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5847 "smb2_util_unlink failed\n");
5848
5849 status = torture_smb2_testfile_access(tree, BASEDIR "\\file",
5850 &baseh, SEC_FILE_ALL);
5851 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5852 "torture_smb2_testfile_access failed\n");
5853
5854 status = torture_smb2_testfile_access(tree, tcase->name, &streamh,
5855 tcase->access);
5856 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5857 "torture_smb2_testfile_access failed\n");
5858
5859 status = smb2_util_write(tree, streamh, tcase->write_data, 0,
5860 tcase->write_size);
5861 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5862 "torture_smb2_open failed\n");
5863
5864 ret = test_empty_stream_do_checks(tctx, tree, tree2, tcase,
5865 mem_ctx, baseh, streamh, T_WRITE);
5866 torture_assert_goto(tctx, ret, ret, done, "test failed\n");
5867
5868 /*
5869 * Subtest: overwrite
5870 */
5871 torture_comment(tctx, "Subtest: T_OVERWRITE\n");
5872
5873 status = smb2_util_unlink(tree, BASEDIR "\\file");
5874 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5875 "smb2_util_unlink failed\n");
5876
5877 status = torture_smb2_testfile_access(tree, BASEDIR "\\file",
5878 &baseh, SEC_FILE_ALL);
5879 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5880 "torture_smb2_testfile_access failed\n");
5881
5882 create = (struct smb2_create) {
5883 .in.desired_access = SEC_FILE_ALL,
5884 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
5885 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
5886 .in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF,
5887 .in.fname = tcase->name,
5888 };
5889
5890 status = smb2_create(tree, tctx, &create);
5891 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5892 "torture_smb2_testfile failed\n");
5893 streamh = create.out.file.handle;
5894
5895 ret = test_empty_stream_do_checks(tctx, tree, tree2, tcase,
5896 mem_ctx, baseh, streamh, T_OVERWRITE);
5897 torture_assert_goto(tctx, ret, ret, done, "test failed\n");
5898
5899 /*
5900 * Subtest: setinfo EOF 0
5901 */
5902 torture_comment(tctx, "Subtest: T_EOF\n");
5903
5904 status = smb2_util_unlink(tree, BASEDIR "\\file");
5905 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5906 "smb2_util_unlink failed\n");
5907
5908 status = torture_smb2_testfile_access(tree, BASEDIR "\\file",
5909 &baseh, SEC_FILE_ALL);
5910 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5911 "torture_smb2_testfile_access failed\n");
5912
5913 status = torture_smb2_testfile_access(tree, tcase->name, &streamh,
5914 tcase->access);
5915 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5916 "torture_smb2_testfile_access failed\n");
5917
5918 status = smb2_util_write(tree, streamh, tcase->write_data, 0,
5919 tcase->write_size);
5920 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5921 "torture_smb2_open failed\n");
5922
5923 sfinfo = (union smb_setfileinfo) {
5924 .end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION,
5925 .end_of_file_info.in.file.handle = streamh,
5926 .end_of_file_info.in.size = 0,
5927 };
5928 status = smb2_setinfo_file(tree, &sfinfo);
5929 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5930 "set eof 0 failed\n");
5931
5932 ret = test_empty_stream_do_checks(tctx, tree, tree2, tcase,
5933 mem_ctx, baseh, streamh, T_EOF);
5934 torture_assert_goto(tctx, ret, ret, done, "test failed\n");
5935
5936 /*
5937 * Subtest: delete-on-close
5938 */
5939 torture_comment(tctx, "Subtest: T_DOC\n");
5940
5941 status = smb2_util_unlink(tree, BASEDIR "\\file");
5942 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5943 "smb2_util_unlink failed\n");
5944
5945 status = torture_smb2_testfile_access(tree, BASEDIR "\\file",
5946 &baseh, SEC_FILE_ALL);
5947 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5948 "torture_smb2_testfile_access failed\n");
5949
5950 status = torture_smb2_testfile_access(tree, tcase->name, &streamh,
5951 tcase->access);
5952 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5953 "torture_smb2_testfile_access failed\n");
5954
5955 status = smb2_util_write(tree, streamh, tcase->write_data, 0,
5956 tcase->write_size);
5957 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5958 "torture_smb2_open failed\n");
5959
5960 sfinfo = (union smb_setfileinfo) {
5961 .disposition_info.level = RAW_SFILEINFO_DISPOSITION_INFORMATION,
5962 .disposition_info.in.file.handle = streamh,
5963 .disposition_info.in.delete_on_close = true,
5964 };
5965 status = smb2_setinfo_file(tree, &sfinfo);
5966 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5967 "set eof 0 failed\n");
5968
5969 ret = test_empty_stream_do_checks(tctx, tree, tree2, tcase,
5970 mem_ctx, baseh, streamh,
5971 T_DOC);
5972 torture_assert_goto(tctx, ret, ret, done, "test failed\n");
5973
5974 ret = true;
5975
5976 done:
5977 smb2_util_close(tree, baseh);
5978 TALLOC_FREE(mem_ctx);
5979 return ret;
5980 }
5981
5982 static bool test_empty_stream(struct torture_context *tctx,
5983 struct smb2_tree *tree)
5984 {
5985 struct smb2_tree *tree2 = NULL;
5986 struct tcase *tcase = NULL;
5987 const char *fname = BASEDIR "\\file";
5988 struct smb2_handle h1;
5989 bool ret = true;
5990 NTSTATUS status;
5991 AfpInfo ai = (AfpInfo) {
5992 .afpi_Signature = AFP_Signature,
5993 .afpi_Version = AFP_Version,
5994 .afpi_BackupTime = AFP_BackupTime,
5995 .afpi_FinderInfo = "FOO BAR ",
5996 };
5997 char *ai_blob = torture_afpinfo_pack(tctx, &ai);
5998 struct tcase tcase_afpinfo_ro = (struct tcase) {
5999 .name = BASEDIR "\\file" AFPINFO_STREAM,
6000 .access = SEC_FILE_READ_DATA|SEC_FILE_READ_ATTRIBUTE,
6001 .create = {
6002 .size = 60,
6003 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6004 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6005 .num_streams_open_handle = 1,
6006 .num_streams_closed_handle = 1,
6007 .streams_open_handle = {"::$DATA"},
6008 .streams_closed_handle = {"::$DATA"},
6009 },
6010 };
6011 struct tcase tcase_afpinfo_rw = (struct tcase) {
6012 .name = BASEDIR "\\file" AFPINFO_STREAM,
6013 .access = SEC_FILE_READ_DATA|SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_DATA|SEC_STD_DELETE,
6014 .write_data = ai_blob,
6015 .write_size = AFP_INFO_SIZE,
6016 .create = {
6017 .size = 60,
6018 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6019 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6020 .num_streams_open_handle = 1,
6021 .num_streams_closed_handle = 1,
6022 .streams_open_handle = {"::$DATA"},
6023 .streams_closed_handle = {"::$DATA"},
6024 },
6025 .write = {
6026 .size = 60,
6027 .initial_status = NT_STATUS_OK,
6028 .final_status = NT_STATUS_OK,
6029 .num_streams_open_handle = 2,
6030 .num_streams_closed_handle = 2,
6031 .streams_open_handle = {"::$DATA", AFPINFO_STREAM},
6032 .streams_closed_handle = {"::$DATA", AFPINFO_STREAM},
6033 },
6034 .overwrite = {
6035 .size = 60,
6036 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6037 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6038 .num_streams_open_handle = 1,
6039 .num_streams_closed_handle = 1,
6040 .streams_open_handle = {"::$DATA"},
6041 .streams_closed_handle = {"::$DATA"},
6042 },
6043 .eof = {
6044 .size = 60,
6045 .initial_status = NT_STATUS_OK,
6046 .final_status = NT_STATUS_OK,
6047 .num_streams_open_handle = 2,
6048 .num_streams_closed_handle = 2,
6049 .streams_open_handle = {"::$DATA", AFPINFO_STREAM},
6050 .streams_closed_handle = {"::$DATA", AFPINFO_STREAM},
6051 },
6052 .doc = {
6053 .size = 60,
6054 .initial_status = NT_STATUS_DELETE_PENDING,
6055 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6056 .num_streams_open_handle = 2,
6057 .num_streams_closed_handle = 1,
6058 .streams_open_handle = {"::$DATA", AFPINFO_STREAM},
6059 .streams_closed_handle = {"::$DATA"},
6060 },
6061 };
6062
6063 struct tcase tcase_afpresource_ro = (struct tcase) {
6064 .name = BASEDIR "\\file" AFPRESOURCE_STREAM,
6065 .access = SEC_FILE_READ_DATA|SEC_FILE_READ_ATTRIBUTE,
6066 .create = {
6067 .size = 0,
6068 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6069 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6070 .num_streams_open_handle = 1,
6071 .num_streams_closed_handle = 1,
6072 .streams_open_handle = {"::$DATA"},
6073 .streams_closed_handle = {"::$DATA"},
6074 },
6075 };
6076 struct tcase tcase_afpresource_rw = (struct tcase) {
6077 .name = BASEDIR "\\file" AFPRESOURCE_STREAM,
6078 .access = SEC_FILE_READ_DATA|SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_DATA|SEC_STD_DELETE,
6079 .write_data = "foo",
6080 .write_size = 3,
6081 .create = {
6082 .size = 0,
6083 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6084 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6085 .num_streams_open_handle = 1,
6086 .num_streams_closed_handle = 1,
6087 .streams_open_handle = {"::$DATA"},
6088 .streams_closed_handle = {"::$DATA"},
6089 },
6090 .write = {
6091 .size = 3,
6092 .initial_status = NT_STATUS_OK,
6093 .final_status = NT_STATUS_OK,
6094 .num_streams_open_handle = 2,
6095 .num_streams_closed_handle = 2,
6096 .streams_open_handle = {"::$DATA", AFPRESOURCE_STREAM},
6097 .streams_closed_handle = {"::$DATA", AFPRESOURCE_STREAM},
6098 },
6099 .overwrite = {
6100 .size = 0,
6101 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6102 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6103 .num_streams_open_handle = 1,
6104 .num_streams_closed_handle = 1,
6105 .streams_open_handle = {"::$DATA"},
6106 .streams_closed_handle = {"::$DATA"},
6107 },
6108 .eof = {
6109 .size = 0,
6110 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6111 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6112 .num_streams_open_handle = 1,
6113 .num_streams_closed_handle = 1,
6114 .streams_open_handle = {"::$DATA"},
6115 .streams_closed_handle = {"::$DATA"},
6116 },
6117 .doc = {
6118 .size = 3,
6119 .initial_status = NT_STATUS_DELETE_PENDING,
6120 .final_status = NT_STATUS_OK,
6121 .num_streams_open_handle = 2,
6122 .num_streams_closed_handle = 2,
6123 .streams_open_handle = {"::$DATA", AFPRESOURCE_STREAM},
6124 .streams_closed_handle = {"::$DATA", AFPRESOURCE_STREAM},
6125 },
6126 };
6127
6128 struct tcase tcase_foo_ro = (struct tcase) {
6129 .name = BASEDIR "\\file:foo",
6130 .access = SEC_FILE_READ_DATA|SEC_FILE_READ_ATTRIBUTE,
6131 .write_data = "foo",
6132 .write_size = 3,
6133 .create = {
6134 .size = 0,
6135 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6136 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6137 .num_streams_open_handle = 1,
6138 .num_streams_closed_handle = 1,
6139 .streams_open_handle = {"::$DATA"},
6140 .streams_closed_handle = {"::$DATA"},
6141 },
6142 };
6143
6144 struct tcase tcase_foo_rw = (struct tcase) {
6145 .name = BASEDIR "\\file:foo",
6146 .access = SEC_FILE_READ_DATA|SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_DATA|SEC_STD_DELETE,
6147 .write_data = "foo",
6148 .write_size = 3,
6149 .create = {
6150 .size = 0,
6151 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6152 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6153 .num_streams_open_handle = 1,
6154 .num_streams_closed_handle = 1,
6155 .streams_open_handle = {"::$DATA"},
6156 .streams_closed_handle = {"::$DATA"},
6157 },
6158 .write = {
6159 .size = 3,
6160 .initial_status = NT_STATUS_OK,
6161 .final_status = NT_STATUS_OK,
6162 .num_streams_open_handle = 2,
6163 .num_streams_closed_handle = 2,
6164 .streams_open_handle = {"::$DATA", ":foo:$DATA"},
6165 .streams_closed_handle = {"::$DATA", ":foo:$DATA"},
6166 },
6167 .overwrite = {
6168 .size = 0,
6169 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6170 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6171 .num_streams_open_handle = 1,
6172 .num_streams_closed_handle = 1,
6173 .streams_open_handle = {"::$DATA"},
6174 .streams_closed_handle = {"::$DATA"},
6175 },
6176 .eof = {
6177 .size = 0,
6178 .initial_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6179 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6180 .num_streams_open_handle = 1,
6181 .num_streams_closed_handle = 1,
6182 .streams_open_handle = {"::$DATA"},
6183 .streams_closed_handle = {"::$DATA"},
6184 },
6185 .doc = {
6186 .size = 3,
6187 .initial_status = NT_STATUS_DELETE_PENDING,
6188 .final_status = NT_STATUS_OBJECT_NAME_NOT_FOUND,
6189 .num_streams_open_handle = 2,
6190 .num_streams_closed_handle = 1,
6191 .streams_open_handle = {"::$DATA", ":foo:$DATA"},
6192 .streams_closed_handle = {"::$DATA"},
6193 },
6194 };
6195
6196 struct tcase tcases[] = {
6197 tcase_afpinfo_ro,
6198 tcase_afpinfo_rw,
6199 tcase_afpresource_ro,
6200 tcase_afpresource_rw,
6201 tcase_foo_ro,
6202 tcase_foo_rw,
6203 {NULL}
6204 };
6205
6206 ret = torture_smb2_connection(tctx, &tree2);
6207 torture_assert_goto(tctx, ret == true, ret, done,
6208 "torture_smb2_connection failed\n");
6209
6210 ret = enable_aapl(tctx, tree);
6211 torture_assert(tctx, ret == true, "enable_aapl failed\n");
6212
6213 ret = enable_aapl(tctx, tree2);
6214 torture_assert(tctx, ret == true, "enable_aapl failed\n");
6215
6216 smb2_deltree(tree, BASEDIR);
6217
6218 status = torture_smb2_testdir(tree, BASEDIR, &h1);
6219 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6220 "torture_smb2_testdir\n");
6221 smb2_util_close(tree, h1);
6222
6223 for (tcase = &tcases[0]; tcase->name != NULL; tcase++) {
6224 ret = torture_setup_file(tctx, tree, fname, false);
6225 torture_assert_goto(tctx, ret == true, ret, done,
6226 "torture_setup_file failed\n");
6227
6228 ret = test_empty_stream_do_one(tctx, tree, tree2, tcase);
6229 torture_assert_goto(tctx, ret == true, ret, done,
6230 "subtest failed\n");
6231
6232 status = smb2_util_unlink(tree, fname);
6233 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6234 "smb2_util_unlink failed\n");
6235 }
6236
6237 done:
6238 smb2_deltree(tree, BASEDIR);
6239 TALLOC_FREE(tree2);
6240 return ret;
6241 }
6242
6243 /*
6244 * Note: This test depends on "vfs objects = catia fruit streams_xattr". For
6245 * some tests torture must be run on the host it tests and takes an additional
6246 * argument with the local path to the share:
6247 * "--option=torture:localdir=<SHAREPATH>".
6248 *
6249 * When running against an OS X SMB server add "--option=torture:osx=true"
6250 */
6251 struct torture_suite *torture_vfs_fruit(TALLOC_CTX *ctx)
6252 {
6253 struct torture_suite *suite = torture_suite_create(
6254 ctx, "fruit");
6255
6256 suite->description = talloc_strdup(suite, "vfs_fruit tests");
6257
6258 torture_suite_add_1smb2_test(suite, "copyfile", test_copyfile);
6259 torture_suite_add_1smb2_test(suite, "read metadata", test_read_afpinfo);
6260 torture_suite_add_1smb2_test(suite, "write metadata", test_write_atalk_metadata);
6261 torture_suite_add_1smb2_test(suite, "resource fork IO", test_write_atalk_rfork_io);
6262 torture_suite_add_1smb2_test(suite, "SMB2/CREATE context AAPL", test_aapl);
6263 torture_suite_add_1smb2_test(suite, "stream names", test_stream_names);
6264 torture_suite_add_1smb2_test(suite, "truncate resource fork to 0 bytes", test_rfork_truncate);
6265 torture_suite_add_1smb2_test(suite, "opening and creating resource fork", test_rfork_create);
6266 torture_suite_add_1smb2_test(suite, "rename_dir_openfile", test_rename_dir_openfile);
6267 torture_suite_add_1smb2_test(suite, "File without AFP_AfpInfo", test_afpinfo_enoent);
6268 torture_suite_add_1smb2_test(suite, "create delete-on-close AFP_AfpInfo", test_create_delete_on_close);
6269 torture_suite_add_1smb2_test(suite, "setinfo delete-on-close AFP_AfpInfo", test_setinfo_delete_on_close);
6270 torture_suite_add_1smb2_test(suite, "setinfo eof AFP_AfpInfo", test_setinfo_eof);
6271 torture_suite_add_1smb2_test(suite, "delete AFP_AfpInfo by writing all 0", test_afpinfo_all0);
6272 torture_suite_add_1smb2_test(suite, "create delete-on-close AFP_AfpResource", test_create_delete_on_close_resource);
6273 torture_suite_add_1smb2_test(suite, "setinfo delete-on-close AFP_AfpResource", test_setinfo_delete_on_close_resource);
6274 torture_suite_add_1smb2_test(suite, "setinfo eof AFP_AfpResource", test_setinfo_eof_resource);
6275 torture_suite_add_1smb2_test(suite, "setinfo eof stream", test_setinfo_stream_eof);
6276 torture_suite_add_1smb2_test(suite, "null afpinfo", test_null_afpinfo);
6277 torture_suite_add_1smb2_test(suite, "delete", test_delete_file_with_rfork);
6278 torture_suite_add_1smb2_test(suite, "read open rsrc after rename", test_rename_and_read_rsrc);
6279 torture_suite_add_1smb2_test(suite, "readdir_attr with names with illegal ntfs characters", test_readdir_attr_illegal_ntfs);
6280 torture_suite_add_2ns_smb2_test(suite, "invalid AFP_AfpInfo", test_invalid_afpinfo);
6281 torture_suite_add_1smb2_test(suite, "creating rsrc with read-only access", test_rfork_create_ro);
6282 torture_suite_add_1smb2_test(suite, "copy-chunk streams", test_copy_chunk_streams);
6283 torture_suite_add_1smb2_test(suite, "OS X AppleDouble file conversion", test_adouble_conversion);
6284 torture_suite_add_1smb2_test(suite, "NFS ACE entries", test_nfs_aces);
6285 torture_suite_add_1smb2_test(suite, "OS X AppleDouble file conversion without embedded xattr", test_adouble_conversion_wo_xattr);
6286 torture_suite_add_1smb2_test(suite, "empty_stream", test_empty_stream);
6287 torture_suite_add_1smb2_test(suite, "writing_afpinfo", test_writing_afpinfo);
6288
6289 return suite;
6290 }
6291
6292 static bool test_stream_names_local(struct torture_context *tctx,
6293 struct smb2_tree *tree)
6294 {
6295 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6296 NTSTATUS status;
6297 struct smb2_create create;
6298 struct smb2_handle h;
6299 const char *fname = BASEDIR "\\stream_names.txt";
6300 const char *sname1;
6301 bool ret;
6302 /* UTF8 private use are starts at 0xef 0x80 0x80 (0xf000) */
6303 const char *streams[] = {
6304 ":foo" "\xef\x80\xa2" "bar:$DATA", /* "foo:bar:$DATA" */
6305 ":bar" "\xef\x80\xa2" "baz:$DATA", /* "bar:baz:$DATA" */
6306 "::$DATA"
6307 };
6308 const char *localdir = NULL;
6309
6310 localdir = torture_setting_string(tctx, "localdir", NULL);
6311 if (localdir == NULL) {
6312 torture_skip(tctx, "Need localdir for test");
6313 }
6314
6315 sname1 = talloc_asprintf(mem_ctx, "%s%s", fname, streams[0]);
6316
6317 /* clean slate ...*/
6318 smb2_util_unlink(tree, fname);
6319 smb2_deltree(tree, fname);
6320 smb2_deltree(tree, BASEDIR);
6321
6322 status = torture_smb2_testdir(tree, BASEDIR, &h);
6323 CHECK_STATUS(status, NT_STATUS_OK);
6324 smb2_util_close(tree, h);
6325
6326 torture_comment(tctx, "(%s) testing stream names\n", __location__);
6327 ZERO_STRUCT(create);
6328 create.in.desired_access = SEC_FILE_WRITE_DATA;
6329 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
6330 create.in.share_access =
6331 NTCREATEX_SHARE_ACCESS_DELETE|
6332 NTCREATEX_SHARE_ACCESS_READ|
6333 NTCREATEX_SHARE_ACCESS_WRITE;
6334 create.in.create_disposition = NTCREATEX_DISP_CREATE;
6335 create.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
6336 create.in.fname = sname1;
6337
6338 status = smb2_create(tree, mem_ctx, &create);
6339 CHECK_STATUS(status, NT_STATUS_OK);
6340
6341 status = smb2_util_write(tree, create.out.file.handle, "foo", 0, 3);
6342 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6343 "smb2_util_write failed\n");
6344
6345 smb2_util_close(tree, create.out.file.handle);
6346
6347 ret = torture_setup_local_xattr(tctx, "localdir", BASEDIR "/stream_names.txt",
6348 "user.DosStream.bar:baz:$DATA",
6349 "data", strlen("data"));
6350 CHECK_VALUE(ret, true);
6351
6352 ret = check_stream_list(tree, tctx, fname, 3, streams, false);
6353 CHECK_VALUE(ret, true);
6354
6355 done:
6356 status = smb2_util_unlink(tree, fname);
6357 smb2_deltree(tree, BASEDIR);
6358 talloc_free(mem_ctx);
6359
6360 return ret;
6361 }
6362
6363 static bool test_fruit_locking_conflict(struct torture_context *tctx,
6364 struct smb2_tree *tree,
6365 struct smb2_tree *tree2)
6366 {
6367 TALLOC_CTX *mem_ctx;
6368 struct smb2_create create;
6369 struct smb2_handle h;
6370 struct smb2_lock lck;
6371 struct smb2_lock_element el;
6372 const char *fname = BASEDIR "\\locking_conflict.txt";
6373 NTSTATUS status;
6374 bool ret = false;
6375
6376 mem_ctx = talloc_new(tctx);
6377 torture_assert_not_null(tctx, mem_ctx, "talloc_new failed");
6378
6379 /* clean slate ...*/
6380 smb2_util_unlink(tree, fname);
6381 smb2_deltree(tree, fname);
6382 smb2_deltree(tree, BASEDIR);
6383
6384 status = torture_smb2_testdir(tree, BASEDIR, &h);
6385 CHECK_STATUS(status, NT_STATUS_OK);
6386 smb2_util_close(tree, h);
6387
6388 create = (struct smb2_create) {
6389 .in.desired_access = SEC_RIGHTS_FILE_READ,
6390 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
6391 .in.share_access =
6392 NTCREATEX_SHARE_ACCESS_READ|
6393 NTCREATEX_SHARE_ACCESS_WRITE,
6394 .in.create_disposition = NTCREATEX_DISP_CREATE,
6395 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
6396 .in.fname = fname,
6397 };
6398
6399 status = smb2_create(tree, mem_ctx, &create);
6400 CHECK_STATUS(status, NT_STATUS_OK);
6401 h = create.out.file.handle;
6402
6403 /* Add AD_FILELOCK_RSRC_DENY_WR lock. */
6404 el = (struct smb2_lock_element) {
6405 .offset = 0xfffffffffffffffc,
6406 .length = 1,
6407 .flags = SMB2_LOCK_FLAG_EXCLUSIVE,
6408 };
6409 lck = (struct smb2_lock) {
6410 .in.lock_count = 1,
6411 .in.file.handle = h,
6412 .in.locks = &el,
6413 };
6414
6415 /*
6416 * Lock up to and including:
6417 * AD_FILELOCK_OPEN_WR
6418 * AD_FILELOCK_OPEN_RD
6419 * This is designed to cause a NetAtalk
6420 * locking conflict on the next open,
6421 * even though the share modes are
6422 * compatible.
6423 */
6424 status = smb2_lock(tree, &lck);
6425 CHECK_STATUS(status, NT_STATUS_OK);
6426
6427 el = (struct smb2_lock_element) {
6428 .offset = 0,
6429 .length = 0x7ffffffffffffff7,
6430 .flags = SMB2_LOCK_FLAG_EXCLUSIVE,
6431 };
6432 status = smb2_lock(tree, &lck);
6433 CHECK_STATUS(status, NT_STATUS_OK);
6434
6435 create = (struct smb2_create) {
6436 .in.desired_access =
6437 SEC_RIGHTS_FILE_READ|SEC_RIGHTS_FILE_WRITE,
6438 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
6439 .in.share_access = NTCREATEX_SHARE_ACCESS_READ,
6440 .in.create_disposition = NTCREATEX_DISP_OPEN,
6441 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
6442 .in.fname = fname,
6443 };
6444
6445 /*
6446 * Open on the second tree - ensure we are
6447 * emulating trying to access with a NetATalk
6448 * process with an existing open/deny mode.
6449 */
6450 status = smb2_create(tree2, mem_ctx, &create);
6451 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
6452
6453 {
6454 struct smb2_close cl = {
6455 .level = RAW_CLOSE_SMB2,
6456 .in.file.handle = h,
6457 };
6458 smb2_close(tree, &cl);
6459 }
6460
6461 ret = true;
6462 done:
6463 return ret;
6464 }
6465
6466 struct torture_suite *torture_vfs_fruit_netatalk(TALLOC_CTX *ctx)
6467 {
6468 struct torture_suite *suite = torture_suite_create(
6469 ctx, "fruit_netatalk");
6470
6471 suite->description = talloc_strdup(suite, "vfs_fruit tests for Netatalk interop that require fruit:metadata=netatalk");
6472
6473 torture_suite_add_1smb2_test(suite, "read netatalk metadata", test_read_netatalk_metadata);
6474 torture_suite_add_1smb2_test(suite, "stream names with locally created xattr", test_stream_names_local);
6475 torture_suite_add_2smb2_test(
6476 suite, "locking conflict", test_fruit_locking_conflict);
6477
6478 return suite;
6479 }
6480
6481 struct torture_suite *torture_vfs_fruit_file_id(TALLOC_CTX *ctx)
6482 {
6483 struct torture_suite *suite =
6484 torture_suite_create(ctx, "fruit_file_id");
6485
6486 suite->description =
6487 talloc_strdup(suite, "vfs_fruit tests for on-disk file ID that "
6488 "require fruit:zero_file_id=yes");
6489
6490 torture_suite_add_1smb2_test(suite, "zero file id if AAPL negotiated",
6491 test_zero_file_id);
6492
6493 return suite;
6494 }
6495
6496 static bool test_timemachine_volsize(struct torture_context *tctx,
6497 struct smb2_tree *tree)
6498 {
6499 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6500 struct smb2_handle h = {{0}};
6501 union smb_fsinfo fsinfo;
6502 NTSTATUS status;
6503 bool ok = true;
6504 const char *info_plist =
6505 "<dict>\n"
6506 " <key>band-size</key>\n"
6507 " <integer>8192</integer>\n"
6508 "</dict>\n";
6509
6510 smb2_deltree(tree, "test.sparsebundle");
6511
6512 ok = enable_aapl(tctx, tree);
6513 torture_assert_goto(tctx, ok, ok, done, "enable_aapl failed");
6514
6515 status = smb2_util_mkdir(tree, "test.sparsebundle");
6516 torture_assert_ntstatus_ok_goto(tctx, status, ok, done,
6517 "smb2_util_mkdir\n");
6518
6519 ok = write_stream(tree, __location__, tctx, mem_ctx,
6520 "test.sparsebundle/Info.plist", NULL,
6521 0, strlen(info_plist), info_plist);
6522 torture_assert_goto(tctx, ok, ok, done, "write_stream failed\n");
6523
6524 status = smb2_util_mkdir(tree, "test.sparsebundle/bands");
6525 torture_assert_ntstatus_ok_goto(tctx, status, ok, done,
6526 "smb2_util_mkdir\n");
6527
6528 ok = torture_setup_file(tctx, tree, "test.sparsebundle/bands/1", false);
6529 torture_assert_goto(tctx, ok, ok, done, "torture_setup_file failed\n");
6530
6531 ok = torture_setup_file(tctx, tree, "test.sparsebundle/bands/2", false);
6532 torture_assert_goto(tctx, ok, ok, done, "torture_setup_file failed\n");
6533
6534 status = smb2_util_roothandle(tree, &h);
6535 torture_assert_ntstatus_ok(tctx, status, "Unable to create root handle");
6536
6537 ZERO_STRUCT(fsinfo);
6538 fsinfo.generic.level = RAW_QFS_SIZE_INFORMATION;
6539 fsinfo.generic.handle = h;
6540
6541 status = smb2_getinfo_fs(tree, tree, &fsinfo);
6542 torture_assert_ntstatus_ok(tctx, status, "smb2_getinfo_fs failed");
6543
6544 torture_comment(tctx, "sectors_per_unit: %" PRIu32"\n"
6545 "bytes_per_sector: %" PRIu32"\n"
6546 "total_alloc_units: %" PRIu64"\n"
6547 "avail_alloc_units: %" PRIu64"\n",
6548 fsinfo.size_info.out.sectors_per_unit,
6549 fsinfo.size_info.out.bytes_per_sector,
6550 fsinfo.size_info.out.total_alloc_units,
6551 fsinfo.size_info.out.avail_alloc_units);
6552
6553 /*
6554 * Let me explain the numbers:
6555 *
6556 * - the share is set to "fruit:time machine max size = 32K"
6557 * - we've faked a bandsize of 8 K in the Info.plist file
6558 * - we've created two bands files
6559 * - one allocation unit is made of two sectors with 512 B each
6560 * => we've consumed 16 allocation units, there should be 16 free
6561 */
6562
6563 torture_assert_goto(tctx, fsinfo.size_info.out.sectors_per_unit == 2,
6564 ok, done, "Bad sectors_per_unit");
6565
6566 torture_assert_goto(tctx, fsinfo.size_info.out.bytes_per_sector == 512,
6567 ok, done, "Bad bytes_per_sector");
6568
6569 torture_assert_goto(tctx, fsinfo.size_info.out.total_alloc_units == 32,
6570 ok, done, "Bad total_alloc_units");
6571
6572 torture_assert_goto(tctx, fsinfo.size_info.out.avail_alloc_units == 16,
6573 ok, done, "Bad avail_alloc_units");
6574
6575 done:
6576 if (!smb2_util_handle_empty(h)) {
6577 smb2_util_close(tree, h);
6578 }
6579 smb2_deltree(tree, "test.sparsebundle");
6580 talloc_free(mem_ctx);
6581 return ok;
6582 }
6583
6584 struct torture_suite *torture_vfs_fruit_timemachine(TALLOC_CTX *ctx)
6585 {
6586 struct torture_suite *suite = torture_suite_create(
6587 ctx, "fruit_timemachine");
6588
6589 suite->description = talloc_strdup(
6590 suite, "vfs_fruit tests for TimeMachine");
6591
6592 torture_suite_add_1smb2_test(suite, "Timemachine-volsize",
6593 test_timemachine_volsize);
6594
6595 return suite;
6596 }
6597
6598 static bool test_convert_xattr_and_empty_rfork_then_delete(
6599 struct torture_context *tctx,
6600 struct smb2_tree *tree1,
6601 struct smb2_tree *tree2)
6602 {
6603 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6604 const char *fname = BASEDIR "\\test_adouble_conversion";
6605 const char *adname = BASEDIR "/._test_adouble_conversion";
6606 const char *rfork = BASEDIR "\\test_adouble_conversion" AFPRESOURCE_STREAM_NAME;
6607 NTSTATUS status;
6608 struct smb2_handle testdirh;
6609 bool ret = true;
6610 const char *streams[] = {
6611 "::$DATA",
6612 AFPINFO_STREAM,
6613 ":com.apple.metadata" "\xef\x80\xa2" "_kMDItemUserTags:$DATA",
6614 ":foo" "\xef\x80\xa2" "bar:$DATA", /* "foo:bar:$DATA" */
6615 };
6616 struct smb2_create create;
6617 struct smb2_find find;
6618 unsigned int count;
6619 union smb_search_data *d;
6620 bool delete_empty_adfiles;
6621 int expected_num_files;
6622
6623 delete_empty_adfiles = torture_setting_bool(tctx,
6624 "delete_empty_adfiles",
6625 false);
6626
6627 smb2_deltree(tree1, BASEDIR);
6628
6629 status = torture_smb2_testdir(tree1, BASEDIR, &testdirh);
6630 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6631 "torture_smb2_testdir failed\n");
6632 smb2_util_close(tree1, testdirh);
6633
6634 ret = torture_setup_file(tctx, tree1, fname, false);
6635 torture_assert_goto(tctx, ret == true, ret, done,
6636 "torture_setup_file failed\n");
6637
6638 ret = torture_setup_file(tctx, tree1, adname, false);
6639 torture_assert_goto(tctx, ret == true, ret, done,
6640 "torture_setup_file failed\n");
6641
6642 ret = write_stream(tree1, __location__, tctx, mem_ctx,
6643 adname, NULL,
6644 0, sizeof(osx_adouble_w_xattr), osx_adouble_w_xattr);
6645 torture_assert_goto(tctx, ret == true, ret, done,
6646 "write_stream failed\n");
6647
6648 ret = enable_aapl(tctx, tree2);
6649 torture_assert_goto(tctx, ret == true, ret, done, "enable_aapl failed");
6650
6651 /*
6652 * Issue a smb2_find(), this triggers the server-side conversion
6653 */
6654
6655 create = (struct smb2_create) {
6656 .in.desired_access = SEC_RIGHTS_DIR_READ,
6657 .in.create_options = NTCREATEX_OPTIONS_DIRECTORY,
6658 .in.file_attributes = FILE_ATTRIBUTE_DIRECTORY,
6659 .in.share_access = NTCREATEX_SHARE_ACCESS_READ,
6660 .in.create_disposition = NTCREATEX_DISP_OPEN,
6661 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
6662 .in.fname = BASEDIR,
6663 };
6664
6665 status = smb2_create(tree2, tctx, &create);
6666 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6667 "smb2_create failed\n");
6668
6669 find = (struct smb2_find) {
6670 .in.file.handle = create.out.file.handle,
6671 .in.pattern = "*",
6672 .in.max_response_size = 0x1000,
6673 .in.level = SMB2_FIND_ID_BOTH_DIRECTORY_INFO,
6674 };
6675
6676 status = smb2_find_level(tree2, tree2, &find, &count, &d);
6677 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6678 "smb2_find_level failed\n");
6679
6680 status = smb2_util_close(tree2, create.out.file.handle);
6681 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6682 "smb2_util_close failed");
6683
6684 /*
6685 * Check number of streams
6686 */
6687
6688 ret = check_stream_list(tree2, tctx, fname, 4, streams, false);
6689 torture_assert_goto(tctx, ret == true, ret, done, "check_stream_list");
6690
6691 /*
6692 * Check Resource Fork is gone
6693 */
6694
6695 create = (struct smb2_create) {
6696 .in.desired_access = SEC_RIGHTS_FILE_READ|SEC_RIGHTS_FILE_WRITE,
6697 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
6698 .in.share_access = NTCREATEX_SHARE_ACCESS_READ,
6699 .in.create_disposition = NTCREATEX_DISP_OPEN,
6700 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
6701 .in.fname = rfork,
6702 };
6703
6704 status = smb2_create(tree2, mem_ctx, &create);
6705 torture_assert_ntstatus_equal_goto(
6706 tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
6707 ret, done, "Bad smb2_create return\n");
6708
6709 /*
6710 * Check xattr data has been migrated from the AppleDouble file to
6711 * streams.
6712 */
6713
6714 ret = check_stream(tree2, __location__, tctx, mem_ctx,
6715 fname, AFPINFO_STREAM,
6716 0, 60, 16, 8, "TESTSLOW");
6717 torture_assert_goto(tctx, ret == true, ret, done,
6718 "check AFPINFO_STREAM failed\n");
6719
6720 ret = check_stream(tree2, __location__, tctx, mem_ctx,
6721 fname, ":foo" "\xef\x80\xa2" "bar", /* foo:bar */
6722 0, 3, 0, 3, "baz");
6723 torture_assert_goto(tctx, ret == true, ret, done,
6724 "check foo stream failed\n");
6725
6726 /*
6727 * Now check number of files. If delete_empty_adfiles is set, the
6728 * AppleDouble files should have been deleted.
6729 */
6730
6731 create = (struct smb2_create) {
6732 .in.desired_access = SEC_RIGHTS_DIR_READ,
6733 .in.create_options = NTCREATEX_OPTIONS_DIRECTORY,
6734 .in.file_attributes = FILE_ATTRIBUTE_DIRECTORY,
6735 .in.share_access = NTCREATEX_SHARE_ACCESS_READ,
6736 .in.create_disposition = NTCREATEX_DISP_OPEN,
6737 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
6738 .in.fname = BASEDIR,
6739 };
6740
6741 status = smb2_create(tree2, tctx, &create);
6742 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6743 "smb2_create failed\n");
6744
6745 find = (struct smb2_find) {
6746 .in.file.handle = create.out.file.handle,
6747 .in.pattern = "*",
6748 .in.max_response_size = 0x1000,
6749 .in.level = SMB2_FIND_ID_BOTH_DIRECTORY_INFO,
6750 };
6751
6752 status = smb2_find_level(tree2, tree2, &find, &count, &d);
6753 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6754 "smb2_find_level failed\n");
6755
6756 status = smb2_util_close(tree2, create.out.file.handle);
6757 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6758 "smb2_util_close failed");
6759
6760 if (delete_empty_adfiles) {
6761 expected_num_files = 3;
6762 } else {
6763 expected_num_files = 4;
6764 }
6765 torture_assert_int_equal_goto(tctx, count, expected_num_files, ret, done,
6766 "Wrong number of files\n");
6767
6768 done:
6769 smb2_deltree(tree1, BASEDIR);
6770 talloc_free(mem_ctx);
6771 return ret;
6772 }
6773
6774 struct torture_suite *torture_vfs_fruit_conversion(TALLOC_CTX *ctx)
6775 {
6776 struct torture_suite *suite = torture_suite_create(
6777 ctx, "fruit_conversion");
6778
6779 suite->description = talloc_strdup(
6780 suite, "vfs_fruit conversion tests");
6781
6782 torture_suite_add_2ns_smb2_test(
6783 suite, "convert_xattr_and_empty_rfork_then_delete",
6784 test_convert_xattr_and_empty_rfork_then_delete);
6785
6786 return suite;
6787 }
Samba GIT mirror