?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4-torture: Test for #9058
[Samba/gebeck_regimport.git] / source4 / torture / smb2 / compound.c
blob0eef3695bdbb12d8380641d24bb400e553157c73
1 /*
2 Unix SMB/CIFS implementation.
3
4 test suite for SMB2 compounded requests
5
6 Copyright (C) Stefan Metzmacher 2009
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "libcli/smb2/smb2.h"
24 #include "libcli/smb2/smb2_calls.h"
25 #include "torture/torture.h"
26 #include "torture/smb2/proto.h"
27 #include "../libcli/smb/smbXcli_base.h"
28
29 #define CHECK_STATUS(status, correct) do { \
30 if (!NT_STATUS_EQUAL(status, correct)) { \
31 torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
32 nt_errstr(status), nt_errstr(correct)); \
33 ret = false; \
34 goto done; \
35 }} while (0)
36
37 #define TARGET_IS_W2K8(_tctx) (torture_setting_bool(_tctx, "w2k8", false))
38 #define TARGET_IS_WIN7(_tctx) (torture_setting_bool(_tctx, "win7", false))
39
40 static bool test_compound_related1(struct torture_context *tctx,
41 struct smb2_tree *tree)
42 {
43 struct smb2_handle hd;
44 struct smb2_create cr;
45 NTSTATUS status;
46 const char *fname = "compound_related1.dat";
47 struct smb2_close cl;
48 bool ret = true;
49 struct smb2_request *req[2];
50 struct smbXcli_tcon *saved_tcon = tree->smbXcli;
51 struct smbXcli_session *saved_session = tree->session->smbXcli;
52
53 smb2_transport_credits_ask_num(tree->session->transport, 2);
54
55 smb2_util_unlink(tree, fname);
56
57 smb2_transport_credits_ask_num(tree->session->transport, 1);
58
59 ZERO_STRUCT(cr);
60 cr.in.security_flags = 0x00;
61 cr.in.oplock_level = 0;
62 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
63 cr.in.create_flags = 0x00000000;
64 cr.in.reserved = 0x00000000;
65 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
66 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
67 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
68 NTCREATEX_SHARE_ACCESS_WRITE |
69 NTCREATEX_SHARE_ACCESS_DELETE;
70 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
71 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
72 NTCREATEX_OPTIONS_ASYNC_ALERT |
73 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
74 0x00200000;
75 cr.in.fname = fname;
76
77 smb2_transport_compound_start(tree->session->transport, 2);
78
79 req[0] = smb2_create_send(tree, &cr);
80
81 smb2_transport_compound_set_related(tree->session->transport, true);
82
83 hd.data[0] = UINT64_MAX;
84 hd.data[1] = UINT64_MAX;
85
86 ZERO_STRUCT(cl);
87 cl.in.file.handle = hd;
88
89 tree->smbXcli = smbXcli_tcon_create(tree);
90 smb2cli_tcon_set_values(tree->smbXcli,
91 NULL, /* session */
92 0xFFFFFFFF, /* tcon_id */
93 0, /* type */
94 0, /* flags */
95 0, /* capabilities */
96 0 /* maximal_access */);
97
98 tree->session->smbXcli = smbXcli_session_create(tree->session,
99 tree->session->transport->conn);
100 smb2cli_session_set_id_and_flags(tree->session->smbXcli, UINT64_MAX, 0);
101
102 req[1] = smb2_close_send(tree, &cl);
103
104 status = smb2_create_recv(req[0], tree, &cr);
105 CHECK_STATUS(status, NT_STATUS_OK);
106 status = smb2_close_recv(req[1], &cl);
107 CHECK_STATUS(status, NT_STATUS_OK);
108
109 TALLOC_FREE(tree->smbXcli);
110 tree->smbXcli = saved_tcon;
111 TALLOC_FREE(tree->session->smbXcli);
112 tree->session->smbXcli = saved_session;
113
114 smb2_util_unlink(tree, fname);
115 done:
116 return ret;
117 }
118
119 static bool test_compound_related2(struct torture_context *tctx,
120 struct smb2_tree *tree)
121 {
122 struct smb2_handle hd;
123 struct smb2_create cr;
124 NTSTATUS status;
125 const char *fname = "compound_related2.dat";
126 struct smb2_close cl;
127 bool ret = true;
128 struct smb2_request *req[5];
129 struct smbXcli_tcon *saved_tcon = tree->smbXcli;
130 struct smbXcli_session *saved_session = tree->session->smbXcli;
131
132 smb2_transport_credits_ask_num(tree->session->transport, 5);
133
134 smb2_util_unlink(tree, fname);
135
136 smb2_transport_credits_ask_num(tree->session->transport, 1);
137
138 ZERO_STRUCT(cr);
139 cr.in.security_flags = 0x00;
140 cr.in.oplock_level = 0;
141 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
142 cr.in.create_flags = 0x00000000;
143 cr.in.reserved = 0x00000000;
144 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
145 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
146 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
147 NTCREATEX_SHARE_ACCESS_WRITE |
148 NTCREATEX_SHARE_ACCESS_DELETE;
149 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
150 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
151 NTCREATEX_OPTIONS_ASYNC_ALERT |
152 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
153 0x00200000;
154 cr.in.fname = fname;
155
156 smb2_transport_compound_start(tree->session->transport, 5);
157
158 req[0] = smb2_create_send(tree, &cr);
159
160 hd.data[0] = UINT64_MAX;
161 hd.data[1] = UINT64_MAX;
162
163 smb2_transport_compound_set_related(tree->session->transport, true);
164
165 ZERO_STRUCT(cl);
166 cl.in.file.handle = hd;
167
168 tree->smbXcli = smbXcli_tcon_create(tree);
169 smb2cli_tcon_set_values(tree->smbXcli,
170 NULL, /* session */
171 0xFFFFFFFF, /* tcon_id */
172 0, /* type */
173 0, /* flags */
174 0, /* capabilities */
175 0 /* maximal_access */);
176
177 tree->session->smbXcli = smbXcli_session_create(tree->session,
178 tree->session->transport->conn);
179 smb2cli_session_set_id_and_flags(tree->session->smbXcli, UINT64_MAX, 0);
180
181 req[1] = smb2_close_send(tree, &cl);
182 req[2] = smb2_close_send(tree, &cl);
183 req[3] = smb2_close_send(tree, &cl);
184 req[4] = smb2_close_send(tree, &cl);
185
186 status = smb2_create_recv(req[0], tree, &cr);
187 CHECK_STATUS(status, NT_STATUS_OK);
188 status = smb2_close_recv(req[1], &cl);
189 CHECK_STATUS(status, NT_STATUS_OK);
190 status = smb2_close_recv(req[2], &cl);
191 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
192 status = smb2_close_recv(req[3], &cl);
193 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
194 status = smb2_close_recv(req[4], &cl);
195 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
196
197 TALLOC_FREE(tree->smbXcli);
198 tree->smbXcli = saved_tcon;
199 TALLOC_FREE(tree->session->smbXcli);
200 tree->session->smbXcli = saved_session;
201
202 smb2_util_unlink(tree, fname);
203 done:
204 return ret;
205 }
206
207 static bool test_compound_related3(struct torture_context *tctx,
208 struct smb2_tree *tree)
209 {
210 struct smb2_handle hd;
211 struct smb2_ioctl io;
212 struct smb2_create cr;
213 struct smb2_close cl;
214 const char *fname = "compound_related3.dat";
215 struct smb2_request *req[3];
216 NTSTATUS status;
217 bool ret = false;
218
219 smb2_util_unlink(tree, fname);
220
221 ZERO_STRUCT(cr);
222 cr.in.security_flags = 0x00;
223 cr.in.oplock_level = 0;
224 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
225 cr.in.create_flags = 0x00000000;
226 cr.in.reserved = 0x00000000;
227 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
228 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
229 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
230 NTCREATEX_SHARE_ACCESS_WRITE |
231 NTCREATEX_SHARE_ACCESS_DELETE;
232 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
233 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
234 NTCREATEX_OPTIONS_ASYNC_ALERT |
235 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
236 0x00200000;
237 cr.in.fname = fname;
238
239 smb2_transport_compound_start(tree->session->transport, 3);
240
241 req[0] = smb2_create_send(tree, &cr);
242
243 hd.data[0] = UINT64_MAX;
244 hd.data[1] = UINT64_MAX;
245
246 smb2_transport_compound_set_related(tree->session->transport, true);
247
248 ZERO_STRUCT(io);
249 io.in.function = FSCTL_CREATE_OR_GET_OBJECT_ID;
250 io.in.file.handle = hd;
251 io.in.unknown2 = 0;
252 io.in.max_response_size = 64;
253 io.in.flags = 1;
254
255 req[1] = smb2_ioctl_send(tree, &io);
256
257 ZERO_STRUCT(cl);
258 cl.in.file.handle = hd;
259
260 req[2] = smb2_close_send(tree, &cl);
261
262 status = smb2_create_recv(req[0], tree, &cr);
263 CHECK_STATUS(status, NT_STATUS_OK);
264 status = smb2_ioctl_recv(req[1], tree, &io);
265 CHECK_STATUS(status, NT_STATUS_OK);
266 status = smb2_close_recv(req[2], &cl);
267 CHECK_STATUS(status, NT_STATUS_OK);
268
269 status = smb2_util_unlink(tree, fname);
270 CHECK_STATUS(status, NT_STATUS_OK);
271
272 ret = true;
273 done:
274 return ret;
275 }
276
277 static bool test_compound_unrelated1(struct torture_context *tctx,
278 struct smb2_tree *tree)
279 {
280 struct smb2_handle hd;
281 struct smb2_create cr;
282 NTSTATUS status;
283 const char *fname = "compound_unrelated1.dat";
284 struct smb2_close cl;
285 bool ret = true;
286 struct smb2_request *req[5];
287
288 smb2_transport_credits_ask_num(tree->session->transport, 5);
289
290 smb2_util_unlink(tree, fname);
291
292 smb2_transport_credits_ask_num(tree->session->transport, 1);
293
294 ZERO_STRUCT(cr);
295 cr.in.security_flags = 0x00;
296 cr.in.oplock_level = 0;
297 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
298 cr.in.create_flags = 0x00000000;
299 cr.in.reserved = 0x00000000;
300 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
301 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
302 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
303 NTCREATEX_SHARE_ACCESS_WRITE |
304 NTCREATEX_SHARE_ACCESS_DELETE;
305 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
306 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
307 NTCREATEX_OPTIONS_ASYNC_ALERT |
308 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
309 0x00200000;
310 cr.in.fname = fname;
311
312 smb2_transport_compound_start(tree->session->transport, 5);
313
314 req[0] = smb2_create_send(tree, &cr);
315
316 hd.data[0] = UINT64_MAX;
317 hd.data[1] = UINT64_MAX;
318
319 ZERO_STRUCT(cl);
320 cl.in.file.handle = hd;
321 req[1] = smb2_close_send(tree, &cl);
322 req[2] = smb2_close_send(tree, &cl);
323 req[3] = smb2_close_send(tree, &cl);
324 req[4] = smb2_close_send(tree, &cl);
325
326 status = smb2_create_recv(req[0], tree, &cr);
327 CHECK_STATUS(status, NT_STATUS_OK);
328 status = smb2_close_recv(req[1], &cl);
329 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
330 status = smb2_close_recv(req[2], &cl);
331 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
332 status = smb2_close_recv(req[3], &cl);
333 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
334 status = smb2_close_recv(req[4], &cl);
335 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
336
337 smb2_util_unlink(tree, fname);
338 done:
339 return ret;
340 }
341
342 static bool test_compound_invalid1(struct torture_context *tctx,
343 struct smb2_tree *tree)
344 {
345 struct smb2_handle hd;
346 struct smb2_create cr;
347 NTSTATUS status;
348 const char *fname = "compound_invalid1.dat";
349 struct smb2_close cl;
350 bool ret = true;
351 struct smb2_request *req[2];
352
353 smb2_transport_credits_ask_num(tree->session->transport, 2);
354
355 smb2_util_unlink(tree, fname);
356
357 smb2_transport_credits_ask_num(tree->session->transport, 1);
358
359 ZERO_STRUCT(cr);
360 cr.in.security_flags = 0x00;
361 cr.in.oplock_level = 0;
362 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
363 cr.in.create_flags = 0x00000000;
364 cr.in.reserved = 0x00000000;
365 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
366 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
367 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
368 NTCREATEX_SHARE_ACCESS_WRITE |
369 NTCREATEX_SHARE_ACCESS_DELETE;
370 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
371 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
372 NTCREATEX_OPTIONS_ASYNC_ALERT |
373 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
374 0x00200000;
375 cr.in.fname = fname;
376
377 smb2_transport_compound_start(tree->session->transport, 2);
378
379 /* passing the first request with the related flag is invalid */
380 smb2_transport_compound_set_related(tree->session->transport, true);
381
382 req[0] = smb2_create_send(tree, &cr);
383
384 hd.data[0] = UINT64_MAX;
385 hd.data[1] = UINT64_MAX;
386
387 ZERO_STRUCT(cl);
388 cl.in.file.handle = hd;
389 req[1] = smb2_close_send(tree, &cl);
390
391 status = smb2_create_recv(req[0], tree, &cr);
392 /* TODO: check why this fails with --signing=required */
393 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
394 status = smb2_close_recv(req[1], &cl);
395 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
396
397 smb2_util_unlink(tree, fname);
398 done:
399 return ret;
400 }
401
402 static bool test_compound_invalid2(struct torture_context *tctx,
403 struct smb2_tree *tree)
404 {
405 struct smb2_handle hd;
406 struct smb2_create cr;
407 NTSTATUS status;
408 const char *fname = "compound_invalid2.dat";
409 struct smb2_close cl;
410 bool ret = true;
411 struct smb2_request *req[5];
412 struct smbXcli_tcon *saved_tcon = tree->smbXcli;
413 struct smbXcli_session *saved_session = tree->session->smbXcli;
414
415 smb2_transport_credits_ask_num(tree->session->transport, 5);
416
417 smb2_util_unlink(tree, fname);
418
419 smb2_transport_credits_ask_num(tree->session->transport, 1);
420
421 ZERO_STRUCT(cr);
422 cr.in.security_flags = 0x00;
423 cr.in.oplock_level = 0;
424 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
425 cr.in.create_flags = 0x00000000;
426 cr.in.reserved = 0x00000000;
427 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
428 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
429 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
430 NTCREATEX_SHARE_ACCESS_WRITE |
431 NTCREATEX_SHARE_ACCESS_DELETE;
432 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
433 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
434 NTCREATEX_OPTIONS_ASYNC_ALERT |
435 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
436 0x00200000;
437 cr.in.fname = fname;
438
439 smb2_transport_compound_start(tree->session->transport, 5);
440
441 req[0] = smb2_create_send(tree, &cr);
442
443 hd.data[0] = UINT64_MAX;
444 hd.data[1] = UINT64_MAX;
445
446 smb2_transport_compound_set_related(tree->session->transport, true);
447
448 ZERO_STRUCT(cl);
449 cl.in.file.handle = hd;
450
451 tree->smbXcli = smbXcli_tcon_create(tree);
452 smb2cli_tcon_set_values(tree->smbXcli,
453 NULL, /* session */
454 0xFFFFFFFF, /* tcon_id */
455 0, /* type */
456 0, /* flags */
457 0, /* capabilities */
458 0 /* maximal_access */);
459
460 tree->session->smbXcli = smbXcli_session_create(tree->session,
461 tree->session->transport->conn);
462 smb2cli_session_set_id_and_flags(tree->session->smbXcli, UINT64_MAX, 0);
463
464 req[1] = smb2_close_send(tree, &cl);
465 /* strange that this is not generating invalid parameter */
466 smb2_transport_compound_set_related(tree->session->transport, false);
467 req[2] = smb2_close_send(tree, &cl);
468 req[3] = smb2_close_send(tree, &cl);
469 smb2_transport_compound_set_related(tree->session->transport, true);
470 req[4] = smb2_close_send(tree, &cl);
471
472 status = smb2_create_recv(req[0], tree, &cr);
473 CHECK_STATUS(status, NT_STATUS_OK);
474 status = smb2_close_recv(req[1], &cl);
475 CHECK_STATUS(status, NT_STATUS_OK);
476 status = smb2_close_recv(req[2], &cl);
477 CHECK_STATUS(status, NT_STATUS_USER_SESSION_DELETED);
478 status = smb2_close_recv(req[3], &cl);
479 CHECK_STATUS(status, NT_STATUS_USER_SESSION_DELETED);
480 status = smb2_close_recv(req[4], &cl);
481 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
482
483 TALLOC_FREE(tree->smbXcli);
484 tree->smbXcli = saved_tcon;
485 TALLOC_FREE(tree->session->smbXcli);
486 tree->session->smbXcli = saved_session;
487
488 smb2_util_unlink(tree, fname);
489 done:
490 return ret;
491 }
492
493 static bool test_compound_invalid3(struct torture_context *tctx,
494 struct smb2_tree *tree)
495 {
496 struct smb2_handle hd;
497 struct smb2_create cr;
498 NTSTATUS status;
499 const char *fname = "compound_invalid3.dat";
500 struct smb2_close cl;
501 bool ret = true;
502 struct smb2_request *req[5];
503
504 smb2_transport_credits_ask_num(tree->session->transport, 5);
505
506 smb2_util_unlink(tree, fname);
507
508 smb2_transport_credits_ask_num(tree->session->transport, 1);
509
510 ZERO_STRUCT(cr);
511 cr.in.security_flags = 0x00;
512 cr.in.oplock_level = 0;
513 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
514 cr.in.create_flags = 0x00000000;
515 cr.in.reserved = 0x00000000;
516 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
517 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
518 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
519 NTCREATEX_SHARE_ACCESS_WRITE |
520 NTCREATEX_SHARE_ACCESS_DELETE;
521 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
522 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
523 NTCREATEX_OPTIONS_ASYNC_ALERT |
524 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
525 0x00200000;
526 cr.in.fname = fname;
527
528 smb2_transport_compound_start(tree->session->transport, 5);
529
530 req[0] = smb2_create_send(tree, &cr);
531
532 hd.data[0] = UINT64_MAX;
533 hd.data[1] = UINT64_MAX;
534
535 ZERO_STRUCT(cl);
536 cl.in.file.handle = hd;
537 req[1] = smb2_close_send(tree, &cl);
538 req[2] = smb2_close_send(tree, &cl);
539 /* flipping the related flag is invalid */
540 smb2_transport_compound_set_related(tree->session->transport, true);
541 req[3] = smb2_close_send(tree, &cl);
542 req[4] = smb2_close_send(tree, &cl);
543
544 status = smb2_create_recv(req[0], tree, &cr);
545 CHECK_STATUS(status, NT_STATUS_OK);
546 status = smb2_close_recv(req[1], &cl);
547 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
548 status = smb2_close_recv(req[2], &cl);
549 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
550 status = smb2_close_recv(req[3], &cl);
551 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
552 status = smb2_close_recv(req[4], &cl);
553 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
554
555 smb2_util_unlink(tree, fname);
556 done:
557 return ret;
558 }
559
560 /* Send a compound request where we expect the last request (Create, Notify)
561 * to go asynchronous. This works against a Win7 server and the reply is
562 * sent in two different packets. */
563 static bool test_compound_interim1(struct torture_context *tctx,
564 struct smb2_tree *tree)
565 {
566 struct smb2_handle hd;
567 struct smb2_create cr;
568 NTSTATUS status = NT_STATUS_OK;
569 const char *dname = "compound_interim_dir";
570 struct smb2_notify nt;
571 bool ret = true;
572 struct smb2_request *req[2];
573
574 /* Win7 compound request implementation deviates substantially from the
575 * SMB2 spec as noted in MS-SMB2 <159>, <162>. This, test currently
576 * verifies the Windows behavior, not the general spec behavior. */
577 if (!TARGET_IS_WIN7(tctx) && !TARGET_IS_W2K8(tctx)) {
578 torture_skip(tctx, "Interim test is specific to Windows server "
579 "behavior.\n");
580 }
581
582 smb2_transport_credits_ask_num(tree->session->transport, 5);
583
584 smb2_deltree(tree, dname);
585
586 smb2_transport_credits_ask_num(tree->session->transport, 1);
587
588 ZERO_STRUCT(cr);
589 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
590 cr.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
591 cr.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
592 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
593 NTCREATEX_SHARE_ACCESS_WRITE |
594 NTCREATEX_SHARE_ACCESS_DELETE;
595 cr.in.create_disposition = NTCREATEX_DISP_CREATE;
596 cr.in.fname = dname;
597
598 smb2_transport_compound_start(tree->session->transport, 2);
599
600 req[0] = smb2_create_send(tree, &cr);
601
602 smb2_transport_compound_set_related(tree->session->transport, true);
603
604 hd.data[0] = UINT64_MAX;
605 hd.data[1] = UINT64_MAX;
606
607 ZERO_STRUCT(nt);
608 nt.in.recursive = true;
609 nt.in.buffer_size = 0x1000;
610 nt.in.file.handle = hd;
611 nt.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
612 nt.in.unknown = 0x00000000;
613
614 req[1] = smb2_notify_send(tree, &nt);
615
616 status = smb2_create_recv(req[0], tree, &cr);
617 CHECK_STATUS(status, NT_STATUS_OK);
618
619 smb2_cancel(req[1]);
620 status = smb2_notify_recv(req[1], tree, &nt);
621 CHECK_STATUS(status, NT_STATUS_CANCELLED);
622
623 smb2_util_close(tree, cr.out.file.handle);
624
625 smb2_deltree(tree, dname);
626 done:
627 return ret;
628 }
629
630 /* Send a compound request where we expect the middle request (Create, Notify,
631 * GetInfo) to go asynchronous. Against Win7 the sync request succeed while
632 * the async fails. All are returned in the same compound response. */
633 static bool test_compound_interim2(struct torture_context *tctx,
634 struct smb2_tree *tree)
635 {
636 struct smb2_handle hd;
637 struct smb2_create cr;
638 NTSTATUS status = NT_STATUS_OK;
639 const char *dname = "compound_interim_dir";
640 struct smb2_getinfo gf;
641 struct smb2_notify nt;
642 bool ret = true;
643 struct smb2_request *req[3];
644
645 /* Win7 compound request implementation deviates substantially from the
646 * SMB2 spec as noted in MS-SMB2 <159>, <162>. This, test currently
647 * verifies the Windows behavior, not the general spec behavior. */
648 if (!TARGET_IS_WIN7(tctx) && !TARGET_IS_W2K8(tctx)) {
649 torture_skip(tctx, "Interim test is specific to Windows server "
650 "behavior.\n");
651 }
652
653 smb2_transport_credits_ask_num(tree->session->transport, 5);
654
655 smb2_deltree(tree, dname);
656
657 smb2_transport_credits_ask_num(tree->session->transport, 1);
658
659 ZERO_STRUCT(cr);
660 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
661 cr.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
662 cr.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
663 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
664 NTCREATEX_SHARE_ACCESS_WRITE |
665 NTCREATEX_SHARE_ACCESS_DELETE;
666 cr.in.create_disposition = NTCREATEX_DISP_CREATE;
667 cr.in.fname = dname;
668
669 smb2_transport_compound_start(tree->session->transport, 3);
670
671 req[0] = smb2_create_send(tree, &cr);
672
673 smb2_transport_compound_set_related(tree->session->transport, true);
674
675 hd.data[0] = UINT64_MAX;
676 hd.data[1] = UINT64_MAX;
677
678 ZERO_STRUCT(nt);
679 nt.in.recursive = true;
680 nt.in.buffer_size = 0x1000;
681 nt.in.file.handle = hd;
682 nt.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
683 nt.in.unknown = 0x00000000;
684
685 req[1] = smb2_notify_send(tree, &nt);
686
687 ZERO_STRUCT(gf);
688 gf.in.file.handle = hd;
689 gf.in.info_type = SMB2_GETINFO_FILE;
690 gf.in.info_class = 0x04; /* FILE_BASIC_INFORMATION */
691 gf.in.output_buffer_length = 0x1000;
692 gf.in.input_buffer_length = 0;
693
694 req[2] = smb2_getinfo_send(tree, &gf);
695
696 status = smb2_create_recv(req[0], tree, &cr);
697 CHECK_STATUS(status, NT_STATUS_OK);
698
699 status = smb2_notify_recv(req[1], tree, &nt);
700 CHECK_STATUS(status, NT_STATUS_INTERNAL_ERROR);
701
702 status = smb2_getinfo_recv(req[2], tree, &gf);
703 CHECK_STATUS(status, NT_STATUS_OK);
704
705 smb2_util_close(tree, cr.out.file.handle);
706
707 smb2_deltree(tree, dname);
708 done:
709 return ret;
710 }
711
712 struct torture_suite *torture_smb2_compound_init(void)
713 {
714 struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "compound");
715
716 torture_suite_add_1smb2_test(suite, "related1", test_compound_related1);
717 torture_suite_add_1smb2_test(suite, "related2", test_compound_related2);
718 torture_suite_add_1smb2_test(suite, "related3",
719 test_compound_related3);
720 torture_suite_add_1smb2_test(suite, "unrelated1", test_compound_unrelated1);
721 torture_suite_add_1smb2_test(suite, "invalid1", test_compound_invalid1);
722 torture_suite_add_1smb2_test(suite, "invalid2", test_compound_invalid2);
723 torture_suite_add_1smb2_test(suite, "invalid3", test_compound_invalid3);
724 torture_suite_add_1smb2_test(suite, "interim1", test_compound_interim1);
725 torture_suite_add_1smb2_test(suite, "interim2", test_compound_interim2);
726
727 suite->description = talloc_strdup(suite, "SMB2-COMPOUND tests");
728
729 return suite;
730 }
reg import