?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lib: tevent: Use system <tevent.h>, not internal header path (except in self-test).
[Samba.git] / source4 / torture / smb2 / create.c
blob397c07516dd8273728a2fcc575037b238a5e6d35
1 /*
2 Unix SMB/CIFS implementation.
3
4 SMB2 create test suite
5
6 Copyright (C) Andrew Tridgell 2008
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 "torture/torture.h"
26 #include "torture/util.h"
27 #include "torture/smb2/proto.h"
28 #include "librpc/gen_ndr/ndr_security.h"
29 #include "libcli/security/security.h"
30
31 #include "system/filesys.h"
32 #include "auth/credentials/credentials.h"
33 #include "lib/cmdline/popt_common.h"
34 #include "librpc/gen_ndr/security.h"
35 #include "lib/events/events.h"
36
37 #define FNAME "test_create.dat"
38 #define DNAME "smb2_open"
39
40 #define CHECK_STATUS(status, correct) do { \
41 if (!NT_STATUS_EQUAL(status, correct)) { \
42 torture_result(tctx, TORTURE_FAIL, \
43 "(%s) Incorrect status %s - should be %s\n", \
44 __location__, nt_errstr(status), nt_errstr(correct)); \
45 return false; \
46 }} while (0)
47
48 #define CHECK_EQUAL(v, correct) do { \
49 if (v != correct) { \
50 torture_result(tctx, TORTURE_FAIL, \
51 "(%s) Incorrect value for %s 0x%08llx - " \
52 "should be 0x%08llx\n", \
53 __location__, #v, \
54 (unsigned long long)v, \
55 (unsigned long long)correct); \
56 return false; \
57 }} while (0)
58
59 #define CHECK_TIME(t, field) do { \
60 time_t t1, t2; \
61 finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \
62 finfo.all_info.in.file.handle = h1; \
63 status = smb2_getinfo_file(tree, tctx, &finfo); \
64 CHECK_STATUS(status, NT_STATUS_OK); \
65 t1 = t & ~1; \
66 t2 = nt_time_to_unix(finfo.all_info.out.field) & ~1; \
67 if (abs(t1-t2) > 2) { \
68 torture_result(tctx, TORTURE_FAIL, \
69 "(%s) wrong time for field %s %s - %s\n", \
70 __location__, #field, \
71 timestring(tctx, t1), \
72 timestring(tctx, t2)); \
73 dump_all_info(tctx, &finfo); \
74 ret = false; \
75 }} while (0)
76
77 #define CHECK_NTTIME(t, field) do { \
78 NTTIME t2; \
79 finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \
80 finfo.all_info.in.file.handle = h1; \
81 status = smb2_getinfo_file(tree, tctx, &finfo); \
82 CHECK_STATUS(status, NT_STATUS_OK); \
83 t2 = finfo.all_info.out.field; \
84 if (abs(t-t2) > 20000) { \
85 torture_result(tctx, TORTURE_FAIL, \
86 "(%s) wrong time for field %s %s - %s\n", \
87 __location__, #field, \
88 nt_time_string(tctx, t), \
89 nt_time_string(tctx, t2)); \
90 dump_all_info(tctx, &finfo); \
91 ret = false; \
92 }} while (0)
93
94 #define CHECK_ALL_INFO(v, field) do { \
95 finfo.all_info.level = RAW_FILEINFO_ALL_INFORMATION; \
96 finfo.all_info.in.file.handle = h1; \
97 status = smb2_getinfo_file(tree, tctx, &finfo); \
98 CHECK_STATUS(status, NT_STATUS_OK); \
99 if ((v) != (finfo.all_info.out.field)) { \
100 torture_result(tctx, TORTURE_FAIL, \
101 "(%s) wrong value for field %s 0x%x - 0x%x\n", \
102 __location__, #field, (int)v,\
103 (int)(finfo.all_info.out.field)); \
104 dump_all_info(tctx, &finfo); \
105 ret = false; \
106 }} while (0)
107
108 #define CHECK_VAL(v, correct) do { \
109 if ((v) != (correct)) { \
110 torture_result(tctx, TORTURE_FAIL, \
111 "(%s) wrong value for %s 0x%x - should be 0x%x\n", \
112 __location__, #v, (int)(v), (int)correct); \
113 ret = false; \
114 }} while (0)
115
116 #define SET_ATTRIB(sattrib) do { \
117 union smb_setfileinfo sfinfo; \
118 ZERO_STRUCT(sfinfo.basic_info.in); \
119 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION; \
120 sfinfo.basic_info.in.file.handle = h1; \
121 sfinfo.basic_info.in.attrib = sattrib; \
122 status = smb2_setinfo_file(tree, &sfinfo); \
123 if (!NT_STATUS_IS_OK(status)) { \
124 torture_comment(tctx, \
125 "(%s) Failed to set attrib 0x%x on %s\n", \
126 __location__, sattrib, fname); \
127 }} while (0)
128
129 /*
130 test some interesting combinations found by gentest
131 */
132 static bool test_create_gentest(struct torture_context *tctx, struct smb2_tree *tree)
133 {
134 struct smb2_create io;
135 NTSTATUS status;
136 uint32_t access_mask, file_attributes_set;
137 uint32_t ok_mask, not_supported_mask, invalid_parameter_mask;
138 uint32_t not_a_directory_mask, unexpected_mask;
139 union smb_fileinfo q;
140
141 ZERO_STRUCT(io);
142 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
143 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
144 io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
145 io.in.share_access =
146 NTCREATEX_SHARE_ACCESS_DELETE|
147 NTCREATEX_SHARE_ACCESS_READ|
148 NTCREATEX_SHARE_ACCESS_WRITE;
149 io.in.create_options = 0;
150 io.in.fname = FNAME;
151
152 status = smb2_create(tree, tctx, &io);
153 CHECK_STATUS(status, NT_STATUS_OK);
154
155 status = smb2_util_close(tree, io.out.file.handle);
156 CHECK_STATUS(status, NT_STATUS_OK);
157
158 io.in.create_options = 0xF0000000;
159 status = smb2_create(tree, tctx, &io);
160 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
161
162 io.in.create_options = 0;
163
164 io.in.file_attributes = FILE_ATTRIBUTE_DEVICE;
165 status = smb2_create(tree, tctx, &io);
166 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
167
168 io.in.file_attributes = FILE_ATTRIBUTE_VOLUME;
169 status = smb2_create(tree, tctx, &io);
170 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
171
172 io.in.create_disposition = NTCREATEX_DISP_OPEN;
173 io.in.file_attributes = FILE_ATTRIBUTE_VOLUME;
174 status = smb2_create(tree, tctx, &io);
175 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
176
177 io.in.create_disposition = NTCREATEX_DISP_CREATE;
178 io.in.desired_access = 0x08000000;
179 status = smb2_create(tree, tctx, &io);
180 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
181
182 io.in.desired_access = 0x04000000;
183 status = smb2_create(tree, tctx, &io);
184 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
185
186 io.in.file_attributes = 0;
187 io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
188 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
189 ok_mask = 0;
190 not_supported_mask = 0;
191 invalid_parameter_mask = 0;
192 not_a_directory_mask = 0;
193 unexpected_mask = 0;
194 {
195 int i;
196 for (i=0;i<32;i++) {
197 io.in.create_options = 1<<i;
198 if (io.in.create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE) {
199 continue;
200 }
201 status = smb2_create(tree, tctx, &io);
202 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
203 not_supported_mask |= 1<<i;
204 } else if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
205 invalid_parameter_mask |= 1<<i;
206 } else if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_A_DIRECTORY)) {
207 not_a_directory_mask |= 1<<i;
208 } else if (NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
209 ok_mask |= 1<<i;
210 status = smb2_util_close(tree, io.out.file.handle);
211 CHECK_STATUS(status, NT_STATUS_OK);
212 } else {
213 unexpected_mask |= 1<<i;
214 torture_comment(tctx,
215 "create option 0x%08x returned %s\n",
216 1<<i, nt_errstr(status));
217 }
218 }
219 }
220 io.in.create_options = 0;
221
222 CHECK_EQUAL(ok_mask, 0x00efcf7e);
223 CHECK_EQUAL(not_a_directory_mask, 0x00000001);
224 CHECK_EQUAL(not_supported_mask, 0x00102080);
225 CHECK_EQUAL(invalid_parameter_mask, 0xff000000);
226 CHECK_EQUAL(unexpected_mask, 0x00000000);
227
228 io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
229 io.in.file_attributes = 0;
230 access_mask = 0;
231 {
232 int i;
233 for (i=0;i<32;i++) {
234 io.in.desired_access = 1<<i;
235 status = smb2_create(tree, tctx, &io);
236 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) ||
237 NT_STATUS_EQUAL(status, NT_STATUS_PRIVILEGE_NOT_HELD)) {
238 access_mask |= io.in.desired_access;
239 } else {
240 CHECK_STATUS(status, NT_STATUS_OK);
241 status = smb2_util_close(tree, io.out.file.handle);
242 CHECK_STATUS(status, NT_STATUS_OK);
243 }
244 }
245 }
246
247 if (TARGET_IS_WIN7(tctx)) {
248 CHECK_EQUAL(access_mask, 0x0de0fe00);
249 } else if (torture_setting_bool(tctx, "samba4", false)) {
250 CHECK_EQUAL(access_mask, 0x0cf0fe00);
251 } else {
252 CHECK_EQUAL(access_mask, 0x0df0fe00);
253 }
254
255 io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
256 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
257 io.in.file_attributes = 0;
258 ok_mask = 0;
259 invalid_parameter_mask = 0;
260 unexpected_mask = 0;
261 file_attributes_set = 0;
262 {
263 int i;
264 for (i=0;i<32;i++) {
265 io.in.file_attributes = 1<<i;
266 if (io.in.file_attributes & FILE_ATTRIBUTE_ENCRYPTED) {
267 continue;
268 }
269 smb2_deltree(tree, FNAME);
270 status = smb2_create(tree, tctx, &io);
271 if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
272 invalid_parameter_mask |= 1<<i;
273 } else if (NT_STATUS_IS_OK(status)) {
274 uint32_t expected;
275 ok_mask |= 1<<i;
276
277 expected = (io.in.file_attributes | FILE_ATTRIBUTE_ARCHIVE) & 0x00005127;
278 io.out.file_attr &= ~FILE_ATTRIBUTE_NONINDEXED;
279 CHECK_EQUAL(io.out.file_attr, expected);
280 file_attributes_set |= io.out.file_attr;
281
282 status = smb2_util_close(tree, io.out.file.handle);
283 CHECK_STATUS(status, NT_STATUS_OK);
284 } else {
285 unexpected_mask |= 1<<i;
286 torture_comment(tctx,
287 "file attribute 0x%08x returned %s\n",
288 1<<i, nt_errstr(status));
289 }
290 }
291 }
292
293 CHECK_EQUAL(ok_mask, 0x00003fb7);
294 CHECK_EQUAL(invalid_parameter_mask, 0xffff8048);
295 CHECK_EQUAL(unexpected_mask, 0x00000000);
296 CHECK_EQUAL(file_attributes_set, 0x00001127);
297
298 smb2_deltree(tree, FNAME);
299
300 /*
301 * Standalone servers doesn't support encryption
302 */
303 io.in.file_attributes = FILE_ATTRIBUTE_ENCRYPTED;
304 status = smb2_create(tree, tctx, &io);
305 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
306 torture_comment(tctx,
307 "FILE_ATTRIBUTE_ENCRYPTED returned %s\n",
308 nt_errstr(status));
309 } else {
310 CHECK_STATUS(status, NT_STATUS_OK);
311 CHECK_EQUAL(io.out.file_attr, (FILE_ATTRIBUTE_ENCRYPTED | FILE_ATTRIBUTE_ARCHIVE));
312 status = smb2_util_close(tree, io.out.file.handle);
313 CHECK_STATUS(status, NT_STATUS_OK);
314 }
315
316 smb2_deltree(tree, FNAME);
317
318 ZERO_STRUCT(io);
319 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
320 io.in.file_attributes = 0;
321 io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
322 io.in.share_access =
323 NTCREATEX_SHARE_ACCESS_READ|
324 NTCREATEX_SHARE_ACCESS_WRITE;
325 io.in.create_options = 0;
326 io.in.fname = FNAME ":stream1";
327 status = smb2_create(tree, tctx, &io);
328 CHECK_STATUS(status, NT_STATUS_OK);
329
330 status = smb2_util_close(tree, io.out.file.handle);
331 CHECK_STATUS(status, NT_STATUS_OK);
332
333 io.in.fname = FNAME;
334 io.in.file_attributes = 0x8040;
335 io.in.share_access =
336 NTCREATEX_SHARE_ACCESS_READ;
337 status = smb2_create(tree, tctx, &io);
338 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
339
340 io.in.fname = FNAME;
341 io.in.file_attributes = 0;
342 io.in.desired_access = SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA;
343 io.in.query_maximal_access = true;
344 status = smb2_create(tree, tctx, &io);
345 CHECK_STATUS(status, NT_STATUS_OK);
346 CHECK_EQUAL(io.out.maximal_access, 0x001f01ff);
347
348 q.access_information.level = RAW_FILEINFO_ACCESS_INFORMATION;
349 q.access_information.in.file.handle = io.out.file.handle;
350 status = smb2_getinfo_file(tree, tctx, &q);
351 CHECK_STATUS(status, NT_STATUS_OK);
352 CHECK_EQUAL(q.access_information.out.access_flags, io.in.desired_access);
353
354 io.in.file_attributes = 0;
355 io.in.desired_access = 0;
356 io.in.query_maximal_access = false;
357 io.in.share_access = 0;
358 status = smb2_create(tree, tctx, &io);
359 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
360
361 smb2_deltree(tree, FNAME);
362
363 return true;
364 }
365
366
367 /*
368 try the various request blobs
369 */
370 static bool test_create_blob(struct torture_context *tctx, struct smb2_tree *tree)
371 {
372 struct smb2_create io;
373 NTSTATUS status;
374
375 smb2_deltree(tree, FNAME);
376
377 ZERO_STRUCT(io);
378 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
379 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
380 io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
381 io.in.share_access =
382 NTCREATEX_SHARE_ACCESS_DELETE|
383 NTCREATEX_SHARE_ACCESS_READ|
384 NTCREATEX_SHARE_ACCESS_WRITE;
385 io.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
386 NTCREATEX_OPTIONS_ASYNC_ALERT |
387 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
388 0x00200000;
389 io.in.fname = FNAME;
390
391 status = smb2_create(tree, tctx, &io);
392 CHECK_STATUS(status, NT_STATUS_OK);
393
394 status = smb2_util_close(tree, io.out.file.handle);
395 CHECK_STATUS(status, NT_STATUS_OK);
396
397 torture_comment(tctx, "Testing alloc size\n");
398 /* FIXME We use 1M cause that's the rounded size of Samba.
399 * We should ask the server for the cluser size and calulate it
400 * correctly. */
401 io.in.alloc_size = 0x00100000;
402 status = smb2_create(tree, tctx, &io);
403 CHECK_STATUS(status, NT_STATUS_OK);
404 CHECK_EQUAL(io.out.alloc_size, io.in.alloc_size);
405
406 status = smb2_util_close(tree, io.out.file.handle);
407 CHECK_STATUS(status, NT_STATUS_OK);
408
409 torture_comment(tctx, "Testing durable open\n");
410 io.in.durable_open = true;
411 status = smb2_create(tree, tctx, &io);
412 CHECK_STATUS(status, NT_STATUS_OK);
413
414 status = smb2_util_close(tree, io.out.file.handle);
415 CHECK_STATUS(status, NT_STATUS_OK);
416
417 torture_comment(tctx, "Testing query maximal access\n");
418 io.in.query_maximal_access = true;
419 status = smb2_create(tree, tctx, &io);
420 CHECK_STATUS(status, NT_STATUS_OK);
421 CHECK_EQUAL(io.out.maximal_access, 0x001f01ff);
422
423 status = smb2_util_close(tree, io.out.file.handle);
424 CHECK_STATUS(status, NT_STATUS_OK);
425
426 torture_comment(tctx, "Testing timewarp\n");
427 io.in.timewarp = 10000;
428 status = smb2_create(tree, tctx, &io);
429 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
430 io.in.timewarp = 0;
431
432 torture_comment(tctx, "Testing query_on_disk\n");
433 io.in.query_on_disk_id = true;
434 status = smb2_create(tree, tctx, &io);
435 CHECK_STATUS(status, NT_STATUS_OK);
436
437 status = smb2_util_close(tree, io.out.file.handle);
438 CHECK_STATUS(status, NT_STATUS_OK);
439
440 torture_comment(tctx, "Testing unknown tag\n");
441 status = smb2_create_blob_add(tctx, &io.in.blobs,
442 "FooO", data_blob(NULL, 0));
443 CHECK_STATUS(status, NT_STATUS_OK);
444
445 status = smb2_create(tree, tctx, &io);
446 CHECK_STATUS(status, NT_STATUS_OK);
447
448 status = smb2_util_close(tree, io.out.file.handle);
449 CHECK_STATUS(status, NT_STATUS_OK);
450
451 torture_comment(tctx, "Testing bad tag length 0\n");
452 ZERO_STRUCT(io.in.blobs);
453 status = smb2_create_blob_add(tctx, &io.in.blobs,
454 "x", data_blob(NULL, 0));
455 CHECK_STATUS(status, NT_STATUS_OK);
456 status = smb2_create(tree, tctx, &io);
457 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
458
459 torture_comment(tctx, "Testing bad tag length 1\n");
460 ZERO_STRUCT(io.in.blobs);
461 status = smb2_create_blob_add(tctx, &io.in.blobs,
462 "x", data_blob(NULL, 0));
463 CHECK_STATUS(status, NT_STATUS_OK);
464 status = smb2_create(tree, tctx, &io);
465 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
466
467 torture_comment(tctx, "Testing bad tag length 2\n");
468 ZERO_STRUCT(io.in.blobs);
469 status = smb2_create_blob_add(tctx, &io.in.blobs,
470 "xx", data_blob(NULL, 0));
471 CHECK_STATUS(status, NT_STATUS_OK);
472 status = smb2_create(tree, tctx, &io);
473 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
474
475 torture_comment(tctx, "Testing bad tag length 3\n");
476 ZERO_STRUCT(io.in.blobs);
477 status = smb2_create_blob_add(tctx, &io.in.blobs,
478 "xxx", data_blob(NULL, 0));
479 CHECK_STATUS(status, NT_STATUS_OK);
480 status = smb2_create(tree, tctx, &io);
481 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
482
483 torture_comment(tctx, "Testing tag length 4\n");
484 ZERO_STRUCT(io.in.blobs);
485 status = smb2_create_blob_add(tctx, &io.in.blobs,
486 "xxxx", data_blob(NULL, 0));
487 CHECK_STATUS(status, NT_STATUS_OK);
488 status = smb2_create(tree, tctx, &io);
489 CHECK_STATUS(status, NT_STATUS_OK);
490
491 torture_comment(tctx, "Testing tag length 5\n");
492 ZERO_STRUCT(io.in.blobs);
493 status = smb2_create_blob_add(tctx, &io.in.blobs,
494 "xxxxx", data_blob(NULL, 0));
495 CHECK_STATUS(status, NT_STATUS_OK);
496 status = smb2_create(tree, tctx, &io);
497 CHECK_STATUS(status, NT_STATUS_OK);
498
499 torture_comment(tctx, "Testing tag length 6\n");
500 ZERO_STRUCT(io.in.blobs);
501 status = smb2_create_blob_add(tctx, &io.in.blobs,
502 "xxxxxx", data_blob(NULL, 0));
503 CHECK_STATUS(status, NT_STATUS_OK);
504 status = smb2_create(tree, tctx, &io);
505 CHECK_STATUS(status, NT_STATUS_OK);
506
507 torture_comment(tctx, "Testing tag length 7\n");
508 ZERO_STRUCT(io.in.blobs);
509 status = smb2_create_blob_add(tctx, &io.in.blobs,
510 "xxxxxxx", data_blob(NULL, 0));
511 CHECK_STATUS(status, NT_STATUS_OK);
512 status = smb2_create(tree, tctx, &io);
513 CHECK_STATUS(status, NT_STATUS_OK);
514
515 torture_comment(tctx, "Testing tag length 8\n");
516 ZERO_STRUCT(io.in.blobs);
517 status = smb2_create_blob_add(tctx, &io.in.blobs,
518 "xxxxxxxx", data_blob(NULL, 0));
519 CHECK_STATUS(status, NT_STATUS_OK);
520 status = smb2_create(tree, tctx, &io);
521 CHECK_STATUS(status, NT_STATUS_OK);
522
523 torture_comment(tctx, "Testing tag length 16\n");
524 ZERO_STRUCT(io.in.blobs);
525 status = smb2_create_blob_add(tctx, &io.in.blobs,
526 "xxxxxxxxxxxxxxxx", data_blob(NULL, 0));
527 CHECK_STATUS(status, NT_STATUS_OK);
528 status = smb2_create(tree, tctx, &io);
529 CHECK_STATUS(status, NT_STATUS_OK);
530
531 torture_comment(tctx, "Testing tag length 17\n");
532 ZERO_STRUCT(io.in.blobs);
533 status = smb2_create_blob_add(tctx, &io.in.blobs,
534 "xxxxxxxxxxxxxxxxx", data_blob(NULL, 0));
535 CHECK_STATUS(status, NT_STATUS_OK);
536 status = smb2_create(tree, tctx, &io);
537 CHECK_STATUS(status, NT_STATUS_OK);
538
539 torture_comment(tctx, "Testing tag length 34\n");
540 ZERO_STRUCT(io.in.blobs);
541 status = smb2_create_blob_add(tctx, &io.in.blobs,
542 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
543 data_blob(NULL, 0));
544 CHECK_STATUS(status, NT_STATUS_OK);
545 status = smb2_create(tree, tctx, &io);
546 CHECK_STATUS(status, NT_STATUS_OK);
547
548 smb2_deltree(tree, FNAME);
549
550 return true;
551 }
552
553 #define FAIL_UNLESS(__cond) \
554 do { \
555 if (__cond) {} else { \
556 torture_result(tctx, TORTURE_FAIL, "%s) condition violated: %s\n", \
557 __location__, #__cond); \
558 ret = false; goto done; \
559 } \
560 } while(0)
561
562 /*
563 try creating with acls
564 */
565 static bool test_create_acl_ext(struct torture_context *tctx, struct smb2_tree *tree, bool test_dir)
566 {
567 bool ret = true;
568 struct smb2_create io;
569 NTSTATUS status;
570 struct security_ace ace;
571 struct security_descriptor *sd;
572 struct dom_sid *test_sid;
573 union smb_fileinfo q = {};
574 uint32_t attrib =
575 FILE_ATTRIBUTE_HIDDEN |
576 FILE_ATTRIBUTE_SYSTEM |
577 (test_dir ? FILE_ATTRIBUTE_DIRECTORY : 0);
578 NTSTATUS (*delete_func)(struct smb2_tree *, const char *) =
579 test_dir ? smb2_util_rmdir : smb2_util_unlink;
580
581 ZERO_STRUCT(ace);
582
583 smb2_deltree(tree, FNAME);
584
585 ZERO_STRUCT(io);
586 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
587 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
588 io.in.create_disposition = NTCREATEX_DISP_CREATE;
589 io.in.share_access =
590 NTCREATEX_SHARE_ACCESS_DELETE |
591 NTCREATEX_SHARE_ACCESS_READ |
592 NTCREATEX_SHARE_ACCESS_WRITE;
593 io.in.create_options = NTCREATEX_OPTIONS_ASYNC_ALERT | 0x00200000 |
594 (test_dir ? NTCREATEX_OPTIONS_DIRECTORY :
595 (NTCREATEX_OPTIONS_NON_DIRECTORY_FILE));
596
597 io.in.fname = FNAME;
598
599 torture_comment(tctx, "basic create\n");
600
601 status = smb2_create(tree, tctx, &io);
602 CHECK_STATUS(status, NT_STATUS_OK);
603
604 q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
605 q.query_secdesc.in.file.handle = io.out.file.handle;
606 q.query_secdesc.in.secinfo_flags =
607 SECINFO_OWNER |
608 SECINFO_GROUP |
609 SECINFO_DACL;
610 status = smb2_getinfo_file(tree, tctx, &q);
611 CHECK_STATUS(status, NT_STATUS_OK);
612 sd = q.query_secdesc.out.sd;
613
614 status = smb2_util_close(tree, io.out.file.handle);
615 CHECK_STATUS(status, NT_STATUS_OK);
616 status = delete_func(tree, FNAME);
617 CHECK_STATUS(status, NT_STATUS_OK);
618
619 torture_comment(tctx, "adding a new ACE\n");
620 test_sid = dom_sid_parse_talloc(tctx, SID_NT_AUTHENTICATED_USERS);
621
622 ace.type = SEC_ACE_TYPE_ACCESS_ALLOWED;
623 ace.flags = 0;
624 ace.access_mask = SEC_STD_ALL;
625 ace.trustee = *test_sid;
626
627 status = security_descriptor_dacl_add(sd, &ace);
628 CHECK_STATUS(status, NT_STATUS_OK);
629
630 torture_comment(tctx, "creating a file with an initial ACL\n");
631
632 io.in.sec_desc = sd;
633 status = smb2_create(tree, tctx, &io);
634 CHECK_STATUS(status, NT_STATUS_OK);
635
636 FAIL_UNLESS(smb2_util_verify_sd(tctx, tree, io.out.file.handle, sd));
637
638 status = smb2_util_close(tree, io.out.file.handle);
639 CHECK_STATUS(status, NT_STATUS_OK);
640 status = delete_func(tree, FNAME);
641 CHECK_STATUS(status, NT_STATUS_OK);
642
643 torture_comment(tctx, "creating with attributes\n");
644
645 io.in.sec_desc = NULL;
646 io.in.file_attributes = attrib;
647 status = smb2_create(tree, tctx, &io);
648 CHECK_STATUS(status, NT_STATUS_OK);
649
650 FAIL_UNLESS(smb2_util_verify_attrib(tctx, tree, io.out.file.handle, attrib));
651
652 status = smb2_util_close(tree, io.out.file.handle);
653 CHECK_STATUS(status, NT_STATUS_OK);
654 status = delete_func(tree, FNAME);
655 CHECK_STATUS(status, NT_STATUS_OK);
656
657 torture_comment(tctx, "creating with attributes and ACL\n");
658
659 io.in.sec_desc = sd;
660 io.in.file_attributes = attrib;
661 status = smb2_create(tree, tctx, &io);
662 CHECK_STATUS(status, NT_STATUS_OK);
663
664 FAIL_UNLESS(smb2_util_verify_sd(tctx, tree, io.out.file.handle, sd));
665 FAIL_UNLESS(smb2_util_verify_attrib(tctx, tree, io.out.file.handle, attrib));
666
667 status = smb2_util_close(tree, io.out.file.handle);
668 CHECK_STATUS(status, NT_STATUS_OK);
669 status = delete_func(tree, FNAME);
670 CHECK_STATUS(status, NT_STATUS_OK);
671
672 torture_comment(tctx, "creating with attributes, ACL and owner\n");
673 sd = security_descriptor_dacl_create(tctx,
674 0, SID_WORLD, SID_BUILTIN_USERS,
675 SID_WORLD,
676 SEC_ACE_TYPE_ACCESS_ALLOWED,
677 SEC_RIGHTS_FILE_READ | SEC_STD_ALL,
678 0,
679 NULL);
680
681 io.in.sec_desc = sd;
682 io.in.file_attributes = attrib;
683 status = smb2_create(tree, tctx, &io);
684 CHECK_STATUS(status, NT_STATUS_OK);
685
686 FAIL_UNLESS(smb2_util_verify_sd(tctx, tree, io.out.file.handle, sd));
687 FAIL_UNLESS(smb2_util_verify_attrib(tctx, tree, io.out.file.handle, attrib));
688
689 done:
690 status = smb2_util_close(tree, io.out.file.handle);
691 CHECK_STATUS(status, NT_STATUS_OK);
692 status = delete_func(tree, FNAME);
693 CHECK_STATUS(status, NT_STATUS_OK);
694
695 return ret;
696 }
697
698 /*
699 test SMB2 open
700 */
701 static bool test_smb2_open(struct torture_context *tctx,
702 struct smb2_tree *tree)
703 {
704 union smb_open io;
705 union smb_fileinfo finfo;
706 const char *fname = DNAME "\\torture_ntcreatex.txt";
707 const char *dname = DNAME "\\torture_ntcreatex.dir";
708 NTSTATUS status;
709 struct smb2_handle h = {{0}};
710 struct smb2_handle h1 = {{0}};
711 bool ret = true;
712 int i;
713 struct {
714 uint32_t create_disp;
715 bool with_file;
716 NTSTATUS correct_status;
717 } open_funcs[] = {
718 { NTCREATEX_DISP_SUPERSEDE, true, NT_STATUS_OK },
719 { NTCREATEX_DISP_SUPERSEDE, false, NT_STATUS_OK },
720 { NTCREATEX_DISP_OPEN, true, NT_STATUS_OK },
721 { NTCREATEX_DISP_OPEN, false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
722 { NTCREATEX_DISP_CREATE, true, NT_STATUS_OBJECT_NAME_COLLISION },
723 { NTCREATEX_DISP_CREATE, false, NT_STATUS_OK },
724 { NTCREATEX_DISP_OPEN_IF, true, NT_STATUS_OK },
725 { NTCREATEX_DISP_OPEN_IF, false, NT_STATUS_OK },
726 { NTCREATEX_DISP_OVERWRITE, true, NT_STATUS_OK },
727 { NTCREATEX_DISP_OVERWRITE, false, NT_STATUS_OBJECT_NAME_NOT_FOUND },
728 { NTCREATEX_DISP_OVERWRITE_IF, true, NT_STATUS_OK },
729 { NTCREATEX_DISP_OVERWRITE_IF, false, NT_STATUS_OK },
730 { 6, true, NT_STATUS_INVALID_PARAMETER },
731 { 6, false, NT_STATUS_INVALID_PARAMETER },
732 };
733
734 torture_comment(tctx, "Checking SMB2 Open\n");
735
736 smb2_util_unlink(tree, fname);
737 smb2_util_rmdir(tree, dname);
738
739 status = torture_smb2_testdir(tree, DNAME, &h);
740 CHECK_STATUS(status, NT_STATUS_OK);
741
742 ZERO_STRUCT(io.smb2);
743 /* reasonable default parameters */
744 io.generic.level = RAW_OPEN_SMB2;
745 io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
746 io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
747 io.smb2.in.alloc_size = 1024*1024;
748 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
749 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
750 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
751 io.smb2.in.create_options = 0;
752 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
753 io.smb2.in.security_flags = 0;
754 io.smb2.in.fname = fname;
755
756 /* test the create disposition */
757 for (i=0; i<ARRAY_SIZE(open_funcs); i++) {
758 if (open_funcs[i].with_file) {
759 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
760 status= smb2_create(tree, tctx, &(io.smb2));
761 if (!NT_STATUS_IS_OK(status)) {
762 torture_comment(tctx,
763 "Failed to create file %s status %s %d\n",
764 fname, nt_errstr(status), i);
765
766 ret = false;
767 goto done;
768 }
769 smb2_util_close(tree, io.smb2.out.file.handle);
770 }
771 io.smb2.in.create_disposition = open_funcs[i].create_disp;
772 status = smb2_create(tree, tctx, &(io.smb2));
773 if (!NT_STATUS_EQUAL(status, open_funcs[i].correct_status)) {
774 torture_comment(tctx,
775 "(%s) incorrect status %s should be %s (i=%d "
776 "with_file=%d open_disp=%d)\n",
777 __location__, nt_errstr(status),
778 nt_errstr(open_funcs[i].correct_status),
779 i, (int)open_funcs[i].with_file,
780 (int)open_funcs[i].create_disp);
781
782 ret = false;
783 goto done;
784 }
785 if (NT_STATUS_IS_OK(status) || open_funcs[i].with_file) {
786 smb2_util_close(tree, io.smb2.out.file.handle);
787 smb2_util_unlink(tree, fname);
788 }
789 }
790
791 /* basic field testing */
792 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
793
794 status = smb2_create(tree, tctx, &(io.smb2));
795 CHECK_STATUS(status, NT_STATUS_OK);
796 h1 = io.smb2.out.file.handle;
797
798 CHECK_VAL(io.smb2.out.oplock_level, 0);
799 CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_CREATED);
800 CHECK_NTTIME(io.smb2.out.create_time, create_time);
801 CHECK_NTTIME(io.smb2.out.access_time, access_time);
802 CHECK_NTTIME(io.smb2.out.write_time, write_time);
803 CHECK_NTTIME(io.smb2.out.change_time, change_time);
804 CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);
805 CHECK_ALL_INFO(io.smb2.out.alloc_size, alloc_size);
806 CHECK_ALL_INFO(io.smb2.out.size, size);
807
808 /* check fields when the file already existed */
809 smb2_util_close(tree, h1);
810 smb2_util_unlink(tree, fname);
811
812 status = smb2_create_complex_file(tctx, tree, fname, &h1);
813 CHECK_STATUS(status, NT_STATUS_OK);
814
815 smb2_util_close(tree, h1);
816
817 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
818 status = smb2_create(tree, tctx, &(io.smb2));
819 CHECK_STATUS(status, NT_STATUS_OK);
820 h1 = io.smb2.out.file.handle;
821
822 CHECK_VAL(io.smb2.out.oplock_level, 0);
823 CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_EXISTED);
824 CHECK_NTTIME(io.smb2.out.create_time, create_time);
825 CHECK_NTTIME(io.smb2.out.access_time, access_time);
826 CHECK_NTTIME(io.smb2.out.write_time, write_time);
827 CHECK_NTTIME(io.smb2.out.change_time, change_time);
828 CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);
829 CHECK_ALL_INFO(io.smb2.out.alloc_size, alloc_size);
830 CHECK_ALL_INFO(io.smb2.out.size, size);
831 smb2_util_close(tree, h1);
832 smb2_util_unlink(tree, fname);
833
834 /* create a directory */
835 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
836 io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
837 io.smb2.in.alloc_size = 0;
838 io.smb2.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
839 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
840 io.smb2.in.create_options = 0;
841 io.smb2.in.fname = dname;
842 fname = dname;
843
844 smb2_util_rmdir(tree, fname);
845 smb2_util_unlink(tree, fname);
846
847 io.smb2.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
848 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
849 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
850 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
851 NTCREATEX_SHARE_ACCESS_WRITE;
852 status = smb2_create(tree, tctx, &(io.smb2));
853 CHECK_STATUS(status, NT_STATUS_OK);
854 h1 = io.smb2.out.file.handle;
855
856 CHECK_VAL(io.smb2.out.oplock_level, 0);
857 CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_CREATED);
858 CHECK_NTTIME(io.smb2.out.create_time, create_time);
859 CHECK_NTTIME(io.smb2.out.access_time, access_time);
860 CHECK_NTTIME(io.smb2.out.write_time, write_time);
861 CHECK_NTTIME(io.smb2.out.change_time, change_time);
862 CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);
863 CHECK_VAL(io.smb2.out.file_attr & ~FILE_ATTRIBUTE_NONINDEXED,
864 FILE_ATTRIBUTE_DIRECTORY);
865 CHECK_ALL_INFO(io.smb2.out.alloc_size, alloc_size);
866 CHECK_ALL_INFO(io.smb2.out.size, size);
867 CHECK_VAL(io.smb2.out.size, 0);
868 CHECK_VAL(io.smb2.out.alloc_size, 0);
869 smb2_util_unlink(tree, fname);
870
871 done:
872 smb2_util_close(tree, h1);
873 smb2_util_unlink(tree, fname);
874 smb2_deltree(tree, DNAME);
875 return ret;
876 }
877
878 /*
879 test with an already opened and byte range locked file
880 */
881
882 static bool test_smb2_open_brlocked(struct torture_context *tctx,
883 struct smb2_tree *tree)
884 {
885 union smb_open io, io1;
886 union smb_lock io2;
887 struct smb2_lock_element lock[1];
888 const char *fname = DNAME "\\torture_ntcreatex.txt";
889 NTSTATUS status;
890 bool ret = true;
891 struct smb2_handle h;
892 char b = 42;
893
894 torture_comment(tctx,
895 "Testing SMB2 open with a byte range locked file\n");
896
897 smb2_util_unlink(tree, fname);
898
899 status = torture_smb2_testdir(tree, DNAME, &h);
900 CHECK_STATUS(status, NT_STATUS_OK);
901
902 ZERO_STRUCT(io.smb2);
903 io.generic.level = RAW_OPEN_SMB2;
904 io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
905 io.smb2.in.desired_access = 0x2019f;
906 io.smb2.in.alloc_size = 0;
907 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
908 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
909 NTCREATEX_SHARE_ACCESS_WRITE;
910 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
911 io.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
912 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
913 io.smb2.in.security_flags = SMB2_SECURITY_DYNAMIC_TRACKING;
914 io.smb2.in.fname = fname;
915
916 status = smb2_create(tree, tctx, &(io.smb2));
917 CHECK_STATUS(status, NT_STATUS_OK);
918
919 status = smb2_util_write(tree, io.smb2.out.file.handle, &b, 0, 1);
920 CHECK_STATUS(status, NT_STATUS_OK);
921
922 ZERO_STRUCT(io2.smb2);
923 io2.smb2.level = RAW_LOCK_SMB2;
924 io2.smb2.in.file.handle = io.smb2.out.file.handle;
925 io2.smb2.in.lock_count = 1;
926
927 ZERO_STRUCT(lock);
928 lock[0].offset = 0;
929 lock[0].length = 1;
930 lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
931 SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
932 io2.smb2.in.locks = &lock[0];
933 status = smb2_lock(tree, &(io2.smb2));
934 CHECK_STATUS(status, NT_STATUS_OK);
935
936 ZERO_STRUCT(io1.smb2);
937 io1.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
938 io1.smb2.in.desired_access = 0x20196;
939 io1.smb2.in.alloc_size = 0;
940 io1.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
941 io1.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
942 NTCREATEX_SHARE_ACCESS_WRITE;
943 io1.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
944 io1.smb2.in.create_options = 0;
945 io1.smb2.in.impersonation_level = SMB2_IMPERSONATION_IMPERSONATION;
946 io1.smb2.in.security_flags = SMB2_SECURITY_DYNAMIC_TRACKING;
947 io1.smb2.in.fname = fname;
948
949 status = smb2_create(tree, tctx, &(io1.smb2));
950 CHECK_STATUS(status, NT_STATUS_OK);
951
952 smb2_util_close(tree, io.smb2.out.file.handle);
953 smb2_util_close(tree, io1.smb2.out.file.handle);
954 smb2_util_unlink(tree, fname);
955 smb2_deltree(tree, DNAME);
956
957 return ret;
958 }
959
960 /* A little torture test to expose a race condition in Samba 3.0.20 ... :-) */
961
962 static bool test_smb2_open_multi(struct torture_context *tctx,
963 struct smb2_tree *tree)
964 {
965 const char *fname = "test_oplock.dat";
966 NTSTATUS status;
967 bool ret = true;
968 union smb_open io;
969 struct smb2_tree **trees;
970 struct smb2_request **requests;
971 union smb_open *ios;
972 int i, num_files = 3;
973 int num_ok = 0;
974 int num_collision = 0;
975
976 torture_comment(tctx,
977 "Testing SMB2 Open with multiple connections\n");
978 trees = talloc_array(tctx, struct smb2_tree *, num_files);
979 requests = talloc_array(tctx, struct smb2_request *, num_files);
980 ios = talloc_array(tctx, union smb_open, num_files);
981 if ((tctx->ev == NULL) || (trees == NULL) || (requests == NULL) ||
982 (ios == NULL)) {
983 torture_comment(tctx, ("talloc failed\n"));
984 ret = false;
985 goto done;
986 }
987
988 tree->session->transport->options.request_timeout = 60;
989
990 for (i=0; i<num_files; i++) {
991 if (!torture_smb2_connection(tctx, &(trees[i]))) {
992 torture_comment(tctx,
993 "Could not open %d'th connection\n", i);
994 ret = false;
995 goto done;
996 }
997 trees[i]->session->transport->options.request_timeout = 60;
998 }
999
1000 /* cleanup */
1001 smb2_util_unlink(tree, fname);
1002
1003 /*
1004 base ntcreatex parms
1005 */
1006 ZERO_STRUCT(io.smb2);
1007 io.generic.level = RAW_OPEN_SMB2;
1008 io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1009 io.smb2.in.alloc_size = 0;
1010 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1011 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1012 NTCREATEX_SHARE_ACCESS_WRITE|
1013 NTCREATEX_SHARE_ACCESS_DELETE;
1014 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1015 io.smb2.in.create_options = 0;
1016 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1017 io.smb2.in.security_flags = 0;
1018 io.smb2.in.fname = fname;
1019 io.smb2.in.create_flags = 0;
1020
1021 for (i=0; i<num_files; i++) {
1022 ios[i] = io;
1023 requests[i] = smb2_create_send(trees[i], &(ios[i].smb2));
1024 if (requests[i] == NULL) {
1025 torture_comment(tctx,
1026 "could not send %d'th request\n", i);
1027 ret = false;
1028 goto done;
1029 }
1030 }
1031
1032 torture_comment(tctx, "waiting for replies\n");
1033 while (1) {
1034 bool unreplied = false;
1035 for (i=0; i<num_files; i++) {
1036 if (requests[i] == NULL) {
1037 continue;
1038 }
1039 if (requests[i]->state < SMB2_REQUEST_DONE) {
1040 unreplied = true;
1041 break;
1042 }
1043 status = smb2_create_recv(requests[i], tctx,
1044 &(ios[i].smb2));
1045
1046 torture_comment(tctx,
1047 "File %d returned status %s\n", i,
1048 nt_errstr(status));
1049
1050 if (NT_STATUS_IS_OK(status)) {
1051 num_ok += 1;
1052 }
1053
1054 if (NT_STATUS_EQUAL(status,
1055 NT_STATUS_OBJECT_NAME_COLLISION)) {
1056 num_collision += 1;
1057 }
1058
1059 requests[i] = NULL;
1060 }
1061 if (!unreplied) {
1062 break;
1063 }
1064
1065 if (tevent_loop_once(tctx->ev) != 0) {
1066 torture_comment(tctx, "tevent_loop_once failed\n");
1067 ret = false;
1068 goto done;
1069 }
1070 }
1071
1072 if ((num_ok != 1) || (num_ok + num_collision != num_files)) {
1073 ret = false;
1074 }
1075 done:
1076 smb2_deltree(tree, fname);
1077
1078 return ret;
1079 }
1080
1081 /*
1082 test opening for delete on a read-only attribute file.
1083 */
1084
1085 static bool test_smb2_open_for_delete(struct torture_context *tctx,
1086 struct smb2_tree *tree)
1087 {
1088 union smb_open io;
1089 union smb_fileinfo finfo;
1090 const char *fname = DNAME "\\torture_open_for_delete.txt";
1091 NTSTATUS status;
1092 struct smb2_handle h, h1;
1093 bool ret = true;
1094
1095 torture_comment(tctx,
1096 "Checking SMB2_OPEN for delete on a readonly file.\n");
1097 smb2_util_unlink(tree, fname);
1098 smb2_deltree(tree, fname);
1099
1100 status = torture_smb2_testdir(tree, DNAME, &h);
1101 CHECK_STATUS(status, NT_STATUS_OK);
1102
1103 /* reasonable default parameters */
1104 ZERO_STRUCT(io.smb2);
1105 io.generic.level = RAW_OPEN_SMB2;
1106 io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1107 io.smb2.in.alloc_size = 0;
1108 io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1109 io.smb2.in.file_attributes = FILE_ATTRIBUTE_READONLY;
1110 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1111 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1112 io.smb2.in.create_options = 0;
1113 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1114 io.smb2.in.security_flags = 0;
1115 io.smb2.in.fname = fname;
1116
1117 /* Create the readonly file. */
1118
1119 status = smb2_create(tree, tctx, &(io.smb2));
1120 CHECK_STATUS(status, NT_STATUS_OK);
1121 h1 = io.smb2.out.file.handle;
1122
1123 CHECK_VAL(io.smb2.out.oplock_level, 0);
1124 io.smb2.in.create_options = 0;
1125 CHECK_VAL(io.smb2.out.create_action, NTCREATEX_ACTION_CREATED);
1126 CHECK_ALL_INFO(io.smb2.out.file_attr, attrib);
1127 smb2_util_close(tree, h1);
1128
1129 /* Now try and open for delete only - should succeed. */
1130 io.smb2.in.desired_access = SEC_STD_DELETE;
1131 io.smb2.in.file_attributes = 0;
1132 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1133 NTCREATEX_SHARE_ACCESS_WRITE |
1134 NTCREATEX_SHARE_ACCESS_DELETE;
1135 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1136 status = smb2_create(tree, tctx, &(io.smb2));
1137 CHECK_STATUS(status, NT_STATUS_OK);
1138
1139 smb2_util_unlink(tree, fname);
1140
1141 smb2_util_close(tree, h1);
1142 smb2_util_unlink(tree, fname);
1143 smb2_deltree(tree, DNAME);
1144
1145 return ret;
1146 }
1147
1148 /*
1149 test SMB2 open with a leading slash on the path.
1150 Trying to create a directory with a leading slash
1151 should give NT_STATUS_INVALID_PARAMETER error
1152 */
1153 static bool test_smb2_leading_slash(struct torture_context *tctx,
1154 struct smb2_tree *tree)
1155 {
1156 union smb_open io;
1157 const char *dnameslash = "\\"DNAME;
1158 NTSTATUS status;
1159 bool ret = true;
1160
1161 torture_comment(tctx,
1162 "Trying to create a directory with leading slash on path\n");
1163 smb2_deltree(tree, dnameslash);
1164
1165 ZERO_STRUCT(io.smb2);
1166 io.generic.level = RAW_OPEN_SMB2;
1167 io.smb2.in.oplock_level = 0;
1168 io.smb2.in.desired_access = SEC_RIGHTS_DIR_ALL;
1169 io.smb2.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
1170 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1171 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1172 NTCREATEX_SHARE_ACCESS_WRITE |
1173 NTCREATEX_SHARE_ACCESS_DELETE;
1174 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1175 io.smb2.in.fname = dnameslash;
1176
1177 status = smb2_create(tree, tree, &(io.smb2));
1178 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
1179
1180 smb2_deltree(tree, dnameslash);
1181 return ret;
1182 }
1183
1184 /*
1185 test SMB2 open with an invalid impersonation level.
1186 Should give NT_STATUS_BAD_IMPERSONATION_LEVEL error
1187 */
1188 static bool test_smb2_impersonation_level(struct torture_context *tctx,
1189 struct smb2_tree *tree)
1190 {
1191 union smb_open io;
1192 const char *fname = DNAME "\\torture_invalid_impersonation_level.txt";
1193 NTSTATUS status;
1194 struct smb2_handle h;
1195 bool ret = true;
1196
1197 torture_comment(tctx,
1198 "Testing SMB2 open with an invalid impersonation level.\n");
1199
1200 smb2_util_unlink(tree, fname);
1201 smb2_util_rmdir(tree, DNAME);
1202
1203 status = torture_smb2_testdir(tree, DNAME, &h);
1204 CHECK_STATUS(status, NT_STATUS_OK);
1205
1206 ZERO_STRUCT(io.smb2);
1207 io.generic.level = RAW_OPEN_SMB2;
1208 io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1209 io.smb2.in.alloc_size = 0;
1210 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1211 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1212 NTCREATEX_SHARE_ACCESS_WRITE|
1213 NTCREATEX_SHARE_ACCESS_DELETE;
1214 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1215 io.smb2.in.create_options = 0;
1216 io.smb2.in.impersonation_level = 0x12345678;
1217 io.smb2.in.security_flags = 0;
1218 io.smb2.in.fname = fname;
1219 io.smb2.in.create_flags = 0;
1220
1221 status = smb2_create(tree, tree, &(io.smb2));
1222 CHECK_STATUS(status, NT_STATUS_BAD_IMPERSONATION_LEVEL);
1223
1224 smb2_util_close(tree, h);
1225 smb2_util_unlink(tree, fname);
1226 smb2_deltree(tree, DNAME);
1227 return ret;
1228 }
1229
1230 static bool test_create_acl_file(struct torture_context *tctx,
1231 struct smb2_tree *tree)
1232 {
1233 torture_comment(tctx, "Testing nttrans create with sec_desc on files\n");
1234
1235 return test_create_acl_ext(tctx, tree, false);
1236 }
1237
1238 static bool test_create_acl_dir(struct torture_context *tctx,
1239 struct smb2_tree *tree)
1240 {
1241 torture_comment(tctx, "Testing nttrans create with sec_desc on directories\n");
1242
1243 return test_create_acl_ext(tctx, tree, true);
1244 }
1245
1246 #define CHECK_ACCESS_FLAGS(_fh, flags) do { \
1247 union smb_fileinfo _q; \
1248 _q.access_information.level = RAW_FILEINFO_ACCESS_INFORMATION; \
1249 _q.access_information.in.file.handle = (_fh); \
1250 status = smb2_getinfo_file(tree, tctx, &_q); \
1251 CHECK_STATUS(status, NT_STATUS_OK); \
1252 if (_q.access_information.out.access_flags != (flags)) { \
1253 torture_result(tctx, TORTURE_FAIL, "(%s) Incorrect access_flags 0x%08x - should be 0x%08x\n", \
1254 __location__, _q.access_information.out.access_flags, (flags)); \
1255 ret = false; \
1256 goto done; \
1257 } \
1258 } while (0)
1259
1260 /*
1261 * Test creating a file with a NULL DACL.
1262 */
1263 static bool test_create_null_dacl(struct torture_context *tctx,
1264 struct smb2_tree *tree)
1265 {
1266 NTSTATUS status;
1267 struct smb2_create io;
1268 const char *fname = "nulldacl.txt";
1269 bool ret = true;
1270 struct smb2_handle handle;
1271 union smb_fileinfo q;
1272 union smb_setfileinfo s;
1273 struct security_descriptor *sd = security_descriptor_initialise(tctx);
1274 struct security_acl dacl;
1275
1276 torture_comment(tctx, "TESTING SEC_DESC WITH A NULL DACL\n");
1277
1278 smb2_util_unlink(tree, fname);
1279
1280 ZERO_STRUCT(io);
1281 io.level = RAW_OPEN_SMB2;
1282 io.in.create_flags = 0;
1283 io.in.desired_access = SEC_STD_READ_CONTROL | SEC_STD_WRITE_DAC
1284 | SEC_STD_WRITE_OWNER;
1285 io.in.create_options = 0;
1286 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1287 io.in.share_access =
1288 NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1289 io.in.alloc_size = 0;
1290 io.in.create_disposition = NTCREATEX_DISP_CREATE;
1291 io.in.impersonation_level = NTCREATEX_IMPERSONATION_ANONYMOUS;
1292 io.in.security_flags = 0;
1293 io.in.fname = fname;
1294 io.in.sec_desc = sd;
1295 /* XXX create_options ? */
1296 io.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
1297 NTCREATEX_OPTIONS_ASYNC_ALERT |
1298 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
1299 0x00200000;
1300
1301 torture_comment(tctx, "creating a file with a empty sd\n");
1302 status = smb2_create(tree, tctx, &io);
1303 CHECK_STATUS(status, NT_STATUS_OK);
1304 handle = io.out.file.handle;
1305
1306 torture_comment(tctx, "get the original sd\n");
1307 q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
1308 q.query_secdesc.in.file.handle = handle;
1309 q.query_secdesc.in.secinfo_flags =
1310 SECINFO_OWNER |
1311 SECINFO_GROUP |
1312 SECINFO_DACL;
1313 status = smb2_getinfo_file(tree, tctx, &q);
1314 CHECK_STATUS(status, NT_STATUS_OK);
1315
1316 /*
1317 * Testing the created DACL,
1318 * the server should add the inherited DACL
1319 * when SEC_DESC_DACL_PRESENT isn't specified
1320 */
1321 if (!(q.query_secdesc.out.sd->type & SEC_DESC_DACL_PRESENT)) {
1322 ret = false;
1323 torture_fail_goto(tctx, done, "DACL_PRESENT flag not set by the server!\n");
1324 }
1325 if (q.query_secdesc.out.sd->dacl == NULL) {
1326 ret = false;
1327 torture_fail_goto(tctx, done, "no DACL has been created on the server!\n");
1328 }
1329
1330 torture_comment(tctx, "set NULL DACL\n");
1331 sd->type |= SEC_DESC_DACL_PRESENT;
1332
1333 s.set_secdesc.level = RAW_SFILEINFO_SEC_DESC;
1334 s.set_secdesc.in.file.handle = handle;
1335 s.set_secdesc.in.secinfo_flags = SECINFO_DACL;
1336 s.set_secdesc.in.sd = sd;
1337 status = smb2_setinfo_file(tree, &s);
1338 CHECK_STATUS(status, NT_STATUS_OK);
1339
1340 torture_comment(tctx, "get the sd\n");
1341 q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
1342 q.query_secdesc.in.file.handle = handle;
1343 q.query_secdesc.in.secinfo_flags =
1344 SECINFO_OWNER |
1345 SECINFO_GROUP |
1346 SECINFO_DACL;
1347 status = smb2_getinfo_file(tree, tctx, &q);
1348 CHECK_STATUS(status, NT_STATUS_OK);
1349
1350 /* Testing the modified DACL */
1351 if (!(q.query_secdesc.out.sd->type & SEC_DESC_DACL_PRESENT)) {
1352 ret = false;
1353 torture_fail_goto(tctx, done, "DACL_PRESENT flag not set by the server!\n");
1354 }
1355 if (q.query_secdesc.out.sd->dacl != NULL) {
1356 ret = false;
1357 torture_fail_goto(tctx, done, "DACL has been created on the server!\n");
1358 }
1359
1360 io.in.create_disposition = NTCREATEX_DISP_OPEN;
1361
1362 torture_comment(tctx, "try open for read control\n");
1363 io.in.desired_access = SEC_STD_READ_CONTROL;
1364 status = smb2_create(tree, tctx, &io);
1365 CHECK_STATUS(status, NT_STATUS_OK);
1366 CHECK_ACCESS_FLAGS(io.out.file.handle,
1367 SEC_STD_READ_CONTROL);
1368 smb2_util_close(tree, io.out.file.handle);
1369
1370 torture_comment(tctx, "try open for write\n");
1371 io.in.desired_access = SEC_FILE_WRITE_DATA;
1372 status = smb2_create(tree, tctx, &io);
1373 CHECK_STATUS(status, NT_STATUS_OK);
1374 CHECK_ACCESS_FLAGS(io.out.file.handle,
1375 SEC_FILE_WRITE_DATA);
1376 smb2_util_close(tree, io.out.file.handle);
1377
1378 torture_comment(tctx, "try open for read\n");
1379 io.in.desired_access = SEC_FILE_READ_DATA;
1380 status = smb2_create(tree, tctx, &io);
1381 CHECK_STATUS(status, NT_STATUS_OK);
1382 CHECK_ACCESS_FLAGS(io.out.file.handle,
1383 SEC_FILE_READ_DATA);
1384 smb2_util_close(tree, io.out.file.handle);
1385
1386 torture_comment(tctx, "try open for generic write\n");
1387 io.in.desired_access = SEC_GENERIC_WRITE;
1388 status = smb2_create(tree, tctx, &io);
1389 CHECK_STATUS(status, NT_STATUS_OK);
1390 CHECK_ACCESS_FLAGS(io.out.file.handle,
1391 SEC_RIGHTS_FILE_WRITE);
1392 smb2_util_close(tree, io.out.file.handle);
1393
1394 torture_comment(tctx, "try open for generic read\n");
1395 io.in.desired_access = SEC_GENERIC_READ;
1396 status = smb2_create(tree, tctx, &io);
1397 CHECK_STATUS(status, NT_STATUS_OK);
1398 CHECK_ACCESS_FLAGS(io.out.file.handle,
1399 SEC_RIGHTS_FILE_READ);
1400 smb2_util_close(tree, io.out.file.handle);
1401
1402 torture_comment(tctx, "set DACL with 0 aces\n");
1403 ZERO_STRUCT(dacl);
1404 dacl.revision = SECURITY_ACL_REVISION_NT4;
1405 dacl.num_aces = 0;
1406 sd->dacl = &dacl;
1407
1408 s.set_secdesc.level = RAW_SFILEINFO_SEC_DESC;
1409 s.set_secdesc.in.file.handle = handle;
1410 s.set_secdesc.in.secinfo_flags = SECINFO_DACL;
1411 s.set_secdesc.in.sd = sd;
1412 status = smb2_setinfo_file(tree, &s);
1413 CHECK_STATUS(status, NT_STATUS_OK);
1414
1415 torture_comment(tctx, "get the sd\n");
1416 q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
1417 q.query_secdesc.in.file.handle = handle;
1418 q.query_secdesc.in.secinfo_flags =
1419 SECINFO_OWNER |
1420 SECINFO_GROUP |
1421 SECINFO_DACL;
1422 status = smb2_getinfo_file(tree, tctx, &q);
1423 CHECK_STATUS(status, NT_STATUS_OK);
1424
1425 /* Testing the modified DACL */
1426 if (!(q.query_secdesc.out.sd->type & SEC_DESC_DACL_PRESENT)) {
1427 ret = false;
1428 torture_fail_goto(tctx, done, "DACL_PRESENT flag not set by the server!\n");
1429 }
1430 if (q.query_secdesc.out.sd->dacl == NULL) {
1431 ret = false;
1432 torture_fail_goto(tctx, done, "no DACL has been created on the server!\n");
1433 }
1434 if (q.query_secdesc.out.sd->dacl->num_aces != 0) {
1435 torture_result(tctx, TORTURE_FAIL, "DACL has %u aces!\n",
1436 q.query_secdesc.out.sd->dacl->num_aces);
1437 ret = false;
1438 goto done;
1439 }
1440
1441 torture_comment(tctx, "try open for read control\n");
1442 io.in.desired_access = SEC_STD_READ_CONTROL;
1443 status = smb2_create(tree, tctx, &io);
1444 CHECK_STATUS(status, NT_STATUS_OK);
1445 CHECK_ACCESS_FLAGS(io.out.file.handle,
1446 SEC_STD_READ_CONTROL);
1447 smb2_util_close(tree, io.out.file.handle);
1448
1449 torture_comment(tctx, "try open for write => access_denied\n");
1450 io.in.desired_access = SEC_FILE_WRITE_DATA;
1451 status = smb2_create(tree, tctx, &io);
1452 if (torture_setting_bool(tctx, "hide_on_access_denied", false)) {
1453 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1454 } else {
1455 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
1456 }
1457
1458 torture_comment(tctx, "try open for read => access_denied\n");
1459 io.in.desired_access = SEC_FILE_READ_DATA;
1460 status = smb2_create(tree, tctx, &io);
1461 if (torture_setting_bool(tctx, "hide_on_access_denied", false)) {
1462 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1463 } else {
1464 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
1465 }
1466
1467 torture_comment(tctx, "try open for generic write => access_denied\n");
1468 io.in.desired_access = SEC_GENERIC_WRITE;
1469 status = smb2_create(tree, tctx, &io);
1470 if (torture_setting_bool(tctx, "hide_on_access_denied", false)) {
1471 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1472 } else {
1473 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
1474 }
1475
1476 torture_comment(tctx, "try open for generic read => access_denied\n");
1477 io.in.desired_access = SEC_GENERIC_READ;
1478 status = smb2_create(tree, tctx, &io);
1479 if (torture_setting_bool(tctx, "hide_on_access_denied", false)) {
1480 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1481 } else {
1482 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
1483 }
1484
1485 torture_comment(tctx, "set empty sd\n");
1486 sd->type &= ~SEC_DESC_DACL_PRESENT;
1487 sd->dacl = NULL;
1488
1489 s.set_secdesc.level = RAW_SFILEINFO_SEC_DESC;
1490 s.set_secdesc.in.file.handle = handle;
1491 s.set_secdesc.in.secinfo_flags = SECINFO_DACL;
1492 s.set_secdesc.in.sd = sd;
1493 status = smb2_setinfo_file(tree, &s);
1494 CHECK_STATUS(status, NT_STATUS_OK);
1495
1496 torture_comment(tctx, "get the sd\n");
1497 q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
1498 q.query_secdesc.in.file.handle = handle;
1499 q.query_secdesc.in.secinfo_flags =
1500 SECINFO_OWNER |
1501 SECINFO_GROUP |
1502 SECINFO_DACL;
1503 status = smb2_getinfo_file(tree, tctx, &q);
1504 CHECK_STATUS(status, NT_STATUS_OK);
1505
1506 /* Testing the modified DACL */
1507 if (!(q.query_secdesc.out.sd->type & SEC_DESC_DACL_PRESENT)) {
1508 ret = false;
1509 torture_fail_goto(tctx, done, "DACL_PRESENT flag not set by the server!\n");
1510 }
1511 if (q.query_secdesc.out.sd->dacl != NULL) {
1512 ret = false;
1513 torture_fail_goto(tctx, done, "DACL has been created on the server!\n");
1514 }
1515 done:
1516 smb2_util_close(tree, handle);
1517 smb2_util_unlink(tree, fname);
1518 smb2_tdis(tree);
1519 smb2_logoff(tree->session);
1520 return ret;
1521 }
1522
1523 /*
1524 test SMB2 mkdir with OPEN_IF on the same name twice.
1525 Must use 2 connections to hit the race.
1526 */
1527
1528 static bool test_mkdir_dup(struct torture_context *tctx,
1529 struct smb2_tree *tree)
1530 {
1531 const char *fname = "mkdir_dup";
1532 NTSTATUS status;
1533 bool ret = true;
1534 union smb_open io;
1535 struct smb2_tree **trees;
1536 struct smb2_request **requests;
1537 union smb_open *ios;
1538 int i, num_files = 2;
1539 int num_ok = 0;
1540 int num_created = 0;
1541 int num_existed = 0;
1542
1543 torture_comment(tctx,
1544 "Testing SMB2 Create Directory with multiple connections\n");
1545 trees = talloc_array(tctx, struct smb2_tree *, num_files);
1546 requests = talloc_array(tctx, struct smb2_request *, num_files);
1547 ios = talloc_array(tctx, union smb_open, num_files);
1548 if ((tctx->ev == NULL) || (trees == NULL) || (requests == NULL) ||
1549 (ios == NULL)) {
1550 torture_fail(tctx, ("talloc failed\n"));
1551 ret = false;
1552 goto done;
1553 }
1554
1555 tree->session->transport->options.request_timeout = 60;
1556
1557 for (i=0; i<num_files; i++) {
1558 if (!torture_smb2_connection(tctx, &(trees[i]))) {
1559 torture_fail(tctx,
1560 talloc_asprintf(tctx,
1561 "Could not open %d'th connection\n", i));
1562 ret = false;
1563 goto done;
1564 }
1565 trees[i]->session->transport->options.request_timeout = 60;
1566 }
1567
1568 /* cleanup */
1569 smb2_util_unlink(tree, fname);
1570 smb2_util_rmdir(tree, fname);
1571
1572 /*
1573 base ntcreatex parms
1574 */
1575 ZERO_STRUCT(io.smb2);
1576 io.generic.level = RAW_OPEN_SMB2;
1577 io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1578 io.smb2.in.alloc_size = 0;
1579 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1580 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1581 NTCREATEX_SHARE_ACCESS_WRITE|
1582 NTCREATEX_SHARE_ACCESS_DELETE;
1583 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1584 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1585 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1586 io.smb2.in.security_flags = 0;
1587 io.smb2.in.fname = fname;
1588 io.smb2.in.create_flags = 0;
1589
1590 for (i=0; i<num_files; i++) {
1591 ios[i] = io;
1592 requests[i] = smb2_create_send(trees[i], &(ios[i].smb2));
1593 if (requests[i] == NULL) {
1594 torture_fail(tctx,
1595 talloc_asprintf(tctx,
1596 "could not send %d'th request\n", i));
1597 ret = false;
1598 goto done;
1599 }
1600 }
1601
1602 torture_comment(tctx, "waiting for replies\n");
1603 while (1) {
1604 bool unreplied = false;
1605 for (i=0; i<num_files; i++) {
1606 if (requests[i] == NULL) {
1607 continue;
1608 }
1609 if (requests[i]->state < SMB2_REQUEST_DONE) {
1610 unreplied = true;
1611 break;
1612 }
1613 status = smb2_create_recv(requests[i], tctx,
1614 &(ios[i].smb2));
1615
1616 if (NT_STATUS_IS_OK(status)) {
1617 num_ok += 1;
1618
1619 if (ios[i].smb2.out.create_action ==
1620 NTCREATEX_ACTION_CREATED) {
1621 num_created++;
1622 }
1623 if (ios[i].smb2.out.create_action ==
1624 NTCREATEX_ACTION_EXISTED) {
1625 num_existed++;
1626 }
1627 } else {
1628 torture_fail(tctx,
1629 talloc_asprintf(tctx,
1630 "File %d returned status %s\n", i,
1631 nt_errstr(status)));
1632 }
1633
1634
1635 requests[i] = NULL;
1636 }
1637 if (!unreplied) {
1638 break;
1639 }
1640
1641 if (tevent_loop_once(tctx->ev) != 0) {
1642 torture_fail(tctx, "tevent_loop_once failed\n");
1643 ret = false;
1644 goto done;
1645 }
1646 }
1647
1648 if (num_ok != 2) {
1649 torture_fail(tctx,
1650 talloc_asprintf(tctx,
1651 "num_ok == %d\n", num_ok));
1652 ret = false;
1653 }
1654 if (num_created != 1) {
1655 torture_fail(tctx,
1656 talloc_asprintf(tctx,
1657 "num_created == %d\n", num_created));
1658 ret = false;
1659 }
1660 if (num_existed != 1) {
1661 torture_fail(tctx,
1662 talloc_asprintf(tctx,
1663 "num_existed == %d\n", num_existed));
1664 ret = false;
1665 }
1666 done:
1667 smb2_deltree(tree, fname);
1668
1669 return ret;
1670 }
1671
1672 /*
1673 test directory creation with an initial allocation size > 0
1674 */
1675 static bool test_dir_alloc_size(struct torture_context *tctx,
1676 struct smb2_tree *tree)
1677 {
1678 bool ret = true;
1679 const char *dname = DNAME "\\torture_alloc_size.dir";
1680 NTSTATUS status;
1681 struct smb2_create c;
1682 struct smb2_handle h1 = {{0}}, h2;
1683
1684 torture_comment(tctx, "Checking initial allocation size on directories\n");
1685
1686 smb2_deltree(tree, dname);
1687
1688 status = torture_smb2_testdir(tree, DNAME, &h1);
1689 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "torture_smb2_testdir failed");
1690
1691 ZERO_STRUCT(c);
1692 c.in.create_disposition = NTCREATEX_DISP_CREATE;
1693 c.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
1694 c.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
1695 c.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1696 c.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1697 c.in.fname = dname;
1698 /*
1699 * An insanely large value so we can check the value is
1700 * ignored: Samba either returns 0 (current behaviour), or,
1701 * once vfswrap_get_alloc_size() is fixed to allow retrieving
1702 * the allocated size for directories, returns
1703 * smb_roundup(..., stat.st_size) which would be 1 MB by
1704 * default.
1705 *
1706 * Windows returns 0 for emtpy directories, once directories
1707 * have a few entries it starts replying with values > 0.
1708 */
1709 c.in.alloc_size = 1024*1024*1024;
1710
1711 status = smb2_create(tree, tctx, &c);
1712 h2 = c.out.file.handle;
1713 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1714 "dir create with initial alloc size failed");
1715
1716 smb2_util_close(tree, h2);
1717
1718 torture_comment(tctx, "Got directory alloc size: %ju\n", (uintmax_t)c.out.alloc_size);
1719
1720 /*
1721 * See above for the rational for this test
1722 */
1723 if (c.out.alloc_size > 1024*1024) {
1724 torture_fail_goto(tctx, done, talloc_asprintf(tctx, "bad alloc size: %ju",
1725 (uintmax_t)c.out.alloc_size));
1726 }
1727
1728 done:
1729 if (!smb2_util_handle_empty(h1)) {
1730 smb2_util_close(tree, h1);
1731 }
1732 smb2_deltree(tree, DNAME);
1733 return ret;
1734 }
1735
1736 /*
1737 basic testing of SMB2 read
1738 */
1739 struct torture_suite *torture_smb2_create_init(TALLOC_CTX *ctx)
1740 {
1741 struct torture_suite *suite = torture_suite_create(ctx, "create");
1742
1743 torture_suite_add_1smb2_test(suite, "gentest", test_create_gentest);
1744 torture_suite_add_1smb2_test(suite, "blob", test_create_blob);
1745 torture_suite_add_1smb2_test(suite, "open", test_smb2_open);
1746 torture_suite_add_1smb2_test(suite, "brlocked", test_smb2_open_brlocked);
1747 torture_suite_add_1smb2_test(suite, "multi", test_smb2_open_multi);
1748 torture_suite_add_1smb2_test(suite, "delete", test_smb2_open_for_delete);
1749 torture_suite_add_1smb2_test(suite, "leading-slash", test_smb2_leading_slash);
1750 torture_suite_add_1smb2_test(suite, "impersonation", test_smb2_impersonation_level);
1751 torture_suite_add_1smb2_test(suite, "aclfile", test_create_acl_file);
1752 torture_suite_add_1smb2_test(suite, "acldir", test_create_acl_dir);
1753 torture_suite_add_1smb2_test(suite, "nulldacl", test_create_null_dacl);
1754 torture_suite_add_1smb2_test(suite, "mkdir-dup", test_mkdir_dup);
1755 torture_suite_add_1smb2_test(suite, "dir-alloc-size", test_dir_alloc_size);
1756
1757 suite->description = talloc_strdup(suite, "SMB2-CREATE tests");
1758
1759 return suite;
1760 }
Samba GIT mirror