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