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