source4/torture/smb2/util.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    helper functions for SMB2 test suite
   5
   6    Copyright (C) Andrew Tridgell 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "libcli/security/security_descriptor.h"
  24 #include "libcli/smb2/smb2.h"
  25 #include "libcli/smb2/smb2_calls.h"
  26 #include "../libcli/smb/smbXcli_base.h"
  27 #include "lib/cmdline/popt_common.h"
  28 #include "system/time.h"
  29 #include "librpc/gen_ndr/ndr_security.h"
  30 #include "param/param.h"
  31 #include "libcli/resolve/resolve.h"
  32
  33 #include "torture/torture.h"
  34 #include "torture/smb2/proto.h"
  35
  36
  37 /*
  38   write to a file on SMB2
  39 */
  40 NTSTATUS smb2_util_write(struct smb2_tree *tree,
  41                          struct smb2_handle handle,
  42                          const void *buf, off_t offset, size_t size)
  43 {
  44         struct smb2_write w;
  45
  46         ZERO_STRUCT(w);
  47         w.in.file.handle = handle;
  48         w.in.offset      = offset;
  49         w.in.data        = data_blob_const(buf, size);
  50
  51         return smb2_write(tree, &w);
  52 }
  53
  54 /*
  55   create a complex file/dir using the SMB2 protocol
  56 */
  57 static NTSTATUS smb2_create_complex(struct smb2_tree *tree, const char *fname,
  58                                          struct smb2_handle *handle, bool dir)
  59 {
  60         TALLOC_CTX *tmp_ctx = talloc_new(tree);
  61         char buf[7] = "abc";
  62         struct smb2_create io;
  63         union smb_setfileinfo setfile;
  64         union smb_fileinfo fileinfo;
  65         time_t t = (time(NULL) & ~1);
  66         NTSTATUS status;
  67
  68         smb2_util_unlink(tree, fname);
  69         ZERO_STRUCT(io);
  70         io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
  71         io.in.file_attributes   = FILE_ATTRIBUTE_NORMAL;
  72         io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
  73         io.in.share_access =
  74                 NTCREATEX_SHARE_ACCESS_DELETE|
  75                 NTCREATEX_SHARE_ACCESS_READ|
  76                 NTCREATEX_SHARE_ACCESS_WRITE;
  77         io.in.create_options = 0;
  78         io.in.fname = fname;
  79         if (dir) {
  80                 io.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
  81                 io.in.share_access &= ~NTCREATEX_SHARE_ACCESS_DELETE;
  82                 io.in.file_attributes   = FILE_ATTRIBUTE_DIRECTORY;
  83                 io.in.create_disposition = NTCREATEX_DISP_CREATE;
  84         }
  85
  86         /* it seems vista is now fussier about alignment? */
  87         if (strchr(fname, ':') == NULL) {
  88                 /* setup some EAs */
  89                 io.in.eas.num_eas = 2;
  90                 io.in.eas.eas = talloc_array(tmp_ctx, struct ea_struct, 2);
  91                 io.in.eas.eas[0].flags = 0;
  92                 io.in.eas.eas[0].name.s = "EAONE";
  93                 io.in.eas.eas[0].value = data_blob_talloc(tmp_ctx, "VALUE1", 6);
  94                 io.in.eas.eas[1].flags = 0;
  95                 io.in.eas.eas[1].name.s = "SECONDEA";
  96                 io.in.eas.eas[1].value = data_blob_talloc(tmp_ctx, "ValueTwo", 8);
  97         }
  98
  99         status = smb2_create(tree, tmp_ctx, &io);
 100         talloc_free(tmp_ctx);
 101         NT_STATUS_NOT_OK_RETURN(status);
 102
 103         *handle = io.out.file.handle;
 104
 105         if (!dir) {
 106                 status = smb2_util_write(tree, *handle, buf, 0, sizeof(buf));
 107                 NT_STATUS_NOT_OK_RETURN(status);
 108         }
 109
 110         /* make sure all the timestamps aren't the same, and are also
 111            in different DST zones*/
 112         setfile.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
 113         setfile.generic.in.file.handle = *handle;
 114
 115         unix_to_nt_time(&setfile.basic_info.in.create_time, t + 9*30*24*60*60);
 116         unix_to_nt_time(&setfile.basic_info.in.access_time, t + 6*30*24*60*60);
 117         unix_to_nt_time(&setfile.basic_info.in.write_time,  t + 3*30*24*60*60);
 118         unix_to_nt_time(&setfile.basic_info.in.change_time, t + 1*30*24*60*60);
 119         setfile.basic_info.in.attrib      = FILE_ATTRIBUTE_NORMAL;
 120
 121         status = smb2_setinfo_file(tree, &setfile);
 122         if (!NT_STATUS_IS_OK(status)) {
 123                 printf("Failed to setup file times - %s\n", nt_errstr(status));
 124                 return status;
 125         }
 126
 127         /* make sure all the timestamps aren't the same */
 128         fileinfo.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
 129         fileinfo.generic.in.file.handle = *handle;
 130
 131         status = smb2_getinfo_file(tree, tree, &fileinfo);
 132         if (!NT_STATUS_IS_OK(status)) {
 133                 printf("Failed to query file times - %s\n", nt_errstr(status));
 134                 return status;
 135
 136         }
 137
 138 #define CHECK_TIME(field) do {\
 139         if (setfile.basic_info.in.field != fileinfo.all_info2.out.field) { \
 140                 printf("(%s) " #field " not setup correctly: %s(%llu) => %s(%llu)\n", \
 141                         __location__, \
 142                         nt_time_string(tree, setfile.basic_info.in.field), \
 143                         (unsigned long long)setfile.basic_info.in.field, \
 144                         nt_time_string(tree, fileinfo.basic_info.out.field), \
 145                         (unsigned long long)fileinfo.basic_info.out.field); \
 146                 status = NT_STATUS_INVALID_PARAMETER; \
 147         } \
 148 } while (0)
 149
 150         CHECK_TIME(create_time);
 151         CHECK_TIME(access_time);
 152         CHECK_TIME(write_time);
 153         CHECK_TIME(change_time);
 154
 155         return status;
 156 }
 157
 158 /*
 159   create a complex file using the SMB2 protocol
 160 */
 161 NTSTATUS smb2_create_complex_file(struct smb2_tree *tree, const char *fname,
 162                                          struct smb2_handle *handle)
 163 {
 164         return smb2_create_complex(tree, fname, handle, false);
 165 }
 166
 167 /*
 168   create a complex dir using the SMB2 protocol
 169 */
 170 NTSTATUS smb2_create_complex_dir(struct smb2_tree *tree, const char *fname,
 171                                  struct smb2_handle *handle)
 172 {
 173         return smb2_create_complex(tree, fname, handle, true);
 174 }
 175
 176 /*
 177   show lots of information about a file
 178 */
 179 void torture_smb2_all_info(struct smb2_tree *tree, struct smb2_handle handle)
 180 {
 181         NTSTATUS status;
 182         TALLOC_CTX *tmp_ctx = talloc_new(tree);
 183         union smb_fileinfo io;
 184
 185         io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
 186         io.generic.in.file.handle = handle;
 187
 188         status = smb2_getinfo_file(tree, tmp_ctx, &io);
 189         if (!NT_STATUS_IS_OK(status)) {
 190                 DEBUG(0,("getinfo failed - %s\n", nt_errstr(status)));
 191                 talloc_free(tmp_ctx);
 192                 return;
 193         }
 194
 195         d_printf("all_info for '%s'\n", io.all_info2.out.fname.s);
 196         d_printf("\tcreate_time:    %s\n", nt_time_string(tmp_ctx, io.all_info2.out.create_time));
 197         d_printf("\taccess_time:    %s\n", nt_time_string(tmp_ctx, io.all_info2.out.access_time));
 198         d_printf("\twrite_time:     %s\n", nt_time_string(tmp_ctx, io.all_info2.out.write_time));
 199         d_printf("\tchange_time:    %s\n", nt_time_string(tmp_ctx, io.all_info2.out.change_time));
 200         d_printf("\tattrib:         0x%x\n", io.all_info2.out.attrib);
 201         d_printf("\tunknown1:       0x%x\n", io.all_info2.out.unknown1);
 202         d_printf("\talloc_size:     %llu\n", (long long)io.all_info2.out.alloc_size);
 203         d_printf("\tsize:           %llu\n", (long long)io.all_info2.out.size);
 204         d_printf("\tnlink:          %u\n", io.all_info2.out.nlink);
 205         d_printf("\tdelete_pending: %u\n", io.all_info2.out.delete_pending);
 206         d_printf("\tdirectory:      %u\n", io.all_info2.out.directory);
 207         d_printf("\tfile_id:        %llu\n", (long long)io.all_info2.out.file_id);
 208         d_printf("\tea_size:        %u\n", io.all_info2.out.ea_size);
 209         d_printf("\taccess_mask:    0x%08x\n", io.all_info2.out.access_mask);
 210         d_printf("\tposition:       0x%llx\n", (long long)io.all_info2.out.position);
 211         d_printf("\tmode:           0x%llx\n", (long long)io.all_info2.out.mode);
 212
 213         /* short name, if any */
 214         io.generic.level = RAW_FILEINFO_ALT_NAME_INFORMATION;
 215         status = smb2_getinfo_file(tree, tmp_ctx, &io);
 216         if (NT_STATUS_IS_OK(status)) {
 217                 d_printf("\tshort name:     '%s'\n", io.alt_name_info.out.fname.s);
 218         }
 219
 220         /* the EAs, if any */
 221         io.generic.level = RAW_FILEINFO_SMB2_ALL_EAS;
 222         status = smb2_getinfo_file(tree, tmp_ctx, &io);
 223         if (NT_STATUS_IS_OK(status)) {
 224                 int i;
 225                 for (i=0;i<io.all_eas.out.num_eas;i++) {
 226                         d_printf("\tEA[%d] flags=%d len=%d '%s'\n", i,
 227                                  io.all_eas.out.eas[i].flags,
 228                                  (int)io.all_eas.out.eas[i].value.length,
 229                                  io.all_eas.out.eas[i].name.s);
 230                 }
 231         }
 232
 233         /* streams, if available */
 234         io.generic.level = RAW_FILEINFO_STREAM_INFORMATION;
 235         status = smb2_getinfo_file(tree, tmp_ctx, &io);
 236         if (NT_STATUS_IS_OK(status)) {
 237                 int i;
 238                 for (i=0;i<io.stream_info.out.num_streams;i++) {
 239                         d_printf("\tstream %d:\n", i);
 240                         d_printf("\t\tsize       %ld\n",
 241                                  (long)io.stream_info.out.streams[i].size);
 242                         d_printf("\t\talloc size %ld\n",
 243                                  (long)io.stream_info.out.streams[i].alloc_size);
 244                         d_printf("\t\tname       %s\n", io.stream_info.out.streams[i].stream_name.s);
 245                 }
 246         }
 247
 248         if (DEBUGLVL(1)) {
 249                 /* the security descriptor */
 250                 io.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
 251                 io.query_secdesc.in.secinfo_flags =
 252                         SECINFO_OWNER|SECINFO_GROUP|
 253                         SECINFO_DACL;
 254                 status = smb2_getinfo_file(tree, tmp_ctx, &io);
 255                 if (NT_STATUS_IS_OK(status)) {
 256                         NDR_PRINT_DEBUG(security_descriptor, io.query_secdesc.out.sd);
 257                 }
 258         }
 259
 260         talloc_free(tmp_ctx);
 261 }
 262
 263 /**
 264  * open a smb2 tree connect
 265  */
 266 bool torture_smb2_tree_connect(struct torture_context *tctx,
 267                                struct smb2_session *session,
 268                                TALLOC_CTX *mem_ctx,
 269                                struct smb2_tree **_tree)
 270 {
 271         NTSTATUS status;
 272         const char *host = torture_setting_string(tctx, "host", NULL);
 273         const char *share = torture_setting_string(tctx, "share", NULL);
 274         struct smb2_tree_connect tcon;
 275         struct smb2_tree *tree;
 276
 277         ZERO_STRUCT(tcon);
 278         tcon.in.reserved = 0;
 279         tcon.in.path = talloc_asprintf(tctx, "\\\\%s\\%s", host, share);
 280         if (tcon.in.path == NULL) {
 281                 printf("talloc failed\n");
 282                 return false;
 283         }
 284
 285         status = smb2_tree_connect(session, &tcon);
 286         if (!NT_STATUS_IS_OK(status)) {
 287                 printf("Failed to tree_connect to SMB2 share \\\\%s\\%s - %s\n",
 288                        host, share, nt_errstr(status));
 289                 return false;
 290         }
 291
 292         tree = smb2_tree_init(session, mem_ctx, true);
 293         if (tree == NULL) {
 294                 printf("talloc failed\n");
 295                 return false;
 296         }
 297
 298         smb2cli_tcon_set_values(tree->smbXcli,
 299                                 tree->session->smbXcli,
 300                                 tcon.out.tid,
 301                                 tcon.out.share_type,
 302                                 tcon.out.flags,
 303                                 tcon.out.capabilities,
 304                                 tcon.out.access_mask);
 305
 306         *_tree = tree;
 307
 308         return true;
 309 }
 310
 311 /**
 312  * do a smb2 session setup (without a tree connect)
 313  */
 314 bool torture_smb2_session_setup(struct torture_context *tctx,
 315                                 struct smb2_transport *transport,
 316                                 uint64_t previous_session_id,
 317                                 TALLOC_CTX *mem_ctx,
 318                                 struct smb2_session **_session)
 319 {
 320         NTSTATUS status;
 321         struct smb2_session *session;
 322         struct cli_credentials *credentials = cmdline_credentials;
 323
 324         session = smb2_session_init(transport,
 325                                     lpcfg_gensec_settings(tctx, tctx->lp_ctx),
 326                                     mem_ctx);
 327
 328         if (session == NULL) {
 329                 return false;
 330         }
 331
 332         status = smb2_session_setup_spnego(session, credentials,
 333                                            previous_session_id);
 334         if (!NT_STATUS_IS_OK(status)) {
 335                 printf("session setup failed: %s\n", nt_errstr(status));
 336                 talloc_free(session);
 337                 return false;
 338         }
 339
 340         *_session = session;
 341
 342         return true;
 343 }
 344
 345 /*
 346   open a smb2 connection
 347 */
 348 bool torture_smb2_connection_ext(struct torture_context *tctx,
 349                                  uint64_t previous_session_id,
 350                                  const struct smbcli_options *options,
 351                                  struct smb2_tree **tree)
 352 {
 353         NTSTATUS status;
 354         const char *host = torture_setting_string(tctx, "host", NULL);
 355         const char *share = torture_setting_string(tctx, "share", NULL);
 356         struct cli_credentials *credentials = cmdline_credentials;
 357
 358         status = smb2_connect_ext(tctx,
 359                                   host,
 360                                   lpcfg_smb_ports(tctx->lp_ctx),
 361                                   share,
 362                                   lpcfg_resolve_context(tctx->lp_ctx),
 363                                   credentials,
 364                                   previous_session_id,
 365                                   tree,
 366                                   tctx->ev,
 367                                   options,
 368                                   lpcfg_socket_options(tctx->lp_ctx),
 369                                   lpcfg_gensec_settings(tctx, tctx->lp_ctx)
 370                                   );
 371         if (!NT_STATUS_IS_OK(status)) {
 372                 printf("Failed to connect to SMB2 share \\\\%s\\%s - %s\n",
 373                        host, share, nt_errstr(status));
 374                 return false;
 375         }
 376         return true;
 377 }
 378
 379 bool torture_smb2_connection(struct torture_context *tctx, struct smb2_tree **tree)
 380 {
 381         bool ret;
 382         struct smbcli_options options;
 383
 384         lpcfg_smbcli_options(tctx->lp_ctx, &options);
 385
 386         ret = torture_smb2_connection_ext(tctx, 0, &options, tree);
 387
 388         return ret;
 389 }
 390
 391 /**
 392  * SMB2 connect with share from soption
 393  **/
 394 bool torture_smb2_con_sopt(struct torture_context *tctx,
 395                            const char *soption,
 396                            struct smb2_tree **tree)
 397 {
 398         bool ret;
 399         struct smbcli_options options;
 400         NTSTATUS status;
 401         const char *host = torture_setting_string(tctx, "host", NULL);
 402         const char *share = torture_setting_string(tctx, soption, NULL);
 403         struct cli_credentials *credentials = cmdline_credentials;
 404
 405         lpcfg_smbcli_options(tctx->lp_ctx, &options);
 406
 407         if (share == NULL) {
 408                 printf("No share for option %s\n", soption);
 409                 return false;
 410         }
 411
 412         status = smb2_connect_ext(tctx,
 413                                   host,
 414                                   lpcfg_smb_ports(tctx->lp_ctx),
 415                                   share,
 416                                   lpcfg_resolve_context(tctx->lp_ctx),
 417                                   credentials,
 418                                   0,
 419                                   tree,
 420                                   tctx->ev,
 421                                   &options,
 422                                   lpcfg_socket_options(tctx->lp_ctx),
 423                                   lpcfg_gensec_settings(tctx, tctx->lp_ctx)
 424                                   );
 425         if (!NT_STATUS_IS_OK(status)) {
 426                 printf("Failed to connect to SMB2 share \\\\%s\\%s - %s\n",
 427                        host, share, nt_errstr(status));
 428                 return false;
 429         }
 430         return true;
 431 }
 432
 433
 434 /*
 435   create and return a handle to a test file
 436 */
 437 NTSTATUS torture_smb2_testfile(struct smb2_tree *tree, const char *fname,
 438                                struct smb2_handle *handle)
 439 {
 440         struct smb2_create io;
 441         NTSTATUS status;
 442
 443         ZERO_STRUCT(io);
 444         io.in.oplock_level = 0;
 445         io.in.desired_access = SEC_RIGHTS_FILE_ALL;
 446         io.in.file_attributes   = FILE_ATTRIBUTE_NORMAL;
 447         io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 448         io.in.share_access =
 449                 NTCREATEX_SHARE_ACCESS_DELETE|
 450                 NTCREATEX_SHARE_ACCESS_READ|
 451                 NTCREATEX_SHARE_ACCESS_WRITE;
 452         io.in.create_options = 0;
 453         io.in.fname = fname;
 454
 455         status = smb2_create(tree, tree, &io);
 456         NT_STATUS_NOT_OK_RETURN(status);
 457
 458         *handle = io.out.file.handle;
 459
 460         return NT_STATUS_OK;
 461 }
 462
 463 /*
 464   create and return a handle to a test directory
 465 */
 466 NTSTATUS torture_smb2_testdir(struct smb2_tree *tree, const char *fname,
 467                               struct smb2_handle *handle)
 468 {
 469         struct smb2_create io;
 470         NTSTATUS status;
 471
 472         ZERO_STRUCT(io);
 473         io.in.oplock_level = 0;
 474         io.in.desired_access = SEC_RIGHTS_DIR_ALL;
 475         io.in.file_attributes   = FILE_ATTRIBUTE_DIRECTORY;
 476         io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 477         io.in.share_access = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE;
 478         io.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
 479         io.in.fname = fname;
 480
 481         status = smb2_create(tree, tree, &io);
 482         NT_STATUS_NOT_OK_RETURN(status);
 483
 484         *handle = io.out.file.handle;
 485
 486         return NT_STATUS_OK;
 487 }
 488
 489
 490 /*
 491   create a complex file using SMB2, to make it easier to
 492   find fields in SMB2 getinfo levels
 493 */
 494 NTSTATUS torture_setup_complex_file(struct smb2_tree *tree, const char *fname)
 495 {
 496         struct smb2_handle handle;
 497         NTSTATUS status = smb2_create_complex_file(tree, fname, &handle);
 498         NT_STATUS_NOT_OK_RETURN(status);
 499         return smb2_util_close(tree, handle);
 500 }
 501
 502
 503 /*
 504   create a complex dir using SMB2, to make it easier to
 505   find fields in SMB2 getinfo levels
 506 */
 507 NTSTATUS torture_setup_complex_dir(struct smb2_tree *tree, const char *fname)
 508 {
 509         struct smb2_handle handle;
 510         NTSTATUS status = smb2_create_complex_dir(tree, fname, &handle);
 511         NT_STATUS_NOT_OK_RETURN(status);
 512         return smb2_util_close(tree, handle);
 513 }
 514
 515
 516 /*
 517   return a handle to the root of the share
 518 */
 519 NTSTATUS smb2_util_roothandle(struct smb2_tree *tree, struct smb2_handle *handle)
 520 {
 521         struct smb2_create io;
 522         NTSTATUS status;
 523
 524         ZERO_STRUCT(io);
 525         io.in.oplock_level = 0;
 526         io.in.desired_access = SEC_STD_SYNCHRONIZE | SEC_DIR_READ_ATTRIBUTE | SEC_DIR_LIST;
 527         io.in.file_attributes   = 0;
 528         io.in.create_disposition = NTCREATEX_DISP_OPEN;
 529         io.in.share_access = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_DELETE;
 530         io.in.create_options = NTCREATEX_OPTIONS_ASYNC_ALERT;
 531         io.in.fname = "";
 532
 533         status = smb2_create(tree, tree, &io);
 534         NT_STATUS_NOT_OK_RETURN(status);
 535
 536         *handle = io.out.file.handle;
 537
 538         return NT_STATUS_OK;
 539 }
 540
 541 /* Comparable to torture_setup_dir, but for SMB2. */
 542 bool smb2_util_setup_dir(struct torture_context *tctx, struct smb2_tree *tree,
 543     const char *dname)
 544 {
 545         NTSTATUS status;
 546
 547         /* XXX: smb_raw_exit equivalent?
 548         smb_raw_exit(cli->session); */
 549         if (smb2_deltree(tree, dname) == -1) {
 550                 torture_result(tctx, TORTURE_ERROR, "Unable to deltree when setting up %s.\n", dname);
 551                 return false;
 552         }
 553
 554         status = smb2_util_mkdir(tree, dname);
 555         if (NT_STATUS_IS_ERR(status)) {
 556                 torture_result(tctx, TORTURE_ERROR, "Unable to mkdir when setting up %s - %s\n", dname,
 557                     nt_errstr(status));
 558                 return false;
 559         }
 560
 561         return true;
 562 }
 563
 564 #define CHECK_STATUS(status, correct) do { \
 565         if (!NT_STATUS_EQUAL(status, correct)) { \
 566                 torture_result(tctx, TORTURE_FAIL, "(%s) Incorrect status %s - should be %s\n", \
 567                        __location__, nt_errstr(status), nt_errstr(correct)); \
 568                 ret = false; \
 569                 goto done; \
 570         }} while (0)
 571
 572 /*
 573  * Helper function to verify a security descriptor, by querying
 574  * and comparing against the passed in sd.
 575  */
 576 bool smb2_util_verify_sd(TALLOC_CTX *tctx, struct smb2_tree *tree,
 577     struct smb2_handle handle, struct security_descriptor *sd)
 578 {
 579         NTSTATUS status;
 580         bool ret = true;
 581         union smb_fileinfo q = {};
 582
 583         q.query_secdesc.level = RAW_FILEINFO_SEC_DESC;
 584         q.query_secdesc.in.file.handle = handle;
 585         q.query_secdesc.in.secinfo_flags =
 586             SECINFO_OWNER |
 587             SECINFO_GROUP |
 588             SECINFO_DACL;
 589         status = smb2_getinfo_file(tree, tctx, &q);
 590         CHECK_STATUS(status, NT_STATUS_OK);
 591
 592         if (!security_acl_equal(
 593             q.query_secdesc.out.sd->dacl, sd->dacl)) {
 594                 torture_warning(tctx, "%s: security descriptors don't match!\n",
 595                     __location__);
 596                 torture_warning(tctx, "got:\n");
 597                 NDR_PRINT_DEBUG(security_descriptor,
 598                     q.query_secdesc.out.sd);
 599                 torture_warning(tctx, "expected:\n");
 600                 NDR_PRINT_DEBUG(security_descriptor, sd);
 601                 ret = false;
 602         }
 603
 604  done:
 605         return ret;
 606 }
 607
 608 /*
 609  * Helper function to verify attributes, by querying
 610  * and comparing against the passed in attrib.
 611  */
 612 bool smb2_util_verify_attrib(TALLOC_CTX *tctx, struct smb2_tree *tree,
 613     struct smb2_handle handle, uint32_t attrib)
 614 {
 615         NTSTATUS status;
 616         bool ret = true;
 617         union smb_fileinfo q = {};
 618
 619         q.standard.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
 620         q.standard.in.file.handle = handle;
 621         status = smb2_getinfo_file(tree, tctx, &q);
 622         CHECK_STATUS(status, NT_STATUS_OK);
 623
 624         q.all_info2.out.attrib &= ~(FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_NONINDEXED);
 625
 626         if (q.all_info2.out.attrib != attrib) {
 627                 torture_warning(tctx, "%s: attributes don't match! "
 628                     "got %x, expected %x\n", __location__,
 629                     (uint32_t)q.standard.out.attrib,
 630                     (uint32_t)attrib);
 631                 ret = false;
 632         }
 633
 634  done:
 635         return ret;
 636 }
 637
 638
 639 uint32_t smb2_util_lease_state(const char *ls)
 640 {
 641         uint32_t val = 0;
 642         int i;
 643
 644         for (i = 0; i < strlen(ls); i++) {
 645                 switch (ls[i]) {
 646                 case 'R':
 647                         val |= SMB2_LEASE_READ;
 648                         break;
 649                 case 'H':
 650                         val |= SMB2_LEASE_HANDLE;
 651                         break;
 652                 case 'W':
 653                         val |= SMB2_LEASE_WRITE;
 654                         break;
 655                 }
 656         }
 657
 658         return val;
 659 }
 660
 661
 662 uint32_t smb2_util_share_access(const char *sharemode)
 663 {
 664         uint32_t val = NTCREATEX_SHARE_ACCESS_NONE; /* 0 */
 665         int i;
 666
 667         for (i = 0; i < strlen(sharemode); i++) {
 668                 switch(sharemode[i]) {
 669                 case 'R':
 670                         val |= NTCREATEX_SHARE_ACCESS_READ;
 671                         break;
 672                 case 'W':
 673                         val |= NTCREATEX_SHARE_ACCESS_WRITE;
 674                         break;
 675                 case 'D':
 676                         val |= NTCREATEX_SHARE_ACCESS_DELETE;
 677                         break;
 678                 }
 679         }
 680
 681         return val;
 682 }
 683
 684 uint8_t smb2_util_oplock_level(const char *op)
 685 {
 686         uint8_t val = SMB2_OPLOCK_LEVEL_NONE;
 687         int i;
 688
 689         for (i = 0; i < strlen(op); i++) {
 690                 switch (op[i]) {
 691                 case 's':
 692                         return SMB2_OPLOCK_LEVEL_II;
 693                 case 'x':
 694                         return SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 695                 case 'b':
 696                         return SMB2_OPLOCK_LEVEL_BATCH;
 697                 default:
 698                         continue;
 699                 }
 700         }
 701
 702         return val;
 703 }
 704
 705 /**
 706  * Helper functions to fill a smb2_create struct for several
 707  * open scenarios.
 708  */
 709 void smb2_generic_create_share(struct smb2_create *io, struct smb2_lease *ls,
 710                                bool dir, const char *name, uint32_t disposition,
 711                                uint32_t share_access,
 712                                uint8_t oplock, uint64_t leasekey,
 713                                uint32_t leasestate)
 714 {
 715         ZERO_STRUCT(*io);
 716         io->in.security_flags           = 0x00;
 717         io->in.oplock_level             = oplock;
 718         io->in.impersonation_level      = NTCREATEX_IMPERSONATION_IMPERSONATION;
 719         io->in.create_flags             = 0x00000000;
 720         io->in.reserved                 = 0x00000000;
 721         io->in.desired_access           = SEC_RIGHTS_FILE_ALL;
 722         io->in.file_attributes          = FILE_ATTRIBUTE_NORMAL;
 723         io->in.share_access             = share_access;
 724         io->in.create_disposition       = disposition;
 725         io->in.create_options           = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
 726                                           NTCREATEX_OPTIONS_ASYNC_ALERT |
 727                                           NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
 728                                           0x00200000;
 729         io->in.fname                    = name;
 730
 731         if (dir) {
 732                 io->in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
 733                 io->in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
 734                 io->in.create_disposition = NTCREATEX_DISP_CREATE;
 735         }
 736
 737         if (ls) {
 738                 ZERO_STRUCTPN(ls);
 739                 ls->lease_key.data[0] = leasekey;
 740                 ls->lease_key.data[1] = ~leasekey;
 741                 ls->lease_state = leasestate;
 742                 io->in.lease_request = ls;
 743         }
 744 }
 745
 746 void smb2_generic_create(struct smb2_create *io, struct smb2_lease *ls,
 747                          bool dir, const char *name, uint32_t disposition,
 748                          uint8_t oplock, uint64_t leasekey,
 749                          uint32_t leasestate)
 750 {
 751         smb2_generic_create_share(io, ls, dir, name, disposition,
 752                                   smb2_util_share_access("RWD"),
 753                                   oplock,
 754                                   leasekey, leasestate);
 755 }
 756
 757 void smb2_lease_create_share(struct smb2_create *io, struct smb2_lease *ls,
 758                              bool dir, const char *name, uint32_t share_access,
 759                              uint64_t leasekey, uint32_t leasestate)
 760 {
 761         smb2_generic_create_share(io, ls, dir, name, NTCREATEX_DISP_OPEN_IF,
 762                                   share_access, SMB2_OPLOCK_LEVEL_LEASE,
 763                                   leasekey, leasestate);
 764 }
 765
 766 void smb2_lease_create(struct smb2_create *io, struct smb2_lease *ls,
 767                        bool dir, const char *name, uint64_t leasekey,
 768                        uint32_t leasestate)
 769 {
 770         smb2_lease_create_share(io, ls, dir, name,
 771                                 smb2_util_share_access("RWD"),
 772                                 leasekey, leasestate);
 773 }
 774
 775 void smb2_lease_v2_create_share(struct smb2_create *io,
 776                                 struct smb2_lease *ls,
 777                                 bool dir,
 778                                 const char *name,
 779                                 uint32_t share_access,
 780                                 uint64_t leasekey,
 781                                 const uint64_t *parentleasekey,
 782                                 uint32_t leasestate,
 783                                 uint16_t lease_epoch)
 784 {
 785         smb2_generic_create_share(io, NULL, dir, name, NTCREATEX_DISP_OPEN_IF,
 786                                   share_access, SMB2_OPLOCK_LEVEL_LEASE, 0, 0);
 787
 788         if (ls) {
 789                 ZERO_STRUCT(*ls);
 790                 ls->lease_key.data[0] = leasekey;
 791                 ls->lease_key.data[1] = ~leasekey;
 792                 ls->lease_state = leasestate;
 793                 if (parentleasekey != NULL) {
 794                         ls->lease_flags |= SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET;
 795                         ls->parent_lease_key.data[0] = *parentleasekey;
 796                         ls->parent_lease_key.data[1] = ~(*parentleasekey);
 797                 }
 798                 ls->lease_epoch = lease_epoch;
 799                 io->in.lease_request_v2 = ls;
 800         }
 801 }
 802
 803 void smb2_lease_v2_create(struct smb2_create *io,
 804                           struct smb2_lease *ls,
 805                           bool dir,
 806                           const char *name,
 807                           uint64_t leasekey,
 808                           const uint64_t *parentleasekey,
 809                           uint32_t leasestate,
 810                           uint16_t lease_epoch)
 811 {
 812         smb2_lease_v2_create_share(io, ls, dir, name,
 813                                    smb2_util_share_access("RWD"),
 814                                    leasekey, parentleasekey,
 815                                    leasestate, lease_epoch);
 816 }
 817
 818
 819 void smb2_oplock_create_share(struct smb2_create *io, const char *name,
 820                               uint32_t share_access, uint8_t oplock)
 821 {
 822         smb2_generic_create_share(io, NULL, false, name, NTCREATEX_DISP_OPEN_IF,
 823                                   share_access, oplock, 0, 0);
 824 }
 825 void smb2_oplock_create(struct smb2_create *io, const char *name, uint8_t oplock)
 826 {
 827         smb2_oplock_create_share(io, name, smb2_util_share_access("RWD"),
 828                                  oplock);
 829 }
 830