?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:smbd: change blocking.c to use fsp_fnum_dbg() for fsp->fnum logging.
[Samba/gebeck_regimport.git] / source3 / torture / test_smb2.c
blob8aff588cc7e6595ea6f289f644f06a8126701143
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.tid, "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.tid, 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.tid, 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.tid, 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.tid, 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.tid, "",
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.tid, 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.tid, "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.tid, 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.tid, 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.tid, 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.tid, 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.tid, fid_persistent, fid_volatile);
532 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
533 printf("smb2cli_flush returned %s\n", nt_errstr(status));
534 return false;
535 }
536
537 status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session,
538 cli2->smb2.tid, strlen(hello), 0, fid_persistent,
539 fid_volatile, 0, 0, (const uint8_t *)hello);
540 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
541 printf("smb2cli_write returned %s\n", nt_errstr(status));
542 return false;
543 }
544
545 status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session,
546 cli2->smb2.tid, 0x10000, 0, fid_persistent,
547 fid_volatile, 2, 0,
548 talloc_tos(), &result, &nread);
549 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
550 printf("smb2cli_read returned %s\n", nt_errstr(status));
551 return false;
552 }
553
554 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
555 cli2->smb2.tid, "session-reconnect.txt",
556 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
557 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
558 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
559 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
560 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
561 FILE_CREATE, /* create_disposition, */
562 FILE_DELETE_ON_CLOSE, /* create_options, */
563 NULL, /* smb2_create_blobs *blobs */
564 &fid_persistent,
565 &fid_volatile);
566 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) &&
567 !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
568 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
569 return false;
570 }
571
572 /* now grab the session key and try with signing */
573
574 status = smb2cli_session_set_session_key(cli2->smb2.session,
575 session_key,
576 recv_iov);
577 if (!NT_STATUS_IS_OK(status)) {
578 printf("smb2cli_session_set_session_key %s\n", nt_errstr(status));
579 return false;
580 }
581
582 /* the tid seems to be irrelevant at this stage */
583
584 cli2->smb2.tid = cli1->smb2.tid;
585
586 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
587 cli2->smb2.tid, fid_persistent, fid_volatile);
588 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
589 printf("smb2cli_flush returned %s\n", nt_errstr(status));
590 return false;
591 }
592
593 status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session,
594 cli2->smb2.tid, strlen(hello), 0, fid_persistent,
595 fid_volatile, 0, 0, (const uint8_t *)hello);
596 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
597 printf("smb2cli_write returned %s\n", nt_errstr(status));
598 return false;
599 }
600
601 status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session,
602 cli2->smb2.tid, 0x10000, 0, fid_persistent,
603 fid_volatile, 2, 0,
604 talloc_tos(), &result, &nread);
605 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
606 printf("smb2cli_read returned %s\n", nt_errstr(status));
607 return false;
608 }
609
610 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
611 cli2->smb2.tid, "session-reconnect.txt",
612 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
613 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
614 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
615 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
616 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
617 FILE_CREATE, /* create_disposition, */
618 FILE_DELETE_ON_CLOSE, /* create_options, */
619 NULL, /* smb2_create_blobs *blobs */
620 &fid_persistent,
621 &fid_volatile);
622 if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
623 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
624 return false;
625 }
626
627 /* now do a new tcon and test file calls again */
628
629 status = cli_tree_connect(cli2, share, "?????", "", 0);
630 if (!NT_STATUS_IS_OK(status)) {
631 printf("cli_tree_connect returned %s\n", nt_errstr(status));
632 return false;
633 }
634
635 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
636 cli2->smb2.tid, "session-reconnect.txt",
637 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
638 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
639 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
640 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
641 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
642 FILE_CREATE, /* create_disposition, */
643 FILE_DELETE_ON_CLOSE, /* create_options, */
644 NULL, /* smb2_create_blobs *blobs */
645 &fid_persistent,
646 &fid_volatile);
647 if (!NT_STATUS_IS_OK(status)) {
648 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
649 return false;
650 }
651
652 status = smb2cli_write(cli2->conn, cli2->timeout, cli2->smb2.session,
653 cli2->smb2.tid, strlen(hello), 0, fid_persistent,
654 fid_volatile, 0, 0, (const uint8_t *)hello);
655 if (!NT_STATUS_IS_OK(status)) {
656 printf("smb2cli_write returned %s\n", nt_errstr(status));
657 return false;
658 }
659
660 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
661 cli2->smb2.tid, fid_persistent, fid_volatile);
662 if (!NT_STATUS_IS_OK(status)) {
663 printf("smb2cli_flush returned %s\n", nt_errstr(status));
664 return false;
665 }
666
667 status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session,
668 cli2->smb2.tid, 0x10000, 0, fid_persistent,
669 fid_volatile, 2, 0,
670 talloc_tos(), &result, &nread);
671 if (!NT_STATUS_IS_OK(status)) {
672 printf("smb2cli_read returned %s\n", nt_errstr(status));
673 return false;
674 }
675
676 if (nread != strlen(hello)) {
677 printf("smb2cli_read returned %d bytes, expected %d\n",
678 (int)nread, (int)strlen(hello));
679 return false;
680 }
681
682 if (memcmp(hello, result, nread) != 0) {
683 printf("smb2cli_read returned '%s', expected '%s'\n",
684 result, hello);
685 return false;
686 }
687
688 return true;
689 }
690
691 bool run_smb2_tcon_dependence(int dummy)
692 {
693 struct cli_state *cli;
694 NTSTATUS status;
695 uint64_t fid_persistent, fid_volatile;
696 const char *hello = "Hello, world\n";
697 uint8_t *result;
698 uint32_t nread;
699
700 printf("Starting SMB2-TCON-DEPENDENCE\n");
701
702 if (!torture_init_connection(&cli)) {
703 return false;
704 }
705 cli->smb2.pid = 0xFEFF;
706
707 status = smbXcli_negprot(cli->conn, cli->timeout,
708 PROTOCOL_SMB2_02, PROTOCOL_LATEST);
709 if (!NT_STATUS_IS_OK(status)) {
710 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
711 return false;
712 }
713
714 status = cli_session_setup(cli, username,
715 password, strlen(password),
716 password, strlen(password),
717 workgroup);
718 if (!NT_STATUS_IS_OK(status)) {
719 printf("cli_session_setup returned %s\n", nt_errstr(status));
720 return false;
721 }
722
723 status = cli_tree_connect(cli, share, "?????", "", 0);
724 if (!NT_STATUS_IS_OK(status)) {
725 printf("cli_tree_connect returned %s\n", nt_errstr(status));
726 return false;
727 }
728
729 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
730 cli->smb2.tid, "tcon_depedence.txt",
731 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
732 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
733 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
734 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
735 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
736 FILE_CREATE, /* create_disposition, */
737 FILE_DELETE_ON_CLOSE, /* create_options, */
738 NULL, /* smb2_create_blobs *blobs */
739 &fid_persistent,
740 &fid_volatile);
741 if (!NT_STATUS_IS_OK(status)) {
742 printf("smb2cli_create on cli %s\n", nt_errstr(status));
743 return false;
744 }
745
746 status = smb2cli_write(cli->conn, cli->timeout, cli->smb2.session,
747 cli->smb2.tid, strlen(hello), 0, fid_persistent,
748 fid_volatile, 0, 0, (const uint8_t *)hello);
749 if (!NT_STATUS_IS_OK(status)) {
750 printf("smb2cli_write returned %s\n", nt_errstr(status));
751 return false;
752 }
753
754 status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session,
755 cli->smb2.tid, fid_persistent, fid_volatile);
756 if (!NT_STATUS_IS_OK(status)) {
757 printf("smb2cli_flush returned %s\n", nt_errstr(status));
758 return false;
759 }
760
761 status = smb2cli_read(cli->conn, cli->timeout, cli->smb2.session,
762 cli->smb2.tid, 0x10000, 0, fid_persistent,
763 fid_volatile, 2, 0,
764 talloc_tos(), &result, &nread);
765 if (!NT_STATUS_IS_OK(status)) {
766 printf("smb2cli_read returned %s\n", nt_errstr(status));
767 return false;
768 }
769
770 if (nread != strlen(hello)) {
771 printf("smb2cli_read returned %d bytes, expected %d\n",
772 (int)nread, (int)strlen(hello));
773 return false;
774 }
775
776 if (memcmp(hello, result, nread) != 0) {
777 printf("smb2cli_read returned '%s', expected '%s'\n",
778 result, hello);
779 return false;
780 }
781
782 /* check behaviour with wrong tid... */
783
784 cli->smb2.tid++;
785
786 status = smb2cli_read(cli->conn, cli->timeout, cli->smb2.session,
787 cli->smb2.tid, 0x10000, 0, fid_persistent,
788 fid_volatile, 2, 0,
789 talloc_tos(), &result, &nread);
790 if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
791 printf("smb2cli_read returned %s\n", nt_errstr(status));
792 return false;
793 }
794
795 cli->smb2.tid--;
796
797 return true;
798 }
799
800 bool run_smb2_multi_channel(int dummy)
801 {
802 struct cli_state *cli1;
803 struct cli_state *cli2;
804 struct cli_state *cli3;
805 NTSTATUS status;
806 bool ok;
807 uint64_t fid_persistent, fid_volatile;
808 struct tevent_context *ev;
809 struct tevent_req *subreq;
810 DATA_BLOB in_blob = data_blob_null;
811 DATA_BLOB out_blob;
812 DATA_BLOB channel_session_key;
813 struct auth_generic_state *auth_generic_state;
814 struct iovec *recv_iov;
815 const char *hello = "Hello, world\n";
816 uint8_t *result;
817 uint32_t nread;
818
819 printf("Starting SMB2-MULTI-CHANNEL\n");
820
821 if (!torture_init_connection(&cli1)) {
822 return false;
823 }
824 cli1->smb2.pid = 0xFEFF;
825
826 if (!torture_init_connection(&cli2)) {
827 return false;
828 }
829 cli2->smb2.pid = 0xFEFF;
830
831 if (!torture_init_connection(&cli3)) {
832 return false;
833 }
834 cli3->smb2.pid = 0xFEFF;
835
836 status = smbXcli_negprot(cli1->conn, cli1->timeout,
837 PROTOCOL_SMB2_22, PROTOCOL_LATEST);
838 if (!NT_STATUS_IS_OK(status)) {
839 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
840 return false;
841 }
842
843 status = smbXcli_negprot(cli2->conn, cli2->timeout,
844 PROTOCOL_SMB2_22, PROTOCOL_LATEST);
845 if (!NT_STATUS_IS_OK(status)) {
846 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
847 return false;
848 }
849
850 status = smbXcli_negprot(cli3->conn, cli3->timeout,
851 PROTOCOL_SMB2_22, PROTOCOL_LATEST);
852 if (!NT_STATUS_IS_OK(status)) {
853 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
854 return false;
855 }
856
857 status = cli_session_setup(cli1, username,
858 password, strlen(password),
859 password, strlen(password),
860 workgroup);
861 if (!NT_STATUS_IS_OK(status)) {
862 printf("smb2cli_sesssetup returned %s\n", nt_errstr(status));
863 return false;
864 }
865
866 status = cli_tree_connect(cli1, share, "?????", "", 0);
867 if (!NT_STATUS_IS_OK(status)) {
868 printf("cli_tree_connect returned %s\n", nt_errstr(status));
869 return false;
870 }
871
872 status = smb2cli_session_create_channel(cli2,
873 cli1->smb2.session,
874 cli2->conn,
875 &cli2->smb2.session);
876 if (!NT_STATUS_IS_OK(status)) {
877 printf("smb2cli_session_create_channel returned %s\n",
878 nt_errstr(status));
879 return false;
880 }
881
882 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
883 if (!NT_STATUS_IS_OK(status)) {
884 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
885 return false;
886 }
887
888 gensec_want_feature(auth_generic_state->gensec_security,
889 GENSEC_FEATURE_SESSION_KEY);
890 status = auth_generic_set_username(auth_generic_state, username);
891 if (!NT_STATUS_IS_OK(status)) {
892 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
893 return false;
894 }
895
896 status = auth_generic_set_domain(auth_generic_state, workgroup);
897 if (!NT_STATUS_IS_OK(status)) {
898 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
899 return false;
900 }
901
902 status = auth_generic_set_password(auth_generic_state, password);
903 if (!NT_STATUS_IS_OK(status)) {
904 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
905 return false;
906 }
907
908 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
909 if (!NT_STATUS_IS_OK(status)) {
910 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
911 return false;
912 }
913
914 ev = event_context_init(talloc_tos());
915 if (ev == NULL) {
916 printf("event_context_init() returned NULL\n");
917 return false;
918 }
919
920 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
921 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
922 printf("gensec_update returned %s\n", nt_errstr(status));
923 return false;
924 }
925
926 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
927 cli2->conn,
928 cli2->timeout,
929 cli2->smb2.session,
930 0x01, /* in_flags */
931 SMB2_CAP_DFS, /* in_capabilities */
932 0, /* in_channel */
933 0, /* in_previous_session_id */
934 &in_blob); /* in_security_buffer */
935 if (subreq == NULL) {
936 printf("smb2cli_session_setup_send() returned NULL\n");
937 return false;
938 }
939
940 ok = tevent_req_poll(subreq, ev);
941 if (!ok) {
942 printf("tevent_req_poll() returned false\n");
943 return false;
944 }
945
946 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
947 NULL, &out_blob);
948 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
949 printf("smb2cli_session_setup_recv returned %s\n",
950 nt_errstr(status));
951 return false;
952 }
953
954 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
955 if (!NT_STATUS_IS_OK(status)) {
956 printf("auth_generic_update returned %s\n", nt_errstr(status));
957 return false;
958 }
959
960 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
961 cli2->conn,
962 cli2->timeout,
963 cli2->smb2.session,
964 0x01, /* in_flags */
965 SMB2_CAP_DFS, /* in_capabilities */
966 0, /* in_channel */
967 0, /* in_previous_session_id */
968 &in_blob); /* in_security_buffer */
969 if (subreq == NULL) {
970 printf("smb2cli_session_setup_send() returned NULL\n");
971 return false;
972 }
973
974 ok = tevent_req_poll(subreq, ev);
975 if (!ok) {
976 printf("tevent_req_poll() returned false\n");
977 return false;
978 }
979
980 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
981 &recv_iov, &out_blob);
982 if (!NT_STATUS_IS_OK(status)) {
983 printf("smb2cli_session_setup_recv returned %s\n",
984 nt_errstr(status));
985 return false;
986 }
987
988 status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(),
989 &channel_session_key);
990 if (!NT_STATUS_IS_OK(status)) {
991 printf("gensec_session_key returned %s\n",
992 nt_errstr(status));
993 return false;
994 }
995
996 status = smb2cli_session_set_channel_key(cli2->smb2.session,
997 channel_session_key,
998 recv_iov);
999 if (!NT_STATUS_IS_OK(status)) {
1000 printf("smb2cli_session_set_channel_key %s\n", nt_errstr(status));
1001 return false;
1002 }
1003
1004 cli2->smb2.tid = cli1->smb2.tid;
1005
1006 status = smb2cli_session_create_channel(cli3,
1007 cli2->smb2.session,
1008 cli3->conn,
1009 &cli3->smb2.session);
1010 if (!NT_STATUS_IS_OK(status)) {
1011 printf("smb2cli_session_create_channel returned %s\n",
1012 nt_errstr(status));
1013 return false;
1014 }
1015
1016 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
1017 if (!NT_STATUS_IS_OK(status)) {
1018 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
1019 return false;
1020 }
1021
1022 gensec_want_feature(auth_generic_state->gensec_security,
1023 GENSEC_FEATURE_SESSION_KEY);
1024 status = auth_generic_set_username(auth_generic_state, username);
1025 if (!NT_STATUS_IS_OK(status)) {
1026 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
1027 return false;
1028 }
1029
1030 status = auth_generic_set_domain(auth_generic_state, workgroup);
1031 if (!NT_STATUS_IS_OK(status)) {
1032 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
1033 return false;
1034 }
1035
1036 status = auth_generic_set_password(auth_generic_state, password);
1037 if (!NT_STATUS_IS_OK(status)) {
1038 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
1039 return false;
1040 }
1041
1042 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
1043 if (!NT_STATUS_IS_OK(status)) {
1044 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
1045 return false;
1046 }
1047
1048 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
1049 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1050 printf("gensec_update returned %s\n", nt_errstr(status));
1051 return false;
1052 }
1053
1054 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1055 cli3->conn,
1056 cli3->timeout,
1057 cli3->smb2.session,
1058 0x01, /* in_flags */
1059 SMB2_CAP_DFS, /* in_capabilities */
1060 0, /* in_channel */
1061 0, /* in_previous_session_id */
1062 &in_blob); /* in_security_buffer */
1063 if (subreq == NULL) {
1064 printf("smb2cli_session_setup_send() returned NULL\n");
1065 return false;
1066 }
1067
1068 ok = tevent_req_poll(subreq, ev);
1069 if (!ok) {
1070 printf("tevent_req_poll() returned false\n");
1071 return false;
1072 }
1073
1074 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1075 NULL, &out_blob);
1076 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1077 printf("smb2cli_session_setup_recv returned %s\n",
1078 nt_errstr(status));
1079 return false;
1080 }
1081
1082 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
1083 if (!NT_STATUS_IS_OK(status)) {
1084 printf("auth_generic_update returned %s\n", nt_errstr(status));
1085 return false;
1086 }
1087
1088 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1089 cli3->conn,
1090 cli3->timeout,
1091 cli3->smb2.session,
1092 0x01, /* in_flags */
1093 SMB2_CAP_DFS, /* in_capabilities */
1094 0, /* in_channel */
1095 0, /* in_previous_session_id */
1096 &in_blob); /* in_security_buffer */
1097 if (subreq == NULL) {
1098 printf("smb2cli_session_setup_send() returned NULL\n");
1099 return false;
1100 }
1101
1102 ok = tevent_req_poll(subreq, ev);
1103 if (!ok) {
1104 printf("tevent_req_poll() returned false\n");
1105 return false;
1106 }
1107
1108 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1109 &recv_iov, &out_blob);
1110 if (!NT_STATUS_IS_OK(status)) {
1111 printf("smb2cli_session_setup_recv returned %s\n",
1112 nt_errstr(status));
1113 return false;
1114 }
1115
1116 status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(),
1117 &channel_session_key);
1118 if (!NT_STATUS_IS_OK(status)) {
1119 printf("gensec_session_key returned %s\n",
1120 nt_errstr(status));
1121 return false;
1122 }
1123
1124 status = smb2cli_session_set_channel_key(cli3->smb2.session,
1125 channel_session_key,
1126 recv_iov);
1127 if (!NT_STATUS_IS_OK(status)) {
1128 printf("smb2cli_session_set_channel_key %s\n", nt_errstr(status));
1129 return false;
1130 }
1131
1132 cli3->smb2.tid = cli2->smb2.tid;
1133
1134 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
1135 cli2->smb2.tid, "multi-channel.txt",
1136 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1137 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1138 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1139 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1140 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1141 FILE_CREATE, /* create_disposition, */
1142 FILE_DELETE_ON_CLOSE, /* create_options, */
1143 NULL, /* smb2_create_blobs *blobs */
1144 &fid_persistent,
1145 &fid_volatile);
1146 if (!NT_STATUS_IS_OK(status)) {
1147 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
1148 return false;
1149 }
1150
1151 status = smb2cli_write(cli1->conn, cli1->timeout, cli1->smb2.session,
1152 cli1->smb2.tid, strlen(hello), 0, fid_persistent,
1153 fid_volatile, 0, 0, (const uint8_t *)hello);
1154 if (!NT_STATUS_IS_OK(status)) {
1155 printf("smb2cli_write returned %s\n", nt_errstr(status));
1156 return false;
1157 }
1158
1159 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
1160 cli2->smb2.tid, fid_persistent, fid_volatile);
1161 if (!NT_STATUS_IS_OK(status)) {
1162 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1163 return false;
1164 }
1165
1166 status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session,
1167 cli1->smb2.tid, fid_persistent, fid_volatile);
1168 if (!NT_STATUS_IS_OK(status)) {
1169 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1170 return false;
1171 }
1172
1173 status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session,
1174 cli3->smb2.tid, fid_persistent, fid_volatile);
1175 if (!NT_STATUS_IS_OK(status)) {
1176 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1177 return false;
1178 }
1179
1180 status = smb2cli_read(cli2->conn, cli2->timeout, cli2->smb2.session,
1181 cli2->smb2.tid, 0x10000, 0, fid_persistent,
1182 fid_volatile, 2, 0,
1183 talloc_tos(), &result, &nread);
1184 if (!NT_STATUS_IS_OK(status)) {
1185 printf("smb2cli_read returned %s\n", nt_errstr(status));
1186 return false;
1187 }
1188
1189 if (nread != strlen(hello)) {
1190 printf("smb2cli_read returned %d bytes, expected %d\n",
1191 (int)nread, (int)strlen(hello));
1192 return false;
1193 }
1194
1195 if (memcmp(hello, result, nread) != 0) {
1196 printf("smb2cli_read returned '%s', expected '%s'\n",
1197 result, hello);
1198 return false;
1199 }
1200
1201 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
1202 if (!NT_STATUS_IS_OK(status)) {
1203 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
1204 return false;
1205 }
1206
1207 gensec_want_feature(auth_generic_state->gensec_security,
1208 GENSEC_FEATURE_SESSION_KEY);
1209 status = auth_generic_set_username(auth_generic_state, username);
1210 if (!NT_STATUS_IS_OK(status)) {
1211 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
1212 return false;
1213 }
1214
1215 status = auth_generic_set_domain(auth_generic_state, workgroup);
1216 if (!NT_STATUS_IS_OK(status)) {
1217 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
1218 return false;
1219 }
1220
1221 status = auth_generic_set_password(auth_generic_state, password);
1222 if (!NT_STATUS_IS_OK(status)) {
1223 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
1224 return false;
1225 }
1226
1227 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
1228 if (!NT_STATUS_IS_OK(status)) {
1229 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
1230 return false;
1231 }
1232
1233 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
1234 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1235 printf("gensec_update returned %s\n", nt_errstr(status));
1236 return false;
1237 }
1238
1239 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1240 cli3->conn,
1241 cli3->timeout,
1242 cli3->smb2.session,
1243 0x0, /* in_flags */
1244 SMB2_CAP_DFS, /* in_capabilities */
1245 0, /* in_channel */
1246 0, /* in_previous_session_id */
1247 &in_blob); /* in_security_buffer */
1248 if (subreq == NULL) {
1249 printf("smb2cli_session_setup_send() returned NULL\n");
1250 return false;
1251 }
1252
1253 ok = tevent_req_poll(subreq, ev);
1254 if (!ok) {
1255 printf("tevent_req_poll() returned false\n");
1256 return false;
1257 }
1258
1259 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1260 NULL, &out_blob);
1261 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1262 printf("smb2cli_session_setup_recv returned %s\n",
1263 nt_errstr(status));
1264 return false;
1265 }
1266
1267 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
1268 if (!NT_STATUS_IS_OK(status)) {
1269 printf("auth_generic_update returned %s\n", nt_errstr(status));
1270 return false;
1271 }
1272
1273 status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session,
1274 cli1->smb2.tid, fid_persistent, fid_volatile);
1275 if (!NT_STATUS_IS_OK(status)) {
1276 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1277 return false;
1278 }
1279
1280 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
1281 cli2->smb2.tid, fid_persistent, fid_volatile);
1282 if (!NT_STATUS_IS_OK(status)) {
1283 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1284 return false;
1285 }
1286
1287 status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session,
1288 cli3->smb2.tid, fid_persistent, fid_volatile);
1289 if (!NT_STATUS_IS_OK(status)) {
1290 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1291 return false;
1292 }
1293
1294 status = smb2cli_create(cli1->conn, cli1->timeout, cli1->smb2.session,
1295 cli1->smb2.tid, "multi-channel-invalid.txt",
1296 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1297 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1298 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1299 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1300 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1301 FILE_CREATE, /* create_disposition, */
1302 FILE_DELETE_ON_CLOSE, /* create_options, */
1303 NULL, /* smb2_create_blobs *blobs */
1304 &fid_persistent,
1305 &fid_volatile);
1306 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1307 printf("smb2cli_create %s\n", nt_errstr(status));
1308 return false;
1309 }
1310
1311 status = smb2cli_create(cli2->conn, cli2->timeout, cli2->smb2.session,
1312 cli2->smb2.tid, "multi-channel-invalid.txt",
1313 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1314 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1315 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1316 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1317 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1318 FILE_CREATE, /* create_disposition, */
1319 FILE_DELETE_ON_CLOSE, /* create_options, */
1320 NULL, /* smb2_create_blobs *blobs */
1321 &fid_persistent,
1322 &fid_volatile);
1323 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1324 printf("smb2cli_create %s\n", nt_errstr(status));
1325 return false;
1326 }
1327
1328 status = smb2cli_create(cli3->conn, cli3->timeout, cli3->smb2.session,
1329 cli3->smb2.tid, "multi-channel-invalid.txt",
1330 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1331 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1332 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1333 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1334 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1335 FILE_CREATE, /* create_disposition, */
1336 FILE_DELETE_ON_CLOSE, /* create_options, */
1337 NULL, /* smb2_create_blobs *blobs */
1338 &fid_persistent,
1339 &fid_volatile);
1340 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1341 printf("smb2cli_create %s\n", nt_errstr(status));
1342 return false;
1343 }
1344
1345 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1346 cli2->conn,
1347 cli2->timeout,
1348 cli2->smb2.session,
1349 0x0, /* in_flags */
1350 SMB2_CAP_DFS, /* in_capabilities */
1351 0, /* in_channel */
1352 0, /* in_previous_session_id */
1353 &in_blob); /* in_security_buffer */
1354 if (subreq == NULL) {
1355 printf("smb2cli_session_setup_send() returned NULL\n");
1356 return false;
1357 }
1358
1359 ok = tevent_req_poll(subreq, ev);
1360 if (!ok) {
1361 printf("tevent_req_poll() returned false\n");
1362 return false;
1363 }
1364
1365 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1366 &recv_iov, &out_blob);
1367 if (!NT_STATUS_IS_OK(status)) {
1368 printf("smb2cli_session_setup_recv returned %s\n",
1369 nt_errstr(status));
1370 return false;
1371 }
1372
1373 status = smb2cli_close(cli3->conn, cli3->timeout, cli3->smb2.session,
1374 cli3->smb2.tid, 0, fid_persistent, fid_volatile);
1375 if (!NT_STATUS_IS_OK(status)) {
1376 printf("smb2cli_close returned %s\n", nt_errstr(status));
1377 return false;
1378 }
1379
1380 status = smb2cli_flush(cli3->conn, cli3->timeout, cli3->smb2.session,
1381 cli3->smb2.tid, fid_persistent, fid_volatile);
1382 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
1383 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1384 return false;
1385 }
1386
1387 status = smb2cli_flush(cli2->conn, cli2->timeout, cli2->smb2.session,
1388 cli2->smb2.tid, fid_persistent, fid_volatile);
1389 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
1390 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1391 return false;
1392 }
1393
1394 status = smb2cli_flush(cli1->conn, cli1->timeout, cli1->smb2.session,
1395 cli1->smb2.tid, fid_persistent, fid_volatile);
1396 if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
1397 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1398 return false;
1399 }
1400
1401 return true;
1402 }
1403
1404 bool run_smb2_session_reauth(int dummy)
1405 {
1406 struct cli_state *cli;
1407 NTSTATUS status;
1408 bool ok;
1409 uint64_t fid_persistent, fid_volatile;
1410 uint64_t dir_persistent, dir_volatile;
1411 uint8_t *dir_data;
1412 uint32_t dir_data_length;
1413 struct tevent_context *ev;
1414 struct tevent_req *subreq;
1415 DATA_BLOB in_blob = data_blob_null;
1416 DATA_BLOB out_blob;
1417 DATA_BLOB in_input_buffer;
1418 DATA_BLOB out_output_buffer;
1419 uint8_t in_file_info_class;
1420 struct auth_generic_state *auth_generic_state;
1421 struct iovec *recv_iov;
1422 uint32_t saved_tid;
1423
1424 printf("Starting SMB2-SESSION_REAUTH\n");
1425
1426 if (!torture_init_connection(&cli)) {
1427 return false;
1428 }
1429 cli->smb2.pid = 0xFEFF;
1430
1431 /*
1432 * PROTOCOL_SMB2_22 has a bug in win8pre0
1433 * it behaves like PROTOCOL_SMB2_02
1434 * and returns NT_STATUS_REQUEST_NOT_ACCEPTED,
1435 * while it allows it on PROTOCOL_SMB2_02.
1436 */
1437 status = smbXcli_negprot(cli->conn, cli->timeout,
1438 PROTOCOL_SMB2_10, PROTOCOL_SMB2_10);
1439 if (!NT_STATUS_IS_OK(status)) {
1440 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
1441 return false;
1442 }
1443
1444 status = cli_session_setup(cli, username,
1445 password, strlen(password),
1446 password, strlen(password),
1447 workgroup);
1448 if (!NT_STATUS_IS_OK(status)) {
1449 printf("smb2cli_sesssetup returned %s\n", nt_errstr(status));
1450 return false;
1451 }
1452
1453 status = cli_tree_connect(cli, share, "?????", "", 0);
1454 if (!NT_STATUS_IS_OK(status)) {
1455 printf("cli_tree_connect returned %s\n", nt_errstr(status));
1456 return false;
1457 }
1458
1459 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1460 cli->smb2.tid, "session-reauth.txt",
1461 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1462 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1463 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1464 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1465 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1466 FILE_CREATE, /* create_disposition, */
1467 FILE_DELETE_ON_CLOSE, /* create_options, */
1468 NULL, /* smb2_create_blobs *blobs */
1469 &fid_persistent,
1470 &fid_volatile);
1471 if (!NT_STATUS_IS_OK(status)) {
1472 printf("smb2cli_create %s\n", nt_errstr(status));
1473 return false;
1474 }
1475
1476 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1477 cli->smb2.tid, "",
1478 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1479 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1480 SEC_STD_SYNCHRONIZE|
1481 SEC_DIR_LIST|
1482 SEC_DIR_READ_ATTRIBUTE, /* desired_access, */
1483 0, /* file_attributes, */
1484 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1485 FILE_OPEN, /* create_disposition, */
1486 FILE_SYNCHRONOUS_IO_NONALERT|FILE_DIRECTORY_FILE, /* create_options, */
1487 NULL, /* smb2_create_blobs *blobs */
1488 &dir_persistent,
1489 &dir_volatile);
1490 if (!NT_STATUS_IS_OK(status)) {
1491 printf("smb2cli_create returned %s\n", nt_errstr(status));
1492 return false;
1493 }
1494
1495 status = smb2cli_query_directory(
1496 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tid,
1497 1, 0x3, 0, dir_persistent, dir_volatile,
1498 "session-reauth.txt", 0xffff,
1499 talloc_tos(), &dir_data, &dir_data_length);
1500 if (!NT_STATUS_IS_OK(status)) {
1501 printf("smb2cli_query_directory returned %s\n", nt_errstr(status));
1502 return false;
1503 }
1504
1505 status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
1506 if (!NT_STATUS_IS_OK(status)) {
1507 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
1508 return false;
1509 }
1510
1511 gensec_want_feature(auth_generic_state->gensec_security,
1512 GENSEC_FEATURE_SESSION_KEY);
1513 status = auth_generic_set_username(auth_generic_state, username);
1514 if (!NT_STATUS_IS_OK(status)) {
1515 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
1516 return false;
1517 }
1518
1519 status = auth_generic_set_domain(auth_generic_state, workgroup);
1520 if (!NT_STATUS_IS_OK(status)) {
1521 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
1522 return false;
1523 }
1524
1525 status = auth_generic_set_password(auth_generic_state, password);
1526 if (!NT_STATUS_IS_OK(status)) {
1527 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
1528 return false;
1529 }
1530
1531 status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
1532 if (!NT_STATUS_IS_OK(status)) {
1533 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
1534 return false;
1535 }
1536
1537 ev = event_context_init(talloc_tos());
1538 if (ev == NULL) {
1539 printf("event_context_init() returned NULL\n");
1540 return false;
1541 }
1542
1543 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
1544 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1545 printf("gensec_update returned %s\n", nt_errstr(status));
1546 return false;
1547 }
1548
1549 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1550 cli->conn,
1551 cli->timeout,
1552 cli->smb2.session,
1553 0x0, /* in_flags */
1554 SMB2_CAP_DFS, /* in_capabilities */
1555 0, /* in_channel */
1556 0, /* in_previous_session_id */
1557 &in_blob); /* in_security_buffer */
1558 if (subreq == NULL) {
1559 printf("smb2cli_session_setup_send() returned NULL\n");
1560 return false;
1561 }
1562
1563 ok = tevent_req_poll(subreq, ev);
1564 if (!ok) {
1565 printf("tevent_req_poll() returned false\n");
1566 return false;
1567 }
1568
1569 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1570 NULL, &out_blob);
1571 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1572 printf("smb2cli_session_setup_recv returned %s\n",
1573 nt_errstr(status));
1574 return false;
1575 }
1576
1577 status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
1578 if (!NT_STATUS_IS_OK(status)) {
1579 printf("auth_generic_update returned %s\n", nt_errstr(status));
1580 return false;
1581 }
1582
1583 status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session,
1584 cli->smb2.tid, fid_persistent, fid_volatile);
1585 if (!NT_STATUS_IS_OK(status)) {
1586 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1587 return false;
1588 }
1589
1590 status = smb2cli_query_directory(
1591 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tid,
1592 1, 0x3, 0, dir_persistent, dir_volatile,
1593 "session-reauth.txt", 0xffff,
1594 talloc_tos(), &dir_data, &dir_data_length);
1595 if (!NT_STATUS_IS_OK(status)) {
1596 printf("smb2cli_query_directory returned %s\n", nt_errstr(status));
1597 return false;
1598 }
1599
1600 /*
1601 * query_info seems to be a path based operation on Windows...
1602 */
1603 status = smb2cli_query_info(cli->conn,
1604 cli->timeout,
1605 cli->smb2.session,
1606 cli->smb2.tid,
1607 SMB2_GETINFO_SECURITY,
1608 0, /* in_file_info_class */
1609 1024, /* in_max_output_length */
1610 NULL, /* in_input_buffer */
1611 SECINFO_OWNER, /* in_additional_info */
1612 0, /* in_flags */
1613 fid_persistent,
1614 fid_volatile,
1615 talloc_tos(),
1616 &out_output_buffer);
1617 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1618 printf("smb2cli_query_info (security) returned %s\n", nt_errstr(status));
1619 return false;
1620 }
1621
1622 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1623 status = smb2cli_query_info(cli->conn,
1624 cli->timeout,
1625 cli->smb2.session,
1626 cli->smb2.tid,
1627 SMB2_GETINFO_FILE,
1628 in_file_info_class,
1629 1024, /* in_max_output_length */
1630 NULL, /* in_input_buffer */
1631 0, /* in_additional_info */
1632 0, /* in_flags */
1633 fid_persistent,
1634 fid_volatile,
1635 talloc_tos(),
1636 &out_output_buffer);
1637 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1638 printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status));
1639 return false;
1640 }
1641
1642 in_input_buffer = data_blob_talloc(talloc_tos(), NULL, 8);
1643 SBVAL(in_input_buffer.data, 0, 512);
1644
1645 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1646 status = smb2cli_set_info(cli->conn,
1647 cli->timeout,
1648 cli->smb2.session,
1649 cli->smb2.tid,
1650 SMB2_GETINFO_FILE,
1651 in_file_info_class,
1652 &in_input_buffer,
1653 0, /* in_additional_info */
1654 fid_persistent,
1655 fid_volatile);
1656 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1657 printf("smb2cli_set_info (position) returned %s\n", nt_errstr(status));
1658 return false;
1659 }
1660
1661 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1662 cli->smb2.tid, "session-reauth-invalid.txt",
1663 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1664 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1665 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1666 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1667 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1668 FILE_CREATE, /* create_disposition, */
1669 FILE_DELETE_ON_CLOSE, /* create_options, */
1670 NULL, /* smb2_create_blobs *blobs */
1671 &fid_persistent,
1672 &fid_volatile);
1673 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1674 printf("smb2cli_create %s\n", nt_errstr(status));
1675 return false;
1676 }
1677
1678 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1679 cli->smb2.tid, "",
1680 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1681 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1682 SEC_STD_SYNCHRONIZE|
1683 SEC_DIR_LIST|
1684 SEC_DIR_READ_ATTRIBUTE, /* desired_access, */
1685 0, /* file_attributes, */
1686 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1687 FILE_OPEN, /* create_disposition, */
1688 FILE_SYNCHRONOUS_IO_NONALERT|FILE_DIRECTORY_FILE, /* create_options, */
1689 NULL, /* smb2_create_blobs *blobs */
1690 &dir_persistent,
1691 &dir_volatile);
1692 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1693 printf("smb2cli_create returned %s\n", nt_errstr(status));
1694 return false;
1695 }
1696
1697 saved_tid = cli->smb2.tid;
1698 status = cli_tree_connect(cli, share, "?????", "", 0);
1699 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
1700 printf("cli_tree_connect returned %s\n", nt_errstr(status));
1701 return false;
1702 }
1703 cli->smb2.tid = saved_tid;
1704
1705 subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1706 cli->conn,
1707 cli->timeout,
1708 cli->smb2.session,
1709 0x0, /* in_flags */
1710 SMB2_CAP_DFS, /* in_capabilities */
1711 0, /* in_channel */
1712 0, /* in_previous_session_id */
1713 &in_blob); /* in_security_buffer */
1714 if (subreq == NULL) {
1715 printf("smb2cli_session_setup_send() returned NULL\n");
1716 return false;
1717 }
1718
1719 ok = tevent_req_poll(subreq, ev);
1720 if (!ok) {
1721 printf("tevent_req_poll() returned false\n");
1722 return false;
1723 }
1724
1725 status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1726 &recv_iov, &out_blob);
1727 if (!NT_STATUS_IS_OK(status)) {
1728 printf("smb2cli_session_setup_recv returned %s\n",
1729 nt_errstr(status));
1730 return false;
1731 }
1732
1733 status = smb2cli_flush(cli->conn, cli->timeout, cli->smb2.session,
1734 cli->smb2.tid, fid_persistent, fid_volatile);
1735 if (!NT_STATUS_IS_OK(status)) {
1736 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1737 return false;
1738 }
1739
1740 status = smb2cli_query_info(cli->conn,
1741 cli->timeout,
1742 cli->smb2.session,
1743 cli->smb2.tid,
1744 SMB2_GETINFO_SECURITY,
1745 0, /* in_file_info_class */
1746 1024, /* in_max_output_length */
1747 NULL, /* in_input_buffer */
1748 SECINFO_OWNER, /* in_additional_info */
1749 0, /* in_flags */
1750 fid_persistent,
1751 fid_volatile,
1752 talloc_tos(),
1753 &out_output_buffer);
1754 if (!NT_STATUS_IS_OK(status)) {
1755 printf("smb2cli_query_info (security) returned %s\n", nt_errstr(status));
1756 return false;
1757 }
1758
1759 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1760 status = smb2cli_query_info(cli->conn,
1761 cli->timeout,
1762 cli->smb2.session,
1763 cli->smb2.tid,
1764 SMB2_GETINFO_FILE,
1765 in_file_info_class,
1766 1024, /* in_max_output_length */
1767 NULL, /* in_input_buffer */
1768 0, /* in_additional_info */
1769 0, /* in_flags */
1770 fid_persistent,
1771 fid_volatile,
1772 talloc_tos(),
1773 &out_output_buffer);
1774 if (!NT_STATUS_IS_OK(status)) {
1775 printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status));
1776 return false;
1777 }
1778
1779 in_input_buffer = data_blob_talloc(talloc_tos(), NULL, 8);
1780 SBVAL(in_input_buffer.data, 0, 512);
1781
1782 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1783 status = smb2cli_set_info(cli->conn,
1784 cli->timeout,
1785 cli->smb2.session,
1786 cli->smb2.tid,
1787 SMB2_GETINFO_FILE,
1788 in_file_info_class,
1789 &in_input_buffer,
1790 0, /* in_additional_info */
1791 fid_persistent,
1792 fid_volatile);
1793 if (!NT_STATUS_IS_OK(status)) {
1794 printf("smb2cli_set_info (position) returned %s\n", nt_errstr(status));
1795 return false;
1796 }
1797
1798 in_file_info_class = SMB_FILE_POSITION_INFORMATION - 1000;
1799 status = smb2cli_query_info(cli->conn,
1800 cli->timeout,
1801 cli->smb2.session,
1802 cli->smb2.tid,
1803 SMB2_GETINFO_FILE,
1804 in_file_info_class,
1805 1024, /* in_max_output_length */
1806 NULL, /* in_input_buffer */
1807 0, /* in_additional_info */
1808 0, /* in_flags */
1809 fid_persistent,
1810 fid_volatile,
1811 talloc_tos(),
1812 &out_output_buffer);
1813 if (!NT_STATUS_IS_OK(status)) {
1814 printf("smb2cli_query_info (position) returned %s\n", nt_errstr(status));
1815 return false;
1816 }
1817
1818 status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session,
1819 cli->smb2.tid, 0, fid_persistent, fid_volatile);
1820 if (!NT_STATUS_IS_OK(status)) {
1821 printf("smb2cli_close returned %s\n", nt_errstr(status));
1822 return false;
1823 }
1824
1825 status = smb2cli_create(cli->conn, cli->timeout, cli->smb2.session,
1826 cli->smb2.tid, "session-reauth.txt",
1827 SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1828 SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1829 SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1830 FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1831 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1832 FILE_CREATE, /* create_disposition, */
1833 FILE_DELETE_ON_CLOSE, /* create_options, */
1834 NULL, /* smb2_create_blobs *blobs */
1835 &fid_persistent,
1836 &fid_volatile);
1837 if (!NT_STATUS_IS_OK(status)) {
1838 printf("smb2cli_create %s\n", nt_errstr(status));
1839 return false;
1840 }
1841
1842 status = smb2cli_query_directory(
1843 cli->conn, cli->timeout, cli->smb2.session, cli->smb2.tid,
1844 1, 0x3, 0, dir_persistent, dir_volatile,
1845 "session-reauth.txt", 0xffff,
1846 talloc_tos(), &dir_data, &dir_data_length);
1847 if (!NT_STATUS_IS_OK(status)) {
1848 printf("smb2cli_query_directory returned %s\n", nt_errstr(status));
1849 return false;
1850 }
1851
1852 status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session,
1853 cli->smb2.tid, 0, dir_persistent, dir_volatile);
1854 if (!NT_STATUS_IS_OK(status)) {
1855 printf("smb2cli_close returned %s\n", nt_errstr(status));
1856 return false;
1857 }
1858
1859 status = smb2cli_close(cli->conn, cli->timeout, cli->smb2.session,
1860 cli->smb2.tid, 0, fid_persistent, fid_volatile);
1861 if (!NT_STATUS_IS_OK(status)) {
1862 printf("smb2cli_close returned %s\n", nt_errstr(status));
1863 return false;
1864 }
1865
1866 saved_tid = cli->smb2.tid;
1867 status = cli_tree_connect(cli, share, "?????", "", 0);
1868 if (!NT_STATUS_IS_OK(status)) {
1869 printf("cli_tree_connect returned %s\n", nt_errstr(status));
1870 return false;
1871 }
1872 cli->smb2.tid = saved_tid;
1873
1874 return true;
1875 }
reg import