?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libcli/smb: pass smbXcli_tcon to smb2cli_flush*()
[Samba/gebeck_regimport.git] / source3 / torture / test_smb2.c
bloba511f186471b74b54c2ebe013f3fe31a76f7a98b
1 /*
2 Unix SMB/CIFS implementation.
3 Initial test for the smb2 client lib
4 Copyright (C) Volker Lendecke 2011
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 "torture/proto.h"
22 #include "client.h"
23 #include "trans2.h"
24 #include "../libcli/smb/smbXcli_base.h"
25 #include "libsmb/smb2cli.h"
26 #include "libcli/security/security.h"
27 #include "libsmb/proto.h"
28 #include "auth/gensec/gensec.h"
29 #include "auth_generic.h"
30
31 extern fstring host, workgroup, share, password, username, myname;
32
33 bool run_smb2_basic(int dummy)
34 {
35 struct cli_state *cli;
36 NTSTATUS status;
37 uint64_t fid_persistent, fid_volatile;
38 const char *hello = "Hello, world\n";
39 uint8_t *result;
40 uint32_t nread;
41 uint8_t *dir_data;
42 uint32_t dir_data_length;
43 uint32_t saved_tid = 0;
44 uint64_t saved_uid = 0;
45
46 printf("Starting SMB2-BASIC\n");
47
48 if (!torture_init_connection(&cli)) {
49 return false;
50 }
51 cli->smb2.pid = 0xFEFF;
52
53 status = smbXcli_negprot(cli->conn, cli->timeout,
54 PROTOCOL_SMB2_02, PROTOCOL_SMB2_02);
55 if (!NT_STATUS_IS_OK(status)) {
56 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
57 return false;
58 }
59
60 status = cli_session_setup(cli, username,
61 password, strlen(password),
62 password, strlen(password),
63 workgroup);
64 if (!NT_STATUS_IS_OK(status)) {
65 printf("cli_session_setup returned %s\n", nt_errstr(status));
66 return false;
67 }
68
69 status = cli_tree_connect(cli, share, "?????", "", 0);
70 if (!NT_STATUS_IS_OK(status)) {
71 printf("cli_tree_connect returned %s\n", nt_errstr(status));
72 return false;
73 }
74
75 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
76 cli->smb2.tcon, "smb2-basic.txt",
77 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
78 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
79 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
80 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
81 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
82 FILE_CREATE, /* create_disposition, */
83 FILE_DELETE_ON_CLOSE, /* create_options, */
84 NULL, /* smb2_create_blobs *blobs */
85 &fid_persistent,
86 &fid_volatile);
87 if (!NT_STATUS_IS_OK(status)) {
88 printf("smb2cli_create returned %s\n", nt_errstr(status));
89 return false;
90 }
91
92 status = smb2cli_write(cli->conn, cli->timeout, cli->smb2.session,
93 cli->smb2.tcon, strlen(hello), 0, fid_persistent,
94 fid_volatile, 0, 0, (const uint8_t *)hello);
95 if (!NT_STATUS_IS_OK(status)) {
96 printf("smb2cli_write returned %s\n", nt_errstr(status));
97 return false;
98 }
99
100 status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session,
101 cli->smb2.tcon, fid_persistent, fid_volatile);
102 if (!NT_STATUS_IS_OK(status)) {
103 printf("smb2cli_flush returned %s\n", nt_errstr(status));
104 return false;
105 }
106
107 status = smb2cli_read(cli->conn, cli->timeout, cli->smb2.session,
108 cli->smb2.tcon, 0x10000, 0, fid_persistent,
109 fid_volatile, 2, 0,
110 talloc_tos(), &result, &nread);
111 if (!NT_STATUS_IS_OK(status)) {
112 printf("smb2cli_read returned %s\n", nt_errstr(status));
113 return false;
114 }
115
116 if (nread != strlen(hello)) {
117 printf("smb2cli_read returned %d bytes, expected %d\n",
118 (int)nread, (int)strlen(hello));
119 return false;
120 }
121
122 if (memcmp(hello, result, nread) != 0) {
123 printf("smb2cli_read returned '%s', expected '%s'\n",
124 result, hello);
125 return false;
126 }
127
128 status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session,
129 cli->smb2.tcon, 0, fid_persistent, fid_volatile);
130 if (!NT_STATUS_IS_OK(status)) {
131 printf("smb2cli_close returned %s\n", nt_errstr(status));
132 return false;
133 }
134
135 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
136 cli->smb2.tcon, "",
137 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
138 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
139 SEC_STD_SYNCHRONIZE|
140 SEC_DIR_LIST|
141 SEC_DIR_READ_ATTRIBUTE, /* desired_access, */
142 0, /* file_attributes, */
143 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
144 FILE_OPEN, /* create_disposition, */
145 FILE_SYNCHRONOUS_IO_NONALERT|FILE_DIRECTORY_FILE, /* create_options, */
146 NULL, /* smb2_create_blobs *blobs */
147 &fid_persistent,
148 &fid_volatile);
149 if (!NT_STATUS_IS_OK(status)) {
150 printf("smb2cli_create returned %s\n", nt_errstr(status));
151 return false;
152 }
153
154 status = smb2cli_query_directory(
155 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tid,
156 1, 0, 0, fid_persistent, fid_volatile, "*", 0xffff,
157 talloc_tos(), &dir_data, &dir_data_length);
158
159 if (!NT_STATUS_IS_OK(status)) {
160 printf("smb2cli_query_directory returned %s\n", nt_errstr(status));
161 return false;
162 }
163
164 status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session,
165 cli->smb2.tcon, 0, fid_persistent, fid_volatile);
166 if (!NT_STATUS_IS_OK(status)) {
167 printf("smb2cli_close returned %s\n", nt_errstr(status));
168 return false;
169 }
170
171 saved_tid = cli->smb2.tid;
172 status = smb2cli_tdis(cli);
173 if (!NT_STATUS_IS_OK(status)) {
174 printf("smb2cli_tdis returned %s\n", nt_errstr(status));
175 return false;
176 }
177 cli->smb2.tid = saved_tid;
178
179 status = smb2cli_tdis(cli);
180 if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
181 printf("2nd smb2cli_tdis returned %s\n", nt_errstr(status));
182 return false;
183 }
184
185 saved_uid = smb2cli_session_current_id(cli->smb2.session);
186 status = smb2cli_logoff(cli->conn, cli->timeout, cli->smb2.session);
187 if (!NT_STATUS_IS_OK(status)) {
188 printf("smb2cli_logoff returned %s\n", nt_errstr(status));
189 return false;
190 }
191
192 cli->smb2.session = smbXcli_session_create(cli, cli->conn);
193 if (cli->smb2.session == NULL) {
194 printf("smbXcli_session_create() returned NULL\n");
195 return false;
196 }
197
198 smb2cli_session_set_id_and_flags(cli->smb2.session, saved_uid, 0);
199
200 status = smb2cli_logoff(cli->conn, cli->timeout, cli->smb2.session);
201 if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
202 printf("2nd smb2cli_logoff returned %s\n", nt_errstr(status));
203 return false;
204 }
205
206 return true;
207 }
208
209 bool run_smb2_negprot(int dummy)
210 {
211 struct cli_state *cli;
212 NTSTATUS status;
213 enum protocol_types protocol;
214 const char *name = NULL;
215
216 printf("Starting SMB2-NEGPROT\n");
217
218 if (!torture_init_connection(&cli)) {
219 return false;
220 }
221 cli->smb2.pid = 0xFEFF;
222
223 status = smbXcli_negprot(cli->conn, cli->timeout,
224 PROTOCOL_CORE, PROTOCOL_LATEST);
225 if (!NT_STATUS_IS_OK(status)) {
226 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
227 return false;
228 }
229
230 protocol = smbXcli_conn_protocol(cli->conn);
231
232 switch (protocol) {
233 case PROTOCOL_SMB2_02:
234 name = "SMB2_02";
235 break;
236 case PROTOCOL_SMB2_10:
237 name = "SMB2_10";
238 break;
239 case PROTOCOL_SMB2_22:
240 name = "SMB2_22";
241 break;
242 case PROTOCOL_SMB2_24:
243 name = "SMB2_24";
244 break;
245 case PROTOCOL_SMB3_00:
246 name = "SMB3_00";
247 break;
248 default:
249 break;
250 }
251
252 if (name) {
253 printf("Server supports %s\n", name);
254 } else {
255 printf("Server DOES NOT support SMB2\n");
256 return false;
257 }
258
259 status = smbXcli_negprot(cli->conn, cli->timeout,
260 protocol, protocol);
261 if (!NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_RESET) &&
262 !NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_DISCONNECTED) &&
263 !NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_ABORTED)) {
264 printf("2nd smbXcli_negprot should disconnect - returned %s\n",
265 nt_errstr(status));
266 return false;
267 }
268
269 if (smbXcli_conn_is_connected(cli->conn)) {
270 printf("2nd smbXcli_negprot should disconnect "
271 "- still connected\n");
272 return false;
273 }
274
275 return true;
276 }
277
278 bool run_smb2_session_reconnect(int dummy)
279 {
280 struct cli_state *cli1;
281 struct cli_state *cli2;
282 NTSTATUS status;
283 bool ok;
284 uint64_t fid_persistent, fid_volatile;
285 struct tevent_context *ev;
286 struct tevent_req *subreq;
287 DATA_BLOB in_blob = data_blob_null;
288 DATA_BLOB out_blob;
289 DATA_BLOB session_key;
290 struct auth_generic_state *auth_generic_state;
291 struct iovec *recv_iov;
292 const char *hello = "Hello, world\n";
293 uint8_t *result;
294 uint32_t nread;
295
296 printf("Starting SMB2-SESSION-RECONNECT\n");
297
298 if (!torture_init_connection(&cli1)) {
299 return false;
300 }
301 cli1->smb2.pid = 0xFEFF;
302
303 status = smbXcli_negprot(cli1->conn, cli1->timeout,
304 PROTOCOL_SMB2_02, PROTOCOL_LATEST);
305 if (!NT_STATUS_IS_OK(status)) {
306 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
307 return false;
308 }
309
310 status = cli_session_setup(cli1, username,
311 password, strlen(password),
312 password, strlen(password),
313 workgroup);
314 if (!NT_STATUS_IS_OK(status)) {
315 printf("cli_session_setup returned %s\n", nt_errstr(status));
316 return false;
317 }
318
319 status = cli_tree_connect(cli1, share, "?????", "", 0);
320 if (!NT_STATUS_IS_OK(status)) {
321 printf("cli_tree_connect returned %s\n", nt_errstr(status));
322 return false;
323 }
324
325 status = smb2cli_create(cli1->conn, cli1->timeout, cli1->smb2.session,
326 cli1->smb2.tcon, "session-reconnect.txt",
327 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
328 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
329 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
330 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
331 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
332 FILE_CREATE, /* create_disposition, */
333 FILE_DELETE_ON_CLOSE, /* create_options, */
334 NULL, /* smb2_create_blobs *blobs */
335 &fid_persistent,
336 &fid_volatile);
337 if (!NT_STATUS_IS_OK(status)) {
338 printf("smb2cli_create on cli1 %s\n", nt_errstr(status));
339 return false;
340 }
341
342 status = smb2cli_write(cli1->conn, cli1->timeout, cli1->smb2.session,
343 cli1->smb2.tcon, strlen(hello), 0, fid_persistent,
344 fid_volatile, 0, 0, (const uint8_t *)hello);
345 if (!NT_STATUS_IS_OK(status)) {
346 printf("smb2cli_write returned %s\n", nt_errstr(status));
347 return false;
348 }
349
350 status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session,
351 cli1->smb2.tcon, fid_persistent, fid_volatile);
352 if (!NT_STATUS_IS_OK(status)) {
353 printf("smb2cli_flush returned %s\n", nt_errstr(status));
354 return false;
355 }
356
357 status = smb2cli_read(cli1->conn, cli1->timeout, cli1->smb2.session,
358 cli1->smb2.tcon, 0x10000, 0, fid_persistent,
359 fid_volatile, 2, 0,
360 talloc_tos(), &result, &nread);
361 if (!NT_STATUS_IS_OK(status)) {
362 printf("smb2cli_read returned %s\n", nt_errstr(status));
363 return false;
364 }
365
366 if (nread != strlen(hello)) {
367 printf("smb2cli_read returned %d bytes, expected %d\n",
368 (int)nread, (int)strlen(hello));
369 return false;
370 }
371
372 if (memcmp(hello, result, nread) != 0) {
373 printf("smb2cli_read returned '%s', expected '%s'\n",
374 result, hello);
375 return false;
376 }
377
378 /* prepare second session */
379
380 if (!torture_init_connection(&cli2)) {
381 return false;
382 }
383 cli2->smb2.pid = 0xFEFF;
384
385 status = smbXcli_negprot(cli2->conn, cli2->timeout,
386 PROTOCOL_SMB2_02, PROTOCOL_LATEST);
387 if (!NT_STATUS_IS_OK(status)) {
388 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
389 return false;
390 }
391
392 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
393 if (!NT_STATUS_IS_OK(status)) {
394 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
395 return false;
396 }
397
398 gensec_want_feature(auth_generic_state->gensec_security,
399 GENSEC_FEATURE_SESSION_KEY);
400 status = auth_generic_set_username(auth_generic_state, username);
401 if (!NT_STATUS_IS_OK(status)) {
402 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
403 return false;
404 }
405
406 status = auth_generic_set_domain(auth_generic_state, workgroup);
407 if (!NT_STATUS_IS_OK(status)) {
408 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
409 return false;
410 }
411
412 status = auth_generic_set_password(auth_generic_state, password);
413 if (!NT_STATUS_IS_OK(status)) {
414 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
415 return false;
416 }
417
418 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
419 if (!NT_STATUS_IS_OK(status)) {
420 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
421 return false;
422 }
423
424 ev = event_context_init(talloc_tos());
425 if (ev == NULL) {
426 printf("event_context_init() returned NULL\n");
427 return false;
428 }
429
430 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
431 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
432 printf("gensec_update returned %s\n", nt_errstr(status));
433 return false;
434 }
435
436 cli2->smb2.session = smbXcli_session_create(cli2, cli2->conn);
437
438 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
439 cli2->conn,
440 cli2->timeout,
441 cli2->smb2.session,
442 0x0, /* in_flags */
443 SMB2_CAP_DFS, /* in_capabilities */
444 0, /* in_channel */
445 /* in_previous_session_id: */
446 smb2cli_session_current_id(cli1->smb2.session),
447 &in_blob); /* in_security_buffer */
448 if (subreq == NULL) {
449 printf("smb2cli_session_setup_send() returned NULL\n");
450 return false;
451 }
452
453 ok = tevent_req_poll(subreq, ev);
454 if (!ok) {
455 printf("tevent_req_poll() returned false\n");
456 return false;
457 }
458
459 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
460 NULL, &out_blob);
461 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
462 printf("smb2cli_session_setup_recv returned %s\n",
463 nt_errstr(status));
464 return false;
465 }
466
467 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
468 if (!NT_STATUS_IS_OK(status)) {
469 printf("auth_generic_update returned %s\n", nt_errstr(status));
470 return false;
471 }
472
473 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
474 cli2->conn,
475 cli2->timeout,
476 cli2->smb2.session,
477 0x0, /* in_flags */
478 SMB2_CAP_DFS, /* in_capabilities */
479 0, /* in_channel */
480 /* in_previous_session_id: */
481 smb2cli_session_current_id(cli1->smb2.session),
482 &in_blob); /* in_security_buffer */
483 if (subreq == NULL) {
484 printf("smb2cli_session_setup_send() returned NULL\n");
485 return false;
486 }
487
488 ok = tevent_req_poll(subreq, ev);
489 if (!ok) {
490 printf("tevent_req_poll() returned false\n");
491 return false;
492 }
493
494 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
495 &recv_iov, &out_blob);
496 if (!NT_STATUS_IS_OK(status)) {
497 printf("smb2cli_session_setup_recv returned %s\n",
498 nt_errstr(status));
499 return false;
500 }
501
502 status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(),
503 &session_key);
504 if (!NT_STATUS_IS_OK(status)) {
505 printf("gensec_session_key returned %s\n",
506 nt_errstr(status));
507 return false;
508 }
509
510 /* check file operation on the old client */
511
512 status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session,
513 cli1->smb2.tcon, fid_persistent, fid_volatile);
514 if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
515 printf("smb2cli_flush returned %s\n", nt_errstr(status));
516 return false;
517 }
518
519 status = cli_tree_connect(cli1, share, "?????", "", 0);
520 if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
521 printf("cli_tree_connect returned %s\n", nt_errstr(status));
522 return false;
523 }
524
525 /*
526 * checking file operations without signing.
527 * on w2k8r2 at least, flush, read and write also work the same way,
528 * while create gives ACCESS_DENIED without signing
529 */
530 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
531 cli2->smb2.tcon, fid_persistent, fid_volatile);
532 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) &&
533 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED))
534 {
535 printf("smb2cli_flush returned %s\n", nt_errstr(status));
536 return false;
537 }
538
539 status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session,
540 cli2->smb2.tcon, strlen(hello), 0, fid_persistent,
541 fid_volatile, 0, 0, (const uint8_t *)hello);
542 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) &&
543 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED))
544 {
545 printf("smb2cli_write returned %s\n", nt_errstr(status));
546 return false;
547 }
548
549 status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session,
550 cli2->smb2.tcon, 0x10000, 0, fid_persistent,
551 fid_volatile, 2, 0,
552 talloc_tos(), &result, &nread);
553 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) &&
554 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED))
555 {
556 printf("smb2cli_read returned %s\n", nt_errstr(status));
557 return false;
558 }
559
560 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
561 cli2->smb2.tcon, "session-reconnect.txt",
562 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
563 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
564 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
565 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
566 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
567 FILE_CREATE, /* create_disposition, */
568 FILE_DELETE_ON_CLOSE, /* create_options, */
569 NULL, /* smb2_create_blobs *blobs */
570 &fid_persistent,
571 &fid_volatile);
572 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) &&
573 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
574 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
575 return false;
576 }
577
578 /* now grab the session key and try with signing */
579
580 status = smb2cli_session_set_session_key(cli2->smb2.session,
581 session_key,
582 recv_iov);
583 if (!NT_STATUS_IS_OK(status)) {
584 printf("smb2cli_session_set_session_key %s\n", nt_errstr(status));
585 return false;
586 }
587
588 /* the tid seems to be irrelevant at this stage */
589
590 cli2->smb2.tid = cli1->smb2.tid;
591
592 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
593 cli2->smb2.tcon, fid_persistent, fid_volatile);
594 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) &&
595 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED))
596 {
597 printf("smb2cli_flush returned %s\n", nt_errstr(status));
598 return false;
599 }
600
601 status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session,
602 cli2->smb2.tcon, strlen(hello), 0, fid_persistent,
603 fid_volatile, 0, 0, (const uint8_t *)hello);
604 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) &&
605 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED))
606 {
607 printf("smb2cli_write returned %s\n", nt_errstr(status));
608 return false;
609 }
610
611 status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session,
612 cli2->smb2.tcon, 0x10000, 0, fid_persistent,
613 fid_volatile, 2, 0,
614 talloc_tos(), &result, &nread);
615 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED) &&
616 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED))
617 {
618 printf("smb2cli_read returned %s\n", nt_errstr(status));
619 return false;
620 }
621
622 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
623 cli2->smb2.tcon, "session-reconnect.txt",
624 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
625 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
626 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
627 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
628 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
629 FILE_CREATE, /* create_disposition, */
630 FILE_DELETE_ON_CLOSE, /* create_options, */
631 NULL, /* smb2_create_blobs *blobs */
632 &fid_persistent,
633 &fid_volatile);
634 if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED) &&
635 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED))
636 {
637 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
638 return false;
639 }
640
641 /* now do a new tcon and test file calls again */
642
643 status = cli_tree_connect(cli2, share, "?????", "", 0);
644 if (!NT_STATUS_IS_OK(status)) {
645 printf("cli_tree_connect returned %s\n", nt_errstr(status));
646 return false;
647 }
648
649 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
650 cli2->smb2.tcon, "session-reconnect.txt",
651 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
652 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
653 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
654 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
655 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
656 FILE_CREATE, /* create_disposition, */
657 FILE_DELETE_ON_CLOSE, /* create_options, */
658 NULL, /* smb2_create_blobs *blobs */
659 &fid_persistent,
660 &fid_volatile);
661 if (!NT_STATUS_IS_OK(status)) {
662 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
663 return false;
664 }
665
666 status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session,
667 cli2->smb2.tcon, strlen(hello), 0, fid_persistent,
668 fid_volatile, 0, 0, (const uint8_t *)hello);
669 if (!NT_STATUS_IS_OK(status)) {
670 printf("smb2cli_write returned %s\n", nt_errstr(status));
671 return false;
672 }
673
674 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
675 cli2->smb2.tcon, fid_persistent, fid_volatile);
676 if (!NT_STATUS_IS_OK(status)) {
677 printf("smb2cli_flush returned %s\n", nt_errstr(status));
678 return false;
679 }
680
681 status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session,
682 cli2->smb2.tcon, 0x10000, 0, fid_persistent,
683 fid_volatile, 2, 0,
684 talloc_tos(), &result, &nread);
685 if (!NT_STATUS_IS_OK(status)) {
686 printf("smb2cli_read returned %s\n", nt_errstr(status));
687 return false;
688 }
689
690 if (nread != strlen(hello)) {
691 printf("smb2cli_read returned %d bytes, expected %d\n",
692 (int)nread, (int)strlen(hello));
693 return false;
694 }
695
696 if (memcmp(hello, result, nread) != 0) {
697 printf("smb2cli_read returned '%s', expected '%s'\n",
698 result, hello);
699 return false;
700 }
701
702 return true;
703 }
704
705 bool run_smb2_tcon_dependence(int dummy)
706 {
707 struct cli_state *cli;
708 NTSTATUS status;
709 uint64_t fid_persistent, fid_volatile;
710 const char *hello = "Hello, world\n";
711 uint8_t *result;
712 uint32_t nread;
713 struct smbXcli_tcon *tcon2;
714 uint32_t tcon2_id;
715
716 printf("Starting SMB2-TCON-DEPENDENCE\n");
717
718 if (!torture_init_connection(&cli)) {
719 return false;
720 }
721 cli->smb2.pid = 0xFEFF;
722
723 status = smbXcli_negprot(cli->conn, cli->timeout,
724 PROTOCOL_SMB2_02, PROTOCOL_LATEST);
725 if (!NT_STATUS_IS_OK(status)) {
726 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
727 return false;
728 }
729
730 status = cli_session_setup(cli, username,
731 password, strlen(password),
732 password, strlen(password),
733 workgroup);
734 if (!NT_STATUS_IS_OK(status)) {
735 printf("cli_session_setup returned %s\n", nt_errstr(status));
736 return false;
737 }
738
739 status = cli_tree_connect(cli, share, "?????", "", 0);
740 if (!NT_STATUS_IS_OK(status)) {
741 printf("cli_tree_connect returned %s\n", nt_errstr(status));
742 return false;
743 }
744
745 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
746 cli->smb2.tcon, "tcon_depedence.txt",
747 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
748 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
749 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
750 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
751 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
752 FILE_CREATE, /* create_disposition, */
753 FILE_DELETE_ON_CLOSE, /* create_options, */
754 NULL, /* smb2_create_blobs *blobs */
755 &fid_persistent,
756 &fid_volatile);
757 if (!NT_STATUS_IS_OK(status)) {
758 printf("smb2cli_create on cli %s\n", nt_errstr(status));
759 return false;
760 }
761
762 status = smb2cli_write(cli->conn, cli->timeout, cli->smb2.session,
763 cli->smb2.tcon, strlen(hello), 0, fid_persistent,
764 fid_volatile, 0, 0, (const uint8_t *)hello);
765 if (!NT_STATUS_IS_OK(status)) {
766 printf("smb2cli_write returned %s\n", nt_errstr(status));
767 return false;
768 }
769
770 status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session,
771 cli->smb2.tcon, fid_persistent, fid_volatile);
772 if (!NT_STATUS_IS_OK(status)) {
773 printf("smb2cli_flush returned %s\n", nt_errstr(status));
774 return false;
775 }
776
777 status = smb2cli_read(cli->conn, cli->timeout, cli->smb2.session,
778 cli->smb2.tcon, 0x10000, 0, fid_persistent,
779 fid_volatile, 2, 0,
780 talloc_tos(), &result, &nread);
781 if (!NT_STATUS_IS_OK(status)) {
782 printf("smb2cli_read returned %s\n", nt_errstr(status));
783 return false;
784 }
785
786 if (nread != strlen(hello)) {
787 printf("smb2cli_read returned %d bytes, expected %d\n",
788 (int)nread, (int)strlen(hello));
789 return false;
790 }
791
792 if (memcmp(hello, result, nread) != 0) {
793 printf("smb2cli_read returned '%s', expected '%s'\n",
794 result, hello);
795 return false;
796 }
797
798 /* check behaviour with wrong tid... */
799
800 tcon2 = smbXcli_tcon_create(cli);
801 tcon2_id = smb2cli_tcon_current_id(cli->smb2.tcon);
802 tcon2_id++;
803 smb2cli_tcon_set_values(tcon2,
804 tcon2_id,
805 0, /* type */
806 0, /* flags */
807 0, /* capabilities */
808 0 /* maximal_access */);
809
810 status = smb2cli_read(cli->conn, cli->timeout, cli->smb2.session,
811 tcon2, 0x10000, 0, fid_persistent,
812 fid_volatile, 2, 0,
813 talloc_tos(), &result, &nread);
814 if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
815 printf("smb2cli_read returned %s\n", nt_errstr(status));
816 return false;
817 }
818
819 talloc_free(tcon2);
820
821 return true;
822 }
823
824 bool run_smb2_multi_channel(int dummy)
825 {
826 struct cli_state *cli1;
827 struct cli_state *cli2;
828 struct cli_state *cli3;
829 NTSTATUS status;
830 bool ok;
831 uint64_t fid_persistent, fid_volatile;
832 struct tevent_context *ev;
833 struct tevent_req *subreq;
834 DATA_BLOB in_blob = data_blob_null;
835 DATA_BLOB out_blob;
836 DATA_BLOB channel_session_key;
837 struct auth_generic_state *auth_generic_state;
838 struct iovec *recv_iov;
839 const char *hello = "Hello, world\n";
840 uint8_t *result;
841 uint32_t nread;
842
843 printf("Starting SMB2-MULTI-CHANNEL\n");
844
845 if (!torture_init_connection(&cli1)) {
846 return false;
847 }
848 cli1->smb2.pid = 0xFEFF;
849
850 if (!torture_init_connection(&cli2)) {
851 return false;
852 }
853 cli2->smb2.pid = 0xFEFF;
854
855 if (!torture_init_connection(&cli3)) {
856 return false;
857 }
858 cli3->smb2.pid = 0xFEFF;
859
860 status = smbXcli_negprot(cli1->conn, cli1->timeout,
861 PROTOCOL_SMB2_22, PROTOCOL_LATEST);
862 if (!NT_STATUS_IS_OK(status)) {
863 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
864 return false;
865 }
866
867 status = smbXcli_negprot(cli2->conn, cli2->timeout,
868 PROTOCOL_SMB2_22, PROTOCOL_LATEST);
869 if (!NT_STATUS_IS_OK(status)) {
870 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
871 return false;
872 }
873
874 status = smbXcli_negprot(cli3->conn, cli3->timeout,
875 PROTOCOL_SMB2_22, PROTOCOL_LATEST);
876 if (!NT_STATUS_IS_OK(status)) {
877 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
878 return false;
879 }
880
881 status = cli_session_setup(cli1, username,
882 password, strlen(password),
883 password, strlen(password),
884 workgroup);
885 if (!NT_STATUS_IS_OK(status)) {
886 printf("smb2cli_sesssetup returned %s\n", nt_errstr(status));
887 return false;
888 }
889
890 status = cli_tree_connect(cli1, share, "?????", "", 0);
891 if (!NT_STATUS_IS_OK(status)) {
892 printf("cli_tree_connect returned %s\n", nt_errstr(status));
893 return false;
894 }
895
896 status = smb2cli_session_create_channel(cli2,
897 cli1->smb2.session,
898 cli2->conn,
899 &cli2->smb2.session);
900 if (!NT_STATUS_IS_OK(status)) {
901 printf("smb2cli_session_create_channel returned %s\n",
902 nt_errstr(status));
903 return false;
904 }
905
906 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
907 if (!NT_STATUS_IS_OK(status)) {
908 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
909 return false;
910 }
911
912 gensec_want_feature(auth_generic_state->gensec_security,
913 GENSEC_FEATURE_SESSION_KEY);
914 status = auth_generic_set_username(auth_generic_state, username);
915 if (!NT_STATUS_IS_OK(status)) {
916 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
917 return false;
918 }
919
920 status = auth_generic_set_domain(auth_generic_state, workgroup);
921 if (!NT_STATUS_IS_OK(status)) {
922 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
923 return false;
924 }
925
926 status = auth_generic_set_password(auth_generic_state, password);
927 if (!NT_STATUS_IS_OK(status)) {
928 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
929 return false;
930 }
931
932 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
933 if (!NT_STATUS_IS_OK(status)) {
934 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
935 return false;
936 }
937
938 ev = event_context_init(talloc_tos());
939 if (ev == NULL) {
940 printf("event_context_init() returned NULL\n");
941 return false;
942 }
943
944 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
945 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
946 printf("gensec_update returned %s\n", nt_errstr(status));
947 return false;
948 }
949
950 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
951 cli2->conn,
952 cli2->timeout,
953 cli2->smb2.session,
954 0x01, /* in_flags */
955 SMB2_CAP_DFS, /* in_capabilities */
956 0, /* in_channel */
957 0, /* in_previous_session_id */
958 &in_blob); /* in_security_buffer */
959 if (subreq == NULL) {
960 printf("smb2cli_session_setup_send() returned NULL\n");
961 return false;
962 }
963
964 ok = tevent_req_poll(subreq, ev);
965 if (!ok) {
966 printf("tevent_req_poll() returned false\n");
967 return false;
968 }
969
970 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
971 NULL, &out_blob);
972 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
973 printf("smb2cli_session_setup_recv returned %s\n",
974 nt_errstr(status));
975 return false;
976 }
977
978 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
979 if (!NT_STATUS_IS_OK(status)) {
980 printf("auth_generic_update returned %s\n", nt_errstr(status));
981 return false;
982 }
983
984 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
985 cli2->conn,
986 cli2->timeout,
987 cli2->smb2.session,
988 0x01, /* in_flags */
989 SMB2_CAP_DFS, /* in_capabilities */
990 0, /* in_channel */
991 0, /* in_previous_session_id */
992 &in_blob); /* in_security_buffer */
993 if (subreq == NULL) {
994 printf("smb2cli_session_setup_send() returned NULL\n");
995 return false;
996 }
997
998 ok = tevent_req_poll(subreq, ev);
999 if (!ok) {
1000 printf("tevent_req_poll() returned false\n");
1001 return false;
1002 }
1003
1004 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1005 &recv_iov, &out_blob);
1006 if (!NT_STATUS_IS_OK(status)) {
1007 printf("smb2cli_session_setup_recv returned %s\n",
1008 nt_errstr(status));
1009 return false;
1010 }
1011
1012 status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(),
1013 &channel_session_key);
1014 if (!NT_STATUS_IS_OK(status)) {
1015 printf("gensec_session_key returned %s\n",
1016 nt_errstr(status));
1017 return false;
1018 }
1019
1020 status = smb2cli_session_set_channel_key(cli2->smb2.session,
1021 channel_session_key,
1022 recv_iov);
1023 if (!NT_STATUS_IS_OK(status)) {
1024 printf("smb2cli_session_set_channel_key %s\n", nt_errstr(status));
1025 return false;
1026 }
1027
1028 cli2->smb2.tid = cli1->smb2.tid;
1029
1030 status = smb2cli_session_create_channel(cli3,
1031 cli1->smb2.session,
1032 cli3->conn,
1033 &cli3->smb2.session);
1034 if (!NT_STATUS_IS_OK(status)) {
1035 printf("smb2cli_session_create_channel returned %s\n",
1036 nt_errstr(status));
1037 return false;
1038 }
1039
1040 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
1041 if (!NT_STATUS_IS_OK(status)) {
1042 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
1043 return false;
1044 }
1045
1046 gensec_want_feature(auth_generic_state->gensec_security,
1047 GENSEC_FEATURE_SESSION_KEY);
1048 status = auth_generic_set_username(auth_generic_state, username);
1049 if (!NT_STATUS_IS_OK(status)) {
1050 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
1051 return false;
1052 }
1053
1054 status = auth_generic_set_domain(auth_generic_state, workgroup);
1055 if (!NT_STATUS_IS_OK(status)) {
1056 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
1057 return false;
1058 }
1059
1060 status = auth_generic_set_password(auth_generic_state, password);
1061 if (!NT_STATUS_IS_OK(status)) {
1062 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
1063 return false;
1064 }
1065
1066 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
1067 if (!NT_STATUS_IS_OK(status)) {
1068 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
1069 return false;
1070 }
1071
1072 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
1073 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1074 printf("gensec_update returned %s\n", nt_errstr(status));
1075 return false;
1076 }
1077
1078 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1079 cli3->conn,
1080 cli3->timeout,
1081 cli3->smb2.session,
1082 0x01, /* in_flags */
1083 SMB2_CAP_DFS, /* in_capabilities */
1084 0, /* in_channel */
1085 0, /* in_previous_session_id */
1086 &in_blob); /* in_security_buffer */
1087 if (subreq == NULL) {
1088 printf("smb2cli_session_setup_send() returned NULL\n");
1089 return false;
1090 }
1091
1092 ok = tevent_req_poll(subreq, ev);
1093 if (!ok) {
1094 printf("tevent_req_poll() returned false\n");
1095 return false;
1096 }
1097
1098 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1099 NULL, &out_blob);
1100 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1101 printf("smb2cli_session_setup_recv returned %s\n",
1102 nt_errstr(status));
1103 return false;
1104 }
1105
1106 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
1107 if (!NT_STATUS_IS_OK(status)) {
1108 printf("auth_generic_update returned %s\n", nt_errstr(status));
1109 return false;
1110 }
1111
1112 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1113 cli3->conn,
1114 cli3->timeout,
1115 cli3->smb2.session,
1116 0x01, /* in_flags */
1117 SMB2_CAP_DFS, /* in_capabilities */
1118 0, /* in_channel */
1119 0, /* in_previous_session_id */
1120 &in_blob); /* in_security_buffer */
1121 if (subreq == NULL) {
1122 printf("smb2cli_session_setup_send() returned NULL\n");
1123 return false;
1124 }
1125
1126 ok = tevent_req_poll(subreq, ev);
1127 if (!ok) {
1128 printf("tevent_req_poll() returned false\n");
1129 return false;
1130 }
1131
1132 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1133 &recv_iov, &out_blob);
1134 if (!NT_STATUS_IS_OK(status)) {
1135 printf("smb2cli_session_setup_recv returned %s\n",
1136 nt_errstr(status));
1137 return false;
1138 }
1139
1140 status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(),
1141 &channel_session_key);
1142 if (!NT_STATUS_IS_OK(status)) {
1143 printf("gensec_session_key returned %s\n",
1144 nt_errstr(status));
1145 return false;
1146 }
1147
1148 status = smb2cli_session_set_channel_key(cli3->smb2.session,
1149 channel_session_key,
1150 recv_iov);
1151 if (!NT_STATUS_IS_OK(status)) {
1152 printf("smb2cli_session_set_channel_key %s\n", nt_errstr(status));
1153 return false;
1154 }
1155
1156 cli3->smb2.tid = cli2->smb2.tid;
1157
1158 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
1159 cli2->smb2.tcon, "multi-channel.txt",
1160 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1161 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1162 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1163 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1164 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1165 FILE_CREATE, /* create_disposition, */
1166 FILE_DELETE_ON_CLOSE, /* create_options, */
1167 NULL, /* smb2_create_blobs *blobs */
1168 &fid_persistent,
1169 &fid_volatile);
1170 if (!NT_STATUS_IS_OK(status)) {
1171 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
1172 return false;
1173 }
1174
1175 status = smb2cli_write(cli1->conn, cli1->timeout, cli1->smb2.session,
1176 cli1->smb2.tcon, strlen(hello), 0, fid_persistent,
1177 fid_volatile, 0, 0, (const uint8_t *)hello);
1178 if (!NT_STATUS_IS_OK(status)) {
1179 printf("smb2cli_write returned %s\n", nt_errstr(status));
1180 return false;
1181 }
1182
1183 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
1184 cli2->smb2.tcon, fid_persistent, fid_volatile);
1185 if (!NT_STATUS_IS_OK(status)) {
1186 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1187 return false;
1188 }
1189
1190 status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session,
1191 cli1->smb2.tcon, fid_persistent, fid_volatile);
1192 if (!NT_STATUS_IS_OK(status)) {
1193 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1194 return false;
1195 }
1196
1197 status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session,
1198 cli3->smb2.tcon, fid_persistent, fid_volatile);
1199 if (!NT_STATUS_IS_OK(status)) {
1200 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1201 return false;
1202 }
1203
1204 status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session,
1205 cli2->smb2.tcon, 0x10000, 0, fid_persistent,
1206 fid_volatile, 2, 0,
1207 talloc_tos(), &result, &nread);
1208 if (!NT_STATUS_IS_OK(status)) {
1209 printf("smb2cli_read returned %s\n", nt_errstr(status));
1210 return false;
1211 }
1212
1213 if (nread != strlen(hello)) {
1214 printf("smb2cli_read returned %d bytes, expected %d\n",
1215 (int)nread, (int)strlen(hello));
1216 return false;
1217 }
1218
1219 if (memcmp(hello, result, nread) != 0) {
1220 printf("smb2cli_read returned '%s', expected '%s'\n",
1221 result, hello);
1222 return false;
1223 }
1224
1225 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
1226 if (!NT_STATUS_IS_OK(status)) {
1227 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
1228 return false;
1229 }
1230
1231 gensec_want_feature(auth_generic_state->gensec_security,
1232 GENSEC_FEATURE_SESSION_KEY);
1233 status = auth_generic_set_username(auth_generic_state, username);
1234 if (!NT_STATUS_IS_OK(status)) {
1235 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
1236 return false;
1237 }
1238
1239 status = auth_generic_set_domain(auth_generic_state, workgroup);
1240 if (!NT_STATUS_IS_OK(status)) {
1241 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
1242 return false;
1243 }
1244
1245 status = auth_generic_set_password(auth_generic_state, password);
1246 if (!NT_STATUS_IS_OK(status)) {
1247 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
1248 return false;
1249 }
1250
1251 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
1252 if (!NT_STATUS_IS_OK(status)) {
1253 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
1254 return false;
1255 }
1256
1257 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
1258 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1259 printf("gensec_update returned %s\n", nt_errstr(status));
1260 return false;
1261 }
1262
1263 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1264 cli3->conn,
1265 cli3->timeout,
1266 cli3->smb2.session,
1267 0x0, /* in_flags */
1268 SMB2_CAP_DFS, /* in_capabilities */
1269 0, /* in_channel */
1270 0, /* in_previous_session_id */
1271 &in_blob); /* in_security_buffer */
1272 if (subreq == NULL) {
1273 printf("smb2cli_session_setup_send() returned NULL\n");
1274 return false;
1275 }
1276
1277 ok = tevent_req_poll(subreq, ev);
1278 if (!ok) {
1279 printf("tevent_req_poll() returned false\n");
1280 return false;
1281 }
1282
1283 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1284 NULL, &out_blob);
1285 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1286 printf("smb2cli_session_setup_recv returned %s\n",
1287 nt_errstr(status));
1288 return false;
1289 }
1290
1291 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
1292 if (!NT_STATUS_IS_OK(status)) {
1293 printf("auth_generic_update returned %s\n", nt_errstr(status));
1294 return false;
1295 }
1296
1297 status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session,
1298 cli1->smb2.tcon, fid_persistent, fid_volatile);
1299 if (!NT_STATUS_IS_OK(status)) {
1300 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1301 return false;
1302 }
1303
1304 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
1305 cli2->smb2.tcon, fid_persistent, fid_volatile);
1306 if (!NT_STATUS_IS_OK(status)) {
1307 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1308 return false;
1309 }
1310
1311 status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session,
1312 cli3->smb2.tcon, fid_persistent, fid_volatile);
1313 if (!NT_STATUS_IS_OK(status)) {
1314 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1315 return false;
1316 }
1317
1318 status = smb2cli_create(cli1->conn, cli1->timeout, cli1->smb2.session,
1319 cli1->smb2.tcon, "multi-channel-invalid.txt",
1320 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1321 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1322 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1323 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1324 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1325 FILE_CREATE, /* create_disposition, */
1326 FILE_DELETE_ON_CLOSE, /* create_options, */
1327 NULL, /* smb2_create_blobs *blobs */
1328 &fid_persistent,
1329 &fid_volatile);
1330 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1331 printf("smb2cli_create %s\n", nt_errstr(status));
1332 return false;
1333 }
1334
1335 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
1336 cli2->smb2.tcon, "multi-channel-invalid.txt",
1337 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1338 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1339 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1340 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1341 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1342 FILE_CREATE, /* create_disposition, */
1343 FILE_DELETE_ON_CLOSE, /* create_options, */
1344 NULL, /* smb2_create_blobs *blobs */
1345 &fid_persistent,
1346 &fid_volatile);
1347 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1348 printf("smb2cli_create %s\n", nt_errstr(status));
1349 return false;
1350 }
1351
1352 status = smb2cli_create(cli3->conn, cli3->timeout, cli3->smb2.session,
1353 cli3->smb2.tcon, "multi-channel-invalid.txt",
1354 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1355 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1356 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1357 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1358 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1359 FILE_CREATE, /* create_disposition, */
1360 FILE_DELETE_ON_CLOSE, /* create_options, */
1361 NULL, /* smb2_create_blobs *blobs */
1362 &fid_persistent,
1363 &fid_volatile);
1364 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1365 printf("smb2cli_create %s\n", nt_errstr(status));
1366 return false;
1367 }
1368
1369 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1370 cli2->conn,
1371 cli2->timeout,
1372 cli2->smb2.session,
1373 0x0, /* in_flags */
1374 SMB2_CAP_DFS, /* in_capabilities */
1375 0, /* in_channel */
1376 0, /* in_previous_session_id */
1377 &in_blob); /* in_security_buffer */
1378 if (subreq == NULL) {
1379 printf("smb2cli_session_setup_send() returned NULL\n");
1380 return false;
1381 }
1382
1383 ok = tevent_req_poll(subreq, ev);
1384 if (!ok) {
1385 printf("tevent_req_poll() returned false\n");
1386 return false;
1387 }
1388
1389 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1390 &recv_iov, &out_blob);
1391 if (!NT_STATUS_IS_OK(status)) {
1392 printf("smb2cli_session_setup_recv returned %s\n",
1393 nt_errstr(status));
1394 return false;
1395 }
1396
1397 status = smb2cli_close(cli3->conn, cli3->timeout, cli3->smb2.session,
1398 cli3->smb2.tcon, 0, fid_persistent, fid_volatile);
1399 if (!NT_STATUS_IS_OK(status)) {
1400 printf("smb2cli_close returned %s\n", nt_errstr(status));
1401 return false;
1402 }
1403
1404 status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session,
1405 cli3->smb2.tcon, fid_persistent, fid_volatile);
1406 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
1407 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1408 return false;
1409 }
1410
1411 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
1412 cli2->smb2.tcon, fid_persistent, fid_volatile);
1413 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
1414 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1415 return false;
1416 }
1417
1418 status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session,
1419 cli1->smb2.tcon, fid_persistent, fid_volatile);
1420 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
1421 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1422 return false;
1423 }
1424
1425 return true;
1426 }
1427
1428 bool run_smb2_session_reauth(int dummy)
1429 {
1430 struct cli_state *cli;
1431 NTSTATUS status;
1432 bool ok;
1433 uint64_t fid_persistent, fid_volatile;
1434 uint64_t dir_persistent, dir_volatile;
1435 uint8_t *dir_data;
1436 uint32_t dir_data_length;
1437 struct tevent_context *ev;
1438 struct tevent_req *subreq;
1439 DATA_BLOB in_blob = data_blob_null;
1440 DATA_BLOB out_blob;
1441 DATA_BLOB in_input_buffer;
1442 DATA_BLOB out_output_buffer;
1443 uint8_t in_file_info_class;
1444 struct auth_generic_state *auth_generic_state;
1445 struct iovec *recv_iov;
1446 uint32_t saved_tid;
1447
1448 printf("Starting SMB2-SESSION_REAUTH\n");
1449
1450 if (!torture_init_connection(&cli)) {
1451 return false;
1452 }
1453 cli->smb2.pid = 0xFEFF;
1454
1455 /*
1456 * PROTOCOL_SMB2_22 has a bug in win8pre0
1457 * it behaves like PROTOCOL_SMB2_02
1458 * and returns NT_STATUS_REQUEST_NOT_ACCEPTED,
1459 * while it allows it on PROTOCOL_SMB2_02.
1460 */
1461 status = smbXcli_negprot(cli->conn, cli->timeout,
1462 PROTOCOL_SMB2_10, PROTOCOL_SMB2_10);
1463 if (!NT_STATUS_IS_OK(status)) {
1464 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
1465 return false;
1466 }
1467
1468 status = cli_session_setup(cli, username,
1469 password, strlen(password),
1470 password, strlen(password),
1471 workgroup);
1472 if (!NT_STATUS_IS_OK(status)) {
1473 printf("smb2cli_sesssetup returned %s\n", nt_errstr(status));
1474 return false;
1475 }
1476
1477 status = cli_tree_connect(cli, share, "?????", "", 0);
1478 if (!NT_STATUS_IS_OK(status)) {
1479 printf("cli_tree_connect returned %s\n", nt_errstr(status));
1480 return false;
1481 }
1482
1483 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1484 cli->smb2.tcon, "session-reauth.txt",
1485 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1486 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1487 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1488 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1489 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1490 FILE_CREATE, /* create_disposition, */
1491 FILE_DELETE_ON_CLOSE, /* create_options, */
1492 NULL, /* smb2_create_blobs *blobs */
1493 &fid_persistent,
1494 &fid_volatile);
1495 if (!NT_STATUS_IS_OK(status)) {
1496 printf("smb2cli_create %s\n", nt_errstr(status));
1497 return false;
1498 }
1499
1500 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1501 cli->smb2.tcon, "",
1502 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1503 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1504 SEC_STD_SYNCHRONIZE|
1505 SEC_DIR_LIST|
1506 SEC_DIR_READ_ATTRIBUTE, /* desired_access, */
1507 0, /* file_attributes, */
1508 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1509 FILE_OPEN, /* create_disposition, */
1510 FILE_SYNCHRONOUS_IO_NONALERT|FILE_DIRECTORY_FILE, /* create_options, */
1511 NULL, /* smb2_create_blobs *blobs */
1512 &dir_persistent,
1513 &dir_volatile);
1514 if (!NT_STATUS_IS_OK(status)) {
1515 printf("smb2cli_create returned %s\n", nt_errstr(status));
1516 return false;
1517 }
1518
1519 status = smb2cli_query_directory(
1520 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tid,
1521 1, 0x3, 0, dir_persistent, dir_volatile,
1522 "session-reauth.txt", 0xffff,
1523 talloc_tos(), &dir_data, &dir_data_length);
1524 if (!NT_STATUS_IS_OK(status)) {
1525 printf("smb2cli_query_directory returned %s\n", nt_errstr(status));
1526 return false;
1527 }
1528
1529 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
1530 if (!NT_STATUS_IS_OK(status)) {
1531 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
1532 return false;
1533 }
1534
1535 gensec_want_feature(auth_generic_state->gensec_security,
1536 GENSEC_FEATURE_SESSION_KEY);
1537 status = auth_generic_set_username(auth_generic_state, username);
1538 if (!NT_STATUS_IS_OK(status)) {
1539 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
1540 return false;
1541 }
1542
1543 status = auth_generic_set_domain(auth_generic_state, workgroup);
1544 if (!NT_STATUS_IS_OK(status)) {
1545 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
1546 return false;
1547 }
1548
1549 status = auth_generic_set_password(auth_generic_state, password);
1550 if (!NT_STATUS_IS_OK(status)) {
1551 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
1552 return false;
1553 }
1554
1555 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
1556 if (!NT_STATUS_IS_OK(status)) {
1557 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
1558 return false;
1559 }
1560
1561 ev = event_context_init(talloc_tos());
1562 if (ev == NULL) {
1563 printf("event_context_init() returned NULL\n");
1564 return false;
1565 }
1566
1567 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
1568 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1569 printf("gensec_update returned %s\n", nt_errstr(status));
1570 return false;
1571 }
1572
1573 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1574 cli->conn,
1575 cli->timeout,
1576 cli->smb2.session,
1577 0x0, /* in_flags */
1578 SMB2_CAP_DFS, /* in_capabilities */
1579 0, /* in_channel */
1580 0, /* in_previous_session_id */
1581 &in_blob); /* in_security_buffer */
1582 if (subreq == NULL) {
1583 printf("smb2cli_session_setup_send() returned NULL\n");
1584 return false;
1585 }
1586
1587 ok = tevent_req_poll(subreq, ev);
1588 if (!ok) {
1589 printf("tevent_req_poll() returned false\n");
1590 return false;
1591 }
1592
1593 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1594 NULL, &out_blob);
1595 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1596 printf("smb2cli_session_setup_recv returned %s\n",
1597 nt_errstr(status));
1598 return false;
1599 }
1600
1601 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
1602 if (!NT_STATUS_IS_OK(status)) {
1603 printf("auth_generic_update returned %s\n", nt_errstr(status));
1604 return false;
1605 }
1606
1607 status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session,
1608 cli->smb2.tcon, fid_persistent, fid_volatile);
1609 if (!NT_STATUS_IS_OK(status)) {
1610 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1611 return false;
1612 }
1613
1614 status = smb2cli_query_directory(
1615 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tid,
1616 1, 0x3, 0, dir_persistent, dir_volatile,
1617 "session-reauth.txt", 0xffff,
1618 talloc_tos(), &dir_data, &dir_data_length);
1619 if (!NT_STATUS_IS_OK(status)) {
1620 printf("smb2cli_query_directory returned %s\n", nt_errstr(status));
1621 return false;
1622 }
1623
1624 /*
1625 * query_info seems to be a path based operation on Windows...
1626 */
1627 status = smb2cli_query_info(cli->conn,
1628 cli->timeout,
1629 cli->smb2.session,
1630 cli->smb2.tid,
1631 SMB2_GETINFO_SECURITY,
1632 0, /* in_file_info_class */
1633 1024, /* in_max_output_length */
1634 NULL, /* in_input_buffer */
1635 SECINFO_OWNER, /* in_additional_info */
1636 0, /* in_flags */
1637 fid_persistent,
1638 fid_volatile,
1639 talloc_tos(),
1640 &out_output_buffer);
1641 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1642 printf("smb2cli_query_info (security) returned %s\n", nt_errstr(status));
1643 return false;
1644 }
1645
1646 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1647 status = smb2cli_query_info(cli->conn,
1648 cli->timeout,
1649 cli->smb2.session,
1650 cli->smb2.tid,
1651 SMB2_GETINFO_FILE,
1652 in_file_info_class,
1653 1024, /* in_max_output_length */
1654 NULL, /* in_input_buffer */
1655 0, /* in_additional_info */
1656 0, /* in_flags */
1657 fid_persistent,
1658 fid_volatile,
1659 talloc_tos(),
1660 &out_output_buffer);
1661 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1662 printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status));
1663 return false;
1664 }
1665
1666 in_input_buffer = data_blob_talloc(talloc_tos(), NULL, 8);
1667 SBVAL(in_input_buffer.data, 0, 512);
1668
1669 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1670 status = smb2cli_set_info(cli->conn,
1671 cli->timeout,
1672 cli->smb2.session,
1673 cli->smb2.tid,
1674 SMB2_GETINFO_FILE,
1675 in_file_info_class,
1676 &in_input_buffer,
1677 0, /* in_additional_info */
1678 fid_persistent,
1679 fid_volatile);
1680 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1681 printf("smb2cli_set_info (position) returned %s\n", nt_errstr(status));
1682 return false;
1683 }
1684
1685 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1686 cli->smb2.tcon, "session-reauth-invalid.txt",
1687 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1688 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1689 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1690 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1691 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1692 FILE_CREATE, /* create_disposition, */
1693 FILE_DELETE_ON_CLOSE, /* create_options, */
1694 NULL, /* smb2_create_blobs *blobs */
1695 &fid_persistent,
1696 &fid_volatile);
1697 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1698 printf("smb2cli_create %s\n", nt_errstr(status));
1699 return false;
1700 }
1701
1702 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1703 cli->smb2.tcon, "",
1704 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1705 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1706 SEC_STD_SYNCHRONIZE|
1707 SEC_DIR_LIST|
1708 SEC_DIR_READ_ATTRIBUTE, /* desired_access, */
1709 0, /* file_attributes, */
1710 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1711 FILE_OPEN, /* create_disposition, */
1712 FILE_SYNCHRONOUS_IO_NONALERT|FILE_DIRECTORY_FILE, /* create_options, */
1713 NULL, /* smb2_create_blobs *blobs */
1714 &dir_persistent,
1715 &dir_volatile);
1716 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1717 printf("smb2cli_create returned %s\n", nt_errstr(status));
1718 return false;
1719 }
1720
1721 saved_tid = cli->smb2.tid;
1722 status = cli_tree_connect(cli, share, "?????", "", 0);
1723 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1724 printf("cli_tree_connect returned %s\n", nt_errstr(status));
1725 return false;
1726 }
1727 cli->smb2.tid = saved_tid;
1728
1729 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1730 cli->conn,
1731 cli->timeout,
1732 cli->smb2.session,
1733 0x0, /* in_flags */
1734 SMB2_CAP_DFS, /* in_capabilities */
1735 0, /* in_channel */
1736 0, /* in_previous_session_id */
1737 &in_blob); /* in_security_buffer */
1738 if (subreq == NULL) {
1739 printf("smb2cli_session_setup_send() returned NULL\n");
1740 return false;
1741 }
1742
1743 ok = tevent_req_poll(subreq, ev);
1744 if (!ok) {
1745 printf("tevent_req_poll() returned false\n");
1746 return false;
1747 }
1748
1749 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1750 &recv_iov, &out_blob);
1751 if (!NT_STATUS_IS_OK(status)) {
1752 printf("smb2cli_session_setup_recv returned %s\n",
1753 nt_errstr(status));
1754 return false;
1755 }
1756
1757 status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session,
1758 cli->smb2.tcon, fid_persistent, fid_volatile);
1759 if (!NT_STATUS_IS_OK(status)) {
1760 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1761 return false;
1762 }
1763
1764 status = smb2cli_query_info(cli->conn,
1765 cli->timeout,
1766 cli->smb2.session,
1767 cli->smb2.tid,
1768 SMB2_GETINFO_SECURITY,
1769 0, /* in_file_info_class */
1770 1024, /* in_max_output_length */
1771 NULL, /* in_input_buffer */
1772 SECINFO_OWNER, /* in_additional_info */
1773 0, /* in_flags */
1774 fid_persistent,
1775 fid_volatile,
1776 talloc_tos(),
1777 &out_output_buffer);
1778 if (!NT_STATUS_IS_OK(status)) {
1779 printf("smb2cli_query_info (security) returned %s\n", nt_errstr(status));
1780 return false;
1781 }
1782
1783 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1784 status = smb2cli_query_info(cli->conn,
1785 cli->timeout,
1786 cli->smb2.session,
1787 cli->smb2.tid,
1788 SMB2_GETINFO_FILE,
1789 in_file_info_class,
1790 1024, /* in_max_output_length */
1791 NULL, /* in_input_buffer */
1792 0, /* in_additional_info */
1793 0, /* in_flags */
1794 fid_persistent,
1795 fid_volatile,
1796 talloc_tos(),
1797 &out_output_buffer);
1798 if (!NT_STATUS_IS_OK(status)) {
1799 printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status));
1800 return false;
1801 }
1802
1803 in_input_buffer = data_blob_talloc(talloc_tos(), NULL, 8);
1804 SBVAL(in_input_buffer.data, 0, 512);
1805
1806 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1807 status = smb2cli_set_info(cli->conn,
1808 cli->timeout,
1809 cli->smb2.session,
1810 cli->smb2.tid,
1811 SMB2_GETINFO_FILE,
1812 in_file_info_class,
1813 &in_input_buffer,
1814 0, /* in_additional_info */
1815 fid_persistent,
1816 fid_volatile);
1817 if (!NT_STATUS_IS_OK(status)) {
1818 printf("smb2cli_set_info (position) returned %s\n", nt_errstr(status));
1819 return false;
1820 }
1821
1822 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1823 status = smb2cli_query_info(cli->conn,
1824 cli->timeout,
1825 cli->smb2.session,
1826 cli->smb2.tid,
1827 SMB2_GETINFO_FILE,
1828 in_file_info_class,
1829 1024, /* in_max_output_length */
1830 NULL, /* in_input_buffer */
1831 0, /* in_additional_info */
1832 0, /* in_flags */
1833 fid_persistent,
1834 fid_volatile,
1835 talloc_tos(),
1836 &out_output_buffer);
1837 if (!NT_STATUS_IS_OK(status)) {
1838 printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status));
1839 return false;
1840 }
1841
1842 status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session,
1843 cli->smb2.tcon, 0, fid_persistent, fid_volatile);
1844 if (!NT_STATUS_IS_OK(status)) {
1845 printf("smb2cli_close returned %s\n", nt_errstr(status));
1846 return false;
1847 }
1848
1849 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1850 cli->smb2.tcon, "session-reauth.txt",
1851 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1852 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1853 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1854 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1855 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1856 FILE_CREATE, /* create_disposition, */
1857 FILE_DELETE_ON_CLOSE, /* create_options, */
1858 NULL, /* smb2_create_blobs *blobs */
1859 &fid_persistent,
1860 &fid_volatile);
1861 if (!NT_STATUS_IS_OK(status)) {
1862 printf("smb2cli_create %s\n", nt_errstr(status));
1863 return false;
1864 }
1865
1866 status = smb2cli_query_directory(
1867 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tid,
1868 1, 0x3, 0, dir_persistent, dir_volatile,
1869 "session-reauth.txt", 0xffff,
1870 talloc_tos(), &dir_data, &dir_data_length);
1871 if (!NT_STATUS_IS_OK(status)) {
1872 printf("smb2cli_query_directory returned %s\n", nt_errstr(status));
1873 return false;
1874 }
1875
1876 status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session,
1877 cli->smb2.tcon, 0, dir_persistent, dir_volatile);
1878 if (!NT_STATUS_IS_OK(status)) {
1879 printf("smb2cli_close returned %s\n", nt_errstr(status));
1880 return false;
1881 }
1882
1883 status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session,
1884 cli->smb2.tcon, 0, fid_persistent, fid_volatile);
1885 if (!NT_STATUS_IS_OK(status)) {
1886 printf("smb2cli_close returned %s\n", nt_errstr(status));
1887 return false;
1888 }
1889
1890 saved_tid = cli->smb2.tid;
1891 status = cli_tree_connect(cli, share, "?????", "", 0);
1892 if (!NT_STATUS_IS_OK(status)) {
1893 printf("cli_tree_connect returned %s\n", nt_errstr(status));
1894 return false;
1895 }
1896 cli->smb2.tid = saved_tid;
1897
1898 return true;
1899 }
reg import