source4/torture/raw/setfileinfo.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RAW_SFILEINFO_* individual test suite
   4    Copyright (C) Andrew Tridgell 2003
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22 #include "system/time.h"
  23 #include "libcli/raw/libcliraw.h"
  24
  25 #define BASEDIR "\\testsfileinfo"
  26
  27 /* basic testing of all RAW_SFILEINFO_* calls
  28    for each call we test that it succeeds, and where possible test
  29    for consistency between the calls.
  30 */
  31 BOOL torture_raw_sfileinfo(void)
  32 {
  33         struct smbcli_state *cli;
  34         BOOL ret = True;
  35         TALLOC_CTX *mem_ctx;
  36         int fnum_saved, d_fnum, fnum2, fnum = -1;
  37         char *fnum_fname;
  38         char *fnum_fname_new;
  39         char *path_fname;
  40         char *path_fname_new;
  41         union smb_fileinfo finfo1, finfo2;
  42         union smb_setfileinfo sfinfo;
  43         NTSTATUS status, status2;
  44         const char *call_name;
  45         time_t basetime = (time(NULL) - 86400) & ~1;
  46         BOOL check_fnum;
  47         int n = time(NULL) % 100;
  48
  49         asprintf(&path_fname, BASEDIR "\\fname_test_%d.txt", n);
  50         asprintf(&path_fname_new, BASEDIR "\\fname_test_new_%d.txt", n);
  51         asprintf(&fnum_fname, BASEDIR "\\fnum_test_%d.txt", n);
  52         asprintf(&fnum_fname_new, BASEDIR "\\fnum_test_new_%d.txt", n);
  53
  54         if (!torture_open_connection(&cli)) {
  55                 return False;
  56         }
  57
  58         mem_ctx = talloc_init("torture_sfileinfo");
  59
  60         if (!torture_setup_dir(cli, BASEDIR)) {
  61                 return False;
  62         }
  63
  64 #define RECREATE_FILE(fname) do { \
  65         if (fnum != -1) smbcli_close(cli->tree, fnum); \
  66         fnum = create_complex_file(cli, mem_ctx, fname); \
  67         if (fnum == -1) { \
  68                 printf("(%s) ERROR: open of %s failed (%s)\n", \
  69                        __location__, fname, smbcli_errstr(cli->tree)); \
  70                 ret = False; \
  71                 goto done; \
  72         }} while (0)
  73
  74 #define RECREATE_BOTH do { \
  75                 RECREATE_FILE(path_fname); \
  76                 smbcli_close(cli->tree, fnum); \
  77                 RECREATE_FILE(fnum_fname); \
  78         } while (0)
  79
  80         RECREATE_BOTH;
  81
  82 #define CHECK_CALL_FNUM(call, rightstatus) do { \
  83         check_fnum = True; \
  84         call_name = #call; \
  85         sfinfo.generic.level = RAW_SFILEINFO_ ## call; \
  86         sfinfo.generic.file.fnum = fnum; \
  87         status = smb_raw_setfileinfo(cli->tree, &sfinfo); \
  88         if (!NT_STATUS_EQUAL(status, rightstatus)) { \
  89                 printf("(%s) %s - %s (should be %s)\n", __location__, #call, \
  90                         nt_errstr(status), nt_errstr(rightstatus)); \
  91                 ret = False; \
  92         } \
  93         finfo1.generic.level = RAW_FILEINFO_ALL_INFO; \
  94         finfo1.generic.in.fnum = fnum; \
  95         status2 = smb_raw_fileinfo(cli->tree, mem_ctx, &finfo1); \
  96         if (!NT_STATUS_IS_OK(status2)) { \
  97                 printf("(%s) %s pathinfo - %s\n", __location__, #call, nt_errstr(status)); \
  98                 ret = False; \
  99         }} while (0)
 100
 101 #define CHECK_CALL_PATH(call, rightstatus) do { \
 102         check_fnum = False; \
 103         call_name = #call; \
 104         sfinfo.generic.level = RAW_SFILEINFO_ ## call; \
 105         sfinfo.generic.file.fname = path_fname; \
 106         status = smb_raw_setpathinfo(cli->tree, &sfinfo); \
 107         if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { \
 108                 sfinfo.generic.file.fname = path_fname_new; \
 109                 status = smb_raw_setpathinfo(cli->tree, &sfinfo); \
 110         } \
 111         if (!NT_STATUS_EQUAL(status, rightstatus)) { \
 112                 printf("(%s) %s - %s (should be %s)\n", __location__, #call, \
 113                         nt_errstr(status), nt_errstr(rightstatus)); \
 114                 ret = False; \
 115         } \
 116         finfo1.generic.level = RAW_FILEINFO_ALL_INFO; \
 117         finfo1.generic.in.fname = path_fname; \
 118         status2 = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo1); \
 119         if (NT_STATUS_EQUAL(status2, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { \
 120                 finfo1.generic.in.fname = path_fname_new; \
 121                 status2 = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo1); \
 122         } \
 123         if (!NT_STATUS_IS_OK(status2)) { \
 124                 printf("(%s) %s pathinfo - %s\n", __location__, #call, nt_errstr(status2)); \
 125                 ret = False; \
 126         }} while (0)
 127
 128 #define CHECK1(call) \
 129         do { if (NT_STATUS_IS_OK(status)) { \
 130                 finfo2.generic.level = RAW_FILEINFO_ ## call; \
 131                 if (check_fnum) { \
 132                         finfo2.generic.in.fnum = fnum; \
 133                         status2 = smb_raw_fileinfo(cli->tree, mem_ctx, &finfo2); \
 134                 } else { \
 135                         finfo2.generic.in.fname = path_fname; \
 136                         status2 = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo2); \
 137                         if (NT_STATUS_EQUAL(status2, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { \
 138                                 finfo2.generic.in.fname = path_fname_new; \
 139                                 status2 = smb_raw_pathinfo(cli->tree, mem_ctx, &finfo2); \
 140                         } \
 141                 } \
 142                 if (!NT_STATUS_IS_OK(status2)) { \
 143                         printf("%s - %s\n", #call, nt_errstr(status2)); \
 144                 } \
 145         }} while (0)
 146
 147 #define CHECK_VALUE(call, stype, field, value) do { \
 148         CHECK1(call); \
 149         if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && finfo2.stype.out.field != value) { \
 150                 printf("(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
 151                        call_name, #stype, #field, \
 152                        (uint_t)value, (uint_t)finfo2.stype.out.field); \
 153                 dump_all_info(mem_ctx, &finfo1); \
 154         }} while (0)
 155
 156 #define CHECK_TIME(call, stype, field, value) do { \
 157         CHECK1(call); \
 158         if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && nt_time_to_unix(finfo2.stype.out.field) != value) { \
 159                 printf("(%s) %s - %s/%s should be 0x%x - 0x%x\n", __location__, \
 160                         call_name, #stype, #field, \
 161                         (uint_t)value, \
 162                         (uint_t)nt_time_to_unix(finfo2.stype.out.field)); \
 163                 printf("\t%s", timestring(mem_ctx, value)); \
 164                 printf("\t%s\n", nt_time_string(mem_ctx, finfo2.stype.out.field)); \
 165                 dump_all_info(mem_ctx, &finfo1); \
 166         }} while (0)
 167
 168 #define CHECK_STR(call, stype, field, value) do { \
 169         CHECK1(call); \
 170         if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(status2) && strcmp(finfo2.stype.out.field, value) != 0) { \
 171                 printf("(%s) %s - %s/%s should be '%s' - '%s'\n", __location__, \
 172                         call_name, #stype, #field, \
 173                         value, \
 174                         finfo2.stype.out.field); \
 175                 dump_all_info(mem_ctx, &finfo1); \
 176         }} while (0)
 177
 178 #define CHECK_STATUS(status, correct) do { \
 179         if (!NT_STATUS_EQUAL(status, correct)) { \
 180                 printf("(%s) Incorrect status %s - should be %s\n", \
 181                        __location__, nt_errstr(status), nt_errstr(correct)); \
 182                 ret = False; \
 183                 goto done; \
 184         }} while (0)
 185
 186
 187         printf("test setattr\n");
 188         sfinfo.setattr.in.attrib = FILE_ATTRIBUTE_READONLY;
 189         sfinfo.setattr.in.write_time = basetime;
 190         CHECK_CALL_PATH(SETATTR, NT_STATUS_OK);
 191         CHECK_VALUE  (ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_READONLY);
 192         CHECK_TIME   (ALL_INFO, all_info, write_time, basetime);
 193
 194         printf("setting to NORMAL doesn't do anything\n");
 195         sfinfo.setattr.in.attrib = FILE_ATTRIBUTE_NORMAL;
 196         sfinfo.setattr.in.write_time = 0;
 197         CHECK_CALL_PATH(SETATTR, NT_STATUS_OK);
 198         CHECK_VALUE(ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_READONLY);
 199         CHECK_TIME (ALL_INFO, all_info, write_time, basetime);
 200
 201         printf("a zero write_time means don't change\n");
 202         sfinfo.setattr.in.attrib = 0;
 203         sfinfo.setattr.in.write_time = 0;
 204         CHECK_CALL_PATH(SETATTR, NT_STATUS_OK);
 205         CHECK_VALUE(ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_NORMAL);
 206         CHECK_TIME (ALL_INFO, all_info, write_time, basetime);
 207
 208         printf("test setattre\n");
 209         sfinfo.setattre.in.create_time = basetime + 20;
 210         sfinfo.setattre.in.access_time = basetime + 30;
 211         sfinfo.setattre.in.write_time  = basetime + 40;
 212         CHECK_CALL_FNUM(SETATTRE, NT_STATUS_OK);
 213         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 20);
 214         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 30);
 215         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 40);
 216
 217         sfinfo.setattre.in.create_time = 0;
 218         sfinfo.setattre.in.access_time = 0;
 219         sfinfo.setattre.in.write_time  = 0;
 220         CHECK_CALL_FNUM(SETATTRE, NT_STATUS_OK);
 221         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 20);
 222         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 30);
 223         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 40);
 224
 225         printf("test standard level\n");
 226         sfinfo.standard.in.create_time = basetime + 100;
 227         sfinfo.standard.in.access_time = basetime + 200;
 228         sfinfo.standard.in.write_time  = basetime + 300;
 229         CHECK_CALL_FNUM(STANDARD, NT_STATUS_OK);
 230         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 100);
 231         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 200);
 232         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 300);
 233
 234         printf("test basic_info level\n");
 235         basetime += 86400;
 236         unix_to_nt_time(&sfinfo.basic_info.in.create_time, basetime + 100);
 237         unix_to_nt_time(&sfinfo.basic_info.in.access_time, basetime + 200);
 238         unix_to_nt_time(&sfinfo.basic_info.in.write_time,  basetime + 300);
 239         unix_to_nt_time(&sfinfo.basic_info.in.change_time, basetime + 400);
 240         sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_READONLY;
 241         CHECK_CALL_FNUM(BASIC_INFO, NT_STATUS_OK);
 242         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 100);
 243         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 200);
 244         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 300);
 245         CHECK_TIME(ALL_INFO, all_info, change_time, basetime + 400);
 246         CHECK_VALUE(ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_READONLY);
 247
 248         printf("a zero time means don't change\n");
 249         unix_to_nt_time(&sfinfo.basic_info.in.create_time, 0);
 250         unix_to_nt_time(&sfinfo.basic_info.in.access_time, 0);
 251         unix_to_nt_time(&sfinfo.basic_info.in.write_time,  0);
 252         unix_to_nt_time(&sfinfo.basic_info.in.change_time, 0);
 253         sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_NORMAL;
 254         CHECK_CALL_FNUM(BASIC_INFO, NT_STATUS_OK);
 255         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 100);
 256         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 200);
 257         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 300);
 258         CHECK_TIME(ALL_INFO, all_info, change_time, basetime + 400);
 259         CHECK_VALUE(ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_NORMAL);
 260
 261         printf("test basic_information level\n");
 262         basetime += 86400;
 263         unix_to_nt_time(&sfinfo.basic_info.in.create_time, basetime + 100);
 264         unix_to_nt_time(&sfinfo.basic_info.in.access_time, basetime + 200);
 265         unix_to_nt_time(&sfinfo.basic_info.in.write_time,  basetime + 300);
 266         unix_to_nt_time(&sfinfo.basic_info.in.change_time, basetime + 400);
 267         sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_READONLY;
 268         CHECK_CALL_FNUM(BASIC_INFORMATION, NT_STATUS_OK);
 269         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 100);
 270         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 200);
 271         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 300);
 272         CHECK_TIME(ALL_INFO, all_info, change_time, basetime + 400);
 273         CHECK_VALUE(ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_READONLY);
 274
 275         CHECK_CALL_PATH(BASIC_INFORMATION, NT_STATUS_OK);
 276         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 100);
 277         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 200);
 278         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 300);
 279         CHECK_TIME(ALL_INFO, all_info, change_time, basetime + 400);
 280         CHECK_VALUE(ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_READONLY);
 281
 282         printf("a zero time means don't change\n");
 283         unix_to_nt_time(&sfinfo.basic_info.in.create_time, 0);
 284         unix_to_nt_time(&sfinfo.basic_info.in.access_time, 0);
 285         unix_to_nt_time(&sfinfo.basic_info.in.write_time,  0);
 286         unix_to_nt_time(&sfinfo.basic_info.in.change_time, 0);
 287         sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_NORMAL;
 288         CHECK_CALL_FNUM(BASIC_INFORMATION, NT_STATUS_OK);
 289         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 100);
 290         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 200);
 291         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 300);
 292         CHECK_TIME(ALL_INFO, all_info, change_time, basetime + 400);
 293         CHECK_VALUE(ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_NORMAL);
 294
 295         CHECK_CALL_PATH(BASIC_INFORMATION, NT_STATUS_OK);
 296         CHECK_TIME(ALL_INFO, all_info, create_time, basetime + 100);
 297         CHECK_TIME(ALL_INFO, all_info, access_time, basetime + 200);
 298         CHECK_TIME(ALL_INFO, all_info, write_time,  basetime + 300);
 299
 300         /* interesting - w2k3 leaves change_time as current time for 0 change time
 301            in setpathinfo
 302           CHECK_TIME(ALL_INFO, all_info, change_time, basetime + 400);
 303         */
 304         CHECK_VALUE(ALL_INFO, all_info, attrib,     FILE_ATTRIBUTE_NORMAL);
 305
 306         printf("test disposition_info level\n");
 307         sfinfo.disposition_info.in.delete_on_close = 1;
 308         CHECK_CALL_FNUM(DISPOSITION_INFO, NT_STATUS_OK);
 309         CHECK_VALUE(ALL_INFO, all_info, delete_pending, 1);
 310         CHECK_VALUE(ALL_INFO, all_info, nlink, 0);
 311
 312         sfinfo.disposition_info.in.delete_on_close = 0;
 313         CHECK_CALL_FNUM(DISPOSITION_INFO, NT_STATUS_OK);
 314         CHECK_VALUE(ALL_INFO, all_info, delete_pending, 0);
 315         CHECK_VALUE(ALL_INFO, all_info, nlink, 1);
 316
 317         printf("test disposition_information level\n");
 318         sfinfo.disposition_info.in.delete_on_close = 1;
 319         CHECK_CALL_FNUM(DISPOSITION_INFORMATION, NT_STATUS_OK);
 320         CHECK_VALUE(ALL_INFO, all_info, delete_pending, 1);
 321         CHECK_VALUE(ALL_INFO, all_info, nlink, 0);
 322
 323         /* this would delete the file! */
 324         /*
 325           CHECK_CALL_PATH(DISPOSITION_INFORMATION, NT_STATUS_OK);
 326           CHECK_VALUE(ALL_INFO, all_info, delete_pending, 1);
 327           CHECK_VALUE(ALL_INFO, all_info, nlink, 0);
 328         */
 329
 330         sfinfo.disposition_info.in.delete_on_close = 0;
 331         CHECK_CALL_FNUM(DISPOSITION_INFORMATION, NT_STATUS_OK);
 332         CHECK_VALUE(ALL_INFO, all_info, delete_pending, 0);
 333         CHECK_VALUE(ALL_INFO, all_info, nlink, 1);
 334
 335         CHECK_CALL_PATH(DISPOSITION_INFORMATION, NT_STATUS_OK);
 336         CHECK_VALUE(ALL_INFO, all_info, delete_pending, 0);
 337         CHECK_VALUE(ALL_INFO, all_info, nlink, 1);
 338
 339         printf("test allocation_info level\n");
 340         sfinfo.allocation_info.in.alloc_size = 0;
 341         CHECK_CALL_FNUM(ALLOCATION_INFO, NT_STATUS_OK);
 342         CHECK_VALUE(ALL_INFO, all_info, size, 0);
 343         CHECK_VALUE(ALL_INFO, all_info, alloc_size, 0);
 344
 345         sfinfo.allocation_info.in.alloc_size = 4096;
 346         CHECK_CALL_FNUM(ALLOCATION_INFO, NT_STATUS_OK);
 347         CHECK_VALUE(ALL_INFO, all_info, alloc_size, 4096);
 348         CHECK_VALUE(ALL_INFO, all_info, size, 0);
 349
 350         RECREATE_BOTH;
 351         sfinfo.allocation_info.in.alloc_size = 0;
 352         CHECK_CALL_FNUM(ALLOCATION_INFORMATION, NT_STATUS_OK);
 353         CHECK_VALUE(ALL_INFO, all_info, size, 0);
 354         CHECK_VALUE(ALL_INFO, all_info, alloc_size, 0);
 355
 356         CHECK_CALL_PATH(ALLOCATION_INFORMATION, NT_STATUS_OK);
 357         CHECK_VALUE(ALL_INFO, all_info, size, 0);
 358         CHECK_VALUE(ALL_INFO, all_info, alloc_size, 0);
 359
 360         sfinfo.allocation_info.in.alloc_size = 4096;
 361         CHECK_CALL_FNUM(ALLOCATION_INFORMATION, NT_STATUS_OK);
 362         CHECK_VALUE(ALL_INFO, all_info, alloc_size, 4096);
 363         CHECK_VALUE(ALL_INFO, all_info, size, 0);
 364
 365         /* setting the allocation size up via setpathinfo seems
 366            to be broken in w2k3 */
 367         CHECK_CALL_PATH(ALLOCATION_INFORMATION, NT_STATUS_OK);
 368         CHECK_VALUE(ALL_INFO, all_info, alloc_size, 0);
 369         CHECK_VALUE(ALL_INFO, all_info, size, 0);
 370
 371         printf("test end_of_file_info level\n");
 372         sfinfo.end_of_file_info.in.size = 37;
 373         CHECK_CALL_FNUM(END_OF_FILE_INFO, NT_STATUS_OK);
 374         CHECK_VALUE(ALL_INFO, all_info, size, 37);
 375
 376         sfinfo.end_of_file_info.in.size = 7;
 377         CHECK_CALL_FNUM(END_OF_FILE_INFO, NT_STATUS_OK);
 378         CHECK_VALUE(ALL_INFO, all_info, size, 7);
 379
 380         sfinfo.end_of_file_info.in.size = 37;
 381         CHECK_CALL_FNUM(END_OF_FILE_INFORMATION, NT_STATUS_OK);
 382         CHECK_VALUE(ALL_INFO, all_info, size, 37);
 383
 384         CHECK_CALL_PATH(END_OF_FILE_INFORMATION, NT_STATUS_OK);
 385         CHECK_VALUE(ALL_INFO, all_info, size, 37);
 386
 387         sfinfo.end_of_file_info.in.size = 7;
 388         CHECK_CALL_FNUM(END_OF_FILE_INFORMATION, NT_STATUS_OK);
 389         CHECK_VALUE(ALL_INFO, all_info, size, 7);
 390
 391         CHECK_CALL_PATH(END_OF_FILE_INFORMATION, NT_STATUS_OK);
 392         CHECK_VALUE(ALL_INFO, all_info, size, 7);
 393
 394         printf("test position_information level\n");
 395         sfinfo.position_information.in.position = 123456;
 396         CHECK_CALL_FNUM(POSITION_INFORMATION, NT_STATUS_OK);
 397         CHECK_VALUE(POSITION_INFORMATION, position_information, position, 123456);
 398
 399         CHECK_CALL_PATH(POSITION_INFORMATION, NT_STATUS_OK);
 400         CHECK_VALUE(POSITION_INFORMATION, position_information, position, 0);
 401
 402         printf("test mode_information level\n");
 403         sfinfo.mode_information.in.mode = 2;
 404         CHECK_CALL_FNUM(MODE_INFORMATION, NT_STATUS_OK);
 405         CHECK_VALUE(MODE_INFORMATION, mode_information, mode, 2);
 406
 407         CHECK_CALL_PATH(MODE_INFORMATION, NT_STATUS_OK);
 408         CHECK_VALUE(MODE_INFORMATION, mode_information, mode, 0);
 409
 410         sfinfo.mode_information.in.mode = 1;
 411         CHECK_CALL_FNUM(MODE_INFORMATION, NT_STATUS_INVALID_PARAMETER);
 412         CHECK_CALL_PATH(MODE_INFORMATION, NT_STATUS_INVALID_PARAMETER);
 413
 414         sfinfo.mode_information.in.mode = 0;
 415         CHECK_CALL_FNUM(MODE_INFORMATION, NT_STATUS_OK);
 416         CHECK_VALUE(MODE_INFORMATION, mode_information, mode, 0);
 417
 418         CHECK_CALL_PATH(MODE_INFORMATION, NT_STATUS_OK);
 419         CHECK_VALUE(MODE_INFORMATION, mode_information, mode, 0);
 420 #if 1
 421         printf("finally the rename_information level\n");
 422         smbcli_close(cli->tree, create_complex_file(cli, mem_ctx, fnum_fname_new));
 423         smbcli_close(cli->tree, create_complex_file(cli, mem_ctx, path_fname_new));
 424
 425         sfinfo.rename_information.in.overwrite = 0;
 426         sfinfo.rename_information.in.root_fid  = 0;
 427         sfinfo.rename_information.in.new_name  = fnum_fname_new+strlen(BASEDIR)+1;
 428         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OBJECT_NAME_COLLISION);
 429
 430         sfinfo.rename_information.in.new_name  = path_fname_new+strlen(BASEDIR)+1;
 431         CHECK_CALL_PATH(RENAME_INFORMATION, NT_STATUS_OBJECT_NAME_COLLISION);
 432
 433         sfinfo.rename_information.in.new_name  = fnum_fname_new;
 434         sfinfo.rename_information.in.overwrite = 1;
 435         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_NOT_SUPPORTED);
 436
 437         sfinfo.rename_information.in.new_name  = fnum_fname_new+strlen(BASEDIR)+1;
 438         sfinfo.rename_information.in.overwrite = 1;
 439         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
 440         CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname_new);
 441
 442         printf("Trying rename with dest file open\n");
 443         fnum2 = create_complex_file(cli, mem_ctx, fnum_fname);
 444         sfinfo.rename_information.in.new_name  = fnum_fname+strlen(BASEDIR)+1;
 445         sfinfo.rename_information.in.overwrite = 1;
 446         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_ACCESS_DENIED);
 447         CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname_new);
 448
 449         fnum_saved = fnum;
 450         fnum = fnum2;
 451         sfinfo.disposition_info.in.delete_on_close = 1;
 452         CHECK_CALL_FNUM(DISPOSITION_INFO, NT_STATUS_OK);
 453         fnum = fnum_saved;
 454
 455         printf("Trying rename with dest file open and delete_on_close\n");
 456         sfinfo.rename_information.in.new_name  = fnum_fname+strlen(BASEDIR)+1;
 457         sfinfo.rename_information.in.overwrite = 1;
 458         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_ACCESS_DENIED);
 459
 460         smbcli_close(cli->tree, fnum2);
 461         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
 462         CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname);
 463
 464         printf("Trying rename with source file open twice\n");
 465         sfinfo.rename_information.in.new_name  = fnum_fname+strlen(BASEDIR)+1;
 466         sfinfo.rename_information.in.overwrite = 1;
 467         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
 468         CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname);
 469
 470         fnum2 = create_complex_file(cli, mem_ctx, fnum_fname);
 471         sfinfo.rename_information.in.new_name  = fnum_fname_new+strlen(BASEDIR)+1;
 472         sfinfo.rename_information.in.overwrite = 0;
 473         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
 474         CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname_new);
 475         smbcli_close(cli->tree, fnum2);
 476
 477         sfinfo.rename_information.in.new_name  = fnum_fname+strlen(BASEDIR)+1;
 478         sfinfo.rename_information.in.overwrite = 0;
 479         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
 480         CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname);
 481
 482         sfinfo.rename_information.in.new_name  = path_fname_new+strlen(BASEDIR)+1;
 483         sfinfo.rename_information.in.overwrite = 1;
 484         CHECK_CALL_PATH(RENAME_INFORMATION, NT_STATUS_OK);
 485         CHECK_STR(NAME_INFO, name_info, fname.s, path_fname_new);
 486
 487         sfinfo.rename_information.in.new_name  = fnum_fname+strlen(BASEDIR)+1;
 488         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_OK);
 489         CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname);
 490
 491         sfinfo.rename_information.in.new_name  = path_fname+strlen(BASEDIR)+1;
 492         CHECK_CALL_PATH(RENAME_INFORMATION, NT_STATUS_OK);
 493         CHECK_STR(NAME_INFO, name_info, fname.s, path_fname);
 494
 495         printf("Trying rename with a root fid\n");
 496         status = create_directory_handle(cli->tree, BASEDIR, &d_fnum);
 497         CHECK_STATUS(status, NT_STATUS_OK);
 498         sfinfo.rename_information.in.new_name  = fnum_fname_new+strlen(BASEDIR)+1;
 499         sfinfo.rename_information.in.root_fid = d_fnum;
 500         CHECK_CALL_FNUM(RENAME_INFORMATION, NT_STATUS_INVALID_PARAMETER);
 501         CHECK_STR(NAME_INFO, name_info, fname.s, fnum_fname);
 502 #endif
 503
 504 #if 0
 505         printf("test unix_basic level\n");
 506         CHECK_CALL_FNUM(UNIX_BASIC, NT_STATUS_OK);
 507         CHECK_CALL_PATH(UNIX_BASIC, NT_STATUS_OK);
 508
 509         printf("test unix_link level\n");
 510         CHECK_CALL_FNUM(UNIX_LINK, NT_STATUS_OK);
 511         CHECK_CALL_PATH(UNIX_LINK, NT_STATUS_OK);
 512 #endif
 513
 514 done:
 515         smb_raw_exit(cli->session);
 516         smbcli_close(cli->tree, fnum);
 517         if (NT_STATUS_IS_ERR(smbcli_unlink(cli->tree, fnum_fname))) {
 518                 printf("Failed to delete %s - %s\n", fnum_fname, smbcli_errstr(cli->tree));
 519         }
 520         if (NT_STATUS_IS_ERR(smbcli_unlink(cli->tree, path_fname))) {
 521                 printf("Failed to delete %s - %s\n", path_fname, smbcli_errstr(cli->tree));
 522         }
 523
 524         torture_close_connection(cli);
 525         talloc_free(mem_ctx);
 526         return ret;
 527 }
 528
 529
 530 /*
 531    look for the w2k3 setpathinfo STANDARD bug
 532 */
 533 BOOL torture_raw_sfileinfo_bug(void)
 534 {
 535         struct smbcli_state *cli;
 536         TALLOC_CTX *mem_ctx;
 537         const char *fname = "\\bug3.txt";
 538         union smb_setfileinfo sfinfo;
 539         NTSTATUS status;
 540         int fnum;
 541
 542         if (!lp_parm_bool(-1, "torture", "dangerous", False)) {
 543                 printf("torture_raw_sfileinfo_bug disabled - enable dangerous tests to use\n");
 544                 return True;
 545         }
 546
 547         if (!torture_open_connection(&cli)) {
 548                 return False;
 549         }
 550
 551         mem_ctx = talloc_init("torture_sfileinfo");
 552
 553         fnum = create_complex_file(cli, mem_ctx, fname);
 554         smbcli_close(cli->tree, fnum);
 555
 556         sfinfo.generic.level = RAW_SFILEINFO_STANDARD;
 557         sfinfo.generic.file.fname = fname;
 558
 559         sfinfo.standard.in.create_time = 0;
 560         sfinfo.standard.in.access_time = 0;
 561         sfinfo.standard.in.write_time  = 0;
 562
 563         status = smb_raw_setpathinfo(cli->tree, &sfinfo);
 564         printf("%s - %s\n", fname, nt_errstr(status));
 565
 566         printf("now try and delete %s\n", fname);
 567
 568         return True;
 569 }