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