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