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