s4/torture: fix build break "implicit declaration of function 'isprint'"
[ira/wip.git] / source4 / torture / smb2 / streams.c
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 "libcli/smb2/smb2.h"
24 #include "libcli/smb2/smb2_calls.h"
25 #include "libcli/smb_composite/smb_composite.h"
26 #include "libcli/raw/libcliraw.h"
27 #include "libcli/raw/raw_proto.h"
28 #include "libcli/libcli.h"
29
30 #include "torture/torture.h"
31 #include "torture/smb2/proto.h"
32 #include "torture/util.h"
33
34 #include "system/filesys.h"
35 #include "system/locale.h"
36
37 #define DNAME "teststreams"
38
39 #define CHECK_STATUS(status, correct) do { \
40         if (!NT_STATUS_EQUAL(status, correct)) { \
41                 torture_result(tctx, TORTURE_FAIL, \
42                     "(%s) Incorrect status %s - should be %s\n", \
43                     __location__, nt_errstr(status), nt_errstr(correct)); \
44                 ret = false; \
45                 goto done; \
46         }} while (0)
47
48 #define CHECK_VALUE(v, correct) do { \
49         if ((v) != (correct)) { \
50                 torture_result(tctx, TORTURE_FAIL, \
51                     "(%s) Incorrect value %s=%d - should be %d\n", \
52                     __location__, #v, (int)v, (int)correct); \
53                 ret = false; \
54         }} while (0)
55
56 #define CHECK_NTTIME(v, correct) do { \
57         if ((v) != (correct)) { \
58                 torture_result(tctx, TORTURE_FAIL, \
59                     "(%s) Incorrect value %s=%llu - should be %llu\n", \
60                     __location__, #v, (unsigned long long)v, \
61                     (unsigned long long)correct); \
62                 ret = false; \
63         }} while (0)
64
65 #define CHECK_STR(v, correct) do { \
66         bool ok; \
67         if ((v) && !(correct)) { \
68                 ok = false; \
69         } else if (!(v) && (correct)) { \
70                 ok = false; \
71         } else if (!(v) && !(correct)) { \
72                 ok = true; \
73         } else if (strcmp((v), (correct)) == 0) { \
74                 ok = true; \
75         } else { \
76                 ok = false; \
77         } \
78         if (!ok) { \
79                 torture_comment(tctx,"(%s) Incorrect value %s='%s' - " \
80                     "should be '%s'\n", \
81                     __location__, #v, (v)?(v):"NULL", \
82                     (correct)?(correct):"NULL"); \
83                 ret = false; \
84         }} while (0)
85
86
87 static int qsort_string(const void *v1,
88                         const void *v2)
89 {
90         char * const *s1 = v1;
91         char * const *s2 = v2;
92         return strcmp(*s1, *s2);
93 }
94
95 static int qsort_stream(const void *v1,
96                         const void *v2)
97 {
98         const struct stream_struct * s1 = v1;
99         const struct stream_struct * s2 = v2;
100         return strcmp(s1->stream_name.s, s2->stream_name.s);
101 }
102
103 static bool check_stream(struct smb2_tree *tree,
104                          const char *location,
105                          TALLOC_CTX *mem_ctx,
106                          const char *fname,
107                          const char *sname,
108                          const char *value)
109 {
110         struct smb2_handle handle;
111         struct smb2_create create;
112         struct smb2_read r;
113         NTSTATUS status;
114         const char *full_name;
115
116         full_name = talloc_asprintf(mem_ctx, "%s:%s", fname, sname);
117
118         ZERO_STRUCT(create);
119         create.in.desired_access = SEC_RIGHTS_FILE_ALL;
120         create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
121         create.in.create_disposition = NTCREATEX_DISP_OPEN;
122         create.in.fname = full_name;
123
124         status = smb2_create(tree, mem_ctx, &create);
125         if (!NT_STATUS_IS_OK(status)) {
126                 if (value == NULL) {
127                         return true;
128                 } else {
129                         torture_comment(mem_ctx, "Unable to open stream %s\n",
130                             full_name);
131                         return false;
132                 }
133         }
134
135         handle = create.out.file.handle;
136         if (value == NULL) {
137                 return true;
138         }
139
140
141         ZERO_STRUCT(r);
142         r.in.file.handle = handle;
143         r.in.length      = strlen(value)+11;
144         r.in.offset      = 0;
145
146         status = smb2_read(tree, tree, &r);
147
148         if (!NT_STATUS_IS_OK(status)) {
149                 torture_comment(mem_ctx, "(%s) Failed to read %lu bytes from "
150                     "stream '%s'\n", location, (long)strlen(value), full_name);
151                 return false;
152         }
153
154         if (memcmp(r.out.data.data, value, strlen(value)) != 0) {
155                 torture_comment(mem_ctx, "(%s) Bad data in stream\n", location);
156                 return false;
157         }
158
159         smb2_util_close(tree, handle);
160         return true;
161 }
162
163 static bool check_stream_list(struct smb2_tree *tree,
164                               struct torture_context *tctx,
165                               const char *fname,
166                               int num_exp,
167                               const char **exp,
168                               struct smb2_handle h)
169 {
170         union smb_fileinfo finfo;
171         NTSTATUS status;
172         int i;
173         TALLOC_CTX *tmp_ctx = talloc_new(tctx);
174         char **exp_sort;
175         struct stream_struct *stream_sort;
176         bool ret = false;
177
178         finfo.generic.level = RAW_FILEINFO_STREAM_INFORMATION;
179         finfo.generic.in.file.handle = h;
180
181         status = smb2_getinfo_file(tree, tctx, &finfo);
182         if (!NT_STATUS_IS_OK(status)) {
183                 torture_comment(tctx, "(%s) smb_raw_pathinfo failed: %s\n",
184                     __location__, nt_errstr(status));
185                 goto fail;
186         }
187
188         if (finfo.stream_info.out.num_streams != num_exp) {
189                 torture_comment(tctx, "(%s) expected %d streams, got %d\n",
190                     __location__, num_exp, finfo.stream_info.out.num_streams);
191                 goto fail;
192         }
193
194         if (num_exp == 0) {
195                 ret = true;
196                 goto fail;
197         }
198
199         exp_sort = talloc_memdup(tmp_ctx, exp, num_exp * sizeof(*exp));
200
201         if (exp_sort == NULL) {
202                 goto fail;
203         }
204
205         qsort(exp_sort, num_exp, sizeof(*exp_sort), qsort_string);
206
207         stream_sort = talloc_memdup(tmp_ctx, finfo.stream_info.out.streams,
208                                     finfo.stream_info.out.num_streams *
209                                     sizeof(*stream_sort));
210
211         if (stream_sort == NULL) {
212                 goto fail;
213         }
214
215         qsort(stream_sort, finfo.stream_info.out.num_streams,
216               sizeof(*stream_sort), qsort_stream);
217
218         for (i=0; i<num_exp; i++) {
219                 if (strcmp(exp_sort[i], stream_sort[i].stream_name.s) != 0) {
220                         torture_comment(tctx,
221                             "(%s) expected stream name %s, got %s\n",
222                             __location__, exp_sort[i],
223                             stream_sort[i].stream_name.s);
224                         goto fail;
225                 }
226         }
227
228         ret = true;
229  fail:
230         talloc_free(tmp_ctx);
231         return ret;
232 }
233
234
235 static bool test_stream_dir(struct torture_context *tctx,
236                             struct smb2_tree *tree)
237 {
238         TALLOC_CTX *mem_ctx = talloc_new(tctx);
239         NTSTATUS status;
240         union smb_open io;
241         const char *fname = DNAME "\\stream.txt";
242         const char *sname1;
243         bool ret = true;
244         const char *basedir_data;
245         struct smb2_handle h;
246
247         smb2_util_unlink(tree, fname);
248         smb2_deltree(tree, DNAME);
249
250         status = torture_smb2_testdir(tree, DNAME, &h);
251         CHECK_STATUS(status, NT_STATUS_OK);
252
253         basedir_data = talloc_asprintf(mem_ctx, "%s::$DATA", DNAME);
254         sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
255         torture_comment(tctx, "%s\n", sname1);
256
257         torture_comment(tctx, "(%s) opening non-existant directory stream\n",
258             __location__);
259         ZERO_STRUCT(io.smb2);
260         io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
261         io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
262         io.smb2.in.file_attributes   = FILE_ATTRIBUTE_NORMAL;
263         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
264         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
265         io.smb2.in.share_access = 0;
266         io.smb2.in.alloc_size = 0;
267         io.smb2.in.security_flags = 0;
268         io.smb2.in.fname = sname1;
269         io.smb2.in.create_flags = 0;
270         status = smb2_create(tree, mem_ctx, &(io.smb2));
271         CHECK_STATUS(status, NT_STATUS_NOT_A_DIRECTORY);
272
273         torture_comment(tctx, "(%s) opening basedir  stream\n", __location__);
274         ZERO_STRUCT(io.smb2);
275         io.smb2.in.create_flags = 0;
276         io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
277         io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
278         io.smb2.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
279         io.smb2.in.share_access = 0;
280         io.smb2.in.alloc_size = 0;
281         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
282         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
283         io.smb2.in.security_flags = 0;
284         io.smb2.in.fname = basedir_data;
285         status = smb2_create(tree, mem_ctx, &(io.smb2));
286         CHECK_STATUS(status, NT_STATUS_NOT_A_DIRECTORY);
287
288         torture_comment(tctx, "(%s) opening basedir ::$DATA stream\n",
289             __location__);
290         ZERO_STRUCT(io.smb2);
291         io.smb2.in.create_flags = 0x10;
292         io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
293         io.smb2.in.create_options = 0;
294         io.smb2.in.file_attributes = 0;
295         io.smb2.in.share_access = 0;
296         io.smb2.in.alloc_size = 0;
297         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
298         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
299         io.smb2.in.security_flags = 0;
300         io.smb2.in.fname = basedir_data;
301         status = smb2_create(tree, mem_ctx, &(io.smb2));
302         CHECK_STATUS(status, NT_STATUS_FILE_IS_A_DIRECTORY);
303
304         torture_comment(tctx, "(%s) list the streams on the basedir\n",
305             __location__);
306         ret &= check_stream_list(tree, mem_ctx, DNAME, 0, NULL, h);
307 done:
308         smb2_util_unlink(tree, fname);
309         smb2_deltree(tree, DNAME);
310         talloc_free(mem_ctx);
311
312         return ret;
313 }
314
315 static bool test_stream_io(struct torture_context *tctx,
316                            struct smb2_tree *tree)
317 {
318         TALLOC_CTX *mem_ctx = talloc_new(tctx);
319         NTSTATUS status;
320         union smb_open io;
321         const char *fname = DNAME "\\stream.txt";
322         const char *sname1, *sname2;
323         bool ret = true;
324         struct smb2_handle h, h2;
325
326         const char *one[] = { "::$DATA" };
327         const char *two[] = { "::$DATA", ":Second Stream:$DATA" };
328         const char *three[] = { "::$DATA", ":Stream One:$DATA",
329                                 ":Second Stream:$DATA" };
330
331         sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
332         sname2 = talloc_asprintf(mem_ctx, "%s:%s:$DaTa", fname,
333                                  "Second Stream");
334
335         smb2_util_unlink(tree, fname);
336         smb2_deltree(tree, DNAME);
337
338         status = torture_smb2_testdir(tree, DNAME, &h);
339         CHECK_STATUS(status, NT_STATUS_OK);
340
341         torture_comment(tctx, "(%s) creating a stream on a non-existant file\n",
342                 __location__);
343
344         ZERO_STRUCT(io.smb2);
345         io.smb2.in.create_flags = 0;
346         io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
347         io.smb2.in.create_options = 0;
348         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
349         io.smb2.in.share_access = 0;
350         io.smb2.in.alloc_size = 0;
351         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
352         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
353         io.smb2.in.security_flags = 0;
354         io.smb2.in.fname = sname1;
355         status = smb2_create(tree, mem_ctx, &(io.smb2));
356         CHECK_STATUS(status, NT_STATUS_OK);
357         h2 = io.smb2.out.file.handle;
358
359         ret &= check_stream(tree, __location__, mem_ctx, fname,
360                             "Stream One", NULL);
361
362         torture_comment(tctx, "(%s) check that open of base file is allowed\n", __location__);
363         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
364         io.smb2.in.fname = fname;
365         status = smb2_create(tree, mem_ctx, &(io.smb2));
366         CHECK_STATUS(status, NT_STATUS_OK);
367         smb2_util_close(tree, io.smb2.out.file.handle);
368
369         torture_comment(tctx, "(%s) writing to stream\n", __location__);
370         status = smb2_util_write(tree, h2, "test data", 0, 9);
371         CHECK_STATUS(status, NT_STATUS_OK);
372
373         smb2_util_close(tree, h2);
374
375         ret &= check_stream(tree, __location__, mem_ctx, fname,
376                             "Stream One", "test data");
377
378         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
379         io.smb2.in.fname = sname1;
380         status = smb2_create(tree, mem_ctx, &(io.smb2));
381         CHECK_STATUS(status, NT_STATUS_OK);
382         h2 = io.smb2.out.file.handle;
383
384         torture_comment(tctx, "(%s) modifying stream\n", __location__);
385         status = smb2_util_write(tree, h2, "MORE DATA ", 5, 10);
386         CHECK_STATUS(status, NT_STATUS_OK);
387
388         smb2_util_close(tree, h2);
389
390         ret &= check_stream(tree, __location__, mem_ctx, fname,
391                             "Stream One:$FOO", NULL);
392
393         torture_comment(tctx, "(%s) creating a stream2 on a existing file\n",
394             __location__);
395         io.smb2.in.fname = sname2;
396         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
397         status = smb2_create(tree, mem_ctx, &(io.smb2));
398         CHECK_STATUS(status, NT_STATUS_OK);
399         h2 = io.smb2.out.file.handle;
400
401         torture_comment(tctx, "(%s) modifying stream\n", __location__);
402         status= smb2_util_write(tree, h2, "SECOND STREAM", 0, 13);
403         CHECK_STATUS(status, NT_STATUS_OK);
404         smb2_util_close(tree, h2);
405
406         ret &= check_stream(tree, __location__, mem_ctx, fname,
407                              "Stream One", "test MORE DATA ");
408
409         ret &= check_stream(tree, __location__, mem_ctx, fname,
410                             "Stream One:$DATA", "test MORE DATA ");
411
412         ret &= check_stream(tree, __location__, mem_ctx, fname,
413                             "Stream One:", NULL);
414
415         ret &= check_stream(tree, __location__, mem_ctx, fname,
416                             "Second Stream", "SECOND STREAM");
417
418         if (!torture_setting_bool(tctx, "samba4", false)) {
419                 ret &= check_stream(tree, __location__, mem_ctx, fname,
420                                     "SECOND STREAM:$DATA", "SECOND STREAM");
421         }
422         ret &= check_stream(tree, __location__, mem_ctx, fname,
423                             "Second Stream:$DATA", "SECOND STREAM");
424
425         ret &= check_stream(tree, __location__, mem_ctx, fname,
426                             "Second Stream:", NULL);
427
428         ret &= check_stream(tree, __location__, mem_ctx, fname,
429                             "Second Stream:$FOO", NULL);
430
431         io.smb2.in.fname = sname2;
432         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
433         status = smb2_create(tree, mem_ctx, &(io.smb2));
434         CHECK_STATUS(status, NT_STATUS_OK);
435         h2 = io.smb2.out.file.handle;
436         check_stream_list(tree, tctx, fname, 3, three, h2);
437
438         smb2_util_close(tree, h2);
439
440         torture_comment(tctx, "(%s) deleting stream\n", __location__);
441         status = smb2_util_unlink(tree, sname1);
442         CHECK_STATUS(status, NT_STATUS_OK);
443
444         io.smb2.in.fname = sname2;
445         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
446         status = smb2_create(tree, mem_ctx, &(io.smb2));
447         CHECK_STATUS(status, NT_STATUS_OK);
448         h2 = io.smb2.out.file.handle;
449         check_stream_list(tree, tctx, fname, 2, two, h2);
450         smb2_util_close(tree, h2);
451
452         torture_comment(tctx, "(%s) delete a stream via delete-on-close\n",
453             __location__);
454         io.smb2.in.fname = sname2;
455         io.smb2.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
456         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE;
457         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
458         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
459
460         status = smb2_create(tree, mem_ctx, &(io.smb2));
461         CHECK_STATUS(status, NT_STATUS_OK);
462         h2 = io.smb2.out.file.handle;
463
464         smb2_util_close(tree, h2);
465         status = smb2_util_unlink(tree, sname2);
466         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
467
468         io.smb2.in.fname = fname;
469         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
470         status = smb2_create(tree, mem_ctx, &(io.smb2));
471         h2 = io.smb2.out.file.handle;
472         check_stream_list(tree,tctx, fname, 1, one, h2);
473         smb2_util_close(tree, h2);
474
475         if (!torture_setting_bool(tctx, "samba4", false)) {
476                 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
477                 io.smb2.in.fname = sname1;
478                 status = smb2_create(tree, mem_ctx, &(io.smb2));
479                 CHECK_STATUS(status, NT_STATUS_OK);
480                 smb2_util_close(tree, io.ntcreatex.out.file.handle);
481                 io.smb2.in.fname = sname2;
482                 status = smb2_create(tree, mem_ctx, &(io.smb2));
483                 CHECK_STATUS(status, NT_STATUS_OK);
484                 smb2_util_close(tree, io.ntcreatex.out.file.handle);
485         }
486
487         torture_comment(tctx, "(%s) deleting file\n", __location__);
488         status = smb2_util_unlink(tree, fname);
489         CHECK_STATUS(status, NT_STATUS_OK);
490
491 done:
492         smb2_util_close(tree, h2);
493         smb2_deltree(tree, DNAME);
494         talloc_free(mem_ctx);
495
496         return ret;
497 }
498
499 /*
500   test stream sharemodes
501 */
502 static bool test_stream_sharemodes(struct torture_context *tctx,
503                                    struct smb2_tree *tree)
504 {
505         TALLOC_CTX *mem_ctx = talloc_new(tctx);
506         NTSTATUS status;
507         union smb_open io;
508         const char *fname = DNAME "\\stream_share.txt";
509         const char *sname1, *sname2;
510         bool ret = true;
511         struct smb2_handle h, h1, h2;
512
513         sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
514         sname2 = talloc_asprintf(mem_ctx, "%s:%s:$DaTa", fname,
515                                  "Second Stream");
516
517         smb2_util_unlink(tree, fname);
518         smb2_deltree(tree, DNAME);
519
520         status = torture_smb2_testdir(tree, DNAME, &h);
521         CHECK_STATUS(status, NT_STATUS_OK);
522
523         torture_comment(tctx, "(%s) Testing stream share mode conflicts\n",
524             __location__);
525         ZERO_STRUCT(io.smb2);
526         io.generic.level = RAW_OPEN_SMB2;
527         io.smb2.in.create_flags = 0;
528         io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
529         io.smb2.in.create_options = 0;
530         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
531         io.smb2.in.share_access = 0;
532         io.smb2.in.alloc_size = 0;
533         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
534         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
535         io.smb2.in.security_flags = 0;
536         io.smb2.in.fname = sname1;
537
538         status = smb2_create(tree, mem_ctx, &(io.smb2));
539         CHECK_STATUS(status, NT_STATUS_OK);
540         h1 = io.smb2.out.file.handle;
541
542         /*
543          * A different stream does not give a sharing violation
544          */
545
546         io.smb2.in.fname = sname2;
547         status = smb2_create(tree, mem_ctx, &(io.smb2));
548         CHECK_STATUS(status, NT_STATUS_OK);
549         h2 = io.smb2.out.file.handle;
550
551         /*
552          * ... whereas the same stream does with unchanged access/share_access
553          * flags
554          */
555
556         io.smb2.in.fname = sname1;
557         io.smb2.in.create_disposition = 0;
558         status = smb2_create(tree, mem_ctx, &(io.smb2));
559         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
560
561         io.smb2.in.fname = sname2;
562         status = smb2_create(tree, mem_ctx, &(io.smb2));
563         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
564
565 done:
566         smb2_util_close(tree, h1);
567         smb2_util_close(tree, h2);
568         status = smb2_util_unlink(tree, fname);
569         smb2_deltree(tree, DNAME);
570         talloc_free(mem_ctx);
571
572         return ret;
573 }
574
575 /*
576  *  Test FILE_SHARE_DELETE on streams
577  *
578  * A stream opened with !FILE_SHARE_DELETE prevents the main file to be opened
579  * with SEC_STD_DELETE.
580  *
581  * The main file opened with !FILE_SHARE_DELETE does *not* prevent a stream to
582  * be opened with SEC_STD_DELETE.
583  *
584  * A stream held open with FILE_SHARE_DELETE allows the file to be
585  * deleted. After the main file is deleted, access to the open file descriptor
586  * still works, but all name-based access to both the main file as well as the
587  * stream is denied with DELETE pending.
588  *
589  * This means, an open of the main file with SEC_STD_DELETE should walk all
590  * streams and also open them with SEC_STD_DELETE. If any of these opens gives
591  * SHARING_VIOLATION, the main open fails.
592  *
593  * Closing the main file after delete_on_close has been set does not really
594  * unlink it but leaves the corresponding share mode entry with
595  * delete_on_close being set around until all streams are closed.
596  *
597  * Opening a stream must also look at the main file's share mode entry, look
598  * at the delete_on_close bit and potentially return DELETE_PENDING.
599  */
600
601 static bool test_stream_delete(struct torture_context *tctx,
602                                struct smb2_tree *tree)
603 {
604         TALLOC_CTX *mem_ctx = talloc_new(tctx);
605         NTSTATUS status;
606         union smb_open io;
607         const char *fname = DNAME "\\stream_delete.txt";
608         const char *sname1;
609         bool ret = true;
610         struct smb2_handle h, h1;
611         struct smb2_read r;
612
613         if (!torture_setting_bool(tctx, "samba4", true)) {
614                 torture_comment(tctx, "Skipping test as samba4 is enabled\n");
615                 goto done;
616         }
617
618         sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
619
620         /* clean slate .. */
621         smb2_util_unlink(tree, fname);
622         smb2_deltree(tree, fname);
623         smb2_deltree(tree, DNAME);
624
625         status = torture_smb2_testdir(tree, DNAME, &h);
626         CHECK_STATUS(status, NT_STATUS_OK);
627
628         torture_comment(tctx, "(%s) opening non-existant file stream\n",
629             __location__);
630         ZERO_STRUCT(io.smb2);
631         io.smb2.in.create_flags = 0;
632         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
633         io.smb2.in.create_options = 0;
634         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
635         io.smb2.in.share_access = 0;
636         io.smb2.in.alloc_size = 0;
637         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
638         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
639         io.smb2.in.security_flags = 0;
640         io.smb2.in.fname = sname1;
641
642         status = smb2_create(tree, mem_ctx, &(io.smb2));
643         CHECK_STATUS(status, NT_STATUS_OK);
644         h1 = io.smb2.out.file.handle;
645
646         status = smb2_util_write(tree, h1, "test data", 0, 9);
647         CHECK_STATUS(status, NT_STATUS_OK);
648
649         /*
650          * One stream opened without FILE_SHARE_DELETE prevents the main file
651          * to be deleted or even opened with DELETE access
652          */
653
654         status = smb2_util_unlink(tree, fname);
655         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
656
657         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
658         io.smb2.in.fname = fname;
659         io.smb2.in.desired_access = SEC_STD_DELETE;
660         status = smb2_create(tree, mem_ctx, &(io.smb2));
661         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
662
663         smb2_util_close(tree, h1);
664
665         /*
666          * ... but unlink works if a stream is opened with FILE_SHARE_DELETE
667          */
668
669         io.smb2.in.fname = sname1;
670         io.smb2.in.desired_access = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA;
671         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
672                         NTCREATEX_SHARE_ACCESS_READ |
673                         NTCREATEX_SHARE_ACCESS_WRITE;
674         status = smb2_create(tree, mem_ctx, &(io.smb2));
675         CHECK_STATUS(status, NT_STATUS_OK);
676         h1 = io.smb2.out.file.handle;
677
678         status = smb2_util_unlink(tree, fname);
679         CHECK_STATUS(status, NT_STATUS_OK);
680
681         /*
682          * file access still works on the stream while the main file is closed
683          */
684         ZERO_STRUCT(r);
685         r.in.file.handle = h1;
686         r.in.length      = 9;
687         r.in.offset      = 0;
688
689         status = smb2_read(tree, tree, &r);
690         CHECK_STATUS(status, NT_STATUS_OK);
691
692         /*
693          * name-based access to both the main file and the stream does not
694          * work anymore but gives DELETE_PENDING
695          */
696
697         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
698         io.smb2.in.fname = fname;
699         status = smb2_create(tree, mem_ctx, &(io.smb2));
700         CHECK_STATUS(status, NT_STATUS_DELETE_PENDING);
701
702         /*
703          * older S3 doesn't do this
704          */
705
706         io.smb2.in.fname = sname1;
707         status = smb2_create(tree, mem_ctx, &(io.smb2));
708         CHECK_STATUS(status, NT_STATUS_DELETE_PENDING);
709
710         smb2_util_close(tree, h1);
711
712         /*
713          * After closing the stream the file is really gone.
714          */
715
716         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
717         io.smb2.in.fname = fname;
718         status = smb2_create(tree, mem_ctx, &(io.smb2));
719         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
720
721 done:
722         smb2_util_close(tree, h1);
723         smb2_util_unlink(tree, fname);
724         smb2_deltree(tree, DNAME);
725         talloc_free(mem_ctx);
726
727         return ret;
728 }
729
730 /*
731   test stream names
732 */
733 static bool test_stream_names(struct torture_context *tctx,
734                               struct smb2_tree *tree)
735 {
736         TALLOC_CTX *mem_ctx = talloc_new(tctx);
737         NTSTATUS status;
738         union smb_open io;
739         union smb_fileinfo finfo;
740         union smb_fileinfo stinfo;
741         union smb_setfileinfo sinfo;
742         const char *fname = DNAME "\\stream_names.txt";
743         const char *sname1, *sname1b, *sname1c, *sname1d;
744         const char *sname2, *snamew, *snamew2;
745         const char *snamer1, *snamer2;
746         bool ret = true;
747         struct smb2_handle h, h1, h2, h3;
748         int i;
749         const char *four[4] = {
750                 "::$DATA",
751                 ":\x05Stream\n One:$DATA",
752                 ":MStream Two:$DATA",
753                 ":?Stream*:$DATA"
754         };
755         const char *five1[5] = {
756                 "::$DATA",
757                 ":\x05Stream\n One:$DATA",
758                 ":BeforeRename:$DATA",
759                 ":MStream Two:$DATA",
760                 ":?Stream*:$DATA"
761         };
762         const char *five2[5] = {
763                 "::$DATA",
764                 ":\x05Stream\n One:$DATA",
765                 ":AfterRename:$DATA",
766                 ":MStream Two:$DATA",
767                 ":?Stream*:$DATA"
768         };
769
770         sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "\x05Stream\n One");
771         sname1b = talloc_asprintf(mem_ctx, "%s:", sname1);
772         sname1c = talloc_asprintf(mem_ctx, "%s:$FOO", sname1);
773         sname1d = talloc_asprintf(mem_ctx, "%s:?D*a", sname1);
774         sname2 = talloc_asprintf(mem_ctx, "%s:%s:$DaTa", fname, "MStream Two");
775         snamew = talloc_asprintf(mem_ctx, "%s:%s:$DATA", fname, "?Stream*");
776         snamew2 = talloc_asprintf(mem_ctx, "%s\\stream*:%s:$DATA", DNAME,
777                                   "?Stream*");
778         snamer1 = talloc_asprintf(mem_ctx, "%s:%s:$DATA", fname,
779                                   "BeforeRename");
780         snamer2 = talloc_asprintf(mem_ctx, "%s:%s:$DATA", fname, "AfterRename");
781
782         /* clean slate ...*/
783         smb2_util_unlink(tree, fname);
784         smb2_deltree(tree, fname);
785         smb2_deltree(tree, DNAME);
786
787         status = torture_smb2_testdir(tree, DNAME, &h);
788         CHECK_STATUS(status, NT_STATUS_OK);
789
790         torture_comment(tctx, "(%s) testing stream names\n", __location__);
791         ZERO_STRUCT(io.smb2);
792         io.smb2.in.create_flags = 0;
793         io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
794         io.smb2.in.create_options = 0;
795         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
796         io.smb2.in.share_access = 0;
797         io.smb2.in.alloc_size = 0;
798         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
799         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
800         io.smb2.in.security_flags = 0;
801         io.smb2.in.fname = sname1;
802
803         status = smb2_create(tree, mem_ctx, &(io.smb2));
804         CHECK_STATUS(status, NT_STATUS_OK);
805         h1 = io.smb2.out.file.handle;
806
807         /*
808          * A different stream does not give a sharing violation
809          */
810
811         io.smb2.in.fname = sname2;
812         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
813         status = smb2_create(tree, mem_ctx, &(io.smb2));
814         CHECK_STATUS(status, NT_STATUS_OK);
815         h2 = io.smb2.out.file.handle;
816
817         /*
818          * ... whereas the same stream does with unchanged access/share_access
819          * flags
820          */
821
822         io.smb2.in.fname = sname1;
823         io.smb2.in.create_disposition = NTCREATEX_DISP_SUPERSEDE;
824         status = smb2_create(tree, mem_ctx, &(io.smb2));
825         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
826
827         io.smb2.in.fname = sname1b;
828         status = smb2_create(tree, mem_ctx, &(io.smb2));
829         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
830
831         io.smb2.in.fname = sname1c;
832         status = smb2_create(tree, mem_ctx, &(io.smb2));
833         if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
834                 /* w2k returns INVALID_PARAMETER */
835                 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
836         } else {
837                 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
838         }
839
840         io.smb2.in.fname = sname1d;
841         status = smb2_create(tree, mem_ctx, &(io.smb2));
842         if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
843                 /* w2k returns INVALID_PARAMETER */
844                 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
845         } else {
846                 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
847         }
848
849         io.smb2.in.fname = sname2;
850         status = smb2_create(tree, mem_ctx, &(io.smb2));
851         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
852
853         io.smb2.in.fname = snamew;
854         status = smb2_create(tree, mem_ctx, &(io.smb2));
855         CHECK_STATUS(status, NT_STATUS_OK);
856         h3 = io.smb2.out.file.handle;
857
858         io.smb2.in.fname = snamew2;
859         status = smb2_create(tree, mem_ctx, &(io.smb2));
860         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_INVALID);
861
862         io.smb2.in.fname = fname;
863         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
864         status = smb2_create(tree, mem_ctx, &(io.smb2));
865         CHECK_STATUS(status, NT_STATUS_OK);
866         ret &= check_stream_list(tree, tctx, fname, 4, four,
867                                  io.smb2.out.file.handle);
868
869         smb2_util_close(tree, h1);
870         smb2_util_close(tree, h2);
871         smb2_util_close(tree, h3);
872
873         if (torture_setting_bool(tctx, "samba4", true)) {
874                 goto done;
875         }
876
877         finfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
878         finfo.generic.in.file.handle = io.smb2.out.file.handle;
879         status = smb2_getinfo_file(tree, mem_ctx, &finfo);
880         CHECK_STATUS(status, NT_STATUS_OK);
881         ret &= check_stream_list(tree, tctx, fname, 4, four,
882                                  io.smb2.out.file.handle);
883
884         for (i=0; i < 4; i++) {
885                 NTTIME write_time;
886                 uint64_t stream_size;
887                 char *path = talloc_asprintf(tctx, "%s%s",
888                                              fname, four[i]);
889
890                 char *rpath = talloc_strdup(path, path);
891                 char *p = strrchr(rpath, ':');
892                 /* eat :$DATA */
893                 *p = 0;
894                 p--;
895                 if (*p == ':') {
896                         /* eat ::$DATA */
897                         *p = 0;
898                 }
899                 torture_comment(tctx, "(%s): i[%u][%s]\n",
900                     __location__, i,path);
901                 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
902                 io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
903                                 SEC_FILE_WRITE_ATTRIBUTE |
904                                 SEC_RIGHTS_FILE_ALL;
905                 io.smb2.in.fname = path;
906                 status = smb2_create(tree, mem_ctx, &(io.smb2));
907                 CHECK_STATUS(status, NT_STATUS_OK);
908                 h1 = io.smb2.out.file.handle;
909
910                 finfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
911                 finfo.generic.in.file.path = fname;
912                 status = smb2_getinfo_file(tree, mem_ctx, &finfo);
913                 CHECK_STATUS(status, NT_STATUS_OK);
914
915                 stinfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
916                 stinfo.generic.in.file.handle = h1;
917                 status = smb2_getinfo_file(tree, mem_ctx, &stinfo);
918                 CHECK_STATUS(status, NT_STATUS_OK);
919                 if (!torture_setting_bool(tctx, "samba3", false)) {
920                         CHECK_NTTIME(stinfo.all_info.out.create_time,
921                                      finfo.all_info.out.create_time);
922                         CHECK_NTTIME(stinfo.all_info.out.access_time,
923                                      finfo.all_info.out.access_time);
924                         CHECK_NTTIME(stinfo.all_info.out.write_time,
925                                      finfo.all_info.out.write_time);
926                         CHECK_NTTIME(stinfo.all_info.out.change_time,
927                                      finfo.all_info.out.change_time);
928                 }
929                 CHECK_VALUE(stinfo.all_info.out.attrib,
930                             finfo.all_info.out.attrib);
931                 CHECK_VALUE(stinfo.all_info.out.size,
932                             finfo.all_info.out.size);
933                 CHECK_VALUE(stinfo.all_info.out.delete_pending,
934                             finfo.all_info.out.delete_pending);
935                 CHECK_VALUE(stinfo.all_info.out.directory,
936                             finfo.all_info.out.directory);
937                 CHECK_VALUE(stinfo.all_info.out.ea_size,
938                             finfo.all_info.out.ea_size);
939
940                 stinfo.generic.level = RAW_FILEINFO_NAME_INFORMATION;
941                 stinfo.generic.in.file.handle = h1;
942                 status = smb2_getinfo_file(tree, mem_ctx, &stinfo);
943                 CHECK_STATUS(status, NT_STATUS_OK);
944                 if (!torture_setting_bool(tctx, "samba3", false)) {
945                         CHECK_STR(rpath, stinfo.name_info.out.fname.s);
946                 }
947
948                 write_time = finfo.all_info.out.write_time;
949                 write_time += i*1000000;
950                 write_time /= 1000000;
951                 write_time *= 1000000;
952
953                 ZERO_STRUCT(sinfo);
954                 sinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION;
955                 sinfo.basic_info.in.file.handle = h1;
956                 sinfo.basic_info.in.write_time = write_time;
957                 sinfo.basic_info.in.attrib = stinfo.all_info.out.attrib;
958                 status = smb2_setinfo_file(tree, &sinfo);
959                 CHECK_STATUS(status, NT_STATUS_OK);
960
961                 stream_size = i*8192;
962
963                 ZERO_STRUCT(sinfo);
964                 sinfo.end_of_file_info.level =
965                         RAW_SFILEINFO_END_OF_FILE_INFORMATION;
966                 sinfo.end_of_file_info.in.file.handle = h1;
967                 sinfo.end_of_file_info.in.size = stream_size;
968                 status = smb2_setinfo_file(tree, &sinfo);
969                 CHECK_STATUS(status, NT_STATUS_OK);
970
971                 stinfo.generic.level = RAW_FILEINFO_ALL_INFORMATION;
972                 stinfo.generic.in.file.handle = h1;
973                 status = smb2_getinfo_file(tree, mem_ctx, &stinfo);
974                 CHECK_STATUS(status, NT_STATUS_OK);
975                 if (!torture_setting_bool(tctx, "samba3", false)) {
976                         CHECK_NTTIME(stinfo.all_info.out.write_time,
977                                      write_time);
978                         CHECK_VALUE(stinfo.all_info.out.attrib,
979                                     finfo.all_info.out.attrib);
980                 }
981                 CHECK_VALUE(stinfo.all_info.out.size,
982                             stream_size);
983                 CHECK_VALUE(stinfo.all_info.out.delete_pending,
984                             finfo.all_info.out.delete_pending);
985                 CHECK_VALUE(stinfo.all_info.out.directory,
986                             finfo.all_info.out.directory);
987                 CHECK_VALUE(stinfo.all_info.out.ea_size,
988                             finfo.all_info.out.ea_size);
989
990                 io.smb2.in.fname = fname;
991                 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
992                 status = smb2_create(tree, mem_ctx, &(io.smb2));
993                 CHECK_STATUS(status, NT_STATUS_OK);
994                 ret &= check_stream_list(tree, tctx, fname, 4, four,
995                                          io.smb2.out.file.handle);
996
997                 smb2_util_close(tree, h1);
998                 talloc_free(path);
999         }
1000
1001         torture_comment(tctx, "(%s): testing stream renames\n", __location__);
1002         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1003         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
1004                                 SEC_FILE_WRITE_ATTRIBUTE |
1005                                 SEC_RIGHTS_FILE_ALL;
1006         io.smb2.in.fname = snamer1;
1007         status = smb2_create(tree, mem_ctx, &(io.smb2));
1008         CHECK_STATUS(status, NT_STATUS_OK);
1009         h1 = io.smb2.out.file.handle;
1010         ret &= check_stream_list(tree,tctx, fname, 5, five1,
1011                                  io.smb2.out.file.handle);
1012
1013         ZERO_STRUCT(sinfo);
1014         sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
1015         sinfo.rename_information.in.file.handle = h1;
1016         sinfo.rename_information.in.overwrite = true;
1017         sinfo.rename_information.in.root_fid = 0;
1018         sinfo.rename_information.in.new_name = ":AfterRename:$DATA";
1019         status = smb2_setinfo_file(tree, &sinfo);
1020         CHECK_STATUS(status, NT_STATUS_OK);
1021
1022         ret &= check_stream_list(tree,tctx, fname, 5, five2,
1023                                  io.smb2.out.file.handle);
1024
1025         ZERO_STRUCT(sinfo);
1026         sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
1027         sinfo.rename_information.in.file.handle = h1;
1028         sinfo.rename_information.in.overwrite = false;
1029         sinfo.rename_information.in.root_fid = 0;
1030         sinfo.rename_information.in.new_name = ":MStream Two:$DATA";
1031         status = smb2_setinfo_file(tree, &sinfo);
1032         CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_COLLISION);
1033
1034         ret &= check_stream_list(tree,tctx, fname, 5, five2,
1035                                  io.smb2.out.file.handle);
1036
1037         ZERO_STRUCT(sinfo);
1038         sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
1039         sinfo.rename_information.in.file.handle = h1;
1040         sinfo.rename_information.in.overwrite = true;
1041         sinfo.rename_information.in.root_fid = 0;
1042         sinfo.rename_information.in.new_name = ":MStream Two:$DATA";
1043         status = smb2_setinfo_file(tree, &sinfo);
1044         CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
1045
1046         ret &= check_stream_list(tree,tctx, fname, 5, five2,
1047                                  io.smb2.out.file.handle);
1048
1049         /* TODO: we need to test more rename combinations */
1050
1051 done:
1052         smb2_util_close(tree, h1);
1053         status = smb2_util_unlink(tree, fname);
1054         smb2_deltree(tree, DNAME);
1055         talloc_free(mem_ctx);
1056
1057         return ret;
1058 }
1059
1060 /*
1061   test stream names
1062 */
1063 static bool test_stream_names2(struct torture_context *tctx,
1064                                struct smb2_tree *tree)
1065 {
1066         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1067         NTSTATUS status;
1068         union smb_open io;
1069         const char *fname = DNAME "\\stream_names2.txt";
1070         bool ret = true;
1071         struct smb2_handle h, h1;
1072         uint8_t i;
1073
1074         smb2_util_unlink(tree, fname);
1075         smb2_deltree(tree, DNAME);
1076
1077         status = torture_smb2_testdir(tree, DNAME, &h);
1078         CHECK_STATUS(status, NT_STATUS_OK);
1079
1080         torture_comment(tctx, "(%s) testing stream names\n", __location__);
1081         ZERO_STRUCT(io.smb2);
1082         io.smb2.in.create_flags = 0;
1083         io.smb2.in.desired_access = SEC_FILE_WRITE_DATA;
1084         io.smb2.in.create_options = 0;
1085         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1086         io.smb2.in.share_access = 0;
1087         io.smb2.in.alloc_size = 0;
1088         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1089         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1090         io.smb2.in.security_flags = 0;
1091         io.smb2.in.fname = fname;
1092         status = smb2_create(tree, mem_ctx, &(io.smb2));
1093         CHECK_STATUS(status, NT_STATUS_OK);
1094         h1 = io.smb2.out.file.handle;
1095
1096         for (i=0x01; i < 0x7F; i++) {
1097                 char *path = talloc_asprintf(mem_ctx, "%s:Stream%c0x%02X:$DATA",
1098                                              fname, i, i);
1099                 NTSTATUS expected;
1100
1101                 switch (i) {
1102                 case '/':/*0x2F*/
1103                 case ':':/*0x3A*/
1104                 case '\\':/*0x5C*/
1105                         expected = NT_STATUS_OBJECT_NAME_INVALID;
1106                         break;
1107                 default:
1108                         expected = NT_STATUS_OBJECT_NAME_NOT_FOUND;
1109                         break;
1110                 }
1111
1112
1113                 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1114                 io.smb2.in.fname = path;
1115                 status = smb2_create(tree, mem_ctx, &(io.smb2));
1116                 if (!NT_STATUS_EQUAL(status, expected)) {
1117                         torture_comment(tctx,
1118                             "(%s) %s:Stream%c0x%02X:$DATA%s => expected[%s]\n",
1119                             __location__, fname, isprint(i)?(char)i:' ', i,
1120                             isprint(i)?"":" (not printable)",
1121                             nt_errstr(expected));
1122                 }
1123                 CHECK_STATUS(status, expected);
1124
1125                 talloc_free(path);
1126         }
1127
1128 done:
1129         smb2_util_close(tree, h1);
1130         status = smb2_util_unlink(tree, fname);
1131         smb2_deltree(tree, DNAME);
1132         talloc_free(mem_ctx);
1133
1134         return ret;
1135 }
1136
1137 #define CHECK_CALL_HANDLE(call, rightstatus) do { \
1138         check_handle = true; \
1139         call_name = #call; \
1140         sfinfo.generic.level = RAW_SFILEINFO_ ## call; \
1141         sfinfo.generic.in.file.handle = h1; \
1142         status = smb2_setinfo_file(tree, &sfinfo); \
1143         if (!NT_STATUS_EQUAL(status, rightstatus)) { \
1144                 torture_comment(tctx,"(%s) %s - %s (should be %s)\n", \
1145                     __location__, #call, \
1146                     nt_errstr(status), nt_errstr(rightstatus)); \
1147                 ret = false; \
1148         } \
1149         finfo1.generic.level = RAW_FILEINFO_ALL_INFORMATION; \
1150         finfo1.generic.in.file.handle = h1; \
1151         status2 = smb2_getinfo_file(tree, tctx, &finfo1); \
1152         if (!NT_STATUS_IS_OK(status2)) { \
1153                 torture_comment(tctx,"(%s) %s pathinfo - %s\n", \
1154                     __location__, #call, nt_errstr(status)); \
1155                 ret = false; \
1156         }} while (0)
1157
1158 /*
1159   test stream renames
1160 */
1161 static bool test_stream_rename(struct torture_context *tctx,
1162                                struct smb2_tree *tree)
1163 {
1164         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1165         NTSTATUS status, status2;
1166         union smb_open io;
1167         const char *fname = DNAME "\\stream_rename.txt";
1168         const char *sname1, *sname2;
1169         union smb_fileinfo finfo1;
1170         union smb_setfileinfo sfinfo;
1171         bool ret = true;
1172         struct smb2_handle h, h1;
1173         bool check_handle;
1174         const char *call_name;
1175
1176         sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname, "Stream One");
1177         sname2 = talloc_asprintf(mem_ctx, "%s:%s:$DaTa", fname,
1178                                  "Second Stream");
1179
1180         smb2_util_unlink(tree, fname);
1181         smb2_deltree(tree, DNAME);
1182
1183         status = torture_smb2_testdir(tree, DNAME, &h);
1184         CHECK_STATUS(status, NT_STATUS_OK);
1185
1186         torture_comment(tctx, "(%s) testing stream renames\n", __location__);
1187         ZERO_STRUCT(io.smb2);
1188         io.smb2.in.create_flags = 0;
1189         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
1190                                       SEC_FILE_WRITE_ATTRIBUTE |
1191                                     SEC_RIGHTS_FILE_ALL;
1192         io.smb2.in.create_options = 0;
1193         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1194         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1195                         NTCREATEX_SHARE_ACCESS_WRITE |
1196                         NTCREATEX_SHARE_ACCESS_DELETE;
1197         io.smb2.in.alloc_size = 0;
1198         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1199         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1200         io.smb2.in.security_flags = 0;
1201         io.smb2.in.fname = sname1;
1202
1203         /* Create two streams. */
1204         status = smb2_create(tree, mem_ctx, &(io.smb2));
1205         CHECK_STATUS(status, NT_STATUS_OK);
1206         h1 = io.smb2.out.file.handle;
1207         smb2_util_close(tree, h1);
1208
1209         io.smb2.in.fname = sname2;
1210         status = smb2_create(tree, mem_ctx, &(io.smb2));
1211         CHECK_STATUS(status, NT_STATUS_OK);
1212         h1 = io.smb2.out.file.handle;
1213
1214         smb2_util_close(tree, h1);
1215
1216         /*
1217          * Open the second stream.
1218          */
1219
1220         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1221         status = smb2_create(tree, mem_ctx, &(io.smb2));
1222         CHECK_STATUS(status, NT_STATUS_OK);
1223         h1 = io.smb2.out.file.handle;
1224
1225         /*
1226          * Now rename the second stream onto the first.
1227          */
1228
1229         ZERO_STRUCT(sfinfo);
1230
1231         sfinfo.rename_information.in.overwrite = 1;
1232         sfinfo.rename_information.in.root_fid  = 0;
1233         sfinfo.rename_information.in.new_name  = ":Stream One";
1234         CHECK_CALL_HANDLE(RENAME_INFORMATION, NT_STATUS_OK);
1235 done:
1236         smb2_util_close(tree, h1);
1237         status = smb2_util_unlink(tree, fname);
1238         smb2_deltree(tree, DNAME);
1239         talloc_free(mem_ctx);
1240
1241         return ret;
1242 }
1243
1244 static bool test_stream_rename2(struct torture_context *tctx,
1245                                 struct smb2_tree *tree)
1246 {
1247         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1248         NTSTATUS status;
1249         union smb_open io;
1250         const char *fname1 = DNAME "\\stream_rename2.txt";
1251         const char *fname2 = DNAME "\\stream2_rename2.txt";
1252         const char *stream_name1 = ":Stream One:$DATA";
1253         const char *stream_name2 = ":Stream Two:$DATA";
1254         const char *stream_name_default = "::$DATA";
1255         const char *sname1;
1256         const char *sname2;
1257         bool ret = true;
1258         struct smb2_handle h, h1;
1259         union smb_setfileinfo sinfo;
1260
1261         sname1 = talloc_asprintf(mem_ctx, "%s:%s", fname1, "Stream One");
1262         sname2 = talloc_asprintf(mem_ctx, "%s:%s", fname1, "Stream Two");
1263
1264         smb2_util_unlink(tree, fname1);
1265         smb2_util_unlink(tree, fname2);
1266         smb2_deltree(tree, DNAME);
1267
1268         status = torture_smb2_testdir(tree, DNAME, &h);
1269         CHECK_STATUS(status, NT_STATUS_OK);
1270
1271         ZERO_STRUCT(io.smb2);
1272         io.smb2.in.create_flags = 0;
1273         io.smb2.in.desired_access = SEC_FILE_READ_DATA |
1274                                 SEC_FILE_WRITE_DATA |
1275                                 SEC_STD_DELETE |
1276                                 SEC_FILE_APPEND_DATA |
1277                                 SEC_STD_READ_CONTROL;
1278         io.smb2.in.create_options = 0;
1279         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1280         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1281                                 NTCREATEX_SHARE_ACCESS_WRITE |
1282                                 NTCREATEX_SHARE_ACCESS_DELETE;
1283         io.smb2.in.alloc_size = 0;
1284         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1285         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1286         io.smb2.in.security_flags = 0;
1287         io.smb2.in.fname = sname1;
1288
1289         /* Open/create new stream. */
1290         status = smb2_create(tree, mem_ctx, &(io.smb2));
1291         CHECK_STATUS(status, NT_STATUS_OK);
1292
1293         smb2_util_close(tree, io.smb2.out.file.handle);
1294
1295         /*
1296          * Reopen the stream for SMB2 renames.
1297          */
1298         io.smb2.in.fname = sname1;
1299         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1300         status = smb2_create(tree, mem_ctx, &(io.smb2));
1301         CHECK_STATUS(status, NT_STATUS_OK);
1302         h1 = io.smb2.out.file.handle;
1303
1304         /*
1305          * Check SMB2 rename of a stream using :<stream>.
1306          */
1307         torture_comment(tctx, "(%s) Checking SMB2 rename of a stream using "
1308                         ":<stream>\n", __location__);
1309         ZERO_STRUCT(sinfo);
1310         sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION_SMB2;
1311         sinfo.rename_information.in.file.handle = h1;
1312         sinfo.rename_information.in.overwrite = 1;
1313         sinfo.rename_information.in.root_fid = 0;
1314         sinfo.rename_information.in.new_name = stream_name1;
1315         status = smb2_setinfo_file(tree, &sinfo);
1316         CHECK_STATUS(status, NT_STATUS_OK);
1317
1318         /*
1319          * Check SMB2 rename of an overwriting stream using :<stream>.
1320          */
1321         torture_comment(tctx, "(%s) Checking SMB2 rename of an overwriting "
1322                         "stream using :<stream>\n", __location__);
1323
1324         /* Create second stream. */
1325         io.smb2.in.fname = sname2;
1326         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1327         status = smb2_create(tree, mem_ctx, &(io.smb2));
1328         CHECK_STATUS(status, NT_STATUS_OK);
1329         smb2_util_close(tree, io.smb2.out.file.handle);
1330
1331         /* Rename the first stream onto the second. */
1332         sinfo.rename_information.in.file.handle = h1;
1333         sinfo.rename_information.in.new_name = stream_name2;
1334         status = smb2_setinfo_file(tree, &sinfo);
1335         CHECK_STATUS(status, NT_STATUS_OK);
1336
1337         smb2_util_close(tree, h1);
1338
1339         /*
1340          * Reopen the stream with the new name.
1341          */
1342         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1343         io.smb2.in.fname = sname2;
1344         status = smb2_create(tree, mem_ctx, &(io.smb2));
1345         CHECK_STATUS(status, NT_STATUS_OK);
1346         h1 = io.smb2.out.file.handle;
1347
1348         /*
1349          * Check SMB2 rename of a stream using <base>:<stream>.
1350          */
1351         torture_comment(tctx, "(%s) Checking SMB2 rename of a stream using "
1352                         "<base>:<stream>\n", __location__);
1353         sinfo.rename_information.in.file.handle = h1;
1354         sinfo.rename_information.in.new_name = sname1;
1355         status = smb2_setinfo_file(tree, &sinfo);
1356         CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
1357
1358         /*
1359          * Check SMB2 rename to the default stream using :<stream>.
1360          */
1361         torture_comment(tctx, "(%s) Checking SMB2 rename to defaualt stream "
1362                         "using :<stream>\n", __location__);
1363         sinfo.rename_information.in.file.handle = h1;
1364         sinfo.rename_information.in.new_name = stream_name_default;
1365         status = smb2_setinfo_file(tree, &sinfo);
1366         CHECK_STATUS(status, NT_STATUS_OK);
1367
1368         smb2_util_close(tree, h1);
1369
1370  done:
1371         smb2_util_close(tree, h1);
1372         status = smb2_util_unlink(tree, fname1);
1373         status = smb2_util_unlink(tree, fname2);
1374         smb2_deltree(tree, DNAME);
1375         talloc_free(mem_ctx);
1376
1377         return ret;
1378 }
1379
1380 static bool create_file_with_stream(struct torture_context *tctx,
1381                                     struct smb2_tree *tree,
1382                                     TALLOC_CTX *mem_ctx,
1383                                     const char *base_fname,
1384                                     const char *stream)
1385 {
1386         NTSTATUS status;
1387         bool ret = true;
1388         union smb_open io;
1389
1390         /* Create a file with a stream */
1391         ZERO_STRUCT(io.smb2);
1392         io.smb2.in.create_flags = 0;
1393         io.smb2.in.desired_access = SEC_FILE_READ_DATA |
1394                                 SEC_FILE_WRITE_DATA |
1395                                 SEC_FILE_APPEND_DATA |
1396                                 SEC_STD_READ_CONTROL;
1397         io.smb2.in.create_options = 0;
1398         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1399         io.smb2.in.share_access = 0;
1400         io.smb2.in.alloc_size = 0;
1401         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1402         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1403         io.smb2.in.security_flags = 0;
1404         io.smb2.in.fname = stream;
1405
1406         status = smb2_create(tree, mem_ctx, &(io.smb2));
1407         CHECK_STATUS(status, NT_STATUS_OK);
1408
1409  done:
1410         smb2_util_close(tree, io.smb2.out.file.handle);
1411         return ret;
1412 }
1413
1414
1415 /* Test how streams interact with create dispositions */
1416 static bool test_stream_create_disposition(struct torture_context *tctx,
1417                                            struct smb2_tree *tree)
1418 {
1419         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1420         NTSTATUS status;
1421         union smb_open io;
1422         const char *fname = DNAME "\\stream_create_disp.txt";
1423         const char *stream = "Stream One:$DATA";
1424         const char *fname_stream;
1425         const char *default_stream_name = "::$DATA";
1426         const char *stream_list[2];
1427         bool ret = true;
1428         struct smb2_handle h, h1;
1429
1430         /* clean slate .. */
1431         smb2_util_unlink(tree, fname);
1432         smb2_deltree(tree, fname);
1433         smb2_deltree(tree, DNAME);
1434
1435         status = torture_smb2_testdir(tree, DNAME, &h);
1436         CHECK_STATUS(status, NT_STATUS_OK);
1437
1438         fname_stream = talloc_asprintf(mem_ctx, "%s:%s", fname, stream);
1439
1440         stream_list[0] = talloc_asprintf(mem_ctx, ":%s", stream);
1441         stream_list[1] = default_stream_name;
1442
1443         if (!create_file_with_stream(tctx, tree, mem_ctx, fname,
1444                                      fname_stream)) {
1445                 goto done;
1446         }
1447
1448         /* Open the base file with OPEN */
1449         ZERO_STRUCT(io.smb2);
1450         io.smb2.in.create_flags = 0;
1451         io.smb2.in.desired_access = SEC_FILE_READ_DATA |
1452                                 SEC_FILE_WRITE_DATA |
1453                                 SEC_FILE_APPEND_DATA |
1454                                 SEC_STD_READ_CONTROL;
1455         io.smb2.in.create_options = 0;
1456         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1457         io.smb2.in.share_access = 0;
1458         io.smb2.in.alloc_size = 0;
1459         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1460         io.smb2.in.security_flags = 0;
1461         io.smb2.in.fname = fname;
1462
1463         /*
1464          * check create open: sanity check
1465          */
1466         torture_comment(tctx, "(%s) Checking create disp: open\n",
1467                         __location__);
1468         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1469         status = smb2_create(tree, mem_ctx, &(io.smb2));
1470         CHECK_STATUS(status, NT_STATUS_OK);
1471         if (!check_stream_list(tree, tctx, fname, 2, stream_list,
1472                                io.smb2.out.file.handle)) {
1473                 goto done;
1474         }
1475         smb2_util_close(tree, io.smb2.out.file.handle);
1476
1477         /*
1478          * check create overwrite
1479          */
1480         torture_comment(tctx, "(%s) Checking create disp: overwrite\n",
1481                         __location__);
1482         io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
1483         status = smb2_create(tree, mem_ctx, &(io.smb2));
1484         CHECK_STATUS(status, NT_STATUS_OK);
1485         if (!check_stream_list(tree, tctx, fname, 1, &default_stream_name,
1486                                io.smb2.out.file.handle)) {
1487                 goto done;
1488         }
1489         smb2_util_close(tree, io.smb2.out.file.handle);
1490
1491         /*
1492          * check create overwrite_if
1493          */
1494         torture_comment(tctx, "(%s) Checking create disp: overwrite_if\n",
1495                         __location__);
1496         smb2_util_unlink(tree, fname);
1497         if (!create_file_with_stream(tctx, tree, mem_ctx, fname, fname_stream))
1498                 goto done;
1499
1500         io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1501         status = smb2_create(tree, mem_ctx, &(io.smb2));
1502         CHECK_STATUS(status, NT_STATUS_OK);
1503         if (!check_stream_list(tree, tctx, fname, 1, &default_stream_name,
1504                                io.smb2.out.file.handle)) {
1505                 goto done;
1506         }
1507         smb2_util_close(tree, io.smb2.out.file.handle);
1508
1509         /*
1510          * check create supersede
1511          */
1512         torture_comment(tctx, "(%s) Checking create disp: supersede\n",
1513                         __location__);
1514         smb2_util_unlink(tree, fname);
1515         if (!create_file_with_stream(tctx, tree, mem_ctx, fname,
1516                                      fname_stream)) {
1517                 goto done;
1518         }
1519
1520         io.smb2.in.create_disposition = NTCREATEX_DISP_SUPERSEDE;
1521         status = smb2_create(tree, mem_ctx, &(io.smb2));
1522         CHECK_STATUS(status, NT_STATUS_OK);
1523         if (!check_stream_list(tree, tctx, fname, 1, &default_stream_name,
1524                                io.smb2.out.file.handle)) {
1525                 goto done;
1526         }
1527         smb2_util_close(tree, io.smb2.out.file.handle);
1528
1529         /*
1530          * check create overwrite_if on a stream.
1531          */
1532         torture_comment(tctx, "(%s) Checking create disp: overwrite_if on "
1533                         "stream\n", __location__);
1534         smb2_util_unlink(tree, fname);
1535         if (!create_file_with_stream(tctx, tree, mem_ctx, fname,
1536                                      fname_stream)) {
1537                 goto done;
1538         }
1539
1540         io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1541         io.smb2.in.fname = fname_stream;
1542         status = smb2_create(tree, mem_ctx, &(io.smb2));
1543         CHECK_STATUS(status, NT_STATUS_OK);
1544         if (!check_stream_list(tree, tctx, fname, 2, stream_list,
1545                                io.smb2.out.file.handle)) {
1546                 goto done;
1547         }
1548         smb2_util_close(tree, io.smb2.out.file.handle);
1549  done:
1550         smb2_util_close(tree, h1);
1551         smb2_util_unlink(tree, fname);
1552         smb2_deltree(tree, DNAME);
1553         talloc_free(mem_ctx);
1554
1555         return ret;
1556 }
1557
1558 static bool open_stream(struct smb2_tree *tree,
1559                         struct torture_context *mem_ctx,
1560                         const char *fname,
1561                         struct smb2_handle *h_out)
1562 {
1563         NTSTATUS status;
1564         union smb_open io;
1565
1566         ZERO_STRUCT(io.smb2);
1567         io.smb2.in.create_flags = 0;
1568         io.smb2.in.desired_access = SEC_FILE_READ_DATA |
1569                                 SEC_FILE_WRITE_DATA |
1570                                 SEC_FILE_APPEND_DATA |
1571                                 SEC_STD_READ_CONTROL |
1572                                 SEC_FILE_WRITE_ATTRIBUTE;
1573         io.smb2.in.create_options = 0;
1574         io.smb2.in.file_attributes = 0;
1575         io.smb2.in.share_access = 0;
1576         io.smb2.in.alloc_size = 0;
1577         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1578         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1579         io.smb2.in.security_flags = 0;
1580         io.smb2.in.fname = fname;
1581
1582         status = smb2_create(tree, mem_ctx, &(io.smb2));
1583         if (!NT_STATUS_IS_OK(status)) {
1584                 return false;
1585         }
1586         *h_out = io.smb2.out.file.handle;
1587         return true;
1588 }
1589
1590
1591 /* Test the effect of setting attributes on a stream. */
1592 static bool test_stream_attributes(struct torture_context *tctx,
1593                                    struct smb2_tree *tree)
1594 {
1595         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1596         bool ret = true;
1597         NTSTATUS status;
1598         union smb_open io;
1599         const char *fname = DNAME "\\stream_attr.txt";
1600         const char *stream = "Stream One:$DATA";
1601         const char *fname_stream;
1602         struct smb2_handle h, h1;
1603         union smb_fileinfo finfo;
1604         union smb_setfileinfo sfinfo;
1605         time_t basetime = (time(NULL) - 86400) & ~1;
1606
1607         torture_comment(tctx, "(%s) testing attribute setting on stream\n",
1608                         __location__);
1609
1610         /* clean slate .. */
1611         smb2_util_unlink(tree, fname);
1612         smb2_deltree(tree, fname);
1613         smb2_deltree(tree, DNAME);
1614
1615         status = torture_smb2_testdir(tree, DNAME, &h);
1616         CHECK_STATUS(status, NT_STATUS_OK);
1617
1618         fname_stream = talloc_asprintf(mem_ctx, "%s:%s", fname, stream);
1619
1620         /* Create a file with a stream with attribute FILE_ATTRIBUTE_ARCHIVE. */
1621         ret = create_file_with_stream(tctx, tree, mem_ctx, fname,
1622                                       fname_stream);
1623         if (!ret) {
1624                 goto done;
1625         }
1626
1627         ZERO_STRUCT(io.smb2);
1628         io.smb2.in.fname = fname;
1629         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1630         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1631         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1632                                  NTCREATEX_SHARE_ACCESS_WRITE |
1633                                  NTCREATEX_SHARE_ACCESS_DELETE;
1634         status = smb2_create(tree, mem_ctx, &(io.smb2));
1635         CHECK_STATUS(status, NT_STATUS_OK);
1636
1637         ZERO_STRUCT(finfo);
1638         finfo.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
1639         finfo.generic.in.file.handle = io.smb2.out.file.handle;
1640         status = smb2_getinfo_file(tree, mem_ctx, &finfo);
1641         CHECK_STATUS(status, NT_STATUS_OK);
1642
1643         if (finfo.basic_info.out.attrib != FILE_ATTRIBUTE_ARCHIVE) {
1644                 torture_comment(tctx, "(%s) Incorrect attrib %x - should be "
1645                     "%x\n", __location__,
1646                     (unsigned int)finfo.basic_info.out.attrib,
1647                     (unsigned int)FILE_ATTRIBUTE_ARCHIVE);
1648                 ret = false;
1649                 goto done;
1650         }
1651
1652         smb2_util_close(tree, io.smb2.out.file.handle);
1653         /* Now open the stream name. */
1654
1655         if (!open_stream(tree, tctx, fname_stream, &h1)) {
1656                 goto done;
1657         }
1658
1659         /* Change the time on the stream. */
1660         ZERO_STRUCT(sfinfo);
1661         unix_to_nt_time(&sfinfo.basic_info.in.write_time, basetime);
1662         sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
1663         sfinfo.generic.in.file.handle = h1;
1664         status = smb2_setinfo_file(tree, &sfinfo);
1665         if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
1666                 torture_comment(tctx, "(%s) %s - %s (should be %s)\n",
1667                     __location__, "SETATTR",
1668                     nt_errstr(status), nt_errstr(NT_STATUS_OK));
1669                 ret = false;
1670                 goto done;
1671         }
1672
1673         smb2_util_close(tree, h1);
1674
1675         ZERO_STRUCT(io.smb2);
1676         io.smb2.in.fname = fname;
1677         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1678         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1679         status = smb2_create(tree, mem_ctx, &(io.smb2));
1680         CHECK_STATUS(status, NT_STATUS_OK);
1681         h1 = io.smb2.out.file.handle;
1682
1683         ZERO_STRUCT(finfo);
1684         finfo.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
1685         finfo.generic.in.file.handle = h1;
1686         status = smb2_getinfo_file(tree, mem_ctx, &finfo);
1687         if (!NT_STATUS_IS_OK(status)) {
1688                 torture_comment(tctx, "(%s) %s pathinfo - %s\n",
1689                     __location__, "SETATTRE", nt_errstr(status));
1690                 ret = false;
1691                 goto done;
1692         }
1693
1694         if (nt_time_to_unix(finfo.basic_info.out.write_time) != basetime) {
1695                 torture_comment(tctx, "(%s) time incorrect.\n", __location__);
1696                 ret = false;
1697                 goto done;
1698         }
1699         smb2_util_close(tree, h1);
1700
1701         if (!open_stream(tree, tctx, fname_stream, &h1)) {
1702                 goto done;
1703         }
1704
1705         /* Changing attributes on stream */
1706         ZERO_STRUCT(sfinfo);
1707         sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_READONLY;
1708
1709         sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
1710         sfinfo.generic.in.file.handle = h1;
1711         status = smb2_setinfo_file(tree, &sfinfo);
1712         if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
1713                 torture_comment(tctx, "(%s) %s - %s (should be %s)\n",
1714                         __location__, "SETATTR",
1715                         nt_errstr(status), nt_errstr(NT_STATUS_OK));
1716                 ret = false;
1717                 goto done;
1718         }
1719
1720         smb2_util_close(tree, h1);
1721
1722         ZERO_STRUCT(io.smb2);
1723         io.smb2.in.fname = fname;
1724         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1725         io.smb2.in.desired_access = SEC_FILE_READ_DATA;
1726         status = smb2_create(tree, mem_ctx, &(io.smb2));
1727         CHECK_STATUS(status, NT_STATUS_OK);
1728         h1 = io.smb2.out.file.handle;
1729
1730         ZERO_STRUCT(finfo);
1731         finfo.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
1732         finfo.generic.in.file.handle = h1;
1733         status = smb2_getinfo_file(tree, mem_ctx, &finfo);
1734         CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
1735
1736 done:
1737         smb2_util_close(tree, h1);
1738         smb2_util_unlink(tree, fname);
1739         smb2_deltree(tree, DNAME);
1740         talloc_free(mem_ctx);
1741
1742         return ret;
1743 }
1744
1745
1746 /*
1747    basic testing of streams calls SMB2
1748 */
1749 struct torture_suite *torture_smb2_streams_init(void)
1750 {
1751         struct torture_suite *suite =
1752                 torture_suite_create(talloc_autofree_context(), "STREAMS");
1753
1754         torture_suite_add_1smb2_test(suite, "DIR", test_stream_dir);
1755         torture_suite_add_1smb2_test(suite, "IO", test_stream_io);
1756         torture_suite_add_1smb2_test(suite, "SHAREMODES", test_stream_sharemodes);
1757         torture_suite_add_1smb2_test(suite, "NAMES", test_stream_names);
1758         torture_suite_add_1smb2_test(suite, "NAMES2", test_stream_names2);
1759         torture_suite_add_1smb2_test(suite, "RENAME", test_stream_rename);
1760         torture_suite_add_1smb2_test(suite, "RENAME2", test_stream_rename2);
1761         torture_suite_add_1smb2_test(suite, "CREATE-DISPOSITION", test_stream_create_disposition);
1762         torture_suite_add_1smb2_test(suite, "ATTRIBUTES", test_stream_attributes);
1763         torture_suite_add_1smb2_test(suite, "DELETE", test_stream_delete);
1764
1765         suite->description = talloc_strdup(suite, "SMB2-STREAM tests");
1766
1767         return suite;
1768 }