?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-waf: remove version from libpdb.so for now.
[Samba/vl.git] / source4 / torture / raw / notify.c
blob6c4ca8266880a91ea72aeca339cb3e8a7143daa9
1 /*
2 Unix SMB/CIFS implementation.
3 basic raw test suite for change notify
4 Copyright (C) Andrew Tridgell 2003
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "libcli/raw/libcliraw.h"
22 #include "libcli/raw/raw_proto.h"
23 #include "libcli/libcli.h"
24 #include "system/filesys.h"
25 #include "torture/util.h"
26 #include "torture/raw/proto.h"
27
28 #define BASEDIR "\\test_notify"
29
30 #define CHECK_STATUS(status, correct) do { \
31 if (!NT_STATUS_EQUAL(status, correct)) { \
32 printf("(%d) Incorrect status %s - should be %s\n", \
33 __LINE__, nt_errstr(status), nt_errstr(correct)); \
34 ret = false; \
35 goto done; \
36 }} while (0)
37
38
39 #define CHECK_VAL(v, correct) do { \
40 if ((v) != (correct)) { \
41 printf("(%d) wrong value for %s 0x%x should be 0x%x\n", \
42 __LINE__, #v, (int)v, (int)correct); \
43 ret = false; \
44 goto done; \
45 }} while (0)
46
47 #define CHECK_WSTR(field, value, flags) do { \
48 if (!field.s || strcmp(field.s, value) || wire_bad_flags(&field, flags, cli->transport)) { \
49 printf("(%d) %s [%s] != %s\n", __LINE__, #field, field.s, value); \
50 ret = false; \
51 goto done; \
52 }} while (0)
53
54 #define CHECK_WSTR2(tctx, field, value, flags) \
55 do { \
56 if (!field.s || strcmp(field.s, value) || \
57 wire_bad_flags(&field, flags, cli->transport)) { \
58 torture_result(tctx, TORTURE_FAIL, \
59 "(%d) %s [%s] != %s\n", __LINE__, #field, field.s, value); \
60 } \
61 } while (0)
62
63 /*
64 basic testing of change notify on directories
65 */
66 static bool test_notify_dir(struct smbcli_state *cli, struct smbcli_state *cli2,
67 TALLOC_CTX *mem_ctx)
68 {
69 bool ret = true;
70 NTSTATUS status;
71 union smb_notify notify;
72 union smb_open io;
73 union smb_close cl;
74 int i, count, fnum, fnum2;
75 struct smbcli_request *req, *req2;
76 extern int torture_numops;
77
78 printf("TESTING CHANGE NOTIFY ON DIRECTORIES\n");
79
80 /*
81 get a handle on the directory
82 */
83 io.generic.level = RAW_OPEN_NTCREATEX;
84 io.ntcreatex.in.root_fid.fnum = 0;
85 io.ntcreatex.in.flags = 0;
86 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
87 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
88 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
89 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
90 io.ntcreatex.in.alloc_size = 0;
91 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
92 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
93 io.ntcreatex.in.security_flags = 0;
94 io.ntcreatex.in.fname = BASEDIR;
95
96 status = smb_raw_open(cli->tree, mem_ctx, &io);
97 CHECK_STATUS(status, NT_STATUS_OK);
98 fnum = io.ntcreatex.out.file.fnum;
99
100 status = smb_raw_open(cli->tree, mem_ctx, &io);
101 CHECK_STATUS(status, NT_STATUS_OK);
102 fnum2 = io.ntcreatex.out.file.fnum;
103
104 /* ask for a change notify,
105 on file or directory name changes */
106 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
107 notify.nttrans.in.buffer_size = 1000;
108 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
109 notify.nttrans.in.file.fnum = fnum;
110 notify.nttrans.in.recursive = true;
111
112 printf("Testing notify cancel\n");
113
114 req = smb_raw_changenotify_send(cli->tree, &notify);
115 smb_raw_ntcancel(req);
116 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
117 CHECK_STATUS(status, NT_STATUS_CANCELLED);
118
119 printf("Testing notify mkdir\n");
120
121 req = smb_raw_changenotify_send(cli->tree, &notify);
122 smbcli_mkdir(cli2->tree, BASEDIR "\\subdir-name");
123
124 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
125 CHECK_STATUS(status, NT_STATUS_OK);
126
127 CHECK_VAL(notify.nttrans.out.num_changes, 1);
128 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_ADDED);
129 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
130
131 printf("Testing notify rmdir\n");
132
133 req = smb_raw_changenotify_send(cli->tree, &notify);
134 smbcli_rmdir(cli2->tree, BASEDIR "\\subdir-name");
135
136 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
137 CHECK_STATUS(status, NT_STATUS_OK);
138 CHECK_VAL(notify.nttrans.out.num_changes, 1);
139 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_REMOVED);
140 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
141
142 printf("Testing notify mkdir - rmdir - mkdir - rmdir\n");
143
144 smbcli_mkdir(cli2->tree, BASEDIR "\\subdir-name");
145 smbcli_rmdir(cli2->tree, BASEDIR "\\subdir-name");
146 smbcli_mkdir(cli2->tree, BASEDIR "\\subdir-name");
147 smbcli_rmdir(cli2->tree, BASEDIR "\\subdir-name");
148 smb_msleep(200);
149 req = smb_raw_changenotify_send(cli->tree, &notify);
150 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
151 CHECK_STATUS(status, NT_STATUS_OK);
152 CHECK_VAL(notify.nttrans.out.num_changes, 4);
153 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_ADDED);
154 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
155 CHECK_VAL(notify.nttrans.out.changes[1].action, NOTIFY_ACTION_REMOVED);
156 CHECK_WSTR(notify.nttrans.out.changes[1].name, "subdir-name", STR_UNICODE);
157 CHECK_VAL(notify.nttrans.out.changes[2].action, NOTIFY_ACTION_ADDED);
158 CHECK_WSTR(notify.nttrans.out.changes[2].name, "subdir-name", STR_UNICODE);
159 CHECK_VAL(notify.nttrans.out.changes[3].action, NOTIFY_ACTION_REMOVED);
160 CHECK_WSTR(notify.nttrans.out.changes[3].name, "subdir-name", STR_UNICODE);
161
162 count = torture_numops;
163 printf("Testing buffered notify on create of %d files\n", count);
164 for (i=0;i<count;i++) {
165 char *fname = talloc_asprintf(cli, BASEDIR "\\test%d.txt", i);
166 int fnum3 = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR, DENY_NONE);
167 if (fnum3 == -1) {
168 printf("Failed to create %s - %s\n",
169 fname, smbcli_errstr(cli->tree));
170 ret = false;
171 goto done;
172 }
173 talloc_free(fname);
174 smbcli_close(cli->tree, fnum3);
175 }
176
177 /* (1st notify) setup a new notify on a different directory handle.
178 This new notify won't see the events above. */
179 notify.nttrans.in.file.fnum = fnum2;
180 req2 = smb_raw_changenotify_send(cli->tree, &notify);
181
182 /* (2nd notify) whereas this notify will see the above buffered events,
183 and it directly returns the buffered events */
184 notify.nttrans.in.file.fnum = fnum;
185 req = smb_raw_changenotify_send(cli->tree, &notify);
186
187 status = smbcli_unlink(cli->tree, BASEDIR "\\nonexistant.txt");
188 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
189
190 /* (1st unlink) as the 2nd notify directly returns,
191 this unlink is only seen by the 1st notify and
192 the 3rd notify (later) */
193 printf("Testing notify on unlink for the first file\n");
194 status = smbcli_unlink(cli2->tree, BASEDIR "\\test0.txt");
195 CHECK_STATUS(status, NT_STATUS_OK);
196
197 /* receive the reply from the 2nd notify */
198 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
199 CHECK_STATUS(status, NT_STATUS_OK);
200
201 CHECK_VAL(notify.nttrans.out.num_changes, count);
202 for (i=1;i<count;i++) {
203 CHECK_VAL(notify.nttrans.out.changes[i].action, NOTIFY_ACTION_ADDED);
204 }
205 CHECK_WSTR(notify.nttrans.out.changes[0].name, "test0.txt", STR_UNICODE);
206
207 printf("and now from the 1st notify\n");
208 status = smb_raw_changenotify_recv(req2, mem_ctx, &notify);
209 CHECK_STATUS(status, NT_STATUS_OK);
210 CHECK_VAL(notify.nttrans.out.num_changes, 1);
211 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_REMOVED);
212 CHECK_WSTR(notify.nttrans.out.changes[0].name, "test0.txt", STR_UNICODE);
213
214 printf("(3rd notify) this notify will only see the 1st unlink\n");
215 req = smb_raw_changenotify_send(cli->tree, &notify);
216
217 status = smbcli_unlink(cli->tree, BASEDIR "\\nonexistant.txt");
218 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
219
220 printf("Testing notify on wildcard unlink for %d files\n", count-1);
221 /* (2nd unlink) do a wildcard unlink */
222 status = smbcli_unlink(cli2->tree, BASEDIR "\\test*.txt");
223 CHECK_STATUS(status, NT_STATUS_OK);
224
225 /* receive the 3rd notify */
226 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
227 CHECK_STATUS(status, NT_STATUS_OK);
228 CHECK_VAL(notify.nttrans.out.num_changes, 1);
229 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_REMOVED);
230 CHECK_WSTR(notify.nttrans.out.changes[0].name, "test0.txt", STR_UNICODE);
231
232 /* and we now see the rest of the unlink calls on both directory handles */
233 notify.nttrans.in.file.fnum = fnum;
234 sleep(3);
235 req = smb_raw_changenotify_send(cli->tree, &notify);
236 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
237 CHECK_STATUS(status, NT_STATUS_OK);
238 CHECK_VAL(notify.nttrans.out.num_changes, count-1);
239 for (i=0;i<notify.nttrans.out.num_changes;i++) {
240 CHECK_VAL(notify.nttrans.out.changes[i].action, NOTIFY_ACTION_REMOVED);
241 }
242 notify.nttrans.in.file.fnum = fnum2;
243 req = smb_raw_changenotify_send(cli->tree, &notify);
244 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
245 CHECK_STATUS(status, NT_STATUS_OK);
246 CHECK_VAL(notify.nttrans.out.num_changes, count-1);
247 for (i=0;i<notify.nttrans.out.num_changes;i++) {
248 CHECK_VAL(notify.nttrans.out.changes[i].action, NOTIFY_ACTION_REMOVED);
249 }
250
251 printf("Testing if a close() on the dir handle triggers the notify reply\n");
252
253 notify.nttrans.in.file.fnum = fnum;
254 req = smb_raw_changenotify_send(cli->tree, &notify);
255
256 cl.close.level = RAW_CLOSE_CLOSE;
257 cl.close.in.file.fnum = fnum;
258 cl.close.in.write_time = 0;
259 status = smb_raw_close(cli->tree, &cl);
260 CHECK_STATUS(status, NT_STATUS_OK);
261
262 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
263 CHECK_STATUS(status, NT_STATUS_OK);
264 CHECK_VAL(notify.nttrans.out.num_changes, 0);
265
266 done:
267 smb_raw_exit(cli->session);
268 return ret;
269 }
270
271 /*
272 * Check notify reply for a rename action. Not sure if this is a valid thing
273 * to do, but depending on timing between inotify and messaging we get the
274 * add/remove/modify in any order. This routines tries to find the action/name
275 * pair in any of the three following notify_changes.
276 */
277
278 static bool check_rename_reply(struct smbcli_state *cli,
279 int line,
280 struct notify_changes *actions,
281 uint32_t action, const char *name)
282 {
283 int i;
284
285 for (i=0; i<3; i++) {
286 if (actions[i].action == action) {
287 if ((actions[i].name.s == NULL)
288 || (strcmp(actions[i].name.s, name) != 0)
289 || (wire_bad_flags(&actions[i].name, STR_UNICODE,
290 cli->transport))) {
291 printf("(%d) name [%s] != %s\n", line,
292 actions[i].name.s, name);
293 return false;
294 }
295 return true;
296 }
297 }
298
299 printf("(%d) expected action %d, not found\n", line, action);
300 return false;
301 }
302
303 /*
304 testing of recursive change notify
305 */
306 static bool test_notify_recursive(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
307 {
308 bool ret = true;
309 NTSTATUS status;
310 union smb_notify notify;
311 union smb_open io;
312 int fnum;
313 struct smbcli_request *req1, *req2;
314
315 printf("TESTING CHANGE NOTIFY WITH RECURSION\n");
316
317 /*
318 get a handle on the directory
319 */
320 io.generic.level = RAW_OPEN_NTCREATEX;
321 io.ntcreatex.in.root_fid.fnum = 0;
322 io.ntcreatex.in.flags = 0;
323 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
324 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
325 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
326 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
327 io.ntcreatex.in.alloc_size = 0;
328 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
329 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
330 io.ntcreatex.in.security_flags = 0;
331 io.ntcreatex.in.fname = BASEDIR;
332
333 status = smb_raw_open(cli->tree, mem_ctx, &io);
334 CHECK_STATUS(status, NT_STATUS_OK);
335 fnum = io.ntcreatex.out.file.fnum;
336
337 /* ask for a change notify, on file or directory name
338 changes. Setup both with and without recursion */
339 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
340 notify.nttrans.in.buffer_size = 1000;
341 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_CREATION;
342 notify.nttrans.in.file.fnum = fnum;
343
344 notify.nttrans.in.recursive = true;
345 req1 = smb_raw_changenotify_send(cli->tree, &notify);
346
347 notify.nttrans.in.recursive = false;
348 req2 = smb_raw_changenotify_send(cli->tree, &notify);
349
350 /* cancel initial requests so the buffer is setup */
351 smb_raw_ntcancel(req1);
352 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
353 CHECK_STATUS(status, NT_STATUS_CANCELLED);
354
355 smb_raw_ntcancel(req2);
356 status = smb_raw_changenotify_recv(req2, mem_ctx, &notify);
357 CHECK_STATUS(status, NT_STATUS_CANCELLED);
358
359 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
360 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name\\subname1");
361 smbcli_close(cli->tree,
362 smbcli_open(cli->tree, BASEDIR "\\subdir-name\\subname2", O_CREAT, 0));
363 smbcli_rename(cli->tree, BASEDIR "\\subdir-name\\subname1", BASEDIR "\\subdir-name\\subname1-r");
364 smbcli_rename(cli->tree, BASEDIR "\\subdir-name\\subname2", BASEDIR "\\subname2-r");
365 smbcli_rename(cli->tree, BASEDIR "\\subname2-r", BASEDIR "\\subname3-r");
366
367 notify.nttrans.in.completion_filter = 0;
368 notify.nttrans.in.recursive = true;
369 smb_msleep(200);
370 req1 = smb_raw_changenotify_send(cli->tree, &notify);
371
372 smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name\\subname1-r");
373 smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
374 smbcli_unlink(cli->tree, BASEDIR "\\subname3-r");
375
376 notify.nttrans.in.recursive = false;
377 req2 = smb_raw_changenotify_send(cli->tree, &notify);
378
379 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
380 CHECK_STATUS(status, NT_STATUS_OK);
381
382 CHECK_VAL(notify.nttrans.out.num_changes, 11);
383 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_ADDED);
384 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
385 CHECK_VAL(notify.nttrans.out.changes[1].action, NOTIFY_ACTION_ADDED);
386 CHECK_WSTR(notify.nttrans.out.changes[1].name, "subdir-name\\subname1", STR_UNICODE);
387 CHECK_VAL(notify.nttrans.out.changes[2].action, NOTIFY_ACTION_ADDED);
388 CHECK_WSTR(notify.nttrans.out.changes[2].name, "subdir-name\\subname2", STR_UNICODE);
389 CHECK_VAL(notify.nttrans.out.changes[3].action, NOTIFY_ACTION_OLD_NAME);
390 CHECK_WSTR(notify.nttrans.out.changes[3].name, "subdir-name\\subname1", STR_UNICODE);
391 CHECK_VAL(notify.nttrans.out.changes[4].action, NOTIFY_ACTION_NEW_NAME);
392 CHECK_WSTR(notify.nttrans.out.changes[4].name, "subdir-name\\subname1-r", STR_UNICODE);
393
394 ret &= check_rename_reply(
395 cli, __LINE__, &notify.nttrans.out.changes[5],
396 NOTIFY_ACTION_ADDED, "subname2-r");
397 ret &= check_rename_reply(
398 cli, __LINE__, &notify.nttrans.out.changes[5],
399 NOTIFY_ACTION_REMOVED, "subdir-name\\subname2");
400 ret &= check_rename_reply(
401 cli, __LINE__, &notify.nttrans.out.changes[5],
402 NOTIFY_ACTION_MODIFIED, "subname2-r");
403
404 ret &= check_rename_reply(
405 cli, __LINE__, &notify.nttrans.out.changes[8],
406 NOTIFY_ACTION_OLD_NAME, "subname2-r");
407 ret &= check_rename_reply(
408 cli, __LINE__, &notify.nttrans.out.changes[8],
409 NOTIFY_ACTION_NEW_NAME, "subname3-r");
410 ret &= check_rename_reply(
411 cli, __LINE__, &notify.nttrans.out.changes[8],
412 NOTIFY_ACTION_MODIFIED, "subname3-r");
413
414 if (!ret) {
415 goto done;
416 }
417
418 status = smb_raw_changenotify_recv(req2, mem_ctx, &notify);
419 CHECK_STATUS(status, NT_STATUS_OK);
420
421 CHECK_VAL(notify.nttrans.out.num_changes, 3);
422 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_REMOVED);
423 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name\\subname1-r", STR_UNICODE);
424 CHECK_VAL(notify.nttrans.out.changes[1].action, NOTIFY_ACTION_REMOVED);
425 CHECK_WSTR(notify.nttrans.out.changes[1].name, "subdir-name", STR_UNICODE);
426 CHECK_VAL(notify.nttrans.out.changes[2].action, NOTIFY_ACTION_REMOVED);
427 CHECK_WSTR(notify.nttrans.out.changes[2].name, "subname3-r", STR_UNICODE);
428
429 done:
430 smb_raw_exit(cli->session);
431 return ret;
432 }
433
434 /*
435 testing of change notify mask change
436 */
437 static bool test_notify_mask_change(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
438 {
439 bool ret = true;
440 NTSTATUS status;
441 union smb_notify notify;
442 union smb_open io;
443 int fnum;
444 struct smbcli_request *req1, *req2;
445
446 printf("TESTING CHANGE NOTIFY WITH MASK CHANGE\n");
447
448 /*
449 get a handle on the directory
450 */
451 io.generic.level = RAW_OPEN_NTCREATEX;
452 io.ntcreatex.in.root_fid.fnum = 0;
453 io.ntcreatex.in.flags = 0;
454 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
455 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
456 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
457 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
458 io.ntcreatex.in.alloc_size = 0;
459 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
460 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
461 io.ntcreatex.in.security_flags = 0;
462 io.ntcreatex.in.fname = BASEDIR;
463
464 status = smb_raw_open(cli->tree, mem_ctx, &io);
465 CHECK_STATUS(status, NT_STATUS_OK);
466 fnum = io.ntcreatex.out.file.fnum;
467
468 /* ask for a change notify, on file or directory name
469 changes. Setup both with and without recursion */
470 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
471 notify.nttrans.in.buffer_size = 1000;
472 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_ATTRIBUTES;
473 notify.nttrans.in.file.fnum = fnum;
474
475 notify.nttrans.in.recursive = true;
476 req1 = smb_raw_changenotify_send(cli->tree, &notify);
477
478 notify.nttrans.in.recursive = false;
479 req2 = smb_raw_changenotify_send(cli->tree, &notify);
480
481 /* cancel initial requests so the buffer is setup */
482 smb_raw_ntcancel(req1);
483 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
484 CHECK_STATUS(status, NT_STATUS_CANCELLED);
485
486 smb_raw_ntcancel(req2);
487 status = smb_raw_changenotify_recv(req2, mem_ctx, &notify);
488 CHECK_STATUS(status, NT_STATUS_CANCELLED);
489
490 notify.nttrans.in.recursive = true;
491 req1 = smb_raw_changenotify_send(cli->tree, &notify);
492
493 /* Set to hidden then back again. */
494 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));
495 smbcli_setatr(cli->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_HIDDEN, 0);
496 smbcli_unlink(cli->tree, BASEDIR "\\tname1");
497
498 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
499 CHECK_STATUS(status, NT_STATUS_OK);
500
501 CHECK_VAL(notify.nttrans.out.num_changes, 1);
502 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_MODIFIED);
503 CHECK_WSTR(notify.nttrans.out.changes[0].name, "tname1", STR_UNICODE);
504
505 /* Now try and change the mask to include other events.
506 * This should not work - once the mask is set on a directory
507 * fnum it seems to be fixed until the fnum is closed. */
508
509 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_CREATION;
510 notify.nttrans.in.recursive = true;
511 req1 = smb_raw_changenotify_send(cli->tree, &notify);
512
513 notify.nttrans.in.recursive = false;
514 req2 = smb_raw_changenotify_send(cli->tree, &notify);
515
516 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
517 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name\\subname1");
518 smbcli_close(cli->tree,
519 smbcli_open(cli->tree, BASEDIR "\\subdir-name\\subname2", O_CREAT, 0));
520 smbcli_rename(cli->tree, BASEDIR "\\subdir-name\\subname1", BASEDIR "\\subdir-name\\subname1-r");
521 smbcli_rename(cli->tree, BASEDIR "\\subdir-name\\subname2", BASEDIR "\\subname2-r");
522 smbcli_rename(cli->tree, BASEDIR "\\subname2-r", BASEDIR "\\subname3-r");
523
524 smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name\\subname1-r");
525 smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
526 smbcli_unlink(cli->tree, BASEDIR "\\subname3-r");
527
528 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
529 CHECK_STATUS(status, NT_STATUS_OK);
530
531 CHECK_VAL(notify.nttrans.out.num_changes, 1);
532 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_MODIFIED);
533 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subname2-r", STR_UNICODE);
534
535 status = smb_raw_changenotify_recv(req2, mem_ctx, &notify);
536 CHECK_STATUS(status, NT_STATUS_OK);
537
538 CHECK_VAL(notify.nttrans.out.num_changes, 1);
539 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_MODIFIED);
540 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subname3-r", STR_UNICODE);
541
542 if (!ret) {
543 goto done;
544 }
545
546 done:
547 smb_raw_exit(cli->session);
548 return ret;
549 }
550
551
552 /*
553 testing of mask bits for change notify
554 */
555 static bool test_notify_mask(struct smbcli_state *cli, struct torture_context *tctx)
556 {
557 bool ret = true;
558 NTSTATUS status;
559 union smb_notify notify;
560 union smb_open io;
561 int fnum, fnum2;
562 uint32_t mask;
563 int i;
564 char c = 1;
565 struct timeval tv;
566 NTTIME t;
567
568 printf("TESTING CHANGE NOTIFY COMPLETION FILTERS\n");
569
570 tv = timeval_current_ofs(1000, 0);
571 t = timeval_to_nttime(&tv);
572
573 /*
574 get a handle on the directory
575 */
576 io.generic.level = RAW_OPEN_NTCREATEX;
577 io.ntcreatex.in.root_fid.fnum = 0;
578 io.ntcreatex.in.flags = 0;
579 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
580 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
581 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
582 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
583 io.ntcreatex.in.alloc_size = 0;
584 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
585 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
586 io.ntcreatex.in.security_flags = 0;
587 io.ntcreatex.in.fname = BASEDIR;
588
589 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
590 notify.nttrans.in.buffer_size = 1000;
591 notify.nttrans.in.recursive = true;
592
593 #define NOTIFY_MASK_TEST(test_name, setup, op, cleanup, Action, expected, nchanges) \
594 do { \
595 smbcli_getatr(cli->tree, test_name, NULL, NULL, NULL); \
596 do { for (mask=i=0;i<32;i++) { \
597 struct smbcli_request *req; \
598 status = smb_raw_open(cli->tree, tctx, &io); \
599 CHECK_STATUS(status, NT_STATUS_OK); \
600 fnum = io.ntcreatex.out.file.fnum; \
601 setup \
602 notify.nttrans.in.file.fnum = fnum; \
603 notify.nttrans.in.completion_filter = (1<<i); \
604 req = smb_raw_changenotify_send(cli->tree, &notify); \
605 op \
606 smb_msleep(200); smb_raw_ntcancel(req); \
607 status = smb_raw_changenotify_recv(req, tctx, &notify); \
608 cleanup \
609 smbcli_close(cli->tree, fnum); \
610 if (NT_STATUS_EQUAL(status, NT_STATUS_CANCELLED)) continue; \
611 CHECK_STATUS(status, NT_STATUS_OK); \
612 /* special case to cope with file rename behaviour */ \
613 if (nchanges == 2 && notify.nttrans.out.num_changes == 1 && \
614 notify.nttrans.out.changes[0].action == NOTIFY_ACTION_MODIFIED && \
615 ((expected) & FILE_NOTIFY_CHANGE_ATTRIBUTES) && \
616 Action == NOTIFY_ACTION_OLD_NAME) { \
617 printf("(rename file special handling OK)\n"); \
618 } else if (nchanges != notify.nttrans.out.num_changes) { \
619 printf("ERROR: nchanges=%d expected=%d action=%d filter=0x%08x\n", \
620 notify.nttrans.out.num_changes, \
621 nchanges, \
622 notify.nttrans.out.changes[0].action, \
623 notify.nttrans.in.completion_filter); \
624 ret = false; \
625 } else if (notify.nttrans.out.changes[0].action != Action) { \
626 printf("ERROR: nchanges=%d action=%d expectedAction=%d filter=0x%08x\n", \
627 notify.nttrans.out.num_changes, \
628 notify.nttrans.out.changes[0].action, \
629 Action, \
630 notify.nttrans.in.completion_filter); \
631 ret = false; \
632 } else if (strcmp(notify.nttrans.out.changes[0].name.s, "tname1") != 0) { \
633 printf("ERROR: nchanges=%d action=%d filter=0x%08x name=%s\n", \
634 notify.nttrans.out.num_changes, \
635 notify.nttrans.out.changes[0].action, \
636 notify.nttrans.in.completion_filter, \
637 notify.nttrans.out.changes[0].name.s); \
638 ret = false; \
639 } \
640 mask |= (1<<i); \
641 } \
642 if ((expected) != mask) { \
643 if (((expected) & ~mask) != 0) { \
644 printf("ERROR: trigger on too few bits. mask=0x%08x expected=0x%08x\n", \
645 mask, expected); \
646 ret = false; \
647 } else { \
648 printf("WARNING: trigger on too many bits. mask=0x%08x expected=0x%08x\n", \
649 mask, expected); \
650 } \
651 } \
652 } while (0); \
653 } while (0);
654
655 printf("Testing mkdir\n");
656 NOTIFY_MASK_TEST("Testing mkdir",;,
657 smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
658 smbcli_rmdir(cli->tree, BASEDIR "\\tname1");,
659 NOTIFY_ACTION_ADDED,
660 FILE_NOTIFY_CHANGE_DIR_NAME, 1);
661
662 printf("Testing create file\n");
663 NOTIFY_MASK_TEST("Testing create file",;,
664 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
665 smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
666 NOTIFY_ACTION_ADDED,
667 FILE_NOTIFY_CHANGE_FILE_NAME, 1);
668
669 printf("Testing unlink\n");
670 NOTIFY_MASK_TEST("Testing unlink",
671 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
672 smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
673 ;,
674 NOTIFY_ACTION_REMOVED,
675 FILE_NOTIFY_CHANGE_FILE_NAME, 1);
676
677 printf("Testing rmdir\n");
678 NOTIFY_MASK_TEST("Testing rmdir",
679 smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
680 smbcli_rmdir(cli->tree, BASEDIR "\\tname1");,
681 ;,
682 NOTIFY_ACTION_REMOVED,
683 FILE_NOTIFY_CHANGE_DIR_NAME, 1);
684
685 printf("Testing rename file\n");
686 NOTIFY_MASK_TEST("Testing rename file",
687 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
688 smbcli_rename(cli->tree, BASEDIR "\\tname1", BASEDIR "\\tname2");,
689 smbcli_unlink(cli->tree, BASEDIR "\\tname2");,
690 NOTIFY_ACTION_OLD_NAME,
691 FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_ATTRIBUTES|FILE_NOTIFY_CHANGE_CREATION, 2);
692
693 printf("Testing rename dir\n");
694 NOTIFY_MASK_TEST("Testing rename dir",
695 smbcli_mkdir(cli->tree, BASEDIR "\\tname1");,
696 smbcli_rename(cli->tree, BASEDIR "\\tname1", BASEDIR "\\tname2");,
697 smbcli_rmdir(cli->tree, BASEDIR "\\tname2");,
698 NOTIFY_ACTION_OLD_NAME,
699 FILE_NOTIFY_CHANGE_DIR_NAME, 2);
700
701 printf("Testing set path attribute\n");
702 NOTIFY_MASK_TEST("Testing set path attribute",
703 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
704 smbcli_setatr(cli->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_HIDDEN, 0);,
705 smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
706 NOTIFY_ACTION_MODIFIED,
707 FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
708
709 printf("Testing set path write time\n");
710 NOTIFY_MASK_TEST("Testing set path write time",
711 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1", O_CREAT, 0));,
712 smbcli_setatr(cli->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_NORMAL, 1000);,
713 smbcli_unlink(cli->tree, BASEDIR "\\tname1");,
714 NOTIFY_ACTION_MODIFIED,
715 FILE_NOTIFY_CHANGE_LAST_WRITE, 1);
716
717 printf("Testing set file attribute\n");
718 NOTIFY_MASK_TEST("Testing set file attribute",
719 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
720 smbcli_fsetatr(cli->tree, fnum2, FILE_ATTRIBUTE_HIDDEN, 0, 0, 0, 0);,
721 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
722 NOTIFY_ACTION_MODIFIED,
723 FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
724
725 if (torture_setting_bool(tctx, "samba3", false)) {
726 printf("Samba3 does not yet support create times "
727 "everywhere\n");
728 }
729 else {
730 printf("Testing set file create time\n");
731 NOTIFY_MASK_TEST("Testing set file create time",
732 fnum2 = create_complex_file(cli, tctx,
733 BASEDIR "\\tname1");,
734 smbcli_fsetatr(cli->tree, fnum2, 0, t, 0, 0, 0);,
735 (smbcli_close(cli->tree, fnum2),
736 smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
737 NOTIFY_ACTION_MODIFIED,
738 FILE_NOTIFY_CHANGE_CREATION, 1);
739 }
740
741 printf("Testing set file access time\n");
742 NOTIFY_MASK_TEST("Testing set file access time",
743 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
744 smbcli_fsetatr(cli->tree, fnum2, 0, 0, t, 0, 0);,
745 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
746 NOTIFY_ACTION_MODIFIED,
747 FILE_NOTIFY_CHANGE_LAST_ACCESS, 1);
748
749 printf("Testing set file write time\n");
750 NOTIFY_MASK_TEST("Testing set file write time",
751 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
752 smbcli_fsetatr(cli->tree, fnum2, 0, 0, 0, t, 0);,
753 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
754 NOTIFY_ACTION_MODIFIED,
755 FILE_NOTIFY_CHANGE_LAST_WRITE, 1);
756
757 printf("Testing set file change time\n");
758 NOTIFY_MASK_TEST("Testing set file change time",
759 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
760 smbcli_fsetatr(cli->tree, fnum2, 0, 0, 0, 0, t);,
761 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
762 NOTIFY_ACTION_MODIFIED,
763 0, 1);
764
765
766 printf("Testing write\n");
767 NOTIFY_MASK_TEST("Testing write",
768 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
769 smbcli_write(cli->tree, fnum2, 1, &c, 10000, 1);,
770 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
771 NOTIFY_ACTION_MODIFIED,
772 0, 1);
773
774 printf("Testing truncate\n");
775 NOTIFY_MASK_TEST("Testing truncate",
776 fnum2 = create_complex_file(cli, tctx, BASEDIR "\\tname1");,
777 smbcli_ftruncate(cli->tree, fnum2, 10000);,
778 (smbcli_close(cli->tree, fnum2), smbcli_unlink(cli->tree, BASEDIR "\\tname1"));,
779 NOTIFY_ACTION_MODIFIED,
780 FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_ATTRIBUTES, 1);
781
782 done:
783 smb_raw_exit(cli->session);
784 return ret;
785 }
786
787 /*
788 basic testing of change notify on files
789 */
790 static bool test_notify_file(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
791 {
792 NTSTATUS status;
793 bool ret = true;
794 union smb_open io;
795 union smb_close cl;
796 union smb_notify notify;
797 struct smbcli_request *req;
798 int fnum;
799 const char *fname = BASEDIR "\\file.txt";
800
801 printf("TESTING CHANGE NOTIFY ON FILES\n");
802
803 io.generic.level = RAW_OPEN_NTCREATEX;
804 io.ntcreatex.in.root_fid.fnum = 0;
805 io.ntcreatex.in.flags = 0;
806 io.ntcreatex.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
807 io.ntcreatex.in.create_options = 0;
808 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
809 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
810 io.ntcreatex.in.alloc_size = 0;
811 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
812 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
813 io.ntcreatex.in.security_flags = 0;
814 io.ntcreatex.in.fname = fname;
815 status = smb_raw_open(cli->tree, mem_ctx, &io);
816 CHECK_STATUS(status, NT_STATUS_OK);
817 fnum = io.ntcreatex.out.file.fnum;
818
819 /* ask for a change notify,
820 on file or directory name changes */
821 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
822 notify.nttrans.in.file.fnum = fnum;
823 notify.nttrans.in.buffer_size = 1000;
824 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_STREAM_NAME;
825 notify.nttrans.in.recursive = false;
826
827 printf("Testing if notifies on file handles are invalid (should be)\n");
828
829 req = smb_raw_changenotify_send(cli->tree, &notify);
830 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
831 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
832
833 cl.close.level = RAW_CLOSE_CLOSE;
834 cl.close.in.file.fnum = fnum;
835 cl.close.in.write_time = 0;
836 status = smb_raw_close(cli->tree, &cl);
837 CHECK_STATUS(status, NT_STATUS_OK);
838
839 status = smbcli_unlink(cli->tree, fname);
840 CHECK_STATUS(status, NT_STATUS_OK);
841
842 done:
843 smb_raw_exit(cli->session);
844 return ret;
845 }
846
847 /*
848 basic testing of change notifies followed by a tdis
849 */
850 static bool test_notify_tdis(struct torture_context *tctx)
851 {
852 bool ret = true;
853 NTSTATUS status;
854 union smb_notify notify;
855 union smb_open io;
856 int fnum;
857 struct smbcli_request *req;
858 struct smbcli_state *cli = NULL;
859
860 printf("TESTING CHANGE NOTIFY FOLLOWED BY TDIS\n");
861
862 if (!torture_open_connection(&cli, tctx, 0)) {
863 return false;
864 }
865
866 /*
867 get a handle on the directory
868 */
869 io.generic.level = RAW_OPEN_NTCREATEX;
870 io.ntcreatex.in.root_fid.fnum = 0;
871 io.ntcreatex.in.flags = 0;
872 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
873 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
874 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
875 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
876 io.ntcreatex.in.alloc_size = 0;
877 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
878 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
879 io.ntcreatex.in.security_flags = 0;
880 io.ntcreatex.in.fname = BASEDIR;
881
882 status = smb_raw_open(cli->tree, tctx, &io);
883 CHECK_STATUS(status, NT_STATUS_OK);
884 fnum = io.ntcreatex.out.file.fnum;
885
886 /* ask for a change notify,
887 on file or directory name changes */
888 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
889 notify.nttrans.in.buffer_size = 1000;
890 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
891 notify.nttrans.in.file.fnum = fnum;
892 notify.nttrans.in.recursive = true;
893
894 req = smb_raw_changenotify_send(cli->tree, &notify);
895
896 status = smbcli_tdis(cli);
897 CHECK_STATUS(status, NT_STATUS_OK);
898 cli->tree = NULL;
899
900 status = smb_raw_changenotify_recv(req, tctx, &notify);
901 CHECK_STATUS(status, NT_STATUS_OK);
902 CHECK_VAL(notify.nttrans.out.num_changes, 0);
903
904 done:
905 torture_close_connection(cli);
906 return ret;
907 }
908
909 /*
910 basic testing of change notifies followed by a exit
911 */
912 static bool test_notify_exit(struct torture_context *tctx)
913 {
914 bool ret = true;
915 NTSTATUS status;
916 union smb_notify notify;
917 union smb_open io;
918 int fnum;
919 struct smbcli_request *req;
920 struct smbcli_state *cli = NULL;
921
922 printf("TESTING CHANGE NOTIFY FOLLOWED BY EXIT\n");
923
924 if (!torture_open_connection(&cli, tctx, 0)) {
925 return false;
926 }
927
928 /*
929 get a handle on the directory
930 */
931 io.generic.level = RAW_OPEN_NTCREATEX;
932 io.ntcreatex.in.root_fid.fnum = 0;
933 io.ntcreatex.in.flags = 0;
934 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
935 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
936 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
937 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
938 io.ntcreatex.in.alloc_size = 0;
939 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
940 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
941 io.ntcreatex.in.security_flags = 0;
942 io.ntcreatex.in.fname = BASEDIR;
943
944 status = smb_raw_open(cli->tree, tctx, &io);
945 CHECK_STATUS(status, NT_STATUS_OK);
946 fnum = io.ntcreatex.out.file.fnum;
947
948 /* ask for a change notify,
949 on file or directory name changes */
950 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
951 notify.nttrans.in.buffer_size = 1000;
952 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
953 notify.nttrans.in.file.fnum = fnum;
954 notify.nttrans.in.recursive = true;
955
956 req = smb_raw_changenotify_send(cli->tree, &notify);
957
958 status = smb_raw_exit(cli->session);
959 CHECK_STATUS(status, NT_STATUS_OK);
960
961 status = smb_raw_changenotify_recv(req, tctx, &notify);
962 CHECK_STATUS(status, NT_STATUS_OK);
963 CHECK_VAL(notify.nttrans.out.num_changes, 0);
964
965 done:
966 torture_close_connection(cli);
967 return ret;
968 }
969
970 /*
971 basic testing of change notifies followed by a ulogoff
972 */
973 static bool test_notify_ulogoff(struct torture_context *tctx)
974 {
975 bool ret = true;
976 NTSTATUS status;
977 union smb_notify notify;
978 union smb_open io;
979 int fnum;
980 struct smbcli_request *req;
981 struct smbcli_state *cli = NULL;
982
983 printf("TESTING CHANGE NOTIFY FOLLOWED BY ULOGOFF\n");
984
985 if (!torture_open_connection(&cli, tctx, 0)) {
986 return false;
987 }
988
989 /*
990 get a handle on the directory
991 */
992 io.generic.level = RAW_OPEN_NTCREATEX;
993 io.ntcreatex.in.root_fid.fnum = 0;
994 io.ntcreatex.in.flags = 0;
995 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
996 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
997 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
998 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
999 io.ntcreatex.in.alloc_size = 0;
1000 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1001 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1002 io.ntcreatex.in.security_flags = 0;
1003 io.ntcreatex.in.fname = BASEDIR;
1004
1005 status = smb_raw_open(cli->tree, tctx, &io);
1006 CHECK_STATUS(status, NT_STATUS_OK);
1007 fnum = io.ntcreatex.out.file.fnum;
1008
1009 /* ask for a change notify,
1010 on file or directory name changes */
1011 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1012 notify.nttrans.in.buffer_size = 1000;
1013 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1014 notify.nttrans.in.file.fnum = fnum;
1015 notify.nttrans.in.recursive = true;
1016
1017 req = smb_raw_changenotify_send(cli->tree, &notify);
1018
1019 status = smb_raw_ulogoff(cli->session);
1020 CHECK_STATUS(status, NT_STATUS_OK);
1021
1022 status = smb_raw_changenotify_recv(req, tctx, &notify);
1023 CHECK_STATUS(status, NT_STATUS_OK);
1024 CHECK_VAL(notify.nttrans.out.num_changes, 0);
1025
1026 done:
1027 torture_close_connection(cli);
1028 return ret;
1029 }
1030
1031 static void tcp_dis_handler(struct smbcli_transport *t, void *p)
1032 {
1033 struct smbcli_state *cli = (struct smbcli_state *)p;
1034 smbcli_transport_dead(cli->transport, NT_STATUS_LOCAL_DISCONNECT);
1035 cli->transport = NULL;
1036 cli->tree = NULL;
1037 }
1038 /*
1039 basic testing of change notifies followed by tcp disconnect
1040 */
1041 static bool test_notify_tcp_dis(struct torture_context *tctx)
1042 {
1043 bool ret = true;
1044 NTSTATUS status;
1045 union smb_notify notify;
1046 union smb_open io;
1047 int fnum;
1048 struct smbcli_request *req;
1049 struct smbcli_state *cli = NULL;
1050
1051 printf("TESTING CHANGE NOTIFY FOLLOWED BY TCP DISCONNECT\n");
1052
1053 if (!torture_open_connection(&cli, tctx, 0)) {
1054 return false;
1055 }
1056
1057 /*
1058 get a handle on the directory
1059 */
1060 io.generic.level = RAW_OPEN_NTCREATEX;
1061 io.ntcreatex.in.root_fid.fnum = 0;
1062 io.ntcreatex.in.flags = 0;
1063 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1064 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1065 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1066 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1067 io.ntcreatex.in.alloc_size = 0;
1068 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1069 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1070 io.ntcreatex.in.security_flags = 0;
1071 io.ntcreatex.in.fname = BASEDIR;
1072
1073 status = smb_raw_open(cli->tree, tctx, &io);
1074 CHECK_STATUS(status, NT_STATUS_OK);
1075 fnum = io.ntcreatex.out.file.fnum;
1076
1077 /* ask for a change notify,
1078 on file or directory name changes */
1079 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1080 notify.nttrans.in.buffer_size = 1000;
1081 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1082 notify.nttrans.in.file.fnum = fnum;
1083 notify.nttrans.in.recursive = true;
1084
1085 req = smb_raw_changenotify_send(cli->tree, &notify);
1086
1087 smbcli_transport_idle_handler(cli->transport, tcp_dis_handler, 250, cli);
1088
1089 status = smb_raw_changenotify_recv(req, tctx, &notify);
1090 CHECK_STATUS(status, NT_STATUS_LOCAL_DISCONNECT);
1091
1092 done:
1093 torture_close_connection(cli);
1094 return ret;
1095 }
1096
1097 /*
1098 test setting up two change notify requests on one handle
1099 */
1100 static bool test_notify_double(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
1101 {
1102 bool ret = true;
1103 NTSTATUS status;
1104 union smb_notify notify;
1105 union smb_open io;
1106 int fnum;
1107 struct smbcli_request *req1, *req2;
1108
1109 printf("TESTING CHANGE NOTIFY TWICE ON ONE DIRECTORY\n");
1110
1111 /*
1112 get a handle on the directory
1113 */
1114 io.generic.level = RAW_OPEN_NTCREATEX;
1115 io.ntcreatex.in.root_fid.fnum = 0;
1116 io.ntcreatex.in.flags = 0;
1117 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1118 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1119 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1120 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1121 io.ntcreatex.in.alloc_size = 0;
1122 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1123 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1124 io.ntcreatex.in.security_flags = 0;
1125 io.ntcreatex.in.fname = BASEDIR;
1126
1127 status = smb_raw_open(cli->tree, mem_ctx, &io);
1128 CHECK_STATUS(status, NT_STATUS_OK);
1129 fnum = io.ntcreatex.out.file.fnum;
1130
1131 /* ask for a change notify,
1132 on file or directory name changes */
1133 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1134 notify.nttrans.in.buffer_size = 1000;
1135 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1136 notify.nttrans.in.file.fnum = fnum;
1137 notify.nttrans.in.recursive = true;
1138
1139 req1 = smb_raw_changenotify_send(cli->tree, &notify);
1140 req2 = smb_raw_changenotify_send(cli->tree, &notify);
1141
1142 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
1143
1144 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
1145 CHECK_STATUS(status, NT_STATUS_OK);
1146 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1147 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
1148
1149 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name2");
1150
1151 status = smb_raw_changenotify_recv(req2, mem_ctx, &notify);
1152 CHECK_STATUS(status, NT_STATUS_OK);
1153 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1154 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name2", STR_UNICODE);
1155
1156 done:
1157 smb_raw_exit(cli->session);
1158 return ret;
1159 }
1160
1161
1162 /*
1163 test multiple change notifies at different depths and with/without recursion
1164 */
1165 static bool test_notify_tree(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
1166 {
1167 bool ret = true;
1168 union smb_notify notify;
1169 union smb_open io;
1170 struct smbcli_request *req;
1171 struct timeval tv;
1172 struct {
1173 const char *path;
1174 bool recursive;
1175 uint32_t filter;
1176 int expected;
1177 int fnum;
1178 int counted;
1179 } dirs[] = {
1180 {BASEDIR "\\abc", true, FILE_NOTIFY_CHANGE_NAME, 30 },
1181 {BASEDIR "\\zqy", true, FILE_NOTIFY_CHANGE_NAME, 8 },
1182 {BASEDIR "\\atsy", true, FILE_NOTIFY_CHANGE_NAME, 4 },
1183 {BASEDIR "\\abc\\foo", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1184 {BASEDIR "\\abc\\blah", true, FILE_NOTIFY_CHANGE_NAME, 13 },
1185 {BASEDIR "\\abc\\blah", false, FILE_NOTIFY_CHANGE_NAME, 7 },
1186 {BASEDIR "\\abc\\blah\\a", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1187 {BASEDIR "\\abc\\blah\\b", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1188 {BASEDIR "\\abc\\blah\\c", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1189 {BASEDIR "\\abc\\fooblah", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1190 {BASEDIR "\\zqy\\xx", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1191 {BASEDIR "\\zqy\\yyy", true, FILE_NOTIFY_CHANGE_NAME, 2 },
1192 {BASEDIR "\\zqy\\..", true, FILE_NOTIFY_CHANGE_NAME, 40 },
1193 {BASEDIR, true, FILE_NOTIFY_CHANGE_NAME, 40 },
1194 {BASEDIR, false,FILE_NOTIFY_CHANGE_NAME, 6 },
1195 {BASEDIR "\\atsy", false,FILE_NOTIFY_CHANGE_NAME, 4 },
1196 {BASEDIR "\\abc", true, FILE_NOTIFY_CHANGE_NAME, 24 },
1197 {BASEDIR "\\abc", false,FILE_NOTIFY_CHANGE_FILE_NAME, 0 },
1198 {BASEDIR "\\abc", true, FILE_NOTIFY_CHANGE_FILE_NAME, 0 },
1199 {BASEDIR "\\abc", true, FILE_NOTIFY_CHANGE_NAME, 24 },
1200 };
1201 int i;
1202 NTSTATUS status;
1203 bool all_done = false;
1204
1205 printf("TESTING CHANGE NOTIFY FOR DIFFERENT DEPTHS\n");
1206
1207 io.generic.level = RAW_OPEN_NTCREATEX;
1208 io.ntcreatex.in.root_fid.fnum = 0;
1209 io.ntcreatex.in.flags = 0;
1210 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1211 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1212 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1213 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1214 io.ntcreatex.in.alloc_size = 0;
1215 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1216 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1217 io.ntcreatex.in.security_flags = 0;
1218
1219 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1220 notify.nttrans.in.buffer_size = 20000;
1221
1222 /*
1223 setup the directory tree, and the notify buffer on each directory
1224 */
1225 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1226 io.ntcreatex.in.fname = dirs[i].path;
1227 status = smb_raw_open(cli->tree, mem_ctx, &io);
1228 CHECK_STATUS(status, NT_STATUS_OK);
1229 dirs[i].fnum = io.ntcreatex.out.file.fnum;
1230
1231 notify.nttrans.in.completion_filter = dirs[i].filter;
1232 notify.nttrans.in.file.fnum = dirs[i].fnum;
1233 notify.nttrans.in.recursive = dirs[i].recursive;
1234 req = smb_raw_changenotify_send(cli->tree, &notify);
1235 smb_raw_ntcancel(req);
1236 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
1237 CHECK_STATUS(status, NT_STATUS_CANCELLED);
1238 }
1239
1240 /* trigger 2 events in each dir */
1241 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1242 char *path = talloc_asprintf(mem_ctx, "%s\\test.dir", dirs[i].path);
1243 smbcli_mkdir(cli->tree, path);
1244 smbcli_rmdir(cli->tree, path);
1245 talloc_free(path);
1246 }
1247
1248 /* give a bit of time for the events to propogate */
1249 tv = timeval_current();
1250
1251 do {
1252 /* count events that have happened in each dir */
1253 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1254 notify.nttrans.in.file.fnum = dirs[i].fnum;
1255 req = smb_raw_changenotify_send(cli->tree, &notify);
1256 smb_raw_ntcancel(req);
1257 notify.nttrans.out.num_changes = 0;
1258 status = smb_raw_changenotify_recv(req, mem_ctx, &notify);
1259 dirs[i].counted += notify.nttrans.out.num_changes;
1260 }
1261
1262 all_done = true;
1263
1264 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1265 if (dirs[i].counted != dirs[i].expected) {
1266 all_done = false;
1267 }
1268 }
1269 } while (!all_done && timeval_elapsed(&tv) < 20);
1270
1271 printf("took %.4f seconds to propogate all events\n", timeval_elapsed(&tv));
1272
1273 for (i=0;i<ARRAY_SIZE(dirs);i++) {
1274 if (dirs[i].counted != dirs[i].expected) {
1275 printf("ERROR: i=%d expected %d got %d for '%s'\n",
1276 i, dirs[i].expected, dirs[i].counted, dirs[i].path);
1277 ret = false;
1278 }
1279 }
1280
1281 /*
1282 run from the back, closing and deleting
1283 */
1284 for (i=ARRAY_SIZE(dirs)-1;i>=0;i--) {
1285 smbcli_close(cli->tree, dirs[i].fnum);
1286 smbcli_rmdir(cli->tree, dirs[i].path);
1287 }
1288
1289 done:
1290 smb_raw_exit(cli->session);
1291 return ret;
1292 }
1293
1294 /*
1295 Test response when cached server events exceed single NT NOTFIY response
1296 packet size.
1297 */
1298 static bool test_notify_overflow(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
1299 {
1300 bool ret = true;
1301 NTSTATUS status;
1302 union smb_notify notify;
1303 union smb_open io;
1304 int fnum;
1305 int count = 100;
1306 struct smbcli_request *req1;
1307 int i;
1308
1309 printf("TESTING CHANGE NOTIFY EVENT OVERFLOW\n");
1310
1311 /* get a handle on the directory */
1312 io.generic.level = RAW_OPEN_NTCREATEX;
1313 io.ntcreatex.in.root_fid.fnum = 0;
1314 io.ntcreatex.in.flags = 0;
1315 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1316 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1317 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1318 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1319 NTCREATEX_SHARE_ACCESS_WRITE;
1320 io.ntcreatex.in.alloc_size = 0;
1321 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1322 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1323 io.ntcreatex.in.security_flags = 0;
1324 io.ntcreatex.in.fname = BASEDIR;
1325
1326 status = smb_raw_open(cli->tree, mem_ctx, &io);
1327 CHECK_STATUS(status, NT_STATUS_OK);
1328 fnum = io.ntcreatex.out.file.fnum;
1329
1330 /* ask for a change notify, on name changes. */
1331 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1332 notify.nttrans.in.buffer_size = 1000;
1333 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1334 notify.nttrans.in.file.fnum = fnum;
1335
1336 notify.nttrans.in.recursive = true;
1337 req1 = smb_raw_changenotify_send(cli->tree, &notify);
1338
1339 /* cancel initial requests so the buffer is setup */
1340 smb_raw_ntcancel(req1);
1341 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
1342 CHECK_STATUS(status, NT_STATUS_CANCELLED);
1343
1344 /* open a lot of files, filling up the server side notify buffer */
1345 printf("Testing overflowed buffer notify on create of %d files\n",
1346 count);
1347 for (i=0;i<count;i++) {
1348 char *fname = talloc_asprintf(cli, BASEDIR "\\test%d.txt", i);
1349 int fnum2 = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR,
1350 DENY_NONE);
1351 if (fnum2 == -1) {
1352 printf("Failed to create %s - %s\n",
1353 fname, smbcli_errstr(cli->tree));
1354 ret = false;
1355 goto done;
1356 }
1357 talloc_free(fname);
1358 smbcli_close(cli->tree, fnum2);
1359 }
1360
1361 /* expect that 0 events will be returned with NT_STATUS_OK */
1362 req1 = smb_raw_changenotify_send(cli->tree, &notify);
1363 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
1364 CHECK_STATUS(status, NT_STATUS_OK);
1365 CHECK_VAL(notify.nttrans.out.num_changes, 0);
1366
1367 done:
1368 smb_raw_exit(cli->session);
1369 return ret;
1370 }
1371
1372 /*
1373 Test if notifications are returned for changes to the base directory.
1374 They shouldn't be.
1375 */
1376 static bool test_notify_basedir(struct smbcli_state *cli, TALLOC_CTX *mem_ctx)
1377 {
1378 bool ret = true;
1379 NTSTATUS status;
1380 union smb_notify notify;
1381 union smb_open io;
1382 int fnum;
1383 struct smbcli_request *req1;
1384
1385 printf("TESTING CHANGE NOTIFY BASEDIR EVENTS\n");
1386
1387 /* get a handle on the directory */
1388 io.generic.level = RAW_OPEN_NTCREATEX;
1389 io.ntcreatex.in.root_fid.fnum = 0;
1390 io.ntcreatex.in.flags = 0;
1391 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1392 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1393 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1394 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1395 NTCREATEX_SHARE_ACCESS_WRITE;
1396 io.ntcreatex.in.alloc_size = 0;
1397 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1398 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1399 io.ntcreatex.in.security_flags = 0;
1400 io.ntcreatex.in.fname = BASEDIR;
1401
1402 status = smb_raw_open(cli->tree, mem_ctx, &io);
1403 CHECK_STATUS(status, NT_STATUS_OK);
1404 fnum = io.ntcreatex.out.file.fnum;
1405
1406 /* create a test file that will also be modified */
1407 smbcli_close(cli->tree, smbcli_open(cli->tree, BASEDIR "\\tname1",
1408 O_CREAT, 0));
1409
1410 /* ask for a change notify, on attribute changes. */
1411 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1412 notify.nttrans.in.buffer_size = 1000;
1413 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_ATTRIBUTES;
1414 notify.nttrans.in.file.fnum = fnum;
1415 notify.nttrans.in.recursive = true;
1416
1417 req1 = smb_raw_changenotify_send(cli->tree, &notify);
1418
1419 /* set attribute on the base dir */
1420 smbcli_setatr(cli->tree, BASEDIR, FILE_ATTRIBUTE_HIDDEN, 0);
1421
1422 /* set attribute on a file to assure we receive a notification */
1423 smbcli_setatr(cli->tree, BASEDIR "\\tname1", FILE_ATTRIBUTE_HIDDEN, 0);
1424 smb_msleep(200);
1425
1426 /* check how many responses were given, expect only 1 for the file */
1427 status = smb_raw_changenotify_recv(req1, mem_ctx, &notify);
1428 CHECK_STATUS(status, NT_STATUS_OK);
1429 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1430 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_MODIFIED);
1431 CHECK_WSTR(notify.nttrans.out.changes[0].name, "tname1", STR_UNICODE);
1432
1433 done:
1434 smb_raw_exit(cli->session);
1435 return ret;
1436 }
1437
1438
1439 /*
1440 create a secondary tree connect - used to test for a bug in Samba3 messaging
1441 with change notify
1442 */
1443 static struct smbcli_tree *secondary_tcon(struct smbcli_state *cli,
1444 struct torture_context *tctx)
1445 {
1446 NTSTATUS status;
1447 const char *share, *host;
1448 struct smbcli_tree *tree;
1449 union smb_tcon tcon;
1450
1451 share = torture_setting_string(tctx, "share", NULL);
1452 host = torture_setting_string(tctx, "host", NULL);
1453
1454 printf("create a second tree context on the same session\n");
1455 tree = smbcli_tree_init(cli->session, tctx, false);
1456
1457 tcon.generic.level = RAW_TCON_TCONX;
1458 tcon.tconx.in.flags = 0;
1459 tcon.tconx.in.password = data_blob(NULL, 0);
1460 tcon.tconx.in.path = talloc_asprintf(tctx, "\\\\%s\\%s", host, share);
1461 tcon.tconx.in.device = "A:";
1462 status = smb_raw_tcon(tree, tctx, &tcon);
1463 if (!NT_STATUS_IS_OK(status)) {
1464 talloc_free(tree);
1465 printf("Failed to create secondary tree\n");
1466 return NULL;
1467 }
1468
1469 tree->tid = tcon.tconx.out.tid;
1470 printf("tid1=%d tid2=%d\n", cli->tree->tid, tree->tid);
1471
1472 return tree;
1473 }
1474
1475
1476 /*
1477 very simple change notify test
1478 */
1479 static bool test_notify_tcon(struct smbcli_state *cli, struct torture_context *torture)
1480 {
1481 bool ret = true;
1482 NTSTATUS status;
1483 union smb_notify notify;
1484 union smb_open io;
1485 int fnum, fnum2;
1486 struct smbcli_request *req;
1487 extern int torture_numops;
1488 struct smbcli_tree *tree = NULL;
1489
1490 printf("TESTING SIMPLE CHANGE NOTIFY\n");
1491
1492 /*
1493 get a handle on the directory
1494 */
1495 io.generic.level = RAW_OPEN_NTCREATEX;
1496 io.ntcreatex.in.root_fid.fnum = 0;
1497 io.ntcreatex.in.flags = 0;
1498 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1499 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1500 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1501 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1502 io.ntcreatex.in.alloc_size = 0;
1503 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1504 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1505 io.ntcreatex.in.security_flags = 0;
1506 io.ntcreatex.in.fname = BASEDIR;
1507
1508 status = smb_raw_open(cli->tree, torture, &io);
1509 CHECK_STATUS(status, NT_STATUS_OK);
1510 fnum = io.ntcreatex.out.file.fnum;
1511
1512 status = smb_raw_open(cli->tree, torture, &io);
1513 CHECK_STATUS(status, NT_STATUS_OK);
1514 fnum2 = io.ntcreatex.out.file.fnum;
1515
1516 /* ask for a change notify,
1517 on file or directory name changes */
1518 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1519 notify.nttrans.in.buffer_size = 1000;
1520 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
1521 notify.nttrans.in.file.fnum = fnum;
1522 notify.nttrans.in.recursive = true;
1523
1524 printf("Testing notify mkdir\n");
1525 req = smb_raw_changenotify_send(cli->tree, &notify);
1526 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
1527
1528 status = smb_raw_changenotify_recv(req, torture, &notify);
1529 CHECK_STATUS(status, NT_STATUS_OK);
1530
1531 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1532 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_ADDED);
1533 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
1534
1535 printf("Testing notify rmdir\n");
1536 req = smb_raw_changenotify_send(cli->tree, &notify);
1537 smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
1538
1539 status = smb_raw_changenotify_recv(req, torture, &notify);
1540 CHECK_STATUS(status, NT_STATUS_OK);
1541 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1542 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_REMOVED);
1543 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
1544
1545 printf("SIMPLE CHANGE NOTIFY OK\n");
1546
1547 printf("TESTING WITH SECONDARY TCON\n");
1548 tree = secondary_tcon(cli, torture);
1549
1550 printf("Testing notify mkdir\n");
1551 req = smb_raw_changenotify_send(cli->tree, &notify);
1552 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
1553
1554 status = smb_raw_changenotify_recv(req, torture, &notify);
1555 CHECK_STATUS(status, NT_STATUS_OK);
1556
1557 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1558 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_ADDED);
1559 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
1560
1561 printf("Testing notify rmdir\n");
1562 req = smb_raw_changenotify_send(cli->tree, &notify);
1563 smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
1564
1565 status = smb_raw_changenotify_recv(req, torture, &notify);
1566 CHECK_STATUS(status, NT_STATUS_OK);
1567 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1568 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_REMOVED);
1569 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
1570
1571 printf("CHANGE NOTIFY WITH TCON OK\n");
1572
1573 printf("Disconnecting secondary tree\n");
1574 status = smb_tree_disconnect(tree);
1575 CHECK_STATUS(status, NT_STATUS_OK);
1576 talloc_free(tree);
1577
1578 printf("Testing notify mkdir\n");
1579 req = smb_raw_changenotify_send(cli->tree, &notify);
1580 smbcli_mkdir(cli->tree, BASEDIR "\\subdir-name");
1581
1582 status = smb_raw_changenotify_recv(req, torture, &notify);
1583 CHECK_STATUS(status, NT_STATUS_OK);
1584
1585 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1586 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_ADDED);
1587 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
1588
1589 printf("Testing notify rmdir\n");
1590 req = smb_raw_changenotify_send(cli->tree, &notify);
1591 smbcli_rmdir(cli->tree, BASEDIR "\\subdir-name");
1592
1593 status = smb_raw_changenotify_recv(req, torture, &notify);
1594 CHECK_STATUS(status, NT_STATUS_OK);
1595 CHECK_VAL(notify.nttrans.out.num_changes, 1);
1596 CHECK_VAL(notify.nttrans.out.changes[0].action, NOTIFY_ACTION_REMOVED);
1597 CHECK_WSTR(notify.nttrans.out.changes[0].name, "subdir-name", STR_UNICODE);
1598
1599 printf("CHANGE NOTIFY WITH TDIS OK\n");
1600 done:
1601 smb_raw_exit(cli->session);
1602 return ret;
1603 }
1604
1605
1606 /*
1607 testing alignment of multiple change notify infos
1608 */
1609 static bool test_notify_alignment(struct smbcli_state *cli,
1610 struct torture_context *tctx)
1611 {
1612 NTSTATUS status;
1613 union smb_notify notify;
1614 union smb_open io;
1615 int i, fnum, fnum2;
1616 struct smbcli_request *req;
1617 const char *fname = BASEDIR "\\starter";
1618 const char *fnames[] = { "a",
1619 "ab",
1620 "abc",
1621 "abcd" };
1622 int num_names = ARRAY_SIZE(fnames);
1623 char *fpath = NULL;
1624
1625 torture_comment(tctx, "TESTING CHANGE NOTIFY REPLY ALIGNMENT\n");
1626
1627 /* get a handle on the directory */
1628 io.generic.level = RAW_OPEN_NTCREATEX;
1629 io.ntcreatex.in.root_fid.fnum = 0;
1630 io.ntcreatex.in.flags = 0;
1631 io.ntcreatex.in.access_mask = SEC_FILE_ALL;
1632 io.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1633 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1634 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1635 NTCREATEX_SHARE_ACCESS_WRITE;
1636 io.ntcreatex.in.alloc_size = 0;
1637 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1638 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1639 io.ntcreatex.in.security_flags = 0;
1640 io.ntcreatex.in.fname = BASEDIR;
1641
1642 status = smb_raw_open(cli->tree, tctx, &io);
1643 torture_assert_ntstatus_ok(tctx, status, "");
1644 fnum = io.ntcreatex.out.file.fnum;
1645
1646 /* ask for a change notify, on file creation */
1647 notify.nttrans.level = RAW_NOTIFY_NTTRANS;
1648 notify.nttrans.in.buffer_size = 1000;
1649 notify.nttrans.in.completion_filter = FILE_NOTIFY_CHANGE_FILE_NAME;
1650 notify.nttrans.in.file.fnum = fnum;
1651 notify.nttrans.in.recursive = false;
1652
1653 /* start change tracking */
1654 req = smb_raw_changenotify_send(cli->tree, &notify);
1655
1656 fnum2 = smbcli_open(cli->tree, fname, O_CREAT|O_RDWR, DENY_NONE);
1657 torture_assert(tctx, fnum2 != -1, smbcli_errstr(cli->tree));
1658 smbcli_close(cli->tree, fnum2);
1659
1660 status = smb_raw_changenotify_recv(req, tctx, &notify);
1661 torture_assert_ntstatus_ok(tctx, status, "");
1662
1663 /* create 4 files that will cause CHANGE_NOTIFY_INFO structures
1664 * to be returned in the same packet with all possible 4-byte padding
1665 * permutations. As per MS-CIFS 2.2.7.4.2 these structures should be
1666 * 4-byte aligned. */
1667
1668 for (i = 0; i < num_names; i++) {
1669 fpath = talloc_asprintf(tctx, "%s\\%s", BASEDIR, fnames[i]);
1670 fnum2 = smbcli_open(cli->tree, fpath,
1671 O_CREAT|O_RDWR, DENY_NONE);
1672 torture_assert(tctx, fnum2 != -1, smbcli_errstr(cli->tree));
1673 smbcli_close(cli->tree, fnum2);
1674 talloc_free(fpath);
1675 }
1676
1677 /* We send a notify packet, and let smb_raw_changenotify_recv() do
1678 * the alignment checking for us. */
1679 req = smb_raw_changenotify_send(cli->tree, &notify);
1680 status = smb_raw_changenotify_recv(req, tctx, &notify);
1681 torture_assert_ntstatus_ok(tctx, status, "");
1682
1683 /* Do basic checking for correctness. */
1684 torture_assert(tctx, notify.nttrans.out.num_changes == num_names, "");
1685 for (i = 0; i < num_names; i++) {
1686 torture_assert(tctx, notify.nttrans.out.changes[i].action ==
1687 NOTIFY_ACTION_ADDED, "");
1688 CHECK_WSTR2(tctx, notify.nttrans.out.changes[i].name, fnames[i],
1689 STR_UNICODE);
1690 }
1691
1692 return true;
1693 }
1694
1695 /*
1696 basic testing of change notify
1697 */
1698 bool torture_raw_notify(struct torture_context *torture,
1699 struct smbcli_state *cli,
1700 struct smbcli_state *cli2)
1701 {
1702 bool ret = true;
1703
1704 if (!torture_setup_dir(cli, BASEDIR)) {
1705 return false;
1706 }
1707
1708 ret &= test_notify_tcon(cli, torture);
1709 ret &= test_notify_dir(cli, cli2, torture);
1710 ret &= test_notify_mask(cli, torture);
1711 ret &= test_notify_recursive(cli, torture);
1712 ret &= test_notify_mask_change(cli, torture);
1713 ret &= test_notify_file(cli, torture);
1714 ret &= test_notify_tdis(torture);
1715 ret &= test_notify_exit(torture);
1716 ret &= test_notify_ulogoff(torture);
1717 ret &= test_notify_tcp_dis(torture);
1718 ret &= test_notify_double(cli, torture);
1719 ret &= test_notify_tree(cli, torture);
1720 ret &= test_notify_overflow(cli, torture);
1721 ret &= test_notify_basedir(cli, torture);
1722 ret &= test_notify_alignment(cli, torture);
1723
1724 smb_raw_exit(cli->session);
1725 smbcli_deltree(cli->tree, BASEDIR);
1726 return ret;
1727 }