?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:torture: send the TCONX_FLAG_EXTENDED_RESPONSE flag
[Samba/gebeck_regimport.git] / source4 / torture / smb2 / compound.c
blob6b65d8a48788cfeaeb115f813ec4d9872b707f8b
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_unrelated1(struct torture_context *tctx,
208 struct smb2_tree *tree)
209 {
210 struct smb2_handle hd;
211 struct smb2_create cr;
212 NTSTATUS status;
213 const char *fname = "compound_unrelated1.dat";
214 struct smb2_close cl;
215 bool ret = true;
216 struct smb2_request *req[5];
217
218 smb2_transport_credits_ask_num(tree->session->transport, 5);
219
220 smb2_util_unlink(tree, fname);
221
222 smb2_transport_credits_ask_num(tree->session->transport, 1);
223
224 ZERO_STRUCT(cr);
225 cr.in.security_flags = 0x00;
226 cr.in.oplock_level = 0;
227 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
228 cr.in.create_flags = 0x00000000;
229 cr.in.reserved = 0x00000000;
230 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
231 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
232 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
233 NTCREATEX_SHARE_ACCESS_WRITE |
234 NTCREATEX_SHARE_ACCESS_DELETE;
235 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
236 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
237 NTCREATEX_OPTIONS_ASYNC_ALERT |
238 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
239 0x00200000;
240 cr.in.fname = fname;
241
242 smb2_transport_compound_start(tree->session->transport, 5);
243
244 req[0] = smb2_create_send(tree, &cr);
245
246 hd.data[0] = UINT64_MAX;
247 hd.data[1] = UINT64_MAX;
248
249 ZERO_STRUCT(cl);
250 cl.in.file.handle = hd;
251 req[1] = smb2_close_send(tree, &cl);
252 req[2] = smb2_close_send(tree, &cl);
253 req[3] = smb2_close_send(tree, &cl);
254 req[4] = smb2_close_send(tree, &cl);
255
256 status = smb2_create_recv(req[0], tree, &cr);
257 CHECK_STATUS(status, NT_STATUS_OK);
258 status = smb2_close_recv(req[1], &cl);
259 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
260 status = smb2_close_recv(req[2], &cl);
261 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
262 status = smb2_close_recv(req[3], &cl);
263 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
264 status = smb2_close_recv(req[4], &cl);
265 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
266
267 smb2_util_unlink(tree, fname);
268 done:
269 return ret;
270 }
271
272 static bool test_compound_invalid1(struct torture_context *tctx,
273 struct smb2_tree *tree)
274 {
275 struct smb2_handle hd;
276 struct smb2_create cr;
277 NTSTATUS status;
278 const char *fname = "compound_invalid1.dat";
279 struct smb2_close cl;
280 bool ret = true;
281 struct smb2_request *req[2];
282
283 smb2_transport_credits_ask_num(tree->session->transport, 2);
284
285 smb2_util_unlink(tree, fname);
286
287 smb2_transport_credits_ask_num(tree->session->transport, 1);
288
289 ZERO_STRUCT(cr);
290 cr.in.security_flags = 0x00;
291 cr.in.oplock_level = 0;
292 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
293 cr.in.create_flags = 0x00000000;
294 cr.in.reserved = 0x00000000;
295 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
296 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
297 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
298 NTCREATEX_SHARE_ACCESS_WRITE |
299 NTCREATEX_SHARE_ACCESS_DELETE;
300 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
301 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
302 NTCREATEX_OPTIONS_ASYNC_ALERT |
303 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
304 0x00200000;
305 cr.in.fname = fname;
306
307 smb2_transport_compound_start(tree->session->transport, 2);
308
309 /* passing the first request with the related flag is invalid */
310 smb2_transport_compound_set_related(tree->session->transport, true);
311
312 req[0] = smb2_create_send(tree, &cr);
313
314 hd.data[0] = UINT64_MAX;
315 hd.data[1] = UINT64_MAX;
316
317 ZERO_STRUCT(cl);
318 cl.in.file.handle = hd;
319 req[1] = smb2_close_send(tree, &cl);
320
321 status = smb2_create_recv(req[0], tree, &cr);
322 /* TODO: check why this fails with --signing=required */
323 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
324 status = smb2_close_recv(req[1], &cl);
325 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
326
327 smb2_util_unlink(tree, fname);
328 done:
329 return ret;
330 }
331
332 static bool test_compound_invalid2(struct torture_context *tctx,
333 struct smb2_tree *tree)
334 {
335 struct smb2_handle hd;
336 struct smb2_create cr;
337 NTSTATUS status;
338 const char *fname = "compound_invalid2.dat";
339 struct smb2_close cl;
340 bool ret = true;
341 struct smb2_request *req[5];
342 struct smbXcli_tcon *saved_tcon = tree->smbXcli;
343 struct smbXcli_session *saved_session = tree->session->smbXcli;
344
345 smb2_transport_credits_ask_num(tree->session->transport, 5);
346
347 smb2_util_unlink(tree, fname);
348
349 smb2_transport_credits_ask_num(tree->session->transport, 1);
350
351 ZERO_STRUCT(cr);
352 cr.in.security_flags = 0x00;
353 cr.in.oplock_level = 0;
354 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
355 cr.in.create_flags = 0x00000000;
356 cr.in.reserved = 0x00000000;
357 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
358 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
359 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
360 NTCREATEX_SHARE_ACCESS_WRITE |
361 NTCREATEX_SHARE_ACCESS_DELETE;
362 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
363 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
364 NTCREATEX_OPTIONS_ASYNC_ALERT |
365 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
366 0x00200000;
367 cr.in.fname = fname;
368
369 smb2_transport_compound_start(tree->session->transport, 5);
370
371 req[0] = smb2_create_send(tree, &cr);
372
373 hd.data[0] = UINT64_MAX;
374 hd.data[1] = UINT64_MAX;
375
376 smb2_transport_compound_set_related(tree->session->transport, true);
377
378 ZERO_STRUCT(cl);
379 cl.in.file.handle = hd;
380
381 tree->smbXcli = smbXcli_tcon_create(tree);
382 smb2cli_tcon_set_values(tree->smbXcli,
383 NULL, /* session */
384 0xFFFFFFFF, /* tcon_id */
385 0, /* type */
386 0, /* flags */
387 0, /* capabilities */
388 0 /* maximal_access */);
389
390 tree->session->smbXcli = smbXcli_session_create(tree->session,
391 tree->session->transport->conn);
392 smb2cli_session_set_id_and_flags(tree->session->smbXcli, UINT64_MAX, 0);
393
394 req[1] = smb2_close_send(tree, &cl);
395 /* strange that this is not generating invalid parameter */
396 smb2_transport_compound_set_related(tree->session->transport, false);
397 req[2] = smb2_close_send(tree, &cl);
398 req[3] = smb2_close_send(tree, &cl);
399 smb2_transport_compound_set_related(tree->session->transport, true);
400 req[4] = smb2_close_send(tree, &cl);
401
402 status = smb2_create_recv(req[0], tree, &cr);
403 CHECK_STATUS(status, NT_STATUS_OK);
404 status = smb2_close_recv(req[1], &cl);
405 CHECK_STATUS(status, NT_STATUS_OK);
406 status = smb2_close_recv(req[2], &cl);
407 CHECK_STATUS(status, NT_STATUS_USER_SESSION_DELETED);
408 status = smb2_close_recv(req[3], &cl);
409 CHECK_STATUS(status, NT_STATUS_USER_SESSION_DELETED);
410 status = smb2_close_recv(req[4], &cl);
411 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
412
413 TALLOC_FREE(tree->smbXcli);
414 tree->smbXcli = saved_tcon;
415 TALLOC_FREE(tree->session->smbXcli);
416 tree->session->smbXcli = saved_session;
417
418 smb2_util_unlink(tree, fname);
419 done:
420 return ret;
421 }
422
423 static bool test_compound_invalid3(struct torture_context *tctx,
424 struct smb2_tree *tree)
425 {
426 struct smb2_handle hd;
427 struct smb2_create cr;
428 NTSTATUS status;
429 const char *fname = "compound_invalid3.dat";
430 struct smb2_close cl;
431 bool ret = true;
432 struct smb2_request *req[5];
433
434 smb2_transport_credits_ask_num(tree->session->transport, 5);
435
436 smb2_util_unlink(tree, fname);
437
438 smb2_transport_credits_ask_num(tree->session->transport, 1);
439
440 ZERO_STRUCT(cr);
441 cr.in.security_flags = 0x00;
442 cr.in.oplock_level = 0;
443 cr.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
444 cr.in.create_flags = 0x00000000;
445 cr.in.reserved = 0x00000000;
446 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
447 cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
448 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
449 NTCREATEX_SHARE_ACCESS_WRITE |
450 NTCREATEX_SHARE_ACCESS_DELETE;
451 cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
452 cr.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
453 NTCREATEX_OPTIONS_ASYNC_ALERT |
454 NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
455 0x00200000;
456 cr.in.fname = fname;
457
458 smb2_transport_compound_start(tree->session->transport, 5);
459
460 req[0] = smb2_create_send(tree, &cr);
461
462 hd.data[0] = UINT64_MAX;
463 hd.data[1] = UINT64_MAX;
464
465 ZERO_STRUCT(cl);
466 cl.in.file.handle = hd;
467 req[1] = smb2_close_send(tree, &cl);
468 req[2] = smb2_close_send(tree, &cl);
469 /* flipping the related flag is invalid */
470 smb2_transport_compound_set_related(tree->session->transport, true);
471 req[3] = smb2_close_send(tree, &cl);
472 req[4] = smb2_close_send(tree, &cl);
473
474 status = smb2_create_recv(req[0], tree, &cr);
475 CHECK_STATUS(status, NT_STATUS_OK);
476 status = smb2_close_recv(req[1], &cl);
477 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
478 status = smb2_close_recv(req[2], &cl);
479 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
480 status = smb2_close_recv(req[3], &cl);
481 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
482 status = smb2_close_recv(req[4], &cl);
483 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
484
485 smb2_util_unlink(tree, fname);
486 done:
487 return ret;
488 }
489
490 /* Send a compound request where we expect the last request (Create, Notify)
491 * to go asynchronous. This works against a Win7 server and the reply is
492 * sent in two different packets. */
493 static bool test_compound_interim1(struct torture_context *tctx,
494 struct smb2_tree *tree)
495 {
496 struct smb2_handle hd;
497 struct smb2_create cr;
498 NTSTATUS status = NT_STATUS_OK;
499 const char *dname = "compound_interim_dir";
500 struct smb2_notify nt;
501 bool ret = true;
502 struct smb2_request *req[2];
503
504 /* Win7 compound request implementation deviates substantially from the
505 * SMB2 spec as noted in MS-SMB2 <159>, <162>. This, test currently
506 * verifies the Windows behavior, not the general spec behavior. */
507 if (!TARGET_IS_WIN7(tctx) && !TARGET_IS_W2K8(tctx)) {
508 torture_skip(tctx, "Interim test is specific to Windows server "
509 "behavior.\n");
510 }
511
512 smb2_transport_credits_ask_num(tree->session->transport, 5);
513
514 smb2_deltree(tree, dname);
515
516 smb2_transport_credits_ask_num(tree->session->transport, 1);
517
518 ZERO_STRUCT(cr);
519 cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
520 cr.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
521 cr.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
522 cr.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
523 NTCREATEX_SHARE_ACCESS_WRITE |
524 NTCREATEX_SHARE_ACCESS_DELETE;
525 cr.in.create_disposition = NTCREATEX_DISP_CREATE;
526 cr.in.fname = dname;
527
528 smb2_transport_compound_start(tree->session->transport, 2);
529
530 req[0] = smb2_create_send(tree, &cr);
531
532 smb2_transport_compound_set_related(tree->session->transport, true);
533
534 hd.data[0] = UINT64_MAX;
535 hd.data[1] = UINT64_MAX;
536
537 ZERO_STRUCT(nt);
538 nt.in.recursive = true;
539 nt.in.buffer_size = 0x1000;
540 nt.in.file.handle = hd;
541 nt.in.completion_filter = FILE_NOTIFY_CHANGE_NAME;
542 nt.in.unknown = 0x00000000;
543
544 req[1] = smb2_notify_send(tree, &nt);
545
546 status = smb2_create_recv(req[0], tree, &cr);
547 CHECK_STATUS(status, NT_STATUS_OK);
548
549 smb2_cancel(req[1]);
550 status = smb2_notify_recv(req[1], tree, &nt);
551 CHECK_STATUS(status, NT_STATUS_CANCELLED);
552
553 smb2_util_close(tree, cr.out.file.handle);
554
555 smb2_deltree(tree, dname);
556 done:
557 return ret;
558 }
559
560 /* Send a compound request where we expect the middle request (Create, Notify,
561 * GetInfo) to go asynchronous. Against Win7 the sync request succeed while
562 * the async fails. All are returned in the same compound response. */
563 static bool test_compound_interim2(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_getinfo gf;
571 struct smb2_notify nt;
572 bool ret = true;
573 struct smb2_request *req[3];
574
575 /* Win7 compound request implementation deviates substantially from the
576 * SMB2 spec as noted in MS-SMB2 <159>, <162>. This, test currently
577 * verifies the Windows behavior, not the general spec behavior. */
578 if (!TARGET_IS_WIN7(tctx) && !TARGET_IS_W2K8(tctx)) {
579 torture_skip(tctx, "Interim test is specific to Windows server "
580 "behavior.\n");
581 }
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, 3);
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 ZERO_STRUCT(gf);
618 gf.in.file.handle = hd;
619 gf.in.info_type = SMB2_GETINFO_FILE;
620 gf.in.info_class = 0x04; /* FILE_BASIC_INFORMATION */
621 gf.in.output_buffer_length = 0x1000;
622 gf.in.input_buffer_length = 0;
623
624 req[2] = smb2_getinfo_send(tree, &gf);
625
626 status = smb2_create_recv(req[0], tree, &cr);
627 CHECK_STATUS(status, NT_STATUS_OK);
628
629 status = smb2_notify_recv(req[1], tree, &nt);
630 CHECK_STATUS(status, NT_STATUS_INTERNAL_ERROR);
631
632 status = smb2_getinfo_recv(req[2], tree, &gf);
633 CHECK_STATUS(status, NT_STATUS_OK);
634
635 smb2_util_close(tree, cr.out.file.handle);
636
637 smb2_deltree(tree, dname);
638 done:
639 return ret;
640 }
641
642 struct torture_suite *torture_smb2_compound_init(void)
643 {
644 struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "compound");
645
646 torture_suite_add_1smb2_test(suite, "related1", test_compound_related1);
647 torture_suite_add_1smb2_test(suite, "related2", test_compound_related2);
648 torture_suite_add_1smb2_test(suite, "unrelated1", test_compound_unrelated1);
649 torture_suite_add_1smb2_test(suite, "invalid1", test_compound_invalid1);
650 torture_suite_add_1smb2_test(suite, "invalid2", test_compound_invalid2);
651 torture_suite_add_1smb2_test(suite, "invalid3", test_compound_invalid3);
652 torture_suite_add_1smb2_test(suite, "interim1", test_compound_interim1);
653 torture_suite_add_1smb2_test(suite, "interim2", test_compound_interim2);
654
655 suite->description = talloc_strdup(suite, "SMB2-COMPOUND tests");
656
657 return suite;
658 }
reg import