source4/torture/smb2/dir.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    SMB2 dir list test suite
   5
   6    Copyright (C) Andrew Tridgell 2005
   7    Copyright (C) Zachary Loafman 2009
   8    Copyright (C) Aravind Srinivasan 2009
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "libcli/smb2/smb2.h"
  26 #include "libcli/smb2/smb2_calls.h"
  27 #include "libcli/smb_composite/smb_composite.h"
  28 #include "libcli/raw/libcliraw.h"
  29 #include "libcli/raw/raw_proto.h"
  30 #include "libcli/libcli.h"
  31
  32 #include "torture/torture.h"
  33 #include "torture/smb2/proto.h"
  34 #include "torture/util.h"
  35
  36 #include "system/filesys.h"
  37 #include "lib/util/tsort.h"
  38
  39 #define DNAME   "smb2_dir"
  40 #define NFILES  100
  41
  42 struct file_elem {
  43         char *name;
  44         NTTIME create_time;
  45         bool found;
  46 };
  47
  48 static NTSTATUS populate_tree(struct torture_context *tctx,
  49                               TALLOC_CTX *mem_ctx,
  50                               struct smb2_tree *tree,
  51                               struct file_elem *files,
  52                               int nfiles,
  53                               struct smb2_handle *h_out)
  54 {
  55         struct smb2_create create;
  56         char **strs = NULL;
  57         NTSTATUS status;
  58         bool ret = true;
  59         int i;
  60
  61         smb2_deltree(tree, DNAME);
  62
  63         ZERO_STRUCT(create);
  64         create.in.desired_access = SEC_RIGHTS_DIR_ALL;
  65         create.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
  66         create.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
  67         create.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
  68                                  NTCREATEX_SHARE_ACCESS_WRITE |
  69                                  NTCREATEX_SHARE_ACCESS_DELETE;
  70         create.in.create_disposition = NTCREATEX_DISP_CREATE;
  71         create.in.fname = DNAME;
  72
  73         status = smb2_create(tree, mem_ctx, &create);
  74         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
  75         *h_out = create.out.file.handle;
  76
  77         ZERO_STRUCT(create);
  78         create.in.desired_access = SEC_RIGHTS_FILE_ALL;
  79         create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
  80         create.in.create_disposition = NTCREATEX_DISP_CREATE;
  81
  82         strs = generate_unique_strs(mem_ctx, 8, nfiles);
  83         if (strs == NULL) {
  84                 status = NT_STATUS_OBJECT_NAME_COLLISION;
  85                 goto done;
  86         }
  87         for (i = 0; i < nfiles; i++) {
  88                 files[i].name = strs[i];
  89                 create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s",
  90                     DNAME, files[i].name);
  91                 status = smb2_create(tree, mem_ctx, &create);
  92                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
  93                 files[i].create_time = create.out.create_time;
  94                 smb2_util_close(tree, create.out.file.handle);
  95         }
  96  done:
  97         if (!ret) {
  98                 return status;
  99         }
 100
 101         return status;
 102 }
 103
 104 /*
 105   test find continue
 106 */
 107
 108 static bool test_find(struct torture_context *tctx,
 109                       struct smb2_tree *tree)
 110 {
 111         TALLOC_CTX *mem_ctx = talloc_new(tctx);
 112         struct smb2_handle h;
 113         struct smb2_find f;
 114         union smb_search_data *d;
 115         struct file_elem files[NFILES] = {};
 116         NTSTATUS status;
 117         bool ret = true;
 118         unsigned int count;
 119         int i, j, file_count = 0;
 120
 121         status = populate_tree(tctx, mem_ctx, tree, files, NFILES, &h);
 122
 123         ZERO_STRUCT(f);
 124         f.in.file.handle        = h;
 125         f.in.pattern            = "*";
 126         f.in.continue_flags     = SMB2_CONTINUE_FLAG_SINGLE;
 127         f.in.max_response_size  = 0x100;
 128         f.in.level              = SMB2_FIND_BOTH_DIRECTORY_INFO;
 129
 130         do {
 131                 status = smb2_find_level(tree, tree, &f, &count, &d);
 132                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
 133                         break;
 134                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 135
 136                 for (i = 0; i < count; i++) {
 137                         bool expected;
 138                         const char *found = d[i].both_directory_info.name.s;
 139                         NTTIME ct = d[i].both_directory_info.create_time;
 140
 141                         if (!strcmp(found, ".") || !strcmp(found, ".."))
 142                                 continue;
 143
 144                         expected = false;
 145                         for (j = 0; j < NFILES; j++) {
 146                                 if (strcmp(files[j].name, found) != 0) {
 147                                         continue;
 148                                 }
 149
 150                                 torture_assert_u64_equal_goto(tctx,
 151                                                         files[j].create_time,
 152                                                         ct, ret, done,
 153                                                         talloc_asprintf(tctx,
 154                                                         "file[%d]\n", j));
 155
 156                                 files[j].found = true;
 157                                 expected = true;
 158                                 break;
 159                         }
 160
 161                         if (expected)
 162                                 continue;
 163
 164                         torture_result(tctx, TORTURE_FAIL,
 165                             "(%s): didn't expect %s\n",
 166                             __location__, found);
 167                         ret = false;
 168                         goto done;
 169                 }
 170
 171                 file_count = file_count + i;
 172                 f.in.continue_flags = 0;
 173                 f.in.max_response_size  = 4096;
 174         } while (count != 0);
 175
 176         torture_assert_int_equal_goto(tctx, file_count, NFILES + 2, ret, done,
 177                                       "");
 178
 179         for (i = 0; i < NFILES; i++) {
 180                 if (files[j].found)
 181                         continue;
 182
 183                 torture_result(tctx, TORTURE_FAIL,
 184                     "(%s): expected to find %s, but didn't\n",
 185                     __location__, files[j].name);
 186                 ret = false;
 187                 goto done;
 188         }
 189
 190  done:
 191         smb2_deltree(tree, DNAME);
 192         talloc_free(mem_ctx);
 193
 194         return ret;
 195 }
 196
 197 /*
 198   test fixed enumeration
 199 */
 200
 201 static bool test_fixed(struct torture_context *tctx,
 202                        struct smb2_tree *tree)
 203 {
 204         TALLOC_CTX *mem_ctx = talloc_new(tctx);
 205         struct smb2_create create;
 206         struct smb2_handle h = {{0}};
 207         struct smb2_handle h2 = {{0}};
 208         struct smb2_find f;
 209         union smb_search_data *d;
 210         struct file_elem files[NFILES] = {};
 211         NTSTATUS status;
 212         bool ret = true;
 213         unsigned int count;
 214         int i;
 215
 216         status = populate_tree(tctx, mem_ctx, tree, files, NFILES, &h);
 217
 218         ZERO_STRUCT(create);
 219         create.in.desired_access = SEC_RIGHTS_DIR_ALL;
 220         create.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
 221         create.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
 222         create.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
 223                                  NTCREATEX_SHARE_ACCESS_WRITE |
 224                                  NTCREATEX_SHARE_ACCESS_DELETE;
 225         create.in.create_disposition = NTCREATEX_DISP_OPEN;
 226         create.in.fname = DNAME;
 227
 228         status = smb2_create(tree, mem_ctx, &create);
 229         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 230         h2 = create.out.file.handle;
 231
 232         ZERO_STRUCT(f);
 233         f.in.file.handle        = h;
 234         f.in.pattern            = "*";
 235         f.in.continue_flags     = SMB2_CONTINUE_FLAG_SINGLE;
 236         f.in.max_response_size  = 0x100;
 237         f.in.level              = SMB2_FIND_BOTH_DIRECTORY_INFO;
 238
 239         /* Start enumeration on h, then delete all from h2 */
 240         status = smb2_find_level(tree, tree, &f, &count, &d);
 241         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 242
 243         f.in.file.handle        = h2;
 244
 245         do {
 246                 status = smb2_find_level(tree, tree, &f, &count, &d);
 247                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
 248                         break;
 249                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 250
 251                 for (i = 0; i < count; i++) {
 252                         const char *found = d[i].both_directory_info.name.s;
 253                         char *path = talloc_asprintf(mem_ctx, "%s\\%s",
 254                             DNAME, found);
 255
 256                         if (!strcmp(found, ".") || !strcmp(found, ".."))
 257                                 continue;
 258
 259                         status = smb2_util_unlink(tree, path);
 260                         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 261                                                         "");
 262
 263                         talloc_free(path);
 264                 }
 265
 266                 f.in.continue_flags = 0;
 267                 f.in.max_response_size  = 4096;
 268         } while (count != 0);
 269
 270         /* Now finish h enumeration. */
 271         f.in.file.handle = h;
 272
 273         do {
 274                 status = smb2_find_level(tree, tree, &f, &count, &d);
 275                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
 276                         break;
 277                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 278
 279                 for (i = 0; i < count; i++) {
 280                         const char *found = d[i].both_directory_info.name.s;
 281
 282                         if (!strcmp(found, ".") || !strcmp(found, ".."))
 283                                 continue;
 284
 285                         torture_result(tctx, TORTURE_FAIL,
 286                                        "(%s): didn't expect %s (count=%u)\n",
 287                                        __location__, found, count);
 288                         ret = false;
 289                         goto done;
 290                 }
 291
 292                 f.in.continue_flags = 0;
 293                 f.in.max_response_size  = 4096;
 294         } while (count != 0);
 295
 296  done:
 297         smb2_util_close(tree, h);
 298         smb2_util_close(tree, h2);
 299         smb2_deltree(tree, DNAME);
 300         talloc_free(mem_ctx);
 301
 302         return ret;
 303 }
 304
 305 static struct {
 306         const char *name;
 307         uint8_t level;
 308         enum smb_search_data_level data_level;
 309         int name_offset;
 310         int resume_key_offset;
 311         uint32_t capability_mask;
 312         NTSTATUS status;
 313         union smb_search_data data;
 314 } levels[] = {
 315         {"SMB2_FIND_DIRECTORY_INFO",
 316          SMB2_FIND_DIRECTORY_INFO, RAW_SEARCH_DATA_DIRECTORY_INFO,
 317          offsetof(union smb_search_data, directory_info.name.s),
 318          offsetof(union smb_search_data, directory_info.file_index),
 319         },
 320         {"SMB2_FIND_FULL_DIRECTORY_INFO",
 321          SMB2_FIND_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,
 322          offsetof(union smb_search_data, full_directory_info.name.s),
 323          offsetof(union smb_search_data, full_directory_info.file_index),
 324         },
 325         {"SMB2_FIND_NAME_INFO",
 326          SMB2_FIND_NAME_INFO, RAW_SEARCH_DATA_NAME_INFO,
 327          offsetof(union smb_search_data, name_info.name.s),
 328          offsetof(union smb_search_data, name_info.file_index),
 329         },
 330         {"SMB2_FIND_BOTH_DIRECTORY_INFO",
 331          SMB2_FIND_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
 332          offsetof(union smb_search_data, both_directory_info.name.s),
 333          offsetof(union smb_search_data, both_directory_info.file_index),
 334         },
 335         {"SMB2_FIND_ID_FULL_DIRECTORY_INFO",
 336          SMB2_FIND_ID_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO,
 337          offsetof(union smb_search_data, id_full_directory_info.name.s),
 338          offsetof(union smb_search_data, id_full_directory_info.file_index),
 339         },
 340         {"SMB2_FIND_ID_BOTH_DIRECTORY_INFO",
 341          SMB2_FIND_ID_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO,
 342          offsetof(union smb_search_data, id_both_directory_info.name.s),
 343          offsetof(union smb_search_data, id_both_directory_info.file_index),
 344         }
 345 };
 346
 347 /*
 348   extract the name from a smb_data structure and level
 349 */
 350 static const char *extract_name(union smb_search_data *data,
 351                                 uint8_t level,
 352                                 enum smb_search_data_level data_level)
 353 {
 354         int i;
 355         for (i=0;i<ARRAY_SIZE(levels);i++) {
 356                 if (level == levels[i].level &&
 357                     data_level == levels[i].data_level) {
 358                         return *(const char **)(levels[i].name_offset + (char *)data);
 359                 }
 360         }
 361         return NULL;
 362 }
 363
 364 /* find a level in the table by name */
 365 static union smb_search_data *find(const char *name)
 366 {
 367         int i;
 368         for (i=0;i<ARRAY_SIZE(levels);i++) {
 369                 if (NT_STATUS_IS_OK(levels[i].status) &&
 370                     strcmp(levels[i].name, name) == 0) {
 371                         return &levels[i].data;
 372                 }
 373         }
 374         return NULL;
 375 }
 376
 377 static bool fill_level_data(TALLOC_CTX *mem_ctx,
 378                             union smb_search_data *data,
 379                             union smb_search_data *d,
 380                             unsigned int count,
 381                             uint8_t level,
 382                             enum smb_search_data_level data_level)
 383 {
 384         int i;
 385         const char *sname = NULL;
 386         for (i=0; i < count ; i++) {
 387                 sname = extract_name(&d[i], level, data_level);
 388                 if (sname == NULL)
 389                         return false;
 390                 if (!strcmp(sname, ".") || !strcmp(sname, ".."))
 391                         continue;
 392                 *data = d[i];
 393         }
 394         return true;
 395 }
 396
 397
 398 NTSTATUS torture_single_file_search(struct smb2_tree *tree,
 399                                     TALLOC_CTX *mem_ctx,
 400                                     const char *pattern,
 401                                     uint8_t level,
 402                                     enum smb_search_data_level data_level,
 403                                     int idx,
 404                                     union smb_search_data *d,
 405                                     unsigned int *count,
 406                                     struct smb2_handle *h)
 407 {
 408         struct smb2_find f;
 409         NTSTATUS status;
 410
 411         ZERO_STRUCT(f);
 412         f.in.file.handle        = *h;
 413         f.in.pattern            = pattern;
 414         f.in.continue_flags     = SMB2_CONTINUE_FLAG_RESTART;
 415         f.in.max_response_size  = 0x100;
 416         f.in.level              = level;
 417
 418         status = smb2_find_level(tree, tree, &f, count, &d);
 419         if (NT_STATUS_IS_OK(status))
 420                 fill_level_data(mem_ctx, &levels[idx].data, d, *count, level,
 421                                 data_level);
 422         return status;
 423 }
 424
 425 /*
 426    basic testing of all File Information Classes using a single file
 427 */
 428 static bool test_one_file(struct torture_context *tctx,
 429                           struct smb2_tree *tree)
 430 {
 431         TALLOC_CTX *mem_ctx = talloc_new(tctx);
 432         bool ret = true;
 433         const char *fname =  "torture_search.txt";
 434         NTSTATUS status;
 435         int i;
 436         unsigned int count;
 437         union smb_fileinfo all_info2, alt_info, internal_info;
 438         union smb_search_data *s;
 439         union smb_search_data d;
 440         struct smb2_handle h, h2;
 441
 442         status = torture_smb2_testdir(tree, DNAME, &h);
 443         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 444
 445         status = smb2_create_complex_file(tctx, tree, DNAME "\\torture_search.txt",
 446                                           &h2);
 447         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 448
 449         /* call all the File Information Classes */
 450         for (i=0;i<ARRAY_SIZE(levels);i++) {
 451                 torture_comment(tctx, "Testing %s %d\n", levels[i].name,
 452                                 levels[i].level);
 453
 454                 levels[i].status = torture_single_file_search(tree, mem_ctx,
 455                                    fname, levels[i].level, levels[i].data_level,
 456                                    i, &d, &count, &h);
 457                 torture_assert_ntstatus_ok_goto(tctx, levels[i].status, ret,
 458                                                 done, "");
 459         }
 460
 461         /* get the all_info file into to check against */
 462         all_info2.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
 463         all_info2.generic.in.file.handle = h2;
 464         status = smb2_getinfo_file(tree, tctx, &all_info2);
 465         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 466                                         "RAW_FILEINFO_ALL_INFO failed");
 467
 468         alt_info.generic.level = RAW_FILEINFO_ALT_NAME_INFORMATION;
 469         alt_info.generic.in.file.handle = h2;
 470         status = smb2_getinfo_file(tree, tctx, &alt_info);
 471         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 472                                         "RAW_FILEINFO_ALT_NAME_INFO failed");
 473
 474         internal_info.generic.level = RAW_FILEINFO_INTERNAL_INFORMATION;
 475         internal_info.generic.in.file.handle = h2;
 476         status = smb2_getinfo_file(tree, tctx, &internal_info);
 477         torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
 478                                         "RAW_FILEINFO_INTERNAL_INFORMATION "
 479                                         "failed");
 480
 481 #define CHECK_VAL(name, sname1, field1, v, sname2, field2) do { \
 482         s = find(name); \
 483         if (s) { \
 484                 if ((s->sname1.field1) != (v.sname2.out.field2)) { \
 485                         torture_result(tctx, TORTURE_FAIL, \
 486                             "(%s) %s/%s [0x%x] != %s/%s [0x%x]\n", \
 487                             __location__, \
 488                             #sname1, #field1, (int)s->sname1.field1, \
 489                             #sname2, #field2, (int)v.sname2.out.field2); \
 490                         ret = false; \
 491                 } \
 492         }} while (0)
 493
 494 #define CHECK_TIME(name, sname1, field1, v, sname2, field2) do { \
 495         s = find(name); \
 496         if (s) { \
 497                 if (s->sname1.field1 != \
 498                     (~1 & nt_time_to_unix(v.sname2.out.field2))) { \
 499                         torture_result(tctx, TORTURE_FAIL, \
 500                             "(%s) %s/%s [%s] != %s/%s [%s]\n", \
 501                             __location__, \
 502                             #sname1, #field1, \
 503                             timestring(tctx, s->sname1.field1), \
 504                             #sname2, #field2, \
 505                             nt_time_string(tctx, v.sname2.out.field2)); \
 506                         ret = false; \
 507                 } \
 508         }} while (0)
 509
 510 #define CHECK_NTTIME(name, sname1, field1, v, sname2, field2) do { \
 511         s = find(name); \
 512         if (s) { \
 513                 if (s->sname1.field1 != v.sname2.out.field2) { \
 514                         torture_result(tctx, TORTURE_FAIL, \
 515                             "(%s) %s/%s [%s] != %s/%s [%s]\n", \
 516                             __location__, \
 517                             #sname1, #field1, \
 518                             nt_time_string(tctx, s->sname1.field1), \
 519                             #sname2, #field2, \
 520                             nt_time_string(tctx, v.sname2.out.field2)); \
 521                         ret = false; \
 522                 } \
 523         }} while (0)
 524
 525 #define CHECK_STR(name, sname1, field1, v, sname2, field2) do { \
 526         s = find(name); \
 527         if (s) { \
 528                 if (!s->sname1.field1 || \
 529                     strcmp(s->sname1.field1, v.sname2.out.field2.s)) { \
 530                         torture_result(tctx, TORTURE_FAIL, \
 531                             "(%s) %s/%s [%s] != %s/%s [%s]\n", \
 532                             __location__, \
 533                             #sname1, #field1, s->sname1.field1, \
 534                             #sname2, #field2, v.sname2.out.field2.s); \
 535                         ret = false; \
 536                 } \
 537         }} while (0)
 538
 539 #define CHECK_WSTR(name, sname1, field1, v, sname2, field2, flags) do { \
 540         s = find(name); \
 541         if (s) { \
 542                 if (!s->sname1.field1.s || \
 543                     strcmp(s->sname1.field1.s, v.sname2.out.field2.s)) { \
 544                         torture_result(tctx, TORTURE_FAIL, \
 545                             "(%s) %s/%s [%s] != %s/%s [%s]\n", \
 546                             __location__, \
 547                             #sname1, #field1, s->sname1.field1.s, \
 548                             #sname2, #field2, v.sname2.out.field2.s); \
 549                         ret = false; \
 550                 } \
 551         }} while (0)
 552
 553 #define CHECK_NAME(name, sname1, field1, fname, flags) do { \
 554         s = find(name); \
 555         if (s) { \
 556                 if (!s->sname1.field1.s || \
 557                     strcmp(s->sname1.field1.s, fname)) { \
 558                         torture_result(tctx, TORTURE_FAIL, \
 559                             "(%s) %s/%s [%s] != %s\n", \
 560                             __location__, \
 561                             #sname1, #field1, s->sname1.field1.s, fname); \
 562                         ret = false; \
 563                 } \
 564         }} while (0)
 565
 566 #define CHECK_UNIX_NAME(name, sname1, field1, fname, flags) do { \
 567         s = find(name); \
 568         if (s) { \
 569                 if (!s->sname1.field1 || \
 570                     strcmp(s->sname1.field1, fname)) { \
 571                         torture_result(tctx, TORTURE_FAIL, \
 572                            "(%s) %s/%s [%s] != %s\n", \
 573                             __location__, \
 574                             #sname1, #field1, s->sname1.field1, fname); \
 575                         ret = false; \
 576                 } \
 577         }} while (0)
 578
 579         /* check that all the results are as expected */
 580         CHECK_VAL("SMB2_FIND_DIRECTORY_INFO",            directory_info,         attrib, all_info2, all_info2, attrib);
 581         CHECK_VAL("SMB2_FIND_FULL_DIRECTORY_INFO",       full_directory_info,    attrib, all_info2, all_info2, attrib);
 582         CHECK_VAL("SMB2_FIND_BOTH_DIRECTORY_INFO",       both_directory_info,    attrib, all_info2, all_info2, attrib);
 583         CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO",    id_full_directory_info, attrib, all_info2, all_info2, attrib);
 584         CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO",    id_both_directory_info, attrib, all_info2, all_info2, attrib);
 585
 586         CHECK_NTTIME("SMB2_FIND_DIRECTORY_INFO",         directory_info,         write_time, all_info2, all_info2, write_time);
 587         CHECK_NTTIME("SMB2_FIND_FULL_DIRECTORY_INFO",    full_directory_info,    write_time, all_info2, all_info2, write_time);
 588         CHECK_NTTIME("SMB2_FIND_BOTH_DIRECTORY_INFO",    both_directory_info,    write_time, all_info2, all_info2, write_time);
 589         CHECK_NTTIME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, write_time, all_info2, all_info2, write_time);
 590         CHECK_NTTIME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, write_time, all_info2, all_info2, write_time);
 591
 592         CHECK_NTTIME("SMB2_FIND_DIRECTORY_INFO",         directory_info,         create_time, all_info2, all_info2, create_time);
 593         CHECK_NTTIME("SMB2_FIND_FULL_DIRECTORY_INFO",    full_directory_info,    create_time, all_info2, all_info2, create_time);
 594         CHECK_NTTIME("SMB2_FIND_BOTH_DIRECTORY_INFO",    both_directory_info,    create_time, all_info2, all_info2, create_time);
 595         CHECK_NTTIME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, create_time, all_info2, all_info2, create_time);
 596         CHECK_NTTIME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, create_time, all_info2, all_info2, create_time);
 597
 598         CHECK_NTTIME("SMB2_FIND_DIRECTORY_INFO",         directory_info,         access_time, all_info2, all_info2, access_time);
 599         CHECK_NTTIME("SMB2_FIND_FULL_DIRECTORY_INFO",    full_directory_info,    access_time, all_info2, all_info2, access_time);
 600         CHECK_NTTIME("SMB2_FIND_BOTH_DIRECTORY_INFO",    both_directory_info,    access_time, all_info2, all_info2, access_time);
 601         CHECK_NTTIME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, access_time, all_info2, all_info2, access_time);
 602         CHECK_NTTIME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, access_time, all_info2, all_info2, access_time);
 603
 604         CHECK_NTTIME("SMB2_FIND_DIRECTORY_INFO",         directory_info,         change_time, all_info2, all_info2, change_time);
 605         CHECK_NTTIME("SMB2_FIND_FULL_DIRECTORY_INFO",    full_directory_info,    change_time, all_info2, all_info2, change_time);
 606         CHECK_NTTIME("SMB2_FIND_BOTH_DIRECTORY_INFO",    both_directory_info,    change_time, all_info2, all_info2, change_time);
 607         CHECK_NTTIME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, change_time, all_info2, all_info2, change_time);
 608         CHECK_NTTIME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, change_time, all_info2, all_info2, change_time);
 609
 610         CHECK_VAL("SMB2_FIND_DIRECTORY_INFO",            directory_info,         size, all_info2, all_info2, size);
 611         CHECK_VAL("SMB2_FIND_FULL_DIRECTORY_INFO",       full_directory_info,    size, all_info2, all_info2, size);
 612         CHECK_VAL("SMB2_FIND_BOTH_DIRECTORY_INFO",       both_directory_info,    size, all_info2, all_info2, size);
 613         CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO",    id_full_directory_info, size, all_info2, all_info2, size);
 614         CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO",    id_both_directory_info, size, all_info2, all_info2, size);
 615
 616         CHECK_VAL("SMB2_FIND_DIRECTORY_INFO",            directory_info,         alloc_size, all_info2, all_info2, alloc_size);
 617         CHECK_VAL("SMB2_FIND_FULL_DIRECTORY_INFO",       full_directory_info,    alloc_size, all_info2, all_info2, alloc_size);
 618         CHECK_VAL("SMB2_FIND_BOTH_DIRECTORY_INFO",       both_directory_info,    alloc_size, all_info2, all_info2, alloc_size);
 619         CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO",    id_full_directory_info, alloc_size, all_info2, all_info2, alloc_size);
 620         CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO",    id_both_directory_info, alloc_size, all_info2, all_info2, alloc_size);
 621
 622         CHECK_VAL("SMB2_FIND_FULL_DIRECTORY_INFO",       full_directory_info,    ea_size, all_info2, all_info2, ea_size);
 623         CHECK_VAL("SMB2_FIND_BOTH_DIRECTORY_INFO",       both_directory_info,    ea_size, all_info2, all_info2, ea_size);
 624         CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO",    id_full_directory_info, ea_size, all_info2, all_info2, ea_size);
 625         CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO",    id_both_directory_info, ea_size, all_info2, all_info2, ea_size);
 626
 627         CHECK_NAME("SMB2_FIND_DIRECTORY_INFO",           directory_info,         name, fname, STR_TERMINATE_ASCII);
 628         CHECK_NAME("SMB2_FIND_FULL_DIRECTORY_INFO",      full_directory_info,    name, fname, STR_TERMINATE_ASCII);
 629         CHECK_NAME("SMB2_FIND_NAME_INFO",                name_info,              name, fname, STR_TERMINATE_ASCII);
 630         CHECK_NAME("SMB2_FIND_BOTH_DIRECTORY_INFO",      both_directory_info,    name, fname, STR_TERMINATE_ASCII);
 631         CHECK_NAME("SMB2_FIND_ID_FULL_DIRECTORY_INFO",   id_full_directory_info, name, fname, STR_TERMINATE_ASCII);
 632         CHECK_NAME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO",   id_both_directory_info, name, fname, STR_TERMINATE_ASCII);
 633
 634         CHECK_WSTR("SMB2_FIND_BOTH_DIRECTORY_INFO",      both_directory_info,    short_name, alt_info, alt_name_info, fname, STR_UNICODE);
 635
 636         CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO",    id_full_directory_info, file_id, internal_info, internal_information, file_id);
 637         CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO",    id_both_directory_info, file_id, internal_info, internal_information, file_id);
 638
 639 done:
 640         smb2_util_close(tree, h);
 641         smb2_util_unlink(tree, fname);
 642         talloc_free(mem_ctx);
 643
 644         return ret;
 645 }
 646
 647
 648 struct multiple_result {
 649         TALLOC_CTX *tctx;
 650         int count;
 651         union smb_search_data *list;
 652 };
 653
 654 bool fill_result(void *private_data,
 655                  union smb_search_data *file,
 656                  int count,
 657                  uint8_t level,
 658                  enum smb_search_data_level data_level)
 659 {
 660         int i;
 661         const char *sname;
 662         struct multiple_result *data = (struct multiple_result *)private_data;
 663
 664         for (i=0; i<count; i++) {
 665                 sname = extract_name(&file[i], level, data_level);
 666                 if (!strcmp(sname, ".") || !(strcmp(sname, "..")))
 667                         continue;
 668                 data->count++;
 669                 data->list = talloc_realloc(data->tctx,
 670                                             data->list,
 671                                             union smb_search_data,
 672                                             data->count);
 673                 data->list[data->count-1] = file[i];
 674         }
 675         return true;
 676 }
 677
 678 enum continue_type {CONT_SINGLE, CONT_INDEX, CONT_RESTART};
 679
 680 static NTSTATUS multiple_smb2_search(struct smb2_tree *tree,
 681                                      TALLOC_CTX *tctx,
 682                                      const char *pattern,
 683                                      uint8_t level,
 684                                      enum smb_search_data_level data_level,
 685                                      enum continue_type cont_type,
 686                                      void *data,
 687                                      struct smb2_handle *h)
 688 {
 689         struct smb2_find f;
 690         bool ret = true;
 691         unsigned int count = 0;
 692         union smb_search_data *d;
 693         NTSTATUS status;
 694         struct multiple_result *result = (struct multiple_result *)data;
 695
 696         ZERO_STRUCT(f);
 697         f.in.file.handle        = *h;
 698         f.in.pattern            = pattern;
 699         f.in.max_response_size  = 0x1000;
 700         f.in.level              = level;
 701
 702         /* The search should start from the beginning everytime */
 703         f.in.continue_flags = SMB2_CONTINUE_FLAG_RESTART;
 704
 705         do {
 706                 status = smb2_find_level(tree, tree, &f, &count, &d);
 707                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
 708                         break;
 709                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 710                 if (!fill_result(result, d, count, level, data_level)) {
 711                         return NT_STATUS_UNSUCCESSFUL;
 712                 }
 713
 714                 if (count == 0 || result == NULL || result->count == 0) {
 715                         return NT_STATUS_UNSUCCESSFUL;
 716                 }
 717
 718                 /*
 719                  * After the first iteration is complete set the CONTINUE
 720                  * FLAGS appropriately
 721                  */
 722                 switch (cont_type) {
 723                         case CONT_INDEX:
 724                                 f.in.continue_flags = SMB2_CONTINUE_FLAG_INDEX;
 725                                 switch (data_level) {
 726                                         case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
 727                                                 f.in.file_index =
 728                                                         result->list[result->count-1].both_directory_info.file_index;
 729                                                 break;
 730                                         case RAW_SEARCH_DATA_DIRECTORY_INFO:
 731                                                 f.in.file_index =
 732                                                         result->list[result->count-1].directory_info.file_index;
 733                                                 break;
 734                                         case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
 735                                                 f.in.file_index =
 736                                                         result->list[result->count-1].full_directory_info.file_index;
 737                                                 break;
 738                                         case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
 739                                                 f.in.file_index =
 740                                                         result->list[result->count-1].id_full_directory_info.file_index;
 741                                                 break;
 742                                         case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
 743                                                 f.in.file_index =
 744                                                         result->list[result->count-1].id_both_directory_info.file_index;
 745                                                 break;
 746                                         default:
 747                                                 return NT_STATUS_INVALID_PARAMETER;
 748                                 }
 749                                 break;
 750                         case CONT_SINGLE:
 751                                 f.in.continue_flags = SMB2_CONTINUE_FLAG_SINGLE;
 752                                 break;
 753                         case CONT_RESTART:
 754                         default:
 755                                 /* we should prevent staying in the loop
 756                                  * forever */
 757                                 f.in.continue_flags = 0;
 758                                 break;
 759                 }
 760         } while (count != 0);
 761 done:
 762         if (!ret) {
 763                 return status;
 764         }
 765         return status;
 766 }
 767
 768
 769 static enum smb_search_data_level compare_data_level;
 770 uint8_t level_sort;
 771
 772 static int search_compare(union smb_search_data *d1,
 773                           union smb_search_data *d2)
 774 {
 775         const char *s1, *s2;
 776
 777         s1 = extract_name(d1, level_sort, compare_data_level);
 778         s2 = extract_name(d2, level_sort, compare_data_level);
 779         return strcmp_safe(s1, s2);
 780 }
 781
 782 /*
 783    basic testing of search calls using many files
 784 */
 785 static bool test_many_files(struct torture_context *tctx,
 786                             struct smb2_tree *tree)
 787 {
 788         TALLOC_CTX *mem_ctx = talloc_new(tctx);
 789         const int num_files = 700;
 790         int i, t;
 791         char *fname;
 792         bool ret = true;
 793         NTSTATUS status;
 794         struct multiple_result result;
 795         struct smb2_create create;
 796         struct smb2_handle h;
 797         struct {
 798                 const char *name;
 799                 const char *cont_name;
 800                 uint8_t level;
 801                 enum smb_search_data_level data_level;
 802                 enum continue_type cont_type;
 803         } search_types[] = {
 804                 {"SMB2_FIND_BOTH_DIRECTORY_INFO",    "SINGLE",  SMB2_FIND_BOTH_DIRECTORY_INFO,    RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,    CONT_SINGLE},
 805                 {"SMB2_FIND_BOTH_DIRECTORY_INFO",    "INDEX",   SMB2_FIND_BOTH_DIRECTORY_INFO,    RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,    CONT_INDEX},
 806                 {"SMB2_FIND_BOTH_DIRECTORY_INFO",    "RESTART", SMB2_FIND_BOTH_DIRECTORY_INFO,    RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,    CONT_RESTART},
 807                 {"SMB2_FIND_DIRECTORY_INFO",         "SINGLE",  SMB2_FIND_DIRECTORY_INFO,         RAW_SEARCH_DATA_DIRECTORY_INFO,         CONT_SINGLE},
 808                 {"SMB2_FIND_DIRECTORY_INFO",         "INDEX",   SMB2_FIND_DIRECTORY_INFO,         RAW_SEARCH_DATA_DIRECTORY_INFO,         CONT_INDEX},
 809                 {"SMB2_FIND_DIRECTORY_INFO",         "RESTART", SMB2_FIND_DIRECTORY_INFO,         RAW_SEARCH_DATA_DIRECTORY_INFO,         CONT_RESTART},
 810                 {"SMB2_FIND_FULL_DIRECTORY_INFO",    "SINGLE",  SMB2_FIND_FULL_DIRECTORY_INFO,    RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,    CONT_SINGLE},
 811                 {"SMB2_FIND_FULL_DIRECTORY_INFO",    "INDEX",   SMB2_FIND_FULL_DIRECTORY_INFO,    RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,    CONT_INDEX},
 812                 {"SMB2_FIND_FULL_DIRECTORY_INFO",    "RESTART", SMB2_FIND_FULL_DIRECTORY_INFO,    RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,    CONT_RESTART},
 813                 {"SMB2_FIND_ID_FULL_DIRECTORY_INFO", "SINGLE",  SMB2_FIND_ID_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_SINGLE},
 814                 {"SMB2_FIND_ID_FULL_DIRECTORY_INFO", "INDEX",   SMB2_FIND_ID_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_INDEX},
 815                 {"SMB2_FIND_ID_FULL_DIRECTORY_INFO", "RESTART", SMB2_FIND_ID_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_RESTART},
 816                 {"SMB2_FIND_ID_BOTH_DIRECTORY_INFO", "SINGLE",  SMB2_FIND_ID_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_SINGLE},
 817                 {"SMB2_FIND_ID_BOTH_DIRECTORY_INFO", "INDEX",   SMB2_FIND_ID_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_INDEX},
 818                 {"SMB2_FIND_ID_BOTH_DIRECTORY_INFO", "RESTART", SMB2_FIND_ID_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_RESTART}
 819         };
 820
 821         smb2_deltree(tree, DNAME);
 822         status = torture_smb2_testdir(tree, DNAME, &h);
 823         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 824
 825         torture_comment(tctx, "Testing with %d files\n", num_files);
 826         ZERO_STRUCT(create);
 827         create.in.desired_access = SEC_RIGHTS_FILE_ALL;
 828         create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 829         create.in.create_disposition = NTCREATEX_DISP_CREATE;
 830
 831         for (i=num_files-1;i>=0;i--) {
 832                 fname = talloc_asprintf(mem_ctx, DNAME "\\t%03d-%d.txt", i, i);
 833                 create.in.fname = talloc_asprintf(mem_ctx, "%s", fname);
 834                 status = smb2_create(tree, mem_ctx, &create);
 835                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 836                 smb2_util_close(tree, create.out.file.handle);
 837                 talloc_free(fname);
 838         }
 839
 840         for (t=0;t<ARRAY_SIZE(search_types);t++) {
 841                 ZERO_STRUCT(result);
 842                 result.tctx = talloc_new(tctx);
 843
 844                 torture_comment(tctx,
 845                                 "Continue %s via %s\n", search_types[t].name,
 846                                 search_types[t].cont_name);
 847                 status = multiple_smb2_search(tree, tctx, "*",
 848                                               search_types[t].level,
 849                                               search_types[t].data_level,
 850                                               search_types[t].cont_type,
 851                                               &result, &h);
 852
 853                 torture_assert_int_equal_goto(tctx, result.count, num_files,
 854                                               ret, done, "");
 855
 856                 compare_data_level = search_types[t].data_level;
 857                 level_sort = search_types[t].level;
 858
 859                 TYPESAFE_QSORT(result.list, result.count, search_compare);
 860
 861                 for (i=0;i<result.count;i++) {
 862                         const char *s;
 863                         s = extract_name(&result.list[i],
 864                                          search_types[t].level,
 865                                          compare_data_level);
 866                         fname = talloc_asprintf(mem_ctx, "t%03d-%d.txt", i, i);
 867                         torture_assert_str_equal_goto(tctx, s, fname, ret,
 868                                                       done, "Incorrect name");
 869                         talloc_free(fname);
 870                 }
 871                 talloc_free(result.tctx);
 872         }
 873
 874 done:
 875         smb2_util_close(tree, h);
 876         smb2_deltree(tree, DNAME);
 877         talloc_free(mem_ctx);
 878
 879         return ret;
 880 }
 881
 882 /*
 883   check an individual file result
 884 */
 885 static bool check_result(struct torture_context *tctx,
 886                          struct multiple_result *result,
 887                          const char *name,
 888                          bool exist,
 889                          uint32_t attrib)
 890 {
 891         int i;
 892         for (i=0;i<result->count;i++) {
 893                 if (strcmp(name,
 894                            result->list[i].both_directory_info.name.s) == 0) {
 895                         break;
 896                 }
 897         }
 898         if (i == result->count) {
 899                 if (exist) {
 900                         torture_result(tctx, TORTURE_FAIL,
 901                             "failed: '%s' should exist with attribute %s\n",
 902                             name, attrib_string(result->list, attrib));
 903                         return false;
 904                 }
 905                 return true;
 906         }
 907
 908         if (!exist) {
 909                 torture_result(tctx, TORTURE_FAIL,
 910                     "failed: '%s' should NOT exist (has attribute %s)\n",
 911                     name, attrib_string(result->list,
 912                     result->list[i].both_directory_info.attrib));
 913                 return false;
 914         }
 915
 916         if ((result->list[i].both_directory_info.attrib&0xFFF) != attrib) {
 917                 torture_result(tctx, TORTURE_FAIL,
 918                     "failed: '%s' should have attribute 0x%x (has 0x%x)\n",
 919                     name, attrib, result->list[i].both_directory_info.attrib);
 920                 return false;
 921         }
 922         return true;
 923 }
 924
 925 /*
 926    test what happens when the directory is modified during a search
 927 */
 928 static bool test_modify_search(struct torture_context *tctx,
 929                                struct smb2_tree *tree)
 930 {
 931         struct multiple_result result;
 932         union smb_setfileinfo sfinfo;
 933         TALLOC_CTX *mem_ctx = talloc_new(tctx);
 934         struct smb2_create create;
 935         struct smb2_handle h;
 936         struct smb2_find f;
 937         union smb_search_data *d;
 938         struct file_elem files[703] = {};
 939         int num_files = ARRAY_SIZE(files)-3;
 940         NTSTATUS status;
 941         bool ret = true;
 942         int i;
 943         unsigned int count;
 944
 945         smb2_deltree(tree, DNAME);
 946
 947         status = torture_smb2_testdir(tree, DNAME, &h);
 948         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 949
 950         torture_comment(tctx, "Creating %d files\n", num_files);
 951
 952         ZERO_STRUCT(create);
 953         create.in.desired_access = SEC_RIGHTS_FILE_ALL;
 954         create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 955         create.in.create_disposition = NTCREATEX_DISP_CREATE;
 956
 957         for (i = num_files-1; i >= 0; i--) {
 958                 files[i].name = talloc_asprintf(mem_ctx, "t%03d-%d.txt", i, i);
 959                 create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s",
 960                                                   DNAME, files[i].name);
 961                 status = smb2_create(tree, mem_ctx, &create);
 962                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 963                 smb2_util_close(tree, create.out.file.handle);
 964         }
 965
 966         torture_comment(tctx, "pulling the first two files\n");
 967         ZERO_STRUCT(result);
 968         result.tctx = talloc_new(tctx);
 969
 970         ZERO_STRUCT(f);
 971         f.in.file.handle        = h;
 972         f.in.pattern            = "*";
 973         f.in.continue_flags     = SMB2_CONTINUE_FLAG_SINGLE;
 974         f.in.max_response_size  = 0x100;
 975         f.in.level              = SMB2_FIND_BOTH_DIRECTORY_INFO;
 976
 977         do {
 978                 status = smb2_find_level(tree, tree, &f, &count, &d);
 979                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
 980                         break;
 981                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
 982                 if (!fill_result(&result, d, count, f.in.level,
 983                                  RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO)) {
 984                         ret = false;
 985                         goto done;
 986                 }
 987         } while (result.count < 2);
 988
 989         torture_comment(tctx, "Changing attributes and deleting\n");
 990
 991         ZERO_STRUCT(create);
 992         create.in.desired_access = SEC_RIGHTS_FILE_ALL;
 993         create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 994         create.in.create_disposition = NTCREATEX_DISP_CREATE;
 995
 996         files[num_files].name = talloc_asprintf(mem_ctx, "T003-03.txt.2");
 997         create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s", DNAME,
 998                                           files[num_files].name);
 999         status = smb2_create(tree, mem_ctx, &create);
1000         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1001         smb2_util_close(tree, create.out.file.handle);
1002
1003         ZERO_STRUCT(create);
1004         create.in.desired_access = SEC_RIGHTS_FILE_ALL;
1005         create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1006         create.in.create_disposition = NTCREATEX_DISP_CREATE;
1007
1008         files[num_files + 1].name = talloc_asprintf(mem_ctx, "T013-13.txt.2");
1009         create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s", DNAME,
1010                                           files[num_files + 1].name);
1011         status = smb2_create(tree, mem_ctx, &create);
1012         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1013         smb2_util_close(tree, create.out.file.handle);
1014
1015         files[num_files + 2].name = talloc_asprintf(mem_ctx, "T013-13.txt.3");
1016         status = smb2_create_complex_file(tctx, tree, DNAME "\\T013-13.txt.3", &h);
1017         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1018
1019         smb2_util_unlink(tree, DNAME "\\T014-14.txt");
1020         smb2_util_setatr(tree, DNAME "\\T015-15.txt", FILE_ATTRIBUTE_HIDDEN);
1021         smb2_util_setatr(tree, DNAME "\\T016-16.txt", FILE_ATTRIBUTE_NORMAL);
1022         smb2_util_setatr(tree, DNAME "\\T017-17.txt", FILE_ATTRIBUTE_SYSTEM);
1023         smb2_util_setatr(tree, DNAME "\\T018-18.txt", 0);
1024         smb2_util_setatr(tree, DNAME "\\T039-39.txt", FILE_ATTRIBUTE_HIDDEN);
1025         smb2_util_setatr(tree, DNAME "\\T000-0.txt", FILE_ATTRIBUTE_HIDDEN);
1026         sfinfo.generic.level = RAW_SFILEINFO_DISPOSITION_INFORMATION;
1027         sfinfo.generic.in.file.path = DNAME "\\T013-13.txt.3";
1028         sfinfo.disposition_info.in.delete_on_close = 1;
1029         status = smb2_composite_setpathinfo(tree, &sfinfo);
1030         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1031
1032         /* Reset the numfiles to include the new files and start the
1033          * search from the beginning */
1034         num_files = num_files + 2;
1035         f.in.pattern = "*";
1036         f.in.continue_flags = SMB2_CONTINUE_FLAG_RESTART;
1037         result.count = 0;
1038
1039         do {
1040                 status = smb2_find_level(tree, tree, &f, &count, &d);
1041                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
1042                         break;
1043                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1044                 if (!fill_result(&result, d, count, f.in.level,
1045                                  RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO)) {
1046                         ret = false;
1047                         goto done;
1048                 }
1049                 f.in.continue_flags = 0;
1050                 f.in.max_response_size  = 4096;
1051         } while (count != 0);
1052
1053
1054         ret &= check_result(tctx, &result, "t039-39.txt", true, FILE_ATTRIBUTE_HIDDEN);
1055         ret &= check_result(tctx, &result, "t000-0.txt", true, FILE_ATTRIBUTE_HIDDEN);
1056         ret &= check_result(tctx, &result, "t014-14.txt", false, 0);
1057         ret &= check_result(tctx, &result, "t015-15.txt", true, FILE_ATTRIBUTE_HIDDEN);
1058         ret &= check_result(tctx, &result, "t016-16.txt", true, FILE_ATTRIBUTE_NORMAL);
1059         ret &= check_result(tctx, &result, "t017-17.txt", true, FILE_ATTRIBUTE_SYSTEM);
1060         ret &= check_result(tctx, &result, "t018-18.txt", true, FILE_ATTRIBUTE_ARCHIVE);
1061         ret &= check_result(tctx, &result, "t019-19.txt", true, FILE_ATTRIBUTE_ARCHIVE);
1062         ret &= check_result(tctx, &result, "T013-13.txt.2", true, FILE_ATTRIBUTE_ARCHIVE);
1063         ret &= check_result(tctx, &result, "T003-3.txt.2", false, 0);
1064         ret &= check_result(tctx, &result, "T013-13.txt.3", true, FILE_ATTRIBUTE_NORMAL);
1065
1066         if (!ret) {
1067                 for (i=0;i<result.count;i++) {
1068                         torture_warning(tctx, "%s %s (0x%x)\n",
1069                                result.list[i].both_directory_info.name.s,
1070                                attrib_string(tctx,
1071                                result.list[i].both_directory_info.attrib),
1072                                result.list[i].both_directory_info.attrib);
1073                 }
1074         }
1075  done:
1076         smb2_util_close(tree, h);
1077         smb2_deltree(tree, DNAME);
1078         talloc_free(mem_ctx);
1079
1080         return ret;
1081 }
1082
1083 /*
1084    testing if directories always come back sorted
1085 */
1086 static bool test_sorted(struct torture_context *tctx,
1087                         struct smb2_tree *tree)
1088 {
1089         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1090         const int num_files = 700;
1091         int i;
1092         struct file_elem files[700] = {};
1093         bool ret = true;
1094         NTSTATUS status;
1095         struct multiple_result result;
1096         struct smb2_handle h;
1097
1098         torture_comment(tctx, "Testing if directories always come back "
1099            "sorted\n");
1100         status = populate_tree(tctx, mem_ctx, tree, files, num_files, &h);
1101         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1102
1103         ZERO_STRUCT(result);
1104         result.tctx = tctx;
1105
1106         status = multiple_smb2_search(tree, tctx, "*",
1107                                       SMB2_FIND_BOTH_DIRECTORY_INFO,
1108                                       RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
1109                                       SMB2_CONTINUE_FLAG_SINGLE,
1110                                       &result, &h);
1111
1112         torture_assert_int_equal_goto(tctx, result.count, num_files, ret, done,
1113                                       "");
1114
1115         for (i=0;i<num_files-1;i++) {
1116                 const char *name1, *name2;
1117                 name1 = result.list[i].both_directory_info.name.s;
1118                 name2 = result.list[i+1].both_directory_info.name.s;
1119                 if (strcasecmp_m(name1, name2) > 0) {
1120                         torture_comment(tctx, "non-alphabetical order at entry "
1121                             "%d '%s' '%s'\n", i, name1, name2);
1122                         torture_comment(tctx,
1123                             "Server does not produce sorted directory listings"
1124                             "(not an error)\n");
1125                         goto done;
1126                 }
1127         }
1128         talloc_free(result.list);
1129 done:
1130         smb2_util_close(tree, h);
1131         smb2_deltree(tree, DNAME);
1132         talloc_free(mem_ctx);
1133
1134         return ret;
1135 }
1136
1137 /* test the behavior of file_index field in the SMB2_FIND struct */
1138 static bool test_file_index(struct torture_context *tctx,
1139                             struct smb2_tree *tree)
1140 {
1141         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1142         const int num_files = 100;
1143         int resume_index = 4;
1144         int i;
1145         char *fname;
1146         bool ret = true;
1147         NTSTATUS status;
1148         struct multiple_result result;
1149         struct smb2_create create;
1150         struct smb2_find f;
1151         struct smb2_handle h;
1152         union smb_search_data *d;
1153         unsigned count;
1154
1155         smb2_deltree(tree, DNAME);
1156
1157         status = torture_smb2_testdir(tree, DNAME, &h);
1158         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1159
1160         torture_comment(tctx, "Testing the behavior of file_index flag\n");
1161
1162         ZERO_STRUCT(create);
1163         create.in.desired_access = SEC_RIGHTS_FILE_ALL;
1164         create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1165         create.in.create_disposition = NTCREATEX_DISP_CREATE;
1166         for (i = num_files-1; i >= 0; i--) {
1167                 fname = talloc_asprintf(mem_ctx, DNAME "\\file%u.txt", i);
1168                 create.in.fname = fname;
1169                 status = smb2_create(tree, mem_ctx, &create);
1170                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1171                 talloc_free(fname);
1172                 smb2_util_close(tree, create.out.file.handle);
1173         }
1174
1175         ZERO_STRUCT(result);
1176         result.tctx = tctx;
1177
1178         ZERO_STRUCT(f);
1179         f.in.file.handle        = h;
1180         f.in.pattern            = "*";
1181         f.in.continue_flags     = SMB2_CONTINUE_FLAG_SINGLE;
1182         f.in.max_response_size  = 0x1000;
1183         f.in.level              = SMB2_FIND_FULL_DIRECTORY_INFO;
1184
1185         do {
1186                 status = smb2_find_level(tree, tree, &f, &count, &d);
1187                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
1188                         break;
1189                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1190                 if (!fill_result(&result, d, count, f.in.level,
1191                                  RAW_SEARCH_DATA_FULL_DIRECTORY_INFO)) {
1192                         ret = false;
1193                         goto done;
1194                 }
1195         } while(result.count < 10);
1196
1197         if (result.list[0].full_directory_info.file_index == 0) {
1198                 torture_skip_goto(tctx, done,
1199                                 "Talking to a server that doesn't provide a "
1200                                 "file index.\nWindows servers using NTFS do "
1201                                 "not provide a file_index. Skipping test\n");
1202         } else {
1203                 /* We are not talking to a Windows based server.  Windows
1204                  * servers using NTFS do not provide a file_index.  Windows
1205                  * servers using FAT do provide a file index, however in both
1206                  * cases they do not honor a file index on a resume request.
1207                  * See MS-FSCC <62> and MS-SMB2 <54> for more information. */
1208
1209                 /* Set the file_index flag to point to the fifth file from the
1210                  * previous enumeration and try to start the subsequent
1211                  * searches from that point */
1212                 f.in.file_index =
1213                     result.list[resume_index].full_directory_info.file_index;
1214                 f.in.continue_flags = SMB2_CONTINUE_FLAG_INDEX;
1215
1216                 /* get the name of the next expected file */
1217                 fname = talloc_asprintf(mem_ctx, DNAME "\\%s",
1218                         result.list[resume_index].full_directory_info.name.s);
1219
1220                 ZERO_STRUCT(result);
1221                 result.tctx = tctx;
1222                 status = smb2_find_level(tree, tree, &f, &count, &d);
1223                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
1224                         goto done;
1225                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1226                 if (!fill_result(&result, d, count, f.in.level,
1227                                  RAW_SEARCH_DATA_FULL_DIRECTORY_INFO)) {
1228                         ret = false;
1229                         goto done;
1230                 }
1231                 if (strcmp(fname,
1232                         result.list[0].full_directory_info.name.s)) {
1233                         torture_comment(tctx, "Next expected file: %s but the "
1234                             "server returned %s\n", fname,
1235                             result.list[0].full_directory_info.name.s);
1236                         torture_comment(tctx,
1237                                         "Not an error. Resuming using a file "
1238                                         "index is an optional feature of the "
1239                                         "protocol.\n");
1240                         goto done;
1241                 }
1242         }
1243 done:
1244         smb2_util_close(tree, h);
1245         smb2_deltree(tree, DNAME);
1246         talloc_free(mem_ctx);
1247
1248         return ret;
1249 }
1250
1251 /*
1252  * Tests directory enumeration in a directory containing >1000 files with
1253  * names of varying lengths.
1254  */
1255 static bool test_large_files(struct torture_context *tctx,
1256                              struct smb2_tree *tree)
1257 {
1258         TALLOC_CTX *mem_ctx = talloc_new(tctx);
1259         const int num_files = 2000;
1260         int max_len = 200;
1261         /* These should be evenly divisible */
1262         int num_at_len = num_files / max_len;
1263         struct file_elem files[2000] = {};
1264         size_t len = 1;
1265         bool ret = true;
1266         NTSTATUS status;
1267         struct smb2_create create;
1268         struct smb2_find f;
1269         struct smb2_handle h = {{0}};
1270         union smb_search_data *d;
1271         int i, j, file_count = 0;
1272         char **strs = NULL;
1273         unsigned count;
1274
1275         torture_comment(tctx,
1276             "Testing directory enumeration in a directory with >1000 files\n");
1277
1278         smb2_deltree(tree, DNAME);
1279
1280         ZERO_STRUCT(create);
1281         create.in.desired_access = SEC_RIGHTS_DIR_ALL;
1282         create.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1283         create.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
1284         create.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1285                                  NTCREATEX_SHARE_ACCESS_WRITE |
1286                                  NTCREATEX_SHARE_ACCESS_DELETE;
1287         create.in.create_disposition = NTCREATEX_DISP_CREATE;
1288         create.in.fname = DNAME;
1289
1290         status = smb2_create(tree, mem_ctx, &create);
1291         torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1292         h = create.out.file.handle;
1293
1294         ZERO_STRUCT(create);
1295         create.in.desired_access = SEC_RIGHTS_FILE_ALL;
1296         create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1297         create.in.create_disposition = NTCREATEX_DISP_CREATE;
1298
1299         for (i = 0; i < num_files; i++) {
1300                 if (i % num_at_len == 0) {
1301                     strs = generate_unique_strs(mem_ctx, len, num_at_len);
1302                     len++;
1303                 }
1304                 files[i].name = strs[i % num_at_len];
1305                 create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s",
1306                     DNAME, files[i].name);
1307                 status = smb2_create(tree, mem_ctx, &create);
1308                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1309                 smb2_util_close(tree, create.out.file.handle);
1310         }
1311
1312         ZERO_STRUCT(f);
1313         f.in.file.handle        = h;
1314         f.in.pattern            = "*";
1315         f.in.max_response_size  = 0x100;
1316         f.in.level              = SMB2_FIND_BOTH_DIRECTORY_INFO;
1317
1318         do {
1319                 status = smb2_find_level(tree, tree, &f, &count, &d);
1320                 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
1321                         break;
1322                 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1323
1324                 for (i = 0; i < count; i++) {
1325                         bool expected;
1326                         const char *found = d[i].both_directory_info.name.s;
1327
1328                         if (!strcmp(found, ".") || !strcmp(found, ".."))
1329                                 continue;
1330
1331                         expected = false;
1332                         for (j = 0; j < 2000; j++) {
1333                                 if (!strcmp(files[j].name, found)) {
1334                                         files[j].found = true;
1335                                         expected = true;
1336                                         break;
1337                                 }
1338                         }
1339
1340                         if (expected)
1341                                 continue;
1342
1343                         torture_result(tctx, TORTURE_FAIL,
1344                             "(%s): didn't expect %s\n",
1345                             __location__, found);
1346                         ret = false;
1347                         goto done;
1348                 }
1349                 file_count = file_count + i;
1350                 f.in.continue_flags = 0;
1351                 f.in.max_response_size  = 4096;
1352         } while (count != 0);
1353
1354         torture_assert_int_equal_goto(tctx, file_count, num_files + 2, ret,
1355                                       done, "");
1356
1357         for (i = 0; i < num_files; i++) {
1358                 if (files[j].found)
1359                         continue;
1360
1361                 torture_result(tctx, TORTURE_FAIL,
1362                     "(%s): expected to find %s, but didn't\n",
1363                     __location__, files[j].name);
1364                 ret = false;
1365                 goto done;
1366         }
1367 done:
1368         smb2_util_close(tree, h);
1369         smb2_deltree(tree, DNAME);
1370         talloc_free(mem_ctx);
1371
1372         return ret;
1373 }
1374
1375 struct torture_suite *torture_smb2_dir_init(void)
1376 {
1377         struct torture_suite *suite =
1378             torture_suite_create(talloc_autofree_context(), "dir");
1379
1380         torture_suite_add_1smb2_test(suite, "find", test_find);
1381         torture_suite_add_1smb2_test(suite, "fixed", test_fixed);
1382         torture_suite_add_1smb2_test(suite, "one", test_one_file);
1383         torture_suite_add_1smb2_test(suite, "many", test_many_files);
1384         torture_suite_add_1smb2_test(suite, "modify", test_modify_search);
1385         torture_suite_add_1smb2_test(suite, "sorted", test_sorted);
1386         torture_suite_add_1smb2_test(suite, "file-index", test_file_index);
1387         torture_suite_add_1smb2_test(suite, "large-files", test_large_files);
1388         suite->description = talloc_strdup(suite, "SMB2-DIR tests");
1389
1390         return suite;
1391 }