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 "../libcli/smb/smbXcli_base.h"
  24 #include "libsmb/smb2cli.h"
  25 #include "libcli/security/security.h"
  26 #include "libsmb/proto.h"
  27 #include "auth/gensec/gensec.h"
  28 #include "auth_generic.h"
  29
  30 extern fstring host, workgroup, share, password, username, myname;
  31
  32 bool run_smb2_basic(int dummy)
  33 {
  34         struct cli_state *cli;
  35         NTSTATUS status;
  36         uint64_t fid_persistent, fid_volatile;
  37         const char *hello = "Hello, world\n";
  38         uint8_t *result;
  39         uint32_t nread;
  40         uint8_t *dir_data;
  41         uint32_t dir_data_length;
  42         uint32_t saved_tid = 0;
  43         uint64_t saved_uid = 0;
  44
  45         printf("Starting SMB2-BASIC\n");
  46
  47         if (!torture_init_connection(&cli)) {
  48                 return false;
  49         }
  50         cli->smb2.pid = 0xFEFF;
  51
  52         status = smbXcli_negprot(cli->conn, cli->timeout,
  53                                  PROTOCOL_SMB2_02, PROTOCOL_SMB2_02);
  54         if (!NT_STATUS_IS_OK(status)) {
  55                 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
  56                 return false;
  57         }
  58
  59         status = cli_session_setup(cli, username,
  60                                    password, strlen(password),
  61                                    password, strlen(password),
  62                                    workgroup);
  63         if (!NT_STATUS_IS_OK(status)) {
  64                 printf("cli_session_setup returned %s\n", nt_errstr(status));
  65                 return false;
  66         }
  67
  68         status = cli_tree_connect(cli, share, "?????", "", 0);
  69         if (!NT_STATUS_IS_OK(status)) {
  70                 printf("cli_tree_connect returned %s\n", nt_errstr(status));
  71                 return false;
  72         }
  73
  74         status = smb2cli_create(cli, "smb2-basic.txt",
  75                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
  76                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
  77                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
  78                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
  79                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
  80                         FILE_CREATE, /* create_disposition, */
  81                         FILE_DELETE_ON_CLOSE, /* create_options, */
  82                         NULL, /* smb2_create_blobs *blobs */
  83                         &fid_persistent,
  84                         &fid_volatile);
  85         if (!NT_STATUS_IS_OK(status)) {
  86                 printf("smb2cli_create returned %s\n", nt_errstr(status));
  87                 return false;
  88         }
  89
  90         status = smb2cli_write(cli, strlen(hello), 0, fid_persistent,
  91                                fid_volatile, 0, 0, (const uint8_t *)hello);
  92         if (!NT_STATUS_IS_OK(status)) {
  93                 printf("smb2cli_write returned %s\n", nt_errstr(status));
  94                 return false;
  95         }
  96
  97         status = smb2cli_flush(cli, fid_persistent, fid_volatile);
  98         if (!NT_STATUS_IS_OK(status)) {
  99                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 100                 return false;
 101         }
 102
 103         status = smb2cli_read(cli, 0x10000, 0, fid_persistent,
 104                                fid_volatile, 2, 0,
 105                                talloc_tos(), &result, &nread);
 106         if (!NT_STATUS_IS_OK(status)) {
 107                 printf("smb2cli_read returned %s\n", nt_errstr(status));
 108                 return false;
 109         }
 110
 111         if (nread != strlen(hello)) {
 112                 printf("smb2cli_read returned %d bytes, expected %d\n",
 113                        (int)nread, (int)strlen(hello));
 114                 return false;
 115         }
 116
 117         if (memcmp(hello, result, nread) != 0) {
 118                 printf("smb2cli_read returned '%s', expected '%s'\n",
 119                        result, hello);
 120                 return false;
 121         }
 122
 123         status = smb2cli_close(cli, 0, fid_persistent, fid_volatile);
 124         if (!NT_STATUS_IS_OK(status)) {
 125                 printf("smb2cli_close returned %s\n", nt_errstr(status));
 126                 return false;
 127         }
 128
 129         status = smb2cli_create(cli, "",
 130                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
 131                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
 132                         SEC_STD_SYNCHRONIZE|
 133                         SEC_DIR_LIST|
 134                         SEC_DIR_READ_ATTRIBUTE, /* desired_access, */
 135                         0, /* file_attributes, */
 136                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
 137                         FILE_OPEN, /* create_disposition, */
 138                         FILE_SYNCHRONOUS_IO_NONALERT|FILE_DIRECTORY_FILE, /* create_options, */
 139                         NULL, /* smb2_create_blobs *blobs */
 140                         &fid_persistent,
 141                         &fid_volatile);
 142         if (!NT_STATUS_IS_OK(status)) {
 143                 printf("smb2cli_create returned %s\n", nt_errstr(status));
 144                 return false;
 145         }
 146
 147         status = smb2cli_query_directory(
 148                 cli, 1, 0, 0, fid_persistent, fid_volatile, "*", 0xffff,
 149                 talloc_tos(), &dir_data, &dir_data_length);
 150
 151         if (!NT_STATUS_IS_OK(status)) {
 152                 printf("smb2cli_query_directory returned %s\n", nt_errstr(status));
 153                 return false;
 154         }
 155
 156         status = smb2cli_close(cli, 0, fid_persistent, fid_volatile);
 157         if (!NT_STATUS_IS_OK(status)) {
 158                 printf("smb2cli_close returned %s\n", nt_errstr(status));
 159                 return false;
 160         }
 161
 162         saved_tid = cli->smb2.tid;
 163         status = smb2cli_tdis(cli);
 164         if (!NT_STATUS_IS_OK(status)) {
 165                 printf("smb2cli_tdis returned %s\n", nt_errstr(status));
 166                 return false;
 167         }
 168         cli->smb2.tid = saved_tid;
 169
 170         status = smb2cli_tdis(cli);
 171         if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
 172                 printf("2nd smb2cli_tdis returned %s\n", nt_errstr(status));
 173                 return false;
 174         }
 175
 176         saved_uid = smb2cli_session_current_id(cli->smb2.session);
 177         status = smb2cli_logoff(cli);
 178         if (!NT_STATUS_IS_OK(status)) {
 179                 printf("smb2cli_logoff returned %s\n", nt_errstr(status));
 180                 return false;
 181         }
 182
 183         cli->smb2.session = smbXcli_session_create(cli, cli->conn);
 184         if (cli->smb2.session == NULL) {
 185                 printf("smbXcli_session_create() returned NULL\n");
 186                 return false;
 187         }
 188
 189         smb2cli_session_set_id_and_flags(cli->smb2.session, saved_uid, 0);
 190
 191         status = smb2cli_logoff(cli);
 192         if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
 193                 printf("2nd smb2cli_logoff returned %s\n", nt_errstr(status));
 194                 return false;
 195         }
 196
 197         return true;
 198 }
 199
 200 bool run_smb2_negprot(int dummy)
 201 {
 202         struct cli_state *cli;
 203         NTSTATUS status;
 204         enum protocol_types protocol;
 205         const char *name = NULL;
 206
 207         printf("Starting SMB2-NEGPROT\n");
 208
 209         if (!torture_init_connection(&cli)) {
 210                 return false;
 211         }
 212         cli->smb2.pid = 0xFEFF;
 213
 214         status = smbXcli_negprot(cli->conn, cli->timeout,
 215                                  PROTOCOL_CORE, PROTOCOL_SMB2_24);
 216         if (!NT_STATUS_IS_OK(status)) {
 217                 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
 218                 return false;
 219         }
 220
 221         protocol = smbXcli_conn_protocol(cli->conn);
 222
 223         switch (protocol) {
 224         case PROTOCOL_SMB2_02:
 225                 name = "SMB2_02";
 226                 break;
 227         case PROTOCOL_SMB2_10:
 228                 name = "SMB2_10";
 229                 break;
 230         case PROTOCOL_SMB2_22:
 231                 name = "SMB2_22";
 232                 break;
 233         case PROTOCOL_SMB2_24:
 234                 name = "SMB2_24";
 235                 break;
 236         default:
 237                 break;
 238         }
 239
 240         if (name) {
 241                 printf("Server supports %s\n", name);
 242         } else {
 243                 printf("Server DOES NOT support SMB2\n");
 244                 return false;
 245         }
 246
 247         status = smbXcli_negprot(cli->conn, cli->timeout,
 248                                  protocol, protocol);
 249         if (!NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_RESET) &&
 250             !NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_DISCONNECTED) &&
 251             !NT_STATUS_EQUAL(status, NT_STATUS_CONNECTION_ABORTED)) {
 252                 printf("2nd smbXcli_negprot should disconnect - returned %s\n",
 253                         nt_errstr(status));
 254                 return false;
 255         }
 256
 257         if (smbXcli_conn_is_connected(cli->conn)) {
 258                 printf("2nd smbXcli_negprot should disconnect "
 259                        "- still connected\n");
 260                 return false;
 261         }
 262
 263         return true;
 264 }
 265
 266 bool run_smb2_session_reconnect(int dummy)
 267 {
 268         struct cli_state *cli1;
 269         struct cli_state *cli2;
 270         NTSTATUS status;
 271         bool ok;
 272         uint64_t fid_persistent, fid_volatile;
 273         struct tevent_context *ev;
 274         struct tevent_req *subreq;
 275         DATA_BLOB in_blob = data_blob_null;
 276         DATA_BLOB out_blob;
 277         DATA_BLOB session_key;
 278         struct auth_generic_state *auth_generic_state;
 279         struct iovec *recv_iov;
 280         const char *hello = "Hello, world\n";
 281         uint8_t *result;
 282         uint32_t nread;
 283
 284         printf("Starting SMB2-SESSION-RECONNECT\n");
 285
 286         if (!torture_init_connection(&cli1)) {
 287                 return false;
 288         }
 289         cli1->smb2.pid = 0xFEFF;
 290
 291         status = smbXcli_negprot(cli1->conn, cli1->timeout,
 292                                  PROTOCOL_SMB2_02, PROTOCOL_SMB2_24);
 293         if (!NT_STATUS_IS_OK(status)) {
 294                 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
 295                 return false;
 296         }
 297
 298         status = cli_session_setup(cli1, username,
 299                                    password, strlen(password),
 300                                    password, strlen(password),
 301                                    workgroup);
 302         if (!NT_STATUS_IS_OK(status)) {
 303                 printf("cli_session_setup returned %s\n", nt_errstr(status));
 304                 return false;
 305         }
 306
 307         status = cli_tree_connect(cli1, share, "?????", "", 0);
 308         if (!NT_STATUS_IS_OK(status)) {
 309                 printf("cli_tree_connect returned %s\n", nt_errstr(status));
 310                 return false;
 311         }
 312
 313         status = smb2cli_create(cli1, "session-reconnect.txt",
 314                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
 315                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
 316                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
 317                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
 318                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
 319                         FILE_CREATE, /* create_disposition, */
 320                         FILE_DELETE_ON_CLOSE, /* create_options, */
 321                         NULL, /* smb2_create_blobs *blobs */
 322                         &fid_persistent,
 323                         &fid_volatile);
 324         if (!NT_STATUS_IS_OK(status)) {
 325                 printf("smb2cli_create on cli1 %s\n", nt_errstr(status));
 326                 return false;
 327         }
 328
 329         status = smb2cli_write(cli1, strlen(hello), 0, fid_persistent,
 330                                fid_volatile, 0, 0, (const uint8_t *)hello);
 331         if (!NT_STATUS_IS_OK(status)) {
 332                 printf("smb2cli_write returned %s\n", nt_errstr(status));
 333                 return false;
 334         }
 335
 336         status = smb2cli_flush(cli1, fid_persistent, fid_volatile);
 337         if (!NT_STATUS_IS_OK(status)) {
 338                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 339                 return false;
 340         }
 341
 342         status = smb2cli_read(cli1, 0x10000, 0, fid_persistent,
 343                                fid_volatile, 2, 0,
 344                                talloc_tos(), &result, &nread);
 345         if (!NT_STATUS_IS_OK(status)) {
 346                 printf("smb2cli_read returned %s\n", nt_errstr(status));
 347                 return false;
 348         }
 349
 350         if (nread != strlen(hello)) {
 351                 printf("smb2cli_read returned %d bytes, expected %d\n",
 352                        (int)nread, (int)strlen(hello));
 353                 return false;
 354         }
 355
 356         if (memcmp(hello, result, nread) != 0) {
 357                 printf("smb2cli_read returned '%s', expected '%s'\n",
 358                        result, hello);
 359                 return false;
 360         }
 361
 362         /* prepare second session */
 363
 364         if (!torture_init_connection(&cli2)) {
 365                 return false;
 366         }
 367         cli2->smb2.pid = 0xFEFF;
 368
 369         status = smbXcli_negprot(cli2->conn, cli2->timeout,
 370                                  PROTOCOL_SMB2_02, PROTOCOL_SMB2_24);
 371         if (!NT_STATUS_IS_OK(status)) {
 372                 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
 373                 return false;
 374         }
 375
 376         status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
 377         if (!NT_STATUS_IS_OK(status)) {
 378                 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
 379                 return false;
 380         }
 381
 382         gensec_want_feature(auth_generic_state->gensec_security,
 383                             GENSEC_FEATURE_SESSION_KEY);
 384         status = auth_generic_set_username(auth_generic_state, username);
 385         if (!NT_STATUS_IS_OK(status)) {
 386                 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
 387                 return false;
 388         }
 389
 390         status = auth_generic_set_domain(auth_generic_state, workgroup);
 391         if (!NT_STATUS_IS_OK(status)) {
 392                 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
 393                 return false;
 394         }
 395
 396         status = auth_generic_set_password(auth_generic_state, password);
 397         if (!NT_STATUS_IS_OK(status)) {
 398                 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
 399                 return false;
 400         }
 401
 402         status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
 403         if (!NT_STATUS_IS_OK(status)) {
 404                 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
 405                 return false;
 406         }
 407
 408         ev = event_context_init(talloc_tos());
 409         if (ev == NULL) {
 410                 printf("event_context_init() returned NULL\n");
 411                 return false;
 412         }
 413
 414         status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
 415         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 416                 printf("gensec_update returned %s\n", nt_errstr(status));
 417                 return false;
 418         }
 419
 420         cli2->smb2.session = smbXcli_session_create(cli2, cli2->conn);
 421
 422         subreq = smb2cli_session_setup_send(talloc_tos(), ev,
 423                                             cli2->conn,
 424                                             cli2->timeout,
 425                                             cli2->smb2.session,
 426                                             0x0, /* in_flags */
 427                                             SMB2_CAP_DFS, /* in_capabilities */
 428                                             0, /* in_channel */
 429                                             cli1->smb2.session, /* in_previous_session */
 430                                             &in_blob); /* in_security_buffer */
 431         if (subreq == NULL) {
 432                 printf("smb2cli_session_setup_send() returned NULL\n");
 433                 return false;
 434         }
 435
 436         ok = tevent_req_poll(subreq, ev);
 437         if (!ok) {
 438                 printf("tevent_req_poll() returned false\n");
 439                 return false;
 440         }
 441
 442         status = smb2cli_session_setup_recv(subreq, talloc_tos(),
 443                                             NULL, &out_blob);
 444         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 445                 printf("smb2cli_session_setup_recv returned %s\n",
 446                         nt_errstr(status));
 447                 return false;
 448         }
 449
 450         status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
 451         if (!NT_STATUS_IS_OK(status)) {
 452                 printf("auth_generic_update returned %s\n", nt_errstr(status));
 453                 return false;
 454         }
 455
 456         subreq = smb2cli_session_setup_send(talloc_tos(), ev,
 457                                             cli2->conn,
 458                                             cli2->timeout,
 459                                             cli2->smb2.session,
 460                                             0x0, /* in_flags */
 461                                             SMB2_CAP_DFS, /* in_capabilities */
 462                                             0, /* in_channel */
 463                                             cli1->smb2.session, /* in_previous_session */
 464                                             &in_blob); /* in_security_buffer */
 465         if (subreq == NULL) {
 466                 printf("smb2cli_session_setup_send() returned NULL\n");
 467                 return false;
 468         }
 469
 470         ok = tevent_req_poll(subreq, ev);
 471         if (!ok) {
 472                 printf("tevent_req_poll() returned false\n");
 473                 return false;
 474         }
 475
 476         status = smb2cli_session_setup_recv(subreq, talloc_tos(),
 477                                             &recv_iov, &out_blob);
 478         if (!NT_STATUS_IS_OK(status)) {
 479                 printf("smb2cli_session_setup_recv returned %s\n",
 480                         nt_errstr(status));
 481                 return false;
 482         }
 483
 484         status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(),
 485                                     &session_key);
 486         if (!NT_STATUS_IS_OK(status)) {
 487                 printf("gensec_session_key returned %s\n",
 488                         nt_errstr(status));
 489                 return false;
 490         }
 491
 492         status = smb2_signing_check_pdu(session_key, recv_iov, 3);
 493         if (!NT_STATUS_IS_OK(status)) {
 494                 printf("check pdu returned %s\n", nt_errstr(status));
 495                 return false;
 496         }
 497
 498         /* check file operation on the old client */
 499
 500         status = smb2cli_flush(cli1, fid_persistent, fid_volatile);
 501         if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
 502                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 503                 return false;
 504         }
 505
 506         status = cli_tree_connect(cli1, share, "?????", "", 0);
 507         if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
 508                 printf("cli_tree_connect returned %s\n", nt_errstr(status));
 509                 return false;
 510         }
 511
 512         /*
 513          * checking file operations without signing.
 514          * on w2k8r2 at least, flush, read and write also work the same way,
 515          * while create gives ACCESS_DENIED without signing
 516          */
 517         status = smb2cli_flush(cli2, fid_persistent, fid_volatile);
 518         if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
 519                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 520                 return false;
 521         }
 522
 523         status = smb2cli_write(cli2, strlen(hello), 0, fid_persistent,
 524                                fid_volatile, 0, 0, (const uint8_t *)hello);
 525         if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
 526                 printf("smb2cli_write returned %s\n", nt_errstr(status));
 527                 return false;
 528         }
 529
 530         status = smb2cli_read(cli2, 0x10000, 0, fid_persistent,
 531                                fid_volatile, 2, 0,
 532                                talloc_tos(), &result, &nread);
 533         if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
 534                 printf("smb2cli_read returned %s\n", nt_errstr(status));
 535                 return false;
 536         }
 537
 538         status = smb2cli_create(cli2, "session-reconnect.txt",
 539                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
 540                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
 541                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
 542                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
 543                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
 544                         FILE_CREATE, /* create_disposition, */
 545                         FILE_DELETE_ON_CLOSE, /* create_options, */
 546                         NULL, /* smb2_create_blobs *blobs */
 547                         &fid_persistent,
 548                         &fid_volatile);
 549         if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED) &&
 550             !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
 551                 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
 552                 return false;
 553         }
 554
 555         /* now grab the session key and try with signing */
 556
 557         status = smb2cli_session_update_session_key(cli2->smb2.session,
 558                                                     session_key,
 559                                                     recv_iov);
 560         if (!NT_STATUS_IS_OK(status)) {
 561                 printf("smb2cli_session_update_session_key %s\n", nt_errstr(status));
 562                 return false;
 563         }
 564
 565         /* the tid seems to be irrelevant at this stage */
 566
 567         cli2->smb2.tid = cli1->smb2.tid;
 568
 569         status = smb2cli_flush(cli2, fid_persistent, fid_volatile);
 570         if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
 571                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 572                 return false;
 573         }
 574
 575         status = smb2cli_write(cli2, strlen(hello), 0, fid_persistent,
 576                                fid_volatile, 0, 0, (const uint8_t *)hello);
 577         if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
 578                 printf("smb2cli_write returned %s\n", nt_errstr(status));
 579                 return false;
 580         }
 581
 582         status = smb2cli_read(cli2, 0x10000, 0, fid_persistent,
 583                                fid_volatile, 2, 0,
 584                                talloc_tos(), &result, &nread);
 585         if (!NT_STATUS_EQUAL(status, NT_STATUS_FILE_CLOSED)) {
 586                 printf("smb2cli_read returned %s\n", nt_errstr(status));
 587                 return false;
 588         }
 589
 590         status = smb2cli_create(cli2, "session-reconnect.txt",
 591                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
 592                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
 593                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
 594                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
 595                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
 596                         FILE_CREATE, /* create_disposition, */
 597                         FILE_DELETE_ON_CLOSE, /* create_options, */
 598                         NULL, /* smb2_create_blobs *blobs */
 599                         &fid_persistent,
 600                         &fid_volatile);
 601         if (!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 do a new tcon and test file calls again */
 607
 608         status = cli_tree_connect(cli2, share, "?????", "", 0);
 609         if (!NT_STATUS_IS_OK(status)) {
 610                 printf("cli_tree_connect returned %s\n", nt_errstr(status));
 611                 return false;
 612         }
 613
 614         status = smb2cli_create(cli2, "session-reconnect.txt",
 615                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
 616                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
 617                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
 618                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
 619                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
 620                         FILE_CREATE, /* create_disposition, */
 621                         FILE_DELETE_ON_CLOSE, /* create_options, */
 622                         NULL, /* smb2_create_blobs *blobs */
 623                         &fid_persistent,
 624                         &fid_volatile);
 625         if (!NT_STATUS_IS_OK(status)) {
 626                 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
 627                 return false;
 628         }
 629
 630         status = smb2cli_write(cli2, strlen(hello), 0, fid_persistent,
 631                                fid_volatile, 0, 0, (const uint8_t *)hello);
 632         if (!NT_STATUS_IS_OK(status)) {
 633                 printf("smb2cli_write returned %s\n", nt_errstr(status));
 634                 return false;
 635         }
 636
 637         status = smb2cli_flush(cli2, fid_persistent, fid_volatile);
 638         if (!NT_STATUS_IS_OK(status)) {
 639                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 640                 return false;
 641         }
 642
 643         status = smb2cli_read(cli2, 0x10000, 0, fid_persistent,
 644                                fid_volatile, 2, 0,
 645                                talloc_tos(), &result, &nread);
 646         if (!NT_STATUS_IS_OK(status)) {
 647                 printf("smb2cli_read returned %s\n", nt_errstr(status));
 648                 return false;
 649         }
 650
 651         if (nread != strlen(hello)) {
 652                 printf("smb2cli_read returned %d bytes, expected %d\n",
 653                        (int)nread, (int)strlen(hello));
 654                 return false;
 655         }
 656
 657         if (memcmp(hello, result, nread) != 0) {
 658                 printf("smb2cli_read returned '%s', expected '%s'\n",
 659                        result, hello);
 660                 return false;
 661         }
 662
 663         return true;
 664 }
 665
 666 bool run_smb2_tcon_dependence(int dummy)
 667 {
 668         struct cli_state *cli;
 669         NTSTATUS status;
 670         uint64_t fid_persistent, fid_volatile;
 671         const char *hello = "Hello, world\n";
 672         uint8_t *result;
 673         uint32_t nread;
 674
 675         printf("Starting SMB2-TCON-DEPENDENCE\n");
 676
 677         if (!torture_init_connection(&cli)) {
 678                 return false;
 679         }
 680         cli->smb2.pid = 0xFEFF;
 681
 682         status = smbXcli_negprot(cli->conn, cli->timeout,
 683                                  PROTOCOL_SMB2_02, PROTOCOL_SMB2_24);
 684         if (!NT_STATUS_IS_OK(status)) {
 685                 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
 686                 return false;
 687         }
 688
 689         status = cli_session_setup(cli, username,
 690                                    password, strlen(password),
 691                                    password, strlen(password),
 692                                    workgroup);
 693         if (!NT_STATUS_IS_OK(status)) {
 694                 printf("cli_session_setup returned %s\n", nt_errstr(status));
 695                 return false;
 696         }
 697
 698         status = cli_tree_connect(cli, share, "?????", "", 0);
 699         if (!NT_STATUS_IS_OK(status)) {
 700                 printf("cli_tree_connect returned %s\n", nt_errstr(status));
 701                 return false;
 702         }
 703
 704         status = smb2cli_create(cli, "tcon_depedence.txt",
 705                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
 706                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
 707                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
 708                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
 709                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
 710                         FILE_CREATE, /* create_disposition, */
 711                         FILE_DELETE_ON_CLOSE, /* create_options, */
 712                         NULL, /* smb2_create_blobs *blobs */
 713                         &fid_persistent,
 714                         &fid_volatile);
 715         if (!NT_STATUS_IS_OK(status)) {
 716                 printf("smb2cli_create on cli %s\n", nt_errstr(status));
 717                 return false;
 718         }
 719
 720         status = smb2cli_write(cli, strlen(hello), 0, fid_persistent,
 721                                fid_volatile, 0, 0, (const uint8_t *)hello);
 722         if (!NT_STATUS_IS_OK(status)) {
 723                 printf("smb2cli_write returned %s\n", nt_errstr(status));
 724                 return false;
 725         }
 726
 727         status = smb2cli_flush(cli, fid_persistent, fid_volatile);
 728         if (!NT_STATUS_IS_OK(status)) {
 729                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 730                 return false;
 731         }
 732
 733         status = smb2cli_read(cli, 0x10000, 0, fid_persistent,
 734                                fid_volatile, 2, 0,
 735                                talloc_tos(), &result, &nread);
 736         if (!NT_STATUS_IS_OK(status)) {
 737                 printf("smb2cli_read returned %s\n", nt_errstr(status));
 738                 return false;
 739         }
 740
 741         if (nread != strlen(hello)) {
 742                 printf("smb2cli_read returned %d bytes, expected %d\n",
 743                        (int)nread, (int)strlen(hello));
 744                 return false;
 745         }
 746
 747         if (memcmp(hello, result, nread) != 0) {
 748                 printf("smb2cli_read returned '%s', expected '%s'\n",
 749                        result, hello);
 750                 return false;
 751         }
 752
 753         /* check behaviour with wrong tid... */
 754
 755         cli->smb2.tid++;
 756
 757         status = smb2cli_read(cli, 0x10000, 0, fid_persistent,
 758                                fid_volatile, 2, 0,
 759                                talloc_tos(), &result, &nread);
 760         if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
 761                 printf("smb2cli_read returned %s\n", nt_errstr(status));
 762                 return false;
 763         }
 764
 765         cli->smb2.tid--;
 766
 767         return true;
 768 }
 769
 770 bool run_smb2_multi_channel(int dummy)
 771 {
 772         struct cli_state *cli1;
 773         struct cli_state *cli2;
 774         NTSTATUS status;
 775         bool ok;
 776         uint64_t fid_persistent, fid_volatile;
 777         struct tevent_context *ev;
 778         struct tevent_req *subreq;
 779         DATA_BLOB in_blob = data_blob_null;
 780         DATA_BLOB out_blob;
 781         DATA_BLOB session_key;
 782         struct auth_generic_state *auth_generic_state;
 783         struct iovec *recv_iov;
 784         const char *hello = "Hello, world\n";
 785         uint8_t *result;
 786         uint32_t nread;
 787
 788         printf("Starting SMB2-MULTI-CHANNEL\n");
 789
 790         if (!torture_init_connection(&cli1)) {
 791                 return false;
 792         }
 793         cli1->smb2.pid = 0xFEFF;
 794
 795         if (!torture_init_connection(&cli2)) {
 796                 return false;
 797         }
 798         cli2->smb2.pid = 0xFEFF;
 799
 800         status = smbXcli_negprot(cli1->conn, cli1->timeout,
 801                                  PROTOCOL_SMB2_22, PROTOCOL_SMB2_24);
 802         if (!NT_STATUS_IS_OK(status)) {
 803                 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
 804                 return false;
 805         }
 806
 807         status = smbXcli_negprot(cli2->conn, cli2->timeout,
 808                                  PROTOCOL_SMB2_22, PROTOCOL_SMB2_24);
 809         if (!NT_STATUS_IS_OK(status)) {
 810                 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
 811                 return false;
 812         }
 813
 814         status = cli_session_setup(cli1, username,
 815                                    password, strlen(password),
 816                                    password, strlen(password),
 817                                    workgroup);
 818         if (!NT_STATUS_IS_OK(status)) {
 819                 printf("smb2cli_sesssetup returned %s\n", nt_errstr(status));
 820                 return false;
 821         }
 822
 823         status = cli_tree_connect(cli1, share, "?????", "", 0);
 824         if (!NT_STATUS_IS_OK(status)) {
 825                 printf("cli_tree_connect returned %s\n", nt_errstr(status));
 826                 return false;
 827         }
 828
 829         status = smb2cli_session_create_channel(cli2,
 830                                                 cli1->smb2.session,
 831                                                 cli2->conn,
 832                                                 &cli2->smb2.session);
 833         if (!NT_STATUS_IS_OK(status)) {
 834                 printf("smb2cli_session_create_channel returned %s\n",
 835                         nt_errstr(status));
 836                 return false;
 837         }
 838
 839         status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
 840         if (!NT_STATUS_IS_OK(status)) {
 841                 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
 842                 return false;
 843         }
 844
 845         gensec_want_feature(auth_generic_state->gensec_security,
 846                             GENSEC_FEATURE_SESSION_KEY);
 847         status = auth_generic_set_username(auth_generic_state, username);
 848         if (!NT_STATUS_IS_OK(status)) {
 849                 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
 850                 return false;
 851         }
 852
 853         status = auth_generic_set_domain(auth_generic_state, workgroup);
 854         if (!NT_STATUS_IS_OK(status)) {
 855                 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
 856                 return false;
 857         }
 858
 859         status = auth_generic_set_password(auth_generic_state, password);
 860         if (!NT_STATUS_IS_OK(status)) {
 861                 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
 862                 return false;
 863         }
 864
 865         status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
 866         if (!NT_STATUS_IS_OK(status)) {
 867                 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
 868                 return false;
 869         }
 870
 871         ev = event_context_init(talloc_tos());
 872         if (ev == NULL) {
 873                 printf("event_context_init() returned NULL\n");
 874                 return false;
 875         }
 876
 877         status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
 878         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 879                 printf("gensec_update returned %s\n", nt_errstr(status));
 880                 return false;
 881         }
 882
 883         subreq = smb2cli_session_setup_send(talloc_tos(), ev,
 884                                             cli2->conn,
 885                                             cli2->timeout,
 886                                             cli2->smb2.session,
 887                                             0x01, /* in_flags */
 888                                             SMB2_CAP_DFS, /* in_capabilities */
 889                                             0, /* in_channel */
 890                                             NULL, /* in_previous_session */
 891                                             &in_blob); /* in_security_buffer */
 892         if (subreq == NULL) {
 893                 printf("smb2cli_session_setup_send() returned NULL\n");
 894                 return false;
 895         }
 896
 897         ok = tevent_req_poll(subreq, ev);
 898         if (!ok) {
 899                 printf("tevent_req_poll() returned false\n");
 900                 return false;
 901         }
 902
 903         status = smb2cli_session_setup_recv(subreq, talloc_tos(),
 904                                             NULL, &out_blob);
 905         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
 906                 printf("smb2cli_session_setup_recv returned %s\n",
 907                         nt_errstr(status));
 908                 return false;
 909         }
 910
 911         status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
 912         if (!NT_STATUS_IS_OK(status)) {
 913                 printf("auth_generic_update returned %s\n", nt_errstr(status));
 914                 return false;
 915         }
 916
 917         subreq = smb2cli_session_setup_send(talloc_tos(), ev,
 918                                             cli2->conn,
 919                                             cli2->timeout,
 920                                             cli2->smb2.session,
 921                                             0x01, /* in_flags */
 922                                             SMB2_CAP_DFS, /* in_capabilities */
 923                                             0, /* in_channel */
 924                                             NULL, /* in_previous_session */
 925                                             &in_blob); /* in_security_buffer */
 926         if (subreq == NULL) {
 927                 printf("smb2cli_session_setup_send() returned NULL\n");
 928                 return false;
 929         }
 930
 931         ok = tevent_req_poll(subreq, ev);
 932         if (!ok) {
 933                 printf("tevent_req_poll() returned false\n");
 934                 return false;
 935         }
 936
 937         status = smb2cli_session_setup_recv(subreq, talloc_tos(),
 938                                             &recv_iov, &out_blob);
 939         if (!NT_STATUS_IS_OK(status)) {
 940                 printf("smb2cli_session_setup_recv returned %s\n",
 941                         nt_errstr(status));
 942                 return false;
 943         }
 944
 945         status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(),
 946                                     &session_key);
 947         if (!NT_STATUS_IS_OK(status)) {
 948                 printf("gensec_session_key returned %s\n",
 949                         nt_errstr(status));
 950                 return false;
 951         }
 952
 953         status = smb2cli_session_update_session_key(cli2->smb2.session,
 954                                                     session_key,
 955                                                     recv_iov);
 956         if (!NT_STATUS_IS_OK(status)) {
 957                 printf("smb2cli_session_update_session_key %s\n", nt_errstr(status));
 958                 return false;
 959         }
 960
 961         cli2->smb2.tid = cli1->smb2.tid;
 962
 963         status = smb2cli_create(cli2, "multi-channel.txt",
 964                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
 965                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
 966                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
 967                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
 968                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
 969                         FILE_CREATE, /* create_disposition, */
 970                         FILE_DELETE_ON_CLOSE, /* create_options, */
 971                         NULL, /* smb2_create_blobs *blobs */
 972                         &fid_persistent,
 973                         &fid_volatile);
 974         if (!NT_STATUS_IS_OK(status)) {
 975                 printf("smb2cli_create on cli2 %s\n", nt_errstr(status));
 976                 return false;
 977         }
 978
 979         status = smb2cli_write(cli1, strlen(hello), 0, fid_persistent,
 980                                fid_volatile, 0, 0, (const uint8_t *)hello);
 981         if (!NT_STATUS_IS_OK(status)) {
 982                 printf("smb2cli_write returned %s\n", nt_errstr(status));
 983                 return false;
 984         }
 985
 986         status = smb2cli_flush(cli2, fid_persistent, fid_volatile);
 987         if (!NT_STATUS_IS_OK(status)) {
 988                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 989                 return false;
 990         }
 991
 992         status = smb2cli_flush(cli1, fid_persistent, fid_volatile);
 993         if (!NT_STATUS_IS_OK(status)) {
 994                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
 995                 return false;
 996         }
 997
 998         status = smb2cli_read(cli2, 0x10000, 0, fid_persistent,
 999                                fid_volatile, 2, 0,
1000                                talloc_tos(), &result, &nread);
1001         if (!NT_STATUS_IS_OK(status)) {
1002                 printf("smb2cli_read returned %s\n", nt_errstr(status));
1003                 return false;
1004         }
1005
1006         if (nread != strlen(hello)) {
1007                 printf("smb2cli_read returned %d bytes, expected %d\n",
1008                        (int)nread, (int)strlen(hello));
1009                 return false;
1010         }
1011
1012         if (memcmp(hello, result, nread) != 0) {
1013                 printf("smb2cli_read returned '%s', expected '%s'\n",
1014                        result, hello);
1015                 return false;
1016         }
1017
1018         status = smb2cli_close(cli1, 0, fid_persistent, fid_volatile);
1019         if (!NT_STATUS_IS_OK(status)) {
1020                 printf("smb2cli_close returned %s\n", nt_errstr(status));
1021                 return false;
1022         }
1023
1024         status = smb2cli_flush(cli2, fid_persistent, fid_volatile);
1025         if (!NT_STATUS_IS_OK(status)) {
1026                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1027         }
1028
1029         status = smb2cli_flush(cli1, fid_persistent, fid_volatile);
1030         if (!NT_STATUS_IS_OK(status)) {
1031                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1032         }
1033
1034         return true;
1035 }
1036
1037 bool run_smb2_session_reauth(int dummy)
1038 {
1039         struct cli_state *cli;
1040         NTSTATUS status;
1041         bool ok;
1042         uint64_t fid_persistent, fid_volatile;
1043         struct tevent_context *ev;
1044         struct tevent_req *subreq;
1045         DATA_BLOB in_blob = data_blob_null;
1046         DATA_BLOB out_blob;
1047         DATA_BLOB session_key;
1048         struct auth_generic_state *auth_generic_state;
1049         struct iovec *recv_iov;
1050
1051         printf("Starting SMB2-SESSION_REAUTH\n");
1052
1053         if (!torture_init_connection(&cli)) {
1054                 return false;
1055         }
1056         cli->smb2.pid = 0xFEFF;
1057
1058         /*
1059          * PROTOCOL_SMB2_22 has a bug in win8pre0
1060          * it behaves like PROTOCOL_SMB2_02
1061          * and returns NT_STATUS_REQUEST_NOT_ACCEPTED,
1062          * while it allows it on PROTOCOL_SMB2_02.
1063          */
1064         status = smbXcli_negprot(cli->conn, cli->timeout,
1065                                  PROTOCOL_SMB2_10, PROTOCOL_SMB2_10);
1066         if (!NT_STATUS_IS_OK(status)) {
1067                 printf("smbXcli_negprot returned %s\n", nt_errstr(status));
1068                 return false;
1069         }
1070
1071         status = cli_session_setup(cli, username,
1072                                    password, strlen(password),
1073                                    password, strlen(password),
1074                                    workgroup);
1075         if (!NT_STATUS_IS_OK(status)) {
1076                 printf("smb2cli_sesssetup returned %s\n", nt_errstr(status));
1077                 return false;
1078         }
1079
1080         status = cli_tree_connect(cli, share, "?????", "", 0);
1081         if (!NT_STATUS_IS_OK(status)) {
1082                 printf("cli_tree_connect returned %s\n", nt_errstr(status));
1083                 return false;
1084         }
1085
1086         status = smb2cli_create(cli, "session-reauth.txt",
1087                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1088                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1089                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1090                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1091                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1092                         FILE_CREATE, /* create_disposition, */
1093                         FILE_DELETE_ON_CLOSE, /* create_options, */
1094                         NULL, /* smb2_create_blobs *blobs */
1095                         &fid_persistent,
1096                         &fid_volatile);
1097         if (!NT_STATUS_IS_OK(status)) {
1098                 printf("smb2cli_create %s\n", nt_errstr(status));
1099                 return false;
1100         }
1101
1102         status = auth_generic_client_prepare(talloc_tos(), &auth_generic_state);
1103         if (!NT_STATUS_IS_OK(status)) {
1104                 printf("auth_generic_client_prepare returned %s\n", nt_errstr(status));
1105                 return false;
1106         }
1107
1108         gensec_want_feature(auth_generic_state->gensec_security,
1109                             GENSEC_FEATURE_SESSION_KEY);
1110         status = auth_generic_set_username(auth_generic_state, username);
1111         if (!NT_STATUS_IS_OK(status)) {
1112                 printf("auth_generic_set_username returned %s\n", nt_errstr(status));
1113                 return false;
1114         }
1115
1116         status = auth_generic_set_domain(auth_generic_state, workgroup);
1117         if (!NT_STATUS_IS_OK(status)) {
1118                 printf("auth_generic_set_domain returned %s\n", nt_errstr(status));
1119                 return false;
1120         }
1121
1122         status = auth_generic_set_password(auth_generic_state, password);
1123         if (!NT_STATUS_IS_OK(status)) {
1124                 printf("auth_generic_set_password returned %s\n", nt_errstr(status));
1125                 return false;
1126         }
1127
1128         status = auth_generic_client_start(auth_generic_state, GENSEC_OID_NTLMSSP);
1129         if (!NT_STATUS_IS_OK(status)) {
1130                 printf("auth_generic_client_start returned %s\n", nt_errstr(status));
1131                 return false;
1132         }
1133
1134         ev = event_context_init(talloc_tos());
1135         if (ev == NULL) {
1136                 printf("event_context_init() returned NULL\n");
1137                 return false;
1138         }
1139
1140         status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, data_blob_null, &in_blob);
1141         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1142                 printf("gensec_update returned %s\n", nt_errstr(status));
1143                 return false;
1144         }
1145
1146         subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1147                                             cli->conn,
1148                                             cli->timeout,
1149                                             cli->smb2.session,
1150                                             0x0, /* in_flags */
1151                                             SMB2_CAP_DFS, /* in_capabilities */
1152                                             0, /* in_channel */
1153                                             NULL, /* in_previous_session */
1154                                             &in_blob); /* in_security_buffer */
1155         if (subreq == NULL) {
1156                 printf("smb2cli_session_setup_send() returned NULL\n");
1157                 return false;
1158         }
1159
1160         ok = tevent_req_poll(subreq, ev);
1161         if (!ok) {
1162                 printf("tevent_req_poll() returned false\n");
1163                 return false;
1164         }
1165
1166         status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1167                                             NULL, &out_blob);
1168         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
1169                 printf("smb2cli_session_setup_recv returned %s\n",
1170                         nt_errstr(status));
1171                 return false;
1172         }
1173
1174         status = gensec_update(auth_generic_state->gensec_security, talloc_tos(), ev, out_blob, &in_blob);
1175         if (!NT_STATUS_IS_OK(status)) {
1176                 printf("auth_generic_update returned %s\n", nt_errstr(status));
1177                 return false;
1178         }
1179
1180         subreq = smb2cli_session_setup_send(talloc_tos(), ev,
1181                                             cli->conn,
1182                                             cli->timeout,
1183                                             cli->smb2.session,
1184                                             0x0, /* in_flags */
1185                                             SMB2_CAP_DFS, /* in_capabilities */
1186                                             0, /* in_channel */
1187                                             NULL, /* in_previous_session */
1188                                             &in_blob); /* in_security_buffer */
1189         if (subreq == NULL) {
1190                 printf("smb2cli_session_setup_send() returned NULL\n");
1191                 return false;
1192         }
1193
1194         ok = tevent_req_poll(subreq, ev);
1195         if (!ok) {
1196                 printf("tevent_req_poll() returned false\n");
1197                 return false;
1198         }
1199
1200         status = smb2cli_session_setup_recv(subreq, talloc_tos(),
1201                                             &recv_iov, &out_blob);
1202         if (!NT_STATUS_IS_OK(status)) {
1203                 printf("smb2cli_session_setup_recv returned %s\n",
1204                         nt_errstr(status));
1205                 return false;
1206         }
1207
1208         status = gensec_session_key(auth_generic_state->gensec_security, talloc_tos(),
1209                                     &session_key);
1210         if (!NT_STATUS_IS_OK(status)) {
1211                 printf("gensec_session_key returned %s\n",
1212                         nt_errstr(status));
1213                 return false;
1214         }
1215
1216         status = smb2cli_session_update_session_key(cli->smb2.session,
1217                                                     session_key,
1218                                                     recv_iov);
1219         if (!NT_STATUS_IS_OK(status)) {
1220                 printf("smb2cli_session_update_session_key %s\n", nt_errstr(status));
1221                 return false;
1222         }
1223
1224         status = smb2cli_flush(cli, fid_persistent, fid_volatile);
1225         if (!NT_STATUS_IS_OK(status)) {
1226                 printf("smb2cli_flush returned %s\n", nt_errstr(status));
1227                 return false;
1228         }
1229
1230         status = smb2cli_close(cli, 0, fid_persistent, fid_volatile);
1231         if (!NT_STATUS_IS_OK(status)) {
1232                 printf("smb2cli_close returned %s\n", nt_errstr(status));
1233                 return false;
1234         }
1235
1236         status = smb2cli_create(cli, "multi-channel.txt",
1237                         SMB2_OPLOCK_LEVEL_NONE, /* oplock_level, */
1238                         SMB2_IMPERSONATION_IMPERSONATION, /* impersonation_level, */
1239                         SEC_STD_ALL | SEC_FILE_ALL, /* desired_access, */
1240                         FILE_ATTRIBUTE_NORMAL, /* file_attributes, */
1241                         FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, /* share_access, */
1242                         FILE_CREATE, /* create_disposition, */
1243                         FILE_DELETE_ON_CLOSE, /* create_options, */
1244                         NULL, /* smb2_create_blobs *blobs */
1245                         &fid_persistent,
1246                         &fid_volatile);
1247         if (!NT_STATUS_IS_OK(status)) {
1248                 printf("smb2cli_create %s\n", nt_errstr(status));
1249                 return false;
1250         }
1251
1252         status = smb2cli_close(cli, 0, fid_persistent, fid_volatile);
1253         if (!NT_STATUS_IS_OK(status)) {
1254                 printf("smb2cli_close returned %s\n", nt_errstr(status));
1255                 return false;
1256         }
1257
1258         return true;
1259 }