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