?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:torture:smb2: don't skip the compound.interim1 test for non win7/win2k8
[Samba/gebeck_regimport.git] / source4 / torture / smb2 / compound.c
blob56ccf7a9b4fdcd7d34f1f04c7f4bb5d421d44ca5
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_FILE_CLOSED);
194 status = smb2_close_recv(req[4], &cl);
195 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
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[3];
352
353 smb2_transport_credits_ask_num(tree->session->transport, 3);
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, 3);
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 smb2_transport_compound_set_related(tree->session->transport, false);
392 req[2] = smb2_close_send(tree, &cl);
393
394 status = smb2_create_recv(req[0], tree, &cr);
395 /* TODO: check why this fails with --signing=required */
396 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
397 status = smb2_close_recv(req[1], &cl);
398 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
399 status = smb2_close_recv(req[2], &cl);
400 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
401
402 smb2_util_unlink(tree, fname);
403 done:
404 return ret;
405 }
406
407 static bool test_compound_invalid2(struct torture_context *tctx,
408 struct smb2_tree *tree)
409 {
410 struct smb2_handle hd;
411 struct smb2_create cr;
412 NTSTATUS status;
413 const char *fname = "compound_invalid2.dat";
414 struct smb2_close cl;
415 bool ret = true;
416 struct smb2_request *req[5];
417 struct smbXcli_tcon *saved_tcon = tree->smbXcli;
418 struct smbXcli_session *saved_session = tree->session->smbXcli;
419
420 smb2_transport_credits_ask_num(tree->session->transport, 5);
421
422 smb2_util_unlink(tree, fname);
423
424 smb2_transport_credits_ask_num(tree->session->transport, 1);
425
426 ZERO_STRUCT(cr);
427 cr.in.security_flags = 0x00;
428 cr.in.oplock_level = 0;
429 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
430 cr.in.create_flags = 0x00000000;
431 cr.in.reserved = 0x00000000;
432 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
433 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
434 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
435 NTCREATEX_SHARE_ACCESS_WRITE |
436 NTCREATEX_SHARE_ACCESS_DELETE;
437 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
438 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
439 NTCREATEX_OPTIONS_ASYNC_ALERT |
440 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
441 0x00200000;
442 cr.in.fname = fname;
443
444 smb2_transport_compound_start(tree->session->transport, 5);
445
446 req[0] = smb2_create_send(tree, &cr);
447
448 hd.data[0] = UINT64_MAX;
449 hd.data[1] = UINT64_MAX;
450
451 smb2_transport_compound_set_related(tree->session->transport, true);
452
453 ZERO_STRUCT(cl);
454 cl.in.file.handle = hd;
455
456 tree->smbXcli = smbXcli_tcon_create(tree);
457 smb2cli_tcon_set_values(tree->smbXcli,
458 NULL, /* session */
459 0xFFFFFFFF, /* tcon_id */
460 0, /* type */
461 0, /* flags */
462 0, /* capabilities */
463 0 /* maximal_access */);
464
465 tree->session->smbXcli = smbXcli_session_create(tree->session,
466 tree->session->transport->conn);
467 smb2cli_session_set_id_and_flags(tree->session->smbXcli, UINT64_MAX, 0);
468
469 req[1] = smb2_close_send(tree, &cl);
470 /* strange that this is not generating invalid parameter */
471 smb2_transport_compound_set_related(tree->session->transport, false);
472 req[2] = smb2_close_send(tree, &cl);
473 req[3] = smb2_close_send(tree, &cl);
474 smb2_transport_compound_set_related(tree->session->transport, true);
475 req[4] = smb2_close_send(tree, &cl);
476
477 status = smb2_create_recv(req[0], tree, &cr);
478 CHECK_STATUS(status, NT_STATUS_OK);
479 status = smb2_close_recv(req[1], &cl);
480 CHECK_STATUS(status, NT_STATUS_OK);
481 status = smb2_close_recv(req[2], &cl);
482 CHECK_STATUS(status, NT_STATUS_USER_SESSION_DELETED);
483 status = smb2_close_recv(req[3], &cl);
484 CHECK_STATUS(status, NT_STATUS_USER_SESSION_DELETED);
485 status = smb2_close_recv(req[4], &cl);
486 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
487
488 TALLOC_FREE(tree->smbXcli);
489 tree->smbXcli = saved_tcon;
490 TALLOC_FREE(tree->session->smbXcli);
491 tree->session->smbXcli = saved_session;
492
493 smb2_util_unlink(tree, fname);
494 done:
495 return ret;
496 }
497
498 static bool test_compound_invalid3(struct torture_context *tctx,
499 struct smb2_tree *tree)
500 {
501 struct smb2_handle hd;
502 struct smb2_create cr;
503 NTSTATUS status;
504 const char *fname = "compound_invalid3.dat";
505 struct smb2_close cl;
506 bool ret = true;
507 struct smb2_request *req[5];
508
509 smb2_transport_credits_ask_num(tree->session->transport, 5);
510
511 smb2_util_unlink(tree, fname);
512
513 smb2_transport_credits_ask_num(tree->session->transport, 1);
514
515 ZERO_STRUCT(cr);
516 cr.in.security_flags = 0x00;
517 cr.in.oplock_level = 0;
518 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
519 cr.in.create_flags = 0x00000000;
520 cr.in.reserved = 0x00000000;
521 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
522 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
523 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
524 NTCREATEX_SHARE_ACCESS_WRITE |
525 NTCREATEX_SHARE_ACCESS_DELETE;
526 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
527 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
528 NTCREATEX_OPTIONS_ASYNC_ALERT |
529 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
530 0x00200000;
531 cr.in.fname = fname;
532
533 smb2_transport_compound_start(tree->session->transport, 5);
534
535 req[0] = smb2_create_send(tree, &cr);
536
537 hd.data[0] = UINT64_MAX;
538 hd.data[1] = UINT64_MAX;
539
540 ZERO_STRUCT(cl);
541 cl.in.file.handle = hd;
542 req[1] = smb2_close_send(tree, &cl);
543 req[2] = smb2_close_send(tree, &cl);
544 /* flipping the related flag is invalid */
545 smb2_transport_compound_set_related(tree->session->transport, true);
546 req[3] = smb2_close_send(tree, &cl);
547 req[4] = smb2_close_send(tree, &cl);
548
549 status = smb2_create_recv(req[0], tree, &cr);
550 CHECK_STATUS(status, NT_STATUS_OK);
551 status = smb2_close_recv(req[1], &cl);
552 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
553 status = smb2_close_recv(req[2], &cl);
554 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
555 status = smb2_close_recv(req[3], &cl);
556 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
557 status = smb2_close_recv(req[4], &cl);
558 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
559
560 smb2_util_unlink(tree, fname);
561 done:
562 return ret;
563 }
564
565 /* Send a compound request where we expect the last request (Create, Notify)
566 * to go asynchronous. This works against a Win7 server and the reply is
567 * sent in two different packets. */
568 static bool test_compound_interim1(struct torture_context *tctx,
569 struct smb2_tree *tree)
570 {
571 struct smb2_handle hd;
572 struct smb2_create cr;
573 NTSTATUS status = NT_STATUS_OK;
574 const char *dname = "compound_interim_dir";
575 struct smb2_notify nt;
576 bool ret = true;
577 struct smb2_request *req[2];
578
579 /* Win7 compound request implementation deviates substantially from the
580 * SMB2 spec as noted in MS-SMB2 <159>, <162>. This, test currently
581 * verifies the Windows behavior, not the general spec behavior. */
582
583 smb2_transport_credits_ask_num(tree->session->transport, 5);
584
585 smb2_deltree(tree, dname);
586
587 smb2_transport_credits_ask_num(tree->session->transport, 1);
588
589 ZERO_STRUCT(cr);
590 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
591 cr.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
592 cr.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
593 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
594 NTCREATEX_SHARE_ACCESS_WRITE |
595 NTCREATEX_SHARE_ACCESS_DELETE;
596 cr.in.create_disposition = NTCREATEX_DISP_CREATE;
597 cr.in.fname = dname;
598
599 smb2_transport_compound_start(tree->session->transport, 2);
600
601 req[0] = smb2_create_send(tree, &cr);
602
603 smb2_transport_compound_set_related(tree->session->transport, true);
604
605 hd.data[0] = UINT64_MAX;
606 hd.data[1] = UINT64_MAX;
607
608 ZERO_STRUCT(nt);
609 nt.in.recursive = true;
610 nt.in.buffer_size = 0x1000;
611 nt.in.file.handle = hd;
612 nt.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
613 nt.in.unknown = 0x00000000;
614
615 req[1] = smb2_notify_send(tree, &nt);
616
617 status = smb2_create_recv(req[0], tree, &cr);
618 CHECK_STATUS(status, NT_STATUS_OK);
619
620 smb2_cancel(req[1]);
621 status = smb2_notify_recv(req[1], tree, &nt);
622 CHECK_STATUS(status, NT_STATUS_CANCELLED);
623
624 smb2_util_close(tree, cr.out.file.handle);
625
626 smb2_deltree(tree, dname);
627 done:
628 return ret;
629 }
630
631 /* Send a compound request where we expect the middle request (Create, Notify,
632 * GetInfo) to go asynchronous. Against Win7 the sync request succeed while
633 * the async fails. All are returned in the same compound response. */
634 static bool test_compound_interim2(struct torture_context *tctx,
635 struct smb2_tree *tree)
636 {
637 struct smb2_handle hd;
638 struct smb2_create cr;
639 NTSTATUS status = NT_STATUS_OK;
640 const char *dname = "compound_interim_dir";
641 struct smb2_getinfo gf;
642 struct smb2_notify nt;
643 bool ret = true;
644 struct smb2_request *req[3];
645
646 /* Win7 compound request implementation deviates substantially from the
647 * SMB2 spec as noted in MS-SMB2 <159>, <162>. This, test currently
648 * verifies the Windows behavior, not the general spec behavior. */
649 if (!TARGET_IS_WIN7(tctx) && !TARGET_IS_W2K8(tctx)) {
650 torture_skip(tctx, "Interim test is specific to Windows server "
651 "behavior.\n");
652 }
653
654 smb2_transport_credits_ask_num(tree->session->transport, 5);
655
656 smb2_deltree(tree, dname);
657
658 smb2_transport_credits_ask_num(tree->session->transport, 1);
659
660 ZERO_STRUCT(cr);
661 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
662 cr.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
663 cr.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
664 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
665 NTCREATEX_SHARE_ACCESS_WRITE |
666 NTCREATEX_SHARE_ACCESS_DELETE;
667 cr.in.create_disposition = NTCREATEX_DISP_CREATE;
668 cr.in.fname = dname;
669
670 smb2_transport_compound_start(tree->session->transport, 3);
671
672 req[0] = smb2_create_send(tree, &cr);
673
674 smb2_transport_compound_set_related(tree->session->transport, true);
675
676 hd.data[0] = UINT64_MAX;
677 hd.data[1] = UINT64_MAX;
678
679 ZERO_STRUCT(nt);
680 nt.in.recursive = true;
681 nt.in.buffer_size = 0x1000;
682 nt.in.file.handle = hd;
683 nt.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
684 nt.in.unknown = 0x00000000;
685
686 req[1] = smb2_notify_send(tree, &nt);
687
688 ZERO_STRUCT(gf);
689 gf.in.file.handle = hd;
690 gf.in.info_type = SMB2_GETINFO_FILE;
691 gf.in.info_class = 0x04; /* FILE_BASIC_INFORMATION */
692 gf.in.output_buffer_length = 0x1000;
693 gf.in.input_buffer_length = 0;
694
695 req[2] = smb2_getinfo_send(tree, &gf);
696
697 status = smb2_create_recv(req[0], tree, &cr);
698 CHECK_STATUS(status, NT_STATUS_OK);
699
700 status = smb2_notify_recv(req[1], tree, &nt);
701 CHECK_STATUS(status, NT_STATUS_INTERNAL_ERROR);
702
703 status = smb2_getinfo_recv(req[2], tree, &gf);
704 CHECK_STATUS(status, NT_STATUS_OK);
705
706 smb2_util_close(tree, cr.out.file.handle);
707
708 smb2_deltree(tree, dname);
709 done:
710 return ret;
711 }
712
713 struct torture_suite *torture_smb2_compound_init(void)
714 {
715 struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "compound");
716
717 torture_suite_add_1smb2_test(suite, "related1", test_compound_related1);
718 torture_suite_add_1smb2_test(suite, "related2", test_compound_related2);
719 torture_suite_add_1smb2_test(suite, "related3",
720 test_compound_related3);
721 torture_suite_add_1smb2_test(suite, "unrelated1", test_compound_unrelated1);
722 torture_suite_add_1smb2_test(suite, "invalid1", test_compound_invalid1);
723 torture_suite_add_1smb2_test(suite, "invalid2", test_compound_invalid2);
724 torture_suite_add_1smb2_test(suite, "invalid3", test_compound_invalid3);
725 torture_suite_add_1smb2_test(suite, "interim1", test_compound_interim1);
726 torture_suite_add_1smb2_test(suite, "interim2", test_compound_interim2);
727
728 suite->description = talloc_strdup(suite, "SMB2-COMPOUND tests");
729
730 return suite;
731 }
reg import