?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lib/util: Build iov_buf library only when building samba
[Samba.git] / source4 / torture / raw / streams.c
blobc1e502ff23760f2a26f65aebc179445ace2e1d97
1 /*
2 Unix SMB/CIFS implementation.
3
4 test alternate data streams
5
6 Copyright (C) Andrew Tridgell 2004
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/locale.h"
24 #include "torture/torture.h"
25 #include "libcli/raw/libcliraw.h"
26 #include "libcli/security/dom_sid.h"
27 #include "libcli/security/security_descriptor.h"
28 #include "system/filesys.h"
29 #include "libcli/libcli.h"
30 #include "torture/util.h"
31 #include "lib/util/tsort.h"
32 #include "torture/raw/proto.h"
33
34 #define BASEDIR "\\teststreams"
35
36 #define CHECK_STATUS(status, correct) \
37 torture_assert_ntstatus_equal_goto(tctx,status,correct,ret,done,"CHECK_STATUS")
38
39 #define CHECK_VALUE(v, correct) \
40 torture_assert_int_equal(tctx,v,correct,"CHECK_VALUE")
41
42 #define CHECK_NTTIME(v, correct) \
43 torture_assert_u64_equal(tctx,v,correct,"CHECK_NTTIME")
44
45 #define CHECK_STR(v, correct) do { \
46 bool ok; \
47 if ((v) && !(correct)) { \
48 ok = false; \
49 } else if (!(v) && (correct)) { \
50 ok = false; \
51 } else if (!(v) && !(correct)) { \
52 ok = true; \
53 } else if (strcmp((v), (correct)) == 0) { \
54 ok = true; \
55 } else { \
56 ok = false; \
57 } \
58 torture_assert(tctx,ok,\
59 talloc_asprintf(tctx, "got '%s', expected '%s'",\
60 (v)?(v):"NULL", (correct)?(correct):"NULL")); \
61 } while (0)
62
63 /*
64 check that a stream has the right contents
65 */
66 static bool check_stream(struct smbcli_state *cli, const char *location,
67 TALLOC_CTX *mem_ctx,
68 const char *fname, const char *sname,
69 const char *value)
70 {
71 int fnum;
72 const char *full_name;
73 uint8_t *buf;
74 ssize_t ret;
75
76 full_name = talloc_asprintf(mem_ctx, "%s:%s", fname, sname);
77
78 fnum = smbcli_open(cli->tree, full_name, O_RDONLY, DENY_NONE);
79
80 if (value == NULL) {
81 if (fnum != -1) {
82 printf("(%s) should have failed stream open of %s\n",
83 location, full_name);
84 return false;
85 }
86 return true;
87 }
88
89 if (fnum == -1) {
90 printf("(%s) Failed to open stream '%s' - %s\n",
91 location, full_name, smbcli_errstr(cli->tree));
92 return false;
93 }
94
95 buf = talloc_array(mem_ctx, uint8_t, strlen(value)+11);
96
97 ret = smbcli_read(cli->tree, fnum, buf, 0, strlen(value)+11);
98 if (ret != strlen(value)) {
99 printf("(%s) Failed to read %lu bytes from stream '%s' - got %d\n",
100 location, (long)strlen(value), full_name, (int)ret);
101 return false;
102 }
103
104 if (memcmp(buf, value, strlen(value)) != 0) {
105 printf("(%s) Bad data in stream\n", location);
106 return false;
107 }
108
109 smbcli_close(cli->tree, fnum);
110 return true;
111 }
112
113 static int qsort_string(char * const *s1, char * const *s2)
114 {
115 return strcmp(*s1, *s2);
116 }
117
118 static int qsort_stream(const struct stream_struct *s1, const struct stream_struct *s2)
119 {
120 return strcmp(s1->stream_name.s, s2->stream_name.s);
121 }
122
123 static bool check_stream_list(struct torture_context *tctx,
124 struct smbcli_state *cli, const char *fname,
125 int num_exp, const char **exp)
126 {
127 union smb_fileinfo finfo;
128 NTSTATUS status;
129 int i;
130 TALLOC_CTX *tmp_ctx = talloc_new(cli);
131 char **exp_sort;
132 struct stream_struct *stream_sort;
133 bool ret = false;
134 int fail = -1;
135
136 finfo.generic.level = RAW_FILEINFO_STREAM_INFO;
137 finfo.generic.in.file.path = fname;
138
139 status = smb_raw_pathinfo(cli->tree, tmp_ctx, &finfo);
140 CHECK_STATUS(status, NT_STATUS_OK);
141
142 CHECK_VALUE(finfo.stream_info.out.num_streams, num_exp);
143
144 if (num_exp == 0) {
145 ret = true;
146 goto done;
147 }
148
149 exp_sort = (char **)talloc_memdup(tmp_ctx, exp, num_exp * sizeof(*exp));
150
151 if (exp_sort == NULL) {
152 goto done;
153 }
154
155 TYPESAFE_QSORT(exp_sort, num_exp, qsort_string);
156
157 stream_sort = (struct stream_struct *)talloc_memdup(tmp_ctx,
158 finfo.stream_info.out.streams,
159 finfo.stream_info.out.num_streams *
160 sizeof(*stream_sort));
161
162 if (stream_sort == NULL) {
163 goto done;
164 }
165
166 TYPESAFE_QSORT(stream_sort, finfo.stream_info.out.num_streams, qsort_stream);
167
168 for (i=0; i<num_exp; i++) {
169 if (strcmp(exp_sort[i], stream_sort[i].stream_name.s) != 0) {
170 fail = i;
171 goto show_streams;
172 }
173 }
174
175 ret = true;
176 done:
177 talloc_free(tmp_ctx);
178 return ret;
179
180 show_streams:
181 for (i=0; i<num_exp; i++) {
182 torture_comment(tctx, "stream names '%s' '%s'\n",
183 exp_sort[i], stream_sort[i].stream_name.s);
184 }
185 CHECK_STR(stream_sort[fail].stream_name.s, exp_sort[fail]);
186 talloc_free(tmp_ctx);
187 return ret;
188 }
189
190 /*
191 test bahavior of streams on directories
192 */
193 static bool test_stream_dir(struct torture_context *tctx,
194 struct smbcli_state *cli)
195 {
196 NTSTATUS status;
197 union smb_open io;
198 const char *fname = BASEDIR "\\stream.txt";
199 const char *sname1;
200 bool ret = true;
201 const char *basedir_data;
202
203 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
204
205 basedir_data = talloc_asprintf(tctx, "%s::$DATA", BASEDIR);
206 sname1 = talloc_asprintf(tctx, "%s:%s", fname, "Stream One");
207
208 printf("(%s) opening non-existent directory stream\n", __location__);
209 io.generic.level = RAW_OPEN_NTCREATEX;
210 io.ntcreatex.in.root_fid.fnum = 0;
211 io.ntcreatex.in.flags = 0;
212 io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
213 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
214 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
215 io.ntcreatex.in.share_access = 0;
216 io.ntcreatex.in.alloc_size = 0;
217 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
218 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
219 io.ntcreatex.in.security_flags = 0;
220 io.ntcreatex.in.fname = sname1;
221 status = smb_raw_open(cli->tree, tctx, &io);
222 CHECK_STATUS(status, NT_STATUS_NOT_A_DIRECTORY);
223
224 printf("(%s) opening basedir stream\n", __location__);
225 io.generic.level = RAW_OPEN_NTCREATEX;
226 io.ntcreatex.in.root_fid.fnum = 0;
227 io.ntcreatex.in.flags = 0;
228 io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
229 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
230 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_DIRECTORY;
231 io.ntcreatex.in.share_access = 0;
232 io.ntcreatex.in.alloc_size = 0;
233 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
234 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
235 io.ntcreatex.in.security_flags = 0;
236 io.ntcreatex.in.fname = basedir_data;
237 status = smb_raw_open(cli->tree, tctx, &io);
238 CHECK_STATUS(status, NT_STATUS_NOT_A_DIRECTORY);
239
240 printf("(%s) opening basedir ::$DATA stream\n", __location__);
241 io.generic.level = RAW_OPEN_NTCREATEX;
242 io.ntcreatex.in.root_fid.fnum = 0;
243 io.ntcreatex.in.flags = 0x10;
244 io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
245 io.ntcreatex.in.create_options = 0;
246 io.ntcreatex.in.file_attr = 0;
247 io.ntcreatex.in.share_access = 0;
248 io.ntcreatex.in.alloc_size = 0;
249 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
250 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
251 io.ntcreatex.in.security_flags = 0;
252 io.ntcreatex.in.fname = basedir_data;
253 status = smb_raw_open(cli->tree, tctx, &io);
254 CHECK_STATUS(status, NT_STATUS_FILE_IS_A_DIRECTORY);
255
256 printf("(%s) list the streams on the basedir\n", __location__);
257 ret &= check_stream_list(tctx, cli, BASEDIR, 0, NULL);
258 done:
259 smbcli_deltree(cli->tree, BASEDIR);
260 return ret;
261 }
262
263 /*
264 test basic behavior of streams on directories
265 */
266 static bool test_stream_io(struct torture_context *tctx,
267 struct smbcli_state *cli)
268 {
269 NTSTATUS status;
270 union smb_open io;
271 const char *fname = BASEDIR "\\stream.txt";
272 const char *sname1, *sname2;
273 bool ret = true;
274 int fnum = -1;
275 ssize_t retsize;
276
277 const char *one[] = { "::$DATA" };
278 const char *two[] = { "::$DATA", ":Second Stream:$DATA" };
279 const char *three[] = { "::$DATA", ":Stream One:$DATA",
280 ":Second Stream:$DATA" };
281
282 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
283
284 sname1 = talloc_asprintf(tctx, "%s:%s", fname, "Stream One");
285 sname2 = talloc_asprintf(tctx, "%s:%s:$DaTa", fname, "Second Stream");
286
287 printf("(%s) creating a stream on a non-existent file\n", __location__);
288 io.generic.level = RAW_OPEN_NTCREATEX;
289 io.ntcreatex.in.root_fid.fnum = 0;
290 io.ntcreatex.in.flags = 0;
291 io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
292 io.ntcreatex.in.create_options = 0;
293 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
294 io.ntcreatex.in.share_access = 0;
295 io.ntcreatex.in.alloc_size = 0;
296 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
297 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
298 io.ntcreatex.in.security_flags = 0;
299 io.ntcreatex.in.fname = sname1;
300 status = smb_raw_open(cli->tree, tctx, &io);
301 CHECK_STATUS(status, NT_STATUS_OK);
302 fnum = io.ntcreatex.out.file.fnum;
303
304 ret &= check_stream(cli, __location__, tctx, fname, "Stream One", NULL);
305
306 printf("(%s) check that open of base file is allowed\n", __location__);
307 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
308 io.ntcreatex.in.fname = fname;
309 status = smb_raw_open(cli->tree, tctx, &io);
310 CHECK_STATUS(status, NT_STATUS_OK);
311 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
312
313 printf("(%s) writing to stream\n", __location__);
314 retsize = smbcli_write(cli->tree, fnum, 0, "test data", 0, 9);
315 CHECK_VALUE(retsize, 9);
316
317 smbcli_close(cli->tree, fnum);
318
319 ret &= check_stream(cli, __location__, tctx, fname, "Stream One", "test data");
320
321 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
322 io.ntcreatex.in.fname = sname1;
323 status = smb_raw_open(cli->tree, tctx, &io);
324 CHECK_STATUS(status, NT_STATUS_OK);
325 fnum = io.ntcreatex.out.file.fnum;
326
327 printf("(%s) modifying stream\n", __location__);
328 retsize = smbcli_write(cli->tree, fnum, 0, "MORE DATA ", 5, 10);
329 CHECK_VALUE(retsize, 10);
330
331 smbcli_close(cli->tree, fnum);
332
333 ret &= check_stream(cli, __location__, tctx, fname, "Stream One:$FOO", NULL);
334
335 printf("(%s) creating a stream2 on a existing file\n", __location__);
336 io.ntcreatex.in.fname = sname2;
337 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
338 status = smb_raw_open(cli->tree, tctx, &io);
339 CHECK_STATUS(status, NT_STATUS_OK);
340 fnum = io.ntcreatex.out.file.fnum;
341
342 printf("(%s) modifying stream\n", __location__);
343 retsize = smbcli_write(cli->tree, fnum, 0, "SECOND STREAM", 0, 13);
344 CHECK_VALUE(retsize, 13);
345
346 smbcli_close(cli->tree, fnum);
347
348 ret &= check_stream(cli, __location__, tctx, fname, "Stream One", "test MORE DATA ");
349 ret &= check_stream(cli, __location__, tctx, fname, "Stream One:$DATA", "test MORE DATA ");
350 ret &= check_stream(cli, __location__, tctx, fname, "Stream One:", NULL);
351 ret &= check_stream(cli, __location__, tctx, fname, "Second Stream", "SECOND STREAM");
352 ret &= check_stream(cli, __location__, tctx, fname,
353 "SECOND STREAM:$DATA", "SECOND STREAM");
354 ret &= check_stream(cli, __location__, tctx, fname, "Second Stream:$DATA", "SECOND STREAM");
355 ret &= check_stream(cli, __location__, tctx, fname, "Second Stream:", NULL);
356 ret &= check_stream(cli, __location__, tctx, fname, "Second Stream:$FOO", NULL);
357
358 check_stream_list(tctx, cli, fname, 3, three);
359
360 printf("(%s) deleting stream\n", __location__);
361 status = smbcli_unlink(cli->tree, sname1);
362 CHECK_STATUS(status, NT_STATUS_OK);
363
364 check_stream_list(tctx, cli, fname, 2, two);
365
366 printf("(%s) delete a stream via delete-on-close\n", __location__);
367 io.ntcreatex.in.fname = sname2;
368 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
369 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE;
370 io.ntcreatex.in.access_mask = SEC_STD_DELETE;
371 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
372
373 status = smb_raw_open(cli->tree, tctx, &io);
374 CHECK_STATUS(status, NT_STATUS_OK);
375 fnum = io.ntcreatex.out.file.fnum;
376
377 smbcli_close(cli->tree, fnum);
378 status = smbcli_unlink(cli->tree, sname2);
379 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
380
381 check_stream_list(tctx, cli, fname, 1, one);
382
383 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
384 io.ntcreatex.in.fname = sname1;
385 status = smb_raw_open(cli->tree, tctx, &io);
386 CHECK_STATUS(status, NT_STATUS_OK);
387 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
388 io.ntcreatex.in.fname = sname2;
389 status = smb_raw_open(cli->tree, tctx, &io);
390 CHECK_STATUS(status, NT_STATUS_OK);
391 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
392
393 printf("(%s) deleting file\n", __location__);
394 status = smbcli_unlink(cli->tree, fname);
395 CHECK_STATUS(status, NT_STATUS_OK);
396
397 done:
398 smbcli_close(cli->tree, fnum);
399 smbcli_deltree(cli->tree, BASEDIR);
400 return ret;
401 }
402
403 /*
404 test stream sharemodes
405 */
406 static bool test_stream_sharemodes(struct torture_context *tctx,
407 struct smbcli_state *cli)
408 {
409 NTSTATUS status;
410 union smb_open io;
411 const char *fname = BASEDIR "\\stream.txt";
412 const char *sname1, *sname2;
413 bool ret = true;
414 int fnum1 = -1;
415 int fnum2 = -1;
416
417 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
418
419 sname1 = talloc_asprintf(tctx, "%s:%s", fname, "Stream One");
420 sname2 = talloc_asprintf(tctx, "%s:%s:$DaTa", fname, "Second Stream");
421
422 printf("(%s) testing stream share mode conflicts\n", __location__);
423 io.generic.level = RAW_OPEN_NTCREATEX;
424 io.ntcreatex.in.root_fid.fnum = 0;
425 io.ntcreatex.in.flags = 0;
426 io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
427 io.ntcreatex.in.create_options = 0;
428 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
429 io.ntcreatex.in.share_access = 0;
430 io.ntcreatex.in.alloc_size = 0;
431 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
432 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
433 io.ntcreatex.in.security_flags = 0;
434 io.ntcreatex.in.fname = sname1;
435
436 status = smb_raw_open(cli->tree, tctx, &io);
437 CHECK_STATUS(status, NT_STATUS_OK);
438 fnum1 = io.ntcreatex.out.file.fnum;
439
440 /*
441 * A different stream does not give a sharing violation
442 */
443
444 io.ntcreatex.in.fname = sname2;
445 status = smb_raw_open(cli->tree, tctx, &io);
446 CHECK_STATUS(status, NT_STATUS_OK);
447 fnum2 = io.ntcreatex.out.file.fnum;
448
449 /*
450 * ... whereas the same stream does with unchanged access/share_access
451 * flags
452 */
453
454 io.ntcreatex.in.fname = sname1;
455 io.ntcreatex.in.open_disposition = 0;
456 status = smb_raw_open(cli->tree, tctx, &io);
457 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
458
459 io.ntcreatex.in.fname = sname2;
460 status = smb_raw_open(cli->tree, tctx, &io);
461 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
462
463 done:
464 if (fnum1 != -1) smbcli_close(cli->tree, fnum1);
465 if (fnum2 != -1) smbcli_close(cli->tree, fnum2);
466 status = smbcli_unlink(cli->tree, fname);
467 smbcli_deltree(cli->tree, BASEDIR);
468 return ret;
469 }
470
471 /*
472 * Test FILE_SHARE_DELETE on streams
473 *
474 * A stream opened with !FILE_SHARE_DELETE prevents the main file to be opened
475 * with SEC_STD_DELETE.
476 *
477 * The main file opened with !FILE_SHARE_DELETE does *not* prevent a stream to
478 * be opened with SEC_STD_DELETE.
479 *
480 * A stream held open with FILE_SHARE_DELETE allows the file to be
481 * deleted. After the main file is deleted, access to the open file descriptor
482 * still works, but all name-based access to both the main file as well as the
483 * stream is denied with DELETE pending.
484 *
485 * This means, an open of the main file with SEC_STD_DELETE should walk all
486 * streams and also open them with SEC_STD_DELETE. If any of these opens gives
487 * SHARING_VIOLATION, the main open fails.
488 *
489 * Closing the main file after delete_on_close has been set does not really
490 * unlink it but leaves the corresponding share mode entry with
491 * delete_on_close being set around until all streams are closed.
492 *
493 * Opening a stream must also look at the main file's share mode entry, look
494 * at the delete_on_close bit and potentially return DELETE_PENDING.
495 */
496
497 static bool test_stream_delete(struct torture_context *tctx,
498 struct smbcli_state *cli)
499 {
500 NTSTATUS status;
501 union smb_open io;
502 const char *fname = BASEDIR "\\stream.txt";
503 const char *sname1;
504 bool ret = true;
505 int fnum = -1;
506 uint8_t buf[9];
507 ssize_t retsize;
508 union smb_fileinfo finfo;
509
510 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
511
512 sname1 = talloc_asprintf(tctx, "%s:%s", fname, "Stream One");
513
514 printf("(%s) opening non-existent file stream\n", __location__);
515 io.generic.level = RAW_OPEN_NTCREATEX;
516 io.ntcreatex.in.root_fid.fnum = 0;
517 io.ntcreatex.in.flags = 0;
518 io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA;
519 io.ntcreatex.in.create_options = 0;
520 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
521 io.ntcreatex.in.share_access = 0;
522 io.ntcreatex.in.alloc_size = 0;
523 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
524 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
525 io.ntcreatex.in.security_flags = 0;
526 io.ntcreatex.in.fname = sname1;
527
528 status = smb_raw_open(cli->tree, tctx, &io);
529 CHECK_STATUS(status, NT_STATUS_OK);
530 fnum = io.ntcreatex.out.file.fnum;
531
532 retsize = smbcli_write(cli->tree, fnum, 0, "test data", 0, 9);
533 CHECK_VALUE(retsize, 9);
534
535 /*
536 * One stream opened without FILE_SHARE_DELETE prevents the main file
537 * to be deleted or even opened with DELETE access
538 */
539
540 status = smbcli_unlink(cli->tree, fname);
541 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
542
543 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
544 io.ntcreatex.in.fname = fname;
545 io.ntcreatex.in.access_mask = SEC_STD_DELETE;
546 status = smb_raw_open(cli->tree, tctx, &io);
547 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
548
549 smbcli_close(cli->tree, fnum);
550
551 /*
552 * ... but unlink works if a stream is opened with FILE_SHARE_DELETE
553 */
554
555 io.ntcreatex.in.fname = sname1;
556 io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA;
557 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE;
558 status = smb_raw_open(cli->tree, tctx, &io);
559 CHECK_STATUS(status, NT_STATUS_OK);
560 fnum = io.ntcreatex.out.file.fnum;
561
562 status = smbcli_unlink(cli->tree, fname);
563 CHECK_STATUS(status, NT_STATUS_OK);
564
565 /*
566 * file access still works on the stream while the main file is closed
567 */
568
569 retsize = smbcli_read(cli->tree, fnum, buf, 0, 9);
570 CHECK_VALUE(retsize, 9);
571
572 finfo.generic.level = RAW_FILEINFO_STANDARD;
573 finfo.generic.in.file.path = fname;
574
575 /*
576 * name-based access to both the main file and the stream does not
577 * work anymore but gives DELETE_PENDING
578 */
579
580 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
581 CHECK_STATUS(status, NT_STATUS_DELETE_PENDING);
582
583 /*
584 * older S3 doesn't do this
585 */
586 finfo.generic.in.file.path = sname1;
587 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
588 CHECK_STATUS(status, NT_STATUS_DELETE_PENDING);
589
590 /*
591 * fd-based qfileinfo on the stream still works, the stream does not
592 * have the delete-on-close bit set. This could mean that open on the
593 * stream first opens the main file
594 */
595
596 finfo.all_info.level = RAW_FILEINFO_ALL_INFO;
597 finfo.all_info.in.file.fnum = fnum;
598
599 status = smb_raw_fileinfo(cli->tree, tctx, &finfo);
600 CHECK_STATUS(status, NT_STATUS_OK);
601
602 /* w2k and w2k3 return 0 and w2k8 returns 1 */
603 if (TARGET_IS_WINXP(tctx) || TARGET_IS_W2K3(tctx) ||
604 TARGET_IS_SAMBA3(tctx)) {
605 CHECK_VALUE(finfo.all_info.out.delete_pending, 0);
606 } else {
607 CHECK_VALUE(finfo.all_info.out.delete_pending, 1);
608 }
609
610 smbcli_close(cli->tree, fnum);
611
612 /*
613 * After closing the stream the file is really gone.
614 */
615
616 finfo.generic.in.file.path = fname;
617 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
618 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
619
620 io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA
621 |SEC_STD_DELETE;
622 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
623 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
624 status = smb_raw_open(cli->tree, tctx, &io);
625 CHECK_STATUS(status, NT_STATUS_OK);
626 fnum = io.ntcreatex.out.file.fnum;
627
628 finfo.generic.in.file.path = fname;
629 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
630 CHECK_STATUS(status, NT_STATUS_OK);
631
632 smbcli_close(cli->tree, fnum);
633
634 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
635 CHECK_STATUS(status, NT_STATUS_OK);
636 done:
637 smbcli_close(cli->tree, fnum);
638 smbcli_unlink(cli->tree, fname);
639 smbcli_deltree(cli->tree, BASEDIR);
640 return ret;
641 }
642
643 /*
644 test stream names
645 */
646 static bool test_stream_names(struct torture_context *tctx,
647 struct smbcli_state *cli)
648 {
649 NTSTATUS status;
650 union smb_open io;
651 union smb_fileinfo info;
652 union smb_fileinfo finfo;
653 union smb_fileinfo stinfo;
654 union smb_setfileinfo sinfo;
655 const char *fname = BASEDIR "\\stream_names.txt";
656 const char *sname1, *sname1b, *sname1c, *sname1d;
657 const char *sname2, *snamew, *snamew2;
658 const char *snamer1, *snamer2;
659 bool ret = true;
660 int fnum1 = -1;
661 int fnum2 = -1;
662 int fnum3 = -1;
663 int i;
664 const char *four[4] = {
665 "::$DATA",
666 ":\x05Stream\n One:$DATA",
667 ":MStream Two:$DATA",
668 ":?Stream*:$DATA"
669 };
670 const char *five1[5] = {
671 "::$DATA",
672 ":\x05Stream\n One:$DATA",
673 ":BeforeRename:$DATA",
674 ":MStream Two:$DATA",
675 ":?Stream*:$DATA"
676 };
677 const char *five2[5] = {
678 "::$DATA",
679 ":\x05Stream\n One:$DATA",
680 ":AfterRename:$DATA",
681 ":MStream Two:$DATA",
682 ":?Stream*:$DATA"
683 };
684
685 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
686
687 sname1 = talloc_asprintf(tctx, "%s:%s", fname, "\x05Stream\n One");
688 sname1b = talloc_asprintf(tctx, "%s:", sname1);
689 sname1c = talloc_asprintf(tctx, "%s:$FOO", sname1);
690 sname1d = talloc_asprintf(tctx, "%s:?D*a", sname1);
691 sname2 = talloc_asprintf(tctx, "%s:%s:$DaTa", fname, "MStream Two");
692 snamew = talloc_asprintf(tctx, "%s:%s:$DATA", fname, "?Stream*");
693 snamew2 = talloc_asprintf(tctx, "%s\\stream*:%s:$DATA", BASEDIR, "?Stream*");
694 snamer1 = talloc_asprintf(tctx, "%s:%s:$DATA", fname, "BeforeRename");
695 snamer2 = talloc_asprintf(tctx, "%s:%s:$DATA", fname, "AfterRename");
696
697 printf("(%s) testing stream names\n", __location__);
698 io.generic.level = RAW_OPEN_NTCREATEX;
699 io.ntcreatex.in.root_fid.fnum = 0;
700 io.ntcreatex.in.flags = 0;
701 io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
702 io.ntcreatex.in.create_options = 0;
703 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
704 io.ntcreatex.in.share_access =
705 NTCREATEX_SHARE_ACCESS_READ |
706 NTCREATEX_SHARE_ACCESS_WRITE;
707 io.ntcreatex.in.alloc_size = 0;
708 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
709 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
710 io.ntcreatex.in.security_flags = 0;
711 io.ntcreatex.in.fname = fname;
712
713 status = smb_raw_open(cli->tree, tctx, &io);
714 CHECK_STATUS(status, NT_STATUS_OK);
715 fnum1 = io.ntcreatex.out.file.fnum;
716
717 torture_comment(tctx, "Adding two EAs to base file\n");
718 ZERO_STRUCT(sinfo);
719 sinfo.generic.level = RAW_SFILEINFO_EA_SET;
720 sinfo.generic.in.file.fnum = fnum1;
721 sinfo.ea_set.in.num_eas = 2;
722 sinfo.ea_set.in.eas = talloc_array(tctx, struct ea_struct, 2);
723 sinfo.ea_set.in.eas[0].flags = 0;
724 sinfo.ea_set.in.eas[0].name.s = "EAONE";
725 sinfo.ea_set.in.eas[0].value = data_blob_string_const("VALUE1");
726 sinfo.ea_set.in.eas[1].flags = 0;
727 sinfo.ea_set.in.eas[1].name.s = "SECONDEA";
728 sinfo.ea_set.in.eas[1].value = data_blob_string_const("ValueTwo");
729
730 status = smb_raw_setfileinfo(cli->tree, &sinfo);
731 CHECK_STATUS(status, NT_STATUS_OK);
732
733 /*
734 * Make sure the create time of the streams are different from the
735 * base file.
736 */
737 sleep(2);
738 smbcli_close(cli->tree, fnum1);
739
740 io.generic.level = RAW_OPEN_NTCREATEX;
741 io.ntcreatex.in.root_fid.fnum = 0;
742 io.ntcreatex.in.flags = 0;
743 io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
744 io.ntcreatex.in.create_options = 0;
745 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
746 io.ntcreatex.in.share_access =
747 NTCREATEX_SHARE_ACCESS_READ |
748 NTCREATEX_SHARE_ACCESS_WRITE;
749 io.ntcreatex.in.alloc_size = 0;
750 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
751 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
752 io.ntcreatex.in.security_flags = 0;
753 io.ntcreatex.in.fname = sname1;
754
755 status = smb_raw_open(cli->tree, tctx, &io);
756 CHECK_STATUS(status, NT_STATUS_OK);
757 fnum1 = io.ntcreatex.out.file.fnum;
758
759 torture_comment(tctx, "Adding one EAs to first stream file\n");
760 ZERO_STRUCT(sinfo);
761 sinfo.generic.level = RAW_SFILEINFO_EA_SET;
762 sinfo.generic.in.file.fnum = fnum1;
763 sinfo.ea_set.in.num_eas = 1;
764 sinfo.ea_set.in.eas = talloc_array(tctx, struct ea_struct, 1);
765 sinfo.ea_set.in.eas[0].flags = 0;
766 sinfo.ea_set.in.eas[0].name.s = "STREAMEA";
767 sinfo.ea_set.in.eas[0].value = data_blob_string_const("EA_VALUE1");
768
769 status = smb_raw_setfileinfo(cli->tree, &sinfo);
770 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
771
772 status = torture_check_ea(cli, sname1, "STREAMEA", "EA_VALUE1");
773 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
774
775 ZERO_STRUCT(info);
776 info.generic.level = RAW_FILEINFO_ALL_EAS;
777 info.all_eas.in.file.path = sname1;
778
779 status = smb_raw_pathinfo(cli->tree, tctx, &info);
780 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
781
782 /*
783 * A different stream does not give a sharing violation
784 */
785
786 io.ntcreatex.in.fname = sname2;
787 status = smb_raw_open(cli->tree, tctx, &io);
788 CHECK_STATUS(status, NT_STATUS_OK);
789 fnum2 = io.ntcreatex.out.file.fnum;
790
791 /*
792 * ... whereas the same stream does with unchanged access/share_access
793 * flags
794 */
795
796 io.ntcreatex.in.fname = sname1;
797 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_SUPERSEDE;
798 status = smb_raw_open(cli->tree, tctx, &io);
799 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
800
801 io.ntcreatex.in.fname = sname1b;
802 status = smb_raw_open(cli->tree, tctx, &io);
803 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
804
805 io.ntcreatex.in.fname = sname1c;
806 status = smb_raw_open(cli->tree, tctx, &io);
807 if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
808 /* w2k returns INVALID_PARAMETER */
809 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
810 } else {
811 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
812 }
813
814 io.ntcreatex.in.fname = sname1d;
815 status = smb_raw_open(cli->tree, tctx, &io);
816 if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
817 /* w2k returns INVALID_PARAMETER */
818 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
819 } else {
820 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
821 }
822
823 io.ntcreatex.in.fname = sname2;
824 status = smb_raw_open(cli->tree, tctx, &io);
825 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
826
827 io.ntcreatex.in.fname = snamew;
828 status = smb_raw_open(cli->tree, tctx, &io);
829 CHECK_STATUS(status, NT_STATUS_OK);
830 fnum3 = io.ntcreatex.out.file.fnum;
831
832 io.ntcreatex.in.fname = snamew2;
833 status = smb_raw_open(cli->tree, tctx, &io);
834 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
835
836 ret &= check_stream_list(tctx, cli, fname, 4, four);
837
838 smbcli_close(cli->tree, fnum1);
839 smbcli_close(cli->tree, fnum2);
840 smbcli_close(cli->tree, fnum3);
841
842 finfo.generic.level = RAW_FILEINFO_ALL_INFO;
843 finfo.generic.in.file.path = fname;
844 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
845 CHECK_STATUS(status, NT_STATUS_OK);
846
847 ret &= check_stream_list(tctx, cli, fname, 4, four);
848
849 for (i=0; i < 4; i++) {
850 NTTIME write_time;
851 uint64_t stream_size;
852 char *path = talloc_asprintf(tctx, "%s%s",
853 fname, four[i]);
854
855 char *rpath = talloc_strdup(path, path);
856 char *p = strrchr(rpath, ':');
857 /* eat :$DATA */
858 *p = 0;
859 p--;
860 if (*p == ':') {
861 /* eat ::$DATA */
862 *p = 0;
863 }
864 printf("(%s): i[%u][%s]\n", __location__, i, path);
865 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
866 io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE |
867 SEC_FILE_WRITE_ATTRIBUTE |
868 SEC_RIGHTS_FILE_ALL;
869 io.ntcreatex.in.fname = path;
870 status = smb_raw_open(cli->tree, tctx, &io);
871 CHECK_STATUS(status, NT_STATUS_OK);
872 fnum1 = io.ntcreatex.out.file.fnum;
873
874 finfo.generic.level = RAW_FILEINFO_ALL_INFO;
875 finfo.generic.in.file.path = fname;
876 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
877 CHECK_STATUS(status, NT_STATUS_OK);
878
879 stinfo.generic.level = RAW_FILEINFO_ALL_INFO;
880 stinfo.generic.in.file.fnum = fnum1;
881 status = smb_raw_fileinfo(cli->tree, tctx, &stinfo);
882 CHECK_STATUS(status, NT_STATUS_OK);
883 if (!torture_setting_bool(tctx, "samba3", false)) {
884 CHECK_NTTIME(stinfo.all_info.out.create_time,
885 finfo.all_info.out.create_time);
886 CHECK_NTTIME(stinfo.all_info.out.access_time,
887 finfo.all_info.out.access_time);
888 CHECK_NTTIME(stinfo.all_info.out.write_time,
889 finfo.all_info.out.write_time);
890 CHECK_NTTIME(stinfo.all_info.out.change_time,
891 finfo.all_info.out.change_time);
892 }
893 CHECK_VALUE(stinfo.all_info.out.attrib,
894 finfo.all_info.out.attrib);
895 CHECK_VALUE(stinfo.all_info.out.size,
896 finfo.all_info.out.size);
897 CHECK_VALUE(stinfo.all_info.out.delete_pending,
898 finfo.all_info.out.delete_pending);
899 CHECK_VALUE(stinfo.all_info.out.directory,
900 finfo.all_info.out.directory);
901 CHECK_VALUE(stinfo.all_info.out.ea_size,
902 finfo.all_info.out.ea_size);
903
904 stinfo.generic.level = RAW_FILEINFO_NAME_INFO;
905 stinfo.generic.in.file.fnum = fnum1;
906 status = smb_raw_fileinfo(cli->tree, tctx, &stinfo);
907 CHECK_STATUS(status, NT_STATUS_OK);
908 if (!torture_setting_bool(tctx, "samba3", false)) {
909 CHECK_STR(stinfo.name_info.out.fname.s, rpath);
910 }
911
912 write_time = finfo.all_info.out.write_time;
913 write_time += i*1000000;
914 write_time /= 1000000;
915 write_time *= 1000000;
916
917 ZERO_STRUCT(sinfo);
918 sinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO;
919 sinfo.basic_info.in.file.fnum = fnum1;
920 sinfo.basic_info.in.write_time = write_time;
921 sinfo.basic_info.in.attrib = stinfo.all_info.out.attrib;
922 status = smb_raw_setfileinfo(cli->tree, &sinfo);
923 CHECK_STATUS(status, NT_STATUS_OK);
924
925 stream_size = i*8192;
926
927 ZERO_STRUCT(sinfo);
928 sinfo.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFO;
929 sinfo.end_of_file_info.in.file.fnum = fnum1;
930 sinfo.end_of_file_info.in.size = stream_size;
931 status = smb_raw_setfileinfo(cli->tree, &sinfo);
932 CHECK_STATUS(status, NT_STATUS_OK);
933
934 stinfo.generic.level = RAW_FILEINFO_ALL_INFO;
935 stinfo.generic.in.file.fnum = fnum1;
936 status = smb_raw_fileinfo(cli->tree, tctx, &stinfo);
937 CHECK_STATUS(status, NT_STATUS_OK);
938 if (!torture_setting_bool(tctx, "samba3", false)) {
939 CHECK_NTTIME(stinfo.all_info.out.write_time,
940 write_time);
941 CHECK_VALUE(stinfo.all_info.out.attrib,
942 finfo.all_info.out.attrib);
943 }
944 CHECK_VALUE(stinfo.all_info.out.size,
945 stream_size);
946 CHECK_VALUE(stinfo.all_info.out.delete_pending,
947 finfo.all_info.out.delete_pending);
948 CHECK_VALUE(stinfo.all_info.out.directory,
949 finfo.all_info.out.directory);
950 CHECK_VALUE(stinfo.all_info.out.ea_size,
951 finfo.all_info.out.ea_size);
952
953 ret &= check_stream_list(tctx, cli, fname, 4, four);
954
955 smbcli_close(cli->tree, fnum1);
956 talloc_free(path);
957 }
958
959 printf("(%s): testing stream renames\n", __location__);
960 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
961 io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE |
962 SEC_FILE_WRITE_ATTRIBUTE |
963 SEC_RIGHTS_FILE_ALL;
964 io.ntcreatex.in.fname = snamer1;
965 status = smb_raw_open(cli->tree, tctx, &io);
966 CHECK_STATUS(status, NT_STATUS_OK);
967 fnum1 = io.ntcreatex.out.file.fnum;
968
969 ret &= check_stream_list(tctx, cli, fname, 5, five1);
970
971 ZERO_STRUCT(sinfo);
972 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
973 sinfo.rename_information.in.file.fnum = fnum1;
974 sinfo.rename_information.in.overwrite = true;
975 sinfo.rename_information.in.root_fid = 0;
976 sinfo.rename_information.in.new_name = ":AfterRename:$DATA";
977 status = smb_raw_setfileinfo(cli->tree, &sinfo);
978 CHECK_STATUS(status, NT_STATUS_OK);
979
980 ret &= check_stream_list(tctx, cli, fname, 5, five2);
981
982 ZERO_STRUCT(sinfo);
983 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
984 sinfo.rename_information.in.file.fnum = fnum1;
985 sinfo.rename_information.in.overwrite = false;
986 sinfo.rename_information.in.root_fid = 0;
987 sinfo.rename_information.in.new_name = ":MStream Two:$DATA";
988 status = smb_raw_setfileinfo(cli->tree, &sinfo);
989 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_COLLISION);
990
991 ret &= check_stream_list(tctx, cli, fname, 5, five2);
992
993 ZERO_STRUCT(sinfo);
994 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
995 sinfo.rename_information.in.file.fnum = fnum1;
996 sinfo.rename_information.in.overwrite = true;
997 sinfo.rename_information.in.root_fid = 0;
998 sinfo.rename_information.in.new_name = ":MStream Two:$DATA";
999 status = smb_raw_setfileinfo(cli->tree, &sinfo);
1000 if (torture_setting_bool(tctx, "samba4", false) ||
1001 torture_setting_bool(tctx, "samba3", false)) {
1002 /* why should this rename be considered invalid?? */
1003 CHECK_STATUS(status, NT_STATUS_OK);
1004 ret &= check_stream_list(tctx, cli, fname, 4, four);
1005 } else {
1006 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
1007 ret &= check_stream_list(tctx, cli, fname, 5, five2);
1008 }
1009
1010
1011 /* TODO: we need to test more rename combinations */
1012
1013 done:
1014 if (fnum1 != -1) smbcli_close(cli->tree, fnum1);
1015 if (fnum2 != -1) smbcli_close(cli->tree, fnum2);
1016 if (fnum3 != -1) smbcli_close(cli->tree, fnum3);
1017 status = smbcli_unlink(cli->tree, fname);
1018 smbcli_deltree(cli->tree, BASEDIR);
1019 return ret;
1020 }
1021
1022 /*
1023 test stream names
1024 */
1025 static bool test_stream_names2(struct torture_context *tctx,
1026 struct smbcli_state *cli)
1027 {
1028 NTSTATUS status;
1029 union smb_open io;
1030 const char *fname = BASEDIR "\\stream_names2.txt";
1031 bool ret = true;
1032 int fnum1 = -1;
1033 uint8_t i;
1034
1035 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1036
1037 printf("(%s) testing stream names\n", __location__);
1038 io.generic.level = RAW_OPEN_NTCREATEX;
1039 io.ntcreatex.in.root_fid.fnum = 0;
1040 io.ntcreatex.in.flags = 0;
1041 io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
1042 io.ntcreatex.in.create_options = 0;
1043 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1044 io.ntcreatex.in.share_access = 0;
1045 io.ntcreatex.in.alloc_size = 0;
1046 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1047 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1048 io.ntcreatex.in.security_flags = 0;
1049 io.ntcreatex.in.fname = fname;
1050 status = smb_raw_open(cli->tree, tctx, &io);
1051 CHECK_STATUS(status, NT_STATUS_OK);
1052 fnum1 = io.ntcreatex.out.file.fnum;
1053
1054 for (i=0x01; i < 0x7F; i++) {
1055 char *path = talloc_asprintf(tctx, "%s:Stream%c0x%02X:$DATA",
1056 fname, i, i);
1057 NTSTATUS expected;
1058
1059 switch (i) {
1060 case '/':/*0x2F*/
1061 case ':':/*0x3A*/
1062 case '\\':/*0x5C*/
1063 expected = NT_STATUS_OBJECT_NAME_INVALID;
1064 break;
1065 default:
1066 expected = NT_STATUS_OBJECT_NAME_NOT_FOUND;
1067 break;
1068 }
1069
1070
1071 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1072 io.ntcreatex.in.fname = path;
1073 status = smb_raw_open(cli->tree, tctx, &io);
1074 if (!NT_STATUS_EQUAL(status, expected)) {
1075 printf("(%s) %s:Stream%c0x%02X:$DATA%s => expected[%s]\n",
1076 __location__, fname, isprint(i)?(char)i:' ', i,
1077 isprint(i)?"":" (not printable)",
1078 nt_errstr(expected));
1079 }
1080 CHECK_STATUS(status, expected);
1081
1082 talloc_free(path);
1083 }
1084
1085 done:
1086 if (fnum1 != -1) smbcli_close(cli->tree, fnum1);
1087 status = smbcli_unlink(cli->tree, fname);
1088 smbcli_deltree(cli->tree, BASEDIR);
1089 return ret;
1090 }
1091
1092 #define CHECK_CALL_FNUM(call, rightstatus) do { \
1093 check_fnum = true; \
1094 call_name = #call; \
1095 sfinfo.generic.level = RAW_SFILEINFO_ ## call; \
1096 sfinfo.generic.in.file.fnum = fnum; \
1097 status = smb_raw_setfileinfo(cli->tree, &sfinfo); \
1098 if (!NT_STATUS_EQUAL(status, rightstatus)) { \
1099 printf("(%s) %s - %s (should be %s)\n", __location__, #call, \
1100 nt_errstr(status), nt_errstr(rightstatus)); \
1101 ret = false; \
1102 } \
1103 finfo1.generic.level = RAW_FILEINFO_ALL_INFO; \
1104 finfo1.generic.in.file.fnum = fnum; \
1105 status2 = smb_raw_fileinfo(cli->tree, tctx, &finfo1); \
1106 if (!NT_STATUS_IS_OK(status2)) { \
1107 printf("(%s) %s pathinfo - %s\n", __location__, #call, nt_errstr(status)); \
1108 ret = false; \
1109 }} while (0)
1110
1111 /*
1112 test stream renames
1113 */
1114 static bool test_stream_rename(struct torture_context *tctx,
1115 struct smbcli_state *cli)
1116 {
1117 NTSTATUS status, status2;
1118 union smb_open io;
1119 const char *fname = BASEDIR "\\stream_rename.txt";
1120 const char *sname1, *sname2;
1121 union smb_fileinfo finfo1;
1122 union smb_setfileinfo sfinfo;
1123 bool ret = true;
1124 int fnum = -1;
1125 bool check_fnum;
1126 const char *call_name;
1127
1128 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1129
1130 sname1 = talloc_asprintf(tctx, "%s:%s", fname, "Stream One");
1131 sname2 = talloc_asprintf(tctx, "%s:%s:$DaTa", fname, "Second Stream");
1132
1133 printf("(%s) testing stream renames\n", __location__);
1134 io.generic.level = RAW_OPEN_NTCREATEX;
1135 io.ntcreatex.in.root_fid.fnum = 0;
1136 io.ntcreatex.in.flags = 0;
1137 io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE |
1138 SEC_FILE_WRITE_ATTRIBUTE |
1139 SEC_RIGHTS_FILE_ALL;
1140 io.ntcreatex.in.create_options = 0;
1141 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1142 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
1143 io.ntcreatex.in.alloc_size = 0;
1144 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1145 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1146 io.ntcreatex.in.security_flags = 0;
1147 io.ntcreatex.in.fname = sname1;
1148
1149 /* Create two streams. */
1150 status = smb_raw_open(cli->tree, tctx, &io);
1151 CHECK_STATUS(status, NT_STATUS_OK);
1152 fnum = io.ntcreatex.out.file.fnum;
1153 if (fnum != -1) smbcli_close(cli->tree, fnum);
1154
1155 io.ntcreatex.in.fname = sname2;
1156 status = smb_raw_open(cli->tree, tctx, &io);
1157 CHECK_STATUS(status, NT_STATUS_OK);
1158 fnum = io.ntcreatex.out.file.fnum;
1159
1160 if (fnum != -1) smbcli_close(cli->tree, fnum);
1161
1162 /*
1163 * Open the second stream.
1164 */
1165
1166 io.ntcreatex.in.access_mask = SEC_STD_DELETE;
1167 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1168 status = smb_raw_open(cli->tree, tctx, &io);
1169 CHECK_STATUS(status, NT_STATUS_OK);
1170 fnum = io.ntcreatex.out.file.fnum;
1171
1172 /*
1173 * Now rename the second stream onto the first.
1174 */
1175
1176 ZERO_STRUCT(sfinfo);
1177
1178 sfinfo.rename_information.in.overwrite = 1;
1179 sfinfo.rename_information.in.root_fid = 0;
1180 sfinfo.rename_information.in.new_name = ":Stream One";
1181 CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
1182
1183 done:
1184 if (fnum != -1) smbcli_close(cli->tree, fnum);
1185 status = smbcli_unlink(cli->tree, fname);
1186 smbcli_deltree(cli->tree, BASEDIR);
1187 return ret;
1188 }
1189
1190 static bool test_stream_rename2(struct torture_context *tctx,
1191 struct smbcli_state *cli)
1192 {
1193 NTSTATUS status;
1194 union smb_open io;
1195 const char *fname1 = BASEDIR "\\stream.txt";
1196 const char *fname2 = BASEDIR "\\stream2.txt";
1197 const char *stream_name1 = ":Stream One:$DATA";
1198 const char *stream_name2 = ":Stream Two:$DATA";
1199 const char *stream_name_default = "::$DATA";
1200 const char *sname1;
1201 const char *sname2;
1202 bool ret = true;
1203 int fnum = -1;
1204 union smb_setfileinfo sinfo;
1205 union smb_rename rio;
1206
1207 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1208
1209 sname1 = talloc_asprintf(tctx, "%s:%s", fname1, "Stream One");
1210 sname2 = talloc_asprintf(tctx, "%s:%s", fname1, "Stream Two");
1211
1212 io.generic.level = RAW_OPEN_NTCREATEX;
1213 io.ntcreatex.in.root_fid.fnum = 0;
1214 io.ntcreatex.in.flags = 0;
1215 io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
1216 SEC_STD_DELETE|SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL);
1217 io.ntcreatex.in.create_options = 0;
1218 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1219 io.ntcreatex.in.share_access = (NTCREATEX_SHARE_ACCESS_READ |
1220 NTCREATEX_SHARE_ACCESS_WRITE |
1221 NTCREATEX_SHARE_ACCESS_DELETE);
1222 io.ntcreatex.in.alloc_size = 0;
1223 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1224 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1225 io.ntcreatex.in.security_flags = 0;
1226 io.ntcreatex.in.fname = sname1;
1227
1228 /* Open/create new stream. */
1229 status = smb_raw_open(cli->tree, tctx, &io);
1230 CHECK_STATUS(status, NT_STATUS_OK);
1231
1232 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1233
1234 /*
1235 * Check raw rename with <base>:<stream>.
1236 */
1237 printf("(%s) Checking NTRENAME of a stream using <base>:<stream>\n",
1238 __location__);
1239 rio.generic.level = RAW_RENAME_NTRENAME;
1240 rio.ntrename.in.old_name = sname1;
1241 rio.ntrename.in.new_name = sname2;
1242 rio.ntrename.in.attrib = 0;
1243 rio.ntrename.in.cluster_size = 0;
1244 rio.ntrename.in.flags = RENAME_FLAG_RENAME;
1245 status = smb_raw_rename(cli->tree, &rio);
1246 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
1247
1248 /*
1249 * Check raw rename to the default stream using :<stream>.
1250 */
1251 printf("(%s) Checking NTRENAME to default stream using :<stream>\n",
1252 __location__);
1253 rio.ntrename.in.new_name = stream_name_default;
1254 status = smb_raw_rename(cli->tree, &rio);
1255 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_COLLISION);
1256
1257 /*
1258 * Check raw rename using :<stream>.
1259 */
1260 printf("(%s) Checking NTRENAME of a stream using :<stream>\n",
1261 __location__);
1262 rio.ntrename.in.new_name = stream_name2;
1263 status = smb_raw_rename(cli->tree, &rio);
1264 CHECK_STATUS(status, NT_STATUS_OK);
1265
1266 /*
1267 * Check raw rename of a stream to a file.
1268 */
1269 printf("(%s) Checking NTRENAME of a stream to a file\n",
1270 __location__);
1271 rio.ntrename.in.old_name = sname2;
1272 rio.ntrename.in.new_name = fname2;
1273 status = smb_raw_rename(cli->tree, &rio);
1274 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
1275
1276 /*
1277 * Check raw rename of a file to a stream.
1278 */
1279 printf("(%s) Checking NTRENAME of a file to a stream\n",
1280 __location__);
1281
1282 /* Create the file. */
1283 io.ntcreatex.in.fname = fname2;
1284 status = smb_raw_open(cli->tree, tctx, &io);
1285 CHECK_STATUS(status, NT_STATUS_OK);
1286 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1287
1288 /* Try the rename. */
1289 rio.ntrename.in.old_name = fname2;
1290 rio.ntrename.in.new_name = sname1;
1291 status = smb_raw_rename(cli->tree, &rio);
1292 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
1293
1294 /*
1295 * Reopen the stream for trans2 renames.
1296 */
1297 io.ntcreatex.in.fname = sname2;
1298 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1299 status = smb_raw_open(cli->tree, tctx, &io);
1300 CHECK_STATUS(status, NT_STATUS_OK);
1301 fnum = io.ntcreatex.out.file.fnum;
1302
1303 /*
1304 * Check trans2 rename of a stream using :<stream>.
1305 */
1306 printf("(%s) Checking trans2 rename of a stream using :<stream>\n",
1307 __location__);
1308 ZERO_STRUCT(sinfo);
1309 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
1310 sinfo.rename_information.in.file.fnum = fnum;
1311 sinfo.rename_information.in.overwrite = 1;
1312 sinfo.rename_information.in.root_fid = 0;
1313 sinfo.rename_information.in.new_name = stream_name1;
1314 status = smb_raw_setfileinfo(cli->tree, &sinfo);
1315 CHECK_STATUS(status, NT_STATUS_OK);
1316
1317 /*
1318 * Check trans2 rename of an overwriting stream using :<stream>.
1319 */
1320 printf("(%s) Checking trans2 rename of an overwriting stream using "
1321 ":<stream>\n", __location__);
1322
1323 /* Create second stream. */
1324 io.ntcreatex.in.fname = sname2;
1325 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1326 status = smb_raw_open(cli->tree, tctx, &io);
1327 CHECK_STATUS(status, NT_STATUS_OK);
1328 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1329
1330 /* Rename the first stream onto the second. */
1331 sinfo.rename_information.in.file.fnum = fnum;
1332 sinfo.rename_information.in.new_name = stream_name2;
1333 status = smb_raw_setfileinfo(cli->tree, &sinfo);
1334 CHECK_STATUS(status, NT_STATUS_OK);
1335
1336 smbcli_close(cli->tree, fnum);
1337
1338 /*
1339 * Reopen the stream with the new name.
1340 */
1341 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1342 io.ntcreatex.in.fname = sname2;
1343 status = smb_raw_open(cli->tree, tctx, &io);
1344 CHECK_STATUS(status, NT_STATUS_OK);
1345 fnum = io.ntcreatex.out.file.fnum;
1346
1347 /*
1348 * Check trans2 rename of a stream using <base>:<stream>.
1349 */
1350 printf("(%s) Checking trans2 rename of a stream using "
1351 "<base>:<stream>\n", __location__);
1352 sinfo.rename_information.in.file.fnum = fnum;
1353 sinfo.rename_information.in.new_name = sname1;
1354 status = smb_raw_setfileinfo(cli->tree, &sinfo);
1355 CHECK_STATUS(status, NT_STATUS_NOT_SUPPORTED);
1356
1357 /*
1358 * Samba3 doesn't currently support renaming a stream to the default
1359 * stream. This test does pass on windows.
1360 */
1361 if (torture_setting_bool(tctx, "samba3", false) ||
1362 torture_setting_bool(tctx, "samba4", false)) {
1363 goto done;
1364 }
1365
1366 /*
1367 * Check trans2 rename to the default stream using :<stream>.
1368 */
1369 printf("(%s) Checking trans2 rename to defaualt stream using "
1370 ":<stream>\n", __location__);
1371 sinfo.rename_information.in.file.fnum = fnum;
1372 sinfo.rename_information.in.new_name = stream_name_default;
1373 status = smb_raw_setfileinfo(cli->tree, &sinfo);
1374 CHECK_STATUS(status, NT_STATUS_OK);
1375
1376 smbcli_close(cli->tree, fnum);
1377
1378 done:
1379 smbcli_close(cli->tree, fnum);
1380 status = smbcli_unlink(cli->tree, fname1);
1381 status = smbcli_unlink(cli->tree, fname2);
1382 smbcli_deltree(cli->tree, BASEDIR);
1383 return ret;
1384 }
1385
1386 /*
1387 test stream renames
1388 */
1389 static bool test_stream_rename3(struct torture_context *tctx,
1390 struct smbcli_state *cli)
1391 {
1392 NTSTATUS status, status2;
1393 union smb_open io;
1394 const char *fname = BASEDIR "\\stream_rename.txt";
1395 const char *sname1, *sname2;
1396 union smb_fileinfo finfo1;
1397 union smb_setfileinfo sfinfo;
1398 bool ret = true;
1399 int fnum = -1;
1400 int fnum2 = -1;
1401 bool check_fnum;
1402 const char *call_name;
1403
1404 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1405
1406 sname1 = talloc_asprintf(tctx, "%s:%s", fname, "MStream Two:$DATA");
1407 sname2 = talloc_asprintf(tctx, "%s:%s:$DaTa", fname, "Second Stream");
1408
1409 printf("(%s) testing stream renames\n", __location__);
1410 io.generic.level = RAW_OPEN_NTCREATEX;
1411 io.ntcreatex.in.root_fid.fnum = 0;
1412 io.ntcreatex.in.flags = 0;
1413 io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE |
1414 SEC_FILE_WRITE_ATTRIBUTE |
1415 SEC_RIGHTS_FILE_ALL;
1416 io.ntcreatex.in.create_options = 0;
1417 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1418 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1419 NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
1420 io.ntcreatex.in.alloc_size = 0;
1421 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1422 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1423 io.ntcreatex.in.security_flags = 0;
1424 io.ntcreatex.in.fname = sname1;
1425
1426 /* Create two streams. */
1427 status = smb_raw_open(cli->tree, tctx, &io);
1428 CHECK_STATUS(status, NT_STATUS_OK);
1429 fnum = io.ntcreatex.out.file.fnum;
1430 if (fnum != -1) smbcli_close(cli->tree, fnum);
1431
1432 io.ntcreatex.in.fname = sname2;
1433 status = smb_raw_open(cli->tree, tctx, &io);
1434 CHECK_STATUS(status, NT_STATUS_OK);
1435 fnum = io.ntcreatex.out.file.fnum;
1436
1437 if (fnum != -1) smbcli_close(cli->tree, fnum);
1438
1439 /* open the second stream. */
1440 io.ntcreatex.in.access_mask = SEC_STD_DELETE;
1441 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1442 status = smb_raw_open(cli->tree, tctx, &io);
1443 CHECK_STATUS(status, NT_STATUS_OK);
1444 fnum = io.ntcreatex.out.file.fnum;
1445
1446 /* Keep a handle to the first stream open. */
1447 io.ntcreatex.in.fname = sname1;
1448 io.ntcreatex.in.access_mask = SEC_STD_DELETE;
1449 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1450 status = smb_raw_open(cli->tree, tctx, &io);
1451 CHECK_STATUS(status, NT_STATUS_OK);
1452 fnum2 = io.ntcreatex.out.file.fnum;
1453
1454 ZERO_STRUCT(sfinfo);
1455 sfinfo.rename_information.in.overwrite = 1;
1456 sfinfo.rename_information.in.root_fid = 0;
1457 sfinfo.rename_information.in.new_name = ":MStream Two:$DATA";
1458 if (torture_setting_bool(tctx, "samba4", false) ||
1459 torture_setting_bool(tctx, "samba3", false)) {
1460 CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
1461 } else {
1462 CHECK_CALL_FNUM(RENAME_INFORMATION,
1463 NT_STATUS_INVALID_PARAMETER);
1464 }
1465
1466
1467 done:
1468 if (fnum != -1) smbcli_close(cli->tree, fnum);
1469 if (fnum2 != -1) smbcli_close(cli->tree, fnum2);
1470 status = smbcli_unlink(cli->tree, fname);
1471 smbcli_deltree(cli->tree, BASEDIR);
1472 return ret;
1473 }
1474
1475 static bool create_file_with_stream(struct torture_context *tctx,
1476 struct smbcli_state *cli,
1477 const char *stream)
1478 {
1479 NTSTATUS status;
1480 bool ret = true;
1481 union smb_open io;
1482
1483 /* Create a file with a stream */
1484 io.generic.level = RAW_OPEN_NTCREATEX;
1485 io.ntcreatex.in.root_fid.fnum = 0;
1486 io.ntcreatex.in.flags = 0;
1487 io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
1488 SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL);
1489 io.ntcreatex.in.create_options = 0;
1490 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1491 io.ntcreatex.in.share_access = 0;
1492 io.ntcreatex.in.alloc_size = 0;
1493 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1494 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1495 io.ntcreatex.in.security_flags = 0;
1496 io.ntcreatex.in.fname = stream;
1497
1498 status = smb_raw_open(cli->tree, tctx, &io);
1499 CHECK_STATUS(status, NT_STATUS_OK);
1500
1501 done:
1502 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1503 return ret;
1504 }
1505
1506 /* Test how streams interact with create dispositions */
1507 static bool test_stream_create_disposition(struct torture_context *tctx,
1508 struct smbcli_state *cli)
1509 {
1510 NTSTATUS status;
1511 union smb_open io;
1512 const char *fname = BASEDIR "\\stream.txt";
1513 const char *stream = "Stream One:$DATA";
1514 const char *fname_stream;
1515 const char *default_stream_name = "::$DATA";
1516 const char *stream_list[2];
1517 bool ret = false;
1518 int fnum = -1;
1519
1520 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1521
1522 fname_stream = talloc_asprintf(tctx, "%s:%s", fname, stream);
1523
1524 stream_list[0] = talloc_asprintf(tctx, ":%s", stream);
1525 stream_list[1] = default_stream_name;
1526
1527 if (!create_file_with_stream(tctx, cli, fname_stream)) {
1528 goto done;
1529 }
1530
1531 /* Open the base file with OPEN */
1532 io.generic.level = RAW_OPEN_NTCREATEX;
1533 io.ntcreatex.in.root_fid.fnum = 0;
1534 io.ntcreatex.in.flags = 0;
1535 io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
1536 SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL);
1537 io.ntcreatex.in.create_options = 0;
1538 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1539 io.ntcreatex.in.share_access = 0;
1540 io.ntcreatex.in.alloc_size = 0;
1541 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1542 io.ntcreatex.in.security_flags = 0;
1543 io.ntcreatex.in.fname = fname;
1544
1545 /*
1546 * check ntcreatex open: sanity check
1547 */
1548 printf("(%s) Checking ntcreatex disp: open\n", __location__);
1549 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1550 status = smb_raw_open(cli->tree, tctx, &io);
1551 CHECK_STATUS(status, NT_STATUS_OK);
1552 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1553 if (!check_stream_list(tctx, cli, fname, 2, stream_list)) {
1554 goto done;
1555 }
1556
1557 /*
1558 * check ntcreatex overwrite
1559 */
1560 printf("(%s) Checking ntcreatex disp: overwrite\n", __location__);
1561 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE;
1562 status = smb_raw_open(cli->tree, tctx, &io);
1563 CHECK_STATUS(status, NT_STATUS_OK);
1564 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1565 if (!check_stream_list(tctx, cli, fname, 1, &default_stream_name)) {
1566 goto done;
1567 }
1568
1569 /*
1570 * check ntcreatex overwrite_if
1571 */
1572 printf("(%s) Checking ntcreatex disp: overwrite_if\n", __location__);
1573 smbcli_unlink(cli->tree, fname);
1574 if (!create_file_with_stream(tctx, cli, fname_stream)) {
1575 goto done;
1576 }
1577
1578 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1579 status = smb_raw_open(cli->tree, tctx, &io);
1580 CHECK_STATUS(status, NT_STATUS_OK);
1581 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1582 if (!check_stream_list(tctx, cli, fname, 1, &default_stream_name)) {
1583 goto done;
1584 }
1585
1586 /*
1587 * check ntcreatex supersede
1588 */
1589 printf("(%s) Checking ntcreatex disp: supersede\n", __location__);
1590 smbcli_unlink(cli->tree, fname);
1591 if (!create_file_with_stream(tctx, cli, fname_stream)) {
1592 goto done;
1593 }
1594
1595 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_SUPERSEDE;
1596 status = smb_raw_open(cli->tree, tctx, &io);
1597 CHECK_STATUS(status, NT_STATUS_OK);
1598 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1599 if (!check_stream_list(tctx, cli, fname, 1, &default_stream_name)) {
1600 goto done;
1601 }
1602
1603 /*
1604 * check ntcreatex overwrite_if on a stream.
1605 */
1606 printf("(%s) Checking ntcreatex disp: overwrite_if on stream\n",
1607 __location__);
1608 smbcli_unlink(cli->tree, fname);
1609 if (!create_file_with_stream(tctx, cli, fname_stream)) {
1610 goto done;
1611 }
1612
1613 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1614 io.ntcreatex.in.fname = fname_stream;
1615 status = smb_raw_open(cli->tree, tctx, &io);
1616 CHECK_STATUS(status, NT_STATUS_OK);
1617 smbcli_close(cli->tree, io.ntcreatex.out.file.fnum);
1618 if (!check_stream_list(tctx, cli, fname, 2, stream_list)) {
1619 goto done;
1620 }
1621
1622 /*
1623 * check openx overwrite_if
1624 */
1625 printf("(%s) Checking openx disp: overwrite_if\n", __location__);
1626 smbcli_unlink(cli->tree, fname);
1627 if (!create_file_with_stream(tctx, cli, fname_stream)) {
1628 goto done;
1629 }
1630
1631 io.openx.level = RAW_OPEN_OPENX;
1632 io.openx.in.flags = OPENX_FLAGS_ADDITIONAL_INFO;
1633 io.openx.in.open_mode = OPENX_MODE_ACCESS_RDWR | OPEN_FLAGS_DENY_NONE;
1634 io.openx.in.search_attrs = 0;
1635 io.openx.in.file_attrs = 0;
1636 io.openx.in.write_time = 0;
1637 io.openx.in.size = 1024*1024;
1638 io.openx.in.timeout = 0;
1639 io.openx.in.fname = fname;
1640
1641 io.openx.in.open_func = OPENX_OPEN_FUNC_TRUNC | OPENX_OPEN_FUNC_CREATE;
1642 status = smb_raw_open(cli->tree, tctx, &io);
1643 CHECK_STATUS(status, NT_STATUS_OK);
1644 smbcli_close(cli->tree, io.openx.out.file.fnum);
1645 if (!check_stream_list(tctx, cli, fname, 1, &default_stream_name)) {
1646 goto done;
1647 }
1648
1649 ret = true;
1650
1651 done:
1652 smbcli_close(cli->tree, fnum);
1653 smbcli_unlink(cli->tree, fname);
1654 smbcli_deltree(cli->tree, BASEDIR);
1655 return ret;
1656 }
1657
1658 #if 0
1659 /* Test streaminfo with enough streams on a file to fill up the buffer. */
1660 static bool test_stream_large_streaminfo(struct torture_context *tctx,
1661 struct smbcli_state *cli)
1662 {
1663 #define LONG_STREAM_SIZE 2
1664 char *lstream_name;
1665 const char *fname = BASEDIR "\\stream.txt";
1666 const char *fname_stream;
1667 NTSTATUS status;
1668 bool ret = true;
1669 int i;
1670 union smb_fileinfo finfo;
1671
1672 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1673
1674 lstream_name = talloc_array(tctx, char, LONG_STREAM_SIZE);
1675
1676 for (i = 0; i < LONG_STREAM_SIZE - 1; i++) {
1677 lstream_name[i] = (char)('a' + i%26);
1678 }
1679 lstream_name[LONG_STREAM_SIZE - 1] = '\0';
1680
1681 torture_comment(tctx, "(%s) Creating a file with a lot of streams\n", __location__);
1682 for (i = 0; i < 10000; i++) {
1683 fname_stream = talloc_asprintf(tctx, "%s:%s%d", fname,
1684 lstream_name, i);
1685 ret = create_file_with_stream(tctx, cli, fname_stream);
1686 if (!ret) {
1687 goto done;
1688 }
1689 }
1690
1691 finfo.generic.level = RAW_FILEINFO_STREAM_INFO;
1692 finfo.generic.in.file.path = fname;
1693
1694 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
1695 CHECK_STATUS(status, STATUS_BUFFER_OVERFLOW);
1696
1697 done:
1698 smbcli_unlink(cli->tree, fname);
1699 smbcli_deltree(cli->tree, BASEDIR);
1700 return ret;
1701 }
1702 #endif
1703
1704 /* Test the effect of setting attributes on a stream. */
1705 static bool test_stream_attributes(struct torture_context *tctx,
1706 struct smbcli_state *cli)
1707 {
1708 bool ret = true;
1709 NTSTATUS status;
1710 union smb_open io;
1711 const char *fname = BASEDIR "\\stream_attr.txt";
1712 const char *stream = "Stream One:$DATA";
1713 const char *fname_stream;
1714 int fnum = -1;
1715 union smb_fileinfo finfo;
1716 union smb_setfileinfo sfinfo;
1717 time_t basetime = (time(NULL) - 86400) & ~1;
1718
1719 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1720
1721 torture_comment(tctx, "(%s) testing attribute setting on stream\n", __location__);
1722
1723 fname_stream = talloc_asprintf(tctx, "%s:%s", fname, stream);
1724
1725 /* Create a file with a stream with attribute FILE_ATTRIBUTE_ARCHIVE. */
1726 ret = create_file_with_stream(tctx, cli, fname_stream);
1727 if (!ret) {
1728 goto done;
1729 }
1730
1731 ZERO_STRUCT(finfo);
1732 finfo.generic.level = RAW_FILEINFO_BASIC_INFO;
1733 finfo.generic.in.file.path = fname;
1734 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
1735 CHECK_STATUS(status, NT_STATUS_OK);
1736
1737 torture_assert_int_equal_goto(tctx, finfo.all_info.out.attrib & ~FILE_ATTRIBUTE_NONINDEXED, FILE_ATTRIBUTE_ARCHIVE, ret, done, "attrib incorrect");
1738
1739 /* Now open the stream name. */
1740
1741 io.generic.level = RAW_OPEN_NTCREATEX;
1742 io.ntcreatex.in.root_fid.fnum = 0;
1743 io.ntcreatex.in.flags = 0;
1744 io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
1745 SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL|SEC_FILE_WRITE_ATTRIBUTE);
1746 io.ntcreatex.in.create_options = 0;
1747 io.ntcreatex.in.file_attr = 0;
1748 io.ntcreatex.in.share_access = 0;
1749 io.ntcreatex.in.alloc_size = 0;
1750 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1751 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1752 io.ntcreatex.in.security_flags = 0;
1753 io.ntcreatex.in.fname = fname_stream;
1754
1755 status = smb_raw_open(cli->tree, tctx, &io);
1756 CHECK_STATUS(status, NT_STATUS_OK);
1757
1758 fnum = io.ntcreatex.out.file.fnum;
1759
1760 /* Change the attributes + time on the stream fnum. */
1761 ZERO_STRUCT(sfinfo);
1762 sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_READONLY;
1763 unix_to_nt_time(&sfinfo.basic_info.in.write_time, basetime);
1764
1765 sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
1766 sfinfo.generic.in.file.fnum = fnum;
1767 status = smb_raw_setfileinfo(cli->tree, &sfinfo);
1768 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OK, ret, done, "smb_raw_setfileinfo failed");
1769
1770 smbcli_close(cli->tree, fnum);
1771 fnum = -1;
1772
1773 ZERO_STRUCT(finfo);
1774 finfo.generic.level = RAW_FILEINFO_ALL_INFO;
1775 finfo.generic.in.file.path = fname;
1776 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
1777 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OK, ret, done, "smb_raw_pathinfo failed");
1778
1779 torture_assert_int_equal_goto(tctx, finfo.all_info.out.attrib & ~FILE_ATTRIBUTE_NONINDEXED, FILE_ATTRIBUTE_READONLY, ret, done, "attrib incorrect");
1780
1781 torture_assert_int_equal_goto(tctx, nt_time_to_unix(finfo.all_info.out.write_time), basetime, ret, done, "time incorrect");
1782
1783 done:
1784
1785 if (fnum != -1) {
1786 smbcli_close(cli->tree, fnum);
1787 }
1788 smbcli_unlink(cli->tree, fname);
1789 smbcli_deltree(cli->tree, BASEDIR);
1790 return ret;
1791 }
1792
1793 /**
1794 * A rough approximation of how a windows client creates the streams for use
1795 * in the summary tab.
1796 */
1797 static bool test_stream_summary_tab(struct torture_context *tctx,
1798 struct smbcli_state *cli)
1799 {
1800 bool ret = true;
1801 NTSTATUS status;
1802 union smb_open io;
1803 const char *fname = BASEDIR "\\stream_summary.txt";
1804 const char *stream = ":\005SummaryInformation:$DATA";
1805 const char *fname_stream = NULL;
1806 const char *tmp_stream = ":Updt_\005SummaryInformation:$DATA";
1807 const char *fname_tmp_stream = NULL;
1808 int fnum = -1;
1809 union smb_fileinfo finfo;
1810 union smb_rename rio;
1811 ssize_t retsize;
1812
1813 torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
1814
1815 fname_stream = talloc_asprintf(tctx, "%s%s", fname, stream);
1816 fname_tmp_stream = talloc_asprintf(tctx, "%s%s", fname,
1817 tmp_stream);
1818
1819 /* Create summary info stream */
1820 ret = create_file_with_stream(tctx, cli, fname_stream);
1821 if (!ret) {
1822 goto done;
1823 }
1824
1825 /* Create summary info tmp update stream */
1826 ret = create_file_with_stream(tctx, cli, fname_tmp_stream);
1827 if (!ret) {
1828 goto done;
1829 }
1830
1831 /* Open tmp stream and write to it */
1832 io.generic.level = RAW_OPEN_NTCREATEX;
1833 io.ntcreatex.in.root_fid.fnum = 0;
1834 io.ntcreatex.in.flags = 0;
1835 io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA;
1836 io.ntcreatex.in.create_options = 0;
1837 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1838 io.ntcreatex.in.share_access = 0;
1839 io.ntcreatex.in.alloc_size = 0;
1840 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1841 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1842 io.ntcreatex.in.security_flags = 0;
1843 io.ntcreatex.in.fname = fname_tmp_stream;
1844
1845 status = smb_raw_open(cli->tree, tctx, &io);
1846 CHECK_STATUS(status, NT_STATUS_OK);
1847 fnum = io.ntcreatex.out.file.fnum;
1848
1849 retsize = smbcli_write(cli->tree, fnum, 0, "test data", 0, 9);
1850 CHECK_VALUE(retsize, 9);
1851
1852 /* close the tmp stream. */
1853 smbcli_close(cli->tree, fnum);
1854 fnum = -1;
1855
1856 /* Delete the current stream */
1857 smbcli_unlink(cli->tree, fname_stream);
1858
1859 /* Do the rename. */
1860 rio.generic.level = RAW_RENAME_RENAME;
1861 rio.rename.in.pattern1 = fname_tmp_stream;
1862 rio.rename.in.pattern2 = stream;
1863 rio.rename.in.attrib = FILE_ATTRIBUTE_SYSTEM |
1864 FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
1865 status = smb_raw_rename(cli->tree, &rio);
1866 CHECK_STATUS(status, NT_STATUS_OK);
1867
1868 /* Try to open the tmp stream that we just renamed away. */
1869 status = smb_raw_open(cli->tree, tctx, &io);
1870 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1871
1872 /* Query the base file to make sure it's still there. */
1873 finfo.generic.level = RAW_FILEINFO_BASIC_INFO;
1874 finfo.generic.in.file.path = fname;
1875
1876 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
1877 CHECK_STATUS(status, NT_STATUS_OK);
1878
1879 done:
1880
1881 if (fnum != -1) {
1882 smbcli_close(cli->tree, fnum);
1883 }
1884 smbcli_unlink(cli->tree, fname);
1885
1886 smbcli_deltree(cli->tree, BASEDIR);
1887 return ret;
1888 }
1889
1890 /* Test how streams interact with base file permissions */
1891 /* Regression test for bug:
1892 https://bugzilla.samba.org/show_bug.cgi?id=10229
1893 bug #10229 - No access check verification on stream files.
1894 */
1895 static bool test_stream_permissions(struct torture_context *tctx,
1896 struct smbcli_state *cli)
1897 {
1898 NTSTATUS status;
1899 bool ret = true;
1900 union smb_open io;
1901 const char *fname = BASEDIR "\\stream_permissions.txt";
1902 const char *stream = "Stream One:$DATA";
1903 const char *fname_stream;
1904 union smb_fileinfo finfo;
1905 union smb_setfileinfo sfinfo;
1906 int fnum = -1;
1907 union smb_fileinfo q;
1908 union smb_setfileinfo set;
1909 struct security_ace ace;
1910 struct security_descriptor *sd;
1911
1912 torture_assert(tctx, torture_setup_dir(cli, BASEDIR),
1913 "Failed to setup up test directory: " BASEDIR);
1914
1915 torture_comment(tctx, "(%s) testing permissions on streams\n", __location__);
1916
1917 fname_stream = talloc_asprintf(tctx, "%s:%s", fname, stream);
1918
1919 /* Create a file with a stream with attribute FILE_ATTRIBUTE_ARCHIVE. */
1920 ret = create_file_with_stream(tctx, cli, fname_stream);
1921 if (!ret) {
1922 goto done;
1923 }
1924
1925 ZERO_STRUCT(finfo);
1926 finfo.generic.level = RAW_FILEINFO_BASIC_INFO;
1927 finfo.generic.in.file.path = fname;
1928 status = smb_raw_pathinfo(cli->tree, tctx, &finfo);
1929 CHECK_STATUS(status, NT_STATUS_OK);
1930
1931 torture_assert_int_equal_goto(tctx,
1932 finfo.all_info.out.attrib & ~FILE_ATTRIBUTE_NONINDEXED,
1933 FILE_ATTRIBUTE_ARCHIVE, ret, done, "attrib incorrect");
1934
1935 /* Change the attributes on the base file name. */
1936 ZERO_STRUCT(sfinfo);
1937 sfinfo.generic.level = RAW_SFILEINFO_SETATTR;
1938 sfinfo.generic.in.file.path = fname;
1939 sfinfo.setattr.in.attrib = FILE_ATTRIBUTE_READONLY;
1940
1941 status = smb_raw_setpathinfo(cli->tree, &sfinfo);
1942 CHECK_STATUS(status, NT_STATUS_OK);
1943
1944 /* Try and open the stream name for WRITE_DATA. Should
1945 fail with ACCESS_DENIED. */
1946
1947 ZERO_STRUCT(io);
1948 io.generic.level = RAW_OPEN_NTCREATEX;
1949 io.ntcreatex.in.root_fid.fnum = 0;
1950 io.ntcreatex.in.flags = 0;
1951 io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
1952 io.ntcreatex.in.create_options = 0;
1953 io.ntcreatex.in.file_attr = 0;
1954 io.ntcreatex.in.share_access = 0;
1955 io.ntcreatex.in.alloc_size = 0;
1956 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1957 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1958 io.ntcreatex.in.security_flags = 0;
1959 io.ntcreatex.in.fname = fname_stream;
1960
1961 status = smb_raw_open(cli->tree, tctx, &io);
1962 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
1963
1964 /* Change the attributes on the base file back. */
1965 ZERO_STRUCT(sfinfo);
1966 sfinfo.generic.level = RAW_SFILEINFO_SETATTR;
1967 sfinfo.generic.in.file.path = fname;
1968 sfinfo.setattr.in.attrib = 0;
1969
1970 status = smb_raw_setpathinfo(cli->tree, &sfinfo);
1971 CHECK_STATUS(status, NT_STATUS_OK);
1972
1973 /* Re-open the file name. */
1974
1975 ZERO_STRUCT(io);
1976 io.generic.level = RAW_OPEN_NTCREATEX;
1977 io.ntcreatex.in.root_fid.fnum = 0;
1978 io.ntcreatex.in.flags = 0;
1979 io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
1980 SEC_STD_READ_CONTROL|SEC_STD_WRITE_DAC|
1981 SEC_FILE_WRITE_ATTRIBUTE);
1982 io.ntcreatex.in.create_options = 0;
1983 io.ntcreatex.in.file_attr = 0;
1984 io.ntcreatex.in.share_access = 0;
1985 io.ntcreatex.in.alloc_size = 0;
1986 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1987 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1988 io.ntcreatex.in.security_flags = 0;
1989 io.ntcreatex.in.fname = fname;
1990
1991 status = smb_raw_open(cli->tree, tctx, &io);
1992 CHECK_STATUS(status, NT_STATUS_OK);
1993
1994 fnum = io.ntcreatex.out.file.fnum;
1995
1996 /* Get the existing security descriptor. */
1997 ZERO_STRUCT(q);
1998 q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
1999 q.query_secdesc.in.file.fnum = fnum;
2000 q.query_secdesc.in.secinfo_flags =
2001 SECINFO_OWNER |
2002 SECINFO_GROUP |
2003 SECINFO_DACL;
2004 status = smb_raw_fileinfo(cli->tree, tctx, &q);
2005 CHECK_STATUS(status, NT_STATUS_OK);
2006 sd = q.query_secdesc.out.sd;
2007
2008 /* Now add a DENY WRITE security descriptor for Everyone. */
2009 torture_comment(tctx, "add a new ACE to the DACL\n");
2010
2011 ace.type = SEC_ACE_TYPE_ACCESS_DENIED;
2012 ace.flags = 0;
2013 ace.access_mask = SEC_FILE_WRITE_DATA;
2014 ace.trustee = *dom_sid_parse_talloc(tctx, SID_WORLD);
2015
2016 status = security_descriptor_dacl_add(sd, &ace);
2017 CHECK_STATUS(status, NT_STATUS_OK);
2018
2019 /* security_descriptor_dacl_add adds to the *end* of
2020 the ace array, we need it at the start. Swap.. */
2021 ace = sd->dacl->aces[0];
2022 sd->dacl->aces[0] = sd->dacl->aces[sd->dacl->num_aces-1];
2023 sd->dacl->aces[sd->dacl->num_aces-1] = ace;
2024
2025 ZERO_STRUCT(set);
2026 set.set_secdesc.level = RAW_SFILEINFO_SEC_DESC;
2027 set.set_secdesc.in.file.fnum = fnum;
2028 set.set_secdesc.in.secinfo_flags = SECINFO_DACL;
2029 set.set_secdesc.in.sd = sd;
2030
2031 status = smb_raw_setfileinfo(cli->tree, &set);
2032 CHECK_STATUS(status, NT_STATUS_OK);
2033
2034 smbcli_close(cli->tree, fnum);
2035 fnum = -1;
2036
2037 /* Try and open the stream name for WRITE_DATA. Should
2038 fail with ACCESS_DENIED. */
2039
2040 ZERO_STRUCT(io);
2041 io.generic.level = RAW_OPEN_NTCREATEX;
2042 io.ntcreatex.in.root_fid.fnum = 0;
2043 io.ntcreatex.in.flags = 0;
2044 io.ntcreatex.in.access_mask = SEC_FILE_WRITE_DATA;
2045 io.ntcreatex.in.create_options = 0;
2046 io.ntcreatex.in.file_attr = 0;
2047 io.ntcreatex.in.share_access = 0;
2048 io.ntcreatex.in.alloc_size = 0;
2049 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
2050 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2051 io.ntcreatex.in.security_flags = 0;
2052 io.ntcreatex.in.fname = fname_stream;
2053
2054 status = smb_raw_open(cli->tree, tctx, &io);
2055 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
2056
2057 done:
2058
2059 if (fnum != -1) {
2060 smbcli_close(cli->tree, fnum);
2061 }
2062 smbcli_unlink(cli->tree, fname);
2063
2064 smbcli_deltree(cli->tree, BASEDIR);
2065 return ret;
2066 }
2067
2068 /*
2069 basic testing of streams calls
2070 */
2071 struct torture_suite *torture_raw_streams(TALLOC_CTX *tctx)
2072 {
2073 struct torture_suite *suite = torture_suite_create(tctx, "streams");
2074
2075 torture_suite_add_1smb_test(suite, "dir", test_stream_dir);
2076 torture_suite_add_1smb_test(suite, "io", test_stream_io);
2077 torture_suite_add_1smb_test(suite, "sharemodes", test_stream_sharemodes);
2078 torture_suite_add_1smb_test(suite, "delete", test_stream_delete);
2079 torture_suite_add_1smb_test(suite, "names", test_stream_names);
2080 torture_suite_add_1smb_test(suite, "names2", test_stream_names2);
2081 torture_suite_add_1smb_test(suite, "rename", test_stream_rename);
2082 torture_suite_add_1smb_test(suite, "rename2", test_stream_rename2);
2083 torture_suite_add_1smb_test(suite, "rename3", test_stream_rename3);
2084 torture_suite_add_1smb_test(suite, "createdisp",
2085 test_stream_create_disposition);
2086 torture_suite_add_1smb_test(suite, "attr", test_stream_attributes);
2087 torture_suite_add_1smb_test(suite, "sumtab", test_stream_summary_tab);
2088 torture_suite_add_1smb_test(suite, "perms", test_stream_permissions);
2089
2090 #if 0
2091 torture_suite_add_1smb_test(suite, "LARGESTREAMINFO",
2092 test_stream_large_streaminfo);
2093 #endif
2094
2095 return suite;
2096 }
Samba GIT mirror