?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
torture: Add smb2.notify.rmdir
[Samba.git] / source4 / torture / smb2 / notify.c
blob0f572b6774dd07c6e9696b437db57436a6d6e7ac
1 /*
2 Unix SMB/CIFS implementation.
3
4 SMB2 notify test suite
5
6 Copyright (C) Stefan Metzmacher 2006
7 Copyright (C) Andrew Tridgell 2009
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "libcli/smb2/smb2.h"
25 #include "libcli/smb2/smb2_calls.h"
26 #include "../libcli/smb/smbXcli_base.h"
27
28 #include "torture/torture.h"
29 #include "torture/smb2/proto.h"
30 #include "librpc/gen_ndr/ndr_security.h"
31 #include "libcli/security/security.h"
32 #include "torture/util.h"
33
34 #include "system/filesys.h"
35 #include "auth/credentials/credentials.h"
36 #include "lib/cmdline/popt_common.h"
37 #include "librpc/gen_ndr/security.h"
38
39 #include "lib/events/events.h"
40
41 #include "libcli/raw/libcliraw.h"
42 #include "libcli/raw/raw_proto.h"
43 #include "libcli/libcli.h"
44
45 #define CHECK_STATUS(status, correct) do { \
46 if (!NT_STATUS_EQUAL(status, correct)) { \
47 torture_result(torture, TORTURE_FAIL, \
48 "(%s) Incorrect status %s - should be %s\n", \
49 __location__, nt_errstr(status), nt_errstr(correct)); \
50 ret = false; \
51 goto done; \
52 }} while (0)
53
54 #define CHECK_VAL(v, correct) do { \
55 if ((v) != (correct)) { \
56 torture_result(torture, TORTURE_FAIL, \
57 "(%s) wrong value for %s 0x%x should be 0x%x\n", \
58 __location__, #v, (int)v, (int)correct); \
59 ret = false; \
60 goto done; \
61 }} while (0)
62
63 #define CHECK_WIRE_STR(field, value) do { \
64 if (!field.s || strcmp(field.s, value)) { \
65 torture_result(torture, TORTURE_FAIL, \
66 "(%s) %s [%s] != %s\n", __location__, #field, \
67 field.s, value); \
68 ret = false; \
69 goto done; \
70 }} while (0)
71
72 #define WAIT_FOR_ASYNC_RESPONSE(req) \
73 while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) { \
74 if (tevent_loop_once(torture->ev) != 0) { \
75 break; \
76 } \
77 }
78
79 #define BASEDIR "test_notify"
80 #define FNAME "smb2-notify01.dat"
81
82 static bool test_valid_request(struct torture_context *torture,
83 struct smb2_tree *tree)
84 {
85 bool ret = true;
86 NTSTATUS status;
87 struct smb2_handle dh;
88 struct smb2_notify n;
89 struct smb2_request *req;
90 uint32_t max_buffer_size;
91
92 torture_comment(torture, "TESTING VALIDITY OF CHANGE NOTIFY REQUEST\n");
93
94 smb2_util_unlink(tree, FNAME);
95
96 status = smb2_util_roothandle(tree, &dh);
97 CHECK_STATUS(status, NT_STATUS_OK);
98
99 /* 0x00080000 is the default max buffer size for Windows servers
100 * pre-Win7 */
101 max_buffer_size = torture_setting_ulong(torture, "cn_max_buffer_size",
102 0x00080000);
103
104 n.in.recursive = 0x0000;
105 n.in.buffer_size = max_buffer_size;
106 n.in.file.handle = dh;
107 n.in.completion_filter = FILE_NOTIFY_CHANGE_ALL;
108 n.in.unknown = 0x00000000;
109 req = smb2_notify_send(tree, &n);
110
111 while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {
112 if (tevent_loop_once(torture->ev) != 0) {
113 break;
114 }
115 }
116
117 status = torture_setup_complex_file(tree, FNAME);
118 CHECK_STATUS(status, NT_STATUS_OK);
119
120 status = smb2_notify_recv(req, torture, &n);
121 CHECK_STATUS(status, NT_STATUS_OK);
122 CHECK_VAL(n.out.num_changes, 1);
123 CHECK_VAL(n.out.changes[0].action, NOTIFY_ACTION_ADDED);
124 CHECK_WIRE_STR(n.out.changes[0].name, FNAME);
125
126 /*
127 * if the change response doesn't fit in the buffer
128 * NOTIFY_ENUM_DIR is returned.
129 */
130 n.in.buffer_size = 0x00000000;
131 req = smb2_notify_send(tree, &n);
132
133 while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {
134 if (tevent_loop_once(torture->ev) != 0) {
135 break;
136 }
137 }
138
139 status = torture_setup_complex_file(tree, FNAME);
140 CHECK_STATUS(status, NT_STATUS_OK);
141
142 status = smb2_notify_recv(req, torture, &n);
143 CHECK_STATUS(status, STATUS_NOTIFY_ENUM_DIR);
144
145 /*
146 * if the change response fits in the buffer we get
147 * NT_STATUS_OK again
148 */
149 n.in.buffer_size = max_buffer_size;
150 req = smb2_notify_send(tree, &n);
151
152 while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {
153 if (tevent_loop_once(torture->ev) != 0) {
154 break;
155 }
156 }
157
158 status = torture_setup_complex_file(tree, FNAME);
159 CHECK_STATUS(status, NT_STATUS_OK);
160
161 status = smb2_notify_recv(req, torture, &n);
162 CHECK_STATUS(status, NT_STATUS_OK);
163 CHECK_VAL(n.out.num_changes, 3);
164 CHECK_VAL(n.out.changes[0].action, NOTIFY_ACTION_REMOVED);
165 CHECK_WIRE_STR(n.out.changes[0].name, FNAME);
166 CHECK_VAL(n.out.changes[1].action, NOTIFY_ACTION_ADDED);
167 CHECK_WIRE_STR(n.out.changes[1].name, FNAME);
168 CHECK_VAL(n.out.changes[2].action, NOTIFY_ACTION_MODIFIED);
169 CHECK_WIRE_STR(n.out.changes[2].name, FNAME);
170
171 /* if the first notify returns NOTIFY_ENUM_DIR, all do */
172 status = smb2_util_close(tree, dh);
173 CHECK_STATUS(status, NT_STATUS_OK);
174 status = smb2_util_roothandle(tree, &dh);
175 CHECK_STATUS(status, NT_STATUS_OK);
176
177 n.in.recursive = 0x0000;
178 n.in.buffer_size = 0x00000001;
179 n.in.file.handle = dh;
180 n.in.completion_filter = FILE_NOTIFY_CHANGE_ALL;
181 n.in.unknown = 0x00000000;
182 req = smb2_notify_send(tree, &n);
183
184 while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {
185 if (tevent_loop_once(torture->ev) != 0) {
186 break;
187 }
188 }
189
190 status = torture_setup_complex_file(tree, FNAME);
191 CHECK_STATUS(status, NT_STATUS_OK);
192
193 status = smb2_notify_recv(req, torture, &n);
194 CHECK_STATUS(status, STATUS_NOTIFY_ENUM_DIR);
195
196 n.in.buffer_size = max_buffer_size;
197 req = smb2_notify_send(tree, &n);
198 while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) {
199 if (tevent_loop_once(torture->ev) != 0) {
200 break;
201 }
202 }
203
204 status = torture_setup_complex_file(tree, FNAME);
205 CHECK_STATUS(status, NT_STATUS_OK);
206
207 status = smb2_notify_recv(req, torture, &n);
208 CHECK_STATUS(status, STATUS_NOTIFY_ENUM_DIR);
209
210 /* if the buffer size is too large, we get invalid parameter */
211 n.in.recursive = 0x0000;
212 n.in.buffer_size = max_buffer_size + 1;
213 n.in.file.handle = dh;
214 n.in.completion_filter = FILE_NOTIFY_CHANGE_ALL;
215 n.in.unknown = 0x00000000;
216 req = smb2_notify_send(tree, &n);
217 status = smb2_notify_recv(req, torture, &n);
218 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
219
220 done:
221 return ret;
222 }
223
224 /*
225 basic testing of change notify on directories
226 */
227 static bool torture_smb2_notify_dir(struct torture_context *torture,
228 struct smb2_tree *tree1,
229 struct smb2_tree *tree2)
230 {
231 bool ret = true;
232 NTSTATUS status;
233 union smb_notify notify;
234 union smb_open io;
235 union smb_close cl;
236 int i, count;
237 struct smb2_handle h1, h2;
238 struct smb2_request *req, *req2;
239 const char *fname = BASEDIR "\\subdir-name";
240 extern int torture_numops;
241
242 torture_comment(torture, "TESTING CHANGE NOTIFY ON DIRECTORIES\n");
243
244 smb2_deltree(tree1, BASEDIR);
245 smb2_util_rmdir(tree1, BASEDIR);
246 /*
247 get a handle on the directory
248 */
249 ZERO_STRUCT(io.smb2);
250 io.generic.level = RAW_OPEN_SMB2;
251 io.smb2.in.create_flags = 0;
252 io.smb2.in.desired_access = SEC_FILE_ALL;
253 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
254 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
255 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
256 NTCREATEX_SHARE_ACCESS_WRITE;
257 io.smb2.in.alloc_size = 0;
258 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
259 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
260 io.smb2.in.security_flags = 0;
261 io.smb2.in.fname = BASEDIR;
262
263 status = smb2_create(tree1, torture, &(io.smb2));
264 CHECK_STATUS(status, NT_STATUS_OK);
265 h1 = io.smb2.out.file.handle;
266
267 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
268 io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ;
269 status = smb2_create(tree1, torture, &(io.smb2));
270 CHECK_STATUS(status, NT_STATUS_OK);
271 h2 = io.smb2.out.file.handle;
272
273 /* ask for a change notify,
274 on file or directory name changes */
275 ZERO_STRUCT(notify.smb2);
276 notify.smb2.level = RAW_NOTIFY_SMB2;
277 notify.smb2.in.buffer_size = 1000;
278 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
279 notify.smb2.in.file.handle = h1;
280 notify.smb2.in.recursive = true;
281
282 torture_comment(torture, "Testing notify cancel\n");
283
284 req = smb2_notify_send(tree1, &(notify.smb2));
285 smb2_cancel(req);
286 status = smb2_notify_recv(req, torture, &(notify.smb2));
287 CHECK_STATUS(status, NT_STATUS_CANCELLED);
288
289 torture_comment(torture, "Testing notify mkdir\n");
290
291 req = smb2_notify_send(tree1, &(notify.smb2));
292 smb2_util_mkdir(tree2, fname);
293
294 status = smb2_notify_recv(req, torture, &(notify.smb2));
295 CHECK_STATUS(status, NT_STATUS_OK);
296
297 CHECK_VAL(notify.smb2.out.num_changes, 1);
298 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_ADDED);
299 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
300
301 torture_comment(torture, "Testing notify rmdir\n");
302
303 req = smb2_notify_send(tree1, &(notify.smb2));
304 smb2_util_rmdir(tree2, fname);
305
306 status = smb2_notify_recv(req, torture, &(notify.smb2));
307 CHECK_STATUS(status, NT_STATUS_OK);
308 CHECK_VAL(notify.smb2.out.num_changes, 1);
309 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_REMOVED);
310 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
311
312 torture_comment(torture,
313 "Testing notify mkdir - rmdir - mkdir - rmdir\n");
314
315 smb2_util_mkdir(tree2, fname);
316 smb2_util_rmdir(tree2, fname);
317 smb2_util_mkdir(tree2, fname);
318 smb2_util_rmdir(tree2, fname);
319 smb_msleep(200);
320 req = smb2_notify_send(tree1, &(notify.smb2));
321 status = smb2_notify_recv(req, torture, &(notify.smb2));
322 CHECK_STATUS(status, NT_STATUS_OK);
323 CHECK_VAL(notify.smb2.out.num_changes, 4);
324 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_ADDED);
325 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
326 CHECK_VAL(notify.smb2.out.changes[1].action, NOTIFY_ACTION_REMOVED);
327 CHECK_WIRE_STR(notify.smb2.out.changes[1].name, "subdir-name");
328 CHECK_VAL(notify.smb2.out.changes[2].action, NOTIFY_ACTION_ADDED);
329 CHECK_WIRE_STR(notify.smb2.out.changes[2].name, "subdir-name");
330 CHECK_VAL(notify.smb2.out.changes[3].action, NOTIFY_ACTION_REMOVED);
331 CHECK_WIRE_STR(notify.smb2.out.changes[3].name, "subdir-name");
332
333 count = torture_numops;
334 torture_comment(torture,
335 "Testing buffered notify on create of %d files\n", count);
336 for (i=0;i<count;i++) {
337 struct smb2_handle h12;
338 char *fname2 = talloc_asprintf(torture, BASEDIR "\\test%d.txt",
339 i);
340
341 ZERO_STRUCT(io.smb2);
342 io.generic.level = RAW_OPEN_SMB2;
343 io.smb2.in.create_flags = 0;
344 io.smb2.in.desired_access = SEC_FILE_ALL;
345 io.smb2.in.create_options =
346 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
347 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
348 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
349 NTCREATEX_SHARE_ACCESS_WRITE;
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 = fname2;
355
356 status = smb2_create(tree1, torture, &(io.smb2));
357 if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
358 torture_comment(torture, "Failed to create %s \n",
359 fname);
360 ret = false;
361 goto done;
362 }
363 h12 = io.smb2.out.file.handle;
364 talloc_free(fname2);
365 smb2_util_close(tree1, h12);
366 }
367
368 /* (1st notify) setup a new notify on a different directory handle.
369 This new notify won't see the events above. */
370 notify.smb2.in.file.handle = h2;
371 req2 = smb2_notify_send(tree1, &(notify.smb2));
372
373 /* (2nd notify) whereas this notify will see the above buffered events,
374 and it directly returns the buffered events */
375 notify.smb2.in.file.handle = h1;
376 req = smb2_notify_send(tree1, &(notify.smb2));
377
378 status = smb2_util_unlink(tree1, BASEDIR "\\nonexistent.txt");
379 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
380
381 /* (1st unlink) as the 2nd notify directly returns,
382 this unlink is only seen by the 1st notify and
383 the 3rd notify (later) */
384 torture_comment(torture,
385 "Testing notify on unlink for the first file\n");
386 status = smb2_util_unlink(tree2, BASEDIR "\\test0.txt");
387 CHECK_STATUS(status, NT_STATUS_OK);
388
389 /* receive the reply from the 2nd notify */
390 status = smb2_notify_recv(req, torture, &(notify.smb2));
391 CHECK_STATUS(status, NT_STATUS_OK);
392
393 CHECK_VAL(notify.smb2.out.num_changes, count);
394 for (i=1;i<count;i++) {
395 CHECK_VAL(notify.smb2.out.changes[i].action,
396 NOTIFY_ACTION_ADDED);
397 }
398 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "test0.txt");
399
400 torture_comment(torture, "and now from the 1st notify\n");
401 status = smb2_notify_recv(req2, torture, &(notify.smb2));
402 CHECK_STATUS(status, NT_STATUS_OK);
403 CHECK_VAL(notify.smb2.out.num_changes, 1);
404 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_REMOVED);
405 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "test0.txt");
406
407 torture_comment(torture,
408 "(3rd notify) this notify will only see the 1st unlink\n");
409 req = smb2_notify_send(tree1, &(notify.smb2));
410
411 status = smb2_util_unlink(tree1, BASEDIR "\\nonexistent.txt");
412 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
413
414 for (i=1;i<count;i++) {
415 char *fname2 = talloc_asprintf(torture,
416 BASEDIR "\\test%d.txt", i);
417 status = smb2_util_unlink(tree2, fname2);
418 CHECK_STATUS(status, NT_STATUS_OK);
419 talloc_free(fname2);
420 }
421
422 /* receive the 3rd notify */
423 status = smb2_notify_recv(req, torture, &(notify.smb2));
424 CHECK_STATUS(status, NT_STATUS_OK);
425 CHECK_VAL(notify.smb2.out.num_changes, 1);
426 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_REMOVED);
427 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "test0.txt");
428
429 /* and we now see the rest of the unlink calls on both
430 * directory handles */
431 notify.smb2.in.file.handle = h1;
432 sleep(3);
433 req = smb2_notify_send(tree1, &(notify.smb2));
434 status = smb2_notify_recv(req, torture, &(notify.smb2));
435 CHECK_STATUS(status, NT_STATUS_OK);
436 CHECK_VAL(notify.smb2.out.num_changes, count-1);
437 for (i=0;i<notify.smb2.out.num_changes;i++) {
438 CHECK_VAL(notify.smb2.out.changes[i].action,
439 NOTIFY_ACTION_REMOVED);
440 }
441 notify.smb2.in.file.handle = h2;
442 req = smb2_notify_send(tree1, &(notify.smb2));
443 status = smb2_notify_recv(req, torture, &(notify.smb2));
444 CHECK_STATUS(status, NT_STATUS_OK);
445 CHECK_VAL(notify.smb2.out.num_changes, count-1);
446 for (i=0;i<notify.smb2.out.num_changes;i++) {
447 CHECK_VAL(notify.smb2.out.changes[i].action,
448 NOTIFY_ACTION_REMOVED);
449 }
450
451 torture_comment(torture,
452 "Testing if a close() on the dir handle triggers the notify reply\n");
453
454 notify.smb2.in.file.handle = h1;
455 req = smb2_notify_send(tree1, &(notify.smb2));
456
457 ZERO_STRUCT(cl.smb2);
458 cl.smb2.level = RAW_CLOSE_SMB2;
459 cl.smb2.in.file.handle = h1;
460 status = smb2_close(tree1, &(cl.smb2));
461 CHECK_STATUS(status, NT_STATUS_OK);
462
463 status = smb2_notify_recv(req, torture, &(notify.smb2));
464 CHECK_STATUS(status, STATUS_NOTIFY_CLEANUP);
465 CHECK_VAL(notify.smb2.out.num_changes, 9);
466
467 done:
468 smb2_util_close(tree1, h1);
469 smb2_util_close(tree1, h2);
470 smb2_deltree(tree1, BASEDIR);
471 return ret;
472 }
473
474 static struct smb2_handle custom_smb2_create(struct smb2_tree *tree,
475 struct torture_context *torture,
476 struct smb2_create *smb2)
477 {
478 struct smb2_handle h1;
479 bool ret = true;
480 NTSTATUS status;
481 smb2_deltree(tree, smb2->in.fname);
482 status = smb2_create(tree, torture, smb2);
483 CHECK_STATUS(status, NT_STATUS_OK);
484 h1 = smb2->out.file.handle;
485 done:
486 if (!ret) {
487 h1 = (struct smb2_handle) {
488 .data = { 0 , 0},
489 };
490 }
491 return h1;
492 }
493
494 /*
495 testing of recursive change notify
496 */
497
498 static bool torture_smb2_notify_recursive(struct torture_context *torture,
499 struct smb2_tree *tree1,
500 struct smb2_tree *tree2)
501 {
502 bool ret = true;
503 NTSTATUS status;
504 union smb_notify notify;
505 union smb_open io, io1;
506 union smb_setfileinfo sinfo;
507 struct smb2_handle h1;
508 struct smb2_request *req1, *req2;
509
510 smb2_deltree(tree1, BASEDIR);
511 smb2_util_rmdir(tree1, BASEDIR);
512
513 torture_comment(torture, "TESTING CHANGE NOTIFY WITH RECURSION\n");
514
515 /*
516 get a handle on the directory
517 */
518 ZERO_STRUCT(io.smb2);
519 io.generic.level = RAW_OPEN_SMB2;
520 io.smb2.in.create_flags = 0;
521 io.smb2.in.desired_access = SEC_FILE_ALL;
522 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
523 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
524 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
525 NTCREATEX_SHARE_ACCESS_WRITE;
526 io.smb2.in.alloc_size = 0;
527 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
528 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
529 io.smb2.in.security_flags = 0;
530 io.smb2.in.fname = BASEDIR;
531
532 status = smb2_create(tree1, torture, &(io.smb2));
533 CHECK_STATUS(status, NT_STATUS_OK);
534 h1 = io.smb2.out.file.handle;
535
536 /* ask for a change notify, on file or directory name
537 changes. Setup both with and without recursion */
538 ZERO_STRUCT(notify.smb2);
539 notify.smb2.level = RAW_NOTIFY_SMB2;
540 notify.smb2.in.buffer_size = 1000;
541 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME |
542 FILE_NOTIFY_CHANGE_ATTRIBUTES |
543 FILE_NOTIFY_CHANGE_CREATION;
544 notify.smb2.in.file.handle = h1;
545
546 notify.smb2.in.recursive = true;
547 req1 = smb2_notify_send(tree1, &(notify.smb2));
548 smb2_cancel(req1);
549 status = smb2_notify_recv(req1, torture, &(notify.smb2));
550 CHECK_STATUS(status, NT_STATUS_CANCELLED);
551
552 notify.smb2.in.recursive = false;
553 req2 = smb2_notify_send(tree1, &(notify.smb2));
554 smb2_cancel(req2);
555 status = smb2_notify_recv(req2, torture, &(notify.smb2));
556 CHECK_STATUS(status, NT_STATUS_CANCELLED);
557
558 ZERO_STRUCT(io1.smb2);
559 io1.generic.level = RAW_OPEN_SMB2;
560 io1.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
561 io1.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
562 SEC_RIGHTS_FILE_WRITE|
563 SEC_RIGHTS_FILE_ALL;
564 io1.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
565 io1.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
566 io1.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
567 NTCREATEX_SHARE_ACCESS_WRITE |
568 NTCREATEX_SHARE_ACCESS_DELETE;
569 io1.smb2.in.alloc_size = 0;
570 io1.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
571 io1.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
572 io1.smb2.in.security_flags = 0;
573 io1.smb2.in.fname = BASEDIR "\\subdir-name";
574 status = smb2_create(tree2, torture, &(io1.smb2));
575 CHECK_STATUS(status, NT_STATUS_OK);
576 smb2_util_close(tree2, io1.smb2.out.file.handle);
577
578 io1.smb2.in.fname = BASEDIR "\\subdir-name\\subname1";
579 status = smb2_create(tree2, torture, &(io1.smb2));
580 CHECK_STATUS(status, NT_STATUS_OK);
581 ZERO_STRUCT(sinfo);
582 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
583 sinfo.rename_information.in.file.handle = io1.smb2.out.file.handle;
584 sinfo.rename_information.in.overwrite = 0;
585 sinfo.rename_information.in.root_fid = 0;
586 sinfo.rename_information.in.new_name =
587 BASEDIR "\\subdir-name\\subname1-r";
588 status = smb2_setinfo_file(tree2, &sinfo);
589 CHECK_STATUS(status, NT_STATUS_OK);
590
591 io1.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
592 io1.smb2.in.fname = BASEDIR "\\subdir-name\\subname2";
593 status = smb2_create(tree2, torture, &(io1.smb2));
594 CHECK_STATUS(status, NT_STATUS_OK);
595 ZERO_STRUCT(sinfo);
596 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
597 sinfo.rename_information.in.file.handle = io1.smb2.out.file.handle;
598 sinfo.rename_information.in.overwrite = true;
599 sinfo.rename_information.in.root_fid = 0;
600 sinfo.rename_information.in.new_name = BASEDIR "\\subname2-r";
601 status = smb2_setinfo_file(tree2, &sinfo);
602 CHECK_STATUS(status, NT_STATUS_OK);
603
604 io1.smb2.in.fname = BASEDIR "\\subname2-r";
605 io1.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
606 status = smb2_create(tree2, torture, &(io1.smb2));
607 CHECK_STATUS(status, NT_STATUS_OK);
608 ZERO_STRUCT(sinfo);
609 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
610 sinfo.rename_information.in.file.handle = io1.smb2.out.file.handle;
611 sinfo.rename_information.in.overwrite = true;
612 sinfo.rename_information.in.root_fid = 0;
613 sinfo.rename_information.in.new_name = BASEDIR "\\subname3-r";
614 status = smb2_setinfo_file(tree2, &sinfo);
615 CHECK_STATUS(status, NT_STATUS_OK);
616
617 notify.smb2.in.completion_filter = 0;
618 notify.smb2.in.recursive = true;
619 smb_msleep(200);
620 req1 = smb2_notify_send(tree1, &(notify.smb2));
621
622 status = smb2_util_rmdir(tree2, BASEDIR "\\subdir-name\\subname1-r");
623 CHECK_STATUS(status, NT_STATUS_OK);
624 status = smb2_util_rmdir(tree2, BASEDIR "\\subdir-name");
625 CHECK_STATUS(status, NT_STATUS_OK);
626 status = smb2_util_unlink(tree2, BASEDIR "\\subname3-r");
627 CHECK_STATUS(status, NT_STATUS_OK);
628
629 notify.smb2.in.recursive = false;
630 req2 = smb2_notify_send(tree1, &(notify.smb2));
631
632 status = smb2_notify_recv(req1, torture, &(notify.smb2));
633 CHECK_STATUS(status, NT_STATUS_OK);
634
635 CHECK_VAL(notify.smb2.out.num_changes, 9);
636 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_ADDED);
637 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
638 CHECK_VAL(notify.smb2.out.changes[1].action, NOTIFY_ACTION_ADDED);
639 CHECK_WIRE_STR(notify.smb2.out.changes[1].name, "subdir-name\\subname1");
640 CHECK_VAL(notify.smb2.out.changes[2].action, NOTIFY_ACTION_OLD_NAME);
641 CHECK_WIRE_STR(notify.smb2.out.changes[2].name, "subdir-name\\subname1");
642 CHECK_VAL(notify.smb2.out.changes[3].action, NOTIFY_ACTION_NEW_NAME);
643 CHECK_WIRE_STR(notify.smb2.out.changes[3].name, "subdir-name\\subname1-r");
644 CHECK_VAL(notify.smb2.out.changes[4].action, NOTIFY_ACTION_ADDED);
645 CHECK_WIRE_STR(notify.smb2.out.changes[4].name, "subdir-name\\subname2");
646 CHECK_VAL(notify.smb2.out.changes[5].action, NOTIFY_ACTION_REMOVED);
647 CHECK_WIRE_STR(notify.smb2.out.changes[5].name, "subdir-name\\subname2");
648 CHECK_VAL(notify.smb2.out.changes[6].action, NOTIFY_ACTION_ADDED);
649 CHECK_WIRE_STR(notify.smb2.out.changes[6].name, "subname2-r");
650 CHECK_VAL(notify.smb2.out.changes[7].action, NOTIFY_ACTION_OLD_NAME);
651 CHECK_WIRE_STR(notify.smb2.out.changes[7].name, "subname2-r");
652 CHECK_VAL(notify.smb2.out.changes[8].action, NOTIFY_ACTION_NEW_NAME);
653 CHECK_WIRE_STR(notify.smb2.out.changes[8].name, "subname3-r");
654
655 done:
656 smb2_deltree(tree1, BASEDIR);
657 return ret;
658 }
659
660 /*
661 testing of change notify mask change
662 */
663
664 static bool torture_smb2_notify_mask_change(struct torture_context *torture,
665 struct smb2_tree *tree1,
666 struct smb2_tree *tree2)
667 {
668 bool ret = true;
669 NTSTATUS status;
670 union smb_notify notify;
671 union smb_open io, io1;
672 struct smb2_handle h1;
673 struct smb2_request *req1, *req2;
674 union smb_setfileinfo sinfo;
675
676 smb2_deltree(tree1, BASEDIR);
677 smb2_util_rmdir(tree1, BASEDIR);
678
679 torture_comment(torture, "TESTING CHANGE NOTIFY WITH MASK CHANGE\n");
680
681 /*
682 get a handle on the directory
683 */
684 ZERO_STRUCT(io.smb2);
685 io.generic.level = RAW_OPEN_SMB2;
686 io.smb2.in.create_flags = 0;
687 io.smb2.in.desired_access = SEC_FILE_ALL;
688 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
689 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
690 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
691 NTCREATEX_SHARE_ACCESS_WRITE;
692 io.smb2.in.alloc_size = 0;
693 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
694 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
695 io.smb2.in.security_flags = 0;
696 io.smb2.in.fname = BASEDIR;
697
698 status = smb2_create(tree1, torture, &(io.smb2));
699 CHECK_STATUS(status, NT_STATUS_OK);
700 h1 = io.smb2.out.file.handle;
701
702 /* ask for a change notify, on file or directory name
703 changes. Setup both with and without recursion */
704 ZERO_STRUCT(notify.smb2);
705 notify.smb2.level = RAW_NOTIFY_SMB2;
706 notify.smb2.in.buffer_size = 1000;
707 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_ATTRIBUTES;
708 notify.smb2.in.file.handle = h1;
709
710 notify.smb2.in.recursive = true;
711 req1 = smb2_notify_send(tree1, &(notify.smb2));
712
713 smb2_cancel(req1);
714 status = smb2_notify_recv(req1, torture, &(notify.smb2));
715 CHECK_STATUS(status, NT_STATUS_CANCELLED);
716
717
718 notify.smb2.in.recursive = false;
719 req2 = smb2_notify_send(tree1, &(notify.smb2));
720
721 smb2_cancel(req2);
722 status = smb2_notify_recv(req2, torture, &(notify.smb2));
723 CHECK_STATUS(status, NT_STATUS_CANCELLED);
724
725 notify.smb2.in.recursive = true;
726 req1 = smb2_notify_send(tree1, &(notify.smb2));
727
728 /* Set to hidden then back again. */
729 ZERO_STRUCT(io1.smb2);
730 io1.generic.level = RAW_OPEN_SMB2;
731 io1.smb2.in.create_flags = 0;
732 io1.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
733 SEC_RIGHTS_FILE_WRITE|
734 SEC_RIGHTS_FILE_ALL;
735 io1.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
736 io1.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
737 NTCREATEX_SHARE_ACCESS_WRITE |
738 NTCREATEX_SHARE_ACCESS_DELETE;
739 io1.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
740 io1.smb2.in.security_flags = 0;
741 io1.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
742 io1.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
743 io1.smb2.in.fname = BASEDIR "\\tname1";
744
745 smb2_util_close(tree1,
746 custom_smb2_create(tree1, torture, &(io1.smb2)));
747 status = smb2_util_setatr(tree1, BASEDIR "\\tname1",
748 FILE_ATTRIBUTE_HIDDEN);
749 CHECK_STATUS(status, NT_STATUS_OK);
750 smb2_util_unlink(tree1, BASEDIR "\\tname1");
751
752 status = smb2_notify_recv(req1, torture, &(notify.smb2));
753 CHECK_STATUS(status, NT_STATUS_OK);
754
755 CHECK_VAL(notify.smb2.out.num_changes, 1);
756 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_MODIFIED);
757 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "tname1");
758
759 /* Now try and change the mask to include other events.
760 * This should not work - once the mask is set on a directory
761 * h1 it seems to be fixed until the fnum is closed. */
762
763 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME |
764 FILE_NOTIFY_CHANGE_ATTRIBUTES |
765 FILE_NOTIFY_CHANGE_CREATION;
766 notify.smb2.in.recursive = true;
767 req1 = smb2_notify_send(tree1, &(notify.smb2));
768
769 notify.smb2.in.recursive = false;
770 req2 = smb2_notify_send(tree1, &(notify.smb2));
771
772 io1.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
773 io1.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
774 io1.smb2.in.fname = BASEDIR "\\subdir-name";
775 status = smb2_create(tree2, torture, &(io1.smb2));
776 CHECK_STATUS(status, NT_STATUS_OK);
777 smb2_util_close(tree2, io1.smb2.out.file.handle);
778
779 ZERO_STRUCT(sinfo);
780 io1.smb2.in.fname = BASEDIR "\\subdir-name\\subname1";
781 io1.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
782 io1.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
783 status = smb2_create(tree2, torture, &(io1.smb2));
784 CHECK_STATUS(status, NT_STATUS_OK);
785 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
786 sinfo.rename_information.in.file.handle = io1.smb2.out.file.handle;
787 sinfo.rename_information.in.overwrite = true;
788 sinfo.rename_information.in.root_fid = 0;
789 sinfo.rename_information.in.new_name =
790 BASEDIR "\\subdir-name\\subname1-r";
791 status = smb2_setinfo_file(tree2, &sinfo);
792 CHECK_STATUS(status, NT_STATUS_OK);
793
794 io1.smb2.in.fname = BASEDIR "\\subdir-name\\subname2";
795 io1.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
796 io1.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
797 status = smb2_create(tree2, torture, &(io1.smb2));
798 CHECK_STATUS(status, NT_STATUS_OK);
799 sinfo.rename_information.in.file.handle = io1.smb2.out.file.handle;
800 sinfo.rename_information.in.new_name = BASEDIR "\\subname2-r";
801 status = smb2_setinfo_file(tree2, &sinfo);
802 CHECK_STATUS(status, NT_STATUS_OK);
803 smb2_util_close(tree2, io1.smb2.out.file.handle);
804
805 io1.smb2.in.fname = BASEDIR "\\subname2-r";
806 io1.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
807 status = smb2_create(tree2, torture, &(io1.smb2));
808 CHECK_STATUS(status, NT_STATUS_OK);
809 sinfo.rename_information.in.file.handle = io1.smb2.out.file.handle;
810 sinfo.rename_information.in.new_name = BASEDIR "\\subname3-r";
811 status = smb2_setinfo_file(tree2, &sinfo);
812 CHECK_STATUS(status, NT_STATUS_OK);
813 smb2_util_close(tree2, io1.smb2.out.file.handle);
814
815 status = smb2_util_rmdir(tree2, BASEDIR "\\subdir-name\\subname1-r");
816 CHECK_STATUS(status, NT_STATUS_OK);
817 status = smb2_util_rmdir(tree2, BASEDIR "\\subdir-name");
818 CHECK_STATUS(status, NT_STATUS_OK);
819 status = smb2_util_unlink(tree2, BASEDIR "\\subname3-r");
820 CHECK_STATUS(status, NT_STATUS_OK);
821
822 status = smb2_notify_recv(req1, torture, &(notify.smb2));
823 CHECK_STATUS(status, NT_STATUS_OK);
824
825 CHECK_VAL(notify.smb2.out.num_changes, 1);
826 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_MODIFIED);
827 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subname2-r");
828
829 status = smb2_notify_recv(req2, torture, &(notify.smb2));
830 CHECK_STATUS(status, NT_STATUS_OK);
831
832 CHECK_VAL(notify.smb2.out.num_changes, 1);
833 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_MODIFIED);
834 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subname3-r");
835
836 if (!ret) {
837 goto done;
838 }
839
840 done:
841 smb2_deltree(tree1, BASEDIR);
842 return ret;
843 }
844
845 /*
846 testing of mask bits for change notify
847 */
848
849 static bool torture_smb2_notify_mask(struct torture_context *torture,
850 struct smb2_tree *tree1,
851 struct smb2_tree *tree2)
852 {
853 bool ret = true;
854 NTSTATUS status;
855 union smb_notify notify;
856 union smb_open io, io1;
857 struct smb2_handle h1, h2;
858 uint32_t mask;
859 int i;
860 char c = 1;
861 union smb_setfileinfo sinfo;
862
863 smb2_deltree(tree1, BASEDIR);
864 smb2_util_rmdir(tree1, BASEDIR);
865
866 torture_comment(torture, "TESTING CHANGE NOTIFY COMPLETION FILTERS\n");
867
868
869 /*
870 get a handle on the directory
871 */
872 ZERO_STRUCT(io.smb2);
873 io.generic.level = RAW_OPEN_SMB2;
874 io.smb2.in.create_flags = 0;
875 io.smb2.in.desired_access = SEC_FILE_ALL;
876 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
877 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
878 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
879 NTCREATEX_SHARE_ACCESS_WRITE;
880 io.smb2.in.alloc_size = 0;
881 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
882 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
883 io.smb2.in.security_flags = 0;
884 io.smb2.in.fname = BASEDIR;
885
886 ZERO_STRUCT(notify.smb2);
887 notify.smb2.level = RAW_NOTIFY_SMB2;
888 notify.smb2.in.buffer_size = 1000;
889 notify.smb2.in.recursive = true;
890
891 #define NOTIFY_MASK_TEST(test_name, setup, op, cleanup, Action, \
892 expected, nchanges) \
893 do { \
894 do { for (mask=i=0;i<32;i++) { \
895 struct smb2_request *req; \
896 status = smb2_create(tree1, torture, &(io.smb2)); \
897 CHECK_STATUS(status, NT_STATUS_OK); \
898 h1 = io.smb2.out.file.handle; \
899 setup \
900 notify.smb2.in.file.handle = h1; \
901 notify.smb2.in.completion_filter = (1<<i); \
902 /* cancel initial requests so the buffer is setup */ \
903 req = smb2_notify_send(tree1, &(notify.smb2)); \
904 smb2_cancel(req); \
905 status = smb2_notify_recv(req, torture, &(notify.smb2)); \
906 CHECK_STATUS(status, NT_STATUS_CANCELLED); \
907 /* send the change notify request */ \
908 req = smb2_notify_send(tree1, &(notify.smb2)); \
909 op \
910 smb_msleep(200); smb2_cancel(req); \
911 status = smb2_notify_recv(req, torture, &(notify.smb2)); \
912 cleanup \
913 smb2_util_close(tree1, h1); \
914 if (NT_STATUS_EQUAL(status, NT_STATUS_CANCELLED)) continue; \
915 CHECK_STATUS(status, NT_STATUS_OK); \
916 /* special case to cope with file rename behaviour */ \
917 if (nchanges == 2 && notify.smb2.out.num_changes == 1 && \
918 notify.smb2.out.changes[0].action == \
919 NOTIFY_ACTION_MODIFIED && \
920 ((expected) & FILE_NOTIFY_CHANGE_ATTRIBUTES) && \
921 Action == NOTIFY_ACTION_OLD_NAME) { \
922 torture_comment(torture, \
923 "(rename file special handling OK)\n"); \
924 } else if (nchanges != notify.smb2.out.num_changes) { \
925 torture_result(torture, TORTURE_FAIL, \
926 "ERROR: nchanges=%d expected=%d "\
927 "action=%d filter=0x%08x\n", \
928 notify.smb2.out.num_changes, \
929 nchanges, \
930 notify.smb2.out.changes[0].action, \
931 notify.smb2.in.completion_filter); \
932 ret = false; \
933 } else if (notify.smb2.out.changes[0].action != Action) { \
934 torture_result(torture, TORTURE_FAIL, \
935 "ERROR: nchanges=%d action=%d " \
936 "expectedAction=%d filter=0x%08x\n", \
937 notify.smb2.out.num_changes, \
938 notify.smb2.out.changes[0].action, \
939 Action, \
940 notify.smb2.in.completion_filter); \
941 ret = false; \
942 } else if (strcmp(notify.smb2.out.changes[0].name.s, \
943 "tname1") != 0) { \
944 torture_result(torture, TORTURE_FAIL, \
945 "ERROR: nchanges=%d action=%d " \
946 "filter=0x%08x name=%s\n", \
947 notify.smb2.out.num_changes, \
948 notify.smb2.out.changes[0].action, \
949 notify.smb2.in.completion_filter, \
950 notify.smb2.out.changes[0].name.s); \
951 ret = false; \
952 } \
953 mask |= (1<<i); \
954 } \
955 } while (0); \
956 } while (0);
957
958 torture_comment(torture, "Testing mkdir\n");
959 NOTIFY_MASK_TEST("Testing mkdir",;,
960 smb2_util_mkdir(tree2, BASEDIR "\\tname1");,
961 smb2_util_rmdir(tree2, BASEDIR "\\tname1");,
962 NOTIFY_ACTION_ADDED,
963 FILE_NOTIFY_CHANGE_DIR_NAME, 1);
964
965 torture_comment(torture, "Testing create file\n");
966 ZERO_STRUCT(io1.smb2);
967 io1.generic.level = RAW_OPEN_SMB2;
968 io1.smb2.in.create_flags = 0;
969 io1.smb2.in.desired_access = SEC_FILE_ALL;
970 io1.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
971 io1.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
972 NTCREATEX_SHARE_ACCESS_WRITE;
973 io1.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
974 io1.smb2.in.security_flags = 0;
975 io1.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
976 io1.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
977 io1.smb2.in.fname = BASEDIR "\\tname1";
978
979 NOTIFY_MASK_TEST("Testing create file",;,
980 smb2_util_close(tree2, custom_smb2_create(tree2,
981 torture, &(io1.smb2)));,
982 smb2_util_unlink(tree2, BASEDIR "\\tname1");,
983 NOTIFY_ACTION_ADDED,
984 FILE_NOTIFY_CHANGE_FILE_NAME, 1);
985
986 torture_comment(torture, "Testing unlink\n");
987 NOTIFY_MASK_TEST("Testing unlink",
988 smb2_util_close(tree2, custom_smb2_create(tree2,
989 torture, &(io1.smb2)));,
990 smb2_util_unlink(tree2, BASEDIR "\\tname1");,
991 ;,
992 NOTIFY_ACTION_REMOVED,
993 FILE_NOTIFY_CHANGE_FILE_NAME, 1);
994
995 torture_comment(torture, "Testing rmdir\n");
996 NOTIFY_MASK_TEST("Testing rmdir",
997 smb2_util_mkdir(tree2, BASEDIR "\\tname1");,
998 smb2_util_rmdir(tree2, BASEDIR "\\tname1");,
999 ;,
1000 NOTIFY_ACTION_REMOVED,
1001 FILE_NOTIFY_CHANGE_DIR_NAME, 1);
1002
1003 torture_comment(torture, "Testing rename file\n");
1004 ZERO_STRUCT(sinfo);
1005 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
1006 sinfo.rename_information.in.file.handle = h1;
1007 sinfo.rename_information.in.overwrite = true;
1008 sinfo.rename_information.in.root_fid = 0;
1009 sinfo.rename_information.in.new_name = BASEDIR "\\tname2";
1010 NOTIFY_MASK_TEST("Testing rename file",
1011 smb2_util_close(tree2, custom_smb2_create(tree2,
1012 torture, &(io1.smb2)));,
1013 smb2_setinfo_file(tree2, &sinfo);,
1014 smb2_util_unlink(tree2, BASEDIR "\\tname2");,
1015 NOTIFY_ACTION_OLD_NAME,
1016 FILE_NOTIFY_CHANGE_FILE_NAME, 2);
1017
1018 torture_comment(torture, "Testing rename dir\n");
1019 ZERO_STRUCT(sinfo);
1020 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
1021 sinfo.rename_information.in.file.handle = h1;
1022 sinfo.rename_information.in.overwrite = true;
1023 sinfo.rename_information.in.root_fid = 0;
1024 sinfo.rename_information.in.new_name = BASEDIR "\\tname2";
1025 NOTIFY_MASK_TEST("Testing rename dir",
1026 smb2_util_mkdir(tree2, BASEDIR "\\tname1");,
1027 smb2_setinfo_file(tree2, &sinfo);,
1028 smb2_util_rmdir(tree2, BASEDIR "\\tname2");,
1029 NOTIFY_ACTION_OLD_NAME,
1030 FILE_NOTIFY_CHANGE_DIR_NAME, 2);
1031
1032 torture_comment(torture, "Testing set path attribute\n");
1033 NOTIFY_MASK_TEST("Testing set path attribute",
1034 smb2_util_close(tree2, custom_smb2_create(tree2,
1035 torture, &(io.smb2)));,
1036 smb2_util_setatr(tree2, BASEDIR "\\tname1",
1037 FILE_ATTRIBUTE_HIDDEN);,
1038 smb2_util_unlink(tree2, BASEDIR "\\tname1");,
1039 NOTIFY_ACTION_MODIFIED,
1040 FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
1041
1042 torture_comment(torture, "Testing set path write time\n");
1043 ZERO_STRUCT(sinfo);
1044 sinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
1045 sinfo.generic.in.file.handle = h1;
1046 sinfo.basic_info.in.write_time = 1000;
1047 NOTIFY_MASK_TEST("Testing set path write time",
1048 smb2_util_close(tree2, custom_smb2_create(tree2,
1049 torture, &(io1.smb2)));,
1050 smb2_setinfo_file(tree2, &sinfo);,
1051 smb2_util_unlink(tree2, BASEDIR "\\tname1");,
1052 NOTIFY_ACTION_MODIFIED,
1053 FILE_NOTIFY_CHANGE_LAST_WRITE, 1);
1054
1055 if (torture_setting_bool(torture, "samba3", false)) {
1056 torture_comment(torture,
1057 "Samba3 does not yet support create times "
1058 "everywhere\n");
1059 }
1060 else {
1061 ZERO_STRUCT(sinfo);
1062 sinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
1063 sinfo.generic.in.file.handle = h1;
1064 sinfo.basic_info.in.create_time = 0;
1065 torture_comment(torture, "Testing set file create time\n");
1066 NOTIFY_MASK_TEST("Testing set file create time",
1067 smb2_create_complex_file(tree2,
1068 BASEDIR "\\tname1", &h2);,
1069 smb2_setinfo_file(tree2, &sinfo);,
1070 (smb2_util_close(tree2, h2),
1071 smb2_util_unlink(tree2, BASEDIR "\\tname1"));,
1072 NOTIFY_ACTION_MODIFIED,
1073 FILE_NOTIFY_CHANGE_CREATION, 1);
1074 }
1075
1076 ZERO_STRUCT(sinfo);
1077 sinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
1078 sinfo.generic.in.file.handle = h1;
1079 sinfo.basic_info.in.access_time = 0;
1080 torture_comment(torture, "Testing set file access time\n");
1081 NOTIFY_MASK_TEST("Testing set file access time",
1082 smb2_create_complex_file(tree2, BASEDIR "\\tname1", &h2);,
1083 smb2_setinfo_file(tree2, &sinfo);,
1084 (smb2_util_close(tree2, h2),
1085 smb2_util_unlink(tree2, BASEDIR "\\tname1"));,
1086 NOTIFY_ACTION_MODIFIED,
1087 FILE_NOTIFY_CHANGE_LAST_ACCESS, 1);
1088
1089 ZERO_STRUCT(sinfo);
1090 sinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
1091 sinfo.generic.in.file.handle = h1;
1092 sinfo.basic_info.in.change_time = 0;
1093 torture_comment(torture, "Testing set file change time\n");
1094 NOTIFY_MASK_TEST("Testing set file change time",
1095 smb2_create_complex_file(tree2, BASEDIR "\\tname1", &h2);,
1096 smb2_setinfo_file(tree2, &sinfo);,
1097 (smb2_util_close(tree2, h2),
1098 smb2_util_unlink(tree2, BASEDIR "\\tname1"));,
1099 NOTIFY_ACTION_MODIFIED,
1100 0, 1);
1101
1102
1103 torture_comment(torture, "Testing write\n");
1104 NOTIFY_MASK_TEST("Testing write",
1105 smb2_create_complex_file(tree2, BASEDIR "\\tname1", &h2);,
1106 smb2_util_write(tree2, h2, &c, 10000, 1);,
1107 (smb2_util_close(tree2, h2),
1108 smb2_util_unlink(tree2, BASEDIR "\\tname1"));,
1109 NOTIFY_ACTION_MODIFIED,
1110 0, 1);
1111
1112 done:
1113 smb2_deltree(tree1, BASEDIR);
1114 return ret;
1115 }
1116
1117 /*
1118 basic testing of change notify on files
1119 */
1120 static bool torture_smb2_notify_file(struct torture_context *torture,
1121 struct smb2_tree *tree)
1122 {
1123 NTSTATUS status;
1124 bool ret = true;
1125 union smb_open io;
1126 union smb_close cl;
1127 union smb_notify notify;
1128 struct smb2_request *req;
1129 struct smb2_handle h1;
1130 const char *fname = BASEDIR "\\file.txt";
1131
1132 smb2_deltree(tree, BASEDIR);
1133 smb2_util_rmdir(tree, BASEDIR);
1134
1135 torture_comment(torture, "TESTING CHANGE NOTIFY ON FILES\n");
1136 status = torture_smb2_testdir(tree, BASEDIR, &h1);
1137 CHECK_STATUS(status, NT_STATUS_OK);
1138
1139 ZERO_STRUCT(io.smb2);
1140 io.generic.level = RAW_OPEN_SMB2;
1141 io.smb2.in.create_flags = 0;
1142 io.smb2.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
1143 io.smb2.in.create_options = 0;
1144 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1145 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1146 NTCREATEX_SHARE_ACCESS_WRITE;
1147 io.smb2.in.alloc_size = 0;
1148 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1149 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1150 io.smb2.in.security_flags = 0;
1151 io.smb2.in.fname = fname;
1152 status = smb2_create(tree, torture, &(io.smb2));
1153 CHECK_STATUS(status, NT_STATUS_OK);
1154 h1 = io.smb2.out.file.handle;
1155
1156 /* ask for a change notify,
1157 on file or directory name changes */
1158 ZERO_STRUCT(notify.smb2);
1159 notify.smb2.level = RAW_NOTIFY_SMB2;
1160 notify.smb2.in.file.handle = h1;
1161 notify.smb2.in.buffer_size = 1000;
1162 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_STREAM_NAME;
1163 notify.smb2.in.recursive = false;
1164
1165 torture_comment(torture,
1166 "Testing if notifies on file handles are invalid (should be)\n");
1167
1168 req = smb2_notify_send(tree, &(notify.smb2));
1169 status = smb2_notify_recv(req, torture, &(notify.smb2));
1170 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
1171
1172 ZERO_STRUCT(cl.smb2);
1173 cl.close.level = RAW_CLOSE_SMB2;
1174 cl.close.in.file.handle = h1;
1175 status = smb2_close(tree, &(cl.smb2));
1176 CHECK_STATUS(status, NT_STATUS_OK);
1177
1178 status = smb2_util_unlink(tree, fname);
1179 CHECK_STATUS(status, NT_STATUS_OK);
1180
1181 done:
1182 smb2_deltree(tree, BASEDIR);
1183 return ret;
1184 }
1185 /*
1186 basic testing of change notifies followed by a tdis
1187 */
1188
1189 static bool torture_smb2_notify_tree_disconnect(
1190 struct torture_context *torture,
1191 struct smb2_tree *tree)
1192 {
1193 bool ret = true;
1194 NTSTATUS status;
1195 union smb_notify notify;
1196 union smb_open io;
1197 struct smb2_handle h1;
1198 struct smb2_request *req;
1199
1200 smb2_deltree(tree, BASEDIR);
1201 smb2_util_rmdir(tree, BASEDIR);
1202
1203 torture_comment(torture, "TESTING CHANGE NOTIFY+CANCEL FOLLOWED BY "
1204 "TREE-DISCONNECT\n");
1205
1206 /*
1207 get a handle on the directory
1208 */
1209 ZERO_STRUCT(io.smb2);
1210 io.generic.level = RAW_OPEN_SMB2;
1211 io.smb2.in.create_flags = 0;
1212 io.smb2.in.desired_access = SEC_FILE_ALL;
1213 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1214 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1215 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1216 NTCREATEX_SHARE_ACCESS_WRITE;
1217 io.smb2.in.alloc_size = 0;
1218 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1219 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1220 io.smb2.in.security_flags = 0;
1221 io.smb2.in.fname = BASEDIR;
1222
1223 status = smb2_create(tree, torture, &(io.smb2));
1224 CHECK_STATUS(status, NT_STATUS_OK);
1225 h1 = io.smb2.out.file.handle;
1226
1227 /* ask for a change notify,
1228 on file or directory name changes */
1229 ZERO_STRUCT(notify.smb2);
1230 notify.smb2.level = RAW_NOTIFY_SMB2;
1231 notify.smb2.in.buffer_size = 1000;
1232 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1233 notify.smb2.in.file.handle = h1;
1234 notify.smb2.in.recursive = true;
1235
1236 req = smb2_notify_send(tree, &(notify.smb2));
1237 smb2_cancel(req);
1238 status = smb2_notify_recv(req, torture, &(notify.smb2));
1239
1240 status = smb2_tdis(tree);
1241 CHECK_STATUS(status, NT_STATUS_OK);
1242
1243 req = smb2_notify_send(tree, &(notify.smb2));
1244
1245 smb2_notify_recv(req, torture, &(notify.smb2));
1246 CHECK_STATUS(status, NT_STATUS_OK);
1247 CHECK_VAL(notify.smb2.out.num_changes, 0);
1248
1249 done:
1250 smb2_deltree(tree, BASEDIR);
1251 return ret;
1252 }
1253
1254 /*
1255 testing of change notifies followed by a tdis - no cancel
1256 */
1257
1258 static bool torture_smb2_notify_tree_disconnect_1(
1259 struct torture_context *torture,
1260 struct smb2_tree *tree)
1261 {
1262 bool ret = true;
1263 NTSTATUS status;
1264 union smb_notify notify;
1265 union smb_open io;
1266 struct smb2_handle h1;
1267 struct smb2_request *req;
1268
1269 smb2_deltree(tree, BASEDIR);
1270 smb2_util_rmdir(tree, BASEDIR);
1271
1272 torture_comment(torture, "TESTING CHANGE NOTIFY ASYNC FOLLOWED BY "
1273 "TREE-DISCONNECT\n");
1274
1275 /*
1276 get a handle on the directory
1277 */
1278 ZERO_STRUCT(io.smb2);
1279 io.generic.level = RAW_OPEN_SMB2;
1280 io.smb2.in.create_flags = 0;
1281 io.smb2.in.desired_access = SEC_FILE_ALL;
1282 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1283 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1284 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1285 NTCREATEX_SHARE_ACCESS_WRITE;
1286 io.smb2.in.alloc_size = 0;
1287 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1288 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1289 io.smb2.in.security_flags = 0;
1290 io.smb2.in.fname = BASEDIR;
1291
1292 status = smb2_create(tree, torture, &(io.smb2));
1293 CHECK_STATUS(status, NT_STATUS_OK);
1294 h1 = io.smb2.out.file.handle;
1295
1296 /* ask for a change notify,
1297 on file or directory name changes */
1298 ZERO_STRUCT(notify.smb2);
1299 notify.smb2.level = RAW_NOTIFY_SMB2;
1300 notify.smb2.in.buffer_size = 1000;
1301 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1302 notify.smb2.in.file.handle = h1;
1303 notify.smb2.in.recursive = true;
1304
1305 req = smb2_notify_send(tree, &(notify.smb2));
1306 WAIT_FOR_ASYNC_RESPONSE(req);
1307
1308 status = smb2_tdis(tree);
1309 CHECK_STATUS(status, NT_STATUS_OK);
1310
1311 status = smb2_notify_recv(req, torture, &(notify.smb2));
1312 CHECK_VAL(notify.smb2.out.num_changes, 0);
1313
1314 done:
1315 smb2_deltree(tree, BASEDIR);
1316 return ret;
1317 }
1318
1319 /*
1320 basic testing of change notifies followed by a ulogoff
1321 */
1322
1323 static bool torture_smb2_notify_ulogoff(struct torture_context *torture,
1324 struct smb2_tree *tree1)
1325 {
1326 bool ret = true;
1327 NTSTATUS status;
1328 union smb_notify notify;
1329 union smb_open io;
1330 struct smb2_handle h1;
1331 struct smb2_request *req;
1332
1333 smb2_deltree(tree1, BASEDIR);
1334 smb2_util_rmdir(tree1, BASEDIR);
1335
1336 torture_comment(torture, "TESTING CHANGE NOTIFY FOLLOWED BY ULOGOFF\n");
1337
1338 /*
1339 get a handle on the directory
1340 */
1341 ZERO_STRUCT(io.smb2);
1342 io.generic.level = RAW_OPEN_SMB2;
1343 io.smb2.in.create_flags = 0;
1344 io.smb2.in.desired_access = SEC_FILE_ALL;
1345 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1346 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1347 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1348 NTCREATEX_SHARE_ACCESS_WRITE;
1349 io.smb2.in.alloc_size = 0;
1350 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1351 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1352 io.smb2.in.security_flags = 0;
1353 io.smb2.in.fname = BASEDIR;
1354
1355 status = smb2_create(tree1, torture, &(io.smb2));
1356 CHECK_STATUS(status, NT_STATUS_OK);
1357
1358 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1359 status = smb2_create(tree1, torture, &(io.smb2));
1360 CHECK_STATUS(status, NT_STATUS_OK);
1361 h1 = io.smb2.out.file.handle;
1362
1363 /* ask for a change notify,
1364 on file or directory name changes */
1365 ZERO_STRUCT(notify.smb2);
1366 notify.smb2.level = RAW_NOTIFY_SMB2;
1367 notify.smb2.in.buffer_size = 1000;
1368 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1369 notify.smb2.in.file.handle = h1;
1370 notify.smb2.in.recursive = true;
1371
1372 req = smb2_notify_send(tree1, &(notify.smb2));
1373
1374 WAIT_FOR_ASYNC_RESPONSE(req);
1375
1376 status = smb2_logoff(tree1->session);
1377 CHECK_STATUS(status, NT_STATUS_OK);
1378
1379 status = smb2_notify_recv(req, torture, &(notify.smb2));
1380 CHECK_VAL(notify.smb2.out.num_changes, 0);
1381
1382 done:
1383 smb2_deltree(tree1, BASEDIR);
1384 return ret;
1385 }
1386
1387 static void tcp_dis_handler(struct smb2_transport *t, void *p)
1388 {
1389 struct smb2_tree *tree = (struct smb2_tree *)p;
1390 smb2_transport_dead(tree->session->transport,
1391 NT_STATUS_LOCAL_DISCONNECT);
1392 t = NULL;
1393 tree = NULL;
1394 }
1395
1396 /*
1397 basic testing of change notifies followed by tcp disconnect
1398 */
1399
1400 static bool torture_smb2_notify_tcp_disconnect(
1401 struct torture_context *torture,
1402 struct smb2_tree *tree)
1403 {
1404 bool ret = true;
1405 NTSTATUS status;
1406 union smb_notify notify;
1407 union smb_open io;
1408 struct smb2_handle h1;
1409 struct smb2_request *req;
1410
1411 smb2_deltree(tree, BASEDIR);
1412 smb2_util_rmdir(tree, BASEDIR);
1413
1414 torture_comment(torture,
1415 "TESTING CHANGE NOTIFY FOLLOWED BY TCP DISCONNECT\n");
1416
1417 /*
1418 get a handle on the directory
1419 */
1420 ZERO_STRUCT(io.smb2);
1421 io.generic.level = RAW_OPEN_SMB2;
1422 io.smb2.in.create_flags = 0;
1423 io.smb2.in.desired_access = SEC_FILE_ALL;
1424 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1425 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1426 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1427 NTCREATEX_SHARE_ACCESS_WRITE;
1428 io.smb2.in.alloc_size = 0;
1429 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1430 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1431 io.smb2.in.security_flags = 0;
1432 io.smb2.in.fname = BASEDIR;
1433
1434 status = smb2_create(tree, torture, &(io.smb2));
1435 CHECK_STATUS(status, NT_STATUS_OK);
1436 h1 = io.smb2.out.file.handle;
1437
1438 /* ask for a change notify,
1439 on file or directory name changes */
1440 ZERO_STRUCT(notify.smb2);
1441 notify.smb2.level = RAW_NOTIFY_SMB2;
1442 notify.smb2.in.buffer_size = 1000;
1443 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1444 notify.smb2.in.file.handle = h1;
1445 notify.smb2.in.recursive = true;
1446
1447 req = smb2_notify_send(tree, &(notify.smb2));
1448 smb2_cancel(req);
1449 status = smb2_notify_recv(req, torture, &(notify.smb2));
1450 CHECK_STATUS(status, NT_STATUS_CANCELLED);
1451
1452 notify.smb2.in.recursive = true;
1453 req = smb2_notify_send(tree, &(notify.smb2));
1454 smb2_transport_idle_handler(tree->session->transport,
1455 tcp_dis_handler, 250, tree);
1456 tree = NULL;
1457 status = smb2_notify_recv(req, torture, &(notify.smb2));
1458 CHECK_STATUS(status, NT_STATUS_LOCAL_DISCONNECT);
1459
1460 done:
1461 return ret;
1462 }
1463
1464 /*
1465 test setting up two change notify requests on one handle
1466 */
1467
1468 static bool torture_smb2_notify_double(struct torture_context *torture,
1469 struct smb2_tree *tree1,
1470 struct smb2_tree *tree2)
1471 {
1472 bool ret = true;
1473 NTSTATUS status;
1474 union smb_notify notify;
1475 union smb_open io;
1476 struct smb2_handle h1;
1477 struct smb2_request *req1, *req2;
1478
1479 smb2_deltree(tree1, BASEDIR);
1480 smb2_util_rmdir(tree1, BASEDIR);
1481
1482 torture_comment(torture,
1483 "TESTING CHANGE NOTIFY TWICE ON ONE DIRECTORY\n");
1484
1485 /*
1486 get a handle on the directory
1487 */
1488 ZERO_STRUCT(io.smb2);
1489 io.generic.level = RAW_OPEN_SMB2;
1490 io.smb2.in.create_flags = 0;
1491 io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ|
1492 SEC_RIGHTS_FILE_WRITE|
1493 SEC_RIGHTS_FILE_ALL;
1494 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1495 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1496 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1497 NTCREATEX_SHARE_ACCESS_WRITE;
1498 io.smb2.in.alloc_size = 0;
1499 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1500 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1501 io.smb2.in.security_flags = 0;
1502 io.smb2.in.fname = BASEDIR;
1503
1504 status = smb2_create(tree1, torture, &(io.smb2));
1505 CHECK_STATUS(status, NT_STATUS_OK);
1506 h1 = io.smb2.out.file.handle;
1507
1508 /* ask for a change notify,
1509 on file or directory name changes */
1510 ZERO_STRUCT(notify.smb2);
1511 notify.smb2.level = RAW_NOTIFY_SMB2;
1512 notify.smb2.in.buffer_size = 1000;
1513 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1514 notify.smb2.in.file.handle = h1;
1515 notify.smb2.in.recursive = true;
1516
1517 req1 = smb2_notify_send(tree1, &(notify.smb2));
1518 smb2_cancel(req1);
1519 status = smb2_notify_recv(req1, torture, &(notify.smb2));
1520 CHECK_STATUS(status, NT_STATUS_CANCELLED);
1521
1522 req2 = smb2_notify_send(tree1, &(notify.smb2));
1523 smb2_cancel(req2);
1524 status = smb2_notify_recv(req2, torture, &(notify.smb2));
1525 CHECK_STATUS(status, NT_STATUS_CANCELLED);
1526
1527 smb2_util_mkdir(tree2, BASEDIR "\\subdir-name");
1528 req1 = smb2_notify_send(tree1, &(notify.smb2));
1529 req2 = smb2_notify_send(tree1, &(notify.smb2));
1530
1531 status = smb2_notify_recv(req1, torture, &(notify.smb2));
1532 CHECK_STATUS(status, NT_STATUS_OK);
1533 CHECK_VAL(notify.smb2.out.num_changes, 1);
1534 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
1535
1536 smb2_util_mkdir(tree2, BASEDIR "\\subdir-name2");
1537
1538 status = smb2_notify_recv(req2, torture, &(notify.smb2));
1539 CHECK_STATUS(status, NT_STATUS_OK);
1540 CHECK_VAL(notify.smb2.out.num_changes, 1);
1541 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name2");
1542
1543 done:
1544 smb2_deltree(tree1, BASEDIR);
1545 return ret;
1546 }
1547
1548
1549 /*
1550 test multiple change notifies at different depths and with/without recursion
1551 */
1552
1553 static bool torture_smb2_notify_tree(struct torture_context *torture,
1554 struct smb2_tree *tree)
1555 {
1556 bool ret = true;
1557 union smb_notify notify;
1558 union smb_open io;
1559 struct smb2_request *req;
1560 struct timeval tv;
1561 struct {
1562 const char *path;
1563 bool recursive;
1564 uint32_t filter;
1565 int expected;
1566 struct smb2_handle h1;
1567 int counted;
1568 } dirs[] = {
1569 {BASEDIR "\\abc", true, FILE_NOTIFY_CHANGE_NAME, 30 },
1570 {BASEDIR "\\zqy", true, FILE_NOTIFY_CHANGE_NAME, 8 },
1571 {BASEDIR "\\atsy", true, FILE_NOTIFY_CHANGE_NAME, 4 },
1572 {BASEDIR "\\abc\\foo", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1573 {BASEDIR "\\abc\\blah", true, FILE_NOTIFY_CHANGE_NAME, 13 },
1574 {BASEDIR "\\abc\\blah", false, FILE_NOTIFY_CHANGE_NAME, 7 },
1575 {BASEDIR "\\abc\\blah\\a", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1576 {BASEDIR "\\abc\\blah\\b", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1577 {BASEDIR "\\abc\\blah\\c", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1578 {BASEDIR "\\abc\\fooblah", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1579 {BASEDIR "\\zqy\\xx", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1580 {BASEDIR "\\zqy\\yyy", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1581 {BASEDIR "\\zqy\\..", true, FILE_NOTIFY_CHANGE_NAME, 40 },
1582 {BASEDIR, true, FILE_NOTIFY_CHANGE_NAME, 40 },
1583 {BASEDIR, false,FILE_NOTIFY_CHANGE_NAME, 6 },
1584 {BASEDIR "\\atsy", false,FILE_NOTIFY_CHANGE_NAME, 4 },
1585 {BASEDIR "\\abc", true, FILE_NOTIFY_CHANGE_NAME, 24 },
1586 {BASEDIR "\\abc", false,FILE_NOTIFY_CHANGE_FILE_NAME, 0 },
1587 {BASEDIR "\\abc", true, FILE_NOTIFY_CHANGE_FILE_NAME, 0 },
1588 {BASEDIR "\\abc", true, FILE_NOTIFY_CHANGE_NAME, 24 },
1589 };
1590 int i;
1591 NTSTATUS status;
1592 bool all_done = false;
1593
1594 smb2_deltree(tree, BASEDIR);
1595 smb2_util_rmdir(tree, BASEDIR);
1596
1597 torture_comment(torture, "TESTING NOTIFY FOR DIFFERENT DEPTHS\n");
1598
1599 ZERO_STRUCT(io.smb2);
1600 io.generic.level = RAW_OPEN_SMB2;
1601 io.smb2.in.create_flags = 0;
1602 io.smb2.in.desired_access = SEC_FILE_ALL;
1603 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1604 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1605 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1606 NTCREATEX_SHARE_ACCESS_WRITE;
1607 io.smb2.in.alloc_size = 0;
1608 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1609 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1610 io.smb2.in.security_flags = 0;
1611 io.smb2.in.fname = BASEDIR;
1612 status = smb2_create(tree, torture, &(io.smb2));
1613 CHECK_STATUS(status, NT_STATUS_OK);
1614
1615 ZERO_STRUCT(notify.smb2);
1616 notify.smb2.level = RAW_NOTIFY_SMB2;
1617 notify.smb2.in.buffer_size = 20000;
1618
1619 /*
1620 setup the directory tree, and the notify buffer on each directory
1621 */
1622 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1623 io.smb2.in.fname = dirs[i].path;
1624 status = smb2_create(tree, torture, &(io.smb2));
1625 CHECK_STATUS(status, NT_STATUS_OK);
1626 dirs[i].h1 = io.smb2.out.file.handle;
1627
1628 notify.smb2.in.completion_filter = dirs[i].filter;
1629 notify.smb2.in.file.handle = dirs[i].h1;
1630 notify.smb2.in.recursive = dirs[i].recursive;
1631 req = smb2_notify_send(tree, &(notify.smb2));
1632 smb2_cancel(req);
1633 status = smb2_notify_recv(req, torture, &(notify.smb2));
1634 CHECK_STATUS(status, NT_STATUS_CANCELLED);
1635 }
1636
1637 /* trigger 2 events in each dir */
1638 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1639 char *path = talloc_asprintf(torture, "%s\\test.dir",
1640 dirs[i].path);
1641 smb2_util_mkdir(tree, path);
1642 smb2_util_rmdir(tree, path);
1643 talloc_free(path);
1644 }
1645
1646 /* give a bit of time for the events to propogate */
1647 tv = timeval_current();
1648
1649 do {
1650 /* count events that have happened in each dir */
1651 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1652 notify.smb2.in.file.handle = dirs[i].h1;
1653 req = smb2_notify_send(tree, &(notify.smb2));
1654 smb2_cancel(req);
1655 notify.smb2.out.num_changes = 0;
1656 status = smb2_notify_recv(req, torture,
1657 &(notify.smb2));
1658 dirs[i].counted += notify.smb2.out.num_changes;
1659 }
1660
1661 all_done = true;
1662
1663 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1664 if (dirs[i].counted != dirs[i].expected) {
1665 all_done = false;
1666 }
1667 }
1668 } while (!all_done && timeval_elapsed(&tv) < 20);
1669
1670 torture_comment(torture, "took %.4f seconds to propogate all events\n",
1671 timeval_elapsed(&tv));
1672
1673 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1674 if (dirs[i].counted != dirs[i].expected) {
1675 torture_comment(torture,
1676 "ERROR: i=%d expected %d got %d for '%s'\n",
1677 i, dirs[i].expected, dirs[i].counted,
1678 dirs[i].path);
1679 ret = false;
1680 }
1681 }
1682
1683 /*
1684 run from the back, closing and deleting
1685 */
1686 for (i=ARRAY_SIZE(dirs)-1;i>=0;i--) {
1687 smb2_util_close(tree, dirs[i].h1);
1688 smb2_util_rmdir(tree, dirs[i].path);
1689 }
1690
1691 done:
1692 smb2_deltree(tree, BASEDIR);
1693 smb2_util_rmdir(tree, BASEDIR);
1694 return ret;
1695 }
1696
1697 /*
1698 Test response when cached server events exceed single NT NOTFIY response
1699 packet size.
1700 */
1701
1702 static bool torture_smb2_notify_overflow(struct torture_context *torture,
1703 struct smb2_tree *tree)
1704 {
1705 bool ret = true;
1706 NTSTATUS status;
1707 union smb_notify notify;
1708 union smb_open io;
1709 struct smb2_handle h1, h2;
1710 int count = 100;
1711 struct smb2_request *req1;
1712 int i;
1713
1714 smb2_deltree(tree, BASEDIR);
1715 smb2_util_rmdir(tree, BASEDIR);
1716
1717 torture_comment(torture, "TESTING CHANGE NOTIFY EVENT OVERFLOW\n");
1718
1719 /* get a handle on the directory */
1720 ZERO_STRUCT(io.smb2);
1721 io.generic.level = RAW_OPEN_SMB2;
1722 io.smb2.in.create_flags = 0;
1723 io.smb2.in.desired_access = SEC_FILE_ALL;
1724 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1725 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1726 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1727 NTCREATEX_SHARE_ACCESS_WRITE;
1728 io.smb2.in.alloc_size = 0;
1729 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1730 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1731 io.smb2.in.security_flags = 0;
1732 io.smb2.in.fname = BASEDIR;
1733
1734 status = smb2_create(tree, torture, &(io.smb2));
1735 CHECK_STATUS(status, NT_STATUS_OK);
1736 h1 = io.smb2.out.file.handle;
1737
1738 /* ask for a change notify, on name changes. */
1739 ZERO_STRUCT(notify.smb2);
1740 notify.smb2.level = RAW_NOTIFY_NTTRANS;
1741 notify.smb2.in.buffer_size = 1000;
1742 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1743 notify.smb2.in.file.handle = h1;
1744
1745 notify.smb2.in.recursive = true;
1746 req1 = smb2_notify_send(tree, &(notify.smb2));
1747
1748 /* cancel initial requests so the buffer is setup */
1749 smb2_cancel(req1);
1750 status = smb2_notify_recv(req1, torture, &(notify.smb2));
1751 CHECK_STATUS(status, NT_STATUS_CANCELLED);
1752
1753 /* open a lot of files, filling up the server side notify buffer */
1754 torture_comment(torture,
1755 "Testing overflowed buffer notify on create of %d files\n",
1756 count);
1757
1758 for (i=0;i<count;i++) {
1759 char *fname = talloc_asprintf(torture,
1760 BASEDIR "\\test%d.txt", i);
1761 union smb_open io1;
1762 ZERO_STRUCT(io1.smb2);
1763 io1.generic.level = RAW_OPEN_SMB2;
1764 io1.smb2.in.create_flags = 0;
1765 io1.smb2.in.desired_access = SEC_FILE_ALL;
1766 io1.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1767 io1.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1768 io1.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1769 NTCREATEX_SHARE_ACCESS_WRITE;
1770 io1.smb2.in.alloc_size = 0;
1771 io1.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1772 io1.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1773 io1.smb2.in.security_flags = 0;
1774 io1.smb2.in.fname = fname;
1775
1776 h2 = custom_smb2_create(tree, torture, &(io1.smb2));
1777 talloc_free(fname);
1778 smb2_util_close(tree, h2);
1779 }
1780
1781 req1 = smb2_notify_send(tree, &(notify.smb2));
1782 status = smb2_notify_recv(req1, torture, &(notify.smb2));
1783 CHECK_STATUS(status, STATUS_NOTIFY_ENUM_DIR);
1784 CHECK_VAL(notify.smb2.out.num_changes, 0);
1785
1786 done:
1787 smb2_deltree(tree, BASEDIR);
1788 return ret;
1789 }
1790
1791 /*
1792 Test if notifications are returned for changes to the base directory.
1793 They shouldn't be.
1794 */
1795
1796 static bool torture_smb2_notify_basedir(struct torture_context *torture,
1797 struct smb2_tree *tree1,
1798 struct smb2_tree *tree2)
1799 {
1800 bool ret = true;
1801 NTSTATUS status;
1802 union smb_notify notify;
1803 union smb_open io;
1804 struct smb2_handle h1;
1805 struct smb2_request *req1;
1806
1807 smb2_deltree(tree1, BASEDIR);
1808 smb2_util_rmdir(tree1, BASEDIR);
1809
1810 torture_comment(torture, "TESTING CHANGE NOTIFY BASEDIR EVENTS\n");
1811
1812 /* get a handle on the directory */
1813 ZERO_STRUCT(io.smb2);
1814 io.generic.level = RAW_OPEN_SMB2;
1815 io.smb2.in.create_flags = 0;
1816 io.smb2.in.desired_access = SEC_FILE_ALL;
1817 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1818 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1819 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1820 NTCREATEX_SHARE_ACCESS_WRITE;
1821 io.smb2.in.alloc_size = 0;
1822 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1823 io.smb2.in.impersonation_level = NTCREATEX_IMPERSONATION_ANONYMOUS;
1824 io.smb2.in.security_flags = 0;
1825 io.smb2.in.fname = BASEDIR;
1826
1827 status = smb2_create(tree1, torture, &(io.smb2));
1828 CHECK_STATUS(status, NT_STATUS_OK);
1829 h1 = io.smb2.out.file.handle;
1830
1831 /* create a test file that will also be modified */
1832 io.smb2.in.fname = BASEDIR "\\tname1";
1833 io.smb2.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
1834 status = smb2_create(tree2, torture, &(io.smb2));
1835 CHECK_STATUS(status,NT_STATUS_OK);
1836 smb2_util_close(tree2, io.smb2.out.file.handle);
1837
1838 /* ask for a change notify, on attribute changes. */
1839 ZERO_STRUCT(notify.smb2);
1840 notify.smb2.level = RAW_NOTIFY_SMB2;
1841 notify.smb2.in.buffer_size = 1000;
1842 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_ATTRIBUTES;
1843 notify.smb2.in.file.handle = h1;
1844 notify.smb2.in.recursive = true;
1845
1846 req1 = smb2_notify_send(tree1, &(notify.smb2));
1847
1848 /* set attribute on the base dir */
1849 smb2_util_setatr(tree2, BASEDIR, FILE_ATTRIBUTE_HIDDEN);
1850
1851 /* set attribute on a file to assure we receive a notification */
1852 smb2_util_setatr(tree2, BASEDIR "\\tname1", FILE_ATTRIBUTE_HIDDEN);
1853 smb_msleep(200);
1854
1855 /* check how many responses were given, expect only 1 for the file */
1856 status = smb2_notify_recv(req1, torture, &(notify.smb2));
1857 CHECK_STATUS(status, NT_STATUS_OK);
1858 CHECK_VAL(notify.smb2.out.num_changes, 1);
1859 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_MODIFIED);
1860 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "tname1");
1861
1862 done:
1863 smb2_deltree(tree1, BASEDIR);
1864 return ret;
1865 }
1866
1867 /*
1868 very simple change notify test
1869 */
1870 static bool torture_smb2_notify_tcon(struct torture_context *torture,
1871 struct smb2_tree *tree)
1872 {
1873 bool ret = true;
1874 NTSTATUS status;
1875 union smb_notify notify;
1876 union smb_open io;
1877 struct smb2_handle h1;
1878 struct smb2_request *req = NULL;
1879 struct smb2_tree *tree1 = NULL;
1880 const char *fname = BASEDIR "\\subdir-name";
1881
1882 smb2_deltree(tree, BASEDIR);
1883 smb2_util_rmdir(tree, BASEDIR);
1884
1885 torture_comment(torture, "TESTING SIMPLE CHANGE NOTIFY\n");
1886
1887 /*
1888 get a handle on the directory
1889 */
1890
1891 ZERO_STRUCT(io.smb2);
1892 io.generic.level = RAW_OPEN_SMB2;
1893 io.smb2.in.create_flags = 0;
1894 io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1895 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1896 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL |
1897 FILE_ATTRIBUTE_DIRECTORY;
1898 io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1899 NTCREATEX_SHARE_ACCESS_WRITE;
1900 io.smb2.in.alloc_size = 0;
1901 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1902 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1903 io.smb2.in.security_flags = 0;
1904 io.smb2.in.fname = BASEDIR;
1905
1906 status = smb2_create(tree, torture, &(io.smb2));
1907 CHECK_STATUS(status, NT_STATUS_OK);
1908 h1 = io.smb2.out.file.handle;
1909
1910 /* ask for a change notify,
1911 on file or directory name changes */
1912 ZERO_STRUCT(notify.smb2);
1913 notify.smb2.level = RAW_NOTIFY_SMB2;
1914 notify.smb2.in.buffer_size = 1000;
1915 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1916 notify.smb2.in.file.handle = h1;
1917 notify.smb2.in.recursive = true;
1918
1919 torture_comment(torture, "Testing notify mkdir\n");
1920 req = smb2_notify_send(tree, &(notify.smb2));
1921 smb2_cancel(req);
1922 status = smb2_notify_recv(req, torture, &(notify.smb2));
1923 CHECK_STATUS(status, NT_STATUS_CANCELLED);
1924
1925 notify.smb2.in.recursive = true;
1926 req = smb2_notify_send(tree, &(notify.smb2));
1927 status = smb2_util_mkdir(tree, fname);
1928 CHECK_STATUS(status, NT_STATUS_OK);
1929
1930 status = smb2_notify_recv(req, torture, &(notify.smb2));
1931 CHECK_STATUS(status, NT_STATUS_OK);
1932
1933 CHECK_VAL(notify.smb2.out.num_changes, 1);
1934 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_ADDED);
1935 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
1936
1937 torture_comment(torture, "Testing notify rmdir\n");
1938 req = smb2_notify_send(tree, &(notify.smb2));
1939 status = smb2_util_rmdir(tree, fname);
1940 CHECK_STATUS(status, NT_STATUS_OK);
1941
1942 status = smb2_notify_recv(req, torture, &(notify.smb2));
1943 CHECK_STATUS(status, NT_STATUS_OK);
1944 CHECK_VAL(notify.smb2.out.num_changes, 1);
1945 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_REMOVED);
1946 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
1947
1948 torture_comment(torture, "SIMPLE CHANGE NOTIFY OK\n");
1949
1950 torture_comment(torture, "TESTING WITH SECONDARY TCON\n");
1951 if (!torture_smb2_tree_connect(torture, tree->session, tree, &tree1)) {
1952 torture_warning(torture, "couldn't reconnect to share, bailing\n");
1953 ret = false;
1954 goto done;
1955 }
1956
1957 torture_comment(torture, "tid1=%d tid2=%d\n",
1958 smb2cli_tcon_current_id(tree->smbXcli),
1959 smb2cli_tcon_current_id(tree1->smbXcli));
1960
1961 torture_comment(torture, "Testing notify mkdir\n");
1962 req = smb2_notify_send(tree, &(notify.smb2));
1963 smb2_util_mkdir(tree1, fname);
1964
1965 status = smb2_notify_recv(req, torture, &(notify.smb2));
1966 CHECK_STATUS(status, NT_STATUS_OK);
1967
1968 CHECK_VAL(notify.smb2.out.num_changes, 1);
1969 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_ADDED);
1970 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
1971
1972 torture_comment(torture, "Testing notify rmdir\n");
1973 req = smb2_notify_send(tree, &(notify.smb2));
1974 smb2_util_rmdir(tree, fname);
1975
1976 status = smb2_notify_recv(req, torture, &(notify.smb2));
1977 CHECK_STATUS(status, NT_STATUS_OK);
1978 CHECK_VAL(notify.smb2.out.num_changes, 1);
1979 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_REMOVED);
1980 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
1981
1982 torture_comment(torture, "CHANGE NOTIFY WITH TCON OK\n");
1983
1984 torture_comment(torture, "Disconnecting secondary tree\n");
1985 status = smb2_tdis(tree1);
1986 CHECK_STATUS(status, NT_STATUS_OK);
1987 talloc_free(tree1);
1988
1989 torture_comment(torture, "Testing notify mkdir\n");
1990 req = smb2_notify_send(tree, &(notify.smb2));
1991 smb2_util_mkdir(tree, fname);
1992
1993 status = smb2_notify_recv(req, torture, &(notify.smb2));
1994 CHECK_STATUS(status, NT_STATUS_OK);
1995
1996 CHECK_VAL(notify.smb2.out.num_changes, 1);
1997 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_ADDED);
1998 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
1999
2000 torture_comment(torture, "Testing notify rmdir\n");
2001 req = smb2_notify_send(tree, &(notify.smb2));
2002 smb2_util_rmdir(tree, fname);
2003
2004 status = smb2_notify_recv(req, torture, &(notify.smb2));
2005 CHECK_STATUS(status, NT_STATUS_OK);
2006 CHECK_VAL(notify.smb2.out.num_changes, 1);
2007 CHECK_VAL(notify.smb2.out.changes[0].action, NOTIFY_ACTION_REMOVED);
2008 CHECK_WIRE_STR(notify.smb2.out.changes[0].name, "subdir-name");
2009
2010 torture_comment(torture, "CHANGE NOTIFY WITH TDIS OK\n");
2011 done:
2012 smb2_util_close(tree, h1);
2013 smb2_deltree(tree, BASEDIR);
2014
2015 return ret;
2016 }
2017
2018 static bool torture_smb2_notify_rmdir(struct torture_context *torture,
2019 struct smb2_tree *tree1,
2020 struct smb2_tree *tree2,
2021 bool initial_delete_on_close)
2022 {
2023 bool ret = true;
2024 NTSTATUS status;
2025 union smb_notify notify = {};
2026 union smb_setfileinfo sfinfo = {};
2027 union smb_open io = {};
2028 struct smb2_handle h = {};
2029 struct smb2_request *req;
2030
2031 torture_comment(torture, "TESTING NOTIFY CANCEL FOR DELETED DIR\n");
2032
2033 smb2_deltree(tree1, BASEDIR);
2034 smb2_util_rmdir(tree1, BASEDIR);
2035
2036 ZERO_STRUCT(io.smb2);
2037 io.generic.level = RAW_OPEN_SMB2;
2038 io.smb2.in.create_flags = 0;
2039 io.smb2.in.desired_access = SEC_FILE_ALL;
2040 io.smb2.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
2041 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2042 io.smb2.in.share_access =
2043 NTCREATEX_SHARE_ACCESS_READ |
2044 NTCREATEX_SHARE_ACCESS_WRITE |
2045 NTCREATEX_SHARE_ACCESS_DELETE ;
2046 io.smb2.in.alloc_size = 0;
2047 io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
2048 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2049 io.smb2.in.security_flags = 0;
2050 io.smb2.in.fname = BASEDIR;
2051
2052 status = smb2_create(tree1, torture, &(io.smb2));
2053 CHECK_STATUS(status, NT_STATUS_OK);
2054 h = io.smb2.out.file.handle;
2055
2056 ZERO_STRUCT(notify.smb2);
2057 notify.smb2.level = RAW_NOTIFY_SMB2;
2058 notify.smb2.in.buffer_size = 1000;
2059 notify.smb2.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
2060 notify.smb2.in.file.handle = h;
2061 notify.smb2.in.recursive = false;
2062
2063 io.smb2.in.desired_access |= SEC_STD_DELETE;
2064 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
2065 req = smb2_notify_send(tree1, &(notify.smb2));
2066
2067 if (initial_delete_on_close) {
2068 status = smb2_util_rmdir(tree2, BASEDIR);
2069 CHECK_STATUS(status, NT_STATUS_OK);
2070 } else {
2071 status = smb2_create(tree2, torture, &(io.smb2));
2072 CHECK_STATUS(status, NT_STATUS_OK);
2073
2074 sfinfo.generic.level = RAW_SFILEINFO_DISPOSITION_INFORMATION;
2075 sfinfo.generic.in.file.handle = io.smb2.out.file.handle;
2076 sfinfo.disposition_info.in.delete_on_close = 1;
2077 status = smb2_setinfo_file(tree2, &sfinfo);
2078 CHECK_STATUS(status, NT_STATUS_OK);
2079
2080 smb2_util_close(tree2, io.smb2.out.file.handle);
2081 }
2082
2083 status = smb2_notify_recv(req, torture, &(notify.smb2));
2084 CHECK_STATUS(status, NT_STATUS_DELETE_PENDING);
2085
2086 done:
2087
2088 smb2_util_close(tree1, h);
2089 smb2_deltree(tree1, BASEDIR);
2090
2091 return ret;
2092 }
2093
2094 static bool torture_smb2_notify_rmdir1(struct torture_context *torture,
2095 struct smb2_tree *tree)
2096 {
2097 return torture_smb2_notify_rmdir(torture, tree, tree, false);
2098 }
2099
2100 static bool torture_smb2_notify_rmdir2(struct torture_context *torture,
2101 struct smb2_tree *tree)
2102 {
2103 return torture_smb2_notify_rmdir(torture, tree, tree, true);
2104 }
2105
2106 static bool torture_smb2_notify_rmdir3(struct torture_context *torture,
2107 struct smb2_tree *tree1,
2108 struct smb2_tree *tree2)
2109 {
2110 return torture_smb2_notify_rmdir(torture, tree1, tree2, false);
2111 }
2112
2113 static bool torture_smb2_notify_rmdir4(struct torture_context *torture,
2114 struct smb2_tree *tree1,
2115 struct smb2_tree *tree2)
2116 {
2117 return torture_smb2_notify_rmdir(torture, tree1, tree2, true);
2118 }
2119
2120 /*
2121 basic testing of SMB2 change notify
2122 */
2123 struct torture_suite *torture_smb2_notify_init(void)
2124 {
2125 struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "notify");
2126
2127 torture_suite_add_1smb2_test(suite, "valid-req", test_valid_request);
2128 torture_suite_add_1smb2_test(suite, "tcon", torture_smb2_notify_tcon);
2129 torture_suite_add_2smb2_test(suite, "dir", torture_smb2_notify_dir);
2130 torture_suite_add_2smb2_test(suite, "mask", torture_smb2_notify_mask);
2131 torture_suite_add_1smb2_test(suite, "tdis", torture_smb2_notify_tree_disconnect);
2132 torture_suite_add_1smb2_test(suite, "tdis1", torture_smb2_notify_tree_disconnect_1);
2133 torture_suite_add_2smb2_test(suite, "mask-change", torture_smb2_notify_mask_change);
2134 torture_suite_add_1smb2_test(suite, "logoff", torture_smb2_notify_ulogoff);
2135 torture_suite_add_1smb2_test(suite, "tree", torture_smb2_notify_tree);
2136 torture_suite_add_2smb2_test(suite, "basedir", torture_smb2_notify_basedir);
2137 torture_suite_add_2smb2_test(suite, "double", torture_smb2_notify_double);
2138 torture_suite_add_1smb2_test(suite, "file", torture_smb2_notify_file);
2139 torture_suite_add_1smb2_test(suite, "tcp", torture_smb2_notify_tcp_disconnect);
2140 torture_suite_add_2smb2_test(suite, "rec", torture_smb2_notify_recursive);
2141 torture_suite_add_1smb2_test(suite, "overflow", torture_smb2_notify_overflow);
2142 torture_suite_add_1smb2_test(suite, "rmdir1",
2143 torture_smb2_notify_rmdir1);
2144 torture_suite_add_1smb2_test(suite, "rmdir2",
2145 torture_smb2_notify_rmdir2);
2146 torture_suite_add_2smb2_test(suite, "rmdir3",
2147 torture_smb2_notify_rmdir3);
2148 torture_suite_add_2smb2_test(suite, "rmdir4",
2149 torture_smb2_notify_rmdir4);
2150
2151 suite->description = talloc_strdup(suite, "SMB2-NOTIFY tests");
2152
2153 return suite;
2154 }
2155
Samba GIT mirror